Hello,
What is the usual way in OCaml to define mutually recursive classes
that share default instances? In order to illustrate my problem, let's
suppose we would like to define a hierarchy of classes defining booleans
/à la/ Smalltalk:
-8<-------------------------------------------------------------
class virtual object_ = object
method virtual to_string: string
end
class virtual boolean = object
inherit object_
method virtual not_: boolean
method virtual or_: boolean Lazy.t -> boolean
method virtual and_: boolean Lazy.t -> boolean
method virtual if_: 'a . 'a Lazy.t -> 'a Lazy.t -> 'a
end
class false_class = object (self)
inherit boolean
method to_string = "false"
method not_ = new true_class
method or_ chk = Lazy.force chk
method and_ _ = (self :> boolean)
method if_ _ chk = Lazy.force chk
end
and true_class = object (self)
inherit boolean
method to_string = "true"
method not_ = new false_class
method or_ _ = (self :> boolean)
method and_ chk = Lazy.force chk
method if_ chk _ = Lazy.force chk
end
(* Default instances (that I would have preferred to inject
directly in definitions above) *)
let false_ = new false_class
and true_ = new true_class
-8<-------------------------------------------------------------
Methods corresponding to message not_ in both false_class and
true_class should ideally return a instance of, respectively, true_class
and false_class that would have been created once and for all (instead
of a fresh instance each time they are invoked). How does one achieve
this in OCaml the functional way? (i.e., without resorting to
references, but also, ideally, without resorting to lazy values)
The use of immediate objects is IMO a better choice to implement
booleans (because I don't want nor need to let users subclass
false_class and true_class). Here is an attempt:
-8<-------------------------------------------------------------
(* Using the same definition of boolean above *)
let rec false_ = object (self)
inherit boolean
method to_string = "false"
method not_ = true_
method or_ chk = Lazy.force chk
method and_ _ = self
method if_ _ chk = Lazy.force chk
end
and true_ = object (self)
inherit boolean
method to_string = "true"
method not_ = false_
method or_ _ = self
method and_ chk = Lazy.force chk
method if_ chk _ = Lazy.force chk
end
-8<-------------------------------------------------------------
I get “Error: This kind of expression is not allowed as right-hand
side of `let rec'”. I wonder why OCaml does not accept the definition of
recursive values like above (notice that references to false_ and true_
are “protected” by method definitions). Wouldn't it be safe to extend
recursive definitions with this pattern?
Cheers,
Sébastien.
--
Caml-list mailing list. Subscription management and archives:
https://sympa-roc.inria.fr/wws/info/caml-list
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners
Bug reports: http://caml.inria.fr/bin/caml-bugs
