Hashtbl.Make_es
val create : int -> ('a, 'trace) t
val clear : ('a, 'trace) t -> unit
clear tbl
cancels and removes all the promises in tbl
.
val reset : ('a, 'trace) t -> unit
reset tbl
cancels and removes all the promises in tbl
, and resizes tbl
to its initial size.
val find_or_make :
('a, 'trace) t ->
key ->
(unit -> ('a, 'trace) Stdlib.result Lwt.t) ->
('a, 'trace) Stdlib.result Lwt.t
find_or_make tbl k make
behaves differently depending on k
being bound in tbl
:
k
is bound in tbl
then find_or_make tbl k make
returns the promise p
that k
is bound to. This p
might be already fulfilled with Ok _
or it might be pending. This p
cannot be already fulfilled with Error _
or already rejected. This is because Error
/rejected promises are removed from the table automatically. Note however that if this p
is pending, p
might become fulfilled with Error _
or become rejected.k
is not bound in tbl
then make ()
is called and the returned promise p
is bound to k
in tbl
. Then p
is returned. When p
is resolved, it may be removed automatically from tbl
as described above.remove tbl k
cancels the promise bound to k
in tbl
and removes it. If k
is not bound in tbl
it does nothing.
val iter_with_waiting_es :
(key -> 'a -> (unit, 'trace) Stdlib.result Lwt.t) ->
('a, 'trace) t ->
(unit, 'trace) Stdlib.result Lwt.t
iter_with_waiting_es f tbl
iterates f
over the bindings in tbl
.
Specifically, for each binding (k, p)
it waits for p
to be fulfilled with Ok v
and calls f k v
. If p
fulfills with Error _
or is rejected, then no call to f
is made for this binding. Note however that an Error
/rejection in one promise returned by f
interrupts the iteration.
It processes bindings one after the other: it waits for both the bound promise to resolve and then the call promise to resolve before continuing to the next binding.
val iter_with_waiting_ep :
(key -> 'a -> (unit, 'error) Stdlib.result Lwt.t) ->
('a, 'error) t ->
(unit, 'error list) Stdlib.result Lwt.t
iter_with_waiting_ep f tbl
iterates f
over the bindings in tbl
.
Specifically, for each binding (k, p)
it waits for p
to be fulfilled with Ok v
and calls f k v
. If p
fulfills with Error _
or is rejected, then no call is made for this binding.
Note however that if one (or more) of the promises returned by f
ends in Error
/rejection, the final result of this promise is an Error
/rejection. Even so, it only resolves once all the promises have.
It processes all bindings concurrently: it concurrently waits for all the bound promises to resolve and calls f
as they resolve.
val fold_with_waiting_es :
(key -> 'a -> 'b -> ('b, 'trace) Stdlib.result Lwt.t) ->
('a, 'trace) t ->
'b ->
('b, 'trace) Stdlib.result Lwt.t
fold_with_waiting_es f tbl init
folds init
with f
over the bindings in tbl
.
Specifically, for each binding (k, p)
it waits for p
to be fulfilled with Ok v
and determines the next accumulator by calling f k v acc
. If p
fulfills with Error _
or is rejected, then no call is made for this binding.
It processes bindings one after the other.
val fold_promises :
(key -> ('a, 'trace) Stdlib.result Lwt.t -> 'b -> 'b) ->
('a, 'trace) t ->
'b ->
'b
fold_promises f tbl init
folds over the table, passing the raw promises to f
. This means that f
can observe Error
/rejections.
This can be used to, e.g., count the number of resolved/unresolved promises.
fold_resolved f tbl init
folds over the already resolved promises of tbl
. More specifically, it folds over the v
for all the promises fulfilled with Ok v
that are bound in tbl
.
val length : ('a, 'trace) t -> int
val stats : ('a, 'trace) t -> Stdlib.Hashtbl.statistics