scala.collection

# immutable

#### package immutable

Source
  package.scala

Linear Supertypes
AnyRef, Any
Content Hierarchy Learn more about scaladoc diagrams
Ordering

1. Alphabetic
2. By inheritance

Inherited

1. immutable
2. AnyRef
3. Any

1. Hide All
2. Show all

Learn more about member selection
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 collection.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 collection.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[immutable.IntMapUtils.Int, T] with Map[immutable.IntMapUtils.Int, T] with MapLike[immutable.IntMapUtils.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 collection.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 collection.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[immutable.LongMapUtils.Long, T] with Map[immutable.LongMapUtils.Long, T] with MapLike[immutable.LongMapUtils.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 collection.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 collection.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 collection.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 collection.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 collection.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 collection.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 collection.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 AnyVal with StringLike[String]

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

33. #### trait Traversable[+A] extends collection.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 generic.BitOperations.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

   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

    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

    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

    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

    A companion object for wrapped strings.

### Inherited from AnyRef

### Inherited from Any

### Ungrouped