Scala 3
3.7.3-RC1-bin-20250717-fb66af2-NIGHTLY
LearnInstallPlaygroundFind A LibraryCommunityBlog
LearnInstallPlaygroundFind A LibraryCommunityBlog
DocsAPI
Generated with
Copyright (c) 2002-2025, LAMP/EPFL
Copyright (c) 2002-2025, LAMP/EPFL
Scala 3/scala/scala.collection/scala.collection.mutable

scala.collection.mutable

package scala.collection.mutable

Members list

Type members

Classlikes

abstract class AbstractBuffer[A] extends AbstractSeq[A], Buffer[A]

Explicit instantiation of the Buffer trait to reduce class file size in subclasses.

Explicit instantiation of the Buffer trait to reduce class file size in subclasses.

Attributes

Source
Buffer.scala
Supertypes
trait Buffer[A]
trait Shrinkable[A]
trait Growable[A]
trait Clearable
class AbstractSeq[A]
trait Seq[A]
trait SeqOps[A, Buffer, Buffer[A]]
trait Cloneable[Buffer[A]]
trait Cloneable
trait Iterable[A]
class AbstractSeq[A]
trait Seq[A]
trait Equals
trait SeqOps[A, Buffer, Buffer[A]]
trait PartialFunction[Int, A]
trait Int => A
class AbstractIterable[A]
trait Iterable[A]
trait IterableOps[A, Buffer, Buffer[A]]
trait IterableOnceOps[A, Buffer, Buffer[A]]
trait IterableOnce[A]
class Object
trait Matchable
class Any
Show all
Known subtypes
class ArrayBuffer[A]
class ArrayDeque[A]
class Queue[A]
class Stack[A]
class ListBuffer[A]
class UnrolledBuffer[T]
Show all
abstract class AbstractIterable[A] extends AbstractIterable[A], Iterable[A]

Explicit instantiation of the Iterable trait to reduce class file size in subclasses.

Explicit instantiation of the Iterable trait to reduce class file size in subclasses.

Attributes

Source
Iterable.scala
Supertypes
trait Iterable[A]
class AbstractIterable[A]
trait Iterable[A]
trait IterableOps[A, Iterable, Iterable[A]]
trait IterableOnce[A]
class Object
trait Matchable
class Any
Show all
Known subtypes
class PriorityQueue[A]
abstract class AbstractMap[K, V] extends AbstractMap[K, V], Map[K, V]

Explicit instantiation of the Map trait to reduce class file size in subclasses.

Explicit instantiation of the Map trait to reduce class file size in subclasses.

Attributes

Source
Map.scala
Supertypes
trait Map[K, V]
trait MapOps[K, V, Map, Map[K, V]]
trait Shrinkable[K]
trait Builder[(K, V), Map[K, V]]
trait Growable[(K, V)]
trait Clearable
trait Cloneable[Map[K, V]]
trait Cloneable
trait Iterable[(K, V)]
class AbstractMap[K, V]
trait Map[K, V]
trait Equals
trait MapOps[K, V, Map, Map[K, V]]
trait PartialFunction[K, V]
trait K => V
class AbstractIterable[(K, V)]
trait Iterable[(K, V)]
trait IterableOps[(K, V), Iterable, Map[K, V]]
trait IterableOnceOps[(K, V), Iterable, Map[K, V]]
trait IterableOnce[(K, V)]
class Object
trait Matchable
class Any
Show all
Known subtypes
class TrieMap[K, V]
class AnyRefMap[K, V]
class CollisionProofHashMap[K, V]
class HashMap[K, V]
class LinkedHashMap[K, V]
class ListMap[K, V]
class LongMap[V]
class WithDefault[K, V]
class WithDefault[K, V]
class OpenHashMap[Key, Value]
class TreeMap[K, V]
Show all
abstract class AbstractSeq[A] extends AbstractSeq[A], Seq[A]

Explicit instantiation of the Seq trait to reduce class file size in subclasses.

Explicit instantiation of the Seq trait to reduce class file size in subclasses.

Attributes

Source
Seq.scala
Supertypes
trait Seq[A]
trait SeqOps[A, Seq, Seq[A]]
trait Cloneable[Seq[A]]
trait Cloneable
trait Iterable[A]
class AbstractSeq[A]
trait Seq[A]
trait Equals
trait SeqOps[A, Seq, Seq[A]]
trait PartialFunction[Int, A]
trait Int => A
class AbstractIterable[A]
trait Iterable[A]
trait IterableOps[A, Seq, Seq[A]]
trait IterableOnceOps[A, Seq, Seq[A]]
trait IterableOnce[A]
class Object
trait Matchable
class Any
Show all
Known subtypes
class AbstractBuffer[A]
class ArrayBuffer[A]
class ArrayDeque[A]
class Queue[A]
class Stack[A]
class ListBuffer[A]
class UnrolledBuffer[T]
class ArraySeq[T]
class ofBoolean
class ofByte
class ofChar
class ofDouble
class ofFloat
class ofInt
class ofLong
class ofRef[T]
class ofShort
class ofUnit
Show all
abstract class AbstractSet[A] extends AbstractSet[A], Set[A]

Explicit instantiation of the Set trait to reduce class file size in subclasses.

Explicit instantiation of the Set trait to reduce class file size in subclasses.

Attributes

Source
Set.scala
Supertypes
trait Set[A]
trait SetOps[A, Set, Set[A]]
trait Shrinkable[A]
trait Builder[A, Set[A]]
trait Growable[A]
trait Clearable
trait Cloneable[Set[A]]
trait Cloneable
trait Iterable[A]
class AbstractSet[A]
trait Set[A]
trait Equals
trait SetOps[A, Set, Set[A]]
trait A => Boolean
class AbstractIterable[A]
trait Iterable[A]
trait IterableOps[A, Set, Set[A]]
trait IterableOnceOps[A, Set, Set[A]]
trait IterableOnce[A]
class Object
trait Matchable
class Any
Show all
Known subtypes
class BitSet
class HashSet[A]
class LinkedHashSet[A]
class TreeSet[A]
class ArrayBuffer[A] extends AbstractBuffer[A], IndexedBuffer[A], IndexedSeqOps[A, ArrayBuffer, ArrayBuffer[A]], StrictOptimizedSeqOps[A, ArrayBuffer, ArrayBuffer[A]], IterableFactoryDefaults[A, ArrayBuffer], DefaultSerializable

An implementation of the Buffer class using an array to represent the assembled sequence internally.

An implementation of the Buffer class using an array to represent the assembled sequence internally. Append, update and random access take constant time (amortized time). Prepends and removes are linear in the buffer size.

Type parameters

A

the type of this arraybuffer's elements.

Attributes

See also

"Scala's Collection Library overview" section on Array Buffers for more information.

Companion
object
Source
ArrayBuffer.scala
Supertypes
trait Serializable
trait IndexedBuffer[A]
trait IndexedSeq[A]
trait IndexedSeq[A]
class AbstractBuffer[A]
trait Buffer[A]
trait Shrinkable[A]
trait Growable[A]
trait Clearable
class AbstractSeq[A]
trait Seq[A]
trait Cloneable
trait Iterable[A]
class AbstractSeq[A]
trait Seq[A]
trait Equals
trait PartialFunction[Int, A]
trait Int => A
class AbstractIterable[A]
trait Iterable[A]
trait IterableOnce[A]
class Object
trait Matchable
class Any
Show all
object ArrayBuffer extends StrictOptimizedSeqFactory[ArrayBuffer]

Factory object for the ArrayBuffer class.

Factory object for the ArrayBuffer class.

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

Attributes

Companion
class
Source
ArrayBuffer.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Show all
Self type
final class ArrayBufferView[A] extends AbstractIndexedSeqView[A]

Attributes

Source
ArrayBuffer.scala
Supertypes
trait IndexedSeqView[A]
trait IndexedSeqOps[A, View, View[A]]
class AbstractSeqView[A]
trait SeqView[A]
trait SeqOps[A, View, View[A]]
class AbstractView[A]
trait View[A]
trait Serializable
class AbstractIterable[A]
trait Iterable[A]
trait IterableOps[A, View, View[A]]
trait IterableOnceOps[A, View, View[A]]
trait IterableOnce[A]
class Object
trait Matchable
class Any
Show all
sealed abstract class ArrayBuilder[T] extends ReusableBuilder[T, Array[T]], Serializable

A builder class for arrays.

A builder class for arrays.

Type parameters

T

the type of the elements for the builder.

Attributes

Companion
object
Source
ArrayBuilder.scala
Supertypes
trait Serializable
trait ReusableBuilder[T, Array[T]]
trait Builder[T, Array[T]]
trait Growable[T]
trait Clearable
class Object
trait Matchable
class Any
Show all
Known subtypes
class ofBoolean
class ofByte
class ofChar
class ofDouble
class ofFloat
class ofInt
class ofLong
class ofRef[T]
class ofShort
class ofUnit
Show all
object ArrayBuilder

A companion object for array builders.

A companion object for array builders.

Attributes

Companion
class
Source
ArrayBuilder.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Self type
class ArrayDeque[A] extends AbstractBuffer[A], IndexedBuffer[A], IndexedSeqOps[A, ArrayDeque, ArrayDeque[A]], StrictOptimizedSeqOps[A, ArrayDeque, ArrayDeque[A]], IterableFactoryDefaults[A, ArrayDeque], ArrayDequeOps[A, ArrayDeque, ArrayDeque[A]], Cloneable[ArrayDeque[A]], DefaultSerializable

An implementation of a double-ended queue that internally uses a resizable circular buffer.

An implementation of a double-ended queue that internally uses a resizable circular buffer.

Append, prepend, removeHead, removeLast and random-access (indexed-lookup and indexed-replacement) take amortized constant time. In general, removals and insertions at i-th index are O(min(i, n-i)) and thus insertions and removals from end/beginning are fast.

Type parameters

A

the type of this ArrayDeque's elements.

Attributes

Note

Subclasses must override the ofArray protected method to return a more specific type.

Companion
object
Source
ArrayDeque.scala
Supertypes
trait Serializable
trait IndexedBuffer[A]
trait IndexedSeq[A]
trait IndexedSeq[A]
class AbstractBuffer[A]
trait Buffer[A]
trait Shrinkable[A]
trait Growable[A]
trait Clearable
class AbstractSeq[A]
trait Seq[A]
trait SeqOps[A, ArrayDeque, ArrayDeque[A]]
trait Cloneable[ArrayDeque[A]]
trait Cloneable
trait Iterable[A]
class AbstractSeq[A]
trait Seq[A]
trait Equals
trait SeqOps[A, ArrayDeque, ArrayDeque[A]]
trait PartialFunction[Int, A]
trait Int => A
class AbstractIterable[A]
trait Iterable[A]
trait IterableOnce[A]
class Object
trait Matchable
class Any
Show all
Known subtypes
class Queue[A]
class Stack[A]
object ArrayDeque extends StrictOptimizedSeqFactory[ArrayDeque]

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

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

