Many built-in functions and predicates described below are adapted from [XPath-Functions] and, when appropriate, we will refer to the definitions in that specification in order to avoid copying them.

RIF defines guard predicates for all datatypes in Section Primitive Datatypes.

• Schema: The schemas for these predicates have the general form

  (?arg₁; pred:isDATATYPE (?arg₁ ) )

  Here, DATATYPE is the short name for a datatype. As a naming convention we use the capitalized non-prefix XML local name part of the IRI denoting the datatype, for instance we use pred:isString for the guard predicate for xs:string, or pred:isText for the guard predicate for rif:text. Parties defining their own datatypes to be used in RIF exchanged rules may define their own guard predicates for these datatypes. Labels used for such additional guard predicates for datatypes not mentioned in the present document MAY follow the samea similar naming convention where applicable without creating ambiguities with predicate names defined in the present document. Particularly, upcoming W3C specifications MAY - but 3rd party dialects MUST NOT - reuse the pred: namespace for such guard predicates.

  Editor's Note: The naming conventionformulation of the clause on namespace-reuse is under discussion, for guard predicates, particularlyinstance, whether third parties defining their ownwe shall allow guards and negative guards for all of the XML Schema primitive datatypes should be encouraged/discouraged to reuseunder the standardpred: and func: namespaces to define their own built-in predicates and functions, are still under discussion in the working group. Intended domain : Guardnamespace.

• Intended domain:

  Guard predicates do not depend on a specific intended domain.

• Mapping:

  I_truth I_external(?arg₁; pred:isDATATYPE (?arg₁ ) )(s₁) = t if and only if s₁ is in the value space of DATATYPE and f otherwise.

Accordingly, the following schemas are defined.

Likewise, RIF defines negative guard predicates for all datatypes in Section Primitive Datatypes.

• Schema: The schemas for negative guards have the general form

  (?arg₁; pred:isNotDATATYPE (?arg₁ ) )

  Here, DATATYPE is the short name for one of the datatypes mentioned in this document. As a naming convention we use the capitalized non-prefix XML local name part of the IRI denoting the datatype, for instance we use pred:isNotString for the negative guard predicate for xs:string, or pred:isNotText for the negative guard predicate for rif:text. Parties defining their own datatypes to be used in RIF exchanged rules may define their own negative guard predicates for these datatypes. Labels used for such additional negative guard predicates for datatypes not mentioned in the present document MAY follow the samea similar naming convention where applicable without creating ambiguities with predicate names defined in the present document. Editor's Note:Particularly, upcoming W3C specifications MAY, but 3rd party dialects MUST NOT reuse, the naming conventionpred: namespace for such negative guard predicates, particularly whether third parties defining their own datatypes should be encouraged/discouraged to reusepredicates.

  
  

  Editor's Note: The standard pred: and func: namespaces to define their own built-in predicatesformulation of the clause on namespace-reuse is under discussion, for instance, whether we shall allow guards and functions, are stillnegative guards for all of the XML Schema primitive datatypes under discussion inthe working group.pred: namespace.

• Intended domain:

  Negative guard predicates do not depend on a specific intended domain.

• Mapping:

  I_truth I_external(?arg₁; pred:isNotDATATYPE (?arg₁ ) )(s₁) = f if and only if s₁ is in the value space of DATATYPE and t otherwise.

Accordingly, the following schemas are defined.

In the following, we adapt several cast functions fromaccording to the conversions defined in Section 17.1 of [XPath-Functions]. Note that some of these conversions are only partially defined, which affects the intended domains of these cast functions.

Editor's Note: Due to the subtle differences in e.g.casting, e.g., concerning error handlinghandling, between RIF and [XPath-Functions], thesethe definitions of cast functions might still need refinement in terms of defining the intended domains in future versions of this draft. Also, the definition of the mappings need refinement.

Likewise we define a conversion predicate useful for converting between rif:iri constants and strings, as well as a predicate to check the datatype of a constant.

• , xs:integer , xs:decimal , xs:time , xs:date , xs:date , xs:dateTime , xs:dayTimeDuration , xs:yearMonthDuration SchemataSchema:

  (?arg₁; xs:double (?arg₁ ) )

