Rounding Modes
Rounding Mode	Meaning
`'floor'`	Returns `L`.
`'ceiling'`	Returns `U`.
`'toward-zero'`	Returns `L` if `$value` is positive, otherwise `U`.
`'away-from-zero'`	Returns `U` if `$value` is positive, otherwise `L`
`'half-to-floor'`	Returns `N`, unless midway, in which case `L`.
`'half-to-ceiling'`	Returns `N`, unless midway, in which case `U`. This is the default.
`'half-toward-zero'`	Returns `N`, unless midway, in which case it returns `L` if `$value` is positive, otherwise `U`.
`'half-away-from-zero'`	Returns `N`, unless midway, in which case it returns `U` if `$value` is positive, otherwise `L`.
`'half-to-even'`	Returns `N`, unless midway, in which case it returns whichever of `L` and `U` has a last significant digit that is even.

tzname	Offset
UT, UTC, GMT	00:00
EST	-05:00
EDT	-04:00
CST	-06:00
CDT	-05:00
MST	-07:00
MDT	-06:00
PST	-08:00
PDT	-07:00

")//div => innermost() =!> string(@id)]]> "c" innermost()]]> [1,2], [3,4], [5,6], [7,8]

Generalized to work with JNodes as well as XNodes.

deterministic context-independent focus-independent special-streaming-rules

Returns every GNode within the input sequence that has no ancestor that is itself a member of the input sequence; the nodes are returned in document order with duplicates eliminated.

The effect of the function call fn:outermost($nodes) is defined to be equivalent to the result of the expression:

$nodes[not(ancestor::gnode() intersect $nodes)]/.

That is, the function takes as input a sequence of GNodes, and returns every GNode within the sequence that does not have another GNode within the sequence as an ancestor; the GNodes are returned in document order with duplicates eliminated.

The formulation $nodes except $nodes/descendant::node() might appear to be simpler, but does not correctly account for attribute nodes, as these are not descendants of their parent element.

