Further changes to rdf:text + a proposal for a change

Hello,

I have just made several additional changes to rdf:text. The old version of the
document talked about *abbreviating* rdf:text literals, and it contained a
grammar for abbreviations. There were several problems with that. First, the
grammar rules were chosen from the functional-style syntax of OWL, and were as
such incompatible with other grammars (n particular, the syntax for strings was
not compatible with that of SPARQL). Second, I think it was wrong to talk about
*abbreviating* rdf:text literals.

The document now talks about replacing typed rdf:text RDF literals with plain
RDF literals. This seems better because it is detached from the actual syntax --
that is, it works at the level of RDF graphs rather than at the level of a
particular syntax. I have also removed any references to RIF and OWL in this
section. RIF and OWL specifications do not actually have a notion of plain
literals; in fact, typed rdf:text literals in RIF and OWL *are* plain literals.
Getting into all that in the rdf:text document would be quite messy, and it
seems more reasonable to focus in the rdf:text document solely on RDF.


Another problem is in the treatment of xsd:string. The old version of the
document said that implementations MAY choose to make the value space of
xsd:string be a subset of rdf:text. I believe that MAY should actually be a
MUST. Without this, we could get into the following situation:

- The typed RDF literal "abc@"^^rdf:text would be interpreted as ("abc","").
- Type plain RDF literal "abc" would be interpreted as "abc".
- Clearly, the two literals would NOT be the same.
- However, the typed RDF literal "abc@"^^rdf:text would be replaced with the
plain RDF literal "abc", which would suggest that the two literals ARE the same.

This seems seriously flawed. Consequently, I have changed a MAY into a MUST.



There is, however, a much nicer solution to the latter problem. We could change
the value space of rdf:text such that it contains two types of objects:

- all strings, and
- all pairs of the form ( s, l ) where l is a (nonempty) language tag.

In this case, rdf:text would *be* interpreted as the set of all plain RDF
literals. That is, we would not need to fuss about with changing the
interpretation of xsd:string: the very definition of the value space of rdf:text
would contain the value space of xsd:string, as well as all plain RDF literals.
Thus, we could just simply note this in the document and would not need any
additional definitions. Furthermore, the XQuery functions that work on
xsd:string would be readily applicable to the subset of rdf:text that does not
represent strings with language tags.

The nice aspect of this solution is that rdf:text then just provides an explicit
name for the set of all plain RDF literals, so we can't really be accused of
changing anything.

The only downside is that the definitions of facets and some functions would
become slightly messier, as they cannot treat literals with and without language
tags uniformly any more. I think, however, that this is a small price to pay for
the elegance that this solution brings.

Please let me know how you feel about this. If everyone agrees, I would like to
make the change as soon as possible (preferably today) so that the document can
be reviewed soon.

Regards,

	Boris

Received on Friday, 27 March 2009 10:18:11 UTC