interleave-streams-functional.rkt

(define (interleave-streams . ss)
  (define (helper to-process processed)
    (λ ()
      (if (null? to-process)
          ((helper (reverse processed) null))
          (let* ([next (car to-process)]
                 [pr (next)])
            (cons (car pr) (helper (cdr to-process) (cons (cdr pr) processed)))))))
  (helper ss null))

interleave-streams-mlist.rkt

; Take a non-empty list and return a cyclic mlist
(define (list->cyclic-mlist lst)
  (define (helper l)
    (if (null? l)
        #f
        (let ([next (helper (cdr l))])
          (if next
              (cons (mcons (car l) (car next)) (cdr next))
              (let ([val (mcons (car l) null)])
                (cons val val))))))
  (let ([pr (helper lst)])
    (begin
      (set-mcdr! (cdr pr) (car pr))
      (car pr))))

; Interleave n streams together
(define (interleave-streams2 . ss)
  (define (helper to-process)
    (thunk
     (let ([pr ((mcar to-process))])
       (begin
         (set-mcar! to-process (cdr pr))
         (cons (car pr) (helper (mcdr to-process)))))))
  (helper (list->cyclic-mlist ss)))