Attributes

Companion
class
Source
ArrayDeque.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Show all
Self type
ArrayDeque.type
trait ArrayDequeOps[A, +CC[_], +C <: AnyRef] extends StrictOptimizedSeqOps[A, CC, C]

Attributes

Source
ArrayDeque.scala
Supertypes
trait StrictOptimizedSeqOps[A, CC, C]
trait StrictOptimizedIterableOps[A, CC, C]
trait SeqOps[A, CC, C]
trait IterableOps[A, CC, C]
trait IterableOnceOps[A, CC, C]
trait IterableOnce[A]
class Object
trait Matchable
class Any
Show all
Known subtypes
class ArrayDeque[A]
class Queue[A]
class Stack[A]
sealed abstract class ArraySeq[T] extends AbstractSeq[T], IndexedSeq[T], IndexedSeqOps[T, ArraySeq, ArraySeq[T]], StrictOptimizedSeqOps[T, ArraySeq, ArraySeq[T]], Serializable

A collection representing Array[T].

A collection representing Array[T]. Unlike ArrayBuffer it is always backed by the same underlying Array, therefore it is not growable or shrinkable.

Type parameters

T

type of the elements in this wrapped array.

Attributes

Companion
object
Source
ArraySeq.scala
Supertypes
trait Serializable
trait IndexedSeq[T]
trait IndexedSeq[T]
class AbstractSeq[T]
trait Seq[T]
trait SeqOps[T, ArraySeq, ArraySeq[T]]
trait Cloneable[ArraySeq[T]]
trait Cloneable
trait Iterable[T]
class AbstractSeq[T]
trait Seq[T]
trait Equals
trait SeqOps[T, ArraySeq, ArraySeq[T]]
trait PartialFunction[Int, T]
trait Int => T
class AbstractIterable[T]
trait Iterable[T]
trait IterableOps[T, ArraySeq, ArraySeq[T]]
trait IterableOnce[T]
class Object
trait Matchable
class Any
Show all
Known subtypes
class ofBoolean
class ofByte
class ofChar
class ofDouble
class ofFloat
class ofInt
class ofLong
class ofRef[T]
class ofShort
class ofUnit
Show all
object ArraySeq extends StrictOptimizedClassTagSeqFactory[ArraySeq]

A companion object used to create instances of ArraySeq.

A companion object used to create instances of ArraySeq.

Attributes

Companion
class
Source
ArraySeq.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Show all
Self type
ArraySeq.type
class BitSet(var elems: Array[Long]) extends AbstractSet[Int], SortedSet[Int], SortedSetOps[Int, SortedSet, BitSet], StrictOptimizedIterableOps[Int, Set, BitSet], StrictOptimizedSortedSetOps[Int, SortedSet, BitSet], BitSet, BitSetOps[BitSet], Serializable

A class for mutable bitsets.

A class for mutable bitsets.

Bitsets are sets of non-negative integers which are represented as variable-size arrays of bits packed into 64-bit words. The lower bound of memory footprint of a bitset is determined by the largest number stored in it.

Attributes

See also

"Scala's Collection Library overview" section on Mutable Bitsets for more information.

Companion
object
Source
BitSet.scala
Supertypes
trait Serializable
trait BitSet
trait BitSetOps[BitSet]
trait SortedSet[Int]
trait SortedSet[Int]
trait SortedOps[Int, BitSet]
class AbstractSet[Int]
trait Set[Int]
trait SetOps[Int, Set, BitSet]
trait Shrinkable[Int]
trait Builder[Int, BitSet]
trait Growable[Int]
trait Clearable
trait Cloneable[BitSet]
trait Cloneable
trait Iterable[Int]
class AbstractSet[Int]
trait Set[Int]
trait Equals
trait SetOps[Int, Set, BitSet]
trait Int => Boolean
trait Iterable[Int]
trait IterableOnce[Int]
class Object
trait Matchable
class Any
Show all
object BitSet extends SpecificIterableFactory[Int, BitSet]

Attributes

Companion
class
Source
BitSet.scala
Supertypes
trait Serializable
trait Factory[Int, BitSet]
class Object
trait Matchable
class Any
Show all
Self type
BitSet.type
trait Buffer[A] extends Seq[A], SeqOps[A, Buffer, Buffer[A]], Growable[A], Shrinkable[A], IterableFactoryDefaults[A, Buffer]

A Buffer is a growable and shrinkable Seq.

A Buffer is a growable and shrinkable Seq.

Attributes

Companion
object
Source
Buffer.scala
Supertypes
trait Shrinkable[A]
trait Growable[A]
trait Clearable
trait Seq[A]
trait SeqOps[A, Buffer, Buffer[A]]
trait Cloneable[Buffer[A]]
trait Cloneable
trait Seq[A]
trait Equals
trait SeqOps[A, Buffer, Buffer[A]]
trait PartialFunction[Int, A]
trait Int => A
trait Iterable[A]
trait Iterable[A]
trait IterableOps[A, Buffer, Buffer[A]]
trait IterableOnceOps[A, Buffer, Buffer[A]]
trait IterableOnce[A]
class Object
trait Matchable
class Any
Show all
Known subtypes
class AbstractBuffer[A]
class ArrayBuffer[A]
class ArrayDeque[A]
class Queue[A]
class Stack[A]
class ListBuffer[A]
class UnrolledBuffer[T]
trait IndexedBuffer[A]
Show all
object Buffer extends Delegate[Buffer]

Attributes

Companion
trait
Source
Buffer.scala
Supertypes
class Delegate[Buffer]
trait Serializable
class Object
trait Matchable
class Any
Show all
Self type
Buffer.type
trait Builder[-A, +To] extends Growable[A]

Base trait for collection builders.

Base trait for collection builders.

After calling result() the behavior of a Builder (which is not also a scala.collection.mutable.ReusableBuilder) is undefined. No further methods should be called. It is common for mutable collections to be their own non-reusable Builder, in which case result() simply returns this.

Attributes

See also

scala.collection.mutable.ReusableBuilder for Builders which can be reused after calling result()

Source
Builder.scala
Supertypes
trait Growable[A]
trait Clearable
class Object
trait Matchable
class Any
Known subtypes
class Builder[K, V]
class GrowableBuilder[Elem, To]
trait MapOps[K, V, CC, C]
class TrieMap[K, V]
class AnyRefMap[K, V]
class CollisionProofHashMap[K, V]
class HashMap[K, V]
class LinkedHashMap[K, V]
class ListMap[K, V]
class LongMap[V]
trait Map[K, V]
trait Map[K, V]
class AbstractMap[K, V]
class WithDefault[K, V]
class WithDefault[K, V]
class OpenHashMap[Key, Value]
class TreeMap[K, V]
trait MultiMap[K, V]
trait SeqMap[K, V]
trait SortedMap[K, V]
trait SortedMapOps[K, V, CC, C]
class PriorityQueue[A]
trait ReusableBuilder[Elem, To]
class VectorBuilder[A]
class AnyRefMapBuilder[K, V]
class ArrayBuilder[T]
class ofBoolean
class ofByte
class ofChar
class ofDouble
class ofFloat
class ofInt
class ofLong
class ofRef[T]
class ofShort
class ofUnit
class ImmutableBuilder[A, C]
class ListBuffer[A]
class LongMapBuilder[V]
trait SetOps[A, CC, C]
class HashSet[A]
class LinkedHashSet[A]
trait Set[A]
class AbstractSet[A]
class BitSet
class TreeSet[A]
trait SortedSet[A]
trait SortedSetOps[A, CC, C]
class UnrolledBuffer[T]
class Accumulator[A, CC, C]
class AnyAccumulator[A]
Show all
Self type
Builder[A, To]
trait Clearable

This trait forms part of collections that can be cleared with a clear() call.

This trait forms part of collections that can be cleared with a clear() call.

Attributes

Source
Growable.scala
Supertypes
class Object
trait Matchable
class Any
Known subtypes
trait Growable[A]
trait Buffer[A]
class AbstractBuffer[A]
class ArrayBuffer[A]
class ArrayDeque[A]
class Queue[A]
class Stack[A]
class ListBuffer[A]
class UnrolledBuffer[T]
trait IndexedBuffer[A]
trait Builder[A, To]
class Builder[K, V]
class GrowableBuilder[Elem, To]
trait MapOps[K, V, CC, C]
class TrieMap[K, V]
class AnyRefMap[K, V]
class CollisionProofHashMap[K, V]
class HashMap[K, V]
class LinkedHashMap[K, V]
class ListMap[K, V]
class LongMap[V]
trait Map[K, V]
trait Map[K, V]
class AbstractMap[K, V]
class WithDefault[K, V]
class WithDefault[K, V]
class OpenHashMap[Key, Value]
class TreeMap[K, V]
trait MultiMap[K, V]
trait SeqMap[K, V]
trait SortedMap[K, V]
trait SortedMapOps[K, V, CC, C]
class PriorityQueue[A]
trait ReusableBuilder[Elem, To]
class VectorBuilder[A]
class AnyRefMapBuilder[K, V]
class ArrayBuilder[T]
class ofBoolean
class ofByte
class ofChar
class ofDouble
class ofFloat
class ofInt
class ofLong
class ofRef[T]
class ofShort
class ofUnit
class ImmutableBuilder[A, C]
class LongMapBuilder[V]
trait SetOps[A, CC, C]
class HashSet[A]
class LinkedHashSet[A]
trait Set[A]
class AbstractSet[A]
class BitSet
class TreeSet[A]
trait SortedSet[A]
trait SortedSetOps[A, CC, C]
class Accumulator[A, CC, C]
class AnyAccumulator[A]
Show all
trait Cloneable[+C <: AnyRef] extends Cloneable

A trait for cloneable collections.

A trait for cloneable collections.

Type parameters

C

Type of the collection, covariant and with reference types as upperbound.

Attributes

