ManagedTraversable

def internalForeach [U] (resource: A, f: (B) ⇒ U): Unit

This method gives us an iterator over items in a resource.

val resource : ManagedResource[A]

The resource we plan to traverse through

def != (arg0: AnyRef): Boolean

def != (arg0: Any): Boolean

def ## (): Int

def ++ [B >: B, That] (that: TraversableOnce[B])(implicit bf: CanBuildFrom[Traversable[B], B, That]): That

def ++ [B >: B, That] (that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[Traversable[B], B, That]): That

def ++: [B >: B, That] (that: Traversable[B])(implicit bf: CanBuildFrom[Traversable[B], B, That]): That

def ++: [B >: B, That] (that: TraversableOnce[B])(implicit bf: CanBuildFrom[Traversable[B], B, That]): That

def /: [B] (z: B)(op: (B, B) ⇒ B): B

def /:\ [A1 >: B] (z: A1)(op: (A1, A1) ⇒ A1): A1

def :\ [B] (z: B)(op: (B, B) ⇒ B): B

def == (arg0: AnyRef): Boolean

def == (arg0: Any): Boolean

def addString (b: StringBuilder): StringBuilder

def addString (b: StringBuilder, sep: String): StringBuilder

def addString (b: StringBuilder, start: String, sep: String, end: String): StringBuilder

def aggregate [B] (z: B)(seqop: (B, B) ⇒ B, combop: (B, B) ⇒ B): B

def asInstanceOf [T0] : T0

def clone (): AnyRef

def collect [B, That] (pf: PartialFunction[B, B])(implicit bf: CanBuildFrom[Traversable[B], B, That]): That

def collectFirst [B] (pf: PartialFunction[B, B]): Option[B]

def companion : GenericCompanion[Traversable]

def copyToArray [B >: B] (xs: Array[B], start: Int, len: Int): Unit

def copyToArray [B >: B] (xs: Array[B]): Unit

def copyToArray [B >: B] (xs: Array[B], start: Int): Unit

def copyToBuffer [B >: B] (dest: Buffer[B]): Unit

def count (p: (B) ⇒ Boolean): Int

def drop (n: Int): Traversable[B]

def dropWhile (p: (B) ⇒ Boolean): Traversable[B]

def eq (arg0: AnyRef): Boolean

def equals (arg0: Any): Boolean

def exists (p: (B) ⇒ Boolean): Boolean

def filter (p: (B) ⇒ Boolean): Traversable[B]

def filterNot (p: (B) ⇒ Boolean): Traversable[B]

def finalize (): Unit

def find (p: (B) ⇒ Boolean): Option[B]

def flatMap [B, That] (f: (B) ⇒ GenTraversableOnce[B])(implicit bf: CanBuildFrom[Traversable[B], B, That]): That

def flatten [B] (implicit asTraversable: (B) ⇒ TraversableOnce[B]): Traversable[B]

def fold [A1 >: B] (z: A1)(op: (A1, A1) ⇒ A1): A1

def foldLeft [B] (z: B)(op: (B, B) ⇒ B): B

def foldRight [B] (z: B)(op: (B, B) ⇒ B): B

def forall (p: (B) ⇒ Boolean): Boolean

def foreach [U] (f: (B) ⇒ U): Unit

Executes a given function against all items in the resource.

def genericBuilder [B] : Builder[B, Traversable[B]]

def getClass (): java.lang.Class[_]

def groupBy [K] (f: (B) ⇒ K): Map[K, Traversable[B]]

def handleErrorsDuringTraversal (ex: List[Throwable]): Unit

This method is called if an exception happens during traversal of the collection.

def hasDefiniteSize : Boolean

def hashCode (): Int

def head : B

def headOption : Option[B]

def ignoreError (error: Exception): Boolean

This method determines if the error can be ignored and traversable continues

def init : Traversable[B]

def inits : Iterator[Traversable[B]]

def isEmpty : Boolean

def isInstanceOf [T0] : Boolean

def isTraversableAgain : Boolean

