<xsl:variable name="elAS"  as="element()">
    <p><em>Elements</em></p>
</xsl:variable>
Gives  
<xsl:variable name="decAS" select="'3.1519'" as="xs:string"/>
<xsl:variable name="intAS" select="'2'" as="xs:string"/>
<xsl:variable name="boolAS" select="'true'" as="xs:string"/>
<xsl:variable name="bool2AS" select="'1'" as="xs:string"/>
<xsl:variable name="dateAS" select="'2003-06-16'" as="xs:string"/>
<xsl:variable name="ymdAS" select="'P1Y2M3'" as="xs:string"/>
<xsl:variable name="dtdurAS" select="'P3DT10H30M'" as="xs:string"/>
<xsl:variable name="datetimeAS" select="'2003-06-19T08:18:05.2810Z'" as="xs:string"/>
<xsl:variable name="uriAS" select="'http://www.dpawson.co.uk/xsl'" as="xs:string"/>
<xsl:variable name="timeAS" select="'13:29:26.109Z'" as="xs:string"/>
<xsl:variable name="xAS" select="' '" as="xs:string"/>
<xsl:variable name="durAS" select="'P1Y2M3DT10H30M'" as="xs:string"/>
<xsl:variable name="qnameAS" select="'dp:element'" as="xs:string"/>
<xsl:variable name="base64AS" select="'PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4NCg=='" as="xs:string"/>
<xsl:variable name="strAS" select="' A string with lots
  of white space in it    '" as="xs:string"/>
<xsl:variable name="langAS" select="'en-UK'" as="xs:string"/>
<xsl:variable name="nameAS" select="'ident'" as="xs:string"/>
<xsl:variable name="itemAS" select="('ident', 'item', 'list3')" as="item()*"/>
<xsl:variable name="attset" as="attribute()+">
  <xsl:attribute name="x">attval1</xsl:attribute>
  <xsl:attribute name="y">attval2</xsl:attribute>
  <xsl:attribute name="z">attval3</xsl:attribute>    
</xsl:variable>

Using the following value-of statements....

String => decimal - <xsl:value-of select="xs:decimal($decAS)"/> 
String => float -   <xsl:value-of select="xs:float($decAS)"/> 
String => double -   <xsl:value-of select="xs:double($decAS)"/> 
String => integer -   <xsl:value-of select="xs:integer($intAS)"/> 
String => duration -   <xsl:value-of select="xs:duration($durAS)"/> 
String => yearMonthDuration -   <xsl:value-of select="xdt:yearMonthDuration($ymdAS)"/> (note xdt ns) 
String => dayTimeDuration -   <xsl:value-of select="xdt:dayTimeDuration($dtdurAS)"/> (note xdt ns) 
String => dateTime -   <xsl:value-of select="xs:dateTime($datetimeAS)"/> 
String => date -   <xsl:value-of select="xs:date($dateAS)"/> 
String => time -   <xsl:value-of select="xs:time($timeAS)"/> 
String => anyURI -   <xsl:value-of select="xs:anyURI($uriAS)"/> 
String => qname -   <xsl:value-of select="xs:QName($qnameAS)"/> 
String => untyped () -   <xsl:value-of select="xdt:untypedAtomic($qnameAS)"/> 
String => base64Binary -   <xsl:value-of select="xs:base64Binary($base64AS)"/> 

String => boolean -  <xsl:value-of select="xs:boolean($boolAS)"/>(input is true) 
String => boolean -  <xsl:value-of select="xs:boolean($bool2AS)"/> (input is string 1) 
attribute =>String  - [<xsl:value-of select="$attset[1]"/>]


item()*=> String - 
<xsl:for-each select="$itemAS">
 Item  <xsl:value-of select="position()"/> [<xsl:value-of select="."/>]
</xsl:for-each>
Noting that item()* is the new lowest common denominator.

This gives:
String => decimal -
String => float -
String => double -
String => integer -
String => duration -
String => yearMonthDuration - (note xdt ns)
String => dayTimeDuration - (note xdt ns)
String => dateTime -
String => date -
String => time -
String => anyURI -
String => untyped () -
String => base64Binary - <xsl:value-of select="xs:base64Binary($base64AS)"/> Not in
String => boolean - (input is true)
String => boolean - (input is string 1)
attribute =>String - []
item()*=> String -
Item []
Noting that item()* is the new lowest common denominator.