The motivation for the function was based on XSLT streaming use cases. There are cases where the streaming rules allow the construct outermost(//section) but do not allow //section; the function can therefore be useful in cases where it is known that sections will not be nested, as well as cases where the application actually wishes to process all sections except those that are nested within another.

If the supplied argument includes a map or an array, it will automatically be coerced to a JNode.

")//div => outermost() => string(@id)]]> "a" outermost() => array:size()]]> 3

Generalized to work with JNodes as well as XNodes.

deterministic context-dependent focus-independent deterministic context-dependent focus-independent

Returns a sequence of positive integers giving the positions within the sequence $input of items that are equal to $target.

The function returns a sequence of positive integers giving the positions within the sequence $input of items that are equal to $target.

The collation used by this function is determined according to the rules in . This collation is used when string comparison is required.

The items in the sequence $input are compared with $target under the rules for the eq operator. Values of type xs:untypedAtomic are compared as if they were of type xs:string. Values that cannot be compared, because the eq operator is not defined for their types, are considered to be distinct. If an item compares equal, then the position of that item in the sequence $input is included in the result.

The first item in a sequence is at position 1, not position 0.

The result sequence is in ascending numeric order.

If $input is the empty sequence, or if no item in $input matches $target, then the function returns the empty sequence.

No error occurs if non-comparable values are encountered. So when comparing two atomic items, the effective boolean value of fn:index-of($a, $b) is true if $a and $b are equal, false if they are not equal or not comparable.

index-of((10, 20, 30, 40), 35) () index-of((10, 20, 30, 30, 20, 10), 20) 2, 5 index-of( ("a", "sport", "and", "a", "pastime"), "a" ) 1, 4 index-of( ("a", "b", "c"), "B", "http://www.w3.org/2005/xpath-functions/collation/html-ascii-case-insensitive" ) 2 index-of(current-date(), 23) () index-of([ 1, [ 5, 6 ], [ 6, 7 ] ], 6) 3, 4 The array is atomized to a sequence of five integers

If @a is an attribute of type xs:NMTOKENS whose string value is "red green blue", and whose typed value is therefore ("red", "green", "blue"), then fn:index-of(@a, "blue") returns 3. This is because the function calling mechanism atomizes the attribute node to produce a sequence of three xs:NMTOKEN values.

deterministic context-independent focus-independent

Returns true if the argument is the empty sequence.

If $input is the empty sequence, the function returns true; otherwise, the function returns false.

count($input) eq 0 empty((1, 2, 3)[10]) true() empty(remove(("hello", "world"), 1)) false() empty([]) false() empty({}) false() empty("") false()

Assuming $break is an element with no children:

let $break := return empty($break)

The result is false().

deterministic context-dependent focus-dependent deterministic context-independent focus-independent

Returns the supplied GNode together with its siblings, in document order.

If the $node argument is omitted, it defaults to the context value (.).

If the value of $node is an empty sequence, the function returns an empty sequence.

If $node is a child of some parent GNode P, the function returns all the children of P (including $node), in document order, as determined by the value of $node/child::gnode().

Otherwise (specifically, if $node is parentless, or if it is an attribute or namespace node), the function returns $node.

if ($node intersect $node/parent::node()/child::node()) then $node/parent::node()/child::node() else $node

The following errors may be raised when $node is omitted:

If the context value is absent, type error

If the context value is not an instance of the sequence type node()?, type error .

The result of siblings($n) (except in error cases) is the same as the result of $n/(preceding-sibling::node() | following-sibling-or-self::node()). It is also the same as $n/(preceding-sibling-or-self::node() | following-sibling::node())

As with names such as parent and child, the word sibling used here as a technical term is not a precise match to its use in describing human family relationships, but is chosen for convenience.

Atext]]> siblings($e//a) ! string() "A", "text", "3.14159" siblings($e//processing-instruction('pi')) ! string() "A", "text", "3.14159" siblings($e//@x) ! string() "X"

New in 4.0

deterministic context-independent focus-independent

Returns true if the argument is a non-empty sequence.

If $input is a non-empty sequence, the function returns true; otherwise, the function returns false.

count($input) gt 0 exists(remove(("hello"), 1)) false() exists(remove(("hello", "world"), 1)) true() exists([]) true() exists({}) true() exists("") true()

Assuming $break is an element with no children:

let $break := return exists($break)

The result is true().

deterministic context-dependent focus-independent deterministic context-dependent focus-independent

Returns the values that appear in a sequence, with duplicates eliminated.

The function returns the sequence that results from removing from $values all but one of a set of values that are considered equal to one another. Two items $J and $K in the input sequence (after atomization, as required by the function signature) are considered equal if fn:deep-equal($J, $K, $coll) is true, where $coll is the collation selected according to the rules in . This collation is used when string comparison is required.

The ordering of the result is as follows:

For any set of values that compare equal, the one that is returned is the one that appears first in $values.

The items that are returned appear in the order of their first appearance within $values.

filter($values, fn($item, $pos) { empty( filter( subsequence($values, 1, $pos - 1), deep-equal(?, $item, $collation) ) ) } )

If $values is the empty sequence, the function returns the empty sequence.

Values of type xs:untypedAtomic are compared as if they were of type xs:string.

Values that cannot be compared, because the eq operator is not defined for their types, are considered to be distinct.

For xs:float and xs:double values, positive zero is equal to negative zero and, although NaN does not equal itself, if $values contains multiple NaN values a single NaN is returned.

If xs:dateTime, xs:date or xs:time values do not have a timezone, they are considered to have the implicit timezone provided by the dynamic context for the purpose of comparison. Note that xs:dateTime, xs:date or xs:time values can compare equal even if their timezones are different.

distinct-values((1, 2.0, 3, 2)) 1, 2.0, 3 distinct-values(( xs:untypedAtomic("cherry"), xs:untypedAtomic("plum"), xs:untypedAtomic("plum") )) xs:untypedAtomic("cherry"), xs:untypedAtomic("plum")

Changed in 4.0 to use transitive equality comparisons for numeric values.

The order of results is now prescribed; it was previously implementation-dependent.

Atomic items of types xs:hexBinary and xs:base64Binary are now mutually comparable. In rare cases, where an application uses both types and assumes they are distinct, this can represent a backwards incompatibility.

deterministic context-dependent focus-independent deterministic context-dependent focus-independent

Returns the values that appear in a sequence more than once.

The items of $values are compared against each other, according to the rules of fn:distinct-values and with $coll as the collation selected according to the rules in .

From each resulting set of values that are considered equal, one value will be returned if the set contains more than one value.

Specifically, the function returns those items in $values that are equal (under this definition) to exactly one item appearing earlier in the sequence

This means that the ordering of the result is as follows:

For any set of values that compare equal, the one that is returned is the one that appears second in $values.

The items that are returned appear in the order of their second appearance within $values.

filter( $values, fn($item, $pos) { count( filter( subsequence($values, 1, $pos - 1), deep-equal(?, $item, $collation) ) ) eq 1 } ) duplicate-values((1, 2, 3, 1.0, 1e0)) 1.0 duplicate-values(1 to 100) () 1, '2', 2))]]> xs:untypedAtomic("1") The string "1" and the untyped value of the element node are considered equal, whereas the string "2" and the integer are considered unequal.

