scala.collection

# immutable

#### package immutable

Visibility

1. Public
2. All

### Type Members

1. #### final case class ::[B](hd: B, tl: List[B]) extends List[B] with Product with Serializable

   A non empty list characterized by a head and a tail.

2. #### abstract class BitSet extends AbstractSet[Int] with SortedSet[Int] with BitSet with BitSetLike[BitSet] with Serializable

   A class for immutable bitsets.

3. #### trait DefaultMap[A, +B] extends Map[A, B]

   A default map which implements the `+` and `-` methods of maps.

4. #### class HashMap[A, +B] extends AbstractMap[A, B] with Map[A, B] with MapLike[A, B, HashMap[A, B]] with Serializable with CustomParallelizable[(A, B), ParHashMap[A, B]]

   This class implements immutable maps using a hash trie.

5. #### class HashSet[A] extends AbstractSet[A] with Set[A] with GenericSetTemplate[A, HashSet] with SetLike[A, HashSet[A]] with CustomParallelizable[A, ParHashSet[A]] with Serializable

   This class implements immutable sets using a hash trie.

6. #### trait IndexedSeq[+A] extends Seq[A] with IndexedSeq[A] with GenericTraversableTemplate[A, IndexedSeq] with IndexedSeqLike[A, IndexedSeq[A]]

   A subtrait of `collection.IndexedSeq` which represents indexed sequences that are guaranteed immutable.

7. #### sealed abstract class IntMap[+T] extends AbstractMap[Int, T] with Map[Int, T] with MapLike[Int, T, IntMap[T]]

   Specialised immutable map structure for integer keys, based on Fast Mergeable Integer Maps by Okasaki and Gill.

8. #### trait Iterable[+A] extends Traversable[A] with Iterable[A] with GenericTraversableTemplate[A, Iterable] with IterableLike[A, Iterable[A]] with Parallelizable[A, ParIterable[A]]

   A base trait for iterable collections that are guaranteed immutable.

9. #### trait LinearSeq[+A] extends Seq[A] with LinearSeq[A] with GenericTraversableTemplate[A, LinearSeq] with LinearSeqLike[A, LinearSeq[A]]

   A subtrait of `collection.LinearSeq` which represents sequences that are guaranteed immutable.

10. #### sealed abstract class List[+A] extends AbstractSeq[A] with LinearSeq[A] with Product with GenericTraversableTemplate[A, List] with LinearSeqOptimized[A, List[A]]

    A class for immutable linked lists representing ordered collections of elements of type.

11. #### class ListMap[A, +B] extends AbstractMap[A, B] with Map[A, B] with MapLike[A, B, ListMap[A, B]] with Serializable

    This class implements immutable maps using a list-based data structure.

12. #### class ListSet[A] extends AbstractSet[A] with Set[A] with GenericSetTemplate[A, ListSet] with SetLike[A, ListSet[A]] with Serializable

    This class implements immutable sets using a list-based data structure.

13. #### sealed abstract class LongMap[+T] extends AbstractMap[Long, T] with Map[Long, T] with MapLike[Long, T, LongMap[T]]

    Specialised immutable map structure for long keys, based on Fast Mergeable Long Maps by Okasaki and Gill.

14. #### trait Map[A, +B] extends Iterable[(A, B)] with Map[A, B] with MapLike[A, B, Map[A, B]]

    A generic trait for immutable maps.

15. #### trait MapLike[A, +B, +This <: MapLike[A, B, This] with Map[A, B]] extends MapLike[A, B, This] with Parallelizable[(A, B), ParMap[A, B]]

    A generic template for immutable maps from keys of type `A` to values of type `B`.

16. #### trait MapProxy[A, +B] extends Map[A, B] with MapProxyLike[A, B, Map[A, B]]

    This is a simple wrapper class for `scala.collection.immutable.Map`.

17. #### abstract class NumericRange[T] extends AbstractSeq[T] with IndexedSeq[T] with Serializable

    `NumericRange` is a more generic version of the `Range` class which works with arbitrary types.

18. #### class PagedSeq[T] extends AbstractSeq[T] with IndexedSeq[T]

    An implementation of lazily computed sequences, where elements are stored in "pages", i.

