Re: [Caml-list] Confusing behaviour of type inference for polymorphic classes.

[Jeremy Yallop <yallop@gmail.com>]

On 3 December 2013 17:49, Dmitri Boulytchev <dboulytchev@gmail.com> wrote:
>   Here subm is a legitimate subclass of m with the desired behaviour [...]. So I don't see why I'm loosing the ability to subtype.

You're quite right, of course: you still have subtyping.  What you're
giving up are some of the benefits of inheritance, since the
"recursive" calls go through the instance you pass in rather than
through a self variable.  If you don't have other reasons for using
objects and classes it might be worth considering using records
instead, since they're semantically much simpler.  The example should
translate directly:

  type ('a, 'b, 'ta, 'tb) m' =  {
    t : ('a -> 'ta) -> ('b -> 'tb) -> ('a, 'b) t -> ('ta, 'tb) t
  }

  let proto_m f = {
    t = fun fa fb s ->
    ...

  let m' f =
    let super = proto_m f in {
      super with t = fun fa fb s ->
    ...

> It seems to me that this workaround can be used to overcome the "regular class" restriction completely in a syntax-conversion manner. I appreciate any comments.

Yes, it's a neat approach!  One small suggestion: in order to handle
the case where the type you're traversing has multiple recursive
instantations with different parameters you might consider passing the
instance creation function in a way that allows it to be called
polymorphically (e.g. by wrapping it in a record with a polymorphic
field):

  type new_proto_m = {
     new_proto_m : 'a 'b 'ta 'tb .
         unit -> <t : ('a -> 'ta) -> ('b -> 'tb) ->
                      ('a, 'b) t -> ('ta, 'tb) t>
  }

There is one last thing I'm curious about.  The difficulties that
you're avoiding with open recursion seem to arise from the
representation of the traversal as a parameterised class with a
monomorphic method.  Have you considered switching things round and
using an unparameterised class with polymorphic methods instead?  I
think everything turns out much simpler if you do: you can use
straightforward inheritance, calls through self, etc.

  class m =
  object (self)
    method t : 'a 'b 'ta 'tb. ('a -> 'ta) -> ('b -> 'tb) ->
                              ('a, 'b) t -> ('ta, 'tb) t =
      fun fa fb s ->
        match s with
        | A (a, bat) -> A (fa a, self#t fb fa bat)
        | B  a       -> B (fa a)
  end

The map and fold generators supplied with Camlp4 use a variant of this
approach, and it seems to work well in practice.