▼Functional Data Structures in Typed Racket
On this page:
Stream
stream
empty-stream
empty-stream?
stream-cons
stream-car
stream-cdr
stream-append
stream-reverse
stream->list
drop
take
8.16.0.4
  top  contents    up   

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)

A stream of type A.

procedure

(stream a ...) → (Stream A)

  a : A
Function stream creates a Stream with the given inputs.

Example:
> (stream 1 2 3 4 5 6)

- : (Rec

     g325653

     (U (Boxof (U (-> (Pairof Integer g325653)) (Pairof Integer g325653)))

        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)

An empty stream.

procedure

(empty-stream? strm) → Boolean

  strm : (Stream A)
Function empty-stream? takes a Stream checks if the given stream is empty.

Examples:
> (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)
Function stream-cons takes an element and a stream and adds the given element to the given stream.

Example:
> (stream-cons 10 (stream 1 2 3 4 5 6))

- : (Boxof

     (-> (Pairof

          Positive-Byte

          (Rec

           g325677

           (U (Boxof

               (U (-> (Pairof Integer g325677)) (Pairof Integer g325677)))

              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)
Function stream-car takes a stream and returns the first element of the given stream. If the given stream is empty, then it throws an error.

Examples:
> (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)
Function stream-cdr takes a stream and returns the same stream but without the first element of the given stream.

Examples:
> (stream-cdr (stream 1 2 3 4 5 6))

- : (Rec

     g325699

     (U (Boxof (U (-> (Pairof Integer g325699)) (Pairof Integer g325699)))

        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)
Function stream-append takes two streams and creates a new stream by appending the second stream to the end of first stream.

Examples:
> (define strm1 (stream 1 2 3 4 5 6))
> (define strm2 (stream 51 32 42))
> (stream-append strm1 strm2)

- : (Rec

     g325721

     (U (Boxof (U (-> (Pairof Integer g325721)) (Pairof Integer g325721)))

        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)
Function stream-reverse takes a streams and gives a reversed stream back.

Example:
> (stream-reverse (stream 1 2 3 4 5 6))

- : (Rec

     g325730

     (U (Boxof (U (-> (Pairof Integer g325730)) (Pairof Integer g325730)))

        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)
Function stream->list takes a stream and returns a list of elements which are in the same order as in the stream.

Examples:
> (stream->list (stream 1 2 3 4 5 6))

- : (Listof Integer)

'(1 2 3 4 5 6)

> (stream->list empty-stream)

- : (Listof Nothing)

'()

procedure

(drop num strm) → (Stream A)

  num : Integer
  strm : (Stream A)
Function drop takes an integer(say n) and a stream and creates a new stream which is same as the given stream but without the first n elements of the input stream. If the number of elements in the given stream is less than n, then drop throws an error.

Examples:
> (drop 3 (stream 1 2 3 4 5 6))

- : (Rec

     g325752

     (U (Boxof (U (-> (Pairof Integer g325752)) (Pairof Integer g325752)))

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

procedure

(take num strm) → (Stream A)

  num : Integer
  strm : (Stream A)
Function take takes an integer(say n) and a stream and creates a new stream with the first n elements of the input stream. If the number of elements in the given stream is less than n, then take throws an error.

(take 5 (stream 1)) does not throw any error because of its lazy nature. take returns a suspension rather than finishing the whole computation.

Examples:
> (take 3 (stream 1 2 3 4 5 6))

- : (Rec

     g325770

     (U (Boxof (U (-> (Pairof Integer g325770)) (Pairof Integer g325770)))

        Null))

'#&#<procedure:...fds/pfds/stream.rkt:40:7>

> (take 5 (stream 1))

- : (Rec

     g325779

     (U (Boxof (U (-> (Pairof Integer g325779)) (Pairof Integer g325779)))

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

  top  contents    up