camlinternalmod(3) [centos man page]

CamlinternalMod(3)						   OCaml library						CamlinternalMod(3)

NAME

       CamlinternalMod - Run-time support for recursive modules.

Module
       Module	CamlinternalMod

Documentation
       Module CamlinternalMod
	: sig end

       Run-time support for recursive modules.	All functions in this module are for system use only, not for the casual user.

       type shape =
	| Function
	| Lazy
	| Class
	| Module of shape array

       val init_mod : string * int * int -> shape -> Obj.t

       val update_mod : shape -> Obj.t -> Obj.t -> unit

OCamldoc							    2014-06-09							CamlinternalMod(3)

Lazy(3o)							   OCaml library							  Lazy(3o)

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 suspension, 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	-rectypes  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 already been forced, Lazy.force x returns the same value again with-
       out recomputing it. If it raised an exception, the same exception is raised again.  Raise Undefined if the forcing of x tries  to  force  x
       itself 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 lazy_from_fun : (unit -> 'a) -> 'a t

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

       val lazy_from_val : 'a -> 'a t

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

       val lazy_is_val : 'a t -> bool

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

OCamldoc							    2012-06-26								  Lazy(3o)