Module `Core.Result`Source

This module extends Base.Result.

Sourcetype ('a, 'b) t = ('a, 'b) Base.Result.t =

| Ok of 'a
| Error of 'b

include Bin_prot.Binable.S_local2
  with type ('a, 'b) t := ('a, 'b) Core.Result.t

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

Sourceval bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t -> Bin_prot.Shape.t

Sourceval bin_size_t : ('a, 'b, ('a, 'b) Core.Result.t) Bin_prot.Size.sizer2

Sourceval bin_write_t : ('a, 'b, ('a, 'b) Core.Result.t) Bin_prot.Write.writer2

Sourceval bin_read_t : ('a, 'b, ('a, 'b) Core.Result.t) Bin_prot.Read.reader2

Source

val __bin_read_t__ : 
  ('a, 'b, int -> ('a, 'b) Core.Result.t) Bin_prot.Read.reader2

Source

val bin_writer_t : 
  ('a, 'b, ('a, 'b) Core.Result.t) Bin_prot.Type_class.S2.writer

Source

val bin_reader_t : 
  ('a, 'b, ('a, 'b) Core.Result.t) Bin_prot.Type_class.S2.reader

Sourceval bin_t : ('a, 'b, ('a, 'b) Core.Result.t) Bin_prot.Type_class.S2.t

Source

val bin_size_t__local : 
  ('a, 'b, ('a, 'b) Core.Result.t) Bin_prot.Size.sizer_local2

Source

val bin_write_t__local : 
  ('a, 'b, ('a, 'b) Core.Result.t) Bin_prot.Write.writer_local2

include Ppx_compare_lib.Comparable.S2
  with type ('a, 'b) t := ('a, 'b) Core.Result.t

include Ppx_compare_lib.Equal.S2 with type ('a, 'b) t := ('a, 'b) Core.Result.t

include Ppx_hash_lib.Hashable.S2 with type ('a, 'b) t := ('a, 'b) Core.Result.t

include Typerep_lib.Typerepable.S2
  with type ('a, 'b) t := ('a, 'b) Core.Result.t

Source

val typerep_of_t : 
  'a Typerep_lib.Std_internal.Typerep.t ->
  'b Typerep_lib.Std_internal.Typerep.t ->
  ('a, 'b) Core.Result.t Typerep_lib.Std_internal.Typerep.t

Source

val typename_of_t : 
  'a Typerep_lib.Typename.t ->
  'b Typerep_lib.Typename.t ->
  ('a, 'b) Core.Result.t Typerep_lib.Typename.t

include Sexplib0.Sexpable.S2 with type ('a, 'b) t := ('a, 'b) Core.Result.t

Sourcemodule Diff : sig ... end

include Sexplib0.Sexpable.S2
  with type ('ok, 'err) t := ('ok, 'err) Core.Result.t

Source

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

Source

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

Source

val t_sexp_grammar : 
  'ok Sexplib0.Sexp_grammar.t ->
  'err Sexplib0.Sexp_grammar.t ->
  ('ok, 'err) Core.Result.t Sexplib0.Sexp_grammar.t

Source

val compare : 
  ('a -> 'a -> int) ->
  ('b -> 'b -> int) ->
  ('a, 'b) Core.Result.t ->
  ('a, 'b) Core.Result.t ->
  int

Source

val equal : 
  ('a -> 'a -> bool) ->
  ('b -> 'b -> bool) ->
  ('a, 'b) Core.Result.t ->
  ('a, 'b) Core.Result.t ->
  bool

Source

val hash_fold_t : 
  (Base.Hash.state -> 'a -> Base.Hash.state) ->
  (Base.Hash.state -> 'b -> Base.Hash.state) ->
  Base.Hash.state ->
  ('a, 'b) Core.Result.t ->
  Base.Hash.state

Source

val globalize : 
  ('ok -> 'ok) ->
  ('err -> 'err) ->
  ('ok, 'err) Core.Result.t ->
  ('ok, 'err) Core.Result.t

include Base.Monad.S2_local with type ('a, 'err) t := ('a, 'err) Core.Result.t

Source

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

Sourceval (>>|) : ('a, 'e) Core.Result.t -> ('a -> 'b) -> ('b, 'e) Core.Result.t

Sourcemodule Let_syntax = Base.Result.Let_syntax

Sourcemodule Monad_infix = Base.Result.Monad_infix

Source

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

Sourceval return : 'a -> ('a, _) Core.Result.t

Sourceval join : (('a, 'e) Core.Result.t, 'e) Core.Result.t -> ('a, 'e) Core.Result.t

Sourceval ignore_m : (_, 'e) Core.Result.t -> (unit, 'e) Core.Result.t

Sourceval all : ('a, 'e) Core.Result.t list -> ('a list, 'e) Core.Result.t

Sourceval all_unit : (unit, 'e) Core.Result.t list -> (unit, 'e) Core.Result.t

Sourcemodule Error = Base.Result.Error

Sourceval invariant : ('a -> unit) -> ('b -> unit) -> ('a, 'b) Core.Result.t -> unit

Sourceval fail : 'err -> (_, 'err) Core.Result.t

Sourceval failf : ('a, unit, string, (_, string) Core.Result.t) Stdlib.format4 -> 'a

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

Sourceval is_ok : (_, _) Core.Result.t -> bool

Sourceval is_error : (_, _) Core.Result.t -> bool

Sourceval ok : ('ok, _) Core.Result.t -> 'ok option

Sourceval ok_exn : ('ok, exn) Core.Result.t -> 'ok

Sourceval ok_or_failwith : ('ok, string) Core.Result.t -> 'ok

Sourceval error : (_, 'err) Core.Result.t -> 'err option

Sourceval of_option : 'ok option -> error:'err -> ('ok, 'err) Core.Result.t

Sourceval iter : ('ok, _) Core.Result.t -> f:('ok -> unit) -> unit

Sourceval iter_error : (_, 'err) Core.Result.t -> f:('err -> unit) -> unit

Source

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

Source

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

Source

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

Returns Ok if both are Ok and Error otherwise.

Source

val combine_errors : 
  ('ok, 'err) Core.Result.t list ->
  ('ok list, 'err list) Core.Result.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.

Source

val combine_errors_unit : 
  (unit, 'err) Core.Result.t list ->
  (unit, 'err list) Core.Result.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.

Sourceval to_either : ('ok, 'err) Core.Result.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)))

Sourceval of_either : ('ok, 'err) Base__.Either0.t -> ('ok, 'err) Core.Result.t

Sourceval ok_if_true : bool -> error:'err -> (unit, 'err) Core.Result.t

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

Sourceval try_with : (unit -> 'a) -> ('a, exn) Core.Result.t

Sourcemodule Export = Base.Result.Export

Sourcemodule Stable : sig ... end

Module Core.ResultSource

Module `Core.Result`Source