OVERVIEW |  PACKAGE | CONSTR |  FIELDS |  METHODS FRAMES    NO FRAMES INHERITED

scala.Stream

trait Stream

trait Stream[+ A]

 extends Projection[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 { _ % s.head != 0 }))

   def primes = sieve(from(2))

   primes take 10 print
 }
author
- Martin Odersky, Matthias Zenger
version
- 1.1 08/08/03


Companion: Stream

Source: Stream.scala(212)

Direct Known Subclasses

Definite,

 Fields

elements override def elements
An iterator returning the elements of this stream one by one
Iterator[A]
first def first
Returns the first element of this list [details]
return
- the first element of the list.
throws
Predef.UnsupportedOperationException - if the list is empty.
 A Seq
firstOption def firstOption
Returns as an option the first element of this list or None if list is empty [details]
return
- the first element as an option.
 Option[A] Seq
force override def force
convert to a copied strict collection
List[A]
hasDefiniteSize override def hasDefiniteSize
returns true iff this collection has a bound size [details]
Many APIs in this trait will not work on collections of unbound sizes.
Boolean
head abstract def head
The first element of this stream [details]
throws
Predef.NoSuchElementException - if the stream is empty.
 A
headOption def headOption Option[A] Seq
init def init
The stream without its last element [details]
throws
Predef.UnsupportedOperationException - if the stream is empty.
 Stream[A]
isEmpty override abstract def isEmpty
is this stream empty?
Boolean
last override final def last
Returns the last element of this stream [details]
return
- the last element of the stream.
throws
Predef.NoSuchElementException - if the stream is empty.
 A
lastOption def lastOption
Returns as an option the last element of this list or None if list is empty [details]
return
- the last element as an option.
 Option[A] Seq
length override def length
The length of this stream
Int
mkString def mkString
Converts a collection into a flat String by each element's toString method [details]
note
- Will not terminate for infinite-sized collections.
 String Iterable
projection override def projection
returns a projection that can be used to call non-strict filter, map, and flatMap methods that build projections of the collection
Projection[A] Projection
reverse override def reverse
A stream consisting of all elements of this stream in reverse order
Stream[A]
size def size
should always be length
Int Seq
stringPrefix protected def stringPrefix
Defines the prefix of this object's toString representation
String Collection
tail abstract def tail
A stream consisting of the remaining elements of this stream after the first one [details]
throws
Predef.UnsupportedOperationException - if the stream is empty.
 Stream[A]
toList def toList
Returns a list containing all of the elements in this iterable object [details]
note
- Will not terminate for infinite-sized collections.
 List[A] Iterable
toSeq override def toSeq
Overridden for efficiency [details]
return
- the sequence itself
 Seq[A] Seq
toStream override def toStream
Returns a stream containing all of the elements in this iterable object [details]
note
- consider using projection for lazy behavior.
 Stream[A]

 Methods

!= final def !=(arg0 : Any) Boolean Any
!= final def !=(arg0 : Object) Boolean AnyRef
++ override def ++[B >: A](that : Iterable[B])
Appends two iterable objects
Seq[B] Seq
/: def /:[B](z : B)(op : (B, A) => B)
Similar to foldLeft but can be used as an operator with the order of list and zero arguments reversed [details]
That is, z /: xs is the same as xs foldLeft z
note
- Will not terminate for infinite-sized collections.
 B Iterable
:\ def :\[B](z : B)(op : (A, B) => B)
An alias for foldRight [details]
That is, xs :\ z is the same as xs foldRight z
note
- Will not terminate for infinite-sized collections.
 B Iterable
== final def ==(arg0 : Object) Boolean AnyRef
== final def ==(arg0 : Any) Boolean Any
addDefinedElems protected abstract def addDefinedElems(buf : StringBuilder, prefix : String)
Write all elements of this string into given string builder
StringBuilder
addString def addString(buf : StringBuilder, sep : String) StringBuilder Iterable
addString def addString(buf : StringBuilder, start : String, sep : String, end : String)
Write all elements of this string into given string builder [details]
note
- Will not terminate for infinite-sized collections.
param
buf - ...
return
- ...
 StringBuilder Iterable
