View Old View New View Both View Only Previous Next

This draft contains only sections that have differences from the version that it modified.

W3C

XPath and XQuery Functions and Operators 4.0

W3C Editor's Draft 2 February 2026

This version:
https://qt4cg.org/specifications/xpath-functions-40/
Latest version of XPath and XQuery Functions and Operators 4.0:
https://qt4cg.org/specifications/xpath-functions-40/
Most recent Recommendation of XPath and XQuery Functions and Operators:
https://www.w3.org/TR/2017/REC-xpath-functions-31-20170321/
Editor:
Michael Kay, Saxonica <http://www.saxonica.com/>

This document is also available in these non-normative formats: Specification in XML format and XML function catalog.

Copyright © 2000 W3C® (MIT, ERCIM, Keio, Beihang). W3C liability, trademark and document use rules apply.

Abstract

This document defines constructor functions, operators, and functions on the datatypes defined in [XML Schema Part 2: Datatypes Second Edition] and the datatypes defined in [XQuery and XPath Data Model (XDM) 4.0]. It also defines functions and operators on nodes and node sequences as defined in the [XQuery and XPath Data Model (XDM) 4.0]. These functions and operators are defined for use in [XML Path Language (XPath) 4.0] and [XQuery 4.0: An XML Query Language] and [XSL Transformations (XSLT) Version 4.0] and other related XML standards. The signatures and summaries of functions defined in this document are available at: http://www.w3.org/2005/xpath-functions/.

A summary of changes since version 3.1 is provided at H Changes since 3.1.

Status of this Document

This section describes the status of this document at the time of its publication. Other documents may supersede this document.

This document is a working draft developed and maintained by a W3C Community Group, the XQuery and XSLT Extensions Community Group unofficially known as QT4CG (where "QT" denotes Query and Transformation). This draft is work in progress and should not be considered either stable or complete. Standard W3C copyright and patent conditions apply.

The community group welcomes comments on the specification. Comments are best submitted as issues on the group's GitHub repository.

As the Community Group moves towards publishing dated, stable drafts, some features that the group thinks may likely be removed or substantially changed are marked “at risk” in their changes section. In this draft:

The community group maintains two extensive test suites, one oriented to XQuery and XPath, the other to XSLT. These can be found at qt4tests and xslt40-test respectively. New tests, or suggestions for correcting existing tests, are welcome. The test suites include extensive metadata describing the conditions for applicability of each test case as well as the expected results. They do not include any test drivers for executing the tests: each implementation is expected to provide its own test driver.

Dedication

The publications of this community group are dedicated to our co-chair, Michael Sperberg-McQueen (1954–2024).

13 Processing function items

The functions included in this section operate on function items, that is, values referring to a function.

[Definition] Functions that accept functions among their arguments, or that return functions in their result, are described in this specification as higher-order functions.

Note:

Some functions such as fn:parse-json allow the option of supplying a callback function for example to define exception behavior. Where this is not essential to the use of the function, the function has not been classified as higher-order for this purpose; in applications where function items cannot be created, these particular options will not be available.

FunctionMeaning
fn:function-lookupReturns a function item having a given name and arity, if there is one.
fn:function-nameReturns the name of the function identified by a function item.
fn:function-arityReturns the arity of the function identified by a function item.
fn:function-identityReturns a string representing the identity of a function item.
fn:function-annotationsReturns the annotations of the function item.

13.4 fn:function-identity

Changes in 4.0 (next | previous)

  1. New in 4.0  [Issue 1798 PR 1801 5 March 2025]

Summary

Returns a string representing the identity of a function item.

Signature
fn:function-identity(
$functionas fn(*)
) as xs:string
Properties

This function is deterministic, context-independent, and focus-independent.

Rules

The fn:function-identity function returns a string that represents the identity of $function.

The returned string has the property that fn:function-identity($f1) and fn:function-identity($f2) are codepoint-equal if and only if $f1 and $f2 have the same function identity. Apart from this property, the result is implementation-dependent.

In the case of maps and arrays, the result follows the following rule: If $X and $Y are both maps or arrays then fn:function-identity($X)must not be codepoint-equal to fn:function-identity($Y) unless $X and $Y are indistinguishable, that is unless every operator or function applied to $X returns the same result as for $Y. Even in this case, however, the result of the comparison fn:function-identity($X) eq fn:function-identity($Y) is implementation-dependent.

Notes

This function enables applications to test whether two expressions or variables reference the same function item. This may be useful, for example, to allow caching of function results to avoid repeated evaluation. The results of previous function invocations might be held in a map whose key is the function identity.

