| 
 | 
          Scala 1.3.0.7 | |||
hasNext method for checking
  if there is a next element available, and a next method
  which returns the next element and discards it from the iterator.
| Method Summary | |
| def /:[B](z: B)(f: (B,A) => B): BSimilar to foldLeftbut can be used as
  an operator with the order of list and zero arguments reversed. | |
| def :\[B](z: B)(f: (A,B) => B): BAn alias for foldRight. | |
| def append[B >: A](that: Iterator[B]): Iterator[B]Returns a new iterator that first yields the elements of this iterator followed by the elements provided by iterator that. | |
| def buffered: BufferedIterator[A]Returns a buffered iterator from this iterator. | |
| def contains(elem: Any): BooleanTests if the given value elemis a member of this list. | |
| def copyToArray[B >: A](xs: Array[B], start: Int): Array[B]Fills the given array xswith the elements of
  this sequence starting at positionstart. | |
| def drop(n: Int): Iterator[A]Removes the first nelements from this iterator. | |
| def duplicate: Tuple2[Iterator[A],Iterator[A]]Creates two new iterators that both iterate over the same elements than this iterator (in the same order). | |
| def exists(p: (A) => Boolean): BooleanApply a predicate pto all elements of this
  iterable object and return true, iff there is at least one
  element for whichpyields true. | |
| def filter(p: (A) => Boolean): Iterator[A]Returns an iterator over all the elements of this iterator that satisfy the predicate p. | |
| def find(p: (A) => Boolean): Option[A]Find and return the first element of the iterable object satisfying a predicate, if any. | |
| def flatMap[B](f: (A) => Iterator[B]): Iterator[B]Applies the given function fto each element of
  this iterator, then concatenates the results. | |
| def foldLeft[B](z: B)(op: (B,A) => B): BCombines the elements of this list together using the binary operator op, from left to right, and starting with
  the valuez. | |
| def foldRight[B](z: B)(op: (A,B) => B): BCombines the elements of this list together using the binary operator op, from rigth to left, and starting with
  the valuez. | |
| def forall(p: (A) => Boolean): BooleanApply a predicate pto all elements of this
  iterable object and return true, iff the predicate yields
  true for all elements. | |
| def foreach(f: (A) => Unit): UnitApply a function fto all elements of this
  iterable object. | |
| 
        abstract | def hasNext: BooleanDoes this iterator provide another element? | 
| def map[B](f: (A) => B): Iterator[B]Returns a new iterator that maps all elements of this iterator to new elements using function f. | |
| 
        abstract | def next: AReturns the next element. | 
| def take(n: Int): Iterator[A]Returns a new iterator that iterates only over the first nelements. | |
| def toList: List[A]Transform this iterator into a list of all elements. | |
| def zip[B](that: Iterator[B]): Iterator[Tuple2[A,B]]Return an iterator formed from this iterator and the specified iterator thatby associating each element of the former with
  the element at the same position in the latter. | |
| Methods inherited from java/lang/Object-class | 
| clone, eq, equals, finalize, getClass, hashCode, notify, notifyAll, synchronized, toString, wait, wait, wait | 
| Methods inherited from scala/Any-class | 
| !=, ==, asInstanceOf, isInstanceOf, match | 
| Methods inherited from scala/ScalaObject-class | 
| getType | 
| Method Detail | 
abstract def hasNext: Boolean
abstract def next: A
def take(n: Int): Iterator[A]
n
  elements.
     
def drop(n: Int): Iterator[A]
n elements from this iterator.
     
def map[B](f: (A) => B): Iterator[B]
f.
     
def append[B >: A](that: Iterator[B]): Iterator[B]
that.
     
def flatMap[B](f: (A) => Iterator[B]): Iterator[B]
f to each element of
  this iterator, then concatenates the results.
f - 
  the function to apply on each element.
  f(a0), ... , f(an) if this iterator
          yields the elements a0, ..., an.
     
def filter(p: (A) => Boolean): Iterator[A]
p. The order of the elements
  is preserved.
p - 
  the redicate used to filter the iterator.
  p.
     
def zip[B](that: Iterator[B]): Iterator[Tuple2[A,B]]
that by associating each element of the former with
  the element at the same position in the latter.
that(a0,b0), ..., (an,bn) where
           ai are the elements from this iterator and
           bi are the elements from iterator that.
     
def foreach(f: (A) => Unit): Unit
f to all elements of this
  iterable object.
f - 
  a function that is applied to every element.
     
  def forall(p: (A) => Boolean): Boolean
p to all elements of this
  iterable object and return true, iff the predicate yields
  true for all elements.
p - 
  the predicate
  def exists(p: (A) => Boolean): Boolean
p to all elements of this
  iterable object and return true, iff there is at least one
  element for which p yields true.
p - 
  the predicate
  def contains(elem: Any): Boolean
elem is a member of this list.
elem - 
  element whose membership has to be tested.
  ==) to elem.
     
def find(p: (A) => Boolean): Option[A]
p - 
  the predicate
  p,
  or None if none exists.
     
def foldLeft[B](z: B)(op: (B,A) => B): B
op, from left to right, and starting with
  the value z. 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
op, from rigth to left, and starting with
  the value z. a0 op (... op (an op z)...) if the list
  is [a0, a1, ..., an].
     
def /:[B](z: B)(f: (B,A) => B): B
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
foldRight.
  That is, xs :\ z is the same as xs foldRight z
     
def buffered: BufferedIterator[A]
def duplicate: Tuple2[Iterator[A],Iterator[A]]
def copyToArray[B >: A](xs: Array[B], start: Int): Array[B]
xs with the elements of
  this sequence starting at position start.
xs - 
  the array to fill.
  start - 
  starting index.
  xs filled with this list.
     
def toList: List[A]
| 
 | 
          Scala 1.3.0.7 | |||