andThen override def andThen[C](k : (B) => C)
(f andThen g)(x) == g(f(x))
PartialFunction[A, C] PartialFunction
append override def append[B >: A](rest : => Iterable[B])
The stream resulting from the concatenation of this stream with the argument stream [details]
param
rest - The stream that gets appended to this stream
 Stream[B]
apply override def apply(n : Int)
Returns the n-th element of this stream [details]
The first element (head of the stream) is at position 0.
param
n - index of the element to return
return
- the element at position n in this stream.
throws
Predef.NoSuchElementException - if the stream is too short.
 A
asInstanceOf final def asInstanceOf[T0] T0 Any
clone protected def clone Object AnyRef
compose def compose[A](g : (A) => T1)
(f compose g)(x) == f(g(x))
(A) => R Function1
concat override def concat[B >: A](that : Iterable[B])
Appends two iterable objects [details]
deprecated
- use ++ instead
return
- the new iterable object
 Seq[B] Seq
contains def contains(elem : Any)
Tests if the given value elem is a member of this sequence [details]
param
elem - element whose membership has to be tested.
return
- true iff there is an element of this sequence which is equal (w.r.t. ==) to elem.
Boolean Seq
containsSlice def containsSlice[B](that : Seq[B])
Is that a slice in this?
Boolean Seq
copyToArray override final def copyToArray[B >: A](xs : Array[B], start : Int)
Fills the given array xs with the elements of this stream starting at position start [details]
param
start - starting index.
xs - the array to fill.
pre
- the array must be large enough to hold all elements.
 Unit
copyToBuffer def copyToBuffer[B >: A](dest : Buffer[B])
Copy all elements to a given buffer [details]
note
- Will not terminate if not finite.
- Will not terminate for infinite-sized collections.
param
dest - The buffer to which elements are copied
 Unit Iterable
drop override final def drop(n : Int)
Returns the stream without its n first elements [details]
If the stream has less than n elements, the empty stream is returned.
param
n - the number of elements to drop.
return
- the stream without its n first elements.
 Stream[A]
dropWhile override final def dropWhile(p : (A) => Boolean)
Returns the longest suffix of this stream whose first element does not satisfy the predicate p [details]
param
p - the test predicate.
return
- the longest suffix of the stream whose first element does not satisfy the predicate p.
Stream[A]
endsWith def endsWith[B](that : Seq[B])
[details]
return
- true if this sequence end with that sequence
see
- String.endsWith
 Boolean Seq
eq final def eq(arg0 : Object) Boolean AnyRef
equals def equals(arg0 : Any) Boolean AnyRef
equalsWith def equalsWith[B](that : Seq[B])(f : (A, B) => Boolean) Boolean Seq
exists override final def exists(p : (A) => Boolean)
Tests the existence in this stream of an element that satisfies the predicate p [details]
param
p - the test predicate.
return
- true iff there exists an element in this stream that satisfies the predicate p.
Boolean
filter override final def filter(p : (A) => Boolean)
Returns all the elements of this stream that satisfy the predicate p [details]
The order of the elements is preserved.
param
p - the predicate used to filter the stream.
return
- the elements of this stream satisfying p.
 Stream[A]
