Predeclared in STREAMS

Functions

build_stream(f, n) → {stream}

Makes a stream with n elements by applying the unary function f to the numbers 0 to n - 1, assumed to be a nonnegative integer. Lazy? Yes: The result stream forces the application of f for the next element
Parameters:
Name Type Description
f function unary function
n number given nonnegative integer
Returns:
resulting stream
Type
stream

enum_stream(start, end) → {stream}

Returns a stream that enumerates numbers starting from start using a step size of 1, until the number exceeds (>) end. Lazy? Yes: The result stream forces the construction of each next element
Parameters:
Name Type Description
start number starting number
end number ending number
Returns:
stream from start to end
Type
stream

eval_stream(s, n) → {list}

Constructs the list of the first n elements of a given stream s Lazy? Sort-of: eval_stream only forces the computation of the first n elements, and leaves the rest of the stream untouched.
Parameters:
Name Type Description
s stream given stream
n number nonnegative number of elements to place in result list
Returns:
result list
Type
list

integers_from(start) → {stream}

Returns infinite stream if integers starting at given number n using a step size of 1. Lazy? Yes: The result stream forces the construction of each next element
Parameters:
Name Type Description
start number starting number
Returns:
infinite stream from n
Type
stream

is_stream(xs) → {boolean}

Returns true if xs is a stream as defined in the textbook, and false otherwise. Iterative process. Recurses down the stream and checks that it ends with the empty stream null. Laziness: No: is_stream needs to force the given stream.
Parameters:
Name Type Description
xs value given candidate
Returns:
whether xs is a stream
Type
boolean

list_to_stream(xs) → {stream}

Given list xs, returns a stream of same length with the same elements as xs in the same order. Laziness: Yes: list_to_stream goes down the list only when forced.
Parameters:
Name Type Description
xs list given list
Returns:
stream containing all elements of xs
Type
stream

stream() → {stream}

Given n values, returns a stream of length n. The elements of the stream are the given values in the given order. Lazy? No: A complete list is generated, and then a stream using list_to_stream is generated from it.
Parameters:
Name Type Description
value1,value2,...,value_n value given values
Returns:
stream containing all values
Type
stream

stream_append(xs, ys) → {stream}

Returns a stream that results from appending the stream ys to the stream xs. In the result, null at the end of the first argument stream is replaced by the second argument, regardless what the second argument consists of. Lazy? Yes: the result stream forces the actual append operation
Parameters:
Name Type Description
xs stream given first stream
ys stream given second stream
Returns:
result of appending xs and ys
Type
stream

stream_filter(pred, xs) → {stream}

Returns a stream that contains only those elements of given stream xs for which the one-argument function pred returns true. Lazy? Yes: The result stream forces the construction of each next element. Of course, the construction of the next element needs to go down the stream until an element is found for which pred holds.
Parameters:
Name Type Description
pred function unary function returning boolean value
xs stream given stream
Returns:
stream with those elements of xs for which pred holds.
Type
stream

stream_for_each(f, xs) → {boolean}

Applies unary function f to every element of the stream xs. Iterative process. f is applied element-by-element: stream_for_each(f, stream(1, 2)) results in the calls f(1) and f(2). Lazy? No: stream_for_each forces the exploration of the entire stream
Parameters:
Name Type Description
f function unary
xs stream given stream
Returns:
true
Type
boolean

stream_length(xs) → {number}

Returns the length of the stream xs. Iterative process. Lazy? No: The function needs to explore the whole stream
Parameters:
Name Type Description
xs stream given stream
Returns:
length of xs
Type
number

stream_map(f, xs) → {stream}

Returns a stream that results from stream xs by element-wise application of unary function f. f is applied element-by-element: stream_map(f, stream(1,2)) results in the same as stream(f(1),f(2)). Lazy? Yes: The argument stream is only explored as forced by the result stream.
Parameters:
Name Type Description
f function unary
xs stream given stream
Returns:
result of mapping
Type
stream

stream_member(v, xs) → {stream}

Returns first postfix substream whose head is identical to v (using ===); returns null if the element does not occur in the stream. Iterative process. Lazy? Sort-of: stream_member forces the stream only until the element is found.
Parameters:
Name Type Description
v value given value
xs stream given stream
Returns:
postfix substream that starts with v
Type
stream

stream_ref(xs, n) → {value}

Returns the element of stream xs at position n, where the first element has index 0. Iterative process. Lazy? Sort-of: stream_ref only forces the computation of the first n elements, and leaves the rest of the stream untouched.
Parameters:
Name Type Description
xs stream given stream
n number given position
Returns:
item in xs at position n
Type
value

stream_remove(v, xs) → {stream}

Returns a stream that results from xs by removing the first item from xs that is identical (===) to v. Returns the original stream if there is no occurrence. Lazy? Yes: the result stream forces the construction of each next element
Parameters:
Name Type Description
v value given value
xs stream given stream
Returns:
xs with first occurrence of v removed
Type
stream

stream_remove_all(v, xs) → {stream}

Returns a stream that results from xs by removing all items from xs that are identical (===) to v. Returns the original stream if there is no occurrence. Recursive process. Lazy? Yes: the result stream forces the construction of each next element
Parameters:
Name Type Description
v value given value
xs stream given stream
Returns:
xs with all occurrences of v removed
Type
stream

stream_reverse(xs) → {stream}

Returns stream xs in reverse order. Iterative process. The process is iterative, but consumes space Omega(n) because of the result stream. Lazy? No: stream_reverse forces the exploration of the entire stream
Parameters:
Name Type Description
xs stream given stream
Returns:
xs in reverse
Type
stream

stream_tail(xs) → {Stream}

assumes that the tail (second component) of the pair {x} is a nullary function, and returns the result of applying that function. Throws an exception if the argument is not a pair, or if the tail is not a function. Laziness: Yes: {stream_tail} only forces the direct tail stream, but not the rest of the stream, i.e. not the tail of the tail, etc.
Parameters:
Name Type Description
xs Stream given stream
Returns:
result stream (if stream discipline is used)
Type
Stream

stream_to_list(xs) → {list}

Given stream xs, returns a list of same length with the same elements as xs in the same order. Laziness: No: stream_to_list needs to force the whole stream.
Parameters:
Name Type Description
xs stream stream
Returns:
containing all elements of xs
Type
list