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
_______________________________________________
Caml-list mailing list. Subscription management:
http://yquem.inria.fr/cgi-bin/mailman/listinfo/caml-list
Archives: http://caml.inria.fr
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners
Bug reports: http://caml.inria.fr/bin/caml-bugs
