Batteries user guide : BatResult

# Module BatResult

    module BatResult: sig .. end

Monadic results of computations that can raise exceptions

    type ('a, 'b) t = ('a, 'b) BatPervasives.result =

`|` | `Ok of `'a``
`|` | `Bad of `'b``

The type of a result. A result is either `Ok x` carrying the normal return value `x` or is `Bad e` carrying some indication of an error. The value associated with a bad result is usually an exception (`exn`) that can be raised.
Since 1.0

    val catch : ('a -> 'b) -> 'a -> ('b, exn) t

Execute a function and catch any exception as a result. This function encapsulates code that could throw an exception and returns that exception as a value.
Since 1.0

    val catch2 : ('a -> 'b -> 'c) -> 'a -> 'b -> ('c, exn) t

As `catch` but two paramaters. This saves a closure construction
Since 2.0

    val catch3 : ('a -> 'b -> 'c -> 'd) -> 'a -> 'b -> 'c -> ('d, exn) t

As `catch` but three paramaters. This saves a closure construction
Since 2.0

    val get : ('a, exn) t -> 'a

`get (Ok x)` returns `x`, and `get (Bad e)` raises `e`. This function is, in a way, the opposite of the `catch` function
Since 2.0

    val default : 'a -> ('a, 'b) t -> 'a

`default d r` evaluates to `d` if `r` is `Bad` else `x` when `r` is `Ok x`
Since 2.0

    val map_default : 'b -> ('a -> 'b) -> ('a, 'c) t -> 'b

`map_default d f r` evaluates to `d` if `r` is `Bad` else `f x` when `r` is `Ok x`
Since 2.0

    val is_ok : ('a, 'b) t -> bool

`is_ok (Ok _)` is `true`, otherwise `false`.
Since 2.0

    val is_bad : ('a, 'b) t -> bool

`is_bad (Bad _)` is `true`, otherwise `false`
Since 2.0

    val is_exn : exn -> ('a, exn) t -> bool

`is_exn e1 r` is `true` iff `r` is `Bad e2` with `e1=e2`

    val of_option : 'a option -> ('a, unit) t

Convert an `option` to a `result`
Since 1.0

    val to_option : ('a, 'b) t -> 'a option

Convert a `result` to an `option`
Since 1.0

###### The Result Monad

This monad is very similar to the option monad, but instead of being `None` when an error occurs, the first error in the sequence is preserved as the return value.

    module Monad: sig .. end

###### Infix

    module Infix: sig .. end

This infix module provides the operator `(>>=)`

    val print : ('b BatInnerIO.output -> 'a -> unit) ->
           'b BatInnerIO.output -> ('a, exn) t -> unit

Print a result as Ok(x) or Bad(exn)