What is the OCaml counterpart to Python's "with"-statement (automatic release of resources)

Question

What is the OCaml counterpart to Python's "with"-statement?

with open('test.txt', 'r') as f:
    # Do stuff with f
# At this point, f will always be closed, even in case of exceptions

That is: What is the preferred way in OCaml to safely ensure that a certain resource (open file, database connection, HTTP connection, etc.) will always be freed at a certain point in time? Waiting for the garbage collector is no option here, and exceptions should never prevent resources from being freed.

Of course, in OCaml you can always use try-finally and close the file "by hand", as you can do in Python. However, that kind of code is prone to errors. This is why Python introduced the "with"-statement. What's the OCaml idiom to make this kind of code easier to read and less prone to errors?

Note that this question is very different from the question Emulating try-with-finally in OCaml, as this is one step further: I don't just want to emulate try-finally in OCaml! (where Lwt's [%finally ...] does a fine job, by the way.) I want to get one step further, eliminating the need to write those finally-clauses in the first place - as one can do in Python.

Also note that this question is not about implementation details, but about idioms: Which of all possible designs and solutions gained some traction in the OCaml community and is generally accepted?

Answer 1

There is now Fun.protect which may be considered (effectively) the idiom, since it's in the standard library. E.g.,

let get_contents file =
  let ch = open_in file in
  Fun.protect ~finally:(fun () -> close_in ch) begin fun () ->
    let len = in_channel_length ch in
    let bytes = Bytes.create len in
    ignore (input ch bytes 0 len);
    bytes
  end

Nowadays, there are even let-operators which are slowly finding their way into more frequent use, e.g. https://github.com/ocaml/ocaml/pull/9887

So you could define a let-op to use a file, like:

let ( let& ) ch fn =
  Fun.protect ~finally:(fun () -> close_in ch) begin fun () ->
    fn ch
  end

And use it like:

let get_contents file =
  let& ch = open_in file in
  let len = in_channel_length ch in
  let bytes = Bytes.create len in
  ignore (input ch bytes 0 len);
  bytes

The let& operator makes sure the in_channel is closed at the end of the current scope (get_contents).

Answer 2

JaneStreet's core_kernel standard library replacement provides exactly what you need in the form of In_channel.with_file. So if by any chance you are using core_kernel, see for usage examples here: https://dev.realworldocaml.org/imperative-programming.html#file-io

Answer 3

There are some reasonable answers here (emulating try with finally in ocaml), although the absence of macros makes it somewhat more cumbersome than would otherwise be the case (see eg this complaint under "No macros")

Answer 4

"with" in python uses special objects that manage resources and have a cleanup function that gets called when the "with" is done. Ocaml has no such thing. But you could implement them.

Something like:

let with_ (constructor, destructor) fn =
   let obj = constructor () in
   try
       let res = fn obj in
       destructor obj;
       res
   with exn ->
       destructor obj;
       raise exn

Or use an ocaml object that has a destroy method.

What it comes down to is that you hide your finally-clauses in the destructor or destroy method so you doin't have to write it manually.

Answer 5

Another simple implementation.

Let's first define a type which represents either a result, or an exception:

type 'a okko = Ok of 'a | Ko of exn

Then, define capture_errors:

let capture_errors fn = try Ok (fn ()) with e -> (Ko e);;

You can them implement unwind_protect:

let unwind_protect wind unwind =
  let result = (capture_errors wind) in
  begin
    unwind ();
    match result with
    | Ok (result) -> result
    | Ko (error) -> raise error
  end;;

The above consistently execute unwind once.

You could then define a generic with_ function:

let with_ enter leave body =
    let e = enter() in
    unwind_protect
      (fun () -> (body e))
      (fun () -> (leave e)) ;;

For example, with_open_file might be defined as:

let with_open_file opener closer file fn =
  with_
    (fun () -> (opener file))
    (fun (chan) -> (closer chan))
    fn

You can curry open_in and close_in in the common case:

let with_input_file = with_open_file open_in close_in;;

For example:

with_input "/etc/passwd" input_line