RE: [Caml-list] Scoped Bound Resource Management just for C++?

[Jon Harrop <jonathandeanharrop@googlemail.com>]

Orbitz wrote:
> One of the benefits, in my opinion, of C++ is SBRM.  You can reason
> about the lifetime of an object and have an give yourself guarantees
> about its clean up.  The method of initialization and clean up are
> also consistent for every object in the language.
> 
> My questions are:
> 1) Do other people in the FP world consider this to be a good strategy?

For some kinds of resources under some circumstances, yes.

> 2) Can this be done in a sane way in a GCd language?

Yes, of course. You just use a higher order function to factor out the
pattern of initializing and cleaning up the resource. For example, the
following "file" function opens a file, applies the given function "f" to
the resulting channel and then closes the channel:

  let file name f =
    let ch = open_in name in
    try
      let x = f ch in
      close_in ch;
      x
    with e ->
      close_in ch
      raise e

The OOP equivalent is called the command pattern. On the .NET platform, this
pattern is provided by the IDisposable interface and languages like C# and
F# even include syntactic support for it. This is used to handle resources
that benefit from deterministic cleanup, like file handles.

> 3) What are the alternatives in a language like Ocaml?

The most obvious alternative is to leave clean up to the garbage collector
by using a finalizer. When the resource is either memory or equivalent to
memory, this works extremely well in practice and is simpler than manual
memory management. For example, I once used the garbage collector to clean
up OpenGL display lists. However, this is not generally advised for
non-memory resources because they tend to be much more precious and,
therefore, prone to being exhausted.

Cheers,
Jon.