19. #### class Queue[+A] extends AbstractSeq[A] with LinearSeq[A] with GenericTraversableTemplate[A, Queue] with LinearSeqLike[A, Queue[A]] with Serializable

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

20. #### class Range extends AbstractSeq[Int] with IndexedSeq[Int] with CustomParallelizable[Int, ParRange] with Serializable

    The `Range` class represents integer values in range [start;end) with non-zero step value `step`.

21. #### trait Seq[+A] extends Iterable[A] with Seq[A] with GenericTraversableTemplate[A, Seq] with SeqLike[A, Seq[A]] with Parallelizable[A, ParSeq[A]]

    A subtrait of `collection.Seq` which represents sequences that are guaranteed immutable.

22. #### trait Set[A] extends Iterable[A] with Set[A] with GenericSetTemplate[A, Set] with SetLike[A, Set[A]] with Parallelizable[A, ParSet[A]]

    A generic trait for immutable sets.

23. #### trait SetProxy[A] extends Set[A] with SetProxyLike[A, Set[A]]

    This is a simple wrapper class for `scala.collection.immutable.Set`.

24. #### trait SortedMap[A, +B] extends Map[A, B] with SortedMap[A, B] with MapLike[A, B, SortedMap[A, B]] with SortedMapLike[A, B, SortedMap[A, B]]

    A map whose keys are sorted.

25. #### trait SortedSet[A] extends Set[A] with SortedSet[A] with SortedSetLike[A, SortedSet[A]]

    A subtrait of `collection.SortedSet` which represents sorted sets which cannot be mutated.

26. #### class Stack[+A] extends AbstractSeq[A] with LinearSeq[A] with GenericTraversableTemplate[A, Stack] with LinearSeqOptimized[A, Stack[A]] with Serializable

    This class implements immutable stacks using a list-based data structure.

27. #### abstract class Stream[+A] extends AbstractSeq[A] with LinearSeq[A] with GenericTraversableTemplate[A, Stream] with LinearSeqOptimized[A, Stream[A]]

    The class `Stream` implements lazy lists where elements are only evaluated when they are needed.

28. #### final class StreamIterator[+A] extends AbstractIterator[A] with Iterator[A]

    A specialized, extra-lazy implementation of a stream iterator, so it can iterate as lazily as it traverses the tail.

29. #### trait StreamView[+A, +Coll] extends StreamViewLike[A, Coll, StreamView[A, Coll]]

30. #### trait StreamViewLike[+A, +Coll, +This <: StreamView[A, Coll] with StreamViewLike[A, Coll, This]] extends SeqView[A, Coll] with SeqViewLike[A, Coll, This]

31. #### trait StringLike[+Repr] extends IndexedSeqOptimized[Char, Repr] with Ordered[String]

    A trait describing stringlike collections.

32. #### final class StringOps extends StringLike[String]

    This class serves as a wrapper providing `String`s with all the operations found in indexed sequences.

33. #### trait Traversable[+A] extends Traversable[A] with GenericTraversableTemplate[A, Traversable] with TraversableLike[A, Traversable[A]] with Immutable

    A trait for traversable collections that are guaranteed immutable.

34. #### class TreeMap[A, +B] extends SortedMap[A, B] with SortedMapLike[A, B, TreeMap[A, B]] with MapLike[A, B, TreeMap[A, B]] with Serializable

    This class implements immutable maps using a tree.

35. #### class TreeSet[A] extends SortedSet[A] with SortedSetLike[A, TreeSet[A]] with Serializable

    This class implements immutable sets using a tree.

36. #### final class Vector[+A] extends AbstractSeq[A] with IndexedSeq[A] with GenericTraversableTemplate[A, Vector] with IndexedSeqLike[A, Vector[A]] with VectorPointer[A] with Serializable with CustomParallelizable[A, ParVector[A]]

    Vector is a general-purpose, immutable data structure.

37. #### final class VectorBuilder[A] extends Builder[A, Vector[A]] with VectorPointer[A]

38. #### class VectorIterator[+A] extends AbstractIterator[A] with Iterator[A] with VectorPointer[A]

