Jump to: navigation, search

Editors

Axel Polleres, DERI

Harold Boley, National Research Council Canada

Michael Kifer, State University of New York at Stony Brook

This document, developed by the Rule Interchange Format (RIF) Working Group, specifies a list of primitive datatypes, built-in functions and built-in predicates expected to be supported by RIF dialects such as the RIF Basic Logic Dialect. Each dialect supporting a superset or subset of the primitive datatypes, built-in functions and built-in predicates defined here shall specify these additions or restrictions. Some of the datatypes are adopted from [XML-SCHEMA2]. A large part of the definitions of the listed functions and operators are adopted from [XPath-Functions]. The rdf:text datatype as well as functions and operators associated with that datatype are adopted from [RDF-TEXT].

Contents 1 Constants, Symbol Spaces, and Datatypes 1.1 Constants and Symbol Spaces 1.2 The Base and Prefix Directives 1.2.1 Symbol Spaces 1.2.2 Shortcuts for Constants in RIF's Presentation Syntax 1.2.3 Relative IRIs 1.3 Primitive Datatypes 2 Syntax and Semantics of Built-ins 2.1 Syntax of Built-ins 2.2 Semantics of Built-ins 3 List of RIF Built-in Predicates and Functions 3.1 Guard Predicates for Datatypes 3.1.1 pred:isInteger 3.1.2 pred:isDecimal 3.1.3 pred:isDouble 3.1.4 pred:isString 3.1.5 pred:isTime 3.1.6 pred:isDate 3.1.7 pred:isDateTime 3.1.8 pred:isDayTimeDuration 3.1.9 pred:isYearMonthDuration 3.1.10 pred:isXMLLiteral 3.1.11 pred:isText 3.2 Negative Guard Predicates for Datatypes 3.2.1 pred:isNotInteger 3.2.2 pred:isNotDecimal 3.2.3 pred:isNotDouble 3.2.4 pred:isNotString 3.2.5 pred:isNotTime 3.2.6 pred:isNotDate 3.2.7 pred:isNotDateTime 3.2.8 pred:isNotDayTimeDuration 3.2.9 pred:isNotYearMonthDuration 3.2.10 pred:isNotXMLLiteral 3.2.11 pred:isNotText 3.3 Datatype Conversion and Datatypes Checking 3.3.1 xs:double 3.3.2 xs:integer 3.3.3 xs:decimal 3.3.4 xs:time 3.3.5 xs:date 3.3.6 xs:dateTime 3.3.7 xs:dayTimeDuration 3.3.8 xs:yearMonthDuration 3.3.9 xs:string 3.3.10 rdf:XMLLiteral 3.3.11 pred:iri-string 3.3.12 pred:hasDatatype 3.4 Numeric Functions and Predicates 3.4.1 Numeric Functions 3.4.1.1 func:numeric-add (adapted from op:numeric-add) 3.4.1.2 func:numeric-subtract (adapted from op:numeric-subtract) 3.4.1.3 func:numeric-multiply (adapted from op:numeric-multiply) 3.4.1.4 func:numeric-divide (adapted from op:numeric-divide) 3.4.1.5 func:numeric-integer-divide (adapted from op:numeric-integer-divide) 3.4.1.6 func:numeric-mod (adapted from op:numeric-mod) 3.4.2 Numeric Predicates 3.4.2.1 pred:numeric-equal (adapted from op:numeric-equal) 3.4.2.2 pred:numeric-less-than (adapted from op:numeric-less-than) 3.4.2.3 pred:numeric-greater-than (adapted from op:numeric-greater-than) 3.4.2.4 pred:numeric-not-equal 3.4.2.5 pred:numeric-less-than-or-equal 3.4.2.6 pred:numeric-greater-than-or-equal 3.5 Functions and Predicates on Strings 3.5.1 Functions on Strings 3.5.1.1 func:compare (adapted from fn:compare) 3.5.1.2 func:concat (adapted from fn:concat) 3.5.1.3 func:string-join (adapted from fn:string-join) 3.5.1.4 func:substring (adapted from fn:substring) 3.5.1.5 func:string-length (adapted from fn:string-length) 3.5.1.6 func:upper-case (adapted from fn:upper-case) 3.5.1.7 func:lower-case (adapted from fn:lower-case) 3.5.1.8 func:encode-for-uri (adapted from fn:encode-for-uri) 3.5.1.9 func:iri-to-uri (adapted from fn:iri-to-uri) 3.5.1.10 func:escape-html-uri (adapted from fn:escape-html-uri) 3.5.1.11 func:substring-before (adapted from fn:substring-before) 3.5.1.12 func:substring-after (adapted from fn:substring-after) 3.5.1.13 func:replace (adapted from fn:replace) 3.5.2 Predicates on Strings 3.5.2.1 pred:contains (adapted from fn:contains) 3.5.2.2 pred:starts-with (adapted from fn:starts-with) 3.5.2.3 pred:ends-with (adapted from fn:ends-with) 3.5.2.4 pred:matches (adapted from fn:matches) 3.5.2.5 pred:string-equal 3.5.2.6 pred:string-less-than 3.5.2.7 pred:string-greater-than 3.5.2.8 pred:string-not-equal 3.5.2.9 pred:string-less-than-or-equal 3.5.2.10 pred:string-greater-than-or-equal 3.6 Functions and Predicates on Dates, Times, and Durations 3.6.1 Functions on Dates, Times, and Durations 3.6.1.1 func:year-from-dateTime (adapted from fn:year-from-dateTime) 3.6.1.2 func:month-from-dateTime (adapted from fn:month-from-dateTime) 3.6.1.3 func:day-from-dateTime (adapted from fn:day-from-dateTime) 3.6.1.4 func:hours-from-dateTime (adapted from fn:hours-from-dateTime) 3.6.1.5 func:minutes-from-dateTime (adapted from fn:minutes-from-dateTime) 3.6.1.6 func:seconds-from-dateTime (adapted from fn:seconds-from-dateTime) 3.6.1.7 func:year-from-date (adapted from fn:year-from-date) 3.6.1.8 func:month-from-date (adapted from fn:month-from-date) 3.6.1.9 func:day-from-date (adapted from fn:day-from-date) 3.6.1.10 func:hours-from-time (adapted from fn:hours-from-time) 3.6.1.11 func:minutes-from-time (adapted from fn:minutes-from-time) 3.6.1.12 func:seconds-from-time (adapted from fn:seconds-from-time) 3.6.1.13 func:years-from-duration (adapted from fn:years-from-duration) 3.6.1.14 func:months-from-duration (adapted from fn:months-from-duration) 3.6.1.15 func:days-from-duration (adapted from fn:days-from-duration) 3.6.1.16 func:hours-from-duration (adapted from fn:hours-from-duration) 3.6.1.17 func:minutes-from-duration (adapted from fn:minutes-from-duration) 3.6.1.18 func:seconds-from-duration (adapted from fn:seconds-from-duration) 3.6.1.19 func:timezone-from-dateTime (adapted from fn:timezone-from-dateTime) 3.6.1.20 func:timezone-from-date (adapted from fn:timezone-from-date) 3.6.1.21 func:timezone-from-time (adapted from fn:timezone-from-time) 3.6.1.22 func:subtract-dateTimes (adapted from op:subtract-dateTimes) 3.6.1.23 func:subtract-dates (adapted from op:subtract-dates) 3.6.1.24 func:subtract-times (adapted from op:subtract-times) 3.6.1.25 func:add-yearMonthDurations (adapted from op:add-yearMonthDurations) 3.6.1.26 func:subtract-yearMonthDurations (adapted from op:subtract-yearMonthDurations) 3.6.1.27 func:multiply-yearMonthDuration (adapted from op:multiply-yearMonthDuration) 3.6.1.28 func:divide-yearMonthDuration (adapted from op:divide-yearMonthDuration) 3.6.1.29 func:divide-by-yearMonthDuration (adapted from op:divide-yearMonthDuration-by-yearMonthDuration) 3.6.1.30 func:add-dayTimeDurations (adapted from op:add-dayTimeDurations) 3.6.1.31 func:subtract-dayTimeDurations (adapted from op:subtract-dayTimeDurations) 3.6.1.32 func:multiply-dayTimeDuration (adapted from op:multiply-dayTimeDuration) 3.6.1.33 func:divide-dayTimeDuration (adapted from op:divide-dayTimeDuration) 3.6.1.34 func:divide-dayTimeDuration-by-dayTimeDuration (adapted from op:divide-dayTimeDuration-by-dayTimeDuration) 3.6.1.35 func:add-yearMonthDuration-to-dateTime (adapted from op:add-yearMonthDuration-to-dateTime) 3.6.1.36 func:add-yearMonthDuration-to-date (adapted from op:add-yearMonthDuration-to-date) 3.6.1.37 func:add-dayTimeDuration-to-dateTime (adapted from op:add-dayTimeDuration-to-dateTime) 3.6.1.38 func:add-dayTimeDuration-to-date (adapted from op:add-dayTimeDuration-to-date) 3.6.1.39 func:add-dayTimeDuration-to-time (adapted from op:add-dayTimeDuration-to-time) 3.6.1.40 func:subtract-yearMonthDuration-from-dateTime (adapted from op:subtract-yearMonthDuration-from-dateTime) 3.6.1.41 func:subtract-yearMonthDuration-from-date (adapted from op:subtract-yearMonthDuration-from-date) 3.6.1.42 func:subtract-dayTimeDuration-from-dateTime (adapted from op:subtract-dayTimeDuration-from-dateTime) 3.6.1.43 func:subtract-dayTimeDuration-from-date (adapted from op:subtract-dayTimeDuration-from-date) 3.6.1.44 func:subtract-dayTimeDuration-from-time (adapted from op:subtract-dayTimeDuration-from-time) 3.6.2 Predicates on Dates, Times, and Durations 3.6.2.1 pred:dateTime-equal (adapted from op:dateTime-equal) 3.6.2.2 pred:dateTime-less-than (adapted from op:dateTime-less-than) 3.6.2.3 pred:dateTime-greater-thanl (adapted from op:dateTime-greater-than) 3.6.2.4 pred:date-equal (adapted from op:date-equal) 3.6.2.5 pred:date-less-than (adapted from op:date-less-than) 3.6.2.6 pred:date-greater-than (adapted from op:date-greater-than) 3.6.2.7 pred:time-equal (adapted from op:time-equal) 3.6.2.8 pred:time-less-than (adapted from op:time-less-than) 3.6.2.9 pred:time-greater-than (adapted from op:time-greater-than) 3.6.2.10 pred:duration-equal (adapted from op:duration-equal) 3.6.2.11 pred:dateTimeDuration-less-than (adapted from op:dayTimeDuration-less-than) 3.6.2.12 pred:dayTimeDuration-greater-than (adapted from op:dayTimeDuration-greater-than) 3.6.2.13 pred:yearMonthDuration-less-than (adapted from op:yearMonthDuration-less-than) 3.6.2.14 pred:yearMonthDuration-greater-than (adapted from op:yearMonthDuration-greater-than) 3.6.2.15 pred:dateTime-not-equal 3.6.2.16 pred:dateTime-less-than-or-equal 3.6.2.17 pred:dateTime-greater-than-or-equal 3.6.2.18 pred:date-not-equal 3.6.2.19 pred:date-less-than-or-equal 3.6.2.20 pred:date-greater-than-or-equal 3.6.2.21 pred:time-not-equal 3.6.2.22 pred:time-less-than-or-equal 3.6.2.23 pred:time-greater-than-or-equal 3.6.2.24 pred:duration-not-equal 3.6.2.25 pred:dayTimeDuration-less-than-or-equal 3.6.2.26 pred:dayTimeDuration-greater-than-or-equal 3.6.2.27 pred:yearMonthDuration-less-than-or-equal 3.6.2.28 pred:yearMonthDuration-greater-than-or-equal 3.7 Functions and Predicates on rdf:XMLLiterals 3.7.1 pred:XMLLiteral-equal 3.7.2 pred:XMLLiteral-not-equal 3.8 Functions and Predicates on rdf:text 3.8.1 Functions on rdf:text 3.8.1.1 func:text-from-string-lang (adapted from fn:text-from-string-lang) 3.8.1.2 func:text-from-string (adapted from fn:text-from-string) 3.8.1.3 func:string-from-text (adapted from fn:string-from-text) 3.8.1.4 func:lang-from-text (adapted from fn:lang-from-text) 3.8.1.5 func:text-compare (adapted from fn:text-compare) 3.8.1.6 func:text-length (adapted from fn:text-length) 3.8.2 Predicates on rdf:text 3.8.2.1 pred:matches-language-range (adapted from fn:matches-language-range) 3.8.2.2 pred:text-equal 3.8.2.3 pred:text-less-than 3.8.2.4 pred:text-greater-than 3.8.2.5 pred:text-not-equal 3.8.2.6 pred:text-less-than-or-equal 3.8.2.7 pred:text-greater-than-or-equal 4 References 5 Appendix: Schemas for Externally Defined Terms