Reduction in verbosity / test on a sequence

One of the additions that I find useful is the ability to test if some piece of source document content is one from a,b,c,d. For instance, in 1.0 to test if an attribute value is a or b or c or d its necessary to write

   <xsl:if test="@attVal = 'a' or @attval='b' ...... ">

With XSLT 2.0 its possible to write

    <xsl:if test="@attVal = ('a','b','c','d')">

Note that this is usable in any test scenario, e.g. xsl:if, xsl:when etc.

Collation W3C

This is novel.. for me. If you need a specific sort sequence, then this is helpful. As an example, I'm using a suite of input data as follows:

<?xml version="1.0" encoding="utf-8" ?>
<doc>
 <word>Hello</word>
 <word>hello</word>
 <word>[hello]</word>
<word>Mword</word>
<word>Nword</word>
<word>Mother</word>
<word>Nato</word>
<word>:Mother</word>
<word>5Mother</word>
<word>ünter</word>
<word>unter</word>
<word>!unter</word>
<word>$unter</word>

</doc>

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
  xmlns:xs="http://www.w3.org/2001/XMLSchema-datatypes" 
  xmlns:my="http://www.dpawson.co.uk/mylang"
  xmlns:saxon="http://saxon.sf.net/"
                version="2.0">

<saxon:collation
    class="mylang"
   name="mylang" 
  default="yes"/>

  <xsl:template match="/">
    <html>
      <head>
        <title>Collation</title>
        <META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=utf-8" />
      </head>
      <body>
        <xsl:apply-templates/>
      </body>
    </html>
  </xsl:template>


  <xsl:template match="doc">
    <p>
      Before:  <br />
 

  <xsl:for-each select="word">
      <xsl:value-of select="."/> <br />
  </xsl:for-each>
</p>
<hr />

  <p>
    <b>After</b> <br />


  <xsl:for-each select="word">
   <xsl:sort select="."  
     data-type="text"
     lang="mylang"
      collation="mylang"/>  
   <xsl:value-of select="."/> <br />
  </xsl:for-each>

</p>

  </xsl:template>

import java.text.Collator;
import java.text.RuleBasedCollator;
import java.text.ParseException;
import java.lang.StringBuffer;
import java.io.FileReader;
import java.io.BufferedReader;


import java.io.Serializable;
import net.sf.saxon.xpath.XPathException;
import net.sf.saxon.om.Item;
import java.io.File;

/**
 *Class mylang. Implements java.util.Comparator as a collator
 *
 *
 *
 *
 ***/
public class mylang implements java.util.Comparator,Serializable {

    public String ruleFileName="collator.txt";
    
    /**
     * Constructor 
     * Inits the rules from the given rules file.
     *
     **/
    public mylang (){
	String rules = getRules(ruleFileName);
    }

    /**
     * Compare two objects.
     * o1 < o2  return -1
     * o1== o2  return 0
     * o1 > o2  return 1
     * @param o1 first object
     * @param o2 second object
     * @return int: -1 less than, 0 equal, +1 gt
     ***/
    public int compare (Object o1, Object o2) {
	int res= 0;
	String s1 ="";
	String s2 = "";
        try {
            s1 = (o1 instanceof String ? (String)o1 : ((Item)o1).getStringValue());
        } catch (XPathException err) {
            throw new ClassCastException("Cannot convert sort key from " + o1.getClass() + " to a string");
        }

   try {
            s2 = (o2 instanceof String ? (String)o2 : ((Item)o2).getStringValue());
        } catch (XPathException err) {
            throw new ClassCastException("Cannot convert sort key from " + o2.getClass() + " to a string");
        }

	RuleBasedCollator collator =  null;
	String rule = getRules(ruleFileName);

	try {
	    collator =  new RuleBasedCollator(rule);}
	catch (ParseException err) {
	    System.out.println("collator error: " +err.getMessage() + "Quitting" );
	    System.exit(2);
	}
	

	return collator.compare(s1,s2);
    }
    /**
     * Compares another collator with this one.
     * @param o1, the collator to be compared with this one.
     * @return boolean, always false. Not implemented.
     *
     **/
    public boolean equals (Object o1) {
	return false;

    }


