1.15.10 Unfolding

Function: stream-unfold map pred gen base

stream-unfold is the fundamental recursive stream constructor. It constructs a stream by repeatedly applying gen to successive values of base, in the manner of stream-iterate, then applying map to each of the values so generated, appending each of the mapped values to the output stream as long as (pred base) is non–#f. See also stream-iterate and stream-unfolds.

For example, the expression below creates the finite stream:

0 1 4 9 16 25 36 49 64 81

initially the base is 0, which is less than 10, so map squares the base and the mapped value becomes the first element of the output stream; then gen increments the base by 1, so it becomes 1; this is less than 10, so map squares the new base and 1 becomes the second element of the output stream; and so on, until the base becomes 10, when pred? stops the recursion and stream-null ends the output stream.

(stream-unfold
  (lambda (x) (expt x 2)) ; map
  (lambda (x) (< x 10))   ; pred
  (lambda (x) (+ x 1))    ; gen
  0)                      ; base

Function: stream-unfolds proc seed

Return n newly–allocated streams containing those elements produced by successive calls to the generator proc, which takes the current seed as its argument and returns n+1 values:

(proc seed) -> seed R0 ...  R(n-1)

where the returned seed is the input seed to the next call to the generator and R(i) indicates how to produce the next element of the i-th result stream:

(value)

value is the next car of the result stream;

#f

no value produced by this iteration of the generator proc for the result stream;

()

the end of the result stream.

It may require multiple calls of proc to produce the next element of any particular result stream. See also stream-iterate and stream-unfold.

stream-unfolds is especially useful when writing expressions that return multiple streams. For instance, with reference to the definitions below:

(stream-partition pred strm)

is equivalent to:

(values
  (stream-filter pred strm)
  (stream-filter
      (lambda (x)
        (not (pred x)))
     strm))

but only tests pred once for each element of strm.

(define (stream-partition pred strm)
  (stream-unfolds
    (lambda (s)
      (if (stream-null? s)
          (values s '() '())
        (let ((a (stream-car s))
              (d (stream-cdr s)))
          (if (pred a)
              (values d (list a) #f)
            (values d #f (list a))))))
    strm))

(call-with-values
  (lambda ()
    (stream-partition odd?
      (stream-range 1 6)))
  (lambda (odds evens)
    (list (stream->list odds)
          (stream->list evens))))
⇒ ((1 3 5) (2 4))