• (?arg 1 ; xs:integer (?arg 1 ) ) and accordingly for all subtypes of xs:integer (?arg 1 ; xs:decimal (?arg 1 ) ) (?arg 1 ; xs:time (?arg 1 ) ) (?arg 1 ; xs:date (?arg 1 ) ) (?arg 1 ; xs:dateTime (?arg 1 ) ) (?arg 1 ; xs:dayTimeDuration (?arg 1 ) ) (?arg 1 ; xs:yearMonthDuration (?arg 1 ) )Intended domainsdomain:

  The union of the (subsets of the) value spaces of datatypes castable to xs: DATATYPExs:double according to Section 17.1 of [XPath-Functions].

• Mappings:Mapping:

  I_external(?arg₁; xs: DATATYPExs:double (?arg₁ ) )(s₁) = s₁' such that s₁' is the conversion of s₁ to the value space of xs: DATATYPExs:double according to Section 17.1 of [XPath-Functions].

  Note that these conversions are only partial and note further that the subtypes of xs:integer do appear in the conversion table. Conversions from and to subtypes of xs:integer follow the same considerations as xs:integer in that table, by the XPath, XQuery type hierarchy in Section 1.6 of [ XPath-Functions ].If the argument value is outside of the intended domain or outside the partial conversions defined in [XPath-Functions], the value of the function is left unspecified and can vary from one semantic structure to another.

• Schema:

  (?arg₁; xs:stringxs:integer (?arg₁ ) )

• Intended domain:

  The union of the value space(subsets of rif:text with thethe) value spaces of datatypes castable to xs:stringxs:integer according to the table inSection 17.1 of [XPath-Functions].

• Mapping:

  I_external(?arg₁; xs: DATATYPExs:integer (?arg₁ ) )(s₁) = s₁' such that s₁' is the conversion of s₁ to the value space of xs: stringxs:integer according to the table inSection 17.1 of [XPath-Functions ], in case s 1 is in].

  If the argument value spaceis outside of a datatype mentioned in that table. by preservingthe lexical value of its string part, if s 1 isintended domain or outside the partial conversions defined in [XPath-Functions], the value spaceof rif:text . Ifthe argument is outside the intended domain, the value of the functionfunction is left unspecified and can vary from one semantic structure to another.

• Schema:

  (?arg₁; rdf:XMLLiteralxs:decimal (?arg₁ ) )

• Intended domain:

  The intersectionunion of the value space(subsets of xs:string with the lexical spacethe) value spaces of rdf:XMLLiteral , i.e. an xs:string can be castdatatypes castable to rdf:XMLLiteral if and only if its value is in the lexical spacexs:decimal according to Section 17.1 of rdf:XMLLiteral as defined in Resource Description Framework (RDF): Concepts and Abstract Syntax[XPath-Functions].

• Mapping:

  I_external(?arg₁; xs: DATATYPExs:decimal (?arg₁ ) )(s₁) = s₁' such that s₁' is the XMLLiteral corresponding to the given stringconversion of s₁ .to the value space of xs:decimal according to Section 17.1 of [XPath-Functions].

  If the argument value is outside of the intended domain,domain or outside the partial conversions defined in [XPath-Functions], the value of the function is left unspecified and can vary from one semantic structure to another.

• Schema:

  (?arg₁; rif:textxs:time (?arg₁ ?arg 2) )

• Intended domainsdomain:

  The value spaceunion of xs:string for ?arg 1 andthe intersection(subsets of thethe) value spacespaces of datatypes castable to xs:time according to Section 17.1 of xs:string with all Unicode character sequences which are language identifiers as defined by[ BCP-47 ] for ?arg 2 .XPath-Functions].

