XSLT 4.0 introduces two new and closely-related constructs allowing item types to be given names, and to be referred to by name anywhere that item types are used, for example in function declarations and variable declarations.
Changes in 4.0 ⬇ ⬆
Named record types are introduced. [Issue 1485 16 January 2025]
<!-- Category: declaration -->
<xsl:record-type
name = eqname
extensible? = boolean〔'no'〕
visibility? = "private" | "public"〔'private'〕 >
<!-- Content: (xsl:field*) -->
</xsl:record-type>
<xsl:field
name = NCName
as? = sequence-type〔'item()*'〕
required? = boolean〔'yes'〕
default? = expression />
An xsl:record-type declaration associates a name with a record type, and allows the record type to be referenced by name throughout the stylesheet package.
The following example declares a named record type for complex numbers, and uses it in a variable declaration and a function declaration.
<xsl:record-type name="cx:complex">
<xsl:field name="r" as="xs:double"/>
<xsl:field name="i" as="xs:double"/>
</xsl:record-type>
<xsl:variable name="i" as="cx:complex" select="cx:complex(0, 1)"/>
<xsl:function name="cx:add" as="cx:complex">
<xsl:param name="x" as="cx:complex"/>
<xsl:param name="y" as="cx:complex"/>
<xsl:sequence select="cx:complex($x?r + $y?r, $x?i + $y?i)"/>
</xsl:function>Note how the record type declaration has implicitly declared a constructor function cx:complex that can be used to create instances of the item type.
[ERR XTSE4050] It is a static error if the names of the fields in an xsl:record-type declaration are not distinct.
[ERR XTSE4051] It is a static error if an xsl:field element has a default attribute unless it specifies required="no".
An xsl:record-type declaration has two effects:
In the same way as xsl:item-type, it defines a named item type in the static context, allowing the record type to be referenced by name anywhere an ItemType can appear, for example in the declarations of functions and variables. Unlike types declared in xsl:item-type, however, named record types can be recursive.
An xsl:record-type declaration also implicitly defines a constructor function, of the same name, and adds this to the set of statically known function definitionsXP in the static context.
Because of its dual role, the name of an xsl:record-type declaration must be valid both as an item type name and as a function name. This means the name must be distinct from other type names and function names in the static context. It also means that the name must be in a namespace.
Considered as an item type, the xsl:record-type declaration is equivalent to an xsl:item-type declaration formed by the following template rule, evaluated in the context of a namespace alias <xsl:namespace-alias stylesheet-prefix="t" result-prefix="xsl"/>:
<xsl:template match="xsl:record-type" expand-text="yes">
<t:item-type name="{@name}"
visibility="{@visibility otherwise 'private'}">
<xsl:attribute name="as">
<xsl:text>record(</xsl:text>
<xsl:for-each select="xsl:field" separator=", ">
<xsl:variable name="optional"
as="xs:boolean"
select="normalize-space(@required) = ('no','false','0')"/>
{@name}{'?'[$optional]} as {@as otherwise 'item()*'}
</xsl:for-each>
<xsl:if test="normalize-space(@extensible) = ('yes','true','1')">
<xsl:text>, *</xsl:text>
</xsl:if>
<xsl:text>)</xsl:text>
</xsl:attribute>
</t:item-type>
</xsl:template>This generated xsl:item-type declaration must meet all the constraints placed on user-written xsl:item-type declarations, including the rule requiring names to be unique, but not including the rule disallowing recursive references.
For example, the declaration:
<xsl:record-type name="cx:complex" extensible="yes">
<xsl:field name="r" as="xs:double"/>
<xsl:field name="i" as="xs:double" required="no" default="0"/>
</xsl:record-type>produces the equivalent item type declaration:
<xsl:item-type name="cx:complex"
as="record(r as xs:double, i? as xs:double, *)"/>Considered as a function declaration, an xsl:record-type declaration is equivalent to an xsl:function declaration formed by the following template rule, evaluated in the context of a namespace alias <xsl:namespace-alias stylesheet-prefix="t" result-prefix="xsl"/>:
<xsl:template match="xsl:record-type">
<t:function name="{@name}"
as="{@name}"
visibility="{(@visibility otherwise 'private')}">
<!-- if the record type is extensible, choose a name for the options parameter -->
<xsl:variable name="options-param" as="xs:string?">
<xsl:if test="normalize-space(@extensible) = ('yes', 'true', 'a')"
then="('options', (1 to count(xsl:field)) ! `options{.}`)
[not(. = current()/xsl:field/@name)][1]"/>
</xsl:variable>
<!-- declare the parameters -->
<xsl:for-each select="xsl:field">
<t:param name="{@name}"
required="{@required otherwise 'yes'}">
<xsl:attribute name="as">
<xsl:variable name="as"
select="normalize-space(@as otherwise 'item()*')"/>
<xsl:variable name="optional"
select="normalize-space(@required) = ('no', 'false', '0')"/>
<xsl:choose>
<xsl:when test="not($optional)" select="$as"/>
<!-- for optional fields, amend the required type to allow () -->
<xsl:when test="matches($as, '[?*]$')" select="$as"/>
<xsl:when test="matches($as, '\+$')" select="replace($as, '\+$', '*')"/>
<xsl:otherwise select="$as || '?'"/>
</xsl:choose>
</xsl:attribute>
<xsl:if test="@default">
<xsl:attribute name="select" select="@default"/>
</xsl:if>
</t:param>
</xsl:for-each>
<!-- for an extensible record type, declare the options parameter -->
<xsl:if test="exists($options-param)">
<t:param name="{$options-param}" as="map(*)" required="no" select="{}"/>
</xsl:if>
<!-- function body: construct a map -->
<t:map on-duplicates="fn($first, $second){{$first}}">
<xsl:for-each select="xsl:field">
<xsl:variable name="optional"
select="normalize-space(@required) = ('no', 'false', '0')"/>
<xsl:choose>
<xsl:when test="$optional and not(@default)">
<!-- omit map entries for optional fields if no value is supplied -->
<t:if test="exists(${@name})">
<t:map-entry key="'{@name}'" select="${@name}"/>
</t:if>
</xsl:when>
<xsl:otherwise>
<t:map-entry key="'{@name}'" select="${@name}"/>
</xsl:otherwise>
</xsl:choose>
</xsl:for-each>
<!-- if the record type is extensible,
add entries from the options parameter -->
<xsl:if test="exists($options-param)">
<t:sequence select="${$options-param}"/>
</xsl:if>
</t:map>
</t:function>
</xsl:template><xsl:template match="xsl:record-type">
<t:function name="{@name}"
as="{@name}"
visibility="{(@visibility otherwise 'private')}">
<!-- if the record type is extensible, choose a name for the options parameter -->
<xsl:variable name="options-param" as="xs:string?">
<xsl:if test="normalize-space(@extensible) = ('yes', 'true', 'a')"
then="('options', (1 to count(xsl:field)) ! `options{.}`)
[not(. = current()/xsl:field/@name)][1]"/>
</xsl:variable>
<!-- declare the parameters -->
<xsl:for-each select="xsl:field">
<t:param name="{@name}"
required="{@required otherwise 'yes'}">
<xsl:attribute name="as">
<xsl:variable name="as"
select="normalize-space(@as otherwise 'item()*')"/>
<xsl:variable name="optional"
select="normalize-space(@required) = ('no', 'false', '0')"/>
<xsl:choose>
<xsl:when test="not($optional)" select="$as"/>
<!-- for optional fields, amend the required type to allow () -->
<xsl:when test="matches($as, '[?*]$')" select="$as"/>
<xsl:when test="matches($as, '\+$')" select="replace($as, '\+$', '*')"/>
<xsl:otherwise select="$as || '?'"/>
</xsl:choose>
</xsl:attribute>
<xsl:if test="@default">
<xsl:attribute name="select" select="@default"/>
</xsl:if>
</t:param>
</xsl:for-each>
<!-- for an extensible record type, declare the options parameter -->
<xsl:if test="exists($options-param)">
<t:param name="{$options-param}" as="map(*)" required="no" select="{}"/>
</xsl:if>
<!-- function body: construct a map -->
<t:map duplicates="fn($first, $second){{$first}}">
<xsl:for-each select="xsl:field">
<xsl:variable name="optional"
select="normalize-space(@required) = ('no', 'false', '0')"/>
<xsl:choose>
<xsl:when test="$optional and not(@default)">
<!-- omit map entries for optional fields if no value is supplied -->
<t:if test="exists(${@name})">
<t:map-entry key="'{@name}'" select="${@name}"/>
</t:if>
</xsl:when>
<xsl:otherwise>
<t:map-entry key="'{@name}'" select="${@name}"/>
</xsl:otherwise>
</xsl:choose>
</xsl:for-each>
<!-- if the record type is extensible,
add entries from the options parameter -->
<xsl:if test="exists($options-param)">
<t:sequence select="${$options-param}"/>
</xsl:if>
</t:map>
</t:function>
</xsl:template><xsl:template match="xsl:record-type">
<t:function name="{@name}"
as="{@name}"
visibility="{(@visibility otherwise 'private')}">
<!-- if the record type is extensible, choose a name for the options parameter -->
<xsl:variable name="options-param" as="xs:string?">
<xsl:if test="normalize-space(@extensible) = ('yes', 'true', 'a')"
then="('options', (1 to count(xsl:field)) ! `options{.}`)
[not(. = current()/xsl:field/@name)][1]"/>
</xsl:variable>
<!-- declare the parameters -->
<xsl:for-each select="xsl:field">
<t:param name="{@name}"
required="{@required otherwise 'yes'}">
<xsl:attribute name="as">
<xsl:variable name="as"
select="normalize-space(@as otherwise 'item()*')"/>
<xsl:variable name="optional"
select="normalize-space(@required) = ('no', 'false', '0')"/>
<xsl:choose>
<xsl:when test="not($optional)" select="$as"/>
<!-- for optional fields, amend the required type to allow () -->
<xsl:when test="matches($as, '[?*]$')" select="$as"/>
<xsl:when test="matches($as, '\+$')" select="replace($as, '\+$', '*')"/>
<xsl:otherwise select="$as || '?'"/>
</xsl:choose>
</xsl:attribute>
<xsl:if test="@default">
<xsl:attribute name="select" select="@default"/>
</xsl:if>
</t:param>
</xsl:for-each>
<!-- for an extensible record type, declare the options parameter -->
<xsl:if test="exists($options-param)">
<t:param name="{$options-param}" as="map(*)" required="no" select="{}"/>
</xsl:if>
<!-- function body: construct a map -->
<t:map on-duplicatesduplicates="fn($first, $second){{$first}}">
<xsl:for-each select="xsl:field">
<xsl:variable name="optional"
select="normalize-space(@required) = ('no', 'false', '0')"/>
<xsl:choose>
<xsl:when test="$optional and not(@default)">
<!-- omit map entries for optional fields if no value is supplied -->
<t:if test="exists(${@name})">
<t:map-entry key="'{@name}'" select="${@name}"/>
</t:if>
</xsl:when>
<xsl:otherwise>
<t:map-entry key="'{@name}'" select="${@name}"/>
</xsl:otherwise>
</xsl:choose>
</xsl:for-each>
<!-- if the record type is extensible,
add entries from the options parameter -->
<xsl:if test="exists($options-param)">
<t:sequence select="${$options-param}"/>
</xsl:if>
</t:map>
</t:function>
</xsl:template>For example, the declaration:
<xsl:record-type name="cx:complex">
<xsl:field name="r" as="xs:double"/>
<xsl:field name="i" as="xs:double" required="no" default="0"/>
</xsl:record-type>produces the equivalent function declaration:
<xsl:function name="cx:complex" as="cx:complex" visibility="private">
<xsl:param name="r" as="xs:double"/>
<xsl:param name="i" as="xs:double" required="no" select="0"/>
<xsl:map>
<xsl:map-entry key="'r'" select="$r"/>
<xsl:map-entry key="'i'" select="$i"/>
</xsl:map>
</xsl:function>No entry is generated in the constructed map for a field that is declared as optional with no default. So the declaration:
<xsl:record-type name="cx:complex" visibility="public">
<xsl:field name="r" as="xs:double"/>
<xsl:field name="i" as="xs:double" required="no"/>
</xsl:record-type>produces the equivalent function declaration:
<xsl:function name="cx:complex" as="cx:complex" visibility="public">
<xsl:param name="r" as="xs:double"/>
<xsl:param name="i" as="xs:double?" required="no"/>
<xsl:map>
<xsl:map-entry key="'r'" select="$r"/>
<xsl:if test="exists($i)">
<xsl:map-entry key="'i'" select="$i"/>
</xsl:if>
</xsl:map>
</xsl:function>If the record type is extensible, the generated function includes an optional options parameter So the declaration:
<xsl:record-type name="cx:complex" extensible="yes">
<xsl:field name="r" as="xs:double"/>
<xsl:field name="i" as="xs:double"/>
</xsl:record-type>produces the equivalent function declaration:
<xsl:function name="cx:complex" as="cx:complex" visibility="private">
<xsl:param name="r" as="xs:double"/>
<xsl:param name="i" as="xs:double"/>
<xsl:param name="options" as="map(*)" required="no" default="{}"/>
<xsl:map on-duplicates="fn($first, $second){$first}">
<xsl:map-entry key="'r'" select="$r"/>
<xsl:map-entry key="'i'" select="$i"/>
<xsl:sequence select="$options"/>
</xsl:map>
</xsl:function><xsl:function name="cx:complex" as="cx:complex" visibility="private">
<xsl:param name="r" as="xs:double"/>
<xsl:param name="i" as="xs:double"/>
<xsl:param name="options" as="map(*)" required="no" default="{}"/>
<xsl:map duplicates="fn($first, $second){$first}">
<xsl:map-entry key="'r'" select="$r"/>
<xsl:map-entry key="'i'" select="$i"/>
<xsl:sequence select="$options"/>
</xsl:map>
</xsl:function><xsl:function name="cx:complex" as="cx:complex" visibility="private">
<xsl:param name="r" as="xs:double"/>
<xsl:param name="i" as="xs:double"/>
<xsl:param name="options" as="map(*)" required="no" default="{}"/>
<xsl:map on-duplicatesduplicates="fn($first, $second){$first}">
<xsl:map-entry key="'r'" select="$r"/>
<xsl:map-entry key="'i'" select="$i"/>
<xsl:sequence select="$options"/>
</xsl:map>
</xsl:function>This generated xsl:function declaration must meet all the constraints placed on user-written xsl:function declarations, including the rule requiring the combination of name and arity to be unique.
The generated xsl:function declaration has the import precedence associated with the stylesheet module in which the xsl:record-type declaration appears, and it may be overridden by another xsl:function declaration with higher import precedence. If the visibility is public then it can also be overridden using xsl:override in another package.
The scope of a named record type is the package in which it is declared. If it is declared with visibility="public" then it also becomes available for use in using packages.
The name of the record type is the expanded name formed by resolving the name attribute. Because function names are always in a namespace, the name must be prefixed.
If two xsl:record-type declarations in a package have the same name, then the one with higher import precedence is used.
[ERR XTSE4030] It is a static error if a package contains two xsl:record-type declarations having the same import precedence, unless there is another definition of the same record type with higher import precedence.
A record type declaration may refer directly or indirectly to itself if it satisfies the conditions defined in Section 3.2.8.3.1 Recursive Record TypesXP. This allows types to be declared that match recursive data structures such as linked lists and trees.
[ERR XTSE4035] It is a static error for an item type named N to contain in its as attribute a reference to N, or to an item type that references N directly or indirectly, unless it satisfies the conditions defined in Section 3.2.8.3.1 Recursive Record TypesXP.
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. The fact that the record type is private, however, means that it is impossible to override a variable or function that references the record type.
This example illustrates the definition of a recursive record type. The record type represents a node of a binary tree containing a payload value in each node, together with optional references to left and right subtrees. As well as the data fields, the record type defines a depth function that returns the maximum depth of the tree, by making recursive calls on its subtrees.
<xsl:record-type name="my:binary-tree">
<xsl:field name="left" as="my:binary-tree?"/>
<xsl:field name="payload" as="item()*"/>
<xsl:field name="right" as="my:binary-tree?"/>
<xsl:field name="depth" as="fn(my:binary-tree) as xs:integer"
default="fn() {1 + max((?left =?> depth(), ?right =?> depth())) otherwise 0)}"/>
</xsl:record-type>The =?> operator is described in [TITLE OF XP40 SPEC, TITLE OF lookup-arrow-expression SECTION]XP40. Its effect is to make a dynamic call on a function item that is present as an entry in a map, passing that map implicitly as the first argument. It thus mimics method invocation in object-oriented languages, though there is no inheritance or encapsulation.
The following code builds a simple tree and calculates its depth:
let $tree := my:binary-tree(
my:binary-tree((), 17, ()),
18,
my:binary-tree((), 19,
my:binary-tree((), 20, ())))
return $tree =?> depth()Returning the result 3.