]> On Mon, 22 Dec 2003, Alex Baretta wrote: > Here's a puzzle for the Caml breeders: > > # type poly = { f : 'a . 'a -> 'a };; > type poly = { f : 'a. 'a -> 'a; } > # let id x = x;; > val id : 'a -> 'a = <fun> > # let foo = { f = id };; > val foo : poly = {f = <fun>} > # let rec id x = x and foo = { f = id } ;; > This field value has type 'a -> 'a which is less general than 'b. 'b -> 'b > > Why is this last recursive definition unacceptable? > > Alex > Types are not generalized within the scope of their recursive declaration. For instance, take this contrived definition of the identity function : let rec id x = if true then (ignore(id 1); x) else ((ignore (id [])); x) ^^ This expression has type 'a list but is here used with type int Although id could be safely be assigned the type 'a . 'a -> 'a, the type inference algorithm cannot figure it out. It is a limitation that raises from the way the type inference is computed. Then again, it isn't much of a limitation: both my example and yours can trivially be rewritten such that they type. Also, this is one good reason to not use the 'and' keyword unless you actually need a mutual recursion. Instead of writing this: let a = ... body_a ... and b = ... body_b ... in ... write this: let a = ... body_a ... in let b = ... body_b ... in ... It will save you the above error in the case 'body_b' uses 'a' polymorphically. -- "The thing I remember most about America is that it's silly. That can be quite a relief at times." -- Thom Yorke, Radiohead - Guillaume ------------------- 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