Re: [Caml-list] Infer least upper bound for arguments to functions in rows

[Goswin von Brederlow <goswin-v-b@web.de>]

On Wed, Mar 30, 2016 at 12:28:07PM +0200, Christoph Höger wrote:
> Dear experts,
> 
> is there a way to infer a compatible type for the argument to t#x in the
> function:
> 
> let a t = ignore (t#x t) ; t#x (object end) ;;
> 
> I can easily provide a compatible t, e.g.:
> 
> let t = object method x _ = 23 end
> 
> I can also use a coercion:
> 
> let a t = ignore (t#x (t :> < >)) ; t#x (object end) ;;
> 
> Since < > is the common supertype of both arguments.
> 
> My problem is that in general < > won't suffice for the common type, and
> finding it is a rather complicated process.

I found that this is often a huge problem, esspecially for methods.
You can't always coerce the type and type inference won't infere
polymorphic methods (like t#x above). I've spend hours trying
different ways to not run into "self type may not escape it's class"
or "'a is unbound" errors. In the end I found a quite simple way:

  For each class (type) define a method as_<name> that returns
  (self :> name).

That way you function or method does not take a supertype of some long
winded, complex and possibly recursive class type but a simple
supertype of a class having the as_<name> method and nothing else, e.g.

  method add_widget : 'a . (<as_widget : OWidget.oWidget; ..> as 'a) -> unit

Coming up with the right as_<name> is straight forward and the type
never gets longer than this no matter how complex classes are.

> So I wonder if there is some
> clever rewriting of the function that makes ocamlc infer that type for me?
> 
> Is there any expression that for two (expressions with) different input
> types yields (an expression of) the largest common supertype?
> 
> regards,
> 
> Christoph

I don't think there is any way to get type inference to magically do
the right thing here. The inferecne of polymorphic methods simply
doesn't work that way.

MfG
	Goswin