RE: [xml-dev] RE: Abstraction in Science, Mathematics, Software,and Mark

["Costello, Roger L." <costello@mitre.org>]

Hi Stephen,

> Are you suggesting or even hinting that it should be possible
> to define a type whose contents are types rather than elements?

Funny you should ask! Yes!

A couple weeks ago I pitched that very idea on the xmlschema-dev list:

--------------------------------------------
           Data Abstraction
Creating a User-Defined Data Type that is a 
  Collection of User-Defined simpleTypes
--------------------------------------------

Decoupling the definition of a simpleType from an element or attribute declaration is very useful. For example, here I define a family name simpleType:

    <xs:simpleType name="Family-name">
        <xs:restriction base="xs:string">
            <xs:minLength value="1" />
            <xs:maxLength value="100" />
            <xs:pattern value="[a-zA-Z' \.-]+" />
        </xs:restriction>
    </xs:simpleType>

Now that it is defined, I can declare any number of elements or attributes to be of that type; for example: 

    <xs:element name="Family-name" type="Family-name" />

    <xs:element name="Surname" type="Family-name" />

    <xs:element name="Last-name" type="Family-name" />

That's nice! 

The definition of the user-defined simpleType and the declaration of the elements are completely decoupled. The Family-name simpleType is a reusable data type.

Suppose I define 2 more simpleTypes. A simpleType for Middle initial: 

    <xs:simpleType name="Middle-initial">
        <xs:restriction base="xs:string">
            <xs:length value="1" />
            <xs:pattern value="[A-Z]+" />
        </xs:restriction>
    </xs:simpleType>

And a simpleType for Given name:

    <xs:simpleType name="Given-name">
        <xs:restriction base="xs:string">
            <xs:minLength value="1" />
            <xs:maxLength value="100" />
            <xs:pattern value="[a-zA-Z' \.-]+" />
        </xs:restriction>
    </xs:simpleType>

Now there are 3 simpleTypes. Collectively, they make up a user-defined "Name" data type.  

Of course, this Name data type is not a simpleType. It is made up of three simpleTypes. 

XML Schema does not have a way to express this so I propose a new capability, <xs:crossProduct>. Here is how to define the Name data type:

    <xs:crossProduct name="Name">
        <xs:componentType ref="Given-name" />
        <xs:componentType ref="Middle-initial" />
        <xs:componentType ref="Family-name" />
    </xs:crossProduct>

That defines a data type that is a cross product of 3 simpleTypes.

Now that it is defined, I can declare any number of elements to be of that data type; for example:

    <xs:element name="Name" type="Name">
        <xs:element name="First" type="Name.Given-name" />
        <xs:element name="MI" type="Name.Middle-initial" />
        <xs:element name="Last" type="Name.Family-name" />
    </xs:element>

Here's a different assignment of element names to the data type and its components: 

    <xs:element name="Customer" type="Name">
        <xs:element name="Given" type="Name.Given-name" />
        <xs:element name="MI" type="Name.Middle-initial" />
        <xs:element name="Surname" type="Name.Family-name" />
    </xs:element>

Here's how the latter would appear in an XML instance document:

    <Customer>
        <Given>Roger</Given>
        <MI>L</MI>
        <Surname>Costello</Surname>
    </Customer>

The important thing to notice is that the data type definition is completely decoupled (abstracted) from the assignment of element names to the component fields of the data type.

To recap: just like xs:simpleType enables the creation of reusable (simple) data types, xs:crossProduct enables the creation of reusable (cross product) data types.

Comments?

/Roger