    /**
     *Read a set of rules into a String
     *@param filename  name of the file containing the rules
     *@return String, the rules
     *
     **/
    private String getRules(String filename) {
	String res="";
	try{
	    BufferedReader reader = 
		new BufferedReader (new FileReader (filename));
	    StringBuffer buf=new StringBuffer();
	    String text;
	    try {
		while ((text=reader.readLine()) != null)
		    buf.append(text + "\n");
		reader.close();
	    }catch (java.io.IOException e) {
		System.err.println("Unable to read from rules file "+ filename);
		System.exit(2);
		
		}
	    res=buf.toString();


	}catch (java.io.FileNotFoundException e) {
	    System.out.println("Unable to read Rules file, quitting");
	    System.exit(2);
	}
	
	return res;
    }// end of getRules()


    /**
     *sort an array of strings according to the collator .
     *@param collator collator to use
     *@param words - words to sort
     *@return null.
     **/
   public static void sortStrings(Collator collator, String[] words) {
       String tmp;
       for (int i = 0; i < words.length; i++) {
           for (int j = i + 1; j < words.length; j++) {
               // Compare elements of the words array
               if( collator.compare(words[i], words[j] ) > 0 ) {
                   // Swap words[i] and words[j] 
                   tmp = words[i];
                   words[i] = words[j];
                   words[j] = tmp;
               }
           }
       }
   }
    /**
     *print an array of strings.
     *src: http://java.sun.com/docs/books/tutorial/i18n/text/rule.html
     *
     *
     **/
   public static void printStrings(String [] words) {
       for (int i = 0; i < words.length; i++) {
          System.out.println(words[i]);
       }
   }
    /**
     *Default entry point for command line testing.
     *
     *
     *
     *
     **/
    public static void main (String [] argv) {
	RuleBasedCollator collator =  null;
	mylang mc = new mylang();
	String rule = mc.getRules(mc.ruleFileName);
	
	System.err.println(rule);
	try {
	    collator =  new RuleBasedCollator(rule);}
	catch (ParseException err) {
	    System.out.println("collator error: " +err.getMessage() );

	}
	String [] words = {
	    "Hello",
	    "hello",
	    ".hello",
	    " hello",
	    "&hello",
	    "Back",
	    "back",
	    "Mother","Not", "4hello",
	    "!Hi",
	    "\u00FCnter",
	    "under",
	    "Under"
	};
	// print before sorting
	System.out.println("Initial Strings\n\t\t");
	mc.printStrings(words);
	mc.sortStrings(collator, words);
	System.out.println("\t\tPost sort");
	mc.printStrings(words);
    }

}

  ' ' ,  ':' ,  ';' ,  '<'  , '=' ,  '>'  , '?' ,  '@', '!',
 '[' ,  '\' ,  ']' ,  '^' ,  '_' ,  '`',
 '{' ,  '|' ,  '}' ,  '~'
 '!' ,  '"' ,  '#' ,  '$' ,  '%' ,  '&',  ''' ,  '(' ,  ')' ,  '*'  , '+'  , ','  , '-' , '.' ,  '/'

< A,a  < B,b  < C,c  < D,d  < E,e  < F,f  < G,g
< H,h  < I,i  < J,j  < K,k  < L,l < N,n   < M,m 
< O,o  < P,p  < Q,q  < R,r  < S,s  < T,t
< U,u < ü  < V,v  < W,w  < X,x  < Y,y  < Z,z

< 0  < 1  < 2  < 3  < 4  < 5  < 6  < 7  < 8  < 9

Before:
Hello
hello
[hello]
Mword
Nword
Mother
Nato
:Mother
5Mother
ünter
unter
!unter
$unter

After
:Mother
Hello
hello
[hello]
Nato
Nword
Mother
Mword
unter
!unter
$unter
ünter
5Mother

Which has sorted, N before M, as required.

Note: As of Aug 03, Saxon uses saxon:collation as follows.

• If class attribute is present, others are ignored.
• The rules attribute is not implemented. More later

Integer Division W3C

Integer division. Produces an int from a pair of ints.

        <xsl:variable name="i1" select="5" as="xs:integer"/>
        <xsl:variable name="i2" select="2" as="xs:integer"/>
    a result of      <xsl:value-of  select="$i1 idiv $i2"/>
      

<doc>

<r>Mateus 3.1-12; Lucas 3.1-20; </r>
<r>words 1.2-12; Name 1.2-30</r>
<r>LongString 1234.3-45; swd 1.2.1-2</r>
</doc>

<?xml version="1.0" encoding="UTF-8"?>
<wrap>


   <canonRef Book="Mateus" chapter="3" verse="1" verseend="12" />
   <canonRef Book="Lucas" chapter="3" verse="1" verseend="20" />

   <canonRef Book="words" chapter="1" verse="2" verseend="12" />
   <canonRef Book="Name" chapter="1" verse="2" verseend="30" />

   <canonRef Book="LongString" chapter="1234" verse="3" verseend="45" />
</wrap>

  <xsl:template match="doc">
    <wrap>
    <xsl:apply-templates/>
  </wrap>
  </xsl:template>
  
<xsl:template match="r">
  <xsl:analyze-string  regex="[^;]+" select=".">
    <xsl:matching-substring>
      <xsl:analyze-string  regex="([A-Za-z]+) *([0-9]+)\.([0-9]+)-([0-9]+)(.*$)" select=".">
        <xsl:matching-substring>
          <canonRef
           Book="{regex-group(1)}"
            chapter="{regex-group(2)}"
            verse="{regex-group(3)}"
            verseend="{regex-group(4)}"  
            />
          </xsl:matching-substring>
        </xsl:analyze-string >
        </xsl:matching-substring>
      </xsl:analyze-string>
      
</xsl:template>

    <xsl:variable name="ls" select="unordered(1 to 3)"/>
    <xsl:for-each select ="$ls">
      <xsl:value-of select="."/> <xsl:text> </xsl:text>
    </xsl:for-each>

      <xsl:template match="ns:elementName" xmlns:ns="somethingOrOther">

<xsl:stylesheet 
  xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
  version="2.0"
   xpath-default-namespace="xyz">

  <xsl:if test="data(.) instance of xs:boolean">
    This node holds some data of type boolean.
  </xsl:if>

<xsl:variable name="de1" select="(1,2,3,4,5)" as="item()*"/>
<xsl:variable name="de2" select="(1,2,3,4,5)" as="item()*"/>

<xsl:value-of select="if (deep-equal($de1,$de2)) then 'equal' else 'not equal'"/>



Gives:  

<xsl:variable name="singular" select="(1)" as="item()*"/>
<xsl:variable name="multiple" select="(1,2,3)" as="item()*"/>

<xsl:if test="exactly-one($singular)">
Singular has exactly one item.
</xsl:if>

yet I get an error with 

<xsl:if test="exactly-one($multiple)">
Singular has exactly one item.
</xsl:if>

<xsl:variable name="val" select="1356" as="xs:integer"/>
<xsl:number value="$val" format="w"/>

<xsl:variable name="seq" select="(1, 3, 5)" />

<xsl:number value="$seq" format="A I w"/>

  <xsl:template name="recurse">
    <xsl:param name="ns"/>    
... test for exit condition
... if more
    <xsl:call-template name="recurse">
      <xsl:with-param name="ns" select="remove($ns,1"/>
    </xsl:call-template>

  </xsl:template>

 $a= 1,2,3   
 $b= 2,3,5
 
 $a minus $b = 1
 $a differences to $b = 1,5

($a union $b) except ($a intersection $b)

($a except $b) union ($b except $a)

<xsl:value-of select="if (doc-available('newfile.xml')) then
'File newfile.xml exists, and is XML' else 'File not found'"/>

gives



since the file exists.

<xsl:value-of select="document-uri(.)"/> gives 

<xsl:value-of select="prefix-from-QName(node-name(/d:doc))"/> gives 

 <xsl:value-of select="QName('http://www.dpawson.co.uk/ns#','dp:doc')"/> gives 

<xsl:value-of select="in-scope-prefixes(/xsl:stylesheet)"/>

<xsl:value-of select="if (lang('en',/xsl:stylesheet)) then 'English' else 'not English'"/> gives: