Core_lazy (core_kernel.Core_kernel__.Core

type 'a t = 'a Lazy.t

include sig ... end

val typerep_of_t : 'a Typerep_lib.Std.Typerep.t ‑> 'a t Typerep_lib.Std.Typerep.t

val typename_of_t : 'a Typerep_lib.Std.Typename.t ‑> 'a t Typerep_lib.Std.Typename.t

val t_of_sexp : (Sexplib.Sexp.t ‑> 'a) ‑> Sexplib.Sexp.t ‑> 'a t

val sexp_of_t : ('a ‑> Sexplib.Sexp.t) ‑> 'a t ‑> Sexplib.Sexp.t

val hash_fold_t : (Ppx_hash_lib.Std.Hash.state ‑> 'a ‑> Ppx_hash_lib.Std.Hash.state) ‑> Ppx_hash_lib.Std.Hash.state ‑> 'a t ‑> Ppx_hash_lib.Std.Hash.state

val compare : ('a ‑> 'a ‑> Core_kernel__.Import.int) ‑> 'a t ‑> 'a t ‑> Core_kernel__.Import.int

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 ‑> (Core_kernel__.Import.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

include module type of Base.Lazy with type a Lazy.t := a t

val t_of_sexp : (Base__.Sexplib.Sexp.t ‑> 'a) ‑> Base__.Sexplib.Sexp.t ‑> 'a t

val sexp_of_t : ('a ‑> Base__.Sexplib.Sexp.t) ‑> 'a t ‑> Base__.Sexplib.Sexp.t

val hash_fold_t : (Base__.Ppx_hash_lib.Std.Hash.state ‑> 'a ‑> Base__.Ppx_hash_lib.Std.Hash.state) ‑> Base__.Ppx_hash_lib.Std.Hash.state ‑> 'a t ‑> Base__.Ppx_hash_lib.Std.Hash.state

val compare : ('a ‑> 'a ‑> int) ‑> 'a t ‑> 'a t ‑> int

val (>>=) : 'a t ‑> ('a ‑> 'b t) ‑> 'b t

val (>>|) : 'a t ‑> ('a ‑> 'b) ‑> 'b t

module Monad_infix : sig ... end

val bind : 'a t ‑> f:('a ‑> 'b t) ‑> 'b t

val return : 'a ‑> 'a t

val map : 'a t ‑> f:('a ‑> 'b) ‑> 'b t

val join : 'a t t ‑> 'a t

val ignore_m : 'a t ‑> unit t

val all : 'a t list ‑> 'a list t

val all_ignore : unit t list ‑> unit t

module Let_syntax : sig ... end

exception Undefined

external force : 'a t ‑> 'a =

val force_val : 'a t ‑> 'a

val from_fun : (unit ‑> 'a) ‑> 'a t

val from_val : 'a ‑> 'a t

val is_val : 'a t ‑> bool

module T_unforcing : sig ... end

module Stable : sig ... end