The operator mapping tables in this section list the +
Operator Mapping + +ne,
+ le, gt, and ge; these are now defined by reference to the
+ rules for the operators eq and lt.The operator mapping tables in this section list the
combinations of types for which various operators of &language;
are defined. The operators covered by this appendix are the value comparison
operators eq and lt, and the arithmetic operators
@@ -1588,7 +1596,10 @@ See
The terminal symbols assumed by the grammar above are described in this section.
Quoted strings appearing in production rules are terminal symbols.
Other terminal symbols are defined in
fn:collection function wit
id child whose value is not
and and or,
+ and of predicates in filter expressions, in a way that might allow the processor to raise dynamic
+ errors that the author intended to prevent.
+ id child whose value is not
@price/@value, even though dynamic evaluation
+ is defined to return an empty sequence rather than an error.
+ us:address.
us:address.
ItemType, constraining
+ the value space of strings.us:address.
element(chapter|section),
+ attribute(role|class).
+ NodeTest in an AxisStep now allows alternatives:
+ ancestor::(section|appendix)
+ Some of the constructs described in this section include a
us:address.
element(N)
+ and attribute(N) now allow N to be any NameTest,
+ including a wildcard.
+ element(N)
+ and attribute(N) now allow N to be any NameTest,
+ including a wildcard.
+ ItemType, constraining
+ the value space of maps.
+ record(*) is allowed; it matches any map.
+ xs:positiveInteger.
+
Function coercion is a transformation applied to Static and dynamic function calls are described in the following sections. The The detailed rules for evaluating static function calls and function references are defined
in subsequent sections. Certain axis steps, given an inferred type for the context value, are
classified as true#0
+ to be supplied where a predicate function is required.
+ function may be abbreviated
+ as fn.
+ fn { ../@code }
+ @price/@value, even though dynamic evaluation
+ is defined to return an empty sequence rather than an error.
+
× and ÷ can be used for multiplication and division.
+ &language; provides arithmetic operators for addition, subtraction, multiplication, division, and modulus, in their usual binary and unary forms.
@@ -12214,6 +12371,14 @@ course to the use of parentheses. Therefore, the following two examples have dif`{$greeting}, {$planet}!`
+ is equivalent to $greeting || ', ' || $planet || '!'
+ < must be written as
The value comparison operators are eq, ne, lt, le, gt, and ge. Value comparisons are used for comparing single values.
The first step in evaluating a value comparison is to evaluate its operands. The order in which the operands are evaluated is
< and > can use the full-width forms
+ ＜ and ＞ to avoid the need for XML escaping.
+ The general comparison operators are =, !=, <, <=, >, and >=. General comparisons are existentially quantified comparisons that may be applied to operand sequences of any length. The result of a general comparison that does not raise an error is
always true or false.
for member clause is added to FLWOR expressions to allow iteration over
+ an array.for and let clauses can be combined
+ in an expression without an intervenint return keyword.
+ for expression.
+ for expression can be declared.
+ XPath provides an iteration facility called a XPath allows a variable to be declared and bound to a value using a for and let clauses can be combined
+ in an expression without an intervenint return keyword.
+ let expression can be declared.
+
map is now optional, so
+ map { 0: false(), 1: true() } can now be written { 0: false(), 1: true() }.
+ A Map is created using a
? can now be followed by a string literal, for cases where
+ map keys are strings other than NCNames. It can also be followed by a variable
+ reference.
+ ?? is provided for searching
trees of maps and arrays.
@@ -17661,6 +17880,17 @@ let $z := g($x, $y)]]>
for member clause is added to FLWOR expressions to allow iteration over
+ an array.
+ for clause is now converted
+ to the declared type by applying the coercion rules.
+ let clause is now converted
+ to the declared type by applying the coercion rules.
+ start clause in window expressions has become optional, as well as
+ the when keyword and its associated expression.
+ while clause,
+ which causes early exit from the iteration when a condition is encountered.
+ if (condition) {X} else {Y},
+ with the else part being optional.
+ &language; allows conditional expressions to be written in several different ways.
discounted, independently of its value:
otherwise operator is introduced: A otherwise B returns the
+ value of A, unless it is an empty sequence, in which case it returns the value of B.
+ discounted, independently of its value:
case clause to match multiple atomic values.
+ false. For example:
=> is now complemented by a “mapping arrow” operator =!>
+ which applies the supplied function to each item in the input sequence independently.
+ As increasing amounts of information are stored, exchanged, and presented using
XML, the ability to intelligently query XML data sources becomes increasingly important. One
diff --git a/specifications/xquery-40/src/query-prolog.xml b/specifications/xquery-40/src/query-prolog.xml
index 294bafc6b..50e4e387e 100644
--- a/specifications/xquery-40/src/query-prolog.xml
+++ b/specifications/xquery-40/src/query-prolog.xml
@@ -475,6 +475,20 @@ return (
In addition to the A function declaration may use the import schema declarations was entirely at the discretion of the processor. To
+ improve interoperability, XQuery 4.0 recommends (but does not mandate)
+ a specific strategy for interpreting these hints.math, map, array, and err. In XQuery 3.1 it was permitted
+ but not required to predeclare these namespaces.
+ true() and false() are allowed
+ in function annotations, and negated numeric literals are also allowed.
+ %private or %public annotations
to specify that a function is public or private; if neither of these annotations is used, the