; Producer consumer - functional programming variant.

(define (stop-value? x) (and (boolean? x) x))  
(define STOP-VALUE #t)
(define NO-CONTINUATION #f)

(define (producer initial-consumer-continuation)
  (call-with-current-continuation
    (lambda (exit)
       (let ((producer-values (list 2 3 4 5 6)))  
         (letrec ((producer-iter  
                    (lambda (values consumer-continuation)
                      (cond ((null? values) (consumer-continuation (cons STOP-VALUE NO-CONTINUATION)))   
                            (else 
                              (let* ((new-consumer-continuation
                                      (call-with-current-continuation       
                                       (lambda (here)
                                         (if consumer-continuation
                                             (consumer-continuation (cons (car values) here)) 
                                             (exit here)))))) 
                                (producer-iter (cdr values) new-consumer-continuation)))))))
            (producer-iter (cons 'no-value producer-values) initial-consumer-continuation))))))

(define (consumer initial-producer-continuation)
 (letrec ((consumer-processor (lambda (x) (* x x)))) 
  (call-with-current-continuation
    (lambda (exit)
      (letrec ((consumer-iter  
                (lambda (producer-continutation)
                  (let* ((from-producer (call-with-current-continuation  
                                         (lambda (here)
                                           (producer-continutation here)))) 
                         (value-from-producer (car from-producer))
                        )
                    (if (stop-value? value-from-producer)
                        '()
                        (let ((processed-value (consumer-processor value-from-producer))  
                              (new-producer-continuation (cdr from-producer))
                             )
                          (cons processed-value (consumer-iter new-producer-continuation)))))))) 
        (consumer-iter initial-producer-continuation))))))


; Setup: Start producer first. Pass initial-producer-cont to consumer.
(let ((initial-producer-cont (producer NO-CONTINUATION)))  
  (consumer initial-producer-cont) 
)  ; => (4 9 16 25 36)

 
 
Stop value is boolean #t.
 
 
 
 
 
 
produced values - pass to consumer
producer-iter is a loop that iterates over the producer-values.
 
when the producers is done, send a special value to the consumer.
 
 
context shift. Capture continuation, and send it the consumer.
 
 
send pair of value and continuation to the consumer.
to get started: The value returned by first call to producer is exited out of producer.
 
 
 
 
 
 
 
consumer-iter is a loop that iterates over the the values received from the producer.
 
receive value, prepare for context shift, and resume producer.
 
just pass the consumer contiuation in 'here'to producer. 
 
 
 
 
process the value from producer before putting into a list
 
 
accumulated processed values, and call consumere-iter recursively