scala library 2.7.2.final API : scala.Stream

scala.Stream

class Stream

abstract class 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(218)

Direct Known Subclasses

Definite

Constructors

def this

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.

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.

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.

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)

o != arg0 is the same as !(o == (arg0)) [details]

param: arg0 - the object to compare against this object for dis-equality.
return: - false if the receiver object is equivalent to the argument; true otherwise.

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.

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.

Iterable

final def ==(arg0 : Object)

o == arg0 is the same as

if (o eq null) arg0 eq null else o
        
              [details]


                equals(arg0)

param: arg0 - the object to compare against this object for equality.
return: - true if the receiver object is equivalent to the argument; false otherwise.

Boolean

AnyRef

final def ==(arg0 : Any)

o == arg0 is the same as

o
        
              [details]


                equals(arg0)

param: arg0 - the object to compare against this object for equality.
return: - true if the receiver object is equivalent to the argument; false otherwise.

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)

Write all elements of this string into given string builder, with no separator string between elements [details]

note: - Will not terminate for infinite-sized collections.
param: buf - the StringBuilder to which elements are appended
return: - the buf StringBuilder object

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: sep - separator string.; buf - the StringBuilder to which elements are appended; start - starting string.; end - ending string.
return: - the buf StringBuilder object

StringBuilder

Iterable

addString

def addString(buf : StringBuilder, sep : String)

Write all elements of this string into given string builder [details]

note: - Will not terminate for infinite-sized collections.
param: buf - the StringBuilder to which elements are appended; sep - separator string.
return: - the buf StringBuilder object

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.

asInstanceOf

final def asInstanceOf[T0]

This method is used to cast the receiver object to be of type T0 [details]

Note that the success of a cast at runtime is modulo Scala's erasure semantics. Therefore the expression 1.asInstanceOf[String] will throw a ClassCastException at runtime, while the expression List(1).asInstanceOf[List[String]] will not. In the latter example, because the type argument is erased as part of compilation it is not possible to check whether the contents of the list are of the requested typed.

return: - the receiver object.
throws: ClassCastException - if the receiver object is not an instance of erasure of type T0.

Any

clone

protected def clone

This method creates and returns a copy of the receiver object [details]

The default implementation of the clone method is platform dependent.

return: - a copy of the receiver object.

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

final def eq(arg0 : Object)

This method is used to test whether the argument (arg0) is a reference to the receiver object (this) [details]

The eq method implements an equivalence relation on non-null instances of AnyRef:

It is reflexive: for any non-null instance x of type AnyRef, x.eq(x) returns true.
It is symmetric: for any non-null instances x and y of type AnyRef, x.eq(y) returns true if and only if y.eq(x) returns true.
It is transitive: for any non-null instances x, y, and z of type AnyRef if x.eq(y) returns true and y.eq(z) returns true, then x.eq(z) returns true.

Additionally, the eq method has three other properties.

It is consistent: for any non-null instances x and y of type AnyRef, multiple invocations of x.eq(y) consistently returns true or consistently returns false.
For any non-null instance x of type AnyRef, x.eq(null) and null.eq(x) returns false.
null.eq(null) returns true.

When overriding the equals or hashCode methods, it is important to ensure that their behavior is consistent with reference equality. Therefore, if two objects are references to each other (o1 eq o2), they should be equal to each other (o1 == o2) and they should hash to the same value (o1.hashCode == o2.hashCode).

param: arg0 - the object to compare against this object for reference equality.
return: - true if the argument is a reference to the receiver object; false otherwise.

Boolean

AnyRef

equals

def equals(arg0 : Any)

This method is used to compare the receiver object (this) with the argument object (arg0) for equivalence [details]

The default implementations of this method is an equivalence relation:

It is reflexive: for any instance x of type Any, x.equals(x) should return true.
It is symmetric: for any instances x and y of type Any, x.equals(y) should return true if and only if y.equals(x) returns true.
It is transitive: for any instances x, y, and z of type AnyRef if x.equals(y) returns true and y.equals(z) returns true, then x.equals(z) should return true.

If you override this method, you should verify that your implementation remains an equivalence relation. Additionally, when overriding this method it is often necessary to override hashCode to ensure that objects that are "equal" (o1.equals(o2) returns true) hash to the same Int (o1.hashCode.equals(o2.hashCode)).

param: arg0 - the object to compare against this object for equality.
return: - true if the receiver object is equivalent to the argument; false otherwise.

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

This method is called by the garbage collector on the receiver object when garbage collection determines that there are no more references to the object [details]

