Bug? Constraints get ignored in methods

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

Hi,

I want to keep a linked list of structures that have a common subset
of functionality. I thought this would be a good use of ocaml objects.
A base class with the common subset of functionality and methods to
link them. And then derived classes for the specific types. Most
simplified it looks like this:

# class type base_type = object val mutable next : base_type option method set_next : base_type option -> unit end;;
class type base_type =
  object
    val mutable next : base_type option
    method set_next : base_type option -> unit
  end

# class base : base_type = object val mutable next = None method set_next n = next <- n end;;
class base : base_type

# class foo = object inherit base method foo = () end;;
class foo :
  object
    val mutable next : base_type option
    method foo : unit
    method set_next : base_type option -> unit
  end

# let a = new base in
    let b = new foo in
      a#set_next (Some (b :> base_type));;
- : unit = ()

# let a = new base in
    let b = new foo in
      a#set_next (Some b);;
                       ^
Error: This expression has type foo but is here used with type base_type
       The second object type has no method foo

This last error isn't nice. I don't want to have to cast the objects
all the time. So I thought there must be a better way using
polymorphic methods with a constraint. But here is where everything
breaks down. First lets look at just the set_next method:

# class type virtual vbase_type = object method virtual set_next : 'a. 'a option -> unit constraint 'a = #vbase_type end;;
class type virtual vbase_type =
  object method virtual set_next : 'a option -> unit end

# class virtual vbase : vbase_type = object method virtual set_next : 'a. 'a option -> unit constraint 'a = #vbase_type end;;
class virtual vbase : vbase_type

# class base = object inherit vbase method set_next _ = () end;;
class base : object method set_next : 'a option -> unit end

# let b = new base;;
val b : base = <obj>

# b#set_next (Some 1);;
- : unit = ()

Huh? That should not work. 1 is not a superset of #vbase_type. The
constraint gets completly ignored by ocaml. Adding back the next gives
further problems:

# class type virtual vbase_type = object val mutable next : #vbase_type option method virtual set_next : 'a. 'a option -> unit constraint 'a = #vbase_type end;;
class type virtual vbase_type =
  object
    val mutable next : #vbase_type option
    method virtual set_next : 'a option -> unit
  end

# class virtual vbase : vbase_type = object val mutable next = None method virtual set_next : 'a. 'a option -> unit constraint 'a = #vbase_type end;;
class virtual vbase : vbase_type

# class base = object inherit vbase
    method set_next n = next <- (n :> vbase_type option) end;;
                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Error: This method has type #vbase_type option -> unit
       which is less general than 'a. 'a option -> unit

Again I  blame ocaml for dropping the constraint. Given the constraint
the type would be correct.



So how do I have to specify the set_next method that any superset of
#base_type will be accepted as argument? Or is that a bug in ocaml and
my syntax is perfectly fine?

MfG
        Goswin