Source
Cloneable.scala
Supertypes
trait Cloneable
class Object
trait Matchable
class Any
Known subtypes
class ArrayDeque[A]
class Queue[A]
class Stack[A]
trait MapOps[K, V, CC, C]
class TrieMap[K, V]
class AnyRefMap[K, V]
class CollisionProofHashMap[K, V]
class HashMap[K, V]
class LinkedHashMap[K, V]
class ListMap[K, V]
class LongMap[V]
trait Map[K, V]
trait Map[K, V]
class AbstractMap[K, V]
class WithDefault[K, V]
class WithDefault[K, V]
class OpenHashMap[Key, Value]
class TreeMap[K, V]
trait MultiMap[K, V]
trait SeqMap[K, V]
trait SortedMap[K, V]
trait SortedMapOps[K, V, CC, C]
class PriorityQueue[A]
trait SeqOps[A, CC, C]
trait Buffer[A]
class AbstractBuffer[A]
class ArrayBuffer[A]
class ListBuffer[A]
class UnrolledBuffer[T]
trait IndexedBuffer[A]
trait IndexedSeqOps[A, CC, C]
class ArraySeq[T]
class ofBoolean
class ofByte
class ofChar
class ofDouble
class ofFloat
class ofInt
class ofLong
class ofRef[T]
class ofShort
class ofUnit
trait IndexedSeq[T]
trait Seq[A]
class AbstractSeq[A]
class Accumulator[A, CC, C]
class AnyAccumulator[A]
trait SetOps[A, CC, C]
class HashSet[A]
class LinkedHashSet[A]
trait Set[A]
class AbstractSet[A]
class BitSet
class TreeSet[A]
trait SortedSet[A]
trait SortedSetOps[A, CC, C]
Show all
final class CollisionProofHashMap[K, V](initialCapacity: Int, loadFactor: Double)(implicit ordering: Ordering[K]) extends AbstractMap[K, V], MapOps[K, V, Map, CollisionProofHashMap[K, V]], StrictOptimizedIterableOps[(K, V), Iterable, CollisionProofHashMap[K, V]], StrictOptimizedMapOps[K, V, Map, CollisionProofHashMap[K, V]]

This class implements mutable maps using a hashtable with red-black trees in the buckets for good worst-case performance on hash collisions.

This class implements mutable maps using a hashtable with red-black trees in the buckets for good worst-case performance on hash collisions. An Ordering is required for the element type. Equality as determined by the Ordering has to be consistent with equals and hashCode. Universal equality of numeric types is not supported (similar to AnyRefMap).

Attributes

See also

"Scala's Collection Library overview" section on Hash Tables for more information.

Companion
object
Source
CollisionProofHashMap.scala
Supertypes
class AbstractMap[K, V]
trait Map[K, V]
trait MapOps[K, V, Map, CollisionProofHashMap[K, V]]
trait Shrinkable[K]
trait Builder[(K, V), CollisionProofHashMap[K, V]]
trait Growable[(K, V)]
trait Clearable
trait Cloneable
trait Iterable[(K, V)]
class AbstractMap[K, V]
trait Map[K, V]
trait Equals
trait MapOps[K, V, Map, CollisionProofHashMap[K, V]]
trait PartialFunction[K, V]
trait K => V
class AbstractIterable[(K, V)]
trait Iterable[(K, V)]
trait IterableOnce[(K, V)]
class Object
trait Matchable
class Any
Show all
object CollisionProofHashMap extends SortedMapFactory[CollisionProofHashMap]

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

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

Attributes

Companion
class
Source
CollisionProofHashMap.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Self type
trait Growable[-A] extends Clearable

This trait forms part of collections that can be augmented using a += operator and that can be cleared of all elements using a clear method.

This trait forms part of collections that can be augmented using a += operator and that can be cleared of all elements using a clear method.

Attributes

Companion
object
Source
Growable.scala
Supertypes
trait Clearable
class Object
trait Matchable
class Any
Known subtypes
trait Buffer[A]
class AbstractBuffer[A]
class ArrayBuffer[A]
class ArrayDeque[A]
class Queue[A]
class Stack[A]
class ListBuffer[A]
class UnrolledBuffer[T]
trait IndexedBuffer[A]
trait Builder[A, To]
class Builder[K, V]
class GrowableBuilder[Elem, To]
trait MapOps[K, V, CC, C]
class TrieMap[K, V]
class AnyRefMap[K, V]
class CollisionProofHashMap[K, V]
class HashMap[K, V]
class LinkedHashMap[K, V]
class ListMap[K, V]
class LongMap[V]
trait Map[K, V]
trait Map[K, V]
class AbstractMap[K, V]
class WithDefault[K, V]
class WithDefault[K, V]
class OpenHashMap[Key, Value]
class TreeMap[K, V]
trait MultiMap[K, V]
trait SeqMap[K, V]
trait SortedMap[K, V]
trait SortedMapOps[K, V, CC, C]
class PriorityQueue[A]
trait ReusableBuilder[Elem, To]
class VectorBuilder[A]
class AnyRefMapBuilder[K, V]
class ArrayBuilder[T]
class ofBoolean
class ofByte
class ofChar
class ofDouble
class ofFloat
class ofInt
class ofLong
class ofRef[T]
class ofShort
class ofUnit
class ImmutableBuilder[A, C]
class LongMapBuilder[V]
trait SetOps[A, CC, C]
class HashSet[A]
class LinkedHashSet[A]
trait Set[A]
class AbstractSet[A]
class BitSet
class TreeSet[A]
trait SortedSet[A]
trait SortedSetOps[A, CC, C]
class Accumulator[A, CC, C]
class AnyAccumulator[A]
Show all
object Growable

Attributes

Companion
trait
Source
Growable.scala
Supertypes
class Object
trait Matchable
class Any
Self type
Growable.type
class GrowableBuilder[Elem, To <: Growable[Elem]](val elems: To) extends Builder[Elem, To]

The canonical builder for collections that are growable, i.e.

The canonical builder for collections that are growable, i.e. that support an efficient += method which adds an element to the collection.

GrowableBuilders can produce only a single instance of the collection they are growing.

Attributes

Source
GrowableBuilder.scala
Supertypes
trait Builder[Elem, To]
trait Growable[Elem]
trait Clearable
class Object
trait Matchable
class Any
Show all
class HashMap[K, V](initialCapacity: Int, loadFactor: Double) extends AbstractMap[K, V], MapOps[K, V, HashMap, HashMap[K, V]], StrictOptimizedIterableOps[(K, V), Iterable, HashMap[K, V]], StrictOptimizedMapOps[K, V, HashMap, HashMap[K, V]], MapFactoryDefaults[K, V, HashMap, Iterable], Serializable

This class implements mutable maps using a hashtable.

This class implements mutable maps using a hashtable.

Type parameters

K

the type of the keys contained in this hash map.

V

the type of the values assigned to keys in this hash map.

Attributes

See also

"Scala's Collection Library overview" section on Hash Tables for more information.

Companion
object
Source
HashMap.scala
Supertypes
trait Serializable
trait StrictOptimizedMapOps[K, V, HashMap, HashMap[K, V]]
class AbstractMap[K, V]
trait Map[K, V]
trait MapOps[K, V, HashMap, HashMap[K, V]]
trait Shrinkable[K]
trait Builder[(K, V), HashMap[K, V]]
trait Growable[(K, V)]
trait Clearable
trait Cloneable[HashMap[K, V]]
trait Cloneable
trait Iterable[(K, V)]
class AbstractMap[K, V]
trait Map[K, V]
trait Equals
trait MapOps[K, V, HashMap, HashMap[K, V]]
trait PartialFunction[K, V]
trait K => V
class AbstractIterable[(K, V)]
trait Iterable[(K, V)]
trait IterableOps[(K, V), Iterable, HashMap[K, V]]
trait IterableOnceOps[(K, V), Iterable, HashMap[K, V]]
trait IterableOnce[(K, V)]
class Object
trait Matchable
class Any
Show all
object HashMap extends MapFactory[HashMap]

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

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

Attributes

Companion
class
Source
HashMap.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Self type
HashMap.type
final class HashSet[A](initialCapacity: Int, loadFactor: Double) extends AbstractSet[A], SetOps[A, HashSet, HashSet[A]], StrictOptimizedIterableOps[A, HashSet, HashSet[A]], IterableFactoryDefaults[A, HashSet], Serializable

This class implements mutable sets using a hashtable.

This class implements mutable sets using a hashtable.

Attributes

See also

"Scala's Collection Library overview" section on Hash Tables for more information.

Companion
object
Source
HashSet.scala
Supertypes
trait Serializable
class AbstractSet[A]
trait Set[A]
trait SetOps[A, HashSet, HashSet[A]]
trait Shrinkable[A]
trait Builder[A, HashSet[A]]
trait Growable[A]
trait Clearable
trait Cloneable[HashSet[A]]
trait Cloneable
trait Iterable[A]
class AbstractSet[A]
trait Set[A]
trait Equals
trait SetOps[A, HashSet, HashSet[A]]
trait A => Boolean
class AbstractIterable[A]
trait Iterable[A]
trait IterableOps[A, HashSet, HashSet[A]]
trait IterableOnce[A]
class Object
trait Matchable
class Any
Show all
object HashSet extends IterableFactory[HashSet]

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

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

Attributes

Companion
class
Source
HashSet.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Self type
HashSet.type
abstract class ImmutableBuilder[-A, C <: IterableOnce[_]](empty: C) extends ReusableBuilder[A, C]

Reusable builder for immutable collections

Reusable builder for immutable collections

Attributes

Source
ImmutableBuilder.scala
Supertypes
trait ReusableBuilder[A, C]
trait Builder[A, C]
trait Growable[A]
trait Clearable
class Object
trait Matchable
class Any
Show all
trait IndexedBuffer[A] extends IndexedSeq[A], IndexedSeqOps[A, IndexedBuffer, IndexedBuffer[A]], Buffer[A], IterableFactoryDefaults[A, IndexedBuffer]

Attributes

Companion
object
Source
Buffer.scala
Supertypes
trait Buffer[A]
trait Shrinkable[A]
trait Growable[A]
trait Clearable
trait IndexedSeq[A]
trait IndexedSeq[A]
trait Seq[A]
trait Cloneable
trait Seq[A]
trait Equals
trait PartialFunction[Int, A]
trait Int => A
trait Iterable[A]
trait Iterable[A]
trait IterableOnce[A]
class Object
trait Matchable
class Any
Show all
Known subtypes
class ArrayBuffer[A]
class ArrayDeque[A]
class Queue[A]
class Stack[A]
object IndexedBuffer extends Delegate[IndexedBuffer]

Attributes

Companion
trait
Source
Buffer.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Show all
Self type
trait IndexedSeq[T] extends Seq[T], IndexedSeq[T], IndexedSeqOps[T, IndexedSeq, IndexedSeq[T]], IterableFactoryDefaults[T, IndexedSeq]

Attributes

Companion
object
Source
IndexedSeq.scala
Supertypes
trait IndexedSeq[T]
trait Seq[T]
trait SeqOps[T, IndexedSeq, IndexedSeq[T]]
trait Cloneable[IndexedSeq[T]]
trait Cloneable
trait Seq[T]
trait Equals
trait SeqOps[T, IndexedSeq, IndexedSeq[T]]
trait PartialFunction[Int, T]
trait Int => T
trait Iterable[T]
trait Iterable[T]
trait IterableOnce[T]
class Object
trait Matchable
class Any
Show all
Known subtypes
class ArraySeq[T]
class ofBoolean
class ofByte
class ofChar
class ofDouble
class ofFloat
class ofInt
class ofLong
class ofRef[T]
class ofShort
class ofUnit
trait IndexedBuffer[A]
class ArrayBuffer[A]
class ArrayDeque[A]
class Queue[A]
class Stack[A]
Show all
object IndexedSeq extends Delegate[IndexedSeq]

Attributes

Companion
trait
Source
IndexedSeq.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Show all
Self type
IndexedSeq.type
trait IndexedSeqOps[A, +CC[_], +C <: AnyRef] extends IndexedSeqOps[A, CC, C], SeqOps[A, CC, C]

Attributes

Source
IndexedSeq.scala
Supertypes
trait SeqOps[A, CC, C]
trait Cloneable[C]
trait Cloneable
trait IndexedSeqOps[A, CC, C]
trait SeqOps[A, CC, C]
trait IterableOps[A, CC, C]
trait IterableOnceOps[A, CC, C]
trait IterableOnce[A]
class Object
trait Matchable
class Any
Show all
Known subtypes
class ArrayBuffer[A]
class ArrayDeque[A]
class Queue[A]
class Stack[A]
class ArraySeq[T]
class ofBoolean
class ofByte
class ofChar
class ofDouble
class ofFloat
class ofInt
class ofLong
class ofRef[T]
class ofShort
class ofUnit
trait IndexedBuffer[A]
trait IndexedSeq[T]
Show all
trait Iterable[A] extends Iterable[A], IterableOps[A, Iterable, Iterable[A]], IterableFactoryDefaults[A, Iterable]

Attributes

Companion
object
Source
Iterable.scala
Supertypes
trait Iterable[A]
trait IterableOps[A, Iterable, Iterable[A]]
trait IterableOnce[A]
class Object
trait Matchable
class Any
Show all
Known subtypes
class AbstractIterable[A]
class PriorityQueue[A]
trait Map[K, V]
trait Map[K, V]
class TrieMap[K, V]
class AbstractMap[K, V]
class AnyRefMap[K, V]
class CollisionProofHashMap[K, V]
class HashMap[K, V]
class LinkedHashMap[K, V]
class ListMap[K, V]
class LongMap[V]
class WithDefault[K, V]
class WithDefault[K, V]
class OpenHashMap[Key, Value]
class TreeMap[K, V]
trait MultiMap[K, V]
trait SeqMap[K, V]
trait SortedMap[K, V]
trait Seq[A]
class AbstractSeq[A]
class AbstractBuffer[A]
class ArrayBuffer[A]
class ArrayDeque[A]
class Queue[A]
class Stack[A]
class ListBuffer[A]
class UnrolledBuffer[T]
class ArraySeq[T]
class ofBoolean
class ofByte
class ofChar
class ofDouble
class ofFloat
class ofInt
class ofLong
class ofRef[T]
class ofShort
class ofUnit
trait Buffer[A]
trait IndexedBuffer[A]
trait IndexedSeq[T]
class Accumulator[A, CC, C]
class AnyAccumulator[A]
trait Set[A]
class AbstractSet[A]
class BitSet
class HashSet[A]
class LinkedHashSet[A]
class TreeSet[A]
trait SortedSet[A]
Show all
object Iterable extends Delegate[Iterable]

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

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

Attributes

Companion
trait
Source
Iterable.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Show all
Self type
Iterable.type
class LinkedHashMap[K, V] extends AbstractMap[K, V], SeqMap[K, V], MapOps[K, V, LinkedHashMap, LinkedHashMap[K, V]], StrictOptimizedIterableOps[(K, V), Iterable, LinkedHashMap[K, V]], StrictOptimizedMapOps[K, V, LinkedHashMap, LinkedHashMap[K, V]], MapFactoryDefaults[K, V, LinkedHashMap, Iterable], DefaultSerializable

This class implements mutable maps using a hashtable.

This class implements mutable maps using a hashtable. The iterator and all traversal methods of this class visit elements in the order they were inserted.

Type parameters

K

the type of the keys contained in this hash map.

V

the type of the values assigned to keys in this hash map.

Attributes

Companion
object
Source
LinkedHashMap.scala
Supertypes
trait Serializable
trait SeqMap[K, V]
trait SeqMap[K, V]
class AbstractMap[K, V]
trait Map[K, V]
trait MapOps[K, V, LinkedHashMap, LinkedHashMap[K, V]]
trait Shrinkable[K]
trait Builder[(K, V), LinkedHashMap[K, V]]
trait Growable[(K, V)]
trait Clearable
trait Cloneable[LinkedHashMap[K, V]]
trait Cloneable
trait Iterable[(K, V)]
class AbstractMap[K, V]
trait Map[K, V]
trait Equals
trait MapOps[K, V, LinkedHashMap, LinkedHashMap[K, V]]
trait PartialFunction[K, V]
trait K => V
class AbstractIterable[(K, V)]
trait Iterable[(K, V)]
trait IterableOps[(K, V), Iterable, LinkedHashMap[K, V]]
trait IterableOnceOps[(K, V), Iterable, LinkedHashMap[K, V]]
trait IterableOnce[(K, V)]
class Object
trait Matchable
class Any
Show all
object LinkedHashMap extends MapFactory[LinkedHashMap]

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

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

Attributes

Companion
class
Source
LinkedHashMap.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Self type
class LinkedHashSet[A] extends AbstractSet[A], SetOps[A, LinkedHashSet, LinkedHashSet[A]], StrictOptimizedIterableOps[A, LinkedHashSet, LinkedHashSet[A]], IterableFactoryDefaults[A, LinkedHashSet], DefaultSerializable

This class implements mutable sets using a hashtable.

This class implements mutable sets using a hashtable. The iterator and all traversal methods of this class visit elements in the order they were inserted.

Type parameters

A

the type of the elements contained in this set.

Attributes

Companion
object
Source
LinkedHashSet.scala
Supertypes
trait Serializable
class AbstractSet[A]
trait Set[A]
trait Shrinkable[A]
trait Builder[A, LinkedHashSet[A]]
trait Growable[A]
trait Clearable
trait Cloneable
trait Iterable[A]
class AbstractSet[A]
trait Set[A]
trait Equals
trait A => Boolean
class AbstractIterable[A]
trait Iterable[A]
trait IterableOnce[A]
class Object
trait Matchable
class Any
Show all
object LinkedHashSet extends IterableFactory[LinkedHashSet]

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

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

Attributes

Companion
class
Source
LinkedHashSet.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Self type
class ListBuffer[A] extends AbstractBuffer[A], SeqOps[A, ListBuffer, ListBuffer[A]], StrictOptimizedSeqOps[A, ListBuffer, ListBuffer[A]], ReusableBuilder[A, List[A]], IterableFactoryDefaults[A, ListBuffer], DefaultSerializable

A Buffer implementation backed by a list.

A Buffer implementation backed by a list. It provides constant time prepend and append. Most other operations are linear.

Type parameters

A

the type of this list buffer's elements.

Attributes

See also

"Scala's Collection Library overview" section on List Buffers for more information.

Companion
object
Source
ListBuffer.scala
Supertypes
trait Serializable
trait ReusableBuilder[A, List[A]]
trait Builder[A, List[A]]
class AbstractBuffer[A]
trait Buffer[A]
trait Shrinkable[A]
trait Growable[A]
trait Clearable
class AbstractSeq[A]
trait Seq[A]
trait SeqOps[A, ListBuffer, ListBuffer[A]]
trait Cloneable[ListBuffer[A]]
trait Cloneable
trait Iterable[A]
class AbstractSeq[A]
trait Seq[A]
trait Equals
trait SeqOps[A, ListBuffer, ListBuffer[A]]
trait PartialFunction[Int, A]
trait Int => A
class AbstractIterable[A]
trait Iterable[A]
trait IterableOnce[A]
class Object
trait Matchable
class Any
Show all
object ListBuffer extends StrictOptimizedSeqFactory[ListBuffer]

Attributes

Companion
class
Source
ListBuffer.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Show all
Self type
ListBuffer.type
final class LongMap[V] extends AbstractMap[Long, V], MapOps[Long, V, Map, LongMap[V]], StrictOptimizedIterableOps[(Long, V), Iterable, LongMap[V]], Serializable

This class implements mutable maps with Long keys based on a hash table with open addressing.

This class implements mutable maps with Long keys based on a hash table with open addressing.

Basic map operations on single entries, including contains and get, are typically substantially faster with LongMap than HashMap. Methods that act on the whole map, including foreach and map are not in general expected to be faster than with a generic map, save for those that take particular advantage of the internal structure of the map: foreachKey, foreachValue, mapValuesNow, and transformValues.

Maps with open addressing may become less efficient at lookup after repeated addition/removal of elements. Although LongMap makes a decent attempt to remain efficient regardless, calling repack on a map that will no longer have elements removed but will be used heavily may save both time and storage space.

This map is not intended to contain more than 229 entries (approximately 500 million). The maximum capacity is 230, but performance will degrade rapidly as 2^30 is approached.

Attributes

Companion
object
Source
LongMap.scala
Supertypes
trait Serializable
class AbstractMap[Long, V]
trait Map[Long, V]
trait MapOps[Long, V, Map, LongMap[V]]
trait Shrinkable[Long]
trait Builder[(Long, V), LongMap[V]]
trait Growable[(Long, V)]
trait Clearable
trait Cloneable[LongMap[V]]
trait Cloneable
trait Iterable[(Long, V)]
class AbstractMap[Long, V]
trait Map[Long, V]
trait Equals
trait MapOps[Long, V, Map, LongMap[V]]
trait PartialFunction[Long, V]
trait Long => V
class AbstractIterable[(Long, V)]
trait Iterable[(Long, V)]
trait IterableOps[(Long, V), Iterable, LongMap[V]]
trait IterableOnce[(Long, V)]
class Object
trait Matchable
class Any
Show all
object LongMap

Attributes

Companion
class
Source
LongMap.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Self type
LongMap.type
trait Map[K, V] extends Iterable[(K, V)], Map[K, V], MapOps[K, V, Map, Map[K, V]], Growable[(K, V)], Shrinkable[K], MapFactoryDefaults[K, V, Map, Iterable]

Base type of mutable Maps

Base type of mutable Maps

Attributes

Companion
object
Source
Map.scala
Supertypes
trait MapOps[K, V, Map, Map[K, V]]
trait Shrinkable[K]
trait Builder[(K, V), Map[K, V]]
trait Growable[(K, V)]
trait Clearable
trait Cloneable[Map[K, V]]
trait Cloneable
trait Map[K, V]
trait Equals
trait MapOps[K, V, Map, Map[K, V]]
trait PartialFunction[K, V]
trait K => V
trait Iterable[(K, V)]
trait Iterable[(K, V)]
trait IterableOps[(K, V), Iterable, Map[K, V]]
trait IterableOnceOps[(K, V), Iterable, Map[K, V]]
trait IterableOnce[(K, V)]
class Object
trait Matchable
class Any
Show all
Known subtypes
trait Map[K, V]
class TrieMap[K, V]
class AbstractMap[K, V]
class AnyRefMap[K, V]
class CollisionProofHashMap[K, V]
class HashMap[K, V]
class LinkedHashMap[K, V]
class ListMap[K, V]
class LongMap[V]
class WithDefault[K, V]
class WithDefault[K, V]
class OpenHashMap[Key, Value]
class TreeMap[K, V]
trait MultiMap[K, V]
trait SeqMap[K, V]
trait SortedMap[K, V]
Show all
object Map extends Delegate[Map]

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

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

Attributes

Companion
trait
Source
Map.scala
Supertypes
class Delegate[Map]
trait MapFactory[Map]
trait Serializable
class Object
trait Matchable
class Any
Show all
Self type
Map.type
trait MapOps[K, V, +CC <: ([X, Y] =>> MapOps[X, Y, CC, _]), +C <: MapOps[K, V, CC, C]] extends IterableOps[(K, V), Iterable, C], MapOps[K, V, CC, C], Cloneable[C], Builder[(K, V), C], Growable[(K, V)], Shrinkable[K]

Attributes

Source
Map.scala
Supertypes
trait Shrinkable[K]
trait Builder[(K, V), C]
trait Growable[(K, V)]
trait Clearable
trait Cloneable[C]
trait Cloneable
trait MapOps[K, V, CC, C]
trait PartialFunction[K, V]
trait K => V
trait IterableOps[(K, V), Iterable, C]
trait IterableOnceOps[(K, V), Iterable, C]
trait IterableOnce[(K, V)]
class Object
trait Matchable
class Any
Show all
Known subtypes
class TrieMap[K, V]
class AnyRefMap[K, V]
class CollisionProofHashMap[K, V]
class HashMap[K, V]
class LinkedHashMap[K, V]
class ListMap[K, V]
class LongMap[V]
trait Map[K, V]
trait Map[K, V]
class AbstractMap[K, V]
class WithDefault[K, V]
class WithDefault[K, V]
class OpenHashMap[Key, Value]
class TreeMap[K, V]
trait MultiMap[K, V]
trait SeqMap[K, V]
trait SortedMap[K, V]
trait SortedMapOps[K, V, CC, C]
Show all
sealed class PriorityQueue[A](implicit val ord: Ordering[A]) extends AbstractIterable[A], Iterable[A], IterableOps[A, Iterable, PriorityQueue[A]], StrictOptimizedIterableOps[A, Iterable, PriorityQueue[A]], Builder[A, PriorityQueue[A]], Cloneable[PriorityQueue[A]], Growable[A], Serializable

A heap-based priority queue.

A heap-based priority queue.

To prioritize elements of type A there must be an implicit Ordering[A] available at creation. Elements are retrieved in priority order by using dequeue or dequeueAll.

If multiple elements have the same priority as determined by the ordering for this PriorityQueue, no guarantees are made regarding the order in which those elements are returned by dequeue or dequeueAll. In particular, that means this class does not guarantee first-in-first-out behavior, as may be incorrectly inferred from the fact that this data structure is called a "queue".

Only the dequeue and dequeueAll methods will return elements in priority order (while removing elements from the heap). Standard collection methods such as drop, iterator, toList and toString use an arbitrary iteration order: they will traverse the heap or remove elements in whichever order seems most convenient.

Therefore, printing a PriorityQueue will not show elements in priority order, though the highest-priority element will be printed first. To print the elements in order, it's necessary to dequeue them. To do this non-destructively, duplicate the PriorityQueue first; the clone method is a suitable way to obtain a disposable copy.

Client keys are assumed to be immutable. Mutating keys may violate the invariant of the underlying heap-ordered tree. Note that clone does not rebuild the underlying tree.

scala> val pq = collection.mutable.PriorityQueue(1, 2, 5, 3, 7)
val pq: scala.collection.mutable.PriorityQueue[Int] = PriorityQueue(7, 3, 5, 1, 2)

scala> pq.toList              // also not in order
val res0: List[Int] = List(7, 3, 5, 1, 2)

scala> pq.clone.dequeueAll
val res1: Seq[Int] = ArraySeq(7, 5, 3, 2, 1)

Type parameters

A

type of the elements in this priority queue.

Value parameters

ord

implicit ordering used to compare the elements of type A.

Attributes

Companion
object
Source
PriorityQueue.scala
Supertypes
trait Serializable
trait Cloneable
trait Builder[A, PriorityQueue[A]]
trait Growable[A]
trait Clearable
class AbstractIterable[A]
trait Iterable[A]
class AbstractIterable[A]
trait Iterable[A]
trait IterableOnce[A]
class Object
trait Matchable
class Any
Show all
object PriorityQueue extends SortedIterableFactory[PriorityQueue]

Attributes

Companion
class
Source
PriorityQueue.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Show all
Self type
class Queue[A] extends ArrayDeque[A], IndexedSeqOps[A, Queue, Queue[A]], StrictOptimizedSeqOps[A, Queue, Queue[A]], IterableFactoryDefaults[A, Queue], ArrayDequeOps[A, Queue, Queue[A]], Cloneable[Queue[A]], DefaultSerializable

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

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

Attributes

Companion
object
Source
Queue.scala
Supertypes
class ArrayDeque[A]
trait Serializable
trait ArrayDequeOps[A, Queue, Queue[A]]
trait IndexedBuffer[A]
trait IndexedSeq[A]
trait IndexedSeqOps[A, Queue, Queue[A]]
trait IndexedSeq[A]
trait IndexedSeqOps[A, Queue, Queue[A]]
class AbstractBuffer[A]
trait Buffer[A]
trait Shrinkable[A]
trait Growable[A]
trait Clearable
class AbstractSeq[A]
trait Seq[A]
trait SeqOps[A, Queue, Queue[A]]
trait Cloneable[Queue[A]]
trait Cloneable
trait Iterable[A]
class AbstractSeq[A]
trait Seq[A]
trait Equals
trait SeqOps[A, Queue, Queue[A]]
trait PartialFunction[Int, A]
trait Int => A
class AbstractIterable[A]
trait Iterable[A]
trait IterableOps[A, Queue, Queue[A]]
trait IterableOnceOps[A, Queue, Queue[A]]
trait IterableOnce[A]
class Object
trait Matchable
class Any
Show all
object Queue extends StrictOptimizedSeqFactory[Queue]

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

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

Attributes

Companion
class
Source
Queue.scala
Supertypes
trait SeqFactory[Queue]
trait Serializable
class Object
trait Matchable
class Any
Show all
Self type
Queue.type
trait ReusableBuilder[-Elem, +To] extends Builder[Elem, To]

ReusableBuilder is a marker trait that indicates that a Builder can be reused to build more than one instance of a collection.

ReusableBuilder is a marker trait that indicates that a Builder can be reused to build more than one instance of a collection. In particular, calling result() followed by clear() will produce a collection and reset the builder to begin building a new collection of the same type.

In general no method other than clear() may be called after result(). It is up to subclasses to implement and to document other allowed sequences of operations (e.g. calling other methods after result() in order to obtain different snapshots of a collection under construction).

Type parameters

Elem

the type of elements that get added to the builder.

To

the type of collection that it produced.

Attributes

Source
ReusableBuilder.scala
Supertypes
trait Builder[Elem, To]
trait Growable[Elem]
trait Clearable
class Object
trait Matchable
class Any
Show all
Known subtypes
class VectorBuilder[A]
class AnyRefMapBuilder[K, V]
class ArrayBuilder[T]
class ofBoolean
class ofByte
class ofChar
class ofDouble
class ofFloat
class ofInt
class ofLong
class ofRef[T]
class ofShort
class ofUnit
class ImmutableBuilder[A, C]
class ListBuffer[A]
class LongMapBuilder[V]
Show all
trait Seq[A] extends Iterable[A], Seq[A], SeqOps[A, Seq, Seq[A]], IterableFactoryDefaults[A, Seq]

Attributes

Companion
object
Source
Seq.scala
Supertypes
trait SeqOps[A, Seq, Seq[A]]
trait Cloneable[Seq[A]]
trait Cloneable
trait Seq[A]
trait Equals
trait SeqOps[A, Seq, Seq[A]]
trait PartialFunction[Int, A]
trait Int => A
trait Iterable[A]
trait Iterable[A]
trait IterableOps[A, Seq, Seq[A]]
trait IterableOnceOps[A, Seq, Seq[A]]
trait IterableOnce[A]
class Object
trait Matchable
class Any
Show all
Known subtypes
class AbstractSeq[A]
class AbstractBuffer[A]
class ArrayBuffer[A]
class ArrayDeque[A]
class Queue[A]
class Stack[A]
class ListBuffer[A]
class UnrolledBuffer[T]
class ArraySeq[T]
class ofBoolean
class ofByte
class ofChar
class ofDouble
class ofFloat
class ofInt
class ofLong
class ofRef[T]
class ofShort
class ofUnit
trait Buffer[A]
trait IndexedBuffer[A]
trait IndexedSeq[T]
class Accumulator[A, CC, C]
class AnyAccumulator[A]
Show all
object Seq extends Delegate[Seq]

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

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

Attributes

Companion
trait
Source
Seq.scala
Supertypes
class Delegate[Seq]
trait SeqFactory[Seq]
trait Serializable
class Object
trait Matchable
class Any
Show all
Self type
Seq.type
trait SeqMap[K, V] extends Map[K, V], SeqMap[K, V], MapOps[K, V, SeqMap, SeqMap[K, V]], MapFactoryDefaults[K, V, SeqMap, Iterable]

A generic trait for ordered mutable maps.

A generic trait for ordered mutable maps. Concrete classes have to provide functionality for the abstract methods in SeqMap.

Note that when checking for equality SeqMap does not take into account ordering.

Type parameters

K

the type of the keys contained in this linked map.

V

the type of the values associated with the keys in this linked map.

Attributes

Companion
object
Source
SeqMap.scala
Supertypes
trait SeqMap[K, V]
trait Map[K, V]
trait MapOps[K, V, SeqMap, SeqMap[K, V]]
trait Shrinkable[K]
trait Builder[(K, V), SeqMap[K, V]]
trait Growable[(K, V)]
trait Clearable
trait Cloneable[SeqMap[K, V]]
trait Cloneable
trait Map[K, V]
trait Equals
trait MapOps[K, V, SeqMap, SeqMap[K, V]]
trait PartialFunction[K, V]
trait K => V
trait Iterable[(K, V)]
trait Iterable[(K, V)]
trait IterableOps[(K, V), Iterable, SeqMap[K, V]]
trait IterableOnceOps[(K, V), Iterable, SeqMap[K, V]]
trait IterableOnce[(K, V)]
class Object
trait Matchable
class Any
Show all
Known subtypes
class LinkedHashMap[K, V]
object SeqMap extends Delegate[SeqMap]