Raise an error for duplicates in an ID sequence:

let $ids := duplicate-values(//@id) where exists($ids) return error((), 'Duplicate IDs found: ' || string-join($ids, ', '))

New in 4.0

deterministic context-independent focus-independent

Returns its argument value.

The function returns $input.

$input

The function is useful in contexts where a function must be supplied, but no processing is required.

identity(0) 0 identity(1 to 10) 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ') ! (identity(/) is /)]]> true() If the argument is a node, the function returns the identical node, not a copy identity(()) ()

New in 4.0

deterministic context-independent focus-independent

Returns a sequence constructed by inserting an item or a sequence of items at a given position within an existing sequence.

The value returned by the function consists of all items of $input whose 1-based position is less than $position, followed by all items of $insert, followed by the remaining elements of $input, in that order.

filter($input, fn($item, $pos) { $pos lt $position }), $insert, filter($input, fn($item, $pos) { $pos ge $position })

If $input is the empty sequence, $insert is returned. If $insert is the empty sequence, $input is returned.

If $position is less than one (1), the first position, the effective value of $position is one (1). If $position is greater than the number of items in $input, then the effective value of $position is equal to the number of items in $input plus 1.

The value of $input is not affected by the sequence construction.

insert-before($abc, 0, "z") "z", "a", "b", "c" insert-before($abc, 1, "z") "z", "a", "b", "c" insert-before($abc, 2, "z") "a", "z", "b", "c" insert-before($abc, 3, "z") "a", "b", "z", "c" insert-before($abc, 4, "z") "a", "b", "c", "z" deterministic context-independent focus-independent

Returns a new sequence containing all the items of $input except those at specified positions.

The function returns a sequence consisting of all items of $input whose 1-based position is not equal to any of the integers in $positions.

filter($input, fn($item, $pos) { not($pos = $positions) })

Any integer in $positions that is less than 1 or greater than the number of items in $input is effectively ignored.

If $input is the empty sequence, the empty sequence is returned.

If $positions is an empty sequence, the input sequence $input is returned unchanged.

remove($abc, 0) "a", "b", "c" remove($abc, 1) "b", "c" remove($abc, 6) "a", "b", "c" remove((), 3) () remove($abc, 2 to 3) "a" remove($abc, ()) "a", "b", "c"

The second argument can now be a sequence of integers.

deterministic context-independent focus-independent

Returns the first item in a sequence.

The function returns the first item in $input; if $input is empty, it returns an empty sequence.

filter($input, fn($item, $pos) { $pos eq 1 }) head(1 to 5) 1 head(("a", "b", "c")) "a" head(()) () head([ 1, 2, 3 ]) [ 1, 2, 3 ] deterministic context-independent focus-independent

Returns all but the first item in a sequence.

The function all items in $input except the first, retaining order.

filter($input, fn($item, $pos) { $pos gt 1 })

If $input is the empty sequence, or a sequence containing a single item, then the empty sequence is returned.

tail(1 to 5) 2, 3, 4, 5 tail(("a", "b", "c")) "b", "c" tail("a") () tail(()) () tail([ 1, 2, 3 ]) () deterministic context-independent focus-independent

Returns all but the last item in a sequence.

The function returns all items in $input except the last, retaining order.

filter($input, fn($item, $pos) { $pos ne count($input) })

If $input is the empty sequence, or a sequence containing a single item, then the empty sequence is returned.

trunk(1 to 5) 1, 2, 3, 4 trunk(("a", "b", "c")) "a", "b" trunk("a") () trunk(()) () trunk([ 1, 2, 3 ]) ()

New in 4.0

deterministic context-independent focus-independent

Produces multiple copies of a sequence.

The function returns the value of (1 to $count) ! $input.

for-each(1 to $count, fn($item, $pos) { $input })

If $input is the empty sequence, the empty sequence is returned.

The $count argument is declared as xs:nonNegativeInteger, which means that a type error occurs if it is called with a negative value.

If the input sequence contains nodes, these are not copied: instead, the result sequence contains multiple references to the same node. So, for example, fn:count(fn:replicate(/, 6)|()) returns 1, because the fn:replicate call creates duplicates, and the union operation eliminates them.

replicate(0, 6) 0, 0, 0, 0, 0, 0 replicate(("A", "B", "C"), 3) "A", "B", "C", "A", "B", "C", "A", "B", "C" replicate((), 5) () replicate(("A", "B", "C"), 1) "A", "B", "C" replicate(("A", "B", "C"), 0) ()

New in 4.0

deterministic context-independent focus-independent

Inserts a separator between adjacent items in a sequence.

The function inserts a separator between adjacent items in a sequence. The input is returned unchanged if $separator is the empty sequence or if $input contains less than two items.

for-each($input, fn($item, $pos) { if ($pos gt 1) { $separator }, $item }) sequence-join(1 to 5, "|") 1, "|", 2, "|" , 3, "|", 4, "|", 5 sequence-join((), "|") () sequence-join("A", "|") "A" sequence-join(1 to 3, ("⅓", "⅔")) 1, "⅓", "⅔", 2, "⅓", "⅔", 3

Insert an empty hr element between adjacent paragraphs:

)]]>

