XSLT 2.0 and XPath 2.0 Programmer's Reference, 4th Edition (259 page)

Nevertheless, the

instruction has a useful role to play. If you really do want to create a text node—in particular, if you are creating the content of an element—then

is the right way to do it.

The following example shows the correct use of

to create the content of new element nodes:

The new XSLT 2.0 option to use the sequence constructor to obtain the value, rather than the
select
attribute, is provided mainly to make

compatible with other instructions such as

and

. But there are some cases where it can be very useful. Consider the following:

Without the outer

element, the body of this function would create three text nodes, and this would cause a type error, because a sequence of three text nodes cannot be converted to the declared return type of the function,
xs:string
. The effect of the outer

instruction is to concatenate the three text nodes into one, and a single text node can be converted to a string, so the function succeeds. In effect, the

instruction is doing the same thing at the XSLT level as the
concat()
function does at the XPath level.

Avoiding Surprises

There are two situations in which

might not give the result you expect.

The first should be less common with XSLT 2.0 than it was with 1.0, but it will still happen in stylesheets that specify
version=“1.0”
and thus invoke backward-compatibility mode. The surprise is that only the first item in a sequence is actually output. For example, if the context node is a

element and you specify

, only the first author (in document order) will actually be output. This changes when you specify
version=“2.0”
: all the authors are now output, using a single space as the default separator.

Of course, if you have become accustomed to the 1.0 behavior, then the surprise might be the other way around. If your stylesheet specifies

, then when you change it to say
version=“2.0”
, the output will contain all the following sibling paragraphs rather than just the first. You can easily correct this by changing it to

.

The second situation that sometimes causes surprise is typified by the question “Why have all the tags disappeared?” If you use

to output an element such as a

element that contains complex or mixed content, then it will extract the value of this element as a string. If there are nested elements, for example elements marked up by tags such as

or

, then these are lost in the course of converting to a string. If you want these tags to appear in the output, then use

to copy the element, not

.

This situation may also change in XSLT 2.0 if you use a schema-aware processor. If the
select
expression selects an element, and the element is described in the schema as having complex element-only content, then atomization will raise a runtime error. For example if the source document contains the element:

then with a processor that is not schema-aware (or an XSLT 1.0 processor), the instruction

will produce the output:

But with a schema-aware processor, assuming the schema declaration is:

the result will be a runtime error. If you want to concatenate the text nodes within the

element, then you can still do so, by writing

, but it's not something that atomization will do automatically for you. This is because, for data-oriented XML, it doesn't usually make sense.

With mixed content, however (where text and marked-up elements can be freely mixed in the content), it does make sense to extract the textual content without the markup, and

will do this whether or not there is a schema. Mixed content is described in the schema using

.

Examples

The table below shows some common ways in which

is used.