On Fri, 2007-02-23 at 20:28 +0100, Andreas Rossberg wrote:
> Tom <tom.primozic@gmail.com> wrote:
> >
> > I think you should take a look at another currently active thread  -
> > "Feature request : Tuples vs. records". One of the red lines there is the
> > comparison of structural versus nominal typing - classes and objects
> > belonging to the former, and modules and records to the latter.
> 
> Not exactly: ML modules employ fully structural typing and subtyping. That 
> is their big strength, in contrast to comparable features in most other 
> languages (particularly typical notions of class).

I wonder if more explanation could be given here? I admit continuing
to be confused by the status of modules.

It seems like a module functor allows both anonymous 
signatures (structural) and also anonymous argument 
modules (structural), yet you cannot have
anonymous functor applications: you have to bind the application to
a module name. If we really had structural typing that name would
simply be an alias. Why can't we eliminate that name? ***

C++ template applications can be anonymous, and that gives them
a major edge over Ocaml modules. Similarly, when you're lucky
enough to be able to use non-modular functor (a function with
polymorphic type) it is much more convenient. For example Hashtbl
provides both alternatives, whereas Set and Map do not (a fact
many people complain about).

*** more precisely, we probably don't want to eliminate the name
most of the time, but we would like to be able to use a 
'Set of int' in several modules without having to *export* 
the type in another module so it can be reused.

This is particularly annoying when it is intractable: for
example I have variant terms some of which contain sets
of terms .. the recursion is easy to represent with
lists but you can't do it with modular data structures.
The way I do it is make sets of integers instead and 
keep a term table indexed by the integers. But this isn't
really safe. There's probably a better way but the fact
remains if I want the type safety I have to use lists
or some other non-modular data structure: the modules
actually get in the way of type safety instead of 
enhancing it. I guess the 'recursive modules' stuff will
help fix this?


-- 
John Skaller <skaller at users dot sf dot net>
Felix, successor to C++: http://felix.sf.net