From: Dimitri Ara <dimitri@nerim.net>

> While ICFPing, I came upon some strange typing error messages.
> 
> The first one is :
> 
> class type ct = object
>   method m : l:int -> ct
> end
> 
> let rec f (o : ct) =
>   let rec g o =
>     let x = o#m 1 in
>       g x in
>     g o
>
> This expression has type ct = < m : l:int -> ct > as 'a
> but is here used with type 'a

Indeed not very instructive. Ah, backtracking on unification...
Could you file a bug? I will try to fix it.

By the way, the real problem in the above code is that the type
annotation is not in a useful place. It should be where you are going
to call methods:
  let rec f o =
    let rec g (o : ct) =
      let x = o#m 1 in
        g x in
      g o

> The second one is ill-typed and get the same error message:
> 
> class type ct = object
>   method m : l:int -> int
> end
> 
> let rec f (o : ct) =
>   let rec g o =
>     let x = o#m 1 in
>       g x in
>     g o

Sure: the problem is with the label, same cause, same effect.

> If I remove the label I got a stranger error:
> 
> This expression has type ct = < m : int -> int > as 'a
> but is here used with type 'a
> Type int is not compatible with type ct = 'a 

Same kind of unification problem. Fortunately, the second line is more
helpful: an int was unified wis a ct.

With right annotation you get:
# let rec f o =
    let rec g (o : ct) = 
      let x = o#m 1 in
      g x in
        ^
    g o;;
This expression has type int but is here used with type
  ct = < m : l:int -> int >

Cheers,

Jacques Garrigue
-------------------
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