RE: Comments on Last-Call Working Draft of RDF 1.1 Semantics

On Wednesday, December 11, 2013 4:23 PM, Antoine Zimmermann wrote:
> Changes to concepts:
> ====================
> 
> 5.4  Datatype Maps
> 
> Datatypes are identified by IRIs.  In order to know the value of a
> literal, implementations should be able to associate its datatype IRI
> to the datatype it identifies.
> This association between IRIs and datatypes is called a <def>datatype
> map</def> and it is formally defined as a mapping from a set of IRIs to
> datatypes.
> 
> The set of IRIs in a datatype map is known as the <def>recognized
> datatype IRIs</def>, the datatypes associated with recognized IRIs by
> the datatype map are called the <def>recognized datatypes</def>, and
> datatype maps MUST satisfy the following conditions:

I have to admit that I haven't read the whole discussion that lead to this
proposal but I have to say that I find this overly complicated. Currently
Concepts says:

  Datatypes are identified by IRIs. If D is a set of IRIs which are used
  to refer to datatypes, then the elements of D are called recognized
  datatype IRIs. Recognized IRIs have fixed referents, which MUST satisfy
  these conditions

which could be further simplified to (I would like to avoid that math-y
language wherever possible in Concepts):

  Datatypes are identified by IRIs. IRIs known to be denoting a datatype are
  called recognized datatype IRIs. They MUST satisfy the following
conditions

We could then, after listing those conditions, say something like:

  RDF 1.0 used the concept of a datatype map which mapped the datatype IRI
  to the datatype it denoted. In an attempt to simplify RDF 1.1 this
  indirection was removed.


[...]
>   - If the datatype IRI
> http://www.w3.org/1999/02/22-rdf-syntax-ns#PlainLiteral is recognized,
> then it must be paired with the datatype rdf:PlainLiteral defined in
> [RDF:PLAINLITERAL].

Hasn't that been dropped in RDF 1.1?


>   - If the datatype IRI http://www.w3.org/2002/07/owl#rational is
> recognized, then it must be paired with the datatype rdf:PlainLiteral
> defined in [OWL 2 Structural Specification].
>   - If the datatype IRI http://www.w3.org/2002/07/owl#real is
> recognized, then it must be paired with the datatype rdf:PlainLiteral
> defined in [OWL 2 Structural Specification].

Why are you introducing OWL stuff here?


[...]
> Implementations are free to recognize datatype IRIs that are not part of
> a W3C specification,

This is already addresses by the intro of chapter 5 I think:

  The list of datatypes supported by an implementation is determined
  by its recognized datatype IRIs.


> in which case they SHOULD provide in their
> documentation the definition of the datatype to which the IRI maps to,
> making the datatype map explicit. However, if an implementation solely
> recognizes datatypes contained in XSD union {rdf:HTML, rdf:XMLLiteral,
> rdf:HTML, owl:rational, owl:real}, then it MAY only provide a set of
> recognized IRIs because the associate datatypes are constrained by this
> specification.

I don't think such suggestions or common sense should to be added using
normative language.


> <Note:> RDF Test cases never use datatypes outside the list above, so
> entailment tests refer to sets of recognized IRIs without making the
> datatype map explicit.</Note>

This doesn't belong into concepts.


> <Note:> If an implementation recognizes a datatype outside the list
> above, it SHOULD rely on a datatype IRI that can dereference to a
> specification of the associated datatype.

It "SHOULD rely" that the IRI can be dereferenced? Even though the WG voted
against such a suggestion for IRIs in general (ISSUE-103)?


> If it does so, then it is
> possible to define the datatype map of the implementation simply as a
> set of recognized IRIs</Node>.

What is this snippet trying to say?


Summarized, I don't think we should introduce this complexity just to keep
the term "datatype map". IMO it's an unnecessary indirection which doesn't
solve any (practical) purpose. Yeah, it was there in the past... but that's
a very weak argument and about the only one I see in favor of it at the
moment.



--
Markus Lanthaler
@markuslanthaler

Received on Wednesday, 11 December 2013 19:09:36 UTC