Re: [Caml-list] type inference with classes

[Alain Frisch <alain@frisch.fr>]

Hello,

I don't know if this covers all the case, but you need to keep in mind 
the following points.  Feel free to add to the list.

1. The type-checker will never infer that a method is polymorphic.  You 
need to tell it.

  object(this)
     method f = (this # g 1, this # g true)
     method g x = x
  end

===>

   object(this)
     method f = (this # g 1, this # g true)
     method g: 'a. 'a -> 'a = fun x -> x
   end


2. Same for labeled and optional arguments on methods, when the type for 
the method to be called is not known.

   class virtual c =
     object(this)
       method f = this # g ~x:1 ~y:2 + this # g ~y:1 ~x:2
     end

===>

   class virtual c =
     object(this)
       method f = this # g ~x:1 ~y:2 + this # g ~y:1 ~x:2
       method virtual g: x:int -> y:int -> int
     end

(Note: this is really not specific to objects, a simple (fun g -> g ~x:1 
~y:2 + g ~y:1 ~x:2) has the same effect, but it's likely to hit you if 
you use virtual classes.)

3. When declaring classes, the inferred type must have no free variable. 
  So while the expression "object method f x = x end" is allowed and is 
inferred to have a type "< f : 'a -> 'a >", the following class 
declaration is rejected:

class c = object method f x = x end

Depending on what you want to do, you can either force a specific type 
or make the class parametric:

class c = object method f x : int = x end
class ['a] c = object method f x : 'a = x end


-- Alain




On 8/3/2012 6:23 AM, Ivan wrote:
> Hi!
>
> I've mentioned that in some cases ocaml can't infer type (or maybe it
> can, but didn't want to...) of some objects.
> Right to this moment, I've just do as ocaml wants - annotate a type and
> move forward. But now I want to make things more consciously. The reason
> is simple - sometimes ocaml infers types correctly and denotes a type
> error in my code, but I, mistakenly thinking that it can't infer type of
> object, loose my time in useless type annotating of different
> identifiers. Or vice versa, the code is correct, except for some
> undecidable object type, and I spend h^Wminutes in checking my code for
> errors.
>
> So, I'would like to know the rules of type inference failures with
> object types. In what cases an object type can and must be inferred, and
> in what it must be annotated explicitly?
>
> Can someone share this arcane knowledge or, at least, point me at some
> sources, explaining this issue?
>
> Thanks everybody in advance!