1 Constants, Symbol Spaces, and Datatypes

1.1 Constants and Symbol Spaces

Each constant (that is, each non-keyword symbol) in RIF belongs to a particular symbol space. A constant in a particular RIF symbol space has the following presentation syntax:

"literal"^^<symbolSpaceIri>

where literal is called the lexical part of the symbol, and symbolSpaceIri is an (absolute or relative) IRI identifying the symbol space. Here literal is a Unicode string that must be an element in the lexical space of the symbol space identified by the IRI symbolSpaceIri.

1.2 The Base and Prefix Directives

Since IRI typically require long strings of characters, many Web languages have special provisions for abbreviating these strings. One popular technique is called compact URI [CURIE], and RIF uses a similar technique by allowing RIF documents to have the directives Base and Prefix.

• A base directive has the form Base(iri), where iri is a unicode string in the form of an IRI [RFC-3987].

  The Base directive defines a syntactic shortcut for expanding relative IRIs into full IRIs.

• A prefix directive has the form Prefix(p v), where p is called a prefix and v is its expansion. A prefix is an alphanumeric string an expansion is a string that forms an IRI. (An alphanumeric string is a sequence of ASCII characters, where each character is a letter, a digit, or an underscore "_", and the first character is a letter.)

  The basic idea is that in certain contexts prefixes can be used instead of their much longer expansions, and this provides for a much more concise and simple notation. The precise way this mechanism works is explained in Section Shortcuts for Constants in RIF's Presentation Syntax.