• Mapping:

  I_external(?arg₁; rif:textxs:time (?arg₁ ?arg 2) )(s₁ s 2) = s' wheres₁ is a Unicode string and' such that s _{2 is a Unicode character sequence which is language as defined by [ BCP-47 ]. Then s'1}' is defined exactly asthe pair (sconversion of s₁ , lowercase(s 2 )).to the value space of xs:time according to Section 17.1 of [XPath-Functions].

  If the argument values arevalue is outside of the intended domains,domain or outside the partial conversions defined in [XPath-Functions], the value of the function is left unspecified and can vary from one semantic structure to another.

• Schema:

  (?arg₁; pred:iri-to-stringxs:date (?arg₁ ,?arg 2) )

• Intended domainsdomain:

  The first argument is not restricted by a specific domain, the second argument isunion of the (subsets of the) value spacespaces of xs:string .datatypes castable to xs:date according to Section 17.1 of [XPath-Functions].

• Mapping:

  I_external(?arg₁ ?arg 2; pred:iri-to-stringxs:date (?arg₁ ?arg 2) )(iri 1 str)(s₁) = t if and only if str 1 is an element in the lexical space of rif:iri and iris₁ is an element of the domain' such that I ( " str 1 "^^rif:iri ) = iris₁ holds in the current interpretation. Note that this definition restricts allowed RIF interpretations in such a way that' is the interpretationconversion of pred:iri-to-string always needs to comply with respects₁ to the symbols in the rif:iri symbolvalue space forof xs:date according to Section 17.1 of [XPath-Functions].

  If the firstargument and elementsvalue is outside of the xs:string value space forintended domain or outside the second argument.partial conversions defined in [XPath-Functions], the truthvalue of the predicatefunction is left unspecified for other elements of the domainand can vary from one semantic structure to another.

• Schema:

  (?arg₁ ?arg 2; func:numeric-add(?argxs:dateTime (?arg₁ ?arg 2 ))) )

• Intended domainsdomain:

  The union of the (subsets of the) value spaces of xs:integer , xs:double , or xs:decimal for both arguments.datatypes castable to xs:dateTime according to Section 17.1 of [XPath-Functions].

• Mapping:

  When bothI_external(?arg₁; xs:dateTime (?arg₁ ) )(s₁) = s₁ and' such that s _{2 belong to their intended domains, External(func:numeric-add(s1}' is the conversion of s _{2 )) evaluates1} to the resultvalue space of xs:dateTime according to Section 17.1 of op:numeric-add (s 1 , s 2 ) as defined in[XPath-Functions].

  If anthe argument value is outside of the intended domain,domain or outside the partial conversions defined in [XPath-Functions], the value of the function is left unspecified and can vary from one semantic structure to another.

