# Module Std_kernel.Result

    module Result: Result

    type ('ok, 'err) t =

`|` | `Ok of `'ok``
`|` | `Error of `'err``

`'a` is a function's expected return type, and `'b` is often an error message string.

    let ric_of_ticker = function
        | "IBM" -> Ok "IBM.N"
        | "MSFT" -> Ok "MSFT.OQ"
        | "AA" -> Ok "AA.N"
        | "CSCO" -> Ok "CSCO.OQ"
        | _ as ticker -> Error (sprintf "can't find ric of %s" ticker)

The return type of ric_of_ticker could be `string option`, but `(string, string) Result.t` gives more control over the error message.

    include Monad.S2

    val ignore : ('a, 'err) t -> (unit, 'err) t

    val fail : 'err -> ('a, 'err) t

    val failf : ('a, unit, string, ('b, string) t) Pervasives.format4 -> 'a

e.g. `failf "Couldn't find bloogle %s" (Bloogle.to_string b)`

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

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

    val ok : ('ok, 'a) t -> 'ok option

    val error : ('a, 'err) t -> 'err option

    val of_option : 'ok option -> error:'err -> ('ok, 'err) t

    val iter : ('ok, 'a) t -> f:('ok -> unit) -> unit

    val iter_error : ('a, 'err) t -> f:('err -> unit) -> unit

    val map : ('ok, 'err) t -> f:('ok -> 'c) -> ('c, 'err) t

    val map_error : ('ok, 'err) t -> f:('err -> 'c) -> ('ok, 'c) t

    val combine : ('ok1, 'err) t ->
           ('ok2, 'err) t ->
           ok:('ok1 -> 'ok2 -> 'ok3) ->
           err:('err -> 'err -> 'err) -> ('ok3, 'err) t

Returns `Ok` if both are `Ok` and `Error` otherwise.

    val ok_fst : ('ok, 'err) t -> [ `Fst of 'ok | `Snd of 'err ]

`ok_fst` is useful with `List.partition_map`. Continuing the above example:

        let rics, errors = List.partition_map ~f:Result.ok_fst
          (List.map ~f:ric_of_ticker ["AA"; "F"; "CSCO"; "AAPL"])

    val ok_if_true : bool -> error:'err -> (unit, 'err) t

`ok_if_true` returns `Ok ()` if `bool` is true, and `Error error` if it is false

    val try_with : (unit -> 'a) -> ('a, exn) t

    val ok_exn : ('ok, exn) t -> 'ok

`ok_exn t` returns `x` if `t = Ok x`, and raises `exn` if `t = Error exn`

    val ok_or_failwith : ('ok, string) t -> 'ok

raises `Failure` in the `Error` case

    val ok_unit : (unit, 'a) t

`ok_unit = Ok ()`, used to avoid allocation as a performance hack

    module Export: sig .. end

    module Stable: sig .. end

    val compare : ('ok -> 'ok -> int) ->
           ('err -> 'err -> int) -> ('ok, 'err) t -> ('ok, 'err) t -> int

    val t_of_sexp : (Sexplib.Sexp.t -> 'ok) ->
           (Sexplib.Sexp.t -> 'err) -> Sexplib.Sexp.t -> ('ok, 'err) t

    val sexp_of_t : ('ok -> Sexplib.Sexp.t) ->
           ('err -> Sexplib.Sexp.t) -> ('ok, 'err) t -> Sexplib.Sexp.t

    val bin_t : 'ok Bin_prot.Type_class.t ->
           'err Bin_prot.Type_class.t -> ('ok, 'err) t Bin_prot.Type_class.t

    val bin_read_t : 'ok Bin_prot.Read.reader ->
           'err Bin_prot.Read.reader -> ('ok, 'err) t Bin_prot.Read.reader

    val __bin_read_t__ : 'ok Bin_prot.Read.reader ->
           'err Bin_prot.Read.reader ->
           (int -> ('ok, 'err) t) Bin_prot.Read.reader

    val bin_reader_t : 'ok Bin_prot.Type_class.reader ->
           'err Bin_prot.Type_class.reader ->
           ('ok, 'err) t Bin_prot.Type_class.reader

    val bin_size_t : 'ok Bin_prot.Size.sizer ->
           'err Bin_prot.Size.sizer -> ('ok, 'err) t Bin_prot.Size.sizer

    val bin_write_t : 'ok Bin_prot.Write.writer ->
           'err Bin_prot.Write.writer -> ('ok, 'err) t Bin_prot.Write.writer

    val bin_writer_t : 'ok Bin_prot.Type_class.writer ->
           'err Bin_prot.Type_class.writer ->
           ('ok, 'err) t Bin_prot.Type_class.writer

e.g. `failf "Couldn't find bloogle %s" (Bloogle.to_string b)`
Returns `Ok` if both are `Ok` and `Error` otherwise.
`ok_fst` is useful with `List.partition_map`. Continuing the above example:

        let rics, errors = List.partition_map ~f:Result.ok_fst
          (List.map ~f:ric_of_ticker ["AA"; "F"; "CSCO"; "AAPL"])

`ok_if_true` returns `Ok ()` if `bool` is true, and `Error error` if it is false
`ok_exn t` returns `x` if `t = Ok x`, and raises `exn` if `t = Error exn`
raises `Failure` in the `Error` case
`ok_unit = Ok ()`, used to avoid allocation as a performance hack
We export the unit test arg rather than instantiate the functor inside result.ml in order to avoid circular dependencies. The functor is instantiated in stable.ml.