On 2-4-2014 17:15, Michael Kay wrote:
The rules I am after is, in this order:
1) numerical predicates lower than zero never select anything
More precisely, the only numerical predicates that can select anything are
positive integers.
Yes, I should've said "lower than or equal to". But "positive integers"
is better, because it also emphasizes that a predicate such as [3.14]
will never select anything.
2) a sibling numerical predicate that is one is always redundant in a
pattern
"Sibling numerical predicate" isn't one of your defined terms. I assume you
mean a predicate of [1] preceded by another numerical predicate.
I thought it would be clear from the definitions of sibling predicates
and numerical predicates. But indeed, I meant a numerical predicate that
is also a sibling predicate, that has the effective static numeric value
of 1 (the integer, not the string), such like
[xs:integer(1.2)]
[number("1")]
[1]
[(1 to 20)[1]]
3) a sibling predicate that is a sibling of a numeric predicate that is
higher than one never selects anything
Then, to make it tricky, what happens here, if the applied set is //foo?
(foo[2])[3]
This never selects anything, but (.//foo[2])[3] does. The difference is that
foo[2] always selects 0 or 1 elements, whereas .//foo[2] may select more than
one.
I should have emphasized that I meant patterns, not expressions.
(.//foo[2])[3] is not allowed in a pattern. In XSLT 3.0, you can do
.[(.//foo[2])[3]] though, which gets interesting, but is not the same.
Let me try a few variants, for the excercise, and see if the same rules
still apply:
Selects of each second descendant element foo the second item
<xsl:apply-templates select="(//foo[2])[2]" />
Matches never, as foo[2] is always ever one node
<xsl:template match="(foo[2])[2]" />
Matches never, because of the singleton focus on the current node
<xsl:template match="(//foo[2])[2]" />
XSLT 3.0 syntax, matches if current node has at least two second foo
descendants (uncanningly unrelated to the select-expression (//foo[2])[2]).
<xsl:template match=".[(.//foo[2])[2]]" />
Note that the above is not equal to this:
<xsl:template match=".[(//foo[2])[2]]" />
The matching pattern that selects the same node as the expression
(//foo[2])[2] is, I think, node()[2]/foo[2], assuming the
apply-templates is done on a selection that includes these foo elements.
Hmm, not quite. Because the pattern does not have a relation to the
context item that was used during evaluation of the expression, but it
gets close.
Bottom line is, I think, that creating multiple sibling numerical
predicates is (usually) counter-productive and won't match anything when
used in a pattern (unless the number is "1", in which case it is also
redundant).
More generally, an expression using a numeric predicate returns a value with
cardinality 0:1, and applying a numeric predicate to a value with cardinality
0:1 is pointless.
Yes, that's a lot clearer and more generally applicable.
--~------------------------------------------------------------------
XSL-List info and archive: http://www.mulberrytech.com/xsl/xsl-list
To unsubscribe, go to: http://lists.mulberrytech.com/xsl-list/
or e-mail: <mailto:xsl-list-unsubscribe(_at_)lists(_dot_)mulberrytech(_dot_)com>
--~--