39. #### class WrappedString extends AbstractSeq[Char] with IndexedSeq[Char] with StringLike[WrappedString]

    This class serves as a wrapper augmenting `String`s with all the operations found in indexed sequences.

40. #### trait RangeUtils[+Repr <: RangeUtils[Repr]] extends AnyRef

    It looks like once upon a time this was used by ParRange, but since December 2010 in r23721 it is not used by anything.

41. #### abstract class RedBlack[A] extends Serializable

    Old base class that was used by previous implementations of `TreeMaps` and `TreeSets`.

### Value Members

1. #### object BitSet extends BitSetFactory[BitSet] with Serializable

   This object provides a set of operations to create `immutable.BitSet` values.

2. #### object HashMap extends ImmutableMapFactory[HashMap] with Int with Serializable

   This object provides a set of operations needed to create `immutable.HashMap` values.

3. #### object HashSet extends ImmutableSetFactory[HashSet] with Serializable

   This object provides a set of operations needed to create `immutable.HashSet` values.

4. #### object IndexedSeq extends SeqFactory[IndexedSeq]

   This object provides a set of operations to create `IndexedSeq` values.

5. #### object IntMap extends AnyRef

   A companion object for integer maps.

6. #### object Iterable extends GenTraversableFactory[Iterable] with TraversableFactory[Iterable]

   This object provides a set of operations to create `immutable.Iterable` values.

7. #### object LinearSeq extends SeqFactory[LinearSeq]

   This object provides a set of operations to create `immutable.LinearSeq` values.

8. #### object List extends SeqFactory[List]

   This object provides a set of operations to create `List` values.

9. #### object ListMap extends ImmutableMapFactory[ListMap] with Serializable

   This object provides a set of operations needed to create `immutable.ListMap` values.

10. #### object ListSet extends ImmutableSetFactory[ListSet] with Serializable

    This object provides a set of operations needed to create `immutable.ListSet` values.

11. #### object LongMap extends AnyRef

    A companion object for long maps.

12. #### object Map extends ImmutableMapFactory[Map]

    This object provides a set of operations needed to create `immutable.Map` values.

13. #### object Nil extends List[Nothing] with Product with Serializable

    The empty list.

14. #### object NumericRange extends Serializable

    A companion object for numeric ranges.

15. #### object PagedSeq extends AnyRef

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

16. #### object Queue extends SeqFactory[Queue] with Serializable

    This object provides a set of operations to create `immutable.Queue` values.

17. #### object Range extends Serializable

    A companion object for the `Range` class.

18. #### object Seq extends SeqFactory[Seq]

    This object provides a set of operations to create `immutable.Seq` values.

19. #### object Set extends ImmutableSetFactory[Set]

    This object provides a set of operations needed to create `immutable.Set` values.

20. #### object SortedMap extends ImmutableSortedMapFactory[SortedMap]

    This object provides a set of operations needed to create sorted maps of type `immutable.SortedMap`.

21. #### object SortedSet extends ImmutableSortedSetFactory[SortedSet]

    This object provides a set of operations needed to create sorted sets of type `immutable.SortedSet`.

22. #### object Stack extends SeqFactory[Stack] with Serializable

    This object provides a set of operations to create `immutable.Stack` values.

23. #### object Stream extends SeqFactory[Stream]

    The object `Stream` provides helper functions to manipulate streams.

24. #### object StringLike extends AnyRef

    A companion object for the `StringLike` containing some constants.

25. #### object Traversable extends GenTraversableFactory[Traversable] with TraversableFactory[Traversable]

    This object provides a set of operations to create `immutable.Traversable` values.

26. #### object TreeMap extends ImmutableSortedMapFactory[TreeMap] with Serializable

    This object provides a set of operations needed to create sorted maps of type `immutable.TreeMap`.

27. #### object TreeSet extends ImmutableSortedSetFactory[TreeSet] with Serializable

    This object provides a set of operations needed to create sorted sets of type `immutable.TreeSet`.

28. #### object Vector extends SeqFactory[Vector] with Serializable

    Companion object to the Vector class

29. #### object WrappedString extends AnyRef

    A companion object for wrapped strings.