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

scala.Iterable

trait Iterable

trait Iterable[+ A]

 extends ScalaObject

Collection classes mixing in this class provide a method elements which returns an iterator over all the elements contained in the collection.
author
- Matthias Zenger
note
- If a collection has a known size, it should also sub-type Collection. Only potentially unbounded collections should directly sub-class Iterable.
version
- 1.1, 04/02/2004


Companion: Iterable

Source: Iterable.scala(114)

Direct Known Subclasses

Ranged, Projection, IterableProxy, Collection, Scope,

 Fields

elements abstract def elements
Creates a new iterator over all elements contained in this object [details]
return
- the new iterator
 Iterator[A]
hasDefiniteSize 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
isEmpty def isEmpty
Is this collection empty?
Boolean
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
projection 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]
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]
toSeq def toSeq
Returns a sequence containing all of the elements in this iterable object [details]
note
- Will not terminate for infinite-sized collections.
 Seq[A]
toStream 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
++ def ++[B >: A](that : Iterable[B])
Appends two iterable objects [details]
note
- Will not terminate for infinite-sized collections.
return
- the new iterable object
 Collection[B]
/: 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
:\ 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
== 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
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
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
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
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.
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
concat def concat[B >: A](that : Iterable[B])
Appends two iterable objects [details]
deprecated
- use ++ instead
note
- Will not terminate for infinite-sized collections.
return
- the new iterable object
 Collection[B]
copyToArray def copyToArray[B >: A](xs : Array[B], start : Int)
Fills the given array xs with the elements of this sequence starting at position start [details]
note
- Will not terminate for infinite-sized collections.
param
xs - the array to fill.
start - starting index.
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
drop def drop(n : Int)
Returns this iterable without its n first elements If this iterable has less than n elements, the empty iterable is returned [details]
deprecated
- API does not make sense for non-ordered collections
note
- Will not terminate for infinite-sized collections.
param
n - the number of elements to drop
return
- the new iterable
 Collection[A]
dropWhile def dropWhile(p : (A) => Boolean)
Returns the longest suffix of this iterable whose first element does not satisfy the predicate p [details]
note
- May not terminate for infinite-sized collections.
param
p - the test predicate.
return
- the longest suffix of the iterable whose first element does not satisfy the predicate p.
Collection[A]
eq 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
exists def exists(p : (A) => Boolean)
Apply a predicate p to all elements of this iterable object and return true, iff there is at least one element for which p yields true [details]
note
- May not terminate for infinite-sized collections.
param
p - the predicate
return
- true, iff the predicate yields true for at least one element.
 Boolean
filter def filter(p : (A) => Boolean)
Returns all the elements of this iterable that satisfy the predicate p [details]
The order of the elements is preserved.
note
- Will not terminate for infinite-sized collections.
param
p - the predicate used to filter the list.
return
- the elements of this list satisfying p.
 Iterable[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]
findIndexOf def findIndexOf(p : (A) => Boolean)
Returns index of the first element satisying a predicate, or -1 [details]
deprecated
- Method is pushed to Seq, will be removed from Iterable.
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
flatMap def flatMap[B](f : (A) => Iterable[B])
Applies the given function f to each element of this iterable, then concatenates the results [details]
note
- Will not terminate for infinite-sized collections.
param
f - the function to apply on each element.
return
- f(a0) ::: ... ::: f(an) if this iterable is a0, ..., an.
Iterable[B]
foldLeft def foldLeft[B](z : B)(op : (B, A) => B)
Combines the elements of this iterable object together using the binary function f, from left to right, and starting with the value z [details]
note
- Will not terminate for infinite-sized collections.
return
- f(... (f(f(z, a0), a1) ...), an) if the list is [a0, a1, ..., an].
B
foldRight def foldRight[B](z : B)(op : (A, B) => B)
Combines the elements of this list together using the binary function f, from right to left, and starting with the value z [details]
note
- Will not terminate for infinite-sized collections.
return
- f(a0, f(a1, f(..., f(an, z)...))) if the list is [a0, a1, ..., an].
B
forall def forall(p : (A) => Boolean)
Apply a predicate p to all elements of this iterable object and return true, iff the predicate yields true for all elements [details]
note
- May not terminate for infinite-sized collections.
param
p - the predicate
return
- true, iff the predicate yields true for all elements.
 Boolean
foreach def foreach(f : (A) => Unit)
Apply a function f to all elements of this iterable object [details]
note
- Will not terminate for infinite-sized collections.
param
f - a function that is applied to every 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 def indexOf[B >: A](elem : B)
Returns the index of the first occurence of the specified object in this iterable object [details]
deprecated
- Method is pushed to Seq, will be removed from Iterable.
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
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
map def map[B](f : (A) => B)
Returns the iterable resulting from applying the given function f to each element of this iterable [details]
note
- Will not terminate for infinite-sized collections.
param
f - function to apply to each element.
return
- f(a0), ..., f(an) if this iterable is a0, ..., an.
Iterable[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
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
ne 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
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])
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
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
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
synchronized final def synchronized[T0](arg0 : T0) T0 AnyRef
take def take(n : Int)
Returns an iterable consisting only over the first n elements of this iterable, or else the whole iterable, if it has less than n elements [details]
deprecated
- API does not make sense for non-ordered collections
param
n - the number of elements to take
return
- the new iterable
 Collection[A]
takeWhile def takeWhile(p : (A) => Boolean)
Returns the longest prefix of this iterable whose elements satisfy the predicate p [details]
note
- May not terminate for infinite-sized collections.
param
p - the test predicate.
return
- the longest prefix of this iterable whose elements satisfy the predicate p.
Iterable[A]
toString def toString
Returns a string representation of the object [details]

The default representation is platform dependent.

return
- a string representation of the object.

String AnyRef
wait final def wait Unit AnyRef
wait final def wait(arg0 : Long) Unit AnyRef
wait final def wait(arg0 : Long, arg1 : Int) Unit AnyRef
OVERVIEW |  PACKAGE | CONSTR |  FIELDS |  METHODS FRAMES    NO FRAMES INHERITED