> In O'Caml the types are compiled away, right?

Yes, in a sense, but they are also used to determine memory
representation of data to some extent.

> Then, is there actually a performance/memory overhead in replacing:
>   type coord = int * int
> with:
>   type coord = Coord of (int * int)

There is no memory overhead with the following two definitions:

    type coord = Coord of int * int
    type coord = {x:int; y:int}

In both cases, values of type coord will be represented by a two-word
memory block (plus one word of header) holding the two integers --
just like a pair of integers int*int.

However, there *is* some overhead with your proposed

   type coord = Coord of (int * int)

that is interpreted as "Coord takes one argument that is a pair",
causing two memory blocks to be used, one for the pair, one for the
application of Coord.  In contrast,

    type coord = Coord of int * int

instructs the compiler to treat Coord as taking two arguments that are
integers.

> Is it recognized as a 'reasonable' way to get the type system to help me not
> mixing up stuff (except for signatures of course)?

Yes, it's one way to do it.  The other is to use abstract types via
signature constraints, as you said.

> Slightly more general:  Did I miss any doc. about this in the O'Caml manual?

The chapter "interfacing C with OCaml" contains a *lot* of details on
the data representations used by compiled code.  Perhaps more details
than you'd like to know :-)  

- Xavier Leroy

-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners