Prev Up Next
An engine represents computation that is
subject to timed preemption. In other words, an
engine's underlying computation is an ordinary thunk
that runs as a timer-preemptable process.
An engine is called with three arguments: (1) a number
of time units or ticks, (2) a success
procedure, and (3) a failure procedure. If the
engine computation finishes within the allotted ticks, the success procedure is applied to the
computation result and the remaining ticks. If the
engine computation could not finish within the allotted
ticks, the failure procedure is applied
to a new engine representing the unfinished portion of
the engine computation.
For example, consider an engine whose underlying
computation is a loop that printed the nonnegative
integers in sequence. It is created as follows, with
the soon-to-be-defined make-engine procedure.
make-engine is called on an argument thunk
representing the underlying computation, and it
returns the corresponding engine:
(define printn-engine
(make-engine
(lambda ()
(let loop ((i 0))
(display i)
(display " ")
(loop (+ i 1))))))
Here is a call to printn-engine:
(define *more* #f)
(printn-engine 50 list (lambda (ne) (set! *more* ne)))
=> 0 1 2 3 4 5 6 7 8 9
Prev Up Next