Attributes

Companion
trait
Source
SeqMap.scala
Supertypes
class Delegate[SeqMap]
trait Serializable
class Object
trait Matchable
class Any
Show all
Self type
SeqMap.type
trait SeqOps[A, +CC[_], +C <: AnyRef] extends SeqOps[A, CC, C], Cloneable[C]

Attributes

Source
Seq.scala
Supertypes
trait Cloneable[C]
trait Cloneable
trait SeqOps[A, CC, C]
trait IterableOps[A, CC, C]
trait IterableOnceOps[A, CC, C]
trait IterableOnce[A]
class Object
trait Matchable
class Any
Show all
Known subtypes
trait Buffer[A]
class AbstractBuffer[A]
class ArrayBuffer[A]
class ArrayDeque[A]
class Queue[A]
class Stack[A]
class ListBuffer[A]
class UnrolledBuffer[T]
trait IndexedBuffer[A]
trait IndexedSeqOps[A, CC, C]
class ArraySeq[T]
class ofBoolean
class ofByte
class ofChar
class ofDouble
class ofFloat
class ofInt
class ofLong
class ofRef[T]
class ofShort
class ofUnit
trait IndexedSeq[T]
trait Seq[A]
class AbstractSeq[A]
class Accumulator[A, CC, C]
class AnyAccumulator[A]
Show all
trait Set[A] extends Iterable[A], Set[A], SetOps[A, Set, Set[A]], IterableFactoryDefaults[A, Set]

Base trait for mutable sets

Base trait for mutable sets

Attributes

Companion
object
Source
Set.scala
Supertypes
trait SetOps[A, Set, Set[A]]
trait Shrinkable[A]
trait Builder[A, Set[A]]
trait Growable[A]
trait Clearable
trait Cloneable[Set[A]]
trait Cloneable
trait Set[A]
trait Equals
trait SetOps[A, Set, Set[A]]
trait A => Boolean
trait Iterable[A]
trait Iterable[A]
trait IterableOps[A, Set, Set[A]]
trait IterableOnceOps[A, Set, Set[A]]
trait IterableOnce[A]
class Object
trait Matchable
class Any
Show all
Known subtypes
class AbstractSet[A]
class BitSet
class HashSet[A]
class LinkedHashSet[A]
class TreeSet[A]
trait SortedSet[A]
Show all
object Set extends Delegate[Set]

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

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

Attributes

Companion
trait
Source
Set.scala
Supertypes
class Delegate[Set]
trait Serializable
class Object
trait Matchable
class Any
Show all
Self type
Set.type
trait SetOps[A, +CC[X], +C <: SetOps[A, CC, C]] extends SetOps[A, CC, C], IterableOps[A, CC, C], Cloneable[C], Builder[A, C], Growable[A], Shrinkable[A]

Attributes

Source
Set.scala
Supertypes
trait Shrinkable[A]
trait Builder[A, C]
trait Growable[A]
trait Clearable
trait Cloneable[C]
trait Cloneable
trait SetOps[A, CC, C]
trait A => Boolean
trait IterableOps[A, CC, C]
trait IterableOnceOps[A, CC, C]
trait IterableOnce[A]
class Object
trait Matchable
class Any
Show all
Known subtypes
class HashSet[A]
class LinkedHashSet[A]
trait Set[A]
class AbstractSet[A]
class BitSet
class TreeSet[A]
trait SortedSet[A]
trait SortedSetOps[A, CC, C]
Show all
trait Shrinkable[-A]

This trait forms part of collections that can be reduced using a -= operator.

This trait forms part of collections that can be reduced using a -= operator.

Attributes

Source
Shrinkable.scala
Supertypes
class Object
trait Matchable
class Any
Known subtypes
trait Buffer[A]
class AbstractBuffer[A]
class ArrayBuffer[A]
class ArrayDeque[A]
class Queue[A]
class Stack[A]
class ListBuffer[A]
class UnrolledBuffer[T]
trait IndexedBuffer[A]
trait Map[K, V]
trait Map[K, V]
class TrieMap[K, V]
class AbstractMap[K, V]
class AnyRefMap[K, V]
class CollisionProofHashMap[K, V]
class HashMap[K, V]
class LinkedHashMap[K, V]
class ListMap[K, V]
class LongMap[V]
class WithDefault[K, V]
class WithDefault[K, V]
class OpenHashMap[Key, Value]
class TreeMap[K, V]
trait MultiMap[K, V]
trait SeqMap[K, V]
trait SortedMap[K, V]
trait MapOps[K, V, CC, C]
trait SortedMapOps[K, V, CC, C]
trait SetOps[A, CC, C]
class HashSet[A]
class LinkedHashSet[A]
trait Set[A]
class AbstractSet[A]
class BitSet
class TreeSet[A]
trait SortedSet[A]
trait SortedSetOps[A, CC, C]
Show all
trait SortedMap[K, V] extends SortedMap[K, V], Map[K, V], SortedMapOps[K, V, SortedMap, SortedMap[K, V]], SortedMapFactoryDefaults[K, V, SortedMap, Iterable, Map]

Base type for mutable sorted map collections

Base type for mutable sorted map collections

Attributes

Companion
object
Source
SortedMap.scala
Supertypes
trait SortedMapOps[K, V, SortedMap, SortedMap[K, V]]
trait Map[K, V]
trait MapOps[K, V, Map, SortedMap[K, V]]
trait Shrinkable[K]
trait Builder[(K, V), SortedMap[K, V]]
trait Growable[(K, V)]
trait Clearable
trait Cloneable[SortedMap[K, V]]
trait Cloneable
trait Iterable[(K, V)]
trait SortedMap[K, V]
trait SortedMapOps[K, V, SortedMap, SortedMap[K, V]]
trait SortedOps[K, SortedMap[K, V]]
trait Map[K, V]
trait Equals
trait MapOps[K, V, Map, SortedMap[K, V]]
trait PartialFunction[K, V]
trait K => V
trait Iterable[(K, V)]
trait IterableOps[(K, V), Iterable, SortedMap[K, V]]
trait IterableOnceOps[(K, V), Iterable, SortedMap[K, V]]
trait IterableOnce[(K, V)]
class Object
trait Matchable
class Any
Show all
Known subtypes
class WithDefault[K, V]
class TreeMap[K, V]
object SortedMap extends Delegate[SortedMap]

Attributes

Companion
trait
Source
SortedMap.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Show all
Self type
SortedMap.type
trait SortedMapOps[K, V, +CC <: ([X, Y] =>> Map[X, Y] & SortedMapOps[X, Y, CC, _]), +C <: SortedMapOps[K, V, CC, C]] extends SortedMapOps[K, V, CC, C], MapOps[K, V, Map, C]

Attributes

Source
SortedMap.scala
Supertypes
trait MapOps[K, V, Map, C]
trait Shrinkable[K]
trait Builder[(K, V), C]
trait Growable[(K, V)]
trait Clearable
trait Cloneable[C]
trait Cloneable
trait SortedMapOps[K, V, CC, C]
trait SortedOps[K, C]
trait MapOps[K, V, Map, C]
trait PartialFunction[K, V]
trait K => V
trait IterableOps[(K, V), Iterable, C]
trait IterableOnceOps[(K, V), Iterable, C]
trait IterableOnce[(K, V)]
class Object
trait Matchable
class Any
Show all
Known subtypes
trait SortedMap[K, V]
class WithDefault[K, V]
class TreeMap[K, V]
trait SortedSet[A] extends Set[A], SortedSet[A], SortedSetOps[A, SortedSet, SortedSet[A]], SortedSetFactoryDefaults[A, SortedSet, Set]

Base type for mutable sorted set collections

Base type for mutable sorted set collections

Attributes

Companion
object
Source
SortedSet.scala
Supertypes
trait SortedSet[A]
trait SortedOps[A, SortedSet[A]]
trait Set[A]
trait SetOps[A, Set, SortedSet[A]]
trait Shrinkable[A]
trait Builder[A, SortedSet[A]]
trait Growable[A]
trait Clearable
trait Cloneable[SortedSet[A]]
trait Cloneable
trait Set[A]
trait Equals
trait SetOps[A, Set, SortedSet[A]]
trait A => Boolean
trait Iterable[A]
trait Iterable[A]
trait IterableOps[A, Set, SortedSet[A]]
trait IterableOnceOps[A, Set, SortedSet[A]]
trait IterableOnce[A]
class Object
trait Matchable
class Any
Show all
Known subtypes
class BitSet
class TreeSet[A]
object SortedSet extends Delegate[SortedSet]

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

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

Attributes

Companion
trait
Source
SortedSet.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Show all
Self type
SortedSet.type
trait SortedSetOps[A, +CC <: (SortedSet), +C <: SortedSetOps[A, CC, C]] extends SetOps[A, Set, C], SortedSetOps[A, CC, C]

Attributes

Source
SortedSet.scala
Supertypes
trait SortedSetOps[A, CC, C]
trait SortedOps[A, C]
trait SetOps[A, Set, C]
trait Shrinkable[A]
trait Builder[A, C]
trait Growable[A]
trait Clearable
trait Cloneable[C]
trait Cloneable
trait SetOps[A, Set, C]
trait A => Boolean
trait IterableOps[A, Set, C]
trait IterableOnceOps[A, Set, C]
trait IterableOnce[A]
class Object
trait Matchable
class Any
Show all
Known subtypes
class BitSet
trait SortedSet[A]
class TreeSet[A]
class Stack[A] extends ArrayDeque[A], IndexedSeqOps[A, Stack, Stack[A]], StrictOptimizedSeqOps[A, Stack, Stack[A]], IterableFactoryDefaults[A, Stack], ArrayDequeOps[A, Stack, Stack[A]], Cloneable[Stack[A]], DefaultSerializable

A stack implements a data structure which allows to store and retrieve objects in a last-in-first-out (LIFO) fashion.

A stack implements a data structure which allows to store and retrieve objects in a last-in-first-out (LIFO) fashion.

Note that operations which consume and produce iterables preserve order, rather than reversing it (as would be expected from building a new stack by pushing an element at a time).

Type parameters

A

type of the elements contained in this stack.

Attributes

Companion
object
Source
Stack.scala
Supertypes
class ArrayDeque[A]
trait Serializable
trait ArrayDequeOps[A, Stack, Stack[A]]
trait IndexedBuffer[A]
trait IndexedSeq[A]
trait IndexedSeqOps[A, Stack, Stack[A]]
trait IndexedSeq[A]
trait IndexedSeqOps[A, Stack, Stack[A]]
class AbstractBuffer[A]
trait Buffer[A]
trait Shrinkable[A]
trait Growable[A]
trait Clearable
class AbstractSeq[A]
trait Seq[A]
trait SeqOps[A, Stack, Stack[A]]
trait Cloneable[Stack[A]]
trait Cloneable
trait Iterable[A]
class AbstractSeq[A]
trait Seq[A]
trait Equals
trait SeqOps[A, Stack, Stack[A]]
trait PartialFunction[Int, A]
trait Int => A
class AbstractIterable[A]
trait Iterable[A]
trait IterableOps[A, Stack, Stack[A]]
trait IterableOnceOps[A, Stack, Stack[A]]
trait IterableOnce[A]
class Object
trait Matchable
class Any
Show all
object Stack extends StrictOptimizedSeqFactory[Stack]

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

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

