W3C home > Mailing lists > Public > www-webont-wg@w3.org > September 2002

RE: GUIDE: Syntax query re parseType=

From: Smith, Michael K <michael.smith@eds.com>
Date: Tue, 3 Sep 2002 10:40:58 -0500
Message-ID: <B8E84F4D9F65D411803500508BE32214102E1324@USPLM207>
To: Jeff Heflin <heflin@cse.lehigh.edu>
Cc: www-webont-wg@w3.org

There are two things going on with the parseType="rdf:collection" cliche in

1. We use it exclusively to refer to sets.  None of the semantics of
constructs that use it support lists or bags.

2. We use it to carry the information that, contra typical OWL assertions,
the set is completely described by the list of elements.

With respect to 1, it is redundant.  As far as I can tell, ALL uses of
parseType="rdf:collection" in OWL are in contexts that are intended to
describe sets: oneOF, unionOf, etc.  If the parseType tag is not present,
the elements contained in the parent construct are still taken to be sets.
The only distinction is whether the set is open (potentially extensible) or

Which is why the name represents an odd choice IN OWL.  And that is why I
was having some trouble with the Guide explanation.

In a strict RDF context it is very useful, since it supports a precise and
unambiguous list interpretation in those cases where an open-ended list is
undesirable.  An additional feature is that it simplifies the translation of
other formalisms into RDF.  Lists are quasi-dark triples.

We could solve this in the OWL syntax, with an OWL tag
(owl:setType="closed") that translates to an RDF tag.

But I assume that most of the confusion over this will be handled by tools.
The more I write OWL, continuing to confuse which prefix I use with which
keyword, the more convinced I am that the only way OWL will move forward is
with front end support.

- Mike

Michael K. Smith, Ph.D., P.E.
EDS - Austin Innovation Centre
98 San Jacinto, #500
Austin, TX  78701

* phone: +01-512-404-6683
* mailto:michael.smith@eds.com

-----Original Message-----
From: Jeff Heflin [mailto:heflin@cse.lehigh.edu]
Sent: Friday, August 30, 2002 4:24 PM
To: Smith, Michael K
Cc: www-webont-wg@w3.org
Subject: Re: GUIDE: Syntax query re parseType=

I have also come to believe that collection was a bad choice of keyword.
In hindsight, I think "daml:ClosedList" would have made its purpose much
clearer. Does anybody else care enough that I should raise this as an
issue for OWL?


"Smith, Michael K" wrote:
> Ok.  I find the choice of keyword bizarre.  Mixing syntax
> and semantics in an odd way.
> So the difference between
>         <daml:oneOf rdf:parseType="daml:collection">
>           <rdf:li> <Person rdf:id="John" /> </rdf:li>
>           <rdf:li> <Person rdf:id="Bill" /> </rdf:li>
>         </daml:oneOf>
> and
>         <daml:oneOf>
>           <rdf:li> <Person rdf:id="John" /> </rdf:li>
>           <rdf:li> <Person rdf:id="Bill" /> </rdf:li>
>         </daml:oneOf>
> is that I can prove that the first one has exactly 2 elements?
> While I can't extend the second one (since I can't reference it), the
> semantics don't require that it be closed.
> -----Original Message-----
> From: Peter F. Patel-Schneider [mailto:pfps@research.bell-labs.com]
> Sent: Thursday, August 29, 2002 9:37 AM
> To: Smith, Michael K
> Cc: www-webont-wg@w3.org
> Subject: Re: GUIDE: Syntax query re parseType=
> From: "Smith, Michael K" <michael.smith@eds.com>
> Subject: GUIDE: Syntax query re parseType=
> Date: Thu, 29 Aug 2002 09:25:04 -0500
> >
> > Help.  I'm trying to explain some syntax in the Guide document.
> >
> > Why do we have rdfs:parseType tacked onto the various set operators?
> > Obviously, we inherited it from DAML+OIL, but I don't understand the
> > for it there, either.
> >
> > As far as I can tell, it is completely redundant in the XML syntax.
> > is, there is no other possible interpretion of the children of oneOf,
> > unionOf, and intersectionOf.
> >
> > What am I missing?
> >
> > - Mike
> The reason for rdf:parseType="daml:collection" is to allow for a
> way of supplying lists.  The problem is that a construct like
>         <daml:oneOf rdf:id="MySet">
>           <rdf:li> <Person rdf:id="John" /> </rdf:li>
>           <rdf:li> <Person rdf:id="Bill" /> </rdf:li>
>         </daml:oneOf>
> is not closed.  Anyone can do something like
>         <daml:oneOf rdf:id="peter:MySet">
>           <rdf:li> <Person rdf:id="Susan" /> </rdf:li>
>         </daml:oneOf>
> to add another element of the set.
> There are very bad consequences of a construct like this.
> To get around this inadequacy of RDF, DAML+OIL has a list construct and
>         <daml:oneOf rdf:parseType="daml:collection">
>                 <Person rdf:id="John" />
>                 <Person rdf:id="Bill" />
>         </daml:oneOf>
> which expands to
>         <daml:oneOf>
>                 <daml:List>
>                         <daml:first>
>                                 <Person rdf:id="John" />
>                         </daml:first>
>                         <daml:rest>
>                                 <daml:List>
>                                         <daml:first>
>                                                 <Person rdf:id="Bill" />
>                                         </daml:first>
>                                         <daml:rest>
>                                                 <daml:list
> rdf:id="daml:nil">
>                                         </daml:rest>
>                                 </daml:List>
>                         </daml:rest>
>                 </daml:List>
>         </daml:oneOf>
> and cannot be non-monotonically messed with.
> (I may have some of the details wrong, but you should be able to get the
> idea.)
> peter
Received on Tuesday, 3 September 2002 11:41:13 UTC

This archive was generated by hypermail 2.3.1 : Tuesday, 6 January 2015 21:56:47 UTC