9.3 Delayed Evaluation
A promise encapsulates an expression to be evaluated on demand via force. After a promise has been forced, every later force of the promise produces the same result.
|(delay body ...+)|
|(lazy body ...+)|
Note that the last body of this form must produce a single value, but the value can itself be a delay promise that returns multiple values.
The lazy form is useful for implementing lazy libraries and languages, where tail calls can be wrapped in a promise.
If v is forced again before the original call to force returns, then the exn:fail exception is raised.
If v is not a promise, then it is returned as the result.
|(promise-forced? promise) → boolean?|
|promise : promise?|
|(promise-running? promise) → boolean?|
|promise : promise?|
9.3.1 Additional Promise Kinds
|(delay/name body ...+)|
If a delay/name promise forces itself, no exception is raised, the promise is never considered “running” or “forced” in the sense of promise-running? and promise-forced?.
|(delay/strict body ...+)|
|(delay/sync body ...+)|
If a promise created by delay/sync is forced on a thread that is already running the promise, an exception is raised in the same way as for promises created with delay.
|(delay/thread body/option ...+)|
Exceptions raised by the bodys are caught as usual and raised only when the promise is forced.
|(delay/idle body/option ...+)|
the computation does not start until the event produced by wait-evt-expr is ready, where the default is (system-idle-evt);
the computation thread gets to work only when the process is otherwise idle as determined by while-evt-expr, which also defaults to (system-idle-evt);
the thread is allowed to run only periodically: out of every tick-secs-expr (defaults to 0.2) seconds, the thread is allowed to run use-ratio-expr (defaults to 0.12) of the time proportionally; i.e., the thread runs for (* tick-secs-expr use-ratio-expr) seconds.
If the promise is forced before the computation is done, it runs the rest of the computation immediately without waiting on events or periodically restricting evaluation.
A #:wait-for, #:work-while, #:tick, or #:use specification can appear at most once.