It is a
-
ItemType identified by an
RecordType identified by an
Named item types serve two purposes:
+Named record types serve two purposes:
They allow frequently used item types, especially complex item types such as
- record types, to be given simple names, to avoid repeating the definition
+ They allow frequently used record types
+ to be given simple names, to avoid repeating the definition
every time it is used. They allow the definition of recursive types, which are useful for
describing recursive data structures such as lists and trees. For details see
In XQuery, named item types can be declared in the Query Prolog.
-Named item types can be defined in a
In XQuery, named record types can be declared in the Query Prolog.
+Named record types can be defined in a
Certain named record types defined in
us:address.
NCName, then it is expanded according to the
If the name matches a
If the name matches a
Otherwise, it must match the name of a type in the us:address.
Using the QName of a type in the
Using a QName that identifies a
Using a
xs:integer) or a user-defined type. It must however
- be the name of a type defined in a schema; it cannot be a fn is allowed as a synonym for function
in function types, to align with changes to inline function declarations.record() is allowed; the only thing it matches is an empty map.
A
The
A
map(*): that is, it allows any map.A record type can constrain only those entries whose keys are strings, but when the record +
A
The names of the fields in a record type must be distinct
The names of the fields in a
If a variable $rec is known to conform to a particular
- record type, then when a lookup expression $rec?field is used, (a) the processor
+ $rec?field is used, (a) the processor
can report a type error if $rec cannot contain an entry with name field
(see
map(*), which gives very little information (and places very few constraints)
- on the values that are actually passed across. Using record types offers the possibility of
- improving this: for example, the options argument of fn:parse-json, previously
given as map(*), can now be expressed as record(liberal? as xs:boolean,
duplicates? as xs:string, escape? as xs:boolean, fallback as fn(xs:string) as xs:string, *).
In principle the xs:string type used to describe the duplicates
@@ -5572,7 +5588,7 @@ name.
of xs:string that enumerates the permitted values ("reject",
"use-first", "use-last").
- The use of a record type in the signature of such a function causes the +
The use of a xs:double
value, it becomes possible to supply a map in which the corresponding entry has type xs:integer.
One of the motivations for introducing record types is to enable better pattern matching +
One of the motivations for introducing {longitude: 130.2, latitude: 53.4} relies instead on recognizing the property
@@ -5591,7 +5608,7 @@ name.
match="record(longitude, latitude)"
Rules defining whether one record type is a
Rules defining whether one
A named record type N is said to be recursive if its +
A named
Instances of recursive record types can be constructed and interrogated in the normal way. +
Instances of recursive
and the third value in the map can be retrieved as $list?next?next?value.
In practice, recursive data structures are usually manipulated using recursive functions.
It is possible to define a recursive record type that cannot be instantiated, because it +
It is possible to define a recursive declare record X (next as X);.
Such a record declaration is
Recursive type definitions need to be handled specially by the subtyping rules;
- a naïve approach of simply replacing each reference to a named item type
+ a naïve approach of simply replacing each reference to a named record type
with its definition would make the assessment of the subtype relationship non-terminating.
For details see
The rules in this section apply to
STR has been defined in the
- static context as a xs:string,
- then anything said here about the type xs:string applies equally
- whether it is designated as xs:string or as STR,
- or indeed as the parenthesized forms (xs:string) or
- (STR).
(xs:string) designates the
+ same type as xs:string, and anything said here about one form
+ applies equally to the other.
- References to
The relationship A ⊆ B is true
if and only if at least one of the conditions listed in the following subsections applies:
All of the following are true:
A is a record type.
A is a
B is map(*) or record(*).
All of the following are true:
A is a non-extensible record type
A is a non-extensible
B is map(K, V)
K is either xs:string or xs:anyAtomicType
For every field F in A,
@@ -6793,8 +6808,8 @@ declare record Particle (
All of the following are true: A is a non-extensible record type. B is a non-extensible record type. A is a non-extensible B is a non-extensible Every field in A is also declared in B. Every mandatory field in B is also declared as mandatory in A. For every field that is declared in both A and B,
@@ -6814,8 +6829,8 @@ declare record Particle (
All of the following are true: A is an extensible record type B is an extensible record type A is an extensible B is an extensible Every mandatory field in B is also declared as mandatory in A. For every field that is declared in both A and B,
where the declared type in A is T
@@ -6839,8 +6854,8 @@ declare record Particle (
All of the following are true: A is a non-extensible record type. B is an extensible record type. A is a non-extensible B is an extensible Every mandatory field in B is also declared as mandatory in A.
This section describes how references to
This section describes how references to
Named item types can be classified as recursive or non-recursive. - A recursive type is one that references itself, directly or indirectly. Only named record - types are allowed to be recursive.
-In the case of references to non-recursive named item types, the reference
- is fully expanded as the first step in evaluating the subtype relationship. For example
- this means that if U is a named item type with the expansion
- (xs:integer | xs:double),
- then xs:integer ⊆ U is true, because
- xs:integer ⊆ (xs:integer | xs:double) is true.
Named record types can be classified as recursive or non-recursive. + A recursive type is one that references itself, directly or indirectly.
+In the case of references to non-recursive named record types, the reference
+ can be fully expanded as the first step in evaluating the subtype relationship. For example
+ this means that if U is a named record type with the expansion
+ record(first as xs:string, *),
+ then record(first as xs:string, last as xs:string) ⊆ U is true.
Recursive record types are considered to be, in the terminology of the computer science
literature,
If A is a reference to a recursive named item type, then
+ If A is a reference to a recursive record type, then
A ⊆ B is true if either: A and B
are references to the same named record type. This is because only record types are allowed to be recursive.record(*) ⊆ B.
The name of an The name of a type defined in the There is also a constructor function for every There is also a constructor function for every All such constructor functions are classified as
xs:NOTATION, xs:anySimpleType,
@@ -21821,11 +21834,8 @@ else $x cast as xs:string]]>
and can be found in .
If my:location is a named item type that expands
+
If my:location is a named record type that expands
to record(latitude as xs:double, longitude as xs:double),
then the result of my:location(50.52, -3.02) is
the map { 'latitude': 50.52e0, 'longitude': -3.02e0 }.
If a module A imports module B, the static context of module +
If a module A imports module B, then:
+ +The static context of module
A will contain the
Private functions, variables, and item types declared in B.
The static context of A will not contain:
+Private functions, variables, and record types declared in B.
Functions, variables, and item types not declared directly in B, but imported from some other library module.
Other components such as
The dynamic context of module A will contain the
+ public
The following example illustrates a module import:
@@ -774,8 +782,15 @@ return ( module A does not have access to the functions and variables declared in module C. - - +A module may import public variable and function declarations that are defined using named record types + which are not themselves imported, either because the type definitions are private, or because they are defined + in a module that is not itself imported. In such a case the importing module may reference the variable + or function in question, but it cannot reference the named record type used in the declaration of the + variable or function.
+ +Similarly, a module may import public variable and function declarations that are defined using + schema types that are not themselves imported.
+If one module contains an import module declaration with the target namespace
M, then all public variables and public functions in the contexts of modules
whose target namespace is M must be accessible in the importing module,
- regardless whether the participation of the imported module was directly due to this "import
- module" declaration.
import
+ module declaration.
@@ -857,7 +872,7 @@ $triangle
The term “location URIs” refers to the URIs in the at clause of an
+
The term at clause of an
import module declaration.
Products should (by default or at user option) take account of all the location URIs in an @@ -1937,7 +1952,7 @@ local:depth(doc("partlist.xml"))
Although item type declarations, as described in
A record type declaration defines a name representing a
Named record types also introduce additional capability beyond anonymous record types:
Named record types can be recursive.
A named record declaration serves as both a
The name appearing in a record declaration serves as both an item type and as a + function name, and it therefore inherits rules from both these roles. In particular:
Its name must not be the same as the name of any other named item type, or any
+ Its name must not be the same as the name of any other If the declaration appears within a As a named item type declaration, the construct: Given the record type declaration: is equivalent to: it becomes possible to use the name Any initializing expressions for fields are ignored for this purpose.cx:complex effectively as a synonym for the
+ item type:
There is however one significant difference: the name of a named record declaration is available throughout the static +
The name of a named record declaration is available throughout the static context of the module in which it is declared, including within the record declaration itself. This means that named record declarations can be self-recursive or mutually recursive.
-Unlike a named item type declared using declare type, a reference to a named record type
- cannot (in general) be directly replaced by the corresponding record definition during parsing. This is not only
- because forwards references are allowed; it is also because a recursive record type cannot be expressed using
- the usual
A reference to a named record type + cannot (in general) be directly replaced by the corresponding record definition during parsing. This is + because forwards references and self-references are allowed; replacing the name by the + definition is a process that might not terminate.
A recursive record type will only be instantiable if every field whose value may contain instances of the record type
(directly or indirectly) is optional or emptiable. Specifically, it must either be an optional field, or its type
diff --git a/specifications/xslt-40/src/element-catalog.xml b/specifications/xslt-40/src/element-catalog.xml
index d3cb696cd..167f91556 100644
--- a/specifications/xslt-40/src/element-catalog.xml
+++ b/specifications/xslt-40/src/element-catalog.xml
@@ -94,7 +94,7 @@
XSLT 4.0 is designed to be used in conjunction with XPath 4.0, which is defined in
A transformation expressed in XSLT describes rules for transforming input data into output data. The inputs and outputs
- will all be instances of the XDM data model, described in
-
A paragraph labeled as a
Many terms used in this document are defined in the XPath specification
Many terms used in this document are defined in the XPath specification
The components which can be declared in one package and
referenced in another are:
In addition, A component defined in one package can be overridden by a component in
- another package, provided the signatures are type-compatible.
The author of a package can declare whether the components in the package @@ -3747,7 +3752,13 @@
The visibility of a
named template, function, variable, attribute set, mode,
-
+ It is a private or final.
names attribute is not a wildcard.
+ It is a visibility of a final, private, or hidden.
In the absence of a matching
Except where recursive types are involved, a named item type
- (declared in an
Except where recursive types are involved, a named record type
+ (declared in an visibility="final".
XSLT 4.0 provides built-in functions for parsing CSV files (for example
+ the functions
version="1.0" otherwise.
version="1.0" otherwise.
version="1.0" otherwise.
contains entries with keys "first" and "last".
type(complex) matches any value that is an instance of the item type declared in an "complex"
type(my:complex) matches any value that is an instance of the my:complex
type(complex)[?i eq 0] matches any value that is an instance of the item type declared in an "complex" and that is a map with an entry having key i and value zero.
type(my:complex)[?i eq 0] matches any value that is an instance of the
+ my:complex and that is a map
+ with an entry having key i and value zero.
version="1.0" otherwise.
- An
An
The following example declares a named item type for complex numbers, and uses it in a variable +
The following example declares a named record type for complex numbers, and uses it in a variable declaration and a function declaration.
-version="1.0" otherwise.
Note how the item type declaration has implicitly declared a constructor function
- cx:complex that can be used to create instances of the item type;
+
Note how the record type declaration has implicitly declared a constructor function
+ cx:complex that can be used to create instances of the record type;
details of this mechanism are at
Using named item types makes the stylesheet more readable, and improves potential for change: a change + +
SequenceType or ItemType within the containing stylesheet package,
+ for example in the as attributes of the declarations of functions, templates,
+ and global variables.
It is a
In addition, the
The name of the record type must be in a namespace.
The name of each field of the record type must be an xs:NCName.
Using named record types makes the stylesheet more readable, and improves potential for change: a change to the way complex numbers are implemented in this example is less likely to affect users of the function - library. However, named item types do not provide true encapsulation or information hiding; users of the + library. However, named record types do not provide true encapsulation or information hiding; users of the function library can still treat complex numbers as raw maps if they wish.
-The
The ItemType to appear.
The scope of a named item type is the
The scope of a named record type is the visibility="final" then it also becomes available for use in using
- packages. Named item types cannot be overridden in a using package, so the only permitted values for
+ packages. Named record types cannot be overridden in a using package, so the only permitted values for
visibility are private and final.
The name of the item type is the expanded name formed by resolving the name attribute.
+
+
The name of the record type is the expanded name formed by resolving the name attribute.
A lexical QName with no prefix is treated as a no-namespace name.
If two
If two
It is a
An item type declaration may refer directly or indirectly to itself if
- it satisfies the conditions defined in
A record type declaration may refer directly or indirectly to itself. This allows types to be declared that match recursive data structures such as linked lists and trees.
-A named record type with visibility private may be used in the definition of
+ a component (such as a variable, a function, a template, or another named record type) that is itself
+ public. Another package may reference such a component even though it cannot reference
+ the types used in its definition.
version="1.0" otherwise.
]
The following template rules are used. The setting expand-text="yes" is assumed:
version="1.0" otherwise.