Hi,

Your first two examples compile without problem on my system, using either
v. 3.11.2 or 4.00.
If you use a parameterized registry class on the element type, you will not
be able to store polymorphic values, which is, I reckon, what you
probably want to achieve.
I don't think there's a way to avoid casting the parameters of set to the
#element superclass outside the set method. If you only have one final
element class, just use the parameterized version of the registry, or
replace the register method by a private register_elem method, and add a
public register method in the subclass, doing the cast.

Something like that :

module P =
struct

  class element id (registry :registry) =
  object
    method registry = registry
  end

  and registry =
  object
    val mutable set : element list = []
    method register_elem : element -> unit =
      fun s ->
        set <- s :: set
  end

end

module I =
struct

  class element id registry =
    let r = (registry :> P.registry) in
  object(self)

    inherit P.element id r as super

  end

  class registry =
  object(self)

    inherit P.registry as super

    method register : element -> unit =
      fun x -> super#register_elem (x :> P.element)

  end

end

Cheers,

Didier

2012/10/24 Christopher Zimmermann <madroach@gmerlin.de>

> On Wed, 24 Oct 2012 20:40:27 +0200
> Gabriel Scherer <gabriel.scherer@gmail.com> wrote:
>
> > I don't really understand what you are trying to achieve with this
> > #foo types.
>
> It's the simplest statement possible to demonstrate the typing error I
> ran into. Even simpler:
>
> class type a = object end
> and b =
>   object
>     method foo: 'a. (#a as 'a) -> unit
>   end
>
>   fails, but
>
> class type a = object end
> class type b =
>   object
>     method foo: 'a. (#a as 'a) -> unit
>   end
>
>
> works fine. Why?
>
> > What would even be the type of "set" in your example? You
> > cannot hold a mutable reference to a polymorphic type (#element list),
> > so I'm not sure what you would have but (element list).
> That's correct. It should read
>   val mutable set = []
>   method register :'a. (#element as 'a) -> unit =
>     fun s ->
>       set <- (s : #element :> element) :: set
>
> > If you're
> > going to coerce your elements into the common (element) supertype
> > anyway, why insist on having flexible bounds? You could just use
> > (registry) and (element), coerce when needed (foo :> element), and get
> > rid of those pesky typing issues.
>
> That's my current workaround for this issue. But I would prefer a
> solution where the coercion happens in the registry.
>
> >
> > On Wed, Oct 24, 2012 at 8:03 PM, Christopher Zimmermann
> > <madroach@gmerlin.de> wrote:
> > > Hi,
> > >
> > > I have a problem with typing a system of mutually recursive classes.
> > >
> > > This piece of code fails to compile:
> > >
> > > class a =
> > >   object end
> > > and b =
> > >   object
> > >     method foo: a -> int =
> > >       fun s -> 3
> > >   end;;
> > >
> > > Error: The universal type variable 'a cannot be generalized:
> > >        it escapes its scope.
> > >
> > >
> > > But this compiles fine:
> > >
> > > class a =
> > >   object end
> > > class b =
> > >   object
> > >     method foo: 'a. (#a as 'a) -> int =
> > >       fun s -> 3
> > >   end;;
> > >
> > >
> > > What I actually want to do is this:
> > >
> > > class element id (registry :#registry) =
> > >   object
> > >     method registry = registry
> > >   end
> > >
> > > and registry =
> > >   object
> > >     val set = []
> > >     method register :'a. (#element as 'a) -> unit =
> > >       fun s ->
> > >         set <- s :: set
> > >   end
> > >
> > >
> > > Any ideas how to do this without parametrizing the classes?
> > >
> > > Christopher
>
>
> --
> Caml-list mailing list.  Subscription management and archives:
> https://sympa.inria.fr/sympa/arc/caml-list
> Beginner's list: http://groups.yahoo.com/group/ocaml_beginners
> Bug reports: http://caml.inria.fr/bin/caml-bugs
>