Next: streams map, Previous: streams fold, Up: streams [Index]

- 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))

Next: streams map, Previous: streams fold, Up: streams [Index]