package core_kernel

  1. Overview
  2. Docs
Legend:
Library
Module
Module type
Parameter
Class
Class type

This module extends Base.Result.

type ('a, 'b) t = ('a, 'b) Base.Result.t =
  1. | Ok of 'a
  2. | Error of 'b
val bin_read_t : 'a Bin_prot.Read.reader -> 'b Bin_prot.Read.reader -> ('a, 'b) t Bin_prot.Read.reader
val __bin_read_t__ : 'a Bin_prot.Read.reader -> 'b Bin_prot.Read.reader -> (Base.Int.t -> ('a, 'b) t) Bin_prot.Read.reader
val bin_size_t : 'a Bin_prot.Size.sizer -> 'b Bin_prot.Size.sizer -> ('a, 'b) t Bin_prot.Size.sizer
include module type of Base.Result with type ('a, 'b) t := ('a, 'b) t
include sig ... end
val t_of_sexp : (Base.Sexp.t -> 'ok) -> (Base.Sexp.t -> 'err) -> Base.Sexp.t -> ('ok, 'err) t
val sexp_of_t : ('ok -> Base.Sexp.t) -> ('err -> Base.Sexp.t) -> ('ok, 'err) t -> Base.Sexp.t
val compare : ('ok -> 'ok -> int) -> ('err -> 'err -> int) -> ('ok, 'err) t -> ('ok, 'err) t -> int
val hash_fold_t : (Base.Hash.state -> 'ok -> Base.Hash.state) -> (Base.Hash.state -> 'err -> Base.Hash.state) -> Base.Hash.state -> ('ok, 'err) t -> Base.Hash.state
include Base.Monad.S2 with type ('a, 'err) t := ('a, 'err) t
val (>>=) : ('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
val (>>|) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
module Let_syntax = Base.Result.Let_syntax
module Monad_infix = Base.Result.Monad_infix
val bind : ('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val return : 'a -> ('a, _) t
val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
val ignore_m : (_, 'e) t -> (unit, 'e) t
val all : ('a, 'e) t list -> ('a list, 'e) t
val all_unit : (unit, 'e) t list -> (unit, 'e) t
val all_ignore : (unit, 'e) t list -> (unit, 'e) t
  • deprecated [since 2018-02] Use [all_unit]
val ignore : (_, 'err) t -> (unit, 'err) t
val fail : 'err -> (_, 'err) t
val failf : ('a, unit, string, (_, string) t) Pervasives.format4 -> 'a

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

val is_ok : (_, _) t -> bool
val is_error : (_, _) t -> bool
val ok : ('ok, _) t -> 'ok option
val ok_exn : ('ok, exn) t -> 'ok
val ok_or_failwith : ('ok, string) t -> 'ok
val error : (_, 'err) t -> 'err option
val of_option : 'ok option -> error:'err -> ('ok, 'err) t
val iter : ('ok, _) t -> f:('ok -> unit) -> unit
val iter_error : (_, '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 combine_errors : ('ok, 'err) t list -> ('ok list, 'err list) t

combine_errors ts returns Ok if every element in ts is Ok, else it returns Error with all the errors in ts.

This is similar to all from Monad.S2, with the difference that all only returns the first error.

val combine_errors_unit : (unit, 'err) t list -> (unit, 'err list) t

combine_errors_unit returns Ok if every element in ts is Ok (), else it returns Error with all the errors in ts, like combine_errors.

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_unit : (unit, _) t

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

module Export = Base.Result.Export
module Stable : sig ... end
OCaml

Innovation. Community. Security.