Scala Library Documentation


scala/Stream.scala
]
trait
Stream[+a]
extends
Seq[a]The class Stream
implements lazy lists where elements
are only evaluated when they are needed. Here is an example:
object Main extends Application { def from(n: Int): Stream[Int] = Stream.cons(n, from(n + 1)) def sieve(s: Stream[Int]): Stream[Int] = Stream.cons(s.head, sieve(s.tail filter { x => x % s.head != 0 })) def primes = sieve(from(2)) primes take 10 print }
Method Summary  
protected abstract def

addDefinedElems
(buf : StringBuilder, prefix : String) : StringBuilder
Write all elements of this string into given string builder

def

append
[b >: a](rest : => Stream[b]) : Stream[b]
The stream resulting from the concatenation of this stream with the argument stream.

def

apply
(n : Int) : a
Returns the
n th element of this stream. The first element
(head of the stream) is at position 0. 
override def

copyToArray
[b >: a](xs : Array[b], start : Int) : Unit
Fills the given array
xs with the elements of
this stream starting at position start . 
override def

drop
(n : Int) : Stream[a]
Returns the stream without its
n first elements.
If the stream has less than n elements, the empty stream is returned. 
override def

dropWhile
(p : (a) => Boolean) : Stream[a]
Returns the longest suffix of this stream whose first element
does not satisfy the predicate
p . 
def

elements
: Iterator[a]
An iterator returning the elements of this stream one by one.

override def

exists
(p : (a) => Boolean) : Boolean
Tests the existence in this stream of an element that satisfies the
predicate
p . 
override def

filter
(p : (a) => Boolean) : Stream[a]
Returns all the elements of this stream that satisfy the
predicate
p . The order of the elements is preserved. 
override def

flatMap
[b](f : (a) => Iterable[b]) : Stream[b]
Applies the given function
f to each element of
this stream, then concatenates the results. 
override def

foldLeft
[b](z : b)(f : (b, a) => b) : b
Combines the elements of this stream together using the binary
function
f , from left to right, and starting with
the value z . 
override def

foldRight
[b](z : b)(f : (a, b) => b) : b
Combines the elements of this stream together using the binary
function
f , from rigth to left, and starting with
the value z . 
override def

forall
(p : (a) => Boolean) : Boolean
Tests if the predicate
p is satisfied by all elements
in this stream. 
override def

foreach
(f : (a) => Unit) : Unit
Apply the given function
f to each element of this stream
(while respecting the order of the elements). 
abstract def

head
: a
The first element of this stream

def

init
: Stream[a]
The stream without its last element.

override abstract def

isEmpty
: Boolean
is this stream empty?

def

last
: a
Returns the last element of this stream.

def

length
: Int
The length of this stream

override def

map
[b](f : (a) => b) : Stream[b]
Returns the stream resulting from applying the given function
f to each
element of this stream. 
def

print
(sep : String) : Unit
Prints elements of this stream one by one, separated by
sep 
def

print
: Unit
Prints elements of this stream one by one, separated by commas

override def

reverse
: Stream[a]
A stream consisting of all elements of this stream in reverse order.

abstract def

tail
: Stream[a]
A stream consisting of the remaining elements of this stream after the first one.

override def

take
(n : Int) : Stream[a]
Returns the
n first elements of this stream, or else the whole
stream, if it has less than n elements. 
override def

takeWhile
(p : (a) => Boolean) : Stream[a]
Returns the longest prefix of this stream whose elements satisfy
the predicate
p . 
override def

toString
: String
Converts stream to string

def

zip
[b](that : Stream[b]) : Stream[(a, b)]
Returns a stream formed from this stream and the specified stream
that by associating each element of the former with
the element at the same position in the latter.
If one of the two streams is longer than the other, its remaining elements are ignored. 
def

zipWithIndex
: Stream[(a, Int)]
Returns a stream that pairs each element of this stream
with its index, counting from 0.

Methods inherited from Seq  
size, concat, ++, isDefinedAt, lastIndexOf, contains, slice, subseq, toArray 
Methods inherited from Collection  
stringPrefix 
Methods inherited from Iterable  
find, findIndexOf, indexOf, /:, :\, reduceLeft, reduceRight, copyToBuffer, sameElements, toList, mkString, mkString, addString, addString, projection, hasDefiniteSize 
Methods inherited from PartialFunction  
orElse, andThen 
Methods inherited from Function1  
compose 
Methods inherited from AnyRef  
getClass, hashCode, equals, clone, notify, notifyAll, wait, wait, wait, finalize, ==, !=, eq, ne, synchronized 
Methods inherited from Any  
==, !=, isInstanceOf, asInstanceOf 
Method Details 
override abstract
def
isEmpty : Boolean
abstract
def
head : a
def
length : Int
rest 
The stream that gets appended to this stream
def
last : a
n
th element of this stream. The first element
(head of the stream) is at position 0.n 
index of the element to returnn
in this stream.n
first elements of this stream, or else the whole
stream, if it has less than n
elements.n 
the number of elements to take.n
first elements of this stream.n
first elements.
If the stream has less than n
elements, the empty stream is returned.n 
the number of elements to drop.n
first elements.p
.p 
the test predicate.p
.p
.p 
the test predicate.p
.f
to each
element of this stream.f 
function to apply to each element.[f(a0), ..., f(an)]
if this stream is [a0, ..., an]
.f
to each element of this stream
(while respecting the order of the elements).f 
the treatment to apply to each element.p
. The order of the elements is preserved.p 
the predicate used to filter the stream.p
.p
is satisfied by all elements
in this stream.p 
the test predicate.true
iff all elements of this stream satisfy the predicate p
.p
.p 
the test predicate.true
iff there exists an element in this stream that satisfies the predicate p
.f
, from left to right, and starting with
the value z
.f(... (f(f(z, a_{0}), a_{1}) ...), a_{n})
if the stream is
[a_{0}, a_{1}, ..., a_{n}]
.f
, from rigth to left, and starting with
the value z
.f(a_{0}, f(a_{1}, f(..., f(a_{n}, z)...)))
if the stream is [a_{0}, a1, ..., a_{n}]
.f
to each element of
this stream, then concatenates the results.f 
the function to apply on each element.f(a_{0}) ::: ... ::: f(a_{n})
if this stream is [a_{0}, ..., a_{n}]
.xs
with the elements of
this stream starting at position start
.xs 
the array to fill.start 
starting index.that
by associating each element of the former with
the element at the same position in the latter.
If one of the two streams is longer than the other, its remaining elements are ignored.Stream({a_{0},b_{0}}, ..., {a_{min(m,n)},b_{min(m,n)})}
when
Stream(a_{0}, ..., a_{m})
zip Stream(b_{0}, ..., b_{n})
is invoked.Stream({a_{0},0}, {a_{0},1},...)
where a_{i}
are the elements of this stream.
def
print : Unit
sep
sep 
The separator string printed between consecutive elements.override
def
toString : String
protected abstract
def
addDefinedElems(buf : StringBuilder, prefix : String) : StringBuilder
Scala Library Documentation