Attributes

Companion
class
Source
Stack.scala
Supertypes
trait SeqFactory[Stack]
trait Serializable
class Object
trait Matchable
class Any
Show all
Self type
Stack.type
final class StringBuilder(val underlying: StringBuilder) extends AbstractSeq[Char], ReusableBuilder[Char, String], IndexedSeq[Char], IndexedSeqOps[Char, IndexedSeq, StringBuilder], IterableFactoryDefaults[Char, IndexedSeq], CharSequence, Serializable

A builder of String which is also a mutable sequence of characters.

A builder of String which is also a mutable sequence of characters.

This class provides an API mostly compatible with java.lang.StringBuilder, except where there are conflicts with the Scala collections API, such as the reverse method: reverse produces a new StringBuilder, and reverseInPlace mutates this builder.

Mutating operations return either this.type, i.e., the current builder, or Unit.

Other methods extract data or information from the builder without mutating it.

The distinction is also reflected in naming conventions used by collections, such as append, which mutates, and appended, which does not, or reverse, which does not mutate, and reverseInPlace, which does.

The String result may be obtained using either result() or toString.

This Builder can be reused after calling result() without an intermediate call to clear() in order to build multiple related results.

Attributes

See also

"Scala's Collection Library overview" section on StringBuilders for more information.

Companion
object
Source
StringBuilder.scala
Supertypes
trait Serializable
trait CharSequence
trait IndexedSeq[Char]
trait IndexedSeq[Char]
trait Builder[Char, String]
trait Growable[Char]
trait Clearable
class AbstractSeq[Char]
trait Seq[Char]
trait Cloneable
trait Iterable[Char]
class AbstractSeq[Char]
trait Seq[Char]
trait Equals
trait Int => Char
trait Iterable[Char]
class Object
trait Matchable
class Any
Show all
object StringBuilder

Attributes

Companion
class
Source
StringBuilder.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Self type
sealed class TreeMap[K, V] extends AbstractMap[K, V], SortedMap[K, V], SortedMapOps[K, V, TreeMap, TreeMap[K, V]], StrictOptimizedIterableOps[(K, V), Iterable, TreeMap[K, V]], StrictOptimizedMapOps[K, V, Map, TreeMap[K, V]], StrictOptimizedSortedMapOps[K, V, TreeMap, TreeMap[K, V]], SortedMapFactoryDefaults[K, V, TreeMap, Iterable, Map], DefaultSerializable

A mutable sorted map implemented using a mutable red-black tree as underlying data structure.

A mutable sorted map implemented using a mutable red-black tree as underlying data structure.

Type parameters

K

the type of the keys contained in this tree map.

V

the type of the values associated with the keys.

Value parameters

ordering

the implicit ordering used to compare objects of type A.

Attributes

Companion
object
Source
TreeMap.scala
Supertypes
trait Serializable
trait StrictOptimizedMapOps[K, V, Map, TreeMap[K, V]]
trait SortedMap[K, V]
trait SortedMapOps[K, V, TreeMap, TreeMap[K, V]]
trait SortedMap[K, V]
trait SortedMapOps[K, V, TreeMap, TreeMap[K, V]]
trait SortedOps[K, TreeMap[K, V]]
class AbstractMap[K, V]
trait Map[K, V]
trait MapOps[K, V, Map, TreeMap[K, V]]
trait Shrinkable[K]
trait Builder[(K, V), TreeMap[K, V]]
trait Growable[(K, V)]
trait Clearable
trait Cloneable[TreeMap[K, V]]
trait Cloneable
trait Iterable[(K, V)]
class AbstractMap[K, V]
trait Map[K, V]
trait Equals
trait MapOps[K, V, Map, TreeMap[K, V]]
trait PartialFunction[K, V]
trait K => V
class AbstractIterable[(K, V)]
trait Iterable[(K, V)]
trait IterableOps[(K, V), Iterable, TreeMap[K, V]]
trait IterableOnceOps[(K, V), Iterable, TreeMap[K, V]]
trait IterableOnce[(K, V)]
class Object
trait Matchable
class Any
Show all
object TreeMap extends SortedMapFactory[TreeMap]

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

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

Attributes

Companion
class
Source
TreeMap.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Self type
TreeMap.type
sealed class TreeSet[A] extends AbstractSet[A], SortedSet[A], SortedSetOps[A, TreeSet, TreeSet[A]], StrictOptimizedIterableOps[A, Set, TreeSet[A]], StrictOptimizedSortedSetOps[A, TreeSet, TreeSet[A]], SortedSetFactoryDefaults[A, TreeSet, Set], DefaultSerializable

A mutable sorted set implemented using a mutable red-black tree as underlying data structure.

A mutable sorted set implemented using a mutable red-black tree as underlying data structure.

Type parameters

A

the type of the keys contained in this tree set.

Value parameters

ordering

the implicit ordering used to compare objects of type A.

Attributes

Companion
object
Source
TreeSet.scala
Supertypes
trait Serializable
trait SortedSet[A]
trait SortedSetOps[A, TreeSet, TreeSet[A]]
trait SortedSet[A]
trait SortedSetOps[A, TreeSet, TreeSet[A]]
trait SortedOps[A, TreeSet[A]]
class AbstractSet[A]
trait Set[A]
trait SetOps[A, Set, TreeSet[A]]
trait Shrinkable[A]
trait Builder[A, TreeSet[A]]
trait Growable[A]
trait Clearable
trait Cloneable[TreeSet[A]]
trait Cloneable
trait Iterable[A]
class AbstractSet[A]
trait Set[A]
trait Equals
trait SetOps[A, Set, TreeSet[A]]
trait A => Boolean
class AbstractIterable[A]
trait Iterable[A]
trait IterableOps[A, Set, TreeSet[A]]
trait IterableOnceOps[A, Set, TreeSet[A]]
trait IterableOnce[A]
class Object
trait Matchable
class Any
Show all
object TreeSet extends SortedIterableFactory[TreeSet]

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

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

Attributes

Companion
class
Source
TreeSet.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Show all
Self type
TreeSet.type
sealed class UnrolledBuffer[T](implicit val tag: ClassTag[T]) extends AbstractBuffer[T], Buffer[T], Seq[T], SeqOps[T, UnrolledBuffer, UnrolledBuffer[T]], StrictOptimizedSeqOps[T, UnrolledBuffer, UnrolledBuffer[T]], EvidenceIterableFactoryDefaults[T, UnrolledBuffer, ClassTag], Builder[T, UnrolledBuffer[T]], DefaultSerializable

A buffer that stores elements in an unrolled linked list.

A buffer that stores elements in an unrolled linked list.

Unrolled linked lists store elements in linked fixed size arrays.

Unrolled buffers retain locality and low memory overhead properties of array buffers, but offer much more efficient element addition, since they never reallocate and copy the internal array.

However, they provide O(n/m) complexity random access, where n is the number of elements, and m the size of internal array chunks.

Ideal to use when: - elements are added to the buffer and then all of the elements are traversed sequentially - two unrolled buffers need to be concatenated (see concat)

Better than singly linked lists for random access, but should still be avoided for such a purpose.

Attributes

Companion
object
Source
UnrolledBuffer.scala
Supertypes
trait Serializable
trait Builder[T, UnrolledBuffer[T]]
class AbstractBuffer[T]
trait Buffer[T]
trait Shrinkable[T]
trait Growable[T]
trait Clearable
class AbstractSeq[T]
trait Seq[T]
trait Cloneable
trait Iterable[T]
class AbstractSeq[T]
trait Seq[T]
trait Equals
trait PartialFunction[Int, T]
trait Int => T
class AbstractIterable[T]
trait Iterable[T]
trait IterableOnce[T]
class Object
trait Matchable
class Any
Show all
object UnrolledBuffer extends StrictOptimizedClassTagSeqFactory[UnrolledBuffer]
class WeakHashMap[K, V] extends JMapWrapper[K, V], JMapWrapperLike[K, V, WeakHashMap, WeakHashMap[K, V]], MapFactoryDefaults[K, V, WeakHashMap, Iterable]

A hash map with references to entries which are weakly reachable.

A hash map with references to entries which are weakly reachable. Entries are removed from this map when the key is no longer (strongly) referenced. This class wraps java.util.WeakHashMap.

Type parameters

K

type of keys contained in this map

V

type of values associated with the keys

Attributes

See also

"Scala's Collection Library overview" section on Weak Hash Maps for more information.

Companion
object
Source
WeakHashMap.scala
Supertypes
class JMapWrapper[K, V]
class AbstractJMapWrapper[K, V]
trait Serializable
trait JMapWrapperLike[K, V, WeakHashMap, WeakHashMap[K, V]]
class AbstractMap[K, V]
trait Map[K, V]
trait MapOps[K, V, WeakHashMap, WeakHashMap[K, V]]
trait Shrinkable[K]
trait Builder[(K, V), WeakHashMap[K, V]]
trait Growable[(K, V)]
trait Clearable
trait Cloneable[WeakHashMap[K, V]]
trait Cloneable
trait Iterable[(K, V)]
class AbstractMap[K, V]
trait Map[K, V]
trait Equals
trait MapOps[K, V, WeakHashMap, WeakHashMap[K, V]]
trait PartialFunction[K, V]
trait K => V
class AbstractIterable[(K, V)]
trait Iterable[(K, V)]
trait IterableOps[(K, V), Iterable, WeakHashMap[K, V]]
trait IterableOnceOps[(K, V), Iterable, WeakHashMap[K, V]]
trait IterableOnce[(K, V)]
class Object
trait Matchable
class Any
Show all
object WeakHashMap extends MapFactory[WeakHashMap]

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

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

Attributes

Companion
class
Source
WeakHashMap.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Self type

Deprecated classlikes

class AnyRefMap[K <: AnyRef, V] extends AbstractMap[K, V], MapOps[K, V, Map, AnyRefMap[K, V]], StrictOptimizedIterableOps[(K, V), Iterable, AnyRefMap[K, V]], Serializable

This class implements mutable maps with AnyRef keys based on a hash table with open addressing.

This class implements mutable maps with AnyRef keys based on a hash table with open addressing.

Basic map operations on single entries, including contains and get, are typically significantly faster with AnyRefMap than HashMap. Note that numbers and characters are not handled specially in AnyRefMap; only plain equals and hashCode are used in comparisons.

