in scala
class Iterable

mixin abstract `class` Iterable [ A ]
  `extends` java.lang.Object
  `with` scala.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
version:
  1.1, 04/02/2004

Def Summary
| `def` /: [ B ] ( z : B ) ( f : (B, A) => B ) : B Similar to `foldLeft` but can be used as an operator with the order of list and zero arguments reversed. That is, `z /: xs` is the same as `xs foldLeft z`
| `def` :\ [ B ] ( z : B ) ( f : (A, B) => B ) : B An alias for `foldRight`. That is, `xs :\ z` is the same as `xs foldRight z`
| `def` concat [ A <: B ] ( that : scala.Iterable[B] ) : scala.Iterable[B] Concatenates two iterable objects
| `def` elements : scala.Iterator[A] Creates a new iterator over all elements contained in this object.
| `def` exists ( p : (A) => scala.Boolean ) : scala.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.
| `def` find ( p : (A) => scala.Boolean ) : scala.Option[A] Find and return the first element of the iterable object satisfying a predicate, if any.
| `def` foldLeft [ B ] ( z : B ) ( op : (B, A) => B ) : B Combines the elements of this list together using the binary operator `op`, from left to right, and starting with the value `z`.
| `def` foldRight [ B ] ( z : B ) ( op : (A, B) => B ) : B Combines the elements of this list together using the binary operator `op`, from rigth to left, and starting with the value `z`.
| `def` forall ( p : (A) => scala.Boolean ) : scala.Boolean Apply a predicate `p` to all elements of this iterable object and return true, iff the predicate yields true for all elements.
| `def` foreach ( f : (A) => scala.Unit ) : scala.Unit Apply a function `f` to all elements of this iterable object.
| `def` sameElements [ A <: B ] ( that : scala.Iterable[B] ) : scala.Boolean Checks if the other iterable object contains the same elements.

Def Detail

`def` /: [ B ]( z : B ) ( f : (B, A) => B ) : B

  Similar to `foldLeft` but can be used as an operator with the order of list and zero arguments reversed. That is, `z /: xs` is the same as `xs foldLeft z`

`def` :\ [ B ]( z : B ) ( f : (A, B) => B ) : B

  An alias for `foldRight`. That is, `xs :\ z` is the same as `xs foldRight z`

`def` concat [ A <: B ]( that : scala.Iterable[B] ) : scala.Iterable[B]

  Concatenates two iterable objects

return:
  the new iterable object
author:
  buraq

`def` elements : scala.Iterator[A]

  Creates a new iterator over all elements contained in this object.

return:
  the new iterator

`def` exists ( p : (A) => scala.Boolean ) : scala.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.

param:
  p the predicate
returns:
  true, iff the predicate yields true for at least one element.

`def` find ( p : (A) => scala.Boolean ) : scala.Option[A]

  Find and return the first element of the iterable object satisfying a predicate, if any.

param:
  p the predicate
return:
  the first element in the iterable object satisfying `p`, or `None` if none exists.

`def` foldLeft [ B ]( z : B ) ( op : (B, A) => B ) : B

  Combines the elements of this list together using the binary operator `op`, from left to right, and starting with the value `z`.

return:
  `op(... (op(op(z,a0),a1) ...), an)` if the list is `List(a0, a1, ..., an)`.

`def` foldRight [ B ]( z : B ) ( op : (A, B) => B ) : B

  Combines the elements of this list together using the binary operator `op`, from rigth to left, and starting with the value `z`.

return:
  `a0 op (... op (an op z)...)` if the list is `[a0, a1, ..., an]`.

`def` forall ( p : (A) => scala.Boolean ) : scala.Boolean

  Apply a predicate `p` to all elements of this iterable object and return true, iff the predicate yields true for all elements.

param:
  p the predicate
returns:
  true, iff the predicate yields true for all elements.

`def` foreach ( f : (A) => scala.Unit ) : scala.Unit

  Apply a function `f` to all elements of this iterable object.

param:
  f a function that is applied to every element.

`def` sameElements [ A <: B ]( that : scala.Iterable[B] ) : scala.Boolean

  Checks if the other iterable object contains the same elements.

param:
  that the other iterable object
return:
  true, iff both iterable objects contain the same elements.