type 'a t = 'a Base.Lazy.t
include Bin_prot.Binable.S1 with type 'a t := 'a t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
val compare : ('a -> 'a -> Base.Int.t) -> 'a t -> 'a t -> Base.Int.t
val hash_fold_t : (Base.Hash.state -> 'a -> Base.Hash.state) -> Base.Hash.state -> 'a t -> Base.Hash.state
include Ppx_sexp_conv_lib.Sexpable.S1 with type 'a t := 'a t
val t_of_sexp : (Sexplib0.Sexp.t -> 'a) -> Sexplib0.Sexp.t -> 'a t
val sexp_of_t : ('a -> Sexplib0.Sexp.t) -> 'a t -> Sexplib0.Sexp.t
val t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t
include Typerep_lib.Typerepable.S1 with type 'a t := 'a t
val typerep_of_t : 'a Typerep_lib.Std_internal.Typerep.t -> 'a t Typerep_lib.Std_internal.Typerep.t
val typename_of_t : 'a Typerep_lib.Typename.t -> 'a t Typerep_lib.Typename.t
include module type of Base.Lazy with type 'a t := 'a t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val hash_fold_t : (Base.Hash.state -> 'a -> Base.Hash.state) -> Base.Hash.state -> 'a t -> Base.Hash.state
include Base.Sexpable.S1 with type 'a t := 'a t
val t_of_sexp : (Sexplib0.Sexp.t -> 'a) -> Sexplib0.Sexp.t -> 'a t
val sexp_of_t : ('a -> Sexplib0.Sexp.t) -> 'a t -> Sexplib0.Sexp.t
include Base.Monad.S with type 'a t := 'a t
module Monad_infix : sig ... end
val return : 'a -> 'a t
return v
returns the (trivial) computation that returns v.
module Let_syntax : sig ... end
val force : 'a t -> 'a
force x
forces the suspensionx
and returns its result. Ifx
has already been forced,Lazy.force x
returns the same value again without recomputing it. If it raised an exception, the same exception is raised again. RaiseUndefined
if the forcing ofx
tries to forcex
itself recursively.
val force_val : 'a t -> 'a
Like
force
except thatforce_val x
does not use an exception handler, so it may be more efficient. However, if the computation ofx
raises an exception, it is unspecified whetherforce_val x
raises the same exception orUndefined
.
val from_fun : (unit -> 'a) -> 'a t
from_fun f
is the same aslazy (f ())
but slightly more efficient iff
is a variable.from_fun
should only be used if the functionf
is already defined. In particular it is always less efficient to writefrom_fun (fun () -> expr)
thanlazy expr
.
val from_val : 'a -> 'a t
from_val v
returns an already-forced suspension ofv
(wherev
can be any expression). Essentially,from_val expr
is the same aslet var = expr in lazy var
.
val is_val : 'a t -> bool
is_val x
returnstrue
ifx
has already been forced and did not raise an exception.
module T_unforcing : sig ... end
This type offers a serialization function
sexp_of_t
that won't force its argument. Instead, it will serialize the'a
if it is available, or just use a custom string indicating it is not forced. Note that this is not a round-trippable type, thus the type does not exposeof_sexp
. To be used in debug code, while tracking a Heisenbug, etc.
module Stable : sig ... end