New in 4.0

deterministic context-independent focus-independent

Returns the last item in a sequence.

The function returns the value of the expression $input[last()]

filter($input, fn($item, $pos) { $pos eq count($input) })

If $input is the empty sequence the empty sequence is returned.

foot(1 to 5) 5 foot(()) ()

New in 4.0

deterministic context-independent focus-independent special-streaming-rules

Reverses the order of items in a sequence.

The function returns a sequence containing the items in $input in reverse order.

fold-left($input, (), fn($result, $item) { $item, $result })

If $input is the empty sequence, the empty sequence is returned.

reverse($abc) "c", "b", "a" reverse(("hello")) "hello" reverse(()) () reverse([ 1, 2, 3 ]) [ 1, 2, 3 ] The input is a sequence containing a single item (the array) reverse(([ 1, 2, 3 ], [ 4, 5, 6 ])) [ 4, 5, 6 ], [ 1, 2, 3 ] deterministic context-independent focus-independent

Returns the contiguous sequence of items in $input beginning at the position indicated by $start and continuing for the number of items indicated by $length.

In the two-argument case (or where the third argument is an empty sequence), the function returns:

$input[round($start) le position()]

In the three-argument case, the function returns:

$input[round($start) le position() and position() lt round($start) + round($length)] filter( $input, if (empty($length)) then ( fn($item, $pos) { round($start) le $pos } ) else ( fn($item, $pos) { round($start) le $pos and $pos lt round($start) + round($length) } ) )

The first item of a sequence is located at position 1, not position 0.

If $input is the empty sequence, the empty sequence is returned.

