Some examples with "yield" generators in scheme.

generator.scm

(define (generate tree)
  (let ((jump null))
    (lambda () 
      (if (null? jump)
          (call/cc 
           (lambda (yield)
             (let loop ((stack (list tree)))
               (cond
                 ((null? stack) null)
                 (else 
                  (call/cc
                   (lambda (k)
                     (set! jump k)
                     (yield (node-value (car stack)))))
                  (loop (append (filter (lambda (el) (not (null? el)))
                                        (children (car stack)))
                                (cdr stack))))))))
          (jump)))))

iterator.scm

(define (iterate callback tree)
  (let loop ((values '()) 
             (stack (list tree)))
    (cond 
      ((null? stack) values)
      (else
       (loop (cons (callback (node-value (car stack)))
                   values)
             (append (filter (lambda (el) (not (null? el)))
                             (children (car stack)))
                     (cdr stack)))))))

tree.scm

(define (make-node val . others)
  (case (length others)
    ((0) (list val null null))
    ((1) (list val (car others) null))
    ((2) (list val (car others) (cadr others)))))
  
(define (node-value node)
  
  (car node))

(define (node-left node)
  (cadr node))

(define (node-right node)
  (caddr node))

(define (children node)
  (cdr node))

(define *example* 
  (make-node 3 
             (make-node 4) 
             (make-node 2 
                        (make-node 1) 
                        (make-node 0 
                                   '() 
                                   (make-node -1)))))