Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
Lazy(3)				 OCaml library			       Lazy(3)

NAME
       Lazy - Deferred computations.

Module
       Module	Lazy

Documentation
       Module Lazy
	: sig end

       Deferred	computations.

       type 'a t = 'a lazy_t

       A  value	 of type 'a Lazy.t is a	deferred computation, called a suspen-
       sion, that has a	result of type 'a .   The  special  expression	syntax
       lazy  (expr)  makes  a  suspension of the computation of	expr , without
       computing expr itself yet.  "Forcing" the suspension will then  compute
       expr and	return its result.

       Note:  lazy_t is	the built-in type constructor used by the compiler for
       the lazy	keyword.  You should not use it	directly.  Always  use	Lazy.t
       instead.

       Note:  Lazy.force  is  not  thread-safe.	  If  you use this module in a
       multi-threaded program, you will	need to	add some locks.

       Note: if	the program is compiled	with the -rectypes option, ill-founded
       recursive  definitions  of  the	form let rec x = lazy x	or let rec x =
       lazy(lazy(...(lazy x))) are accepted by the type-checker	and lead, when
       forced, to ill-formed values that trigger infinite loops	in the garbage
       collector and other parts of the	run-time system.   Without  the	 -rec-
       types  option,  such  ill-founded recursive definitions are rejected by
       the type-checker.

       exception Undefined

       val force : 'a t	-> 'a

       force x forces the suspension x and returns its result.	If x  has  al-
       ready  been  forced,  Lazy.force	x returns the same value again without
       recomputing it.	If it raised  an  exception,  the  same	 exception  is
       raised again.  Raise Undefined if the forcing of	x tries	to force x it-
       self recursively.

       val force_val : 'a t -> 'a

       force_val x forces the suspension x and returns its result.  If	x  has
       already	been  forced, force_val	x returns the same value again without
       recomputing it.	Raise Undefined	if the forcing of x tries to  force  x
       itself recursively.  If the computation of x raises an exception, it is
       unspecified whether force_val x raises the same exception or  Undefined
       .

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

       from_fun	f is the same as lazy (f ()) but slightly more efficient.

       Since 4.00.0

       val from_val : 'a -> 'a t

       from_val	 v  returns  an	 already-forced	suspension of v	.  This	is for
       special purposes	only and should	not be confused	with lazy (v) .

       Since 4.00.0

       val is_val : 'a t -> bool

       is_val x	returns	true if	x has already been forced and did not raise an
       exception.

       Since 4.00.0

       val lazy_from_fun : (unit -> 'a)	-> 'a t

       Deprecated.  synonym for	from_fun .

       val lazy_from_val : 'a -> 'a t

       Deprecated.  synonym for	from_val .

       val lazy_is_val : 'a t -> bool

       Deprecated.  synonym for	is_val .

OCamldoc			  2017-04-30			       Lazy(3)

NAME | Module | Documentation

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=Lazy&sektion=3o&manpath=FreeBSD+12.0-RELEASE+and+Ports>

home | help