In the two-argument case, the function returns a sequence comprising those items of $input whose 1-based position is greater than or equal to $start (rounded to an integer). No error occurs if $start is zero or negative.

In the three-argument case, The function returns a sequence comprising those items of $input whose 1-based position is greater than or equal to $start (rounded to an integer), and less than the sum of $start and $length (both rounded to integers). No error occurs if $start is zero or negative, or if $start plus $length exceeds the number of items in the sequence, or if $length is negative.

As a consequence of the general rules, if $start is -INF and $length is +INF, then fn:round($start) + fn:round($length) is NaN; since position() lt NaN always returns false, the result is an empty sequence.

The reason the function accepts arguments of type xs:double is that many computations on untyped data return an xs:double result; and the reason for the rounding rules is to compensate for any imprecision in these floating-point computations.

subsequence($seq, 4) "item4", "item5" subsequence($seq, 3, 2) "item3", "item4"

The optional third argument can now be supplied as an empty sequence.

deterministic context-independent focus-independent

Returns a contiguous sequence of items from $input, with the start and end points located by applying predicates.

Informally, the function returns the subsequence of $input starting with the first item that matches the $from predicate, and ending with the first subsequent item that matches the $to predicate. If $from is not supplied, it defaults to the start of $input; if $to is not supplied, it defaults to the end of $input. If $from does not match any items in $input, the result is the empty sequence; if $to does not match any items, all items up to the last are included in the result.

let $start := index-where($input, $from)[1] otherwise count($input) + 1 let $end := index-where($input, $to)[. ge $start][1] otherwise count($input) + 1 return slice($input, $start, $end)

The result includes both the item that matches the $from condition and the item that matches the $to condition. To select a subsequence that starts after the $from item, apply the fn:tail function to the result. To select a subsequence that ends before the $to item, apply the fn:trunk function to the result.

The predicate functions supplied to the $from and $to parameters can include an integer position argument as well as the item itself. This position will always be 1-based, relative to the start of $input. This means it is possible to select items based on their absolute position in the $input sequence, but there is no mechanism to select an end position relative to the start position. If this is needed, the function can be combined with others: for example, to select a subsequence of four items starting with "Barbara", use $input => subsequence-where(fn { . eq "Barbara" }) => slice(end := 4).

If the requirement is to select all elements stopping before the first h2 element if it exists, or up to the end of the sequence otherwise, the simplest solution is perhaps to write:

slice($input, end:=index-where($input, fn { boolean(self::h2) })[1])

A return value of () from the $from or $to predicate is treated as false.

subsequence-where($names, starts-with(?, "E")) "Eliza", "Freda", "Gertrude", "Hilda" subsequence-where($names, to := starts-with(?, "D")) "Anna", "Barbara", "Catherine", "Delia" subsequence-where($names, to := starts-with(?, "D")) => trunk() "Anna", "Barbara", "Catherine" subsequence-where($names, starts-with(?, "E"), starts-with(?, "G")) "Eliza", "Freda", "Gertrude" subsequence-where( $names, starts-with(?, "D"), fn { string-length(.) gt 5 } ) "Delia", "Eliza", "Freda", "Gertrude" subsequence-where($names, starts-with(?, "M")) () subsequence-where($names, starts-with(?, "G"), starts-with(?, "Z")) "Gertrude", "Hilda" subsequence-where($names) "Anna", "Barbara", "Catherine", "Delia", "Eliza", "Freda", "Gertrude", "Hilda" subsequence-where( $names, fn($it, $pos) { ends-with($it, "a") and $pos gt 5 } ) "Freda", "Gertrude", "Hilda" subsequence-where( $names, to := fn($it, $pos) { ends-with($it, "a") and $pos ge 5 } ) "Anna", "Barbara", "Catherine", "Delia", "Eliza"

New in 4.0

deterministic context-independent focus-independent

Returns a sequence containing the items from $input at positions defined by $at, in the order specified.

Returns the items in $input at the positions listed in $at, in order of the integers in the $at argument.

for-each($at, fn($index) { subsequence($input, $index, 1) })