finalize protected def finalize Unit AnyRef
find def find(p : (A) => Boolean)
Find and return the first element of the iterable object satisfying a predicate, if any [details]
note
- may not terminate for infinite-sized collections.
param
p - the predicate
return
- the first element in the iterable object satisfying p, or None if none exists.
Option[A] Iterable
findIndexOf def findIndexOf(p : (A) => Boolean)
Returns index of the first element satisying a predicate, or -1 [details]
note
- may not terminate for infinite-sized collections.
param
p - the predicate
return
- the index of the first element satisfying p, or -1 if such an element does not exist
Int Iterable
flatMap override def flatMap[B](f : (A) => Iterable[B])
Applies the given function f to each element of this stream, then concatenates the results [details]
param
f - the function to apply on each element.
return
- f(a0) ::: ... ::: f(an) if this stream is [a0, ..., an].
Stream[B]
foldLeft override final def foldLeft[B](z : B)(f : (B, A) => B)
Combines the elements of this stream together using the binary function f, from left to right, and starting with the value z [details]
return
- f(... (f(f(z, a0), a1) ...), an) if the stream is [a0, a1, ..., an].
B
foldRight override def foldRight[B](z : B)(f : (A, B) => B)
Combines the elements of this stream together using the binary function f, from rigth to left, and starting with the value z [details]
return
- f(a0, f(a1, f(..., f(an, z)...))) if the stream is [a0, a1, ..., an].
B
forall override final def forall(p : (A) => Boolean)
Tests if the predicate p is satisfied by all elements in this stream [details]
param
p - the test predicate.
return
- true iff all elements of this stream satisfy the predicate p.
Boolean
foreach override final def foreach(f : (A) => Unit)
Apply the given function f to each element of this stream (while respecting the order of the elements) [details]
param
f - the treatment to apply to each element.
 Unit
getClass final def getClass Class[Any] AnyRef
hashCode def hashCode Int AnyRef
indexOf def indexOf[B >: A](elem : B)
Returns the index of the first occurence of the specified object in this iterable object [details]
note
- may not terminate for infinite-sized collections.
param
elem - element to search for.
return
- the index in this sequence of the first occurence of the specified element, or -1 if the sequence does not contain this element.
Int Iterable
indexOf def indexOf[B >: A](that : Seq[B])
[details]
return
- -1 if that not contained in this, otherwise the index where that is contained
see
- String.indexOf
 Int Seq
isDefinedAt def isDefinedAt(x : Int)
Is this partial function defined for the index x? [details]
param
x - ..
return
- true, iff x is a legal sequence index.
 Boolean Seq
isInstanceOf final def isInstanceOf[T0] Boolean Any
lastIndexOf def lastIndexOf[B >: A](elem : B)
Returns the index of the last occurence of the specified element in this sequence, or -1 if the sequence does not contain this element [details]
param
elem - element to search for.
return
- the index in this sequence of the last occurence of the specified element, or -1 if the sequence does not contain this element.
Int Seq
lengthCompare override def lengthCompare(l : Int)
returns length - l without calling length
Int
map override def map[B](f : (A) => B)
Returns the stream resulting from applying the given function f to each element of this stream [details]
param
f - function to apply to each element.
return
- [f(a0), ..., f(an)] if this stream is [a0, ..., an].
 Stream[B]
mkString def mkString(sep : String)
Returns a string representation of this iterable object [details]
The string representations of elements (w.r.t. the method toString()) are separated by the string sep.
note
- Will not terminate for infinite-sized collections.
param
sep - separator string.
return
- a string representation of this iterable object.
 String Iterable
mkString def mkString(start : String, sep : String, end : String)
Returns a string representation of this iterable object [details]
The resulting string begins with the string start and is finished by the string end. Inside, the string representations of elements (w.r.t. the method toString()) are separated by the string sep.
ex
- List(1, 2, 3).mkString("(", "; ", ")") = "(1; 2; 3)"
note
- Will not terminate for infinite-sized collections.
param
sep - separator string.
start - starting string.
end - ending string.
return
- a string representation of this iterable object.
 String Iterable
ne final def ne(arg0 : Object) Boolean AnyRef
notify final def notify Unit AnyRef
notifyAll final def notifyAll Unit AnyRef
orElse def orElse[A1 <: A, B1 >: B](that : PartialFunction[A1, B1]) PartialFunction[A1, B1] PartialFunction
partition def partition(p : (A) => Boolean)
Partitions this iterable in two iterables according to a predicate [details]
param
p - the predicate on which to partition
return
- a pair of iterables: the iterable that satisfy the predicate p and the iterable that do not. The relative order of the elements in the resulting iterables is the same as in the original iterable.
(Iterable[A], Iterable[A]) Iterable
print def print(sep : String)
Prints elements of this stream one by one, separated by sep [details]
param
sep - The separator string printed between consecutive elements.
 Unit
