]> "David Allsopp" <dra-news@metastack.com> writes: > Jon Harrop wrote: >> David Allsopp wrote: >> > I think it would be possible to simulate the SML behaviour in OCaml >> > using camlp4 (if you assume that for [type foo = Bar of int] that future >> > unbound references to [bar] are interpreted as [fun x -> bar x] instead of an >> > error) >> >> Only if you turned multi-argument type constructors into single- >> argument ones >> taking a tuple, i.e. type definitions like: >> >> type t = Bar of int * int >> >> must become: >> >> type t = Bar of (int * int) > > That's not the case at all - there'd be no reason not to interpret [bar] as [fun x y -> Bar(x, y)] for [Bar of int * int]. What would be hairy in camlp4 would be having to read .cmi files to deal with types defined outside your source file, but that's still not impossible... > > > David Then what about type t1 = Bar of int * int type t2 = Foo of (int * int) If you treat constructors as functions taking one argument then t1: int * int -> t1 t2: int * int -> t2 But: # let x = (1,2);; val x : int * int = (1, 2) # Foo(x);; - : t2 = Foo (1, 2) # Bar(x);; Error: The constructor Bar expects 2 argument(s), but is here applied to 1 argument(s) As functions "Bar" would have to deconstruct the tuple while "Foo" uses it directly. And I would rather have curried constructors as in "Bar 1 : int -> t1". The difference between t1 and t2 gets lost. I actually hate that you can write "Bar(1,2)" and "Foo(1,2)" Same problem there. It is unclear if you pass 2 arguments or a tuple. This should really be t1: int -> int -> t1 t2: int * int -> t2 fun x y -> Bar x y fun (x,y) -> Foo (x,y) MfG Goswin