package spin

You can search for identifiers within the package.

in-package search v0.2.0

A project generator for Reason and OCaml

Install

Dune Dependency

github.com Readme Changelog Edit opam file Versions (8)

Authors

Thibaut Mattio

Maintainers

Thibaut Mattio

Sources

spin-0.7.0.tbz

sha256=d151cf6aee92c3b6f2d596b11b5d1ac2c75d554b681aa736b6293981344d062c

sha512=e80ec9d40eecace6684308960ea224b81ce6e2fc8e81201c99702d13b3d888b7f2de9379777c94719bf679ee6ed10e3a83668064bba36cf1121f1f6628539046

doc/spin.std/Spin_std/Result/index.html

Module `Spin_std.Result`Source

include module type of struct include Base.Result end

Sourcetype ('ok, 'err) t = ('ok, 'err) result =

| Ok of 'ok
| 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

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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 Base.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 Monad_infix = Base.Result.Monad_infix

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 = Base.Result.Error

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

Source

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.

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_fst : ('ok, 'err) t -> ('ok, 'err) Base__.Either0.t

deprecated [since 2020-01] Use [to_either] instead.

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 = Base.Result.Export

Sourcemodule Let_syntax : sig ... end

Sourceval fold_left : f:('a -> (unit, 'b) t) -> 'a List.t -> (unit, 'b) t

Sourceval fold_right : f:('a -> (unit, 'b) t) -> 'a List.t -> (unit, 'b) t

package spin

Install

Dune Dependency

Authors

Maintainers

Sources

doc/spin.std/Spin_std/Result/index.html

Module Spin_std.ResultSource

Module `Spin_std.Result`Source