package base

  1. Overview
  2. Docs
Full standard library replacement for OCaml

Install 

dune-project
 Dependency

github.com Changelog MIT License Edit opam file Versions (20)

Authors

  1. J
    Jane Street Group, LLC

Maintainers

  1. J
    Jane Street developers

Sources

v0.17.3.tar.gz
md5=2100b0ed13fecf43be86ed45c5b2cc4d
sha512=628610caff7e124631870fa1e29661caac28bdfdb18750ee43b868037da3d65d6dd9023b4be7c4c52405679efb5e865a6632d95606a22b28a36636a6bf706ef3

doc/base/Base/Result/index.html

Module Base.ResultSource

Result is often used to handle error messages.

Sourcetype ('ok, 'err) t = ('ok, 'err) result =
  1. | Ok of 'ok
  2. | Error of 'err

'ok is the return type, and 'err is often an error message string.

  type nat = Zero | Succ of nat

  let pred = function
    | Succ n -> Ok n
    | Zero -> Error "Zero does not have a predecessor"

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

include Sexplib0.Sexpable.S2 with type ('ok, 'err) t := ('ok, 'err) t
Sourceval t_of_sexp : (Sexplib0.Sexp.t -> 'a) -> (Sexplib0.Sexp.t -> 'b) -> Sexplib0.Sexp.t -> ('a, 'b) t
Sourceval sexp_of_t : ('a -> Sexplib0.Sexp.t) -> ('b -> Sexplib0.Sexp.t) -> ('a, 'b) t -> Sexplib0.Sexp.t
Sourceval t_sexp_grammar : 'ok Sexplib0.Sexp_grammar.t -> 'err Sexplib0.Sexp_grammar.t -> ('ok, 'err) t Sexplib0.Sexp_grammar.t
Sourceval compare : ('a -> 'a -> int) -> ('b -> 'b -> int) -> ('a, 'b) t -> ('a, 'b) t -> int
Sourceval compare__local : ('a -> 'a -> int) -> ('b -> 'b -> int) -> ('a, 'b) t -> ('a, 'b) t -> int
Sourceval equal : ('a -> 'a -> bool) -> ('b -> 'b -> bool) -> ('a, 'b) t -> ('a, 'b) t -> bool
Sourceval equal__local : ('a -> 'a -> bool) -> ('b -> 'b -> bool) -> ('a, 'b) t -> ('a, 'b) t -> bool
Sourceval hash_fold_t : (Hash.state -> 'a -> Hash.state) -> (Hash.state -> 'b -> Hash.state) -> Hash.state -> ('a, 'b) t -> Hash.state
Sourceval globalize : ('ok -> 'ok) -> ('err -> 'err) -> ('ok, 'err) t -> ('ok, 'err) t
include Monad.S2_local with type ('a, 'err) t := ('a, 'err) t
Sourceval (>>=) : ('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t
Sourceval (>>|) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t
Sourcemodule Let_syntax : sig ... end
Sourcemodule Monad_infix : sig ... end

Same as Infix, except the monad type has two arguments. The second is always just passed through.

Sourceval bind : ('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
Sourceval return : 'a -> ('a, _) t
Sourceval join : (('a, 'e) t, 'e) t -> ('a, 'e) t
Sourceval ignore_m : (_, 'e) t -> (unit, 'e) t
Sourceval all : ('a, 'e) t list -> ('a list, 'e) t
Sourceval all_unit : (unit, 'e) t list -> (unit, 'e) t
Sourcemodule Error : Monad.S2_local with type ('err, 'a) t := ('a, 'err) t

The same as S except the monad type has two arguments. The second is always just passed through.

Sourceval invariant : ('a -> unit) -> ('b -> unit) -> ('a, 'b) t -> unit
Sourceval fail : 'err -> (_, 'err) t
Sourceval failf : ('a, unit, string, (_, string) t) format4 -> 'a

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

Sourceval is_ok : (_, _) t -> bool
Sourceval is_error : (_, _) t -> bool
Sourceval ok : ('ok, _) t -> 'ok option
Sourceval ok_exn : ('ok, exn) t -> 'ok
Sourceval ok_or_failwith : ('ok, string) t -> 'ok
Sourceval error : (_, 'err) t -> 'err option
Sourceval of_option : 'ok option -> error:'err -> ('ok, 'err) t
Sourceval iter : ('ok, _) t -> f:('ok -> unit) -> unit
Sourceval iter_error : (_, 'err) t -> f:('err -> unit) -> unit
Sourceval map : ('ok, 'err) t -> f:('ok -> 'c) -> ('c, 'err) t
Sourceval map_error : ('ok, 'err) t -> f:('err -> 'c) -> ('ok, 'c) t
Sourceval 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.

Sourceval 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.

Sourceval 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.

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

Sourceval try_with : (unit -> 'a) -> ('a, exn) t
Sourcemodule Export : sig ... end