<xsl:stylesheet version="2.0"
 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
 xmlns:xs="http://www.w3.org/2001/XMLSchema"
 xmlns:xdt="http://www.w3.org/2005/02/xpath-datatypes" 
 xmlns:f="http://fxsl.sf.net/"
 exclude-result-prefixes="xs xdt f"
>

 <xsl:import href="func-curry.xsl"/>
 <xsl:import href="func-compose-flist.xsl"/>
 
<!--
       This module contains the FXSL versions of the "standard"                
       XPath constructors.                                                     
-->

<!--
       Numeric constructors: decimal(), integer(), double(), float()           
-->

   <f:decimal/>

 <xsl:template match="f:decimal" mode="f:FXSL">
   <xsl:param name="arg1" as="xdt:anyAtomicType?"/>
   
   <xsl:sequence select="f:decimal($arg1)"/>
 </xsl:template>
 
 <xsl:function name="f:decimal" as="node()">
   
   <xsl:sequence select="document('')/*/f:decimal[1]"/>
 </xsl:function>
 

 <xsl:function name="f:decimal" as="xs:decimal?">
   <xsl:param name="arg1" as="xdt:anyAtomicType?"/>
   
   <xsl:sequence select="xs:decimal($arg1)"/>
 </xsl:function>
 
   <f:integer/>

 <xsl:template match="f:integer" mode="f:FXSL">
   <xsl:param name="arg1" as="xdt:anyAtomicType?"/>
   
   <xsl:sequence select="f:integer($arg1)"/>
 </xsl:template>
 
 <xsl:function name="f:integer" as="node()">
   
   <xsl:sequence select="document('')/*/f:integer[1]"/>
 </xsl:function>
 

 <xsl:function name="f:integer" as="xs:integer?">
   <xsl:param name="arg1" as="xdt:anyAtomicType?"/>
   
   <xsl:sequence select="xs:integer($arg1)"/>
 </xsl:function>
 
   <f:double/>

 <xsl:template match="f:double" mode="f:FXSL">
   <xsl:param name="arg1" as="xdt:anyAtomicType?"/>
   
   <xsl:sequence select="f:double($arg1)"/>
 </xsl:template>
 
 <xsl:function name="f:double" as="node()">
   
   <xsl:sequence select="document('')/*/f:double[1]"/>
 </xsl:function>
 

 <xsl:function name="f:double" as="xs:double?">
   <xsl:param name="arg1" as="xdt:anyAtomicType?"/>
   
   <xsl:sequence select="xs:double($arg1)"/>
 </xsl:function>
 
   <f:float/>

 <xsl:template match="f:float" mode="f:FXSL">
   <xsl:param name="arg1" as="xdt:anyAtomicType?"/>
   
   <xsl:sequence select="f:float($arg1)"/>
 </xsl:template>
 
 <xsl:function name="f:float" as="node()">
   
   <xsl:sequence select="document('')/*/f:float[1]"/>
 </xsl:function>
 

 <xsl:function name="f:float" as="xs:float?">
   <xsl:param name="arg1" as="xdt:anyAtomicType?"/>
   
   <xsl:sequence select="xs:float($arg1)"/>
 </xsl:function>
 
   <f:nonPositiveInteger/>

 <xsl:template match="f:nonPositiveInteger" mode="f:FXSL">
   <xsl:param name="arg1" as="xdt:anyAtomicType?"/>
   
   <xsl:sequence select="f:nonPositiveInteger($arg1)"/>
 </xsl:template>
 
 <xsl:function name="f:nonPositiveInteger" as="node()">
   
   <xsl:sequence select="document('')/*/f:nonPositiveInteger[1]"/>
 </xsl:function>
 

 <xsl:function name="f:nonPositiveInteger" as="xs:nonPositiveInteger?">
   <xsl:param name="arg1" as="xdt:anyAtomicType?"/>
   
   <xsl:sequence select="xs:nonPositiveInteger($arg1)"/>
 </xsl:function>
 
   <f:negativeInteger/>

 <xsl:template match="f:negativeInteger" mode="f:FXSL">
   <xsl:param name="arg1" as="xdt:anyAtomicType?"/>
   
   <xsl:sequence select="f:negativeInteger($arg1)"/>
 </xsl:template>
 
 <xsl:function name="f:negativeInteger" as="node()">
   
   <xsl:sequence select="document('')/*/f:negativeInteger[1]"/>
 </xsl:function>
 

 <xsl:function name="f:negativeInteger" as="xs:negativeInteger?">
   <xsl:param name="arg1" as="xdt:anyAtomicType?"/>
   
   <xsl:sequence select="xs:negativeInteger($arg1)"/>
 </xsl:function>
 
   <f:nonNegativeInteger/>

 <xsl:template match="f:nonNegativeInteger" mode="f:FXSL">
   <xsl:param name="arg1" as="xdt:anyAtomicType?"/>
   
   <xsl:sequence select="f:nonNegativeInteger($arg1)"/>
 </xsl:template>
 
 <xsl:function name="f:nonNegativeInteger" as="node()">
   
   <xsl:sequence select="document('')/*/f:nonNegativeInteger[1]"/>
 </xsl:function>
 

 <xsl:function name="f:nonNegativeInteger" as="xs:nonNegativeInteger?">
   <xsl:param name="arg1" as="xdt:anyAtomicType?"/>
   
   <xsl:sequence select="xs:nonNegativeInteger($arg1)"/>
 </xsl:function>

    <f:positiveInteger/>

 <xsl:template match="f:positiveInteger" mode="f:FXSL">
   <xsl:param name="arg1" as="xdt:anyAtomicType?"/>
   
   <xsl:sequence select="f:positiveInteger($arg1)"/>
 </xsl:template>
 
 <xsl:function name="f:positiveInteger" as="node()">
   
   <xsl:sequence select="document('')/*/f:positiveInteger[1]"/>
 </xsl:function>
 

 <xsl:function name="f:positiveInteger" as="xs:positiveInteger?">
   <xsl:param name="arg1" as="xdt:anyAtomicType?"/>
   
   <xsl:sequence select="xs:positiveInteger($arg1)"/>
 </xsl:function>
 
    <f:long/>

 <xsl:template match="f:long" mode="f:FXSL">
   <xsl:param name="arg1" as="xdt:anyAtomicType?"/>
   
   <xsl:sequence select="f:long($arg1)"/>
 </xsl:template>
 
 <xsl:function name="f:long" as="node()">
   
   <xsl:sequence select="document('')/*/f:long[1]"/>
 </xsl:function>
 

 <xsl:function name="f:long" as="xs:long?">
   <xsl:param name="arg1" as="xdt:anyAtomicType?"/>
   
   <xsl:sequence select="xs:long($arg1)"/>
 </xsl:function>
 
    <f:int/>

 <xsl:template match="f:int" mode="f:FXSL">
   <xsl:param name="arg1" as="xdt:anyAtomicType?"/>
   
   <xsl:sequence select="f:int($arg1)"/>
 </xsl:template>
 
 <xsl:function name="f:int" as="node()">
   
   <xsl:sequence select="document('')/*/f:int[1]"/>
 </xsl:function>
 

 <xsl:function name="f:int" as="xs:int?">
   <xsl:param name="arg1" as="xdt:anyAtomicType?"/>
   
   <xsl:sequence select="xs:int($arg1)"/>
 </xsl:function>
 
    <f:short/>

 <xsl:template match="f:short" mode="f:FXSL">
   <xsl:param name="arg1" as="xdt:anyAtomicType?"/>
   
   <xsl:sequence select="f:short($arg1)"/>
 </xsl:template>
 
 <xsl:function name="f:short" as="node()">
   
   <xsl:sequence select="document('')/*/f:short[1]"/>
 </xsl:function>
 

 <xsl:function name="f:short" as="xs:short?">
   <xsl:param name="arg1" as="xdt:anyAtomicType?"/>
   
   <xsl:sequence select="xs:short($arg1)"/>
 </xsl:function>
 
    <f:byte/>

 <xsl:template match="f:byte" mode="f:FXSL">
   <xsl:param name="arg1" as="xdt:anyAtomicType?"/>
   
   <xsl:sequence select="f:byte($arg1)"/>
 </xsl:template>
 
 <xsl:function name="f:byte" as="node()">
   
   <xsl:sequence select="document('')/*/f:byte[1]"/>
 </xsl:function>
 

 <xsl:function name="f:byte" as="xs:byte?">
   <xsl:param name="arg1" as="xdt:anyAtomicType?"/>
   
   <xsl:sequence select="xs:byte($arg1)"/>
 </xsl:function>
 
    <f:unsignedLong/>

 <xsl:template match="f:unsignedLong" mode="f:FXSL">
   <xsl:param name="arg1" as="xdt:anyAtomicType?"/>
   
   <xsl:sequence select="f:unsignedLong($arg1)"/>
 </xsl:template>
 
 <xsl:function name="f:unsignedLong" as="node()">
   
   <xsl:sequence select="document('')/*/f:unsignedLong[1]"/>
 </xsl:function>
 

 <xsl:function name="f:unsignedLong" as="xs:unsignedLong?">
   <xsl:param name="arg1" as="xdt:anyAtomicType?"/>
   
   <xsl:sequence select="xs:unsignedLong($arg1)"/>
 </xsl:function>
 
    <f:unsignedInt/>

 <xsl:template match="f:unsignedInt" mode="f:FXSL">
   <xsl:param name="arg1" as="xdt:anyAtomicType?"/>
   
   <xsl:sequence select="f:unsignedInt($arg1)"/>
 </xsl:template>
 
 <xsl:function name="f:unsignedInt" as="node()">
   
   <xsl:sequence select="document('')/*/f:unsignedInt[1]"/>
 </xsl:function>
 

 <xsl:function name="f:unsignedInt" as="xs:unsignedInt?">
   <xsl:param name="arg1" as="xdt:anyAtomicType?"/>
   
   <xsl:sequence select="xs:unsignedInt($arg1)"/>
 </xsl:function>
 
    <f:unsignedShort/>

 <xsl:template match="f:unsignedShort" mode="f:FXSL">
   <xsl:param name="arg1" as="xdt:anyAtomicType?"/>
   
   <xsl:sequence select="f:unsignedShort($arg1)"/>
 </xsl:template>
 
 <xsl:function name="f:unsignedShort" as="node()">
   
   <xsl:sequence select="document('')/*/f:unsignedShort[1]"/>
 </xsl:function>
 

 <xsl:function name="f:unsignedShort" as="xs:unsignedShort?">
   <xsl:param name="arg1" as="xdt:anyAtomicType?"/>
   
   <xsl:sequence select="xs:unsignedShort($arg1)"/>
 </xsl:function>
 
    <f:unsignedByte/>

 <xsl:template match="f:unsignedByte" mode="f:FXSL">
   <xsl:param name="arg1" as="xdt:anyAtomicType?"/>
   
   <xsl:sequence select="f:unsignedByte($arg1)"/>
 </xsl:template>
 
 <xsl:function name="f:unsignedByte" as="node()">
   
   <xsl:sequence select="document('')/*/f:unsignedByte[1]"/>
 </xsl:function>
 

 <xsl:function name="f:unsignedByte" as="xs:unsignedByte?">
   <xsl:param name="arg1" as="xdt:anyAtomicType?"/>
   
   <xsl:sequence select="xs:unsignedByte($arg1)"/>
 </xsl:function>
 
     
</xsl:stylesheet>