Methods that traverse or regenerate the map, including foreach and map, are not in general faster than with HashMap. The methods foreachKey, foreachValue, mapValuesNow, and transformValues are, however, faster than alternative ways to achieve the same functionality.

Maps with open addressing may become less efficient at lookup after repeated addition/removal of elements. Although AnyRefMap makes a decent attempt to remain efficient regardless, calling repack on a map that will no longer have elements removed but will be used heavily may save both time and storage space.

This map is not intended to contain more than 229 entries (approximately 500 million). The maximum capacity is 230, but performance will degrade rapidly as 230 is approached.

Attributes

Companion
object
Deprecated
[Since version 2.13.16] Use `scala.collection.mutable.HashMap` instead for better performance.
Source
AnyRefMap.scala
Supertypes
trait Serializable
class AbstractMap[K, V]
trait Map[K, V]
trait MapOps[K, V, Map, AnyRefMap[K, V]]
trait Shrinkable[K]
trait Builder[(K, V), AnyRefMap[K, V]]
trait Growable[(K, V)]
trait Clearable
trait Cloneable[AnyRefMap[K, V]]
trait Cloneable
trait Iterable[(K, V)]
class AbstractMap[K, V]
trait Map[K, V]
trait Equals
trait MapOps[K, V, Map, AnyRefMap[K, V]]
trait PartialFunction[K, V]
trait K => V
class AbstractIterable[(K, V)]
trait Iterable[(K, V)]
trait IterableOps[(K, V), Iterable, AnyRefMap[K, V]]
trait IterableOnceOps[(K, V), Iterable, AnyRefMap[K, V]]
trait IterableOnce[(K, V)]
class Object
trait Matchable
class Any
Show all
object AnyRefMap

Attributes

Companion
class
Deprecated
[Since version 2.13.16] Use `scala.collection.mutable.HashMap` instead for better performance.
Source
AnyRefMap.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Self type
AnyRefMap.type
class ListMap[K, V] extends AbstractMap[K, V], MapOps[K, V, ListMap, ListMap[K, V]], StrictOptimizedIterableOps[(K, V), Iterable, ListMap[K, V]], StrictOptimizedMapOps[K, V, ListMap, ListMap[K, V]], MapFactoryDefaults[K, V, ListMap, Iterable], DefaultSerializable

A simple mutable map backed by a list, so it preserves insertion order.

A simple mutable map backed by a list, so it preserves insertion order.

Type parameters

K

the type of the keys contained in this list map.

V

the type of the values assigned to keys in this list map.

Attributes

Companion
object
Deprecated
[Since version 2.13.0] Use an immutable.ListMap assigned to a var instead of mutable.ListMap
Source
ListMap.scala
Supertypes
trait Serializable
trait StrictOptimizedMapOps[K, V, ListMap, ListMap[K, V]]
class AbstractMap[K, V]
trait Map[K, V]
trait MapOps[K, V, ListMap, ListMap[K, V]]
trait Shrinkable[K]
trait Builder[(K, V), ListMap[K, V]]
trait Growable[(K, V)]
trait Clearable
trait Cloneable[ListMap[K, V]]
trait Cloneable
trait Iterable[(K, V)]
class AbstractMap[K, V]
trait Map[K, V]
trait Equals
trait MapOps[K, V, ListMap, ListMap[K, V]]
trait PartialFunction[K, V]
trait K => V
class AbstractIterable[(K, V)]
trait Iterable[(K, V)]
trait IterableOps[(K, V), Iterable, ListMap[K, V]]
trait IterableOnceOps[(K, V), Iterable, ListMap[K, V]]
trait IterableOnce[(K, V)]
class Object
trait Matchable
class Any
Show all
object ListMap extends MapFactory[ListMap]

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

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

Attributes

Companion
class
Deprecated
[Since version 2.13.0] Use an immutable.ListMap assigned to a var instead of mutable.ListMap
Source
ListMap.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Self type
ListMap.type
trait MultiMap[K, V] extends Map[K, Set[V]]

A trait for mutable maps with multiple values assigned to a key.

A trait for mutable maps with multiple values assigned to a key.

This class is typically used as a mixin. It turns maps which map K to Set[V] objects into multimaps that map K to V objects.

Attributes

Example 

// first import all necessary types from package `collection.mutable`
import collection.mutable.{ HashMap, MultiMap, Set }
// to create a `MultiMap` the easiest way is to mixin it into a normal
// `Map` instance
val mm = new HashMap[Int, Set[String]] with MultiMap[Int, String]
// to add key-value pairs to a multimap it is important to use
// the method `addBinding` because standard methods like `+` will
// overwrite the complete key-value pair instead of adding the
// value to the existing key
mm.addBinding(1, "a")
mm.addBinding(2, "b")
mm.addBinding(1, "c")
// mm now contains `Map(2 -> Set(b), 1 -> Set(c, a))`
// to check if the multimap contains a value there is method
// `entryExists`, which allows to traverse the including set
mm.entryExists(1, _ == "a") == true
mm.entryExists(1, _ == "b") == false
mm.entryExists(2, _ == "b") == true
// to remove a previous added value there is the method `removeBinding`
mm.removeBinding(1, "a")
mm.entryExists(1, _ == "a") == false
Deprecated
[Since version 2.13.0] Use a scala.collection.mutable.MultiDict in the scala-collection-contrib module
Source
MultiMap.scala
Supertypes
trait Map[K, Set[V]]
trait MapOps[K, Set[V], Map, Map[K, Set[V]]]
trait Shrinkable[K]
trait Builder[(K, Set[V]), Map[K, Set[V]]]
trait Growable[(K, Set[V])]
trait Clearable
trait Cloneable[Map[K, Set[V]]]
trait Cloneable
trait Map[K, Set[V]]
trait Equals
trait MapOps[K, Set[V], Map, Map[K, Set[V]]]
trait PartialFunction[K, Set[V]]
trait K => Set[V]
trait Iterable[(K, Set[V])]
trait Iterable[(K, Set[V])]
trait IterableOps[(K, Set[V]), Iterable, Map[K, Set[V]]]
trait IterableOnceOps[(K, Set[V]), Iterable, Map[K, Set[V]]]
trait IterableOnce[(K, Set[V])]
class Object
trait Matchable
class Any
Show all
object OpenHashMap extends MapFactory[OpenHashMap]

Attributes

Companion
class
Deprecated
[Since version 2.13.0] Use HashMap or one of the specialized versions (LongMap, AnyRefMap) instead of OpenHashMap
Source
OpenHashMap.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Self type
class OpenHashMap[Key, Value](initialSize: Int) extends AbstractMap[Key, Value], MapOps[Key, Value, OpenHashMap, OpenHashMap[Key, Value]], StrictOptimizedIterableOps[(Key, Value), Iterable, OpenHashMap[Key, Value]], MapFactoryDefaults[Key, Value, OpenHashMap, Iterable], DefaultSerializable

A mutable hash map based on an open addressing method.

A mutable hash map based on an open addressing method. The precise scheme is undefined, but it should make a reasonable effort to ensure that an insert with consecutive hash codes is not unnecessarily penalised. In particular, mappings of consecutive integer keys should work without significant performance loss.

Type parameters

Key

type of the keys in this map.

Value

type of the values in this map.

Value parameters

initialSize

the initial size of the internal hash table.

Attributes

Companion
object
Deprecated
[Since version 2.13.0] Use HashMap or one of the specialized versions (LongMap, AnyRefMap) instead of OpenHashMap
Source
OpenHashMap.scala
Supertypes
trait Serializable
trait StrictOptimizedIterableOps[(Key, Value), Iterable, OpenHashMap[Key, Value]]
class AbstractMap[Key, Value]
trait Map[Key, Value]
trait MapOps[Key, Value, OpenHashMap, OpenHashMap[Key, Value]]
trait Shrinkable[Key]
trait Builder[(Key, Value), OpenHashMap[Key, Value]]
trait Growable[(Key, Value)]
trait Clearable
trait Cloneable[OpenHashMap[Key, Value]]
trait Cloneable
trait Iterable[(Key, Value)]
class AbstractMap[Key, Value]
trait Map[Key, Value]
trait Equals
trait MapOps[Key, Value, OpenHashMap, OpenHashMap[Key, Value]]
trait PartialFunction[Key, Value]
trait Key => Value
class AbstractIterable[(Key, Value)]
trait Iterable[(Key, Value)]
trait IterableFactoryDefaults[(Key, Value), Iterable]
trait IterableOps[(Key, Value), Iterable, OpenHashMap[Key, Value]]
trait IterableOnceOps[(Key, Value), Iterable, OpenHashMap[Key, Value]]
trait IterableOnce[(Key, Value)]
class Object
trait Matchable
class Any
Show all

Deprecated types

type ArrayStack[X] = Stack[X]

Attributes

Deprecated
[Since version 2.13.0] Use Stack instead of ArrayStack; it now uses an array-based implementation
Source
package.scala
type GrowingBuilder[Elem, To <: Growable[Elem]] = GrowableBuilder[Elem, To]

Attributes

Deprecated
[Since version 2.13.0] GrowingBuilder has been renamed to GrowableBuilder
Source
package.scala
type IndexedOptimizedBuffer[A] = IndexedBuffer[A]

Attributes

Deprecated
[Since version 2.13.0] IndexedOptimizedBuffer has been renamed to IndexedBuffer
Source
package.scala
type IndexedOptimizedSeq[A] = IndexedSeq[A]

Attributes

Deprecated
[Since version 2.13.0] IndexedOptimizedSeq has been renamed to IndexedSeq
Source
package.scala
type LinearSeq[X] = Seq[X] & LinearSeq[X]

Attributes

Deprecated
[Since version 2.13.0] mutable.LinearSeq has been removed; use LinearSeq with mutable.Seq instead
Source
package.scala
type Traversable[X] = Iterable[X]

Attributes

Deprecated
[Since version 2.13.0] Use Iterable instead of Traversable
Source
package.scala
type WrappedArray[X] = ArraySeq[X]

Attributes

Deprecated
[Since version 2.13.0] Use ArraySeq instead of WrappedArray; it can represent both, boxed and unboxed arrays
Source
package.scala

Value members

Deprecated fields

val ArrayStack: Stack.type

Attributes

Deprecated
[Since version 2.13.0] Use Stack instead of ArrayStack; it now uses an array-based implementation
Source
package.scala
val Traversable: Iterable.type

Attributes

Deprecated
[Since version 2.13.0] Use Iterable instead of Traversable
Source
package.scala
val WrappedArray: ArraySeq.type

Attributes

Deprecated
[Since version 2.13.0] Use ArraySeq instead of WrappedArray; it can represent both, boxed and unboxed arrays
Source
package.scala
Generated with
Copyright (c) 2002-2025, LAMP/EPFL
Copyright (c) 2002-2025, LAMP/EPFL