The function identity, by definition, is generated upon the creation of a function item. Specific expressions that create function items have their own rules for the identity of the returned functions: for example, it is guaranteed that evaluation of a function reference to a system function with no captured context (such as fn:abs#1) will always return the same function item.

It is not meaningful to store or compare the result of calling fn:function-identity across different execution scopes, because the string used to represent the function identity will generally vary from one execution scope to another.

The result of an expression such as function-identity(abs#1) eq function-identity(abs(?)) may be either true or false, because it is implementation-dependent whether abs#1 and abs(?) return the same function item.

Similarly, function-identity({ 1:() }) eq function-identity(map:entry(1, ())) may be either true or false.

Examples
ExpressionResult
function-identity(abs#1) eq function-identity(abs#1)

true()

function-identity(abs#1) eq function-identity(round#1)

false()

function-identity({ 1: 0 }) eq function-identity({ 1: 1 })

false()

function-identity([ 0 ]) eq function-identity([ 1 ])

false()

13.5 fn:function-annotations

Changes in 4.0 (next | previous)

  1. Changes the functionNew in 4.0 to return a sequence of key-value pairs rather than a map.    [Issue 36 PR 710 17 September 2023]

  2. Changes the function to return a sequence of key-value pairs rather than a map.  [Issue 1391 PR 1393 19 August 2024]

Summary

Returns the annotations of the function item.

Signature
fn:function-annotations(
$functionas fn(*)
) as map(xs:QName, xs:anyAtomicType*)*
Properties

This function is deterministic, context-independent, and focus-independent.

Rules

The fn:function-annotations function returns the annotations of $function as a sequence of single-entry maps, each associating the name of a function annotation with the value of the annotation. Note that several annotations on a function can share the same name. The order of the annotations is retained.

The result is a sequence of single-entry maps, each being an instance of map(xs:QName, xs:anyAtomicType*). If a function (for example, a built-in function) has no annotations, the result of the function is an empty sequence.

For each annotation, a map is returned, with a single entry. The key of the map entry is the name of the annotation as an xs:QName. The value of the entry is the value of the annotation as a sequence of atomic items. If the annotation has no values, the associated value is an empty sequence.

Notes

In the common case where the annotation names are all unique, the result of the function can readily be converted into single map by applying the function map:merge.

Examples
Expression:
function-annotations(true#0)
Result:
()
Expression:
declare %private function local:inc($c) { $c + 1 };
function-annotations(local:inc#1)
Result:
{ #Q{http://www.w3.org/2012/xquery}private : () }
Expression:
let $old := %local:deprecated('0.1', '0.2') fn() {}
let $ann := function-annotations($old)
return map:merge($ann)
Result:
{
  #Q{http://www.w3.org/2005/xquery-local-functions}deprecated :
  ("0.1", "0.2") 
}

16 Processing JNodes

Changes in 4.0 (next | previous)

  1. Introduced the concept of JNodes.   [Issue 2025 PR 2031 11 June 2025]

A JNodeDM is a wrapper around a map or array, or around a value that appears within the content of a map or array. JNodes are described at [XQuery and XPath Data Model (XDM) 4.0] section 8.4 JNodes. Wrapping a map or array in a JNode enables the use of path expressions such as $jnode/descendant::title, as described at [XML Path Language (XPath) 4.0] section 4.7 Path Expressions.

In addition to the functions defined in this section, functions that operate on JNodes include:

fn:distinct-ordered-nodes
fn:generate-id
fn:has-children
fn:innermost
fn:outermost
fn:path
fn:root
fn:siblings
fn:transitive-closure

16.1 Functions on JNodes

16.1.2 fn:jnode-content

Changes in 4.0 (next | previous)

  1. New in 4.0  [Issue 2025 PR 2031 12 June 2025]

Summary

Returns the ·content· property of a JNode.

Signature
fn:jnode-content(
$inputas jnode()?:= .
) as item()*
Properties

This function is deterministic, context-independent, and focus-independent.

Rules

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

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

Otherwise, the function returns the ·content· property of $input.

Error Conditions

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

  • If the context value is absentDM, type error [err:XPDY0002]XP.

  • If the context value is not an instance of the sequence type jnode()?, type error [err:XPTY0004]XP.

Notes

In many cases it is unnecessary to make an explicit call on jnode-content, because the coercion rules will take care of this automatically. For example, in an expression such as $X / descendant::name [matches(., '^J')], the call on matches is supplied with a JNode as its first argument; atomization ensures that the actual value being passed to the first argument of matches is the atomized value of the ·content· property.

Other examples where the ·content· of a JNode is extracted automatically include:

  • Any context where the required type is an atomic value, for example arithmetic operations, value comparisons and general comparisons, and calls on functions that expect an atomic value.

  • Any context where the required type is a map or array, for example the first argument of functions such as map:size or array:size, a free-standing expression within a map constructor such as map{ $jnode }, the constructs for member and for key/value, the left-hand operand of the lookup operator ? (or the context value in the case of a unary lookup operator), and the operand of a map/array filter expression $jnode?[predicate].

Notable places where the ·content· is not automatically extracted include:

  • When computing the effective boolean value. As with XNodes, writing if ($array/child::*[1]) ... tests for the existence of a child, it does not test its value. To test its value, write if (jnode-content($array/child::*[1])) ..., or equivalently if (xs:boolean($array/child::*[1])) ....

  • When calling functions that accept arbitrary sequences, such as count or deep-equal.

It is possible (though probably unwise) to construct a JNode whose ·content· property itself contains another JNode. For example, the expression jtree([jtree([]), jtree([])]) creates a JNode whose ·content· is an array of JNodes, and applying the child axis to this JNode will return a sequence of two JNodes that themselves have further JNodes as their content. The jnode-content returns these contained JNodes, it does not recursively extract their content.

Examples
Expression:
let $array := [1, 3, 4.5, 7, "eight", 10]
return $array / child::type(xs:integer) =!> jnode-content()
Result:
1, 3, 7, 10
Expression:
let $map := {'Mo': 'Monday', 'Tu': 'Tuesday', 'We': 'Wednesday'}
return $map / child::get(("Mo", "We", "Fr", "Su")) =!> jnode-content()
Result:
"Monday", "Wednesday"
Expression:
let $array := [[4, 18], [30, 4, 22]]
return $array / descendant::*[. > 25][1] / ancestor-or-self::* =!> jnode-content()
Result:
[[4, 18], [30, 4, 22]], [30, 4, 22]

H Changes since 3.1 (Non-Normative)

H.1 Summary of Changes

  1. If a section of this specification has been updated since version 3.1, an overview of the changes is provided, along with links to navigate to the next or previous change.

    See 1 Introduction

  2. Sections with significant changes are marked with a ✭ symbol in the table of contents. New functions are indicated by ✚.

    See 1 Introduction

  3. PR 1504 2329 

    New in 4.0

    See 2.1.7 fn:insert-separator

  4. New in 4.0

    See 2.1.10 fn:replicate

  5. New in 4.0

    See 2.1.12 fn:slice

  6. PR 1120 1150 

    A callback function can be supplied for comparing individual items.

    See 2.2.4 fn:deep-equal

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

    See 2.2.5 fn:distinct-values

  8. PR 614 987 

    New in 4.0

    See 2.2.6 fn:duplicate-values

  9. New in 4.0. Originally proposed under the name fn:uniform

    See 2.4.2 fn:all-equal

  10. New in 4.0. Originally proposed under the name fn:unique

    See 2.4.3 fn:all-different

  11. New in 4.0

    See 2.5.3 fn:every

  12. New in 4.0

    See 2.5.9 fn:highest

  13. New in 4.0

    See 2.5.10 fn:index-where

  14. New in 4.0

    See 2.5.11 fn:lowest

  15. New in 4.0

    See 2.5.15 fn:scan-right

  16. New in 4.0

    See 2.5.16 fn:some

  17. PR 795 2228 

    New in 4.0

    See 2.5.19 fn:sort-with

  18. PR 521 761 

    New in 4.0

    See 2.5.22 fn:transitive-closure

  19. New in 4.0

    See 4.4.5 fn:is-NaN

  20. PR 1260 1275 

    A third argument has been added, providing control over the rounding mode.

    See 4.4.6 fn:round

  21. PR 1049 1151 

    Decimal format parameters can now be supplied directly as a map in the third argument, rather than referencing a format defined in the static context.

    See 4.7.2 fn:format-number

  22. PR 1205 1230 

    New in 4.0

    See 4.8.2 math:e

    See 4.8.8 math:cosh

    See 4.8.15 math:sinh

    See 4.8.18 math:tanh

  23. The 3.1 specification suggested that every value in the result range should have the same chance of being chosen. This has been corrected to say that the distribution should be arithmetically uniform (because there are as many xs:double values between 0.01 and 0.1 as there are between 0.1 and 1.0).

    See 4.9.2 fn:random-number-generator

  24. PR 261 306 993 

    New in 4.0

    See 5.4.1 fn:char

  25. New in 4.0

    See 5.4.2 fn:characters

  26. PR 937 995 1190 

    New in 4.0

    See 5.4.13 fn:hash

  27. PR 215 415  

    New in 4.0

    See 7.6.2 fn:parse-uri

  28. PR 1423 1413 

    New in 4.0

    See 7.6.3 fn:build-uri

  29. New in 4.0

    See 12.2.2 fn:in-scope-namespaces

  30. PR 1620 1886 

    Options are added to customize the form of the output.

    See 12.2.9 fn:path

  31. PR 1547 1551 

    New in 4.0

    See 12.2.11 fn:siblings

  32. PR 969 1134 

    New in 4.0

    See 14.4.6 map:filter

  33. PR 478 515 

    New in 4.0

    See 14.4.12 map:keys-where

  34. PR 1575 1906 

    A new function fn:element-to-map is provided for converting XDM trees to maps suitable for serialization as JSON. Unlike the fn:xml-to-json function retained from 3.1, this can handle arbitrary XML as input.

    See 14.5 Converting elements to maps

  35. New in 4.0

    See 15.2.3 array:empty

  36. PR 968 1295 

    New in 4.0

    See 15.2.13 array:index-of

  37. PR 476 1087 

    New in 4.0

    See 15.2.16 array:items

  38. PR 360 476 

    New in 4.0

    See 15.2.18 array:members

    See 15.2.19 array:of-members

  39. Supplying an empty sequence as the value of an optional argument is equivalent to omitting the argument.

    See 15.2.29 array:subarray

  40. PR 1117 1279 

    The $options parameter has been added.

    See 17.1.6 fn:unparsed-text-lines

  41. PR 259 956 

    A new function is available for processing input data in HTML format.

    See 17.3 Functions on HTML Data

    New in 4.0

    See 17.3.2 fn:parse-html

  42. PR 975 1058 1246 

    An option is provided to control how JSON numbers should be formatted.

    See 17.4.4 fn:parse-json

  43. Additional options are available, as defined by fn:parse-json.

    See 17.4.5 fn:json-doc

  44. PR 533 719 834 1066 

    New in 4.0

    See 17.5.4 fn:csv-to-arrays

    See 17.5.7 fn:parse-csv

  45. PR 533 719 834 1066 1605 

    New in 4.0

    See 17.5.10 fn:csv-to-xml

  46. PR 791 1256 1282 1405 

    New in 4.0

    See 17.6.1 fn:invisible-xml

  47. PR 629 803 

    New in 4.0

    See 21.2.2 fn:message

  48. PR 533 719 834 

    New functions are available for processing input data in CSV (comma separated values) format.

    See 17.5 Functions on CSV Data

  49. Comparison of mixed numeric types (for example xs:double and xs:decimal) now generally converts both values to xs:decimal.

    See 4.3 Comparing numeric values

  50. PR 289 1901 

    A third argument is added, allowing user control of how absent keys should be handled.

    See 14.4.9 map:get

    A third argument is added, allowing user control of how index-out-of-bounds conditions should be handled.

    See 15.2.11 array:get

  51. A new collation URI is defined for Unicode case-insensitive comparison and ordering.

    See 5.3.5 The Unicode case-insensitive collation

  52. PR 1727 1740 

    It is no longer guaranteed that the new key replaces the existing key.

    See 14.4.14 map:put

  53. The group may remove this function, it is considered at risk.

    See 15.2.18 array:members

    See 15.2.19 array:of-members

  54. PR 173 

    New in 4.0

    See 18.4 fn:op

  55. PR 203 

    New in 4.0

    See 14.4.1 map:build

  56. PR 207 

    New in 4.0

    See 10.1.2 fn:parse-QName

    See 10.2.5 fn:expanded-QName

  57. PR 222 

    New in 4.0

    See 2.2.3 fn:contains-subsequence

    See 2.2.7 fn:ends-with-subsequence

    See 2.2.9 fn:starts-with-subsequence

  58. PR 250 

    New in 4.0

    See 2.1.3 fn:foot

    See 2.1.15 fn:trunk

    See 15.2.2 array:build

    See 15.2.8 array:foot

    See 15.2.31 array:trunk

  59. PR 258 

    New in 4.0

    See 15.2.14 array:index-where

  60. PR 313 

    The second argument can now be a sequence of integers.

    See 2.1.9 fn:remove

  61. PR 319 

    New in 4.0. The function replaces the internal op:same-key function in 3.1

    See 2.2.1 fn:atomic-equal

  62. PR 326 

    Higher-order functions are no longer an optional feature.

    See 1.2 Conformance

  63. PR 360 

    New in 4.0

    See 14.4.4 map:entries

  64. PR 419 

    New in 4.0

    See 2.1.8 fn:items-at

  65. PR 434 

    New in 4.0

    See 4.5.2 fn:parse-integer

    The function has been extended to allow output in a radix other than 10, for example in hexadecimal.

    See 4.6.1 fn:format-integer

  66. PR 477 

    New in 4.0

    See 15.2.24 array:slice

  67. PR 482 

    Deleted an inaccurate statement concerning the behavior of NaN.

    See 4.3 Comparing numeric values

  68. PR 507 

    New in 4.0

    See 2.5.13 fn:partition

  69. PR 546 

    It is no longer automatically an error if the input contains a codepoint that is not valid in XML. Instead, the codepoint must be a permitted character. The set of permitted characters is implementation-defined, but it is recommended that all Unicode characters should be accepted.

    See 5.2.1 fn:codepoints-to-string

    It is no longer automatically an error if the resource (after decoding) contains a codepoint that is not valid in XML. Instead, the codepoint must be a permitted character. The set of permitted characters is implementation-defined, but it is recommended that all Unicode characters should be accepted.

    See 17.1.5 fn:unparsed-text

    The rules regarding use of non-XML characters in JSON texts have been relaxed.

    See 17.4.3 JSON character repertoire

    See 17.4.4 fn:parse-json

    It is no longer automatically an error if the input contains a codepoint that is not valid in XML. Instead, the codepoint must be a permitted character. The set of permitted characters is implementation-defined, but it is recommended that all Unicode characters should be accepted.

    See 17.4.5 fn:json-doc

  70. PR 609 

    New in 4.0

    See 15.2.28 array:split

  71. PR 631 

    New in 4.0

    See 7.1 fn:decode-from-uri

  72. PR 662 

    Constructor functions now have a zero-arity form; the first argument defaults to the context item.

    See 22 Constructor functions

  73. PR 680 

    The case-insensitive collation is now defined normatively within this specification, rather than by reference to the HTML "living specification", which is subject to change. The collation can now be used for ordering comparisons as well as equality comparisons.

    See 5.3.6 The HTML ASCII Case-Insensitive Collation

  74. PR 702 

    The function can now take any number of arguments (previously it had to be two or more), and the arguments can be sequences of strings rather than single strings.

    See 5.4.4 fn:concat

  75. PR 710 

    Changes the function to return a sequence of key-value pairs rather than a map.

    New in 4.0

    See 13.5 fn:function-annotations

  76. PR 727 

    It has been clarified that loading a module has no effect on the static or dynamic context of the caller.

    See 18.2 fn:load-xquery-module

  77. PR 828 

    The $predicate callback function accepts an optional position argument.

    See 2.5.4 fn:filter

    The $action callback function accepts an optional position argument.

    See 2.5.7 fn:for-each

    See 2.5.8 fn:for-each-pair

    The $predicate callback function now accepts an optional position argument.

    See 15.2.4 array:filter

    The $action callback function now accepts an optional position argument.

    See 15.2.9 array:for-each

    See 15.2.10 array:for-each-pair

  78. PR 881 

    The way that fn:min and fn:max compare numeric values of different types has changed. The most noticeable effect is that when these functions are applied to a sequence of xs:integer or xs:decimal values, the result is an xs:integer or xs:decimal, rather than the result of converting this to an xs:float or xs:double.

    See 2.4.5 fn:max

    See 2.4.6 fn:min

  79. PR 901 

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

    See 2.1.13 fn:subsequence

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

    See 5.4.6 fn:substring

    The second argument can now be an empty sequence.

    See 6.3.3 fn:tokenize

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

    See 7.5 fn:resolve-uri

    The 3rd, 4th, and 5th arguments are now optional; previously the function required either 2 or 5 arguments.

    See 9.8.1 fn:format-dateTime

    See 9.8.2 fn:format-date

    See 9.8.3 fn:format-time

    All three arguments are now optional, and each argument can be set to an empty sequence. Previously if $description was supplied, it could not be empty.

    See 21.1.1 fn:error

    The $label argument can now be set to an empty sequence. Previously if $label was supplied, it could not be empty.

    See 21.2.1 fn:trace

  80. PR 905 

    The rule that multiple calls on fn:doc supplying the same absolute URI must return the same document node has been clarified; in particular the rule does not apply if the dynamic context for the two calls requires different processing of the documents (such as schema validation or whitespace stripping).

    See 17.1.1 fn:doc

  81. PR 909 

    The function has been expanded in scope to handle comparison of values other than strings.

    See 2.2.2 fn:compare

  82. PR 924 

    Rules have been added clarifying that users should not be allowed to change the schema for the fn namespace.

    See D Schemas

  83. PR 925 

    The decimal format name can now be supplied as a value of type xs:QName, as an alternative to supplying a lexical QName as an instance of xs:string.

    See 4.7.2 fn:format-number

  84. PR 932 

    The specification now prescribes a minimum precision and range for durations.

    See 8.1.2 Limits and precision

  85. PR 933 

    When comments and processing instructions are ignored, any text nodes either side of the comment or processing instruction are now merged prior to comparison.

    See 2.2.4 fn:deep-equal

  86. PR 940 

    New in 4.0

    See 2.5.20 fn:subsequence-where

  87. PR 953 

    Constructor functions for named record types have been introduced.

    See 22.6 Constructor functions for named record types

  88. PR 962 

    New in 4.0

    See 2.5.2 fn:do-until

    See 2.5.23 fn:while-do

  89. PR 969 

    New in 4.0

    See 14.4.3 map:empty

  90. PR 984 

    New in 4.0

    See 8.4.1 fn:seconds

  91. PR 987 

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

    See 2.2.5 fn:distinct-values

  92. PR 1022 

    Regular expressions can include comments (starting and ending with #) if the c flag is set.

    See 6.1 Regular expression syntax

    See 6.2 Flags

  93. PR 1028 

    An option is provided to control how the JSON null value should be handled.

    See 17.4.4 fn:parse-json

  94. PR 1032 

    New in 4.0

    See 2.1.17 fn:void

  95. PR 1046 

    New in 4.0

    See 2.5.21 fn:take-while

  96. PR 1059 

    Use of an option keyword that is not defined in the specification and is not known to the implementation now results in a dynamic error; previously it was ignored.

    See 1.7 Options

  97. PR 1068 

    New in 4.0

    See 5.4.3 fn:graphemes

  98. PR 1072 

    The return type is now specified more precisely.

    See 18.2 fn:load-xquery-module

  99. PR 1090 

    When casting from a string to a duration or time or dateTime, it is now specified that when there are more digits in the fractional seconds than the implementation is able to retain, excess digits are truncated. Rounding upwards (which could affect the number of minutes or hours in the value) is not permitted.

    See 23.2 Casting from xs:string and xs:untypedAtomic

  100. PR 1093 

    New in 4.0

    See 5.3.9 fn:collation

  101. PR 1117 

    The $options parameter has been added.

    See 17.1.5 fn:unparsed-text

    See 17.1.7 fn:unparsed-text-available

  102. PR 1182 

    The $predicate callback function may return an empty sequence (meaning false).

    See 2.5.2 fn:do-until

    See 2.5.3 fn:every

    See 2.5.4 fn:filter

    See 2.5.10 fn:index-where

    See 2.5.16 fn:some

    See 2.5.21 fn:take-while

    See 2.5.23 fn:while-do

    See 14.4.6 map:filter

    See 14.4.12 map:keys-where

    See 15.2.4 array:filter

    See 15.2.14 array:index-where

  103. PR 1191 

    The $options parameter has been added, absorbing the $collation parameter.

    See 2.2.4 fn:deep-equal

    New in 4.0

    See 12.3.1 fn:distinct-ordered-nodes

  104. PR 1250 

    For selected properties including percent and exponent-separator, it is now possible to specify a single-character marker to be used in the picture string, together with a multi-character rendition to be used in the formatted output.

    See 4.7.2 fn:format-number

  105. PR 1257 

    The $options parameter has been added.

    See 17.2.1 fn:parse-xml

    See 17.2.2 fn:parse-xml-fragment

  106. PR 1262 

    New in 4.0

    See 5.3.10 fn:collation-available

  107. PR 1265 

    The constraints on the result of the function have been relaxed.

    See 12.1.2 fn:document-uri

  108. PR 1280 

    As a result of changes to the coercion rules, the number of supplied arguments can be greater than the number required: extra arguments are ignored.

    See 2.5.1 fn:apply

  109. PR 1288 

    Additional error conditions have been defined.

    See 17.2.1 fn:parse-xml

  110. PR 1296 

    New in 4.0

    See 2.5.14 fn:scan-left

  111. PR 1333 

    A new option is provided to allow the content of the loaded module to be supplied as a string.

    See 18.2 fn:load-xquery-module

  112. PR 1353 

    An option has been added to suppress the escaping of the solidus (forwards slash) character.

    See 17.4.7 fn:xml-to-json

  113. PR 1358 

    New in 4.0

    See 9.3.2 fn:unix-dateTime

  114. PR 1361 

    The term atomic value has been replaced by atomic item.

    See 1.9 Terminology

  115. PR 1393 

    Changes the function to return a sequence of key-value pairs rather than a map.

    See 13.5 fn:function-annotations

  116. PR 1409 

    This section now uses the term primitive type strictly to refer to the 20 atomic types that are not derived by restriction from another atomic type: that is, the 19 primitive atomic types defined in XSD, plus xs:untypedAtomic. The three types xs:integer, xs:dayTimeDuration, and xs:yearMonthDuration, which have custom casting rules but are not strictly-speaking primitive, are now handled in other subsections.

    See 23.1 Casting from primitive types to primitive types

    The rules for conversion of dates and times to strings are now defined entirely in terms of XSD 1.1 canonical mappings, since these deliver exactly the same result as the XPath 3.1 rules.

    See 23.1.2.2 Casting date/time values to xs:string

    The rules for conversion of durations to strings are now defined entirely in terms of XSD 1.1 canonical mappings, since the XSD 1.1 rules deliver exactly the same result as the XPath 3.1 rules.

    See 23.1.2.3 Casting xs:duration values to xs:string

  117. PR 1455 

    Numbers now retain their original lexical form, except for any changes needed to satisfy JSON syntax rules (for example, stripping leading zero digits).

    See 17.4.7 fn:xml-to-json

  118. PR 1473 

    New in 4.0

    See 2.1.5 fn:identity

  119. PR 1481 

    The function has been extended to handle other Gregorian types such as xs:gYearMonth.

    See 9.5.1 fn:year-from-dateTime

    See 9.5.2 fn:month-from-dateTime

    The function has been extended to handle other Gregorian types such as xs:gMonthDay.

    See 9.5.3 fn:day-from-dateTime

    The function has been extended to handle other types including xs:time.

    See 9.5.4 fn:hours-from-dateTime

    See 9.5.5 fn:minutes-from-dateTime

    The function has been extended to handle other types such as xs:gYearMonth.

    See 9.5.7 fn:timezone-from-dateTime

  120. PR 1523 

    New functions are provided to obtain information about built-in types and types defined in an imported schema.

    See 19 Processing types

    New in 4.0

    See 19.1.2 fn:schema-type

    See 19.1.4 fn:atomic-type-annotation

    See 19.1.5 fn:node-type-annotation

  121. PR 1545 

    New in 4.0

    See 9.6.4 fn:civil-timezone

  122. PR 1565 

    The default for the escape option has been changed to false. The 3.1 specification gave the default value as true, but this appears to have been an error, since it was inconsistent with examples given in the specification and with tests in the test suite.

    See 17.4.4 fn:parse-json

  123. PR 1570 

    New in 4.0

    See 19.1.3 fn:type-of

  124. PR 1587 

    New in 4.0

    See 17.1.8 fn:unparsed-binary

  125. PR 1611 

    The spec has been corrected to note that the function depends on the implicit timezone.

    See 2.2.2 fn:compare

  126. PR 1671 

    New in 4.0.

    See 4.4.3 fn:divide-decimals

  127. PR 1687 

    New in 4.0

    See 14.4.10 map:items

  128. PR 1703 

    Ordered maps are introduced.

    See 14.1 Ordering of Maps

    Enhanced to allow for ordered maps.

    See 14.4.6 map:filter

    See 14.4.7 map:find

    See 14.4.8 map:for-each

    See 14.4.14 map:put

    See 14.4.15 map:remove

    The order of entries in maps is retained.

    See 17.4.4 fn:parse-json

  129. PR 1711 

    It is explicitly stated that the limits for $precision are implementation-defined.

    See 4.4.6 fn:round

    See 4.4.7 fn:round-half-to-even

  130. PR 1727 

    For consistency with the new function map:build, the handling of duplicates may now be controlled by supplying a user-defined callback function as an alternative to the fixed values for the earlier duplicates option.

    See 14.4.13 map:merge

  131. PR 1734 

    In 3.1, given a mixed input sequence such as (1, 3, 4.2e0), the specification was unclear whether it was permitted to add the first two integer items using integer arithmetic, rather than converting all items to doubles before performing any arithmetic. The 4.0 specification is clear that this is permitted; but since the items can be reordered before being added, this is not required.

    See 2.4.4 fn:avg

    See 2.4.7 fn:sum

  132. PR 1801 

    New in 4.0

    See 13.4 fn:function-identity

  133. PR 1825 

    New in 4.0

    See 2.5.12 fn:partial-apply

  134. PR 1856 

    Word boundaries can be matched. Lookahead and lookbehind assertions are supported. Assertions (including ^ and $) can no longer be followed by a quantifier.

    See 6.1 Regular expression syntax

    The output of the function is extended to allow the represention of captured groups found within lookahead assertions.

    See 6.3.4 fn:analyze-string

  135. PR 1879 

    Additional options to control DTD and XInclude processing have been added.

    See 17.2.1 fn:parse-xml

  136. PR 1897 

    The $replacement argument can now be a function that computes the replacement strings.

    See 6.3.2 fn:replace

  137. PR 1906 

    New in 4.0

    See 14.5.10 fn:element-to-map-plan

    New in 4.0.

    See 14.5.11 fn:element-to-map

  138. PR 1910 

    An $options parameter is added. Note that the rules for the $options parameter control aspects of processing that were implementation-defined in earlier versions of this specification. An implementation may provide configuration options designed to retain backwards-compatible behavior when no explicit options are supplied.

    See 17.1.1 fn:doc

    See 17.1.2 fn:doc-available

  139. PR 1913 

    It is now permitted for the regular expression to match a zero-length string.

    See 6.3.2 fn:replace

    See 6.3.3 fn:tokenize

    See 6.3.4 fn:analyze-string

  140. PR 1933 

    New in 4.0

    See 17.2.5 fn:xsd-validator

  141. PR 1991 

    Named record types used in the signatures of built-in functions are now available as standard in the static context.

    See C Built-in named record types

  142. PR 2001 

    New in 4.0.

    See 2.5.18 fn:sort-by

    See 15.2.26 array:sort-by

  143. PR 2013 

    Support for binary input has been added.

    See 17.2.1 fn:parse-xml

    See 17.2.2 fn:parse-xml-fragment

    New in 4.0

    See 17.3.3 fn:html-doc

    See 17.5.8 fn:csv-doc

  144. PR 2030 

    This description of the XSD validation process was previously found (with some duplication) in the XQuery and XSLT specifications; those specifications now reference this description. As a side-effects, the descriptions of the process in XQuery and XSLT are better aligned.

    See 17.2.4 XSD validation

  145. PR 2031 

    Introduced the concept of JNodes.

    See 16 Processing JNodes

    New in 4.0

    See 16.1.1 fn:jtree

    See 16.1.2 fn:jnode-content

    See 16.1.3 fn:jnode-selector

    See 16.1.4 fn:jnode-position

  146. PR 2149 

    Generalized to work with JNodes as well as XNodes.

    See 12.2.1 fn:has-children

    The function is extended to handle JNodes.

    See 12.2.9 fn:path

    Generalized to work with JNodes as well as XNodes.

    See 12.3.2 fn:innermost

    See 12.3.3 fn:outermost

  147. PR 2168 

    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.

    See 2.2.1 fn:atomic-equal

    See 2.2.4 fn:deep-equal

    See 2.2.5 fn:distinct-values

  148. PR 2223 

    An error may now be raised if the base URI is not a valid LEIRI reference.

    See 12.1.1 fn:base-uri

  149. PR 2224 

    The $action callback function now accepts an optional position argument.

    See 14.4.6 map:filter

    See 14.4.8 map:for-each

  150. PR 2228 

    New in 4.0

    See 15.2.27 array:sort-with

  151. PR 2249 

    The specification now describes in more detail how to determine the effective encoding value.

    See 17.1.5 fn:unparsed-text

  152. PR 2256 

    In the interests of consistency, the index-of function now defines equality to mean contextually equal. This has the implication that NaN is now considered equal to NaN.

    See 2.2.8 fn:index-of

  153. PR 2259 

    A new parameter canonical is available to give control over serialization of XML, XHTML, and JSON.

    See 17.2.3 fn:serialize

  154. PR 2286 

    The type of $value has been generalized to xs:anyAtomicType?.

    See 5.4.7 fn:string-length

    See 5.4.8 fn:normalize-space

  155. PR 2387 

    It is now recommended that out-of-range xs:double values should translate to positive or negative infinity.

    See 17.4.4 fn:parse-json