10.3 Delayed Evaluation
|(require racket/promise)||package: base|
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?
10.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 ...+)
body/option = body | #:group thread-group-expr
Exceptions raised by the bodys are caught as usual and raised only when the promise is forced. Unlike delay/sync, if the thread running body terminates without producing a result or exception, force of the promise raises an exception (instead of blocking).
(delay/idle body/option ...+)
body/option = body | #:wait-for wait-evt-expr | #:work-while while-evt-expr | #:tick tick-secs-expr | #:use use-ratio-expr
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.