module Ivar:`sig`

..`end`

An ivar is a write-once cell that can be empty or full (i.e. hold a single value) that
one can

`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 empty`val is_full : ``'a t -> bool`

`is_full t`

returns true if `t`

is fullThe

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

.