XPath and XQuery Functions and Operators 4.0

2 Processing sequences

A sequence is an ordered collection of zero or more items. An item is a node, an atomic item, or a function, such as a map or an array. The terms sequence and item are defined formally in [XQuery 4.0: An XML Query Language] and [XML Path Language (XPath) 4.0].

2.5 Basic higher-order functions

The following functions take function items as an argument.

Function	Meaning
`fn:apply`	Makes a dynamic call on a function with an argument list supplied in the form of an array.
`fn:do-until`	Processes a supplied value repeatedly, continuing when some condition is false, and returning the value that satisfies the condition.
`fn:every`	Returns `true` if every item in the input sequence matches a supplied predicate.
`fn:filter`	Returns those items from the sequence `$input` for which the supplied function `$predicate` returns `true`.
`fn:fold-left`	Processes the supplied sequence from left to right, applying the supplied function repeatedly to each item in turn, together with an accumulated result value.
`fn:fold-right`	Processes the supplied sequence from right to left, applying the supplied function repeatedly to each item in turn, together with an accumulated result value.
`fn:for-each`	Applies the function item `$action` to every item from the sequence `$input` in turn, returning the concatenation of the resulting sequences in order.
`fn:for-each-pair`	Applies the function item `$action` to successive pairs of items taken one from `$input1` and one from `$input2`, returning the concatenation of the resulting sequences in order.
`fn:highest`	Returns a value that is greater than or equal to every other value appearing in the input sequence.
`fn:index-where`	Returns the positions in an input sequence of items that match a supplied predicate.
`fn:lowest`	Returns those items from a supplied sequence that have the lowest value of a sort key, where the sort key can be computed using a caller-supplied function.
`fn:partial-apply`	Performs partial application of a function item by binding values to selected arguments.
`fn:partition`	Partitions a sequence of items into a sequence of non-empty arrays containing the same items, starting a new partition when a supplied condition is true.
`fn:scan-left`	Produces the sequence of successive partial results from the evaluation of `fn:fold-left` with the same arguments.
`fn:scan-right`	Produces the sequence of successive partial results from the evaluation of `fn:fold-right` with the same arguments.
`fn:some`	Returns `true` if at least one item in the input sequence matches a supplied predicate.
`fn:sort`	Sorts a supplied sequence, based on the value of a sort key supplied as a function.
`fn:sort-by`	Sorts a supplied sequence, based on the value of a number of sort keys supplied as functions.
`fn:sort-with`	Sorts a supplied sequence, according to the order induced by the supplied comparator functions.
`fn:subsequence-where`	Returns a contiguous sequence of items from `$input`, with the start and end points located by applying predicates.
`fn:take-while`	Returns items from the input sequence prior to the first one that fails to match a supplied predicate.
`fn:transitive-closure`	Returns all the GNodes reachable from a given start GNode by applying a supplied function repeatedly.
`fn:while-do`	Processes a supplied value repeatedly, continuing while some condition remains true, and returning the first value that does not satisfy the condition.

With all these functions, if the caller-supplied function fails with a dynamic error, this error is propagated as an error from the higher-order function itself.

2.5.9 fn:highest

Changes in 4.0 (next | previous)

New in 4.0 [ 20 September 2022]

Summary

Returns a value that is greater than or equal to every other value appearing in the input sequence.

Signature

`fn:highest`(
`$input`	`as` `item()*`,
`$collation`	`as` `xs:string?`	`:=` `fn:default-collation()`,
`$key`	`as` `(fn(item()) as xs:anyAtomicType*)?`	`:=` `fn:data#1`
) `as` `item()*`

Properties

This function is deterministic, context-dependent, and focus-independent. It depends on collations.

Rules

Any item in $values that is an instance of xs:untypedAtomic is first cast to xs:double. The resulting sequence is referred to as the converted sequence.

All pairs of values in the converted sequence must be mutually comparable. Two values A and B are mutually comparable if fn:compare(A, B) raises no error.

If the converted sequence is empty, the function returns the empty sequence.

If the converted sequence contains the value NaN, the value NaN is returned (as an xs:float or xs:double as appropriate).

Two items A and B from the converted sequence are compared by calling fn:compare(A, B, $collation), where $collation is determined by the rules in 5.3.7 Choosing a collation:

The result of the function is a value from the converted sequence that is greater than or equal to every other value under the above rules. If there is more than one such value, then it is implementation-dependent which of them is returned.

The second argument, $collation, defaults to ().

Supplying an empty sequence as $collation is equivalent to supplying fn:default-collation(). For more information on collations see 5.3.7 Choosing a collation.

The third argument, $key, defaults to the function data#1.

Let $modified-key be the function:

fn($item) {
  $key($item) => data() ! (
    if (. instance of xs:untypedAtomic) then xs:double(.) else .
  )
}

That is, the supplied function for computing key values is wrapped in a function that converts any xs:untypedAtomic values in its result to xs:double. This makes the function consistent with the behavior of fn:min and fn:max, but inconsistent with fn:sort, which treats untyped values as strings.

The result of the function is obtained as follows:

If the input is an empty sequence, the result is an empty sequence.
The input sequence is sorted, by applying the function fn:sort($input, $collation, $modified-key).
Let $C be the selected collation, or the default collation where applicable.
Let $B be the last item in the sorted sequence.
The function returns those items $A from the input sequence that are contextually equal to $B, retaining their order.

Error Conditions

If the set of computed keys contains xs:untypedAtomic values that are not castable to xs:double then the operation will fail with a dynamic error ([err:FORG0001]^FO).

If the set of computed keys contains values that are not comparable using the lt operator then the sort operation will fail with a type error ([err:XPTY0004]^XP).

Examples

Variables
let $e := <a x="10" y="5" z="2"/>

Expression:	`highest($e/@*) ! name()`
Result:	`"x"` (By default, untyped values are compared as numbers.)
Expression:	`highest($e/@*, (), string#1) ! name()`
Result:	`"y"` (Here, the attribute values are compared as strings.)
Expression:	`highest(("red", "green", "blue"), (), string-length#1)`
Result:	`"green"`
Expression:	highest( ("red", "green", "blue"), key := { "red" : xs:hexBinary('FF0000'), "green": xs:hexBinary('008000'), "blue" : xs:hexBinary('0000FF') } )
Result:	"red"
Expression:	highest( ("red", "orange", "yellow", "green", "blue", "indigo", "violet"), key := string-length#1 )
Result:	"orange", "yellow", "indigo", "violet"
Expression:	`highest(1 to 25, (), fn { . idiv 10 })`
Result:	`20, 21, 22, 23, 24, 25`
To find employees having the highest salary:
highest($employees, (), fn { xs:decimal(salary) })

XPath and XQuery Functions and Operators 4.0

W3C Editor's Draft 2 February 2026

Abstract

Status of this Document

Dedication

2 Processing sequences

2.5 Basic higher-order functions

2.5.9 fn:highest