s c h e m a t i c s : c o o k b o o k

(define (make-engine a-thunk)
  (lambda (ticks success failure)
    (let ([result #f])
      (let ([work-thread (thread (lambda () (set! result (a-thunk))))])
        (if (not (object-wait-multiple ticks work-thread))
            (begin
              (thread-suspend work-thread)
              (letrec ([new-engine (lambda (ticks success failure)
                                     (thread-resume work-thread)
                                     (if (not (object-wait-multiple ticks work-thread))
                                         (begin
                                           (thread-suspend work-thread)
                                           (failure new-engine))
                                         (success result)))])
                (failure new-engine)))
            (success result))))))

(define-syntax parallel-or
  (syntax-rules ()
    ((_ x ...)
     (first-true
      (list (make-engine (lambda () x)) ...))))) 

(define (first-true engs)
  (cond
    [(null? engs) #f]
    [else         ((car engs) 1
                              (lambda (value)
                                (or value 
                                    (first-true (cdr engs))))
                              (lambda (eng)
                                (first-true
                                  (append (cdr engs) 
                                          (list eng))))]))

(define (fibonacci n)
  (if (< n 2)
      n
      (+ (fibonacci (- n 1))
         (fibonacci (- n 2)))))

(define (infinite-loop)
  (infinite-loop))

(parallel-or (infinite-loop)
             (fibonacci 10))