• Schema:

  (?arg₁ ?arg 2; func:numeric-subtract(?argxs:dayTimeDuration (?arg₁ ?arg 2) )

• 3.4.1.3 func:numeric-multiply (adapted from op:numeric-multiply ) SchemaIntended domain:

  The union of the (subsets of the) value spaces of datatypes castable to xs:dayTimeDuration according to Section 17.1 of [XPath-Functions].

• Mapping:

  I_external(?arg₁ ?arg 2; func:numeric-multiply(?argxs:dayTimeDuration (?arg₁ ?arg 2 )) 3.4.1.4 func:numeric-divide (adapted from op:numeric-divide)(s₁) Schema : (?arg= s₁ ?arg 2 ; func:numeric-divide(?arg' such that s₁ ?arg 2 ) ) Intended domains :' is the value spacesconversion of xs:integer , xs:double , or xs:decimal for the first argument and xs:integer , xs:double , or xs:decimal without zero for the second argument. Mapping : This function backs up the "div" operator and returnss₁ to the arithmetic quotientvalue space of its operandsxs:dayTimeDuration according to Section 17.1 of [XPath-Functions].

  If anthe argument value is outside of the intended domain,domain or outside the partial conversions defined in [XPath-Functions], the value of the function is left unspecified and can vary from one semantic structure to another, which here particularly means that RIF does not prescribe the behavior on division by zero. 3.4.1.5 func:numeric-integer-divide (adapted from op:numeric-integer-divide )another.

• Schema:

  (?arg₁ ?arg 2; func:numeric-integer-divide(?argxs:yearMonthDuration (?arg₁ ?arg 2) )

• Intended domainsdomain:

  The union of the (subsets of the) value spaces of xs:integer , xs:double , or xs:decimal for the first argument and xs:integer , xs:double , or xs:decimal without zero for the second argument. Mapping : This function backs up the "idiv" operator and performs an integer division:datatypes castable to xs:yearMonthDuration according to Section 17.1 of [XPath-Functions].

• Mapping:

  I_external(?arg₁; xs:yearMonthDuration (?arg₁ ) )(s₁) = s₁' such that is, it divides the first argument by the second, and returns the integer obtained by truncatings₁' is the fractional partconversion of s₁ to the result.value space of xs:yearMonthDuration according to Section 17.1 of [XPath-Functions].

  If anthe argument value is outside of the intended domain,domain or outside the partial conversions defined in [XPath-Functions], the value of the function is left unspecified and can vary from one semantic structure to another, which here particularly means that RIF does not prescribe the behavior on division by zero. 3.4.1.6 func:numeric-mod (adapted from op:numeric-mod )another.

• Schema:

  (?arg₁ ?arg 2; func:numeric-mod(?argxs:string (?arg₁ ?arg 2) )

• Intended domainsdomain:

  The union of the value spaces of xs:integer , xs:double , or xs:decimal fordatatypes castable to xs:string according to Section 17.1 of [XPath-Functions].

• Mapping:

  I_external(?arg₁; xs:string> (?arg₁ ) )(s₁) = s₁' such that s₁' is the first argument and xs:integer , xs:double , or xs:decimal without zero forconversion of s₁ to the second argument. Mapping : Backs upvalue space of xs:string according to the "mod" operator.table in Section 17.1 of [XPath-Functions], in case s₁ is in the value space of a datatype mentioned in that table.

  If anthe argument valueis outside ofthe intended domain, the value of the function is left unspecified and can vary from one semantic structure to another, which here particularly means thatanother.

Note: Since RIF does not prescribe the behavior if the second argument is zero. 3.4.2 Numeric Predicates 3.4.2.1 pred:numeric-equal (adapted from op:numeric-equal ) Schema : (?arg 1 ?arg 2 ; pred:numeric-equal(?argimplementations MAY choose to interpret xs:string and its subtypes as subtypes of rdf:text following Section 3.1 of [RDF-TEXT], in such implementations this cast function also serves for conversions to rdf:text.

• Schema:

  (?arg₁ ?arg 2 )); rdf:XMLLiteral (?arg₁ ) )

• Intended domainsdomain:

  The intersection of the value spacesspace of xs:integer , xs:doublexs:string with the lexical space of rdf:XMLLiteral, or xs:decimal for both arguments. Mapping: When both s 1 and s 2 belongi.e. an xs:string can be cast to their intended domains, External(pred:numeric-equal(s 1 s 2 )) is trdf:XMLLiteral if and only if op:numeric-equal (s 1 , s 2 ) returns true ,its value is in the lexical space of rdf:XMLLiteral as defined in [ XPath-Functions ].Resource Description Framework (RDF): Concepts and Abstract Syntax

• Mapping:

  I_external(?arg₁; xs:XMLLiteral (?arg₁ ) )(s₁) = s₁' such that s₁' is the XMLLiteral corresponding to the given string s₁.

  If anthe argument value is outside of the intended domain, the truthvalue of the function is left unspecified and can vary from one semantic structure to another.

• Schema:

  (?arg₁?arg₂; pred:iri-string (?arg₁,?arg₂ ) )

• Intended domain as pred:numeric-equal and is true whenever pred:numeric-equal is false.domains:

  The predicates pred:numeric-less-than-or-equal (and pred:numeric-greater-than-or-equal , respectively) are true whenever pred:numeric-equalfirst argument is true or pred:numeric-less-than ( pred:numeric-greater-than-or-equal , respectively)not restricted by a specific domain, the second argument is true. 3.4.2.2 pred:numeric-less-than (adapted from op:numeric-less-than ) Schema : (?arg 1 ?arg 2 ; pred:numeric-less-than(?arg 1 ?arg 2 ) ) 3.4.2.3 pred:numeric-greater-than (adapted from op:numeric-greater-than ) Schema : (?arg 1 ?arg 2 ; pred:numeric-greater-than(?arg 1 ?arg 2 ) ) 3.4.2.4 pred:numeric-not-equal Schema :the value space of xs:string.

• Mapping:

  I_external(?arg₁?arg₂; pred:numeric-not-equal(?arg 1 ?arg 2 ) ) 3.4.2.5 pred:numeric-less-than-or-equal Schema :pred:iri-string (?arg₁?arg₂ ; pred:numeric-less-than-or-equal(?arg 1 ?arg 2) ) 3.4.2.6 pred:numeric-greater-than-or-equal Schema : (?arg)(iri₁ ?arg 2 ; pred:numeric-greater-than-or-equal(?argstr₁ ?arg 2) ) 3.5 Functions and Predicates on Strings The following functions and predicates are adapted from the respective functions= t if and operators on stringsonly if str₁ is a string in [ XPath-Functions ]. Editor's Note:the following treatmentlexical space of built-ins which may have multiple aritiesrif:iri and iri₁ is a strawman proposal currently under discussionan element of the domain such that I( "str₁"^^rif:iri ) = iri₁ holds in the working group.current interpretation.

  Note that this definition restricts allowed RIF interpretations in such a way that the following, we encounter several versionsinterpretation of some built-inspred:iri-string always needs to comply with varying arity, since XPath and XQuery allow overloading, i.e.respect to the same function or operator name occurring with different arities. We treat this likewisesymbols in RIF, by numberingthe different versions ofrif:iri symbol space for the respective built-insfirst argument and treatingelements of the unnumbered version as syntactic sugar, i.e. for instancexs:string value space for the second argument. The truth value of the predicate is left unspecified for other elements of the domain and can vary from one semantic structure to another.

  This predicate could be usable for instance to map telephone numbers between an RDF Format for vCard (http://www.w3.org/TR/vcard-rdf) and FOAF (http://xmlns.com/foaf/0.1/). vCard stores telephone numbers as string literals, whereas FOAF uses resources, i.e., URIs with the tel: URI-scheme. So, a mapping from FOAF to vCard would need to convert the tel: URI to a string and then cut off the first four characters ("tel:"). Such a mapping expressed in RIF could involve e.g. a rule as follows:

    ...
    Prefix( VCard http://www.w3.org/TR/vcard-rdf#)
    Prefix( foaf http://xmlns.com/foaf/0.1/)
    ...
    Forall?X?foafTelIri?foafTelString (
     ?X[ VCard:tel -> External( func:substring(?foafTelString 4 ) ]:- 
            And (?X[ foaf:phone ->?foafTelIri ]
                  External( pred:iri-string(?foafTelIri?foafTelString  ) ) )
  

Extractions of the Datatype from a constant cannot be defined by a function (like for instance in SPARQL's datatype function) since the value spaces of datatypes may overlap.

To this end, we introduce a built-in predicate which supports extraction of the datatypes for a constant at hand.

• Schema:

  (?arg₁?arg₂; pred:hasDatatype (?arg₁,?arg₂ ) )

• Intended domains:

  None of the arguments is restricted to a specific domain.

• Mapping:

  I_external(?arg₁?arg₂; pred:hasDatatype (?arg₁?arg₂ ) )(const₁ iri₁) = t if and only if in the current interpretation iri₁ = I( "DatatypeIRI"^^rif:iri ) where DatatypeIRI is the IRI identifier of a datatype d and const₁ is in the value space of d.

Editor's Note: It is still under discussion in the WG whether this predicate should restrict the domain of the second argument rather to strings that represent valid IRIs than just being true for any constants that have the same interpretation as the particular rif:iri representing the datatype.

This predicate can be usable for extracting the datatype from a constant but due to the overlap of the calue spaces of datatypes, such extraction is not necessarily unique; for example, the following is entailed in any RIF ruleset:

  And ( External( pred:hasDatatype( "1.0"^^xs:decimal xs:decimal ) )
        External( pred:hasDatatype( "1.0"^^xs:decimal xs:integer ) )
        External( pred:hasDatatype( "1.0"^^xs:decimal xs:double  ) ) )

Editor's Note: Note that this example shows that pred:hasDatatype is not adequate for emulating SPARQL's datatype function http://www.w3.org/TR/rdf-sparql-query/#func-datatype, cf. the mail thread starting at http://lists.w3.org/Archives/Public/public-rif-wg/2008Nov/0067.html

The following example shows that also whether or not a RIF implementation that treats xs:string as a subtype of rdf:text may affect the entailments for pred:hasDatatype:

  Forall?X (
   ?P [ ex:nameType ->?D ]:-  
          And (?P[ foaf:name ->?N ]
                External( pred:hasDatatype(?N?D ) ) )
  ex:alice [foaf:name -> "Alice"]

In a RIF implementation that treats xs:string as a subtype of rdf:text, following Section 3.1 of [RDF-TEXT], this ruleset would entail both ex:alice [ex:nameType -> rdf:text] and ex:alice [ex:nameType -> xs:string].

Editor's Note: Whether or not we allow the treatment of xs:string as a subtype of rdf:text in RIF implementations is still under discussion, cf. the mail thread starting at http://lists.w3.org/Archives/Public/public-rif-wg/2008Nov/0067.html.

The following functions and predicates are adapted from the respective numeric functions and operators in [XPath-Functions].

3.4.1.1 func:numeric-add (adapted from op:numeric-add)

• Schema:

  (?arg₁?arg₂; func:numeric-add(?arg₁?arg₂))

• Intended domains:

  The value spaces of xs:integer, xs:double, or xs:decimal for both arguments.

• Mapping:

  When both s₁ and s₂ belong to their intended domains, External(func:numeric-add(s₁ s₂)) evaluates to the result of op:numeric-add(s₁, s₂) as defined in [XPath-Functions].

  If an argument value is outside of the intended domain, the value of the function is left unspecified and can vary from one semantic structure to another.

The following numeric built-in functions func:numeric-subtract, func:numeric-multiply, func:numeric-divide, func:numeric-integer-divide, and func:numeric-mod are defined accordingly with respect to their corresponding operators in [XPath-Functions] and we will only add further explanations where needed.

3.4.1.2 func:numeric-subtract (adapted from op:numeric-subtract)

• Schema:

  (?arg₁?arg₂; func:numeric-subtract(?arg₁?arg₂) )

3.4.1.3 func:numeric-multiply (adapted from op:numeric-multiply)

• Schema:

  (?arg₁?arg₂; func:numeric-multiply(?arg₁?arg₂) )

3.4.1.4 func:numeric-divide (adapted from op:numeric-divide)

• Schema:

  (?arg₁?arg₂; func:numeric-divide(?arg₁?arg₂) )

• Intended domains:

  The value spaces of xs:integer, xs:double, or xs:decimal for the first argument and xs:integer, xs:double, or xs:decimal without zero for the second argument.

• Mapping:

  This function backs up the "div" operator and returns the arithmetic quotient of its operands

  If an argument value is outside of the intended domain, the value of the function is left unspecified and can vary from one semantic structure to another, which here particularly means that RIF does not prescribe the behavior on division by zero.

3.4.1.5 func:numeric-integer-divide (adapted from op:numeric-integer-divide)

• Schema:

  (?arg₁?arg₂; func:numeric-integer-divide(?arg₁?arg₂) )

• Intended domains:

  The value spaces of xs:integer, xs:double, or xs:decimal for the first argument and xs:integer, xs:double, or xs:decimal without zero for the second argument.

• Mapping:

  This function backs up the "idiv" operator and performs an integer division: that is, it divides the first argument by the second, and returns the integer obtained by truncating the fractional part of the result.

  If an argument value is outside of the intended domain, the value of the function is left unspecified and can vary from one semantic structure to another, which here particularly means that RIF does not prescribe the behavior on division by zero.

3.4.1.6 func:numeric-mod (adapted from op:numeric-mod)

• Schema:

  (?arg₁?arg₂; func:numeric-mod(?arg₁?arg₂) )

• Intended domains:

  The value spaces of xs:integer, xs:double, or xs:decimal for the first argument and xs:integer, xs:double, or xs:decimal without zero for the second argument.

• Mapping:

  Backs up the "mod" operator.

  If an argument value is outside of the intended domain, the value of the function is left unspecified and can vary from one semantic structure to another, which here particularly means that RIF does not prescribe the behavior if the second argument is zero.

3.4.2.1 pred:numeric-equal (adapted from op:numeric-equal)

• Schema:

  (?arg₁?arg₂; pred:numeric-equal(?arg₁?arg₂))

• Intended domains:

  The value spaces of xs:integer, xs:double, or xs:decimal for both arguments.

• Mapping:

  When both s₁ and s₂ belong to their intended domains, External(pred:numeric-equal(s₁ s₂)) is t if and only if op:numeric-equal(s₁, s₂) returns true, as defined in [XPath-Functions].

  If an argument value is outside of the intended domain, the truth value of the function is left unspecified and can vary from one semantic structure to another.

The following numeric built-in predicates pred:numeric-less-than and pred:numeric-greater-than are defined accordingly with respect to their corresponding operators in [XPath-Functions].

3.4.2.2 pred:numeric-less-than (adapted from op:numeric-less-than)

• Schema:

  (?arg₁?arg₂; pred:numeric-less-than(?arg₁?arg₂) )

3.4.2.3 pred:numeric-greater-than (adapted from op:numeric-greater-than)

• Schema:

  (?arg₁?arg₂; pred:numeric-greater-than(?arg₁?arg₂) )

The following functions and predicates are adapted from the respective functions and operators on strings in [XPath-Functions].

Editor's Note: The following treatment of built-ins which may have multiple arities is a strawman proposal currently under discussion in the working group.

In the following, we encounter several versions of some built-ins with varying arity, since XPath and XQuery allow overloading, i.e. the same function or operator name occurring with different arities. We treat this likewise in RIF, by numbering the different versions of the respective built-ins and treating the unnumbered version as syntactic sugar, i.e. for instance instead of External( func:concat2( strExternal( func:concat2( str₁, str₂) ) and External( func:concat3( str₁ str₂ str₃ ) ) we allow the equivalent forms External( func:concat( str₁, str₂) ) and External( func:concat( str₁ str₂ str₃ ) ). Note that this is really purely syntactic sugar, and does not mean that for external predicates and functions we lift the restriction made in BLD that each function and predicate has a unique assigned arity. Those schemata for which we allow this syntactic sugar, appear in the same box.

3.5.1.1 func:compare (adapted from fn:compare)

• Schema:

  (?comparand₁?comparand₂; func:compare1(?comparand₁?comparand₂) )

  (?comparand₁?comparand₂?collation; func:compare2(?comparand₁?comparand₂?collation) )

• Intended domains:

  The value space of xs:string for all arguments.

• Mapping:

  I_external( (?comparand₁?comparand₂; func:compare1(?comparand₁?comparand₂) )(s₁ s₂) = res such that res = -1, 0, or 1 (from the value space of xs:integer), depending on whether the value of the s₁ is respectively less than, equal to, or greater than the value of s₂, according to the rules of the collation that is used.

  If an argument value is outside of the intended domain, the value of the function is left unspecified and can vary from one semantic structure to another.

The following schemata are defined analogously with respect to their corresponding operators as defined in [XPath-Functions] and we only give informal descriptions of the respective mappings I_external.

3.5.1.2 func:concat (adapted from fn:concat)

• Schema:

  (?arg₁; func:concat1(?arg₁ ) )

  (?arg₁?arg₂; func:concat2(?arg₁?arg₂ ) )

  ...

  (?arg₁ ?arg₂ ...?arg_n; func:concatn(?arg₁?arg₂ ...?arg_n ) )

• Intended domains:

  Following the definition of fn:concat this function accepts xs:anyAtomicType arguments and casts them to xs:string. Thus, the intended domain for all arguments is the union of all value spaces castable to String xs:string as defined in Section Cast Functions and Conversion Predicates for Datatypes and rif:iri above.

• Mapping:

  Returns the xs:string that is the concatenation of the values of its arguments after conversion.

  If an argument value is outside of the intended domain, the value of the function is left unspecified and can vary from one semantic structure to another.

3.5.1.3 func:string-join (adapted from fn:string-join)

• Schema:

  (?arg₁?arg₂; func:string-join2(?arg₁?arg₂ ) )

  (?arg₁?arg₂?arg₃; func:string-join3(?arg₁?arg₂?arg₃ ) )

  ...

  (?arg₁ ?arg₂ ...?arg_n; func:string-joinn(?arg₁?arg₂ ...?arg_n ) )

• Intended domains:

  The value space of xs:string for all arguments.

• Mapping:

  Returns a xs:string created by concatenating the arguments 1 to (n-1) using the n^th argument as a separator.

  If an argument value is outside of the intended domain, the value of the function is left unspecified and can vary from one semantic structure to another.

3.5.1.4 func:substring (adapted from fn:substring)

• Schema:

  (?sourceString?startingLoc; func:substring1(?sourceString?startingLoc) )

  (?sourceString?startingLoc?length; func:substring2(?sourceString?startingLoc?length) )

• Intended domains:

  The value space of xs:string for ?sourceString and the union of the value spaces of xs:integer, xs:long, or xs:decimal for the remaining two arguments.

• Mapping:

  Returns the portion of the value of?sourceString beginning at the position indicated by the value of?startingLoc and continuing for the number of characters indicated by the value of?length. The characters returned do not extend beyond?sourceString. If?startingLoc is zero or negative, only those characters in positions greater than zero are returned.

  If an argument value is outside of its intended domain, the value of the function is left unspecified and can vary from one semantic structure to another.