The details of when and if the finalize method are invoked, as well as the interaction between finalize and non-local returns and exceptions, are all platform dependent.

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

override 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

Seq

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(a₀) ::: ... ::: f(a_n) if this stream is [a₀, ..., a_n].

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, a₀), a₁) ...), a_n) if the stream is [a₀, a₁, ..., a_n].

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(a₀, f(a₁, f(..., f(a_n, z)...))) if the stream is [a₀, a1, ..., a_n].

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

Returns a representation that corresponds to the dynamic class of the receiver object [details]

The nature of the representation is platform dependent.

return: - a representation that corresponds to the dynamic class of the receiver object.

Class[Any]

AnyRef

hashCode

def hashCode

Returns a hash code value for the object [details]

The default hashing algorithm is platform dependent. Note that it is allowed for two objects to have identical hash codes (o1.hashCode.equals(o2.hashCode)) yet not be equal (o1.equals(o2) returns false). A degenerate implementation could always return 0. However, it is required that if two objects are equal (o1.equals(o2) returns true) that they have identical hash codes (o1.hashCode.equals(o2.hashCode)). Therefore, when overriding this method, be sure to verify that the behavior is consistent with the equals method.

return: - the hash code value for the object.

Int

AnyRef

indexOf

override 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

Seq

indexOf

def indexOf[B >: A](that : Seq[B])

Searches for the argument sequence in the receiver object, returning the smallest index where a match occurs [details]

If the receiver object, this, is an infinite sequence this method will not terminate if there is no match. Similarly, if the both the receiver object and the argument, that are infinite sequences this method will not terminate. Because both the receiver object and the argument can both potentially be an infinite sequences, we do not attempt to use an optimized searching algorithm. Therefore, the running time will be proportional to the length of the receiver object and the argument. Subclasses and traits can potentially provide an optimized implementation.

return: - -1 if that not contained in this, otherwise the smallest index where that is found.
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]

This method is used to test whether the dynamic type of the receiver object is T0 [details]

Note that the test result of the test is modulo Scala's erasure semantics. Therefore the expression 1.isInstanceOf[String] will return false, while the expression List(1).isInstanceOf[List[String]] will return true. In the latter example, because the type argument is erased as part of compilation it is not possible to check whether the contents of the list are of the requested typed.

return: - true if the receiver object is an instance of erasure of type T0; false otherwise.

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 final def lengthCompare(l : Int)

Result of comparing length with operand l [details]

returns x where x < 0 iff this.length < l x == 0 iff this.length == l x > 0 iff this.length > that. This method is used by matching streams against right-ignoring (...,_*) patterns. This method does not call Stream.length, it works for O(l), not for O(length) and does not force full Stream evaluation.

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(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

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

final def ne(arg0 : Object)

o
        
              [details]


                ne(arg0)

is the same as !(o.eq(arg0)).

param: arg0 - the object to compare against this object for reference dis-equality.
return: - false if the argument is not a reference to the receiver object; true otherwise.

Boolean

AnyRef

notify

final def notify

Wakes up a single thread that is waiting on the receiver object's monitor

Unit

AnyRef

notifyAll

final def notifyAll

Wakes up all threads that are waiting on the receiver object's monitor

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(a₀,a₁), ..., a_n) if the iterable object has elements a₀, a₁, ..., a_n.
throws: Predef.UnsupportedOperationException - if the iterable object is empty.

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: - a₀ op (... op (a_n-1 op a_n)...) if the iterable object has elements a₀, a₁, ..., a_n.
throws: Predef.UnsupportedOperationException - if the iterator is empty.

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]

deprecated: - Use drop(n: Int): Seq[A] instead.
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])

Check whether the receiver object starts with the argument sequence [details]

return: - true if that is a prefix of this, otherwise false
see: - Seq.startsWith

Boolean

Seq

startsWith

def startsWith[B](that : Seq[B], offset : Int)

Checks whether the argument sequence is contained at the specified index within the receiver object [details]

If the both the receiver object, this and the argument, that are infinite sequences this method may not terminate.

return: - true if that is contained in this, at the specified index, otherwise false
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)

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

Unit

AnyRef

wait

final def wait(arg0 : Long)

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({a₀,b₀}, ..., {a_min(m,n),b_min(m,n))} when Stream(a₀, ..., a_m) zip Stream(b₀, ..., b_n) 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({a₀,0}, {a₀,1},...) where a_i are the elements of this stream.

Stream[(A, Int)]

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]

scala.Stream class Stream

Direct Known Subclasses

Constructors

Fields

Methods

scala.Stream

class Stream