From: Thorsten Ohl <ohl@physik.uni-wuerzburg.de>

> I need to create tuples of mutually dependent objects.  A working
> implementation adds a mutable instance variable that is updated after
> all objects in a tuple have been created.  With a little bit of work,
> this variable can then be hidden.  However, this is a bit tedious.
> Why is the much more elegant approach using `let rec' forbidden?
> 
> Is there a chance that this restriction will be lifted or would such
> permissiveness undermine type safety?

Sure it would: the type system cannot ensure that o1 and o2 will be
initialized at the right time. That is, you could end up with null
pointer errors, which from ocaml point of view are holes in the type
safety. By not allowing them, ocaml also avoids the cost of
dynamically checking for null pointer, as Java does for instance.

A generic answer to that is to use lazy variables (they are more
clever in 3.05).

# class o n o' =
  object (_ : 'a)
    method o' : 'a =     Lazy.force o'
    method n : int = n
  end;;    
class o : int -> 'a Lazy.t -> object ('a) method n : int method o' : 'a end
# let rec o1 = lazy (new o 1 o2) and o2 = lazy (new o 2 o1);;
val o1 : o Lazy.t = <lazy>
val o2 : o Lazy.t = <lazy>
# let o1 = Lazy.force o1 and o2 = Lazy.force o2;;
val o1 : o = <obj>
val o2 : o = <obj>

Note that it will not protect you against null pointer errors, it will
just allow you to detect them at runtime. You can see this with:

# class o n o' =
  let o' = Lazy.force o' in
  object (_ : 'a)   
    method o' : 'a = o'
    method n : int = n
  end;;    
class o : int -> 'a Lazy.t -> object ('a) method n : int method o' : 'a end
[..]
# let o1 = Lazy.force o1 and o2 = Lazy.force o2;;
Exception: Lazy.Undefined.
(Stack overflow with previous versions)

Jacques Garrigue
-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners