W3C home > Mailing lists > Public > w3c-rdfcore-wg@w3.org > December 2001

RE: Action 2001-11-16#9 (datatypes)

From: <Patrick.Stickler@nokia.com>
Date: Thu, 13 Dec 2001 01:06:20 +0200
Message-ID: <A03E60B17132A84F9B4BB5EEDE57957B160B3C@trebe006.NOE.Nokia.com>
To: fmanola@mitre.org
Cc: w3c-rdfcore-wg@w3.org
> >>So what machinery are we assuming, and how do we assume the various
> >>pieces handoff information to each other?
> >>
> > 
> > Is this basically the issue of validation? I.e. which layer tests
> > that some lexical form is a member of the lexical space of a data
> > type and if multiple data types are specified, that the values
> > denoted constitute the same or analogous values. Where are lexical
> > errors or contradictions trapped. Right?
> 
> 
> Validation is one place where we need to have a clear picture of the 
> machinery, but it seems to me there must be others as well.  Any time I 
> have to use the value of a property, I could (depending on how you 
> assume processing is going to work) need to interpret a literal using 
> its associated datatype machinery.  Suppose, for example, that my 
> runtime processing gets information from two separate collections of RDF 
>   (using different data typing schemes) on the Web, and needs to check 
> two values for equality.  This scenario may be considered beyond our 
> specific scope (since you'd also presumably need to deal with vocabulary 
> differences in the general case), but even if we don't need to have a 
> "clear" picture of how this might work, I'd sure like to have at least a 
> "vague" picture.  We might decide that, as Pat suggests in his example, 
> some inference engine is involved, but that decision, based as it would 
> be on some general agreement on how processing would be done, would be 
> very helpful guidance in understanding the issues, in my opinion.

A very good point. Obviously, comparison of values is as important as
validation of values.

I may be terribly naive and ignorant here, but it seems to me
that this is really straightforward, taking the PDU view of pairings
denoting the values. A given application that needs to compare any
values must know about the data typing schemes being used, map the
literal/type pairs to internal representations of their values, per
the system/platform of the application, perform any necessary coercions, 
and make the comparison. The key to this is simply knowing what the 
values are, obviously, and communicating that identity to the
application. RDF simply provides the pairings (defined via one or more 
idioms) and the application takes it from there.

Or am I really missing something here? (I don't think I am, though)

Cheers,

Patrick
Received on Wednesday, 12 December 2001 18:06:23 EST

This archive was generated by hypermail pre-2.1.9 : Wednesday, 3 September 2003 09:43:02 EDT