def last : B

def lastOption : Option[B]

def map [B, That] (f: (B) ⇒ B)(implicit bf: CanBuildFrom[Traversable[B], B, That]): That

def max [B >: B] (implicit cmp: Ordering[B]): B

def maxBy [B] (f: (B) ⇒ B)(implicit cmp: Ordering[B]): B

def min [B >: B] (implicit cmp: Ordering[B]): B

def minBy [B] (f: (B) ⇒ B)(implicit cmp: Ordering[B]): B

def mkString : String

def mkString (sep: String): String

def mkString (start: String, sep: String, end: String): String

def ne (arg0: AnyRef): Boolean

def newBuilder : Builder[B, Traversable[B]]

def nonEmpty : Boolean

def notify (): Unit

def notifyAll (): Unit

def par : ParIterable[B]

def parCombiner : Combiner[B, ParIterable[B]]

def partition (p: (B) ⇒ Boolean): (Traversable[B], Traversable[B])

def product [B >: B] (implicit num: Numeric[B]): B

def reduce [A1 >: B] (op: (A1, A1) ⇒ A1): A1

def reduceLeft [B >: B] (op: (B, B) ⇒ B): B

def reduceLeftOption [B >: B] (op: (B, B) ⇒ B): Option[B]

def reduceOption [A1 >: B] (op: (A1, A1) ⇒ A1): Option[A1]

def reduceRight [B >: B] (op: (B, B) ⇒ B): B

def reduceRightOption [B >: B] (op: (B, B) ⇒ B): Option[B]

def repr : Traversable[B]

def reversed : List[B]

def scan [B >: B, That] (z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[Traversable[B], B, That]): That

def scanLeft [B, That] (z: B)(op: (B, B) ⇒ B)(implicit bf: CanBuildFrom[Traversable[B], B, That]): That

def scanRight [B, That] (z: B)(op: (B, B) ⇒ B)(implicit bf: CanBuildFrom[Traversable[B], B, That]): That

def seq : Traversable[B]

def size : Int

def slice (from: Int, until: Int): Traversable[B]

def span (p: (B) ⇒ Boolean): (Traversable[B], Traversable[B])

def splitAt (n: Int): (Traversable[B], Traversable[B])

def stringPrefix : String

def sum [B >: B] (implicit num: Numeric[B]): B

def synchronized [T0] (arg0: ⇒ T0): T0

def tail : Traversable[B]

def tails : Iterator[Traversable[B]]

def take (n: Int): Traversable[B]

def takeWhile (p: (B) ⇒ Boolean): Traversable[B]

def thisCollection : Traversable[B]

def toArray [B >: B] (implicit arg0: ClassManifest[B]): Array[B]

def toBuffer [B >: B] : Buffer[B]

def toCollection (repr: Traversable[B]): Traversable[B]

def toIndexedSeq [B >: B] : IndexedSeq[B]

def toIterable : Iterable[B]

def toIterator : Iterator[B]

def toList : List[B]

def toMap [T, U] (implicit ev: <:<[B, (T, U)]): Map[T, U]

def toSeq : Seq[B]

def toSet [B >: B] : Set[B]

def toStream : Stream[B]

def toString (): String

def toTraversable : Traversable[B]

def transpose [B] (implicit asTraversable: (B) ⇒ TraversableOnce[B]): Traversable[Traversable[B]]

def unzip [A1, A2] (implicit asPair: (B) ⇒ (A1, A2)): (Traversable[A1], Traversable[A2])

def unzip3 [A1, A2, A3] (implicit asTriple: (B) ⇒ (A1, A2, A3)): (Traversable[A1], Traversable[A2], Traversable[A3])

def view (from: Int, until: Int): TraversableView[B, Traversable[B]]

def view : TraversableView[B, Traversable[B]]

def wait (): Unit

def wait (arg0: Long, arg1: Int): Unit

def wait (arg0: Long): Unit

def withFilter (p: (B) ⇒ Boolean): FilterMonadic[B, Traversable[B]]