In the simplest case where $at is a single integer, fn:items-at($input, 3) returns the same result as $input[3].

Compared with a simple positional filter expression, the function is useful because:

It can select items at multiple positions, and unlike fn:subsequence, these do not need to be contiguous.

The $at expression can depend on the focus.

The order of the returned items can differ from their order in the $input sequence.

If any integer in $at is outside the range 1 to count($input), that integer is effectively ignored: no error occurs.

If either of the arguments is an empty sequence, the result is an empty sequence.

If $at contains duplicate integers, the result also contains duplicates. No de-duplication occurs. If the input sequence contains nodes, these are not copied: instead, the result sequence contains multiple references to the same node.

items-at(11 to 20, 4) 14 items-at(11 to 20, 4 to 6) 14, 15, 16 items-at(11 to 20, (7, 3)) 17, 13 items-at(11 to 20, index-of(("a", "b", "c"), "b")) 12 items-at(characters("quintessential"), (4, 8, 3)) "n", "s", "i" items-at(characters("quintessential"), (4, 8, 1, 1)) "n", "s", "q", "q" items-at((), 832) () items-at((), ()) ()

New in 4.0

deterministic context-independent focus-independent

Returns a sequence containing selected items from a supplied input sequence based on their position.

If $input is the empty sequence, the function returns the empty sequence.

Let $S be the first of the following that applies:

If $start is absent, empty, or zero, then 1.

If $start is negative, then fn:count($input) + $start + 1.

Otherwise, $start.

Let $E be the first of the following that applies:

If $end is absent, empty, or zero, then fn:count($input).

If $end is negative, then fn:count($input) + $end + 1.

Otherwise, $end.

Let $STEP be the first of the following that applies:

If $step is absent, empty, or zero, then:

If $E ge $S, then +1

Otherwise -1

Otherwise, $step.

If $STEP is negative, the function returns $input => fn:reverse() => fn:slice(-$S, -$E, -$STEP).

Otherwise the function returns the result of the expression:

$input[position() ge $S and position() le $E and (position() - $S) mod $STEP eq 0] TBA: define formal equivalent.

The function is inspired by the slice operators in Javascript and Python, but it differs in detail to accommodate the tradition of 1-based addressing in XPath. The end position is inclusive rather than exclusive, so that in the simple case where $start and $end are positive and $end > $start, fn:slice($in, $start, $end) returns the same result as $in[position() = $start to $end].

This function can be used to enhance the RangeExpression, defined in , to construct a sequence of integers based on steps other than 1.

slice($in, start := 2, end := 4) "b", "c", "d" slice($in, start := 2) "b", "c", "d", "e" slice($in, end := 2) "a", "b" slice($in, start := 3, end := 3) "c" slice($in, start := 4, end := 3) "d", "c" slice($in, start := 2, end := 5, step := 2) "b", "d" slice($in, start := 5, end := 2, step := -2) "e", "c" slice($in, start := 2, end := 5, step := -2) () slice($in, start := 5, end := 2, step := 2) () slice($in) "a", "b", "c", "d", "e" slice($in, start := -1) "e" slice($in, start := -3) "c", "d", "e" slice($in, end := -2) "a", "b", "c", "d" slice($in, start := 2, end := -2) "b", "c", "d" slice($in, start := -2, end := 2) "d", "c", "b" slice($in, start := -4, end := -2) "b", "c", "d" slice($in, start := -2, end := -4) "d", "c", "b" slice($in, start := -4, end := -2, step := 2) "b", "d" slice($in, start := -2, end := -4, step := -2) "d", "b" slice(("a", "b", "c", "d"), 0) "a", "b", "c", "d" slice((1 to 5), step := 2) 1, 3, 5

New in 4.0

deterministic context-dependent focus-independent deterministic context-independent focus-independent

Determines whether one sequence starts with another, using a supplied callback function to compare items.

Informally, the function returns true if $input starts with $subsequence, when items are compared using the supplied (or default) $compare function.

count($input) ge count($subsequence) and every(for-each-pair($input, $subsequence, $compare))

