Module Fmlib_std.ResultSource

Result: Handling results of operations which can fail

Overview

Operations returning a result type can be used to have some functional exception handling.

Let's say that you have some operatios returning a result object.

    let op1 ...  : (int,    error) result  = ...
    let op2 ...  : (char,   error) result = ...
    let op3 ...  : (string, error) result = ...
    let op3 ...  : (t,      error) result = ...

You can chain these operations by concentrating on the success case only and handling the error case at the end of the chain.

    match
        let* i = op1 ...  in
        let* c = op2 ... i ...  in
        let* s = op3 ... i ... c ...  in
        op4 ... i ... c ... s
    with
    | Ok x ->
        (* Handling of the success case *)
    | Error e ->
        (* Handling of the error case which might have
           occurred in any of the steps *)

A simple example:

    type 'a r = ('a, string) result

    let add (a: int r) (b: int r): int r =
        let* x = a in
        let* y = b in
        Ok (x + y)

    let divide (a: int r) (b: int r): int r =
        let* x = a in
        let* y = b in
        if y = 0 then
            Error "Division by Zero"
        else
            Ok (x / y)

    assert (
        add (Ok 1) (divide (Ok 2) (Ok 0))
        =
        Error "Division by Zero"
    )

    assert (
        add (Ok 1) (divide (Ok 10) (Ok 2))
        =
        Ok 6
    )

API

Monad