module Ivar:sig
..end
read
and to obtain a deferred that becomes determined when the ivar is
filled. An ivar is similar to an 'a option ref
, except it is an error to fill an
already full ivar.type 'a
t
include Invariant.S1
val equal : 'a t -> 'a t -> bool
equal t t'
is physical equality of t
and t'
.val create : unit -> 'a t
create ()
returns an empty ivar.val fill : 'a t -> 'a -> unit
fill t v
fills t
with value v
if t
was empty. If t
was full, fill raises
an exception.
It is guaranteed that immediately after calling fill t
,
is_some (Deferred.peek (read t))
.
val fill_if_empty : 'a t -> 'a -> unit
fill_if_empty t v
fills t
with v
if t
is currently empty. If t
is full,
then fill_if_empty
does nothing.val is_empty : 'a t -> bool
is_empty t
returns true if t
is emptyval is_full : 'a t -> bool
is_full t
returns true if t
is fullRaw
interface and Deferred
module exposed here are for async's internal use
only. They must be exported here because we want the Deferred.t
and Ivar.t
types
to be fully abstract, so that they show up nicely in type errors, yet other async
code defined later needs to deal with the raw types.include Raw
module Deferred:sig
..end
val read : 'a t -> 'a Deferred.t
read t
returns a deferred that becomes enabled with value v
after the ivar is
filled with v
.val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val bin_t : 'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
val bin_read_t : 'a Bin_prot.Unsafe_read_c.reader ->
'a t Bin_prot.Read_ml.reader
val bin_read_t_ : 'a Bin_prot.Unsafe_read_c.reader ->
'a t Bin_prot.Unsafe_read_c.reader
val bin_read_t__ : 'a Bin_prot.Unsafe_read_c.reader ->
(int -> 'a t) Bin_prot.Unsafe_read_c.reader
val bin_reader_t : 'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t : 'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t : 'a Bin_prot.Unsafe_write_c.writer ->
'a t Bin_prot.Write_ml.writer
val bin_write_t_ : 'a Bin_prot.Unsafe_write_c.writer ->
'a t Bin_prot.Unsafe_write_c.writer
val bin_writer_t : 'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
equal t t'
is physical equality of t
and t'
.create ()
returns an empty ivar.fill t v
fills t
with value v
if t
was empty. If t
was full, fill raises
an exception.
It is guaranteed that immediately after calling fill t
,
is_some (Deferred.peek (read t))
.
fill_if_empty t v
fills t
with v
if t
is currently empty. If t
is full,
then fill_if_empty
does nothing.
is_empty t
returns true if t
is empty
is_full t
returns true if t
is full
The Raw
interface and Deferred
module exposed here are for async's internal use
only. They must be exported here because we want the Deferred.t
and Ivar.t
types
to be fully abstract, so that they show up nicely in type errors, yet other async
code defined later needs to deal with the raw types.
read t
returns a deferred that becomes enabled with value v
after the ivar is
filled with v
.