Result (key_value_database.Key_value_database.Monad.Ident.Result)

val lift : 'a -> ( 'a, 'b ) Core_kernel.Result.t

include module type of struct include Core_kernel.Result end

type (!'a, !'b) t = ( 'a, 'b ) Base.Result.t =

| Ok of 'a

| Error of 'b

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 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 ) ->
  ( 'ok, 'err ) t ->
  ( 'ok, 'err ) t ->
  int

val equal : 
  ( 'ok -> 'ok -> bool ) ->
  ( 'err -> 'err -> bool ) ->
  ( 'ok, 'err ) t ->
  ( 'ok, 'err ) t ->
  bool

val hash_fold_t : 
  ( Base__.Ppx_hash_lib.Std.Hash.state ->
    'ok ->
    Base__.Ppx_hash_lib.Std.Hash.state ) ->
  ( Base__.Ppx_hash_lib.Std.Hash.state ->
    'err ->
    Base__.Ppx_hash_lib.Std.Hash.state ) ->
  Base__.Ppx_hash_lib.Std.Hash.state ->
  ( 'ok, 'err ) t ->
  Base__.Ppx_hash_lib.Std.Hash.state

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

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

module Let_syntax = Core_kernel__Result.Let_syntax

module Monad_infix = Core_kernel__Result.Monad_infix

val bind : ( 'a, 'e ) t -> f:( 'a -> ( 'b, 'e ) t ) -> ( 'b, 'e ) t

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

val join : ( ( 'a, 'e ) t, 'e ) t -> ( 'a, 'e ) t

val ignore_m : ( 'a, '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 invariant : 
  'a Base__Invariant_intf.inv ->
  'b Base__Invariant_intf.inv ->
  ( 'a, 'b ) t Base__Invariant_intf.inv

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

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

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

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

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

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

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

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

val combine_errors : ( 'ok, 'err ) t list -> ( 'ok list, 'err list ) t

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

val to_either : ( 'ok, 'err ) t -> ( 'ok, 'err ) Base__.Either0.t

val of_either : ( 'ok, 'err ) Base__.Either0.t -> ( 'ok, 'err ) t

val ok_fst : ( 'ok, 'err ) t -> ( 'ok, 'err ) Base__.Either0.t

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

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

module Export = Core_kernel__Result.Export

module Stable = Core_kernel__Result.Stable