A write-once cell that can be empty or full (i.e., hold a single value).

One can `read` an ivar 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``= 'a Async_kernel__.Types.Ivar.t```
`include sig ... end`
`val bin_t : 'a Bin_prot.Type_class.t ‑> 'a t Bin_prot.Type_class.t`
`val bin_read_t : 'a Bin_prot.Read.reader ‑> 'a t Bin_prot.Read.reader`
`val __bin_read_t__ : 'a Bin_prot.Read.reader ‑> (int ‑> 'a t) Bin_prot.Read.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.Write.writer ‑> 'a t Bin_prot.Write.writer`
`val bin_writer_t : 'a Bin_prot.Type_class.writer ‑> 'a t Bin_prot.Type_class.writer`
`val bin_shape_t : Bin_prot.Shape.t ‑> Bin_prot.Shape.t`
`val sexp_of_t : ('a ‑> Base.Sexp.t) ‑> 'a t ‑> Base.Sexp.t`
`type 'a ivar``= 'a t```
`include Core_kernel.Invariant.S1 with type a t := a t`
`type 'a t`````
`val invariant : 'a Base__.Invariant_intf.inv ‑> 'a t Base__.Invariant_intf.inv`
`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 create_full : 'a ‑> 'a t`

`create_full v` returns an ivar filled with `v`.

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

`val read : 'a t ‑> 'a Async_kernel__.Deferred0.t`

`read t` returns a deferred that becomes enabled with value `v` after the ivar is filled with `v`.

`val peek : 'a t ‑> 'a option`

`peek t` returns `Some v` iff `t` is full with value `v`.

`val value_exn : 'a t ‑> 'a`

`value_exn t` returns `v` if `t` is full with value `v`, and raises otherwise.

`val has_handlers : _ t ‑> bool`

`has_handlers t` returns `true` if `t` has handlers waiting on `read t`.