Re: Formal and informal type systems?

[Marius Amado Alves <amado.alves@netcabo.pt>]

> There is more to ML types, and reflection is not in sight.
> Will your Patterns handle argument pattern matching like in the
> following ML example (which omits curried functions, but uses
> functions as values and in patterns)?

An application of Patterns to types would only work in Reflexive_Ada.

> (* a polymorphic recursive type *)
> datatype Foo =
> 	 Pea				(* a single item *)
>        | Coord of int * int 		(* a point *)
>        | Finder of Foo -> string	(* some function *)
>        | Spider of Foo list;		(* a Foo is a Foo is a ... *)
> 
> fun explnum (Pea)         = [(0, "a pea")]
>   | explnum (Coord(x, y)) = [(x * y, "product")]
>   | explnum (Finder(f))   = [(String.size (f (Finder f)), "apply")]
>   | explnum (Spider [])   = [(0, "done")]
>   | explnum (Spider(w :: ws)) = hd (explnum w) :: explnum (Spider ws);
> 
> fun print (Pea) = "P"
>   | print (Coord(_, _)) = "C"
>   | print (Finder(_)) = "F"
>   | print (Spider []) = ""
>   | print (Spider(w :: ws)) = "(" ^ (print w) ^ print (Spider ws) ^ ")";
> 
> val sample = Spider([ Pea,  Spider([Coord(47, 11)]),  Finder(print) ])
> 
>       When I now write
> - print sample;
>       I get
> val it = "(P((C)(F)))" : string
> 
>       Typing
> - explnum sample;
>       gives
> val it = [(0,"a pea"),(517,"product"),(1,"apply"),(0,"done")]
>   : (int * string) list
> 
>       Now, see what is already there...
> -ListPair.unzip;
> val it = fn : ('a * 'b) list -> 'a list * 'b list
> 
> For me, the nice thing here is that the "dispatching" subprogram definitions
> for the "Foo'class types" are always next to each other. They must be
> exhaustive or else you will be warned, I find this similar to Ada's case
> statements. Last but not least, using argument patterns resembles
> definition by cases :-)
> 
> (The list (tree, ...) functions and functionals are valuable in
> functional programming.  Similar mechanisms are available with STL
> algorithms. Ada.Containers offers a way to make a similar set of
> useful subprograms. Only, the Ada.Containers way. :-)

See, Ada can do it :-)

But I have no beef conceding that ML is better at this than Ada.

Your code would translate to an Ada class of tagged types rooted at Foo 
and classwide types to simulate types values. I'll let the realisation 
of this as an exercise to the OOP folks :-)

(Is there a comp.lang.comparate group?)