Scala 2.6.1-final
API Specification

This document is the API specification for Scala Library Documentation

Class Summary
`class` | BitSet (`val` size : Int, `val` capacity : Int, ba : Array[Int], copy : Boolean)`extends` BitSet The class `BitSet` provides an immutable bitset view on an int array. Instances can conveniently be created from instances of Bit indices are between `0..(capacity-1)` inclusive.
`class` | EmptyMap [A, +B]`extends` Map[A, B] This class implements empty immutable maps
`class` | EmptySet [A]`extends` Set[A] This class implements empty immutable sets
`protected abstract class` | GBTree [A, B](`implicit` view$5 : (A) => Ordered[A])`extends` AnyRef `GBTree` is an internal class used by `Tree`.
`class` | HashMap [A, B]`extends` Map[A, B]`with` HashTable[A] This class implements immutable maps using a hash table.
`class` | HashSet [A]`extends` Set[A]`with` FlatHashTable[A] This class implements immutable sets using a hash table.
`sealed abstract class` | ImmutableIterator [+A]`extends` AnyRef A stateless iterator.
`protected abstract class` | InsertTree [A, B](`implicit` view$2 : (A) => Ordered[A])`extends` AnyRef
`class` | ListMap [A, +B]`extends` Map[A, B] This class implements immutable maps using a list-based data structure. Instances of `ListMap` represent empty maps; they can be either created by calling the constructor directly, or by applying the function `ListMap.empty`.
`class` | ListSet [A]`extends` Set[A] This class implements immutable sets using a list-based data structure. Instances of `ListSet` represent empty sets; they can be either created by calling the constructor directly, or by applying the function `ListSet.empty`.
`trait` | Map [A, +B]`extends` Map[A, B] This class defines the interface for immutable maps. Operations on an immutable map leave the original map unchanged, and return a new map if needed. Concrete map implementations have to provide functionality for the abstract methods in `scala.collection.Map` as well as for `factory`, `update`, and `-`.
`class` | Map1 [A, +B](key1 : A, value1 : B)`extends` Map[A, B] This class implements immutable maps with exactly one entry
`class` | Map2 [A, +B](key1 : A, value1 : B, key2 : A, value2 : B)`extends` Map[A, B] This class implements immutable maps with exactly two entries
`class` | Map3 [A, +B](key1 : A, value1 : B, key2 : A, value2 : B, key3 : A, value3 : B)`extends` Map[A, B] This class implements immutable maps with exactly three entries
`class` | Map4 [A, +B](key1 : A, value1 : B, key2 : A, value2 : B, key3 : A, value3 : B, key4 : A, value4 : B)`extends` Map[A, B] This class implements immutable maps with exactly four entries
`class` | Queue [+A](elem : A*)`extends` Seq[A] `Queue` objects implement data structures that allow to insert and retrieve elements in a first-in-first-out (FIFO) manner.
`abstract class` | RedBlack [A]`extends` AnyRef
`trait` | Set [A]`extends` Set[A] This class defines the interface for immutable sets. Operations on an immutable set leave the original set unchanged, and return a new set if needed. Concrete set implementations just have to provide functionality for the abstract methods in `scala.collection.Set` as well as for `+` and `-`. Note that abstract immutable.Set's are not covariant in their type parameter. This is because some implementations cannot support the `+` method for arbitrary types.
`class` | Set1 [A](elem1 : A)`extends` Set[A] This class implements immutable sets with exactly one element.
`class` | Set2 [A](elem1 : A, elem2 : A)`extends` Set[A] This class implements immutable sets with exactly two elements.
`class` | Set3 [A](elem1 : A, elem2 : A, elem3 : A)`extends` Set[A] This class implements immutable sets with exactly three elements.
`class` | Set4 [A](elem1 : A, elem2 : A, elem3 : A, elem4 : A)`extends` Set[A] This class implements immutable sets with exactly four elements.
`trait` | SortedMap [A, +B]`extends` Map[A, B]`with` SortedMap[A, B]
`trait` | SortedSet [A]`extends` SortedSet[A]`with` Set[A]
`class` | Stack [+A]`extends` Seq[A] This class implements immutable stacks using a list-based data structure. Instances of `Stack` represent empty stacks; they can be either created by calling the constructor directly, or by applying the function `Stack.Empty`.
`abstract class` | Tree [A, B](`implicit` view$1 : (A) => Ordered[A])`extends` AnyRef General Balanced Trees - highly efficient functional dictionaries. An efficient implementation of Prof. Arne Andersson's General Balanced Trees. These have no storage overhead compared to plain unbalanced binary trees, and their performance is in general better than AVL trees. This implementation does not balance the trees after deletions. Since deletions don't increase the height of a tree, this should be OK in most applications. A balance method is provided for those cases where rebalancing is needed. The tree consists of entries conatining a key with an order. When instanciating the tree an order for the keys has to be supplied.
`class` | TreeMap [A, +B](`val` size : Int, t : Tree[B], `implicit` view$4 : (A) => Ordered[A])`extends` RedBlack[A]`with` SortedMap[A, B] This class implements immutable maps using a tree.
`class` | TreeSet [A](`val` size : Int, t : Tree[Unit], `implicit` view$3 : (A) => Ordered[A])`extends` RedBlack[A]`with` SortedSet[A] This class implements immutable sets using a tree.
`class` | UnbalancedTreeMap [A, +B](`implicit` view$3 : (A) => Ordered[A])`extends` Map[A, B] This class implements immutable maps using a tree.

Object Summary
`object` | HashMap `extends` AnyRef The canonical factory methods for immutable HashMap's.
`object` | HashSet `extends` AnyRef The canonical factory methods for immutable HashSet's.
`object` | ImmutableIterator `extends` AnyRef An object for creating immutable iterators.
`object` | ListMap `extends` AnyRef The canonical factory of ListMap's
`object` | ListSet `extends` AnyRef The canonical factory of ListSet's
`object` | Map `extends` AnyRef An object for creating immutable maps. These are implemented using immutable hash maps.
`object` | Queue `extends` AnyRef
`object` | Set `extends` AnyRef Canonical factories for immutable sets. The canonical immutable sets are currently implemented using immutable hash sets.
`object` | Stack `extends` AnyRef
`object` | TreeMap `extends` AnyRef The canonical factory of TreeMap's.
`object` | TreeSet `extends` AnyRef The canonical factory of TreeSet's.
`object` | UnbalancedTreeMap `extends` AnyRef