- 08/10/2022
- Posted by: ნატა კრასკოვსკაია
- Category: Arablounge review

- The fresh new lexical place of a symbol area is a non-empty gang of Unicode reputation chain.
- The latest identifier from an icon place is a series out-of Unicode emails you to definitely mode an outright IRI [RFC-3987].
- Various other icon room usually do not display the same identifier.

To simplify the language, we will often use symbol space identifiers to refer to the actual symbol spaces (for instance, we may use “symbol space `xs:sequence`” instead of “symbol space identified by `xs:string`“).

where `exact` is called the lexical part of the symbol, and `symspace` is the identifier of the symbol space. Here `literal` is a sequence of Unicode characters that must be an arablounge mobile element in the lexical space of the symbol space `symspace`. For instance, `"step one.2"^^xs:decimal` and `"1"^^xs:quantitative` are syntactically valid constants because 1.2 and 1 are members of the lexical space of the XML Schema datatype `xs:quantitative`. On the other hand, `"a+dos"^^xs:decimal` is not a syntactically valid symbol, since `a+2` is not part of the lexical space of `xs:quantitative`.

## Actually

RIF requires that all dialects include the symbol spaces listed and described in Section Constants and Symbol Spaces of [RIF-DTB] as part of their language. These symbol spaces include constants that belong to several important XML Schema datatypes, certain RDF datatypes, and constant symbols specific to RIF. The latter include the symbol spaces `rif:iri` and `rif:local`, which are used to represent internationalized resource identifiers (IRIs [RFC-3987]) and constant symbols that are not visible outside of the RIF document in which they occur, respectively. Documents that are exchanged through RIF can use additional symbol spaces (for instance, a symbol space to represent Skolem constants and functions).

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:regional` constants.

## 2.4 Terms

The easiest build out of a reason words is actually a phrase. RIF-FLD helps many kinds away from conditions: constants, variables, the typical positional conditions, also words with named arguments, equality, class terminology, structures, and much more. The definition of “term” could be familiar with make reference to whatever label.

- Constants and variables. If
`t`?`Const`or`t`?`Var`then`t`is a simple term. - Positional terms. If
`t`and`t`, ._{1}`t`are terms then_{n}`t(t`is a positional term._{1}. t_{n})

Positional terms in RIF-FLD generalize the regular notion of a term used in first-order logic. For instance, the above definition allows variables everywhere, as in `?X(?Y ?Z(?V "12"^^xs:integer))`, where `?X`, `?Y`, `?Z`, and `?V` are variables. `?X("abc"^^xs:string ?W)(?Y ?Z(?V "33"^^xs:integer))` is a positional term (as in HiLog [CKW93]).

The term `t` here represents a predicate or a function; `s _{1}`, .

`s`represent argument names; and

_{n}`v`, .

_{1}`v`represent argument values. Terms with named arguments are like regular positional terms except that the arguments are named and their order is immaterial. Note that a term with no arguments, like f(), is, trivially, both a positional term and a term with named arguments.

_{n}For instance, `"person"^^xs:string(""^^rif:iri->?Y ""^^rif:iri->?Z)`, `?X("123"^^xs:integer ?W)(arg->?Y arg2->?Z(?V))`, and `"Closure"^^rif:local(""^^rif:iri->""^^rif:iri)("from"^^rif:local->?X "to"^^rif:local->?Y)` are terms with named arguments. The second of these named-argument terms uses a positional term, `?X("123"^^xs:integer ?W)`, in the role of the function, and the third term’s function is itself represented by a named-argument term.

- A closed list has the form
`List(t`, where_{1}. t_{m})`m?0`and`t`are terms._{1}, . t_{m} - An open list (or a list with a tail) has the form
`OpenList(t`, where_{1}. t_{m}t)`m>0`and`t`, ._{1}`t`,_{m}`t`are terms. Open lists are written in the presentation syntax as follows:`List(t`._{1}. t_{m}| t)