W3C home > Mailing lists > Public > www-rdf-logic@w3.org > July 2002

Re: Dataypes, literals, syntax

From: pat hayes <phayes@ai.uwf.edu>
Date: Wed, 31 Jul 2002 18:54:59 -0400
Message-Id: <p05111b22b96e19440677@[65.217.30.57]>
To: "Peter F. Patel-Schneider" <pfps@research.bell-labs.com>
Cc: www-rdf-logic@w3.org

>From: pat hayes <phayes@ai.uwf.edu>
>Subject: Re: Dataypes, literals, syntax
>Date: Sun, 28 Jul 2002 22:53:30 -0400
>
>[...]
>
>>  OK, I see. But I don't see the real utility of the suggestion in this
>>  case. It provides no extra expressive ability; at best it saves a
>>  triple here or there; but on the other hand it complicated the
>>  syntax. So this is a syntactic trade-off, and I guess I think that on
>>  balance its not worth the trouble. We can get the same effect by
>>  using a bnode and an extra triple, in effect writing the typed
>>  literal as a triple:
>
>
>Well, how about compatability with XML Schema?  I mean is it not important
>to be able to write
>
><ex:foo>
>   <ex:bar xsi:type="xsd:integer">10</ex:bar>
></ex:foo>
>
>If not, then what is the relationship between the XML standards and RDF
>good for?
>
>[...]
>
>>  >Ignoring that,
>>  >what is problematic about this example?
>>
>>  Its not semantically problematic, but it does mean that datatyping
>>  would have to be built into RDF even at a very basic level. I guess
>>  this could be considered an advantage, but it doesn't fit very well
>>  into the zeitgeist of the core WG.
>
>How is the above scheme any more built-in than the schemes being considered
>by the RDF Core WG?  They both depend on datatype mappings, don't they?

Building datatypes into the syntax of literals seems to incorporate 
datatyping into RDF much more centrally than the other proposals. It 
would mean for example that RDF without datatyping would be 
meaningless: all of RDF would be datatyped. (This might be considered 
an advantage, I concede. )

>
>>  >  The model theory would say that
>>  >the denotation of xsd:integer"10" is the member of the XML value space that
>>  >is the result of the XML Schema datatype integer lexical-to-value mapping
>>  >of the string "10", i.e., the integer 10.  Similarly, the model theory
>>  >would say that the denotation of xsd:octal"12" is the member of the XML
>>  >value space that is the result of the XML Schema datatype octal
>>  >lexical-to-value mapping of the string "12", i.e., the integer 10.  This is
>>  >no different from how any of the proposals put forward by the RDF Core
>>  >Working Group would have do work.
>>  >
>>  >>  Pat
>>  >
>>  >In sum, I don't see any downsides to having typed literals, only upsides.
>>
>>  I guess I disagree. I see no clear upsides, and several downsides.
>>  Chiefly, I see extra syntactic complexity in the basic spec, for no
>>  real advantage in expressiveness or efficiency. Basically, small
>>  constant factors in numbers of triples are not worth bothering with.
>
>I see much more complexity in the RDF Core WG proposal.  It requires bnodes
>and explicit mappings.

It requires the use of RDF, in other words: but surely it should not 
be considered 'complex' for RDF to use RDF conventions itself.

>
>>  >It is the way XML (Schema) handles typing of literals;  it allows an escape
>>  >from some of the problems with XML Schema datatypes having to do with union
>>  >datatypes
>>
>>  I fail to see how it helps there.
>
>You can locally type in the syntax to allow "10" to be either an integer or
>a string if the range type is a union type.

Again, I fail to see how this is possible. If the datatype label is a 
union type, how does one add a further datatype constraint to a 
literal? Must literals be allowed to have sequences or stacks of 
datatype names attached to them?

>
>>  >; it provides a clear and clean way of locally typing literals;
>>
>>  We already have one of those (the datatyping property idiom)
>>
>>  >it avoids the extra blank node junk in the RDF Core Working Group current
>>  >treatment of local typing.
>>
>>  Extra blank nodes are harmless. RDF is chock-full of this kind of
>>  'junk' in any case. Tiny improvements in elegance are irrelevant.
>
>Well, I disagree very much here.  I don't see where RDF has this kind of
>junk, except in reification and containers, which can be avoided in most
>cases.  Requiring junk to do datatyping makes it much harder to avoid the
>junk.

OK, I think this is basic disagreement about RDF. Bnodes are not 
junk, they are a basic part of the RDF language. I know that 
description logicians such as yourself disapprove of them and 
consider them a nuisance. Tough: get used to the fact the the rest of 
the world uses them for all kinds of purposes. You can't avoid what 
you call 'junk', so your crusade to eliminate it is doomed to 
failure. It certainly is not worth redefining the basic syntax of RDF 
just to accommodate your dislike of what is in fact a central feature 
of RDF.

Pat

-- 
---------------------------------------------------------------------
IHMC					(850)434 8903   home
40 South Alcaniz St.			(850)202 4416   office
Pensacola,  FL 32501			(850)202 4440   fax
phayes@ai.uwf.edu 
http://www.coginst.uwf.edu/~phayes
Received on Wednesday, 31 July 2002 18:55:20 GMT

This archive was generated by hypermail 2.2.0+W3C-0.50 : Monday, 7 December 2009 10:52:42 GMT