Hi Bry,

bry@i... wrote:

>I was just thinking about this, having switched over from coffee to tea this
>morning. It struck me as sort of weird. 
>
>  
>
I can assure you, it's not weird. Many people, including myself, 
occasionally switch from coffee to tea and back : )

>Let us suppose that one had a datatype defined for social security number, this
>would essentially be a regular expression specifying how a SSN should be
>written. 
>
>  
>
so far so good. Fixing an example, let's say D is for digits, A is a 
regexp for some class letters, B is a regexp for other letters, and the 
simple SSN regexp was

DD-AABDD-DDDD

>now a ssn has more information implicit in it than just the SSN. There is
>information that one could use to find out what state issued the number for
>example, in the prefix.
>  
>
Maybe the DD-AA part, after the first dash.

>Let us suppose then that we had a definition for a structure which splits the
>SSN into two elements. The combined strings of both elements matches the
>datatype, this is something I would like to be able to specify. 
>
>Why not specify just a type that says a SSN type has two elements? 
>
>because in some formats that would be overkill. 
>
>  
>
The classical example is the expiry date of a credit card, 31.12.9999 
(German notation) fitting in a couple of bits, compared to  
<date><day><month><year> madness. So people specify a regexp for the 
whole and leave the work of decomposing into days/months/years to 
application developers.

>Perhaps I am uninformed however, can anyone think of any particular schema
>language one can do this in, and if you are the person who knows of such a
>language can you give me an example if possible. (not that it's something I
>need
>to do, just something I thought would be extremely useful to be able to do at
>some point)
>
>  
>
I certainly do not know any schema language that deals with "segmented" 
regular expressions.

However, in research languages, regular pattern matching is getting 
quite popular. In Scala for instance, your SSN could be decomposed like this

def decomp(ssn:Seq[Char]):Pair[Seq[Char],Seq[Char]] = ssn match {
  case (part1 @ DD-AA)(part2 @ BDD-DDDD) => Pair(part1, part2)
  case _ => error("invalid ssn")
}

(this is sloppy syntax, of course D,A,B have to be real regular 
expressions, and Scala for instance does not have POSIX character 
classes, so it is very tedious to actually write, but you get the idea: 
the "variable @ regexp" construction binds whatever matched regexp to 
variable, in a much nicer way then the typical Perl / Java regexp madness)

Many others (Xduce, Cduce, XEN/C_omega) offer similar mechanisms, which 
work often also with sequences of XML nodes, or numbers, or whatever. In 
other words, this seems something of general use, beyond XML.

I once had the idea of adding this feature of pattern matching to a (yet 
another) type system for objects and XML(turning sequences of nodes in 
something like a record). Glad there seems to be use for it.

cheers,
Burak