The precise way in which these directives work is explained in Section Shortcuts for Constants in RIF's Presentation Syntax.

To avoid writing down long IRIs, this document will assume that the following Prefix directives have been specified in all the RIF documents under consideration:

• Prefix(xs http://www.w3.org/2001/XMLSchema#). This prefix stands for the XML Schema namespace URI.
• Prefix(rdf http://www.w3.org/1999/02/22-rdf-syntax-ns#). This prefix stands for the RDF URI.
• Prefix(rif http://www.w3.org/2007/rif#). The rif prefix stands for the RIF URI.
• Prefix(func http://www.w3.org/2007/rif-builtin-function#). This prefix expands into a URI used for RIF builtin functions.
• Prefix(pred http://www.w3.org/2007/rif-builtin-predicate#). This is the prefix used for RIF builtin predicates.

Using these prefixes and the shorthand mechanism defined in Section Shortcuts for Constants in RIF's Presentation Syntax, we can, for example, abbreviate a constant such as "http://www.example.org"^^<http://www.w3.org/2007/rif#iri> into "http://www.example.org"^^rif:iri.

1.2.1 Symbol Spaces

Formally, we define symbol spaces as follows.

Definition (Symbol space). A symbol space is a named subset of the set of all constants, Const in RIF. Each symbol in Const belongs to exactly one symbol space.

Each symbol space has an associated lexical space, a unique IRI identifying it and a short name. More precisely,

• The lexical space of a symbol space is a non-empty set of Unicode character strings.

• The identifier of a symbol space is a sequence of Unicode characters that form an absolute IRI.

• The short name of a symbol space is an NCName, typically the character sequence after the last '/' or '#' in the symbol space IRI (similar to the XML local name part of a QName).

• Different symbol spaces supported by a dialect cannot share the same identifier or short name.

The identifiers of symbol spaces are not themselves constant symbols in RIF.

For convenience we will often use symbol space identifiers to refer to the actual symbol spaces (for instance, we may use "symbol space xs:string" instead of "symbol space identified by xs:string").

RIF dialects are expected to include the following symbol spaces. However, rule sets that are exchanged through RIF can use additional symbol spaces.

• xs:string (http://www.w3.org/2001/XMLSchema#string, short name: string)
• xs:time (http://www.w3.org/2001/XMLSchema#time, short name: time)
• xs:date (http://www.w3.org/2001/XMLSchema#date), short name: date
• xs:dateTime (http://www.w3.org/2001/XMLSchema#dateTime), short name: dateTime)
• xs:double (http://www.w3.org/2001/XMLSchema#double, short name: double)
• xs:integer (http://www.w3.org/2001/XMLSchema#integer, short name: integer)
• xs:decimal (http://www.w3.org/2001/XMLSchema#decimal, short name: decimal)

  The lexical spaces of the above symbol spaces are defined in the document [XML-SCHEMA2].

• xs:dayTimeDuration (http://www.w3.org/2001/XMLSchema#dayTimeDuration, short name: dayTimeDuration)
• xs:yearMonthDuration (http://www.w3.org/2001/XMLSchema#yearMonthDuration, short name: yearMonthDuration)

  These two symbol spaces represent two subtypes of the XML Schema datatype xs:duration with well-defined value spaces, since xs:duration does not have a well-defined value space (this may be corrected in later revisions of XML Schema datatypes, in which case the revised datatype would be suitable for RIF DTB). The lexical spaces of the above symbol spaces are defined in the document [XDM].

• rdf:text (http://www.w3.org/1999/02/22-rdf-syntax-ns#text , short name: text).

  This symbol space represents text strings with a language tag attached. The lexical space of rdf:text is defined in the document [RDF-TEXT].

• rdf:XMLLiteral (http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral, short name: XMLLiteral).

  This symbol space represents XML content. The lexical space of rdf:XMLLiteral is defined in the document [RDF-CONCEPTS].

• rif:iri (http://www.w3.org/2007/rif#iri, , short name: iri, for internationalized resource identifiers or IRIs).

  Constants in this symbol space are intended to be used in a way similar to RDF resources [RDF-SCHEMA]. The lexical space consists of all absolute IRIs as specified in [RFC-3987]; it is unrelated to the XML primitive type anyURI. A rif:iri constant must be interpreted as a reference to one and the same object regardless of the context in which that constant occurs.

• rif:local (http://www.w3.org/2007/rif#local, , short name: local, for constant symbols that are not visible outside of the RIF document in which they occur).

  Constants in this symbol space are local to the RIF documents in which they occur. This means that occurrences of the same rif:local constant in different documents are viewed as unrelated distinct constants, but occurrences of the same rif:local constant in the same document must refer to the same object. The lexical space of rif:local is the same as the lexical space of xs:string.

Note that, by the associated lexical space, not all unicode strings are syntactically valid lexical parts for all symbol spaces. That is, for instance "1.2"^^xs:decimal and "1"^^xs:integer are syntactically valid constant because 1.2 and 1 are members of the lexical space of symbol spaces xs:decimal and xs:integer, respectively. On the other hand, "a+2"^^xs:decimal is not a syntactically valid constant, since a+2 is not part of the lexical space of xs:decimal.

We will often refer to constant symbols that come from a particular symbol space, X, as X-constants. For instance the constants in the symbol space rif:iri will be referred to as IRI constants or rif:iri constants and the constants found in the symbol space rif:local as local constants or rif:local constants.

1.2.2 Shortcuts for Constants in RIF's Presentation Syntax

Besides the basic notion

"literal"^^<identifier>

RIF's presentation syntax introduces several shortcuts for particular symbol spaces, in order to make the presentation syntax more readable. RIF's presentation syntax for constants is defined by the following EBNF.

  ANGLEBRACKIRI ::= IRI_REF
  SYMSPACE      ::= ANGLEBRACKIRI | CURIE
  CURIE         ::= PNAME_LN | PNAME_NS
  Const         ::= '"' UNICODESTRING '"^^' SYMSPACE | CONSTSHORT
  CONSTSHORT    ::= ANGLEBRACKIRI              // shortcut for "..."^^rif:iri
                  | CURIE                      // shortcut for "..."^^rif:iri
                  | '"' UNICODESTRING '"'      // shortcut for "..."^^xs:string
                  | NumericLiteral             // shortcut for "..."^^xs:integer,xs:decimal,xs:double
                  | '_' LocalName              // shortcut for "..."^^rif:local
                  | '"' UNICODESTRING '"' '@' languageTag             // shortcut for "...@..."^^rdf:text

The EBNF grammar relies on reuse of nonterminals defined in the following grammar productions from other documents:

• PNAME_LN, cf. http://www.w3.org/TR/rdf-sparql-query/#rPNAME_LN
• PNAME_NS, cf. http://www.w3.org/TR/rdf-sparql-query/#rPNAME_NS
• languageTag, cf. http://www.w3.org/2007/OWL/wiki/InternationalizedStringSpec#AbbreviationsGrammar
• NumericLiteral, cf. http://www.w3.org/TR/rdf-sparql-query/#rNumericLiteral
• IRI_REF, cf. http://www.w3.org/TR/rdf-sparql-query/#rIRI_REF
• LocalName, cf. http://www.w3.org/TR/2006/REC-xml-names11-20060816/#NT-LocalPart
• UNICODESTRING, any Unicode string where quotes are escaped and additionally all the other escape sequences defined in http://www.w3.org/TR/rdf-sparql-query/#grammarEscapes and http://www.w3.org/TR/rdf-sparql-query/#codepointEscape.

In this grammar, CURIE stands for compact IRIs [CURIE], which are used to abbreviate symbol space IRIs. For instance, one can write "http://www.example.org"^^rif:iri instead of "http://www.example.org"^^<http://www.w3.org/2007/rif#iri>, where rif is a prefix defined in Section Base and Prefix Directives. <p>Apart from compact IRIs, there exist convenient shortcut notations for constants in specific symbol spaces, namely for constants in the symbol spaces rif:iri, xs:string, xs:integer, xs:decimal, xs:double, and rif:local:

• Constants in the the symbol space rif:iri can be abbreviated in two ways, either by simply using an absolute or relative IRI enclosed in angle brackets, or by writing a compact IRI. The symbol space identifier is dropped in both of these alternatives. For instance <http://www.example.org/xyz> is a valid abbreviation for "http://www.example.org/xyz"^^rif:iri and , ex:xyz is a valid abbreviation for this constant, if the directive

  Prefix(ex http://www.example.org/)

  is present in the RIF document in question.

• Constants in the symbol space xs:string can be abbreviated by simply using quoted strings, i.e. "My String!" is a valid abbreviation for the constant "My String!"^^xs:string (which in turn is itself an abbreviation for "My String!"^^<http://www.w3.org/2001/XMLSchema#string>).
• Numeric constants can be abbreviated using the grammar rules for NumericLiterals from the [SPARQL] grammar: Integers can be written directly (without quotation marks and explicit symbol space identifier) and are interpreted as constants in the symbol space xs:integer; decimal numbers for which there is '.' in the number but no exponent are interpreted as constants in the symbol space xs:decimal; and numbers with exponents are interpreted as xs:double. For instance, one could use 1.2 and 1 as shortcuts for "1.2"^^xs:decimal and "1"^^xs:integer, respectively. However, there is no shortcut for "1"^^xs:decimal.
• The shortcut notation for rif:local applies to only a subset of the lexical space of syntactically valid lexical parts of constants in this symbol space: We allow "_"-prefixed unicode strings which are also valid XML NCNames as defined in [XML-NS]. For other constants in the rif:local symbol space one has to use the long notation. That is, for instance _myLocalConstant is a valid abbreviation for the constant "myLocalConstant"^^rif:local, whereas "http://www.example.org"^^rif:local cannot be abbreviated.

1.2.3 Relative IRIs

Relative IRIs in RIF documents are resolved with respect to the base IRI. Relative IRIs are combined with base IRIs as per Uniform Resource Identifier (URI): Generic Syntax [RFC-3986] using only the basic algorithm in Section 5.2. Neither Syntax-Based Normalization nor Scheme-Based Normalization (described in sections 6.2.2 and 6.2.3 of RFC-3986) are performed. Characters additionally allowed in IRI references are treated in the same way that unreserved characters are treated in URI references, per section 6.5 of Internationalized Resource Identifiers (IRIs) [RFC-3987].

Base IRIs are specified using the Base directive described in Section Base and Prefix Directives. At most one base directive per document is allowed. In the XML syntax, base IRIs are specified using the attribute xml:base.

For instance, the constant <./xyz> or "./xyz"^^rif:iri are both valid abbreviations in RIF for the constant http://www.example.org/xyz"^^rif:iri, if the following directive is present in the document:

Base(http://www.example.org)

1.3 Primitive Datatypes

Datatypes in RIF are symbol spaces which have special semantics. That is, each datatype is characterized by a fixed lexical space, value space and lexical-to-value-mapping.

Definition (Primitive datatype). A primitive datatype (or just a datatype, for short) is a symbol space that has

• an associated set, called the value space, and
• a mapping from the lexical space of the symbol space to the value space, called lexical-to-value-space mapping.   ☐

Semantic structures are always defined with respect to a particular set of datatypes, denoted by DTS. In a concrete dialect, DTS always includes the datatypes supported by that dialect. RIF dialects are expected to support the following primitive datatypes. However, RIF dialects may include additional datatypes.

• xs:string
• xs:time
• xs:date
• xs:dateTime
• xs:double
• xs:integer
• xs:decimal
• xs:dayTimeDuration
• xs:yearMonthDuration
• rdf:text
• rdf:XMLLiteral

Their value spaces and the lexical-to-value-space mappings are defined as follows:

• For the XML Schema datatypes of RIF, namely xs:double, xs:integer, xs:decimal, xs:time, xs:dateTime, and xs:string the value spaces and the lexical-to-value-space mappings are defined in the XML Schema specification [XML-SCHEMA2].
• The value spaces and the lexical-to-value-space mappings for the primitive datatypes xs:dayTimeDuration and xs:yearMonthDuration are defined in the XQuery 1.0 and XPath 2.0 Data Model [XDM].
• The value space and the lexical-to-value-space mapping for rdf:text are defined in the document [RDF-TEXT].
• The value space and lexical-to-value-space mapping for the primitive datatype rdf:XMLLiteral is defined in RDF [RDF-CONCEPTS].

Note that the value space and the lexical-to-value-space mapping for rdf:text defined here are compatible with RDF's semantics for string literals with named tags [RDF-SEMANTICS]. Moreover, the value space and the lexical-to-value-space mapping for xs:string are compatible with RDF's semantics for plain literals. RIF implementations MAY choose to interpret xs:string and its subtypes as subtypes of rdf:text following Section 3.1 of [RDF-TEXT], i.e., interpreting strings as texts with an empty language tag.

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.

Editor's Note: Some clarification is needed with respect to the value space of rdf:XMLLiteral which will hopefully be resolved by an erratum to the RDF spec., cf. the mail thread starting at http://lists.w3.org/Archives/Public/public-rif-wg/2008Dec/0013.html.

2 Syntax and Semantics of Built-ins

2.1 Syntax of Built-ins

A RIF built-in function or predicate is a special case of externally defined terms, which are defined in RIF Framework for Logic Dialects and also reproduced in the direct definition of RIF Basic Logic Dialect (RIF-BLD).

In RIF's presentation syntax built-in predicates and functions are syntactically represented as external terms of the form:

'External' '(' Expr ')'

where Expr is a positional term as defined in RIF Framework for Logic Dialects (see also in RIF Basic Logic Dialect). For RIF's normative syntax, see the XML Serialization Framework in RIF-FLD, or, specifically for RIF-BLD, see XML Serialization Syntax for RIF-BLD.

RIF-FLD introduces the notion of an external schema to describe both both the syntax and semantics of exernally defined terms. In the special case of a RIF built-in, external schemas have an especially simple form. A built-in named f that takes n arguments has the schema

( ?X₁ ... ?X_n;   f(?X₁ ... ?X_n) )

Here f(?X₁ ... ?X_n) is the actual term that is used to refer to the built-in (in expressions of the form External(f(?X₁ ... ?X_n))) and ?X₁ ... ?X_n is the list of all variables in that term.

For convenience, a complete definition of external schemas is reproduced in Appendix: Schemas for Externally Defined Terms.

2.2 Semantics of Built-ins

The semantics of external terms in RIF-FLD and RIF-BLD is defined using two mappings: I_external and I_truth ο I_external.

• I_external. This mapping takes an external schema, σ, and returns a mapping, I_external(σ).

  If σ represents a built-in function, I_external(σ) must be that function.

  For each built-in function with external schema σ, the present document specifies the mapping I_external(σ).

• I_truth. This mapping takes an element of the domain of interpretation and returns a truth value.

  In RIF logical semantics, this mapping is used to assign truth values to formulas. In the special case of RIF built-ins, it is used to assign truth values to RIF built-in predicates. The built-in predicates can have the truth values t or f only.

  For a built-in predicate with schema σ, RIF-FLD and RIF-BLD require that the truth-valued mapping I_truth ο I_external(σ) must agree with the specification of the corresponding built-in predicate.

  For each RIF built-in predicate with schema σ, the present document specifies I_truth ο I_external(σ).

3 List of RIF Built-in Predicates and Functions

This section provides a catalogue defining the syntax and semantics of a list of built-in predicates and functions in RIF. For each built-in, the following is defined:

1. The name of the built-in.
2. The external schema of the built-in.
3. For a built-in function, how it maps its arguments into a result.

   As explained in Section Semantics of Built-ins, this corresponds to the mapping I_external(σ) in the formal semantics of RIF-FLD and RIF-BLD, where σ is the external schema of the built-in.

4. For a built-in predicate, its truth value when the arguments are substituted with values in the domain.

   As explained in Section Semantics of Built-ins, this corresponds to the mapping I_truth ο I_external(σ) in the formal semantics of RIF-FLD and RIF-BLD, where σ is the external schema of the built-in.

5. The domains for the arguments of the built-in.

   Typically, built-in functions and predicates are defined over the value spaces of appropriate datatypes, i.e. the domains of the arguments. When an argument falls outside of its domain, it is understood as an error. Since this document defines a model-theoretic semantics for RIF built-ins, which does not support the notion of an error, the definitions leave the values of the built-in predicates and functions unspecified in such cases. This means that if one or more of the arguments is not in its domain, the value of I_external(σ)(a₁ ... a_n) is unspecified. In particular, this means it can vary from one implementation to another. Similarly, I_truth ο I_external(σ)(a₁ ... a_n) is unspecified when an argument is not in its domain.

   This indeterminacy in case of an error implies that applications should not make any assumptions about the values of built-ins in such situations. Implementations are even allowed to abort in such cases and the only safe way to communicate rule sets that contain built-ins among RIF-compliant systems is to use datatype guards.

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.

3.1 Guard Predicates for Datatypes

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. For instance, we use pred:isString for the guard predicate for xs:string, pred:isText for the guard predicate for rif:text, or pred:isXMLLiteral for the guard predicate forrdf:XMLLiteral. 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 a 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 formulation of the clause on namespace-reuse is under discussion, for instance, whether we shall allow guards and negative guards for all of the XML Schema primitive datatypes under the pred: namespace.

• Domain:

  Guard predicates do not depend on a specific 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.

3.1.1 pred:isInteger

• Schema:

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

3.1.2 pred:isDecimal

• Schema:

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

3.1.3 pred:isDouble

• Schema:

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

3.1.4 pred:isString

• Schema:

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

3.1.5 pred:isTime

• Schema:

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

3.1.6 pred:isDate

• Schema:

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

3.1.7 pred:isDateTime

• Schema:

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

3.1.8 pred:isDayTimeDuration

• Schema:

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

3.1.9 pred:isYearMonthDuration

• Schema:

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

3.1.10 pred:isXMLLiteral

• Schema:

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

3.1.11 pred:isText

• Schema:

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

Future dialects may extend this list of guards to other datatypes, but RIF does not require guards for all datatypes.

3.2 Negative Guard Predicates for Datatypes

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. For instance, we use pred:isNotString for the negative guard predicate for xs:string, pred:isNotText for the negative guard predicate for rif:text, or pred:isNotXMLLiteral for the negative guard predicate for rdf:XMLLiteral. 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 a 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 negative guard predicates.

  
  

  Editor's Note: The formulation of the clause on namespace-reuse is under discussion, for instance, whether we shall allow guards and negative guards for all of the XML Schema primitive datatypes under the pred: namespace.

• Domain:

  Negative guard predicates do not depend on a specific 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.

3.2.1 pred:isNotInteger

• Schema:

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

3.2.2 pred:isNotDecimal

• Schema:

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

3.2.3 pred:isNotDouble

• Schema:

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

3.2.4 pred:isNotString

• Schema:

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

3.2.5 pred:isNotTime

• Schema:

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

3.2.6 pred:isNotDate

• Schema:

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

3.2.7 pred:isNotDateTime

• Schema:

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

3.2.8 pred:isNotDayTimeDuration

• Schema:

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

3.2.9 pred:isNotYearMonthDuration

• Schema:

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

3.2.10 pred:isNotXMLLiteral

• Schema:

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

3.2.11 pred:isNotText

• Schema:

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

Future dialects may extend this list of guards to other datatypes, but RIF does not require negative guards for all datatypes.

3.3 Datatype Conversion and Datatypes Checking

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

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

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.

3.3.1 xs:double

• Schema:

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

• Domain:

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

• Mapping:

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

  If the argument value is outside of its domain or outside the partial conversions defined in [XPath-Functions], the value of the function is left unspecified.

3.3.2 xs:integer

• Schema:

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

• Domain:

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

• Mapping:

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

  If the argument value is outside of its domain or outside the partial conversions defined in [XPath-Functions], the value of the function is left unspecified.

3.3.3 xs:decimal

• Schema:

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

• Domain:

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

• Mapping:

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

  If the argument value is outside of its domain or outside the partial conversions defined in [XPath-Functions], the value of the function is left unspecified.

3.3.4 xs:time

• Schema:

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

• Domain:

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

• Mapping:

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

  If the argument value is outside of its domain or outside the partial conversions defined in [XPath-Functions], the value of the function is left unspecified.

3.3.5 xs:date

• Schema:

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

• Domain:

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

• Mapping:

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

  If the argument value is outside of its domain or outside the partial conversions defined in [XPath-Functions], the value of the function is left unspecified.

3.3.6 xs:dateTime

• Schema:

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

• Domain:

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

• Mapping:

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

  If the argument value is outside of its domain or outside the partial conversions defined in [XPath-Functions], the value of the function is left unspecified.

3.3.7 xs:dayTimeDuration

• Schema:

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

• 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₁; xs:dayTimeDuration ( ?arg₁ ) )(s₁) = s₁' such that s₁' is the conversion of s₁ to the value space of xs:dayTimeDuration according to Section 17.1 of [XPath-Functions].

  If the argument value is outside of its domain or outside the partial conversions defined in [XPath-Functions], the value of the function is left unspecified.

3.3.8 xs:yearMonthDuration

• Schema:

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

• Domain:

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

• Mapping:

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

  If the argument value is outside of its domain or outside the partial conversions defined in [XPath-Functions], the value of the function is left unspecified.

3.3.9 xs:string

• Schema:

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

• Domain:

  The union of the value space of rdf:XMLLiteral with the value spaces of datatypes 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 conversion of s₁ to the value space of xs:string according to the table in Section 17.1 of [XPath-Functions], in case s₁ is in the value space of a datatype mentioned there.
  • s₁' is the string in the lexical space of rdf:XMLLiteral correspoding to s₁ (cf. [RDF-CONCEPTS]), in case s₁ is in the value space of rdf:XMLLiteral.

  If the argument is outside of its domain, the value of the function is left unspecified.

Note: Since RIF implementations 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.

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.

Editor's Note: Casting from rdf:XMLLiteral to xs:string is still under discussion.

3.3.10 rdf:XMLLiteral

• Schema:

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

• Domain:

  The intersection of the value space of xs:string with the lexical space of rdf:XMLLiteral, i.e. an xs:string can be cast to rdf:XMLLiteral if and only if its value is in the lexical space of rdf:XMLLiteral as defined in 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 the argument value is outside of its domain, the value of the function is left unspecified.

3.3.11 pred:iri-string

Conversions from rif:iri to xs:string and vice versa cannot be defined by the casting functions as above since rif:iri is not a datatype with a well-defined value space.

To this end, since conversions from IRIs (resources) to strings are a needed feature for instance for conversions between RDF formats (see example below), we introduce a built-in predicate which supports such conversions.

• Schema:

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

• Domains:

  The first argument is not restricted by a specific domain, the second argument is the value space of xs:string.

• Mapping:

  I_external( ?arg₁ ?arg₂; pred:iri-string ( ?arg₁ ?arg₂ ) )(iri₁ str₁) = t if and only if str₁ is a string in the lexical space of rif:iri and iri₁ is an element of the domain such that I( "str₁"^^rif:iri ) = iri₁ holds in the current interpretation.

  Note that this definition restricts allowed RIF interpretations in such a way that the interpretation of pred:iri-string always needs to comply with respect to the symbols in the rif:iri symbol space for the first argument and elements of the xs:string value space for the second argument. The truth value of the predicate is left unspecified for other elements of the domain.

  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  ) ) )
  

3.3.12 pred:hasDatatype

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₂ ) )

• 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.

Editor's Note: It is still under discussion in the WG whether an additional predicate pred:hasNotDatatype should be added, cf. ISSUE-80.

3.4 Numeric Functions and Predicates

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

3.4.1 Numeric Functions

The following numeric built-in functions func:numeric-add, func:numeric-subtract, func:numeric-multiply, func:numeric-divide, func:numeric-integer-divide, and func:numeric-mod are defined in accordance with their corresponding operators in [XPath-Functions].

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

• Schema:

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

• Domains:

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

• Mapping:

  I_external( (?arg₁ ?arg₂; func:numeric-add(?arg₁ ?arg₂) )(a₁ a₂) = res such that res is the result of op:numeric-add(a₁, a₂) as defined in [XPath-Functions], in case both a₁ and a₂ belong to their domains.

  If an argument value is outside of its domain, the value of the function is left unspecified.

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

• Schema:

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

• Domains:

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

• Mapping:

  I_external( (?arg₁ ?arg₂; func:numeric-subtract(?arg₁ ?arg₂) )(a₁ a₂) = res such that res is the result of op:numeric-subtract(a₁, a₂) as defined in [XPath-Functions], in case both a₁ and a₂ belong to their domains.

  If an argument value is outside of its domain, the value of the function is left unspecified.

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

• Schema:

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

• Domains:

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

• Mapping:

  I_external( (?arg₁ ?arg₂; func:numeric-multiply(?arg₁ ?arg₂) )(a₁ a₂) = res such that res is the result of op:numeric-multiply(a₁, a₂) as defined in [XPath-Functions], in case both a₁ and a₂ belong to their domains.

  If an argument value is outside of its domain, the value of the function is left unspecified.

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

• Schema:

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

• 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:

  I_external( (?arg₁ ?arg₂; func:numeric-divide(?arg₁ ?arg₂) )(a₁ a₂) = res such that res is the result of op:numeric-divide(a₁, a₂) as defined in [XPath-Functions], in case both a₁ and a₂ belong to their domains.

  If an argument value is outside of its domain, the value of the function is left unspecified, 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₂) )

• 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:

  I_external( (?arg₁ ?arg₂; func:numeric-integer-divide(?arg₁ ?arg₂) )(a₁ a₂) = res such that res is the result of op:numeric-integer-divide(a₁, a₂) as defined in [XPath-Functions], in case both a₁ and a₂ belong to their domains.

  If an argument value is outside of its domain, the value of the function is left unspecified, 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₂) )

• 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:

  I_external( (?arg₁ ?arg₂; func:numeric-mod(?arg₁ ?arg₂) )(a₁ a₂) = res such that res is the result of op:numeric-mod(a₁, a₂) as defined in [XPath-Functions], in case both a₁ and a₂ belong to their domains.

  If an argument value is outside of its domain, the value of the function is left unspecified, which here particularly means that 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₁ ?arg₂; pred:numeric-equal(?arg₁ ?arg₂))

• Domains:

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

• Mapping:

  When both s₁ and s₂ belong to their domains, I_truth ο I_external( ?arg₁ ?arg₂; pred:numeric-equal(?arg₁ ?arg₂) )(a₁ a₂) = t if and only if op:numeric-equal(a₁, a₂) returns true, as defined in [XPath-Functions].

  If an argument value is outside of its domain, the truth value of the function is left unspecified.

The following numeric built-in predicates pred:numeric-less-than and pred:numeric-greater-than are defined analogously 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₂) )

3.4.2.4 pred:numeric-not-equal

• Schema:

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

The predicate pred:numeric-not-equal has the same domains as pred:numeric-equal and is true whenever pred:numeric-equal is false.

3.4.2.5 pred:numeric-less-than-or-equal

• Schema:

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

The predicate pred:numeric-less-than-or-equal has the same domains as pred:numeric-equal and is true whenever pred:numeric-equal is true or pred:numeric-less-than is true.

3.4.2.6 pred:numeric-greater-than-or-equal

• Schema:

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

The predicate pred:numeric-greater-than-or-equal has the same domains as pred:numeric-equal and is true whenever pred:numeric-equal is true or pred:numeric-greater-than is true.

3.5 Functions and Predicates on Strings

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( 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 Functions on Strings

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) )

• 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. I.e., this function computes the result of fn:compare(s₁, s₂) as defined in [XPath-Functions], in case all arguments belong to their domains.

  If an argument value is outside of its domain, the value of the function is left unspecified.

The following schemata are defined analogously with respect to their corresponding functions and 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 ) )

• Domains:

  Following the definition of fn:concat this function accepts xs:anyAtomicType arguments and casts them to xs:string. Thus, the domain for all a