print def print
Prints elements of this stream one by one, separated by commas
Unit
reduceLeft def reduceLeft[B >: A](op : (B, A) => B)
Combines the elements of this iterable object together using the binary operator op, from left to right [details]
note
- Will not terminate for infinite-sized collections.
param
op - The operator to apply
return
- op(... op(a0,a1), ..., an) if the iterable object has elements a0, a1, ..., an.
throws
Predef.UnsupportedOperationException - if the iterable object is empty.
 B Iterable
reduceRight def reduceRight[B >: A](op : (A, B) => B)
Combines the elements of this iterable object together using the binary operator op, from right to left [details]
note
- Will not terminate for infinite-sized collections.
param
op - The operator to apply
return
- a0 op (... op (an-1 op an)...) if the iterable object has elements a0, a1, ..., an.
throws
Predef.UnsupportedOperationException - if the iterator is empty.
 B Iterable
sameElements def sameElements[B >: A](that : Iterable[B])
Checks if the other iterable object contains the same elements [details]
note
- will not terminate for infinite-sized collections.
param
that - the other iterable object
return
- true, iff both iterable objects contain the same elements.
 Boolean Iterable
slice def slice(from : Int)
A sub-sequence starting at index from and extending up to the length of the current sequence (non-strict) [details]
param
from - The index of the first element of the slice
throws
IndexOutOfBoundsException - if from < 0
 Seq[A] Seq
slice def slice(from : Int, until : Int)
A sub-sequence starting at index from and ending (non-inclusive) at index until (non-strict) [details]
param
until - The index of the element following the slice
from - The index of the first element of the slice
throws
IndexOutOfBoundsException - if from < 0 or length < from + len
Seq[A] Seq
startsWith def startsWith[B](that : Seq[B])
[details]
return
- true if this sequence start with that sequences
see
- String.startsWith
 Boolean Seq
subseq def subseq(from : Int, end : Int)
Returns a subsequence starting from index from consisting of len elements [details]
deprecated
- use slice instead
 Seq[A] Seq
synchronized final def synchronized[T0](arg0 : T0) T0 AnyRef
take override def take(n : Int)
Returns the n first elements of this stream, or else the whole stream, if it has less than n elements [details]
param
n - the number of elements to take.
return
- the n first elements of this stream.
 Stream[A]
takeWhile override def takeWhile(p : (A) => Boolean)
Returns the longest prefix of this stream whose elements satisfy the predicate p [details]
param
p - the test predicate.
return
- the longest prefix of this stream whose elements satisfy the predicate p.
Stream[A]
toArray override def toArray[B >: A]
Converts this sequence to a fresh Array with length elements
Array[B] Seq
toString override def toString
Converts stream to string
String
wait final def wait(arg0 : Long) Unit AnyRef
wait final def wait Unit AnyRef
wait final def wait(arg0 : Long, arg1 : Int) Unit AnyRef
zip def zip[B](that : Stream[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 [details]
If one of the two streams is longer than the other, its remaining elements are ignored.
return
- Stream({a0,b0}, ..., {amin(m,n),bmin(m,n))} when Stream(a0, ..., am) zip Stream(b0, ..., bn) is invoked.
Stream[(A, B)]
zipWithIndex def zipWithIndex
Returns a stream that pairs each element of this stream with its index, counting from 0 [details]
return
- the stream Stream({a0,0}, {a0,1},...) where ai are the elements of this stream.
Stream[(A, Int)]
OVERVIEW |  PACKAGE | CONSTR |  FIELDS |  METHODS FRAMES    NO FRAMES INHERITED
Copyright (c) 2008. All Rights Reserved.