> One of the nice things about C++ and Java is that with properly
> designed classes, you don't need to worry about freeing resources
> in complicated code, because the when the objects go out of scope
> either normally or via an exception, they will clean themselves up.

I believe this is a C++-specific idiom.  Java doesn't have
destructors, just finalizers that are called asynchronously by the
GC.  OCaml also has GC finalization (see below).

> Given that Ocaml has objects, it would be useful to have this
> idiom available to us.  Is there a way to implement it, rather
> than just waiting for the garbage collector?

Yes: higher-order functions.  For a file:

let with_file_in filename action =
  let ic = open_in filename in
  try
    let res = action ic in close_in ic; res
  with x ->
    close_in ic; raise x

For a mutex:

let synchronize mut action =
  try
    Mutex.lock mut;
    let res = action () in
    Mutex.unlock mut;
    res
  with x ->
    Mutex.unlock mut;
    raise x

You get the idea.

> Also, since objects have initializers, do they have finializers?  I
> read the entire Oreilly book and didn't see any mention of them.
> Reading the C code interface, it looks like you can associate a
> finalizer function to clean up an abstract type, but can you do
> this with normal Ocaml code?

Yes.  The function Gc.finalise lets you attach finalization code to any
heap-allocated Caml value, not just objects.  I'm not surprised it is
not mentioned in the O'Reilly book, since this is a recent addition to
the OCaml implementation.

- Xavier Leroy
-------------------
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