There is no requirement that the $compare function should have the traditional qualities of equality comparison. The result is well-defined, for example, even if $compare is not transitive or not symmetric. A return value of () from the function is treated as false.

starts-with-subsequence((), ()) true() starts-with-subsequence(1 to 10, 1 to 5) true() starts-with-subsequence(1 to 10, ()) true() starts-with-subsequence(1 to 10, 1 to 10) true() starts-with-subsequence(1 to 10, 1) true() starts-with-subsequence( 1 to 10, 101 to 105, fn($x, $y) { $x mod 100 = $y mod 100 } ) true() starts-with-subsequence( ("A", "B", "C"), ("a", "b"), fn($x, $y) { compare( $x, $y, "http://www.w3.org/2005/xpath-functions/collation/html-ascii-case-insensitive" ) eq 0 } ) true()

")//p[2] return starts-with-subsequence( $p/ancestor::*[1], $p/parent::*, op("is") )]]> true() starts-with-subsequence(10 to 20, 1 to 5, op("gt")) true() starts-with-subsequence( ("Alpha", "Beta", "Gamma"), ("A", "B"), starts-with#2 ) true() starts-with-subsequence( ("Alpha", "Beta", "Gamma", "Delta"), 1 to 3, fn($x, $y) { ends-with($x, 'a' ) } ) true() True because the first three items in the input sequence end with "a".

New in 4.0

deterministic context-dependent focus-independent deterministic context-independent focus-independent

Determines whether one sequence ends with another, using a supplied callback function to compare items.

Informally, the function returns true if $input ends with $subsequence, when items are compared using the supplied (or default) $compare function.

starts-with-subsequence(reverse($input), reverse($subsequence), $compare)

A return value of () from the function is treated as false.

ends-with-subsequence((), ()) true() ends-with-subsequence(1 to 10, 5 to 10) true() ends-with-subsequence(1 to 10, ()) true() ends-with-subsequence(1 to 10, 1 to 10) true() ends-with-subsequence(1 to 10, 10) true() ends-with-subsequence( 1 to 10, 108 to 110, fn($x, $y) { $x mod 100 = $y mod 100 } ) true() ends-with-subsequence( ("A", "B", "C"), ("b", "c"), fn($x, $y) { compare( $x, $y, "http://www.w3.org/2005/xpath-functions/collation/html-ascii-case-insensitive" ) eq 0 } ) true()

")//p[2] return ends-with-subsequence( $p/ancestor::node()[last()], $p/root(), op("is") )]]> true() ends-with-subsequence(10 to 20, 1 to 5, op("gt")) true() ends-with-subsequence( ("Alpha", "Beta", "Gamma"), ("B", "G"), starts-with#2 ) true() ends-with-subsequence( ("Alpha", "Beta", "Gamma", "Delta"), 1 to 2, fn($x, $y) { string-length($x) eq 5 } ) true() True because the last two items in the input sequence have a string length of 5.

New in 4.0

deterministic context-dependent focus-independent deterministic context-independent focus-independent

Determines whether one sequence contains another as a contiguous subsequence, using a supplied callback function to compare items.

Informally, the function returns true if $input contains a consecutive subsequence matching $subsequence, when items are compared using the supplied (or default) $compare function.

some $i in 0 to count($input) - count($subsequence) satisfies ( every $j in 1 to count($subsequence) satisfies $compare($input[$i + $j], $subsequence[$j]) )

A return value of () from the function is treated as false.

contains-subsequence((), ()) true() contains-subsequence(1 to 10, 3 to 6) true() contains-subsequence(1 to 10, (2, 4, 6)) false() contains-subsequence(1 to 10, ()) true() contains-subsequence(1 to 10, 1 to 10) true() contains-subsequence(1 to 10, 5) true() contains-subsequence( 1 to 10, 103 to 105, fn($x, $y) { $x mod 100 = $y mod 100 } ) true() contains-subsequence( ("A", "B", "C", "D"), ("b", "c"), fn($x, $y) { compare( $x, $y, "http://www.w3.org/2005/xpath-functions/collation/html-ascii-case-insensitive" ) eq 0 } ) true()

