package tezos-lwt-result-stdlib

You can search for identifiers within the package.

in-package search v0.2.0

tezos-lwt-result-stdlib
- Tezos_lwt_result_stdlib
  - Lwtreslib
    
    Bare
    
    Hashtbl
    
    Make
    
    MakeSeeded
    
    Make_es
    
    List
    
    Map
    
    Make
    
    Monad
    
    Option
    
    Result
    
    Seq
    
    Seq_e
    
    Seq_es
    
    Seq_s
    
    Set
    
    Make
    
    WithExceptions
    
    List
    
    Option
    
    Result
    
    Traced
    
    Hashtbl
    
    Make
    
    MakeSeeded
    
    Make_es
    
    S
    
    S_ES
    
    SeededS
    
    List
    
    Map
    
    Make
    
    S
    
    Monad
    
    Option
    
    Result
    
    Seq
    
    Seq_e
    
    Seq_es
    
    Seq_s
    
    Set
    
    Make
    
    S
    
    Trace
    
    WithExceptions
    
    List
    
    Option
    
    Result
tezos-lwt-result-stdlib.bare.functor-outputs
- Bare_functor_outputs
  - Hashtbl
    
    S
    
    S_ES
    
    SeededS
  - Map
    
    S
  - Set
    
    S
tezos-lwt-result-stdlib.bare.sigs
- Bare_sigs
  - Hashtbl
    
    S
    
    Make
    
    MakeSeeded
    
    Make_es
  - List
    
    S
  - Map
    
    S
    
    Make
  - Monad
    
    S
  - Option
    
    S
  - Result
    
    S
  - Seq
    
    S
  - Seq_e
    
    S
  - Seq_es
    
    S
  - Seq_s
    
    S
  - Set
    
    S
    
    Make
  - WithExceptions
    
    S
    
    List
    
    Option
    
    Result
tezos-lwt-result-stdlib.bare.structs
- Bare_structs
  - Hashtbl
    
    Make
    
    MakeSeeded
    
    Make_es
  - List
  - Map
    
    Make
  - Monad
  - Option
  - Result
  - Seq
  - Seq_e
  - Seq_es
  - Seq_s
  - Set
    
    Make
  - WithExceptions
    
    List
    
    Option
    
    Result
tezos-lwt-result-stdlib.examples.traces
- Traces
  - EXTENDED
  - Flat
  - Full
  - SingletonL
  - SingletonND
  - SingletonR
tezos-lwt-result-stdlib.traced.functor-outputs
- Traced_functor_outputs
  - Hashtbl
    
    S
    
    S_ES
    
    SeededS
  - Map
    
    S
  - Set
    
    S
tezos-lwt-result-stdlib.traced.sigs
- Traced_sigs
  - Hashtbl
    
    S
    
    Make
    
    MakeSeeded
    
    Make_es
    
    S
    
    S_ES
    
    SeededS
  - List
    
    S
  - Map
    
    S
    
    Make
    
    S
  - Monad
    
    S
  - Option
  - Result
  - Seq
    
    S
  - Seq_e
    
    S
  - Seq_es
    
    S
  - Seq_s
    
    S
  - Set
    
    S
    
    Make
    
    S
  - Trace
    
    S
  - WithExceptions
tezos-lwt-result-stdlib.traced.structs
- Traced_structs
  - Hashtbl
    
    Make
    
    Make
    
    MakeSeeded
    
    Make_es
    
    Monad
    
    S
    
    S_ES
    
    SeededS
    
    Seq
  - List
    
    Make
    
    Monad
  - Map
    
    Make
    
    Make
    
    Monad
    
    S
    
    Seq
  - Monad
    
    Make
    
    Trace
  - Seq
    
    Make
    
    Monad
  - Seq_e
  - Seq_es
    
    Make
    
    Monad
    
    Seq_e
    
    Seq_s
  - Seq_s
    
    Make
    
    Monad
  - Set
    
    Make
    
    Make
    
    Monad
    
    S
    
    Seq
  - Structs
    
    Make
    
    Hashtbl
    
    Make
    
    Legacy
    
    MakeSeeded
    
    Legacy
    
    Make_es
    
    S
    
    Legacy
    
    S_ES
    
    SeededS
    
    Legacy
    
    List
    
    Map
    
    Make
    
    Legacy
    
    S
    
    Legacy
    
    Monad
    
    Seq
    
    Seq_es
    
    Seq_s
    
    Set
    
    Make
    
    Legacy
    
    S
    
    Legacy
    
    Trace

