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
|
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
Note that abstract immutable.Set's are not covariant in their type
parameter. This is because some implementations cannot support the
|
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
|