Simple PPX rewriter to catch exceptions and wrap the result into (‘a, string) result

Overview

May be useful to handle the case when the function inside List.map fails:

let%catch func lst =
  List.map (fun x ->
    if x > 0 then failwith "Some problem" else x + 1) lst 

becomes:

let%catch func lst =
  try
    Ok (List.map (fun x ->
      if x > 0 then failwith "Some problem" else x + 1) lst)
  with
  | Failure err -> Error (*[ "func: " + err ]*) (* error messages with tracing *)
    (* and so on *) ...
  | _ -> Error "func: Unknown error" 

Extension handles both top-level and “embedded” let bindings:

let foo =
  let%catch wants_to_raise () = (* wrap some Stdlib function for example *)
    (* some logic *)
    failwith "Stdlib exception" (* call to Stdlib function that raises an exception *)
  in

  wants_to_raise () (* returns ('a, string) result *)

Also works with “function” syntax:

let%catch wrap_function = function
  | Some res -> res
  | None -> failwith "function syntax works too"

It basically wraps each case of the pattern matching.

let () =
  match wrap_function None with
  | Ok ok -> Printf.printf "Ok\n" ;
  | Error err -> Printf.printf "%s\n" err ;
  () 

prints :

wrap_function: function syntax works too

Quickstart

To instal this rewriter as opam package:

git clone https://github.com/slamko/ppx_catch.git &&
cd ppx_catch &&
dune build &&
opam install .

Now to use it in your project add ppx_catch to library list and tell to use it as a preprocessor in your dune file:

(libraries
            ppx_catch)
(preprocess (pps ppx_catch))

For a complete dune file example see test/dune

LICENSE

GPL-v3.0