Legend:
Library
Module
Module type
Parameter
Class
Class type

Maps with the signature S are exception-safe replacements for maps with the Stdlib.Map.S signature with Lwt- and result-aware traversal functions.

See Lwtreslib's introductory documentation for explanations regarding _e-, _s-, _es-, _p-, and _ep-suffixed functions and exception safety. See Stdlib.Map.S for explanations regarding OCaml's maps in general.

Note that this signature is within the Traced part of the library. As a result, the _ep traversor returns en 'error trace.

include Bare_functor_outputs.Map.S

type key

type +'a t

module Legacy : Stdlib.Map.S with type key = key and type 'a t = 'a t

val empty : 'a t

val is_empty : 'a t -> bool

val mem : key -> 'a t -> bool

val add : key -> 'a -> 'a t -> 'a t

val update : key -> ('a option -> 'a option) -> 'a t -> 'a t

val singleton : key -> 'a -> 'a t

val remove : key -> 'a t -> 'a t

val merge : 
  (key -> 'a option -> 'b option -> 'c option) ->
  'a t ->
  'b t ->
  'c t

val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t

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

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

val iter : (key -> 'a -> unit) -> 'a t -> unit

val iter_e : 
  (key -> 'a -> (unit, 'trace) Stdlib.result) ->
  'a t ->
  (unit, 'trace) Stdlib.result

iter_e f m applies f to the bindings of m one by one in an unspecified order. If all the applications result in Ok (), then the result of the iteration is Ok (). If any of the applications results in Error e then the iteration stops and the result of the iteration is Error e.

val iter_s : (key -> 'a -> unit Lwt.t) -> 'a t -> unit Lwt.t

val iter_p : (key -> 'a -> unit Lwt.t) -> 'a t -> unit Lwt.t

val iter_es : 
  (key -> 'a -> (unit, 'trace) Stdlib.result Lwt.t) ->
  'a t ->
  (unit, 'trace) Stdlib.result Lwt.t

iter_es f m applies f to the bindings of m in an unspecified order, one after the other as the promises resolve. If all the applications result in Ok (), then the result of the iteration is Ok (). If any of the applications results in Error e then the iteration stops and the result of the iteration is Error e.

val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b

val fold_e : 
  (key -> 'a -> 'b -> ('b, 'trace) Stdlib.result) ->
  'a t ->
  'b ->
  ('b, 'trace) Stdlib.result

fold_e f m init is f k1 d1 init >>? fun acc -> f k2 d2 acc >>? fun acc -> … where kN is the key bound to dN in m.

val fold_s : (key -> 'a -> 'b -> 'b Lwt.t) -> 'a t -> 'b -> 'b Lwt.t

val fold_es : 
  (key -> 'a -> 'b -> ('b, 'trace) Stdlib.result Lwt.t) ->
  'a t ->
  'b ->
  ('b, 'trace) Stdlib.result Lwt.t

fold_es f m init is f k1 d1 init >>=? fun acc -> f k2 d2 acc >>=? fun acc -> … where kN is the key bound to dN in m.

val for_all : (key -> 'a -> bool) -> 'a t -> bool

val exists : (key -> 'a -> bool) -> 'a t -> bool

val filter : (key -> 'a -> bool) -> 'a t -> 'a t

val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t

val cardinal : 'a t -> int

val bindings : 'a t -> (key * 'a) list

val min_binding : 'a t -> (key * 'a) option

val max_binding : 'a t -> (key * 'a) option

val choose : 'a t -> (key * 'a) option

val split : key -> 'a t -> 'a t * 'a option * 'a t

val find : key -> 'a t -> 'a option

val find_first : (key -> bool) -> 'a t -> (key * 'a) option

val find_last : (key -> bool) -> 'a t -> (key * 'a) option

val map : ('a -> 'b) -> 'a t -> 'b t

val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t

val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t

val to_seq_from : key -> 'a t -> (key * 'a) Stdlib.Seq.t

val add_seq : (key * 'a) Stdlib.Seq.t -> 'a t -> 'a t

val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t

type 'error trace

'error trace is intended to be substituted by a type provided by a Trace module (with type 'error trace := 'error Trace.trace)

val iter_ep : 
  (key -> 'a -> (unit, 'error trace) Stdlib.result Lwt.t) ->
  'a t ->
  (unit, 'error trace) Stdlib.result Lwt.t