Result (core_kernel.Core

type ('a, 'b) t = ('a, 'b) Base.Result.t = | Ok of 'a | Error of 'b

include Bin_prot.Binable.S2 with type ('a, 'b) t := ('a, 'b) t

val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'b, ('a, 'b) t) Bin_prot.Size.sizer2
val bin_write_t : ('a, 'b, ('a, 'b) t) Bin_prot.Write.writer2
val bin_read_t : ('a, 'b, ('a, 'b) t) Bin_prot.Read.reader2
val __bin_read_t__ : ('a, 'b, int -> ('a, 'b) t) Bin_prot.Read.reader2
val bin_writer_t : ('a, 'b, ('a, 'b) t) Bin_prot.Type_class.S2.writer
val bin_reader_t : ('a, 'b, ('a, 'b) t) Bin_prot.Type_class.S2.reader
val bin_t : ('a, 'b, ('a, 'b) t) Bin_prot.Type_class.S2.t

val compare : ('a -> 'a -> Base.Int.t) -> ('b -> 'b -> Base.Int.t) -> ('a, 'b) t -> ('a, 'b) t -> Base.Int.t
val equal : ('a -> 'a -> Base.Bool.t) -> ('b -> 'b -> Base.Bool.t) -> ('a, 'b) t -> ('a, 'b) t -> Base.Bool.t
val hash_fold_t : (Base.Hash.state -> 'a -> Base.Hash.state) -> (Base.Hash.state -> 'b -> Base.Hash.state) -> Base.Hash.state -> ('a, 'b) t -> Base.Hash.state

include Ppx_sexp_conv_lib.Sexpable.S2 with type ('a, 'b) t := ('a, 'b) t

val t_of_sexp : (Sexplib0.Sexp.t -> 'a) -> (Sexplib0.Sexp.t -> 'b) -> Sexplib0.Sexp.t -> ('a, 'b) t
val sexp_of_t : ('a -> Sexplib0.Sexp.t) -> ('b -> Sexplib0.Sexp.t) -> ('a, 'b) t -> Sexplib0.Sexp.t

include module type of Base.Result with type ('a, 'b) t := ('a, 'b) t

include Base.Sexpable.S2 with type ('ok, 'err) t := ('a, 'b) t

val t_of_sexp : (Sexplib0.Sexp.t -> 'a) -> (Sexplib0.Sexp.t -> 'b) -> Sexplib0.Sexp.t -> ('a, 'b) t
val sexp_of_t : ('a -> Sexplib0.Sexp.t) -> ('b -> Sexplib0.Sexp.t) -> ('a, 'b) t -> Sexplib0.Sexp.t

val compare : ('ok -> 'ok -> int) -> ('err -> 'err -> int) -> ('a, 'b) t -> ('a, 'b) t -> int
val equal : ('ok -> 'ok -> bool) -> ('err -> 'err -> bool) -> ('a, 'b) t -> ('a, 'b) t -> bool
val hash_fold_t : (Base.Hash.state -> 'ok -> Base.Hash.state) -> (Base.Hash.state -> 'err -> Base.Hash.state) -> Base.Hash.state -> ('a, 'b) t -> Base.Hash.state

include Base.Monad.S2 with type ('a, 'err) t := ('a, 'b) t

val (>>=) : ('a, 'b) t -> ('a -> ('a, 'b) t) -> ('a, 'b) t
val (>>|) : ('a, 'b) t -> ('a -> 'b) -> ('a, 'b) t

module Let_syntax : sig ... end

module Monad_infix : sig ... end

val bind : ('a, 'b) t -> f:('a -> ('a, 'b) t) -> ('a, 'b) t
val return : 'a -> ('a, 'b) t
val map : ('a, 'b) t -> f:('a -> 'b) -> ('a, 'b) t
val join : ('a, 'b) t -> ('a, 'b) t
val ignore_m : ('a, 'b) t -> ('a, 'b) t
val all : ('a, 'b) t list -> ('a, 'b) t
val all_unit : ('a, 'b) t list -> ('a, 'b) t

val invariant : ('a -> unit) -> ('b -> unit) -> ('a, 'b) t -> unit

val fail : 'err -> ('a, 'b) t
val failf : ('a, unit, string, ('a, 'b) t) Stdlib.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 : ('a, 'b) t -> 'ok option
val ok_exn : ('a, 'b) t -> 'ok
val ok_or_failwith : ('a, 'b) t -> 'ok
val error : ('a, 'b) t -> 'err option
val of_option : 'ok option -> error:'err -> ('a, 'b) t
val iter : ('a, 'b) t -> f:('ok -> unit) -> unit
val iter_error : ('a, 'b) t -> f:('err -> unit) -> unit
val map : ('a, 'b) t -> f:('ok -> 'c) -> ('a, 'b) t
val map_error : ('a, 'b) t -> f:('err -> 'c) -> ('a, 'b) t
val combine : ('a, 'b) t -> ('a, 'b) t -> ok:('ok1 -> 'ok2 -> 'ok3) -> err:('err -> 'err -> 'err) -> ('a, 'b) t: Returns Ok if both are Ok and Error otherwise.

val combine_errors : ('a, 'b) t list -> ('a, 'b) 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 : ('a, 'b) t list -> ('a, 'b) 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 to_either : ('a, 'b) t -> ('ok, 'err) Base__Either0.t

to_either is useful with List.partition_map. For example:

let ints, exns =
  List.partition_map ["1"; "two"; "three"; "4"] ~f:(fun string ->
    Result.to_either (Result.try_with (fun () -> Int.of_string string)))

val of_either : ('ok, 'err) Base__Either0.t -> ('a, 'b) t
val ok_fst : ('a, 'b) t -> ('ok, 'err) Base__Either0.t
val ok_if_true : bool -> error:'err -> ('a, 'b) t: ok_if_true returns Ok () if bool is true, and Error error if it is false.

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

module Export : sig ... end

module Stable : sig ... end