reverse() [[4, 18], [30, 4, 22]], [30, 4, 22], 30

`input`	`::=`	`S? (dayname ","? S)? ((datespec S time) \| asctime) S?`
`dayname`	`::=`	`"Mon" \| "Tue" \| "Wed" \| "Thu" \| "Fri" \| "Sat" \| "Sun" \| "Monday \| "Tuesday" \| "Wednesday" \| "Thursday" \| "Friday" \| "Saturday" \| "Sunday"`
`datespec`	`::=`	`daynum dsep monthname dsep year`
`asctime`	`::=`	`monthname dsep daynum S time S year`
`dsep`	`::=`	`S \| (S? "-" S?)`
`daynum`	`::=`	`digit digit?`
`year`	`::=`	`digit digit (digit digit)?`
`digit`	`::=`	`[0-9]`
`monthname`	`::=`	`"Jan" \| "Feb" \| "Mar" \| "Apr" \| "May" \| "Jun" \| "Jul" \| "Aug" \| "Sep" \| "Oct" \| "Nov" \| "Dec"`
`time`	`::=`	`hours ":" minutes (":" seconds)? (S? timezone)?`
`hours`	`::=`	`digit digit?`
`minutes`	`::=`	`digit digit`
`seconds`	`::=`	`digit digit ("." digit+)?`
`timezone`	`::=`	`tzname \| tzoffset (S? "(" S? tzname S? ")")?`
`tzname`	`::=`	`"UT" \| "UTC" \| "GMT" \| "EST" \| "EDT" \| "CST" \| "CDT" \| "MST" \| "MDT" \| "PST" \| "PDT"`
`tzoffset`	`::=`	`("+"\|"-") hours ":"? minutes?`
`S`	`::=`	`(x09 \| x0A \| x0D \| x20)+`

Parameter	Required type	Interpretation	Default Value
`allow-duplicate-names`	`xs:boolean?`	`true()` means `"yes"`, `false()` means `"no"`	`no`
`byte-order-mark`	`xs:boolean?`	`true()` means `"yes"`, `false()` means `"no"`	`no`
`cdata-section-elements`	`xs:QName*`		`()`
`doctype-public`	`xs:string?`	Zero-length string and `()` both represent `"absent"`	absent
`doctype-system`	`xs:string?`	Zero-length string and `()` both represent `"absent"`	absent
`encoding`	`xs:string?`		`utf-8`
`escape-solidus`	`xs:boolean?`	`true()` means `"yes"`, `false()` means `"no"`	`yes`
`escape-uri-attributes`	`xs:boolean?`	`true()` means `"yes"`, `false()` means `"no"`	`yes`
`html-version`	`xs:decimal?`		`5`
`include-content-type`	`xs:boolean?`	`true()` means `"yes"`, `false()` means `"no"`	`yes`
`indent`	`xs:boolean?`	`true()` means `"yes"`, `false()` means `"no"`	`no`
`item-delimiter`	`xs:string?`		absent
`json-lines`	`xs:boolean?`	`true()` means `"yes"`, `false()` means `"no"`	`no`
`json-node-output-method`	`(xs:string \| xs:QName)?`	See Notes 1, 2	`xml`
`media-type`	`xs:string?`		(a media type suitable for the chosen `method`)
`method`	`(xs:string \| xs:QName)?`	See Notes 1, 2	`xml`
`normalization-form`	`xs:string?`		`none`
`omit-xml-declaration`	`xs:boolean?`	`true()` means `"yes"`, `false()` means `"no"`	`yes`
`standalone`	`xs:boolean?`	`true()` means `"yes"`, `false()` means `"no"`, `()` means `"omit"`	`omit`
`suppress-indentation`	`xs:QName*`		`()`
`undeclare-prefixes`	`xs:boolean?`	`true()` means `"yes"`, `false()` means `"no"`	`no`
`use-character-maps`	`map(xs:string, xs:string)?`	See Note 3	`{}`
`version`	`xs:string?`		`1.0`