Scala 2.5.0-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
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$4 : (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$1 : (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$0 : (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$3 : (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$2 : (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