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.

This class implements empty immutable maps

This class implements empty immutable sets

GBTree is an internal class used by Tree.

This class implements immutable maps/sets using a hash table. It is optimized for sequential accesses where the last updated table is accessed most often. It supports with reasonable efficiency accesses to previous versions of the table by keeping a change log that's regularly compacted. It needs to synchronize most methods, so it is less suitable for highly concurrent accesses.

This class implements immutable maps/sets using a hash table. It is optimized for sequential accesses where the last updated table is accessed most often. It supports with reasonable efficiency accesses to previous versions of the table by keeping a change log that's regularly compacted. It needs to synchronize most methods, so it is less suitable for highly concurrent accesses.

A stateless iterator.

Specialised immutable map structure for integer keys, based on Fast Mergeable Integer Maps by Okasaki and Gill. Essentially a trie based on binary digits of the the integers.

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.

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.

Specialised immutable map structure for long keys, based on Fast Mergeable Long Maps by Okasaki and Gill. Essentially a trie based on binary digits of the the integers.

This class implements immutable maps with exactly one entry

This class implements immutable maps with exactly two entries

This class implements immutable maps with exactly three entries

This class implements immutable maps with exactly four entries

An implementation of lazily computed sequences, where elements are stored in ``pages'', i.e. arrays of fixed size.

Queue objects implement data structures that allow to insert and retrieve elements in a first-in-first-out (FIFO) manner.

This class implements immutable sets with exactly one element.

This class implements immutable sets with exactly two elements.

This class implements immutable sets with exactly three elements.

This class implements immutable sets with exactly four elements.

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.

An immutable Map which is based on an IntMap mapping hash codes to lists of (Key, Value) pairs with the same hashCode. Unlike the usual immutable.HashMap it is truly immutable behind the scenes. Consequently it is entirely safe to share between multiple threads and should achieve a much greater degree of sharing between instances. Performancewise, get and update seem to be somewhat slower than with a traditional hash map, but bulk operations such as filter, foreach and transform appear to get something of a speedup.

This class implements immutable maps using a tree.

This class implements immutable sets using a tree.

This class implements immutable maps using a tree.

The canonical factory methods for immutable HashMap's.

The canonical factory methods for immutable HashSet's.

An object for creating immutable iterators.

The canonical factory of ListMap's

The canonical factory of ListSet's

The PagedSeq object defines a lazy implementations of a random access sequence.

Canonical factories for immutable sets. The canonical immutable sets are currently implemented using immutable hash sets.

The canonical factory of TreeMap's.

The canonical factory of TreeSet's.