6 Streams
(require pfds/stream) | package: pfds |
Streams are nothing but lazy lists. They are similar to ordinary lists and they provide the same functionality as that of lists. The difference between Streams and lists is that they are lazy in nature and each cell of a Stream is suspended and is forced only when required. Streams have been used in some of the below mentioned data structures. Since each suspension comes with a little overhead, Streams should be used only when there is a good enough reason to do so.
syntax
(Stream A)
> (stream 1 2 3 4 5 6)
- : (Rec
g325675
(U (Boxof (U (-> (Pairof Integer g325675)) (Pairof Integer g325675)))
Null))
'#&(1 . #&(2 . #&(3 . #&(4 . #&(5 . #&(6))))))
In the above example, the stream obtained will be similar to lists but will lazy in nature. It will have 1 as its first element.
value
empty-stream : (Stream Nothing)
procedure
(empty-stream? strm) → Boolean
strm : (Stream A)
> (empty-stream? (stream 1 2 3 4 5 6)) - : Boolean
#f
> (empty-stream? empty-stream) - : Boolean
#t
procedure
(stream-cons a strm) → (Stream A)
a : A strm : (Stream A)
> (stream-cons 10 (stream 1 2 3 4 5 6))
- : (Boxof
(-> (Pairof
Positive-Byte
(Rec
g325699
(U (Boxof
(U (-> (Pairof Integer g325699)) (Pairof Integer g325699)))
Null)))))
'#&#<procedure:...fds/pfds/stream.rkt:40:7>
In the above example, (stream-cons 10 (stream 1 2 3 4 5 6)) returns the stream (stream 10 1 2 3 4 5 6).
procedure
(stream-car strm) → A
strm : (Stream A)
> (stream-car (stream 1 2 3 4 5 6)) - : Integer
1
> (stream-car empty-stream) stream-car: given stream is empty
procedure
(stream-cdr strm) → (Stream A)
strm : (Stream A)
> (stream-cdr (stream 1 2 3 4 5 6))
- : (Rec
g325721
(U (Boxof (U (-> (Pairof Integer g325721)) (Pairof Integer g325721)))
Null))
'#&(2 . #&(3 . #&(4 . #&(5 . #&(6)))))
> (stream-cdr empty-stream) stream-cdr: given stream is empty
In the above example, (stream-cdr strm) returns (stream 2 3 4 5 6).
procedure
(stream-append strm1 strm2) → (Stream A)
strm1 : (Stream A) strm2 : (Stream A)
> (define strm1 (stream 1 2 3 4 5 6)) > (define strm2 (stream 51 32 42)) > (stream-append strm1 strm2)
- : (Rec
g325743
(U (Boxof (U (-> (Pairof Integer g325743)) (Pairof Integer g325743)))
Null))
'#&#<procedure:...fds/pfds/stream.rkt:40:7>
In the above example, (stream-append strm1 strm2) returns the stream, (stream 1 2 3 4 5 6 51 32 42).
procedure
(stream-reverse strm) → (Stream A)
strm : (Stream A)
> (stream-reverse (stream 1 2 3 4 5 6))
- : (Rec
g325752
(U (Boxof (U (-> (Pairof Integer g325752)) (Pairof Integer g325752)))
Null))
'#&#<procedure:...fds/pfds/stream.rkt:40:7>
In the above example, (stream-reverse (stream 1 2 3 4 5 6)) returns (stream 6 5 4 3 2 1).
procedure
(stream->list strm) → (Listof A)
strm : (Stream A)
> (stream->list (stream 1 2 3 4 5 6)) - : (Listof Integer)
'(1 2 3 4 5 6)
> (stream->list empty-stream) - : (Listof Nothing)
'()
> (drop 3 (stream 1 2 3 4 5 6))
- : (Rec
g325774
(U (Boxof (U (-> (Pairof Integer g325774)) (Pairof Integer g325774)))
Null))
'#&(4 . #&(5 . #&(6)))
> (drop 10 (stream 1 2 3 4 5 6)) drop: not enough elements to drop
In the above example, (drop 3 (stream 1 2 3 4 5 6)) returns (stream 4 5 6).
(take 5 (stream 1)) does not throw any error because of its lazy nature. take returns a suspension rather than finishing the whole computation.
> (take 3 (stream 1 2 3 4 5 6))
- : (Rec
g325792
(U (Boxof (U (-> (Pairof Integer g325792)) (Pairof Integer g325792)))
Null))
'#&#<procedure:...fds/pfds/stream.rkt:40:7>
> (take 5 (stream 1))
- : (Rec
g325801
(U (Boxof (U (-> (Pairof Integer g325801)) (Pairof Integer g325801)))
Null))
'#&#<procedure:...fds/pfds/stream.rkt:40:7>
In the above example, (take 3 (stream 1 2 3 4 5 6)) returns (stream 1 2 3).