addString will take a StringBuilder to add the contents of list into the builder.

Two case fragments can be chained to create a more robust result:

collect will apply a partial function to all elements of a Traversable and return a different collection.

count will count the number of elements that satisfy a predicate in a Traversable:

drop will take the rest of the Traversable except the number of elements given:

dropWhile will continually drop elements until a predicate is no longer satisfied:

exists will determine if a predicate is valid for some members of a Traversable:

filter will take out all elements that don't satisfy a predicate.

filterNot will take out all elements that satisfy a predicate:

find will locate the first item that matches the predicate p as Some, or None if an element is not found:

flatMap will not only apply the given function on all elements of a Traversable, but all elements within the elements and flatten the results:

flatMap of Options will filter out all Nones but keep the Somes:

flatten will "pack" all child Traversables into a single Traversable:

foldLeft will combine an operation starting with a seed and combining from the left.

foldRight will combine an operation starting with a seed and combining from the right.

forall will determine if a predicate is valid for all members of a Traversable:

foreach will apply a function to all elements of a Traversable, but unlike the map function, it will not return anything since the return type is Unit - an equivalent to a void return type in Java/C++:

groupBy will categorize a Traversable according to a given function and return a map with the results.

head will return the first element of an ordered collection, or some random element if order is not defined like in a Set or Map:

headOption will return the first element as an Option of an ordered collection, or some random element if order is not defined.

init will return the rest of the collection without the last:

isEmpty is pretty self-evident:

knownSize will return the number of elements if the traversable has a finite end, otherwise -1:

last will return the last element of an ordered collection, or some random element if order is not defined:

lastOption will return the last element as an Option of an ordered collection, or some random element if order is not defined.

map will apply the given function on all elements of a Traversable and return a new collection of the result:

mkString will also take a beginning and ending string to surround the list.:

mkString will format a Traversable using a given string as the delimiter:

nonEmpty is pretty self-evident too:

partition will split a Traversable according to a predicate, returning a 2 product Tuple.

reduceLeft is similar to foldLeft, except that the seed is the head value:

The naive recursive implementation of reduceRight is not tail recursive and would lead to a stack overflow if used on larger traversables.

reduceRight is similar to foldRight, except that the seed is the last value:

size provides the size of the traversable:

Given a from index, and a to index, slice will return the part of the collection including from, and excluding to:

span will split a Traversable according to a predicate, returning a 2 product Tuple.

splitAt will split a Traversable at a position, returning a 2 product Tuple.

There are some methods that take much of the folding work out by providing basic functionality.

tail will return the rest of the collection without the head:

take is used often with LazyList, since they are also Traversable:

take will return the first number of elements given:

takeWhile will continually accumulate elements until a predicate is no longer satisfied:

toArray will convert any Traversable to an Array, which is a special wrapper around a primitive Java array:

toIndexedSeq will convert any Traversable to an IndexedSeq which is an indexed sequence used in Vectors and Strings:

toIterable will convert any Traversable to an Iterable.

toStream will convert any Traversable to a LazyList where elements are evaluated as they are needed:

toList, as well as other conversion methods such as toSet and toArray, will not convert if the collection type is the same:

toList will convert any Traversable to a List.

toMap will also convert a Set to a Map; it should be of parameterized type Tuple2:

toMap will convert any Traversable to a Map.

toSeq will convert any Traversable to a Seq which is an ordered Iterable and the superclass to List, Queue, and Vector.

toSet will convert any Traversable to a Set which is a collection of unordered, unique values:

At the top of the collection hierarchy is the trait Traversable.

def foreach[U](f: Elem => U)

transpose will take a traversable of traversables and group them by their position in it's own traversable, e.g.: ((x1, x2),(y1, y2)).transpose = (x1, y1), (x2, y2) or ((x1, x2, x3),(y1, y2, y3),(z1, z2, z3)).transpose = ((x1, y1, z1), (x2, y2, z2), (x3, y3, z3))