Scala Standard Library 2.13.1 - scala.collection (original) (raw)

•  abstract class AbstractIndexedSeqView[+A] extends AbstractSeqView[A] with IndexedSeqView[A]
  Explicit instantiation of the IndexedSeqView trait to reduce class file size in subclasses.
•  abstract class AbstractIterable[+A] extends Iterable[A]
  Explicit instantiation of the Iterable trait to reduce class file size in subclasses.
•  abstract class AbstractIterator[+A] extends Iterator[A]
  Explicit instantiation of the Iterator trait to reduce class file size in subclasses.
•  abstract class AbstractMap[K, +V] extends AbstractIterable[(K, V)] with Map[K, V]
  Explicit instantiation of the Map trait to reduce class file size in subclasses.
•  abstract class AbstractMapView[K, +V] extends AbstractView[(K, V)] with MapView[K, V]
  Explicit instantiation of the MapView trait to reduce class file size in subclasses.
•  abstract class AbstractSeq[+A] extends AbstractIterable[A] with Seq[A]
  Explicit instantiation of the Seq trait to reduce class file size in subclasses.
•  abstract class AbstractSeqView[+A] extends AbstractView[A] with SeqView[A]
  Explicit instantiation of the SeqView trait to reduce class file size in subclasses.
•  abstract class AbstractSet[A] extends AbstractIterable[A] with Set[A]
  Explicit instantiation of the Set trait to reduce class file size in subclasses.
•  abstract class AbstractView[+A] extends AbstractIterable[A] with View[A]
  Explicit instantiation of the View trait to reduce class file size in subclasses.
•  trait AnyStepper[+A] extends Stepper[A]
  A Stepper for arbitrary element types.
•  final class ArrayOps[A] extends AnyVal
  This class serves as a wrapper for Arrays with many of the operations found in indexed sequences.
•  trait BitSet extends SortedSet[Int] with BitSetOps[BitSet]
  Base type of bitsets.
•  trait BitSetOps[+C <: BitSet with BitSetOps[C]] extends SortedSetOps[Int, SortedSet, C]
  Base implementation type of bitsets
•  trait BufferedIterator[+A] extends Iterator[A]
  Buffered iterators are iterators which provide a method head that inspects the next element without discarding it.
•  trait BuildFrom[-From, -A, +C] extends Any
  Builds a collection of type C from elements of type A when a source collection of type From is available.
•  trait BuildFromLowPriority1 extends BuildFromLowPriority2
•  trait BuildFromLowPriority2 extends AnyRef
•  trait ClassTagIterableFactory[+CC[_]] extends EvidenceIterableFactory[CC, ClassTag]
  Base trait for companion objects of collections that require an implicit ClassTag.
•  trait ClassTagSeqFactory[+CC[A] <: SeqOps[A, Seq, Seq[A]]] extends ClassTagIterableFactory[CC]
•  trait DoubleStepper extends Stepper[Double]
  A Stepper for Doubles.
•  trait EvidenceIterableFactory[+CC[_], Ev[_]] extends Serializable
  Base trait for companion objects of collections that require an implicit evidence.
•  trait EvidenceIterableFactoryDefaults[+A, +CC[x] <: IterableOps[x, CC, CC[x]], Ev[_]] extends IterableOps[A, CC, CC[A]]
  This trait provides default implementations for the factory methods fromSpecific andnewSpecificBuilder that need to be refined when implementing a collection type that refines the CC and C type parameters.
•  trait Factory[-A, +C] extends Any
  A factory that builds a collection of type C with elements of type A.
•  trait IndexedSeq[+A] extends Seq[A] with IndexedSeqOps[A, IndexedSeq, IndexedSeq[A]] with IterableFactoryDefaults[A, IndexedSeq]
  Base trait for indexed sequences that have efficient apply and length
•  trait IndexedSeqOps[+A, +CC[_], +C] extends SeqOps[A, CC, C]
  Base trait for indexed Seq operations
•  trait IndexedSeqView[+A] extends IndexedSeqOps[A, View, View[A]] with SeqView[A]
  View defined in terms of indexing a range
•  trait IntStepper extends Stepper[Int]
  A Stepper for Ints.
•  trait Iterable[+A] extends IterableOnce[A] with IterableOps[A, Iterable, Iterable[A]] with IterableFactoryDefaults[A, Iterable]
  Base trait for generic collections.
•  trait IterableFactory[+CC[_]] extends Serializable
  Base trait for companion objects of unconstrained collection types that may require multiple traversals of a source collection to build a target collection CC.
•  trait IterableFactoryDefaults[+A, +CC[x] <: IterableOps[x, CC, CC[x]]] extends IterableOps[A, CC, CC[A]]
  This trait provides default implementations for the factory methods fromSpecific andnewSpecificBuilder that need to be refined when implementing a collection type that refines the CC and C type parameters.
•  trait IterableOnce[+A] extends Any
  A template trait for collections which can be traversed either once only or one or more times.
•  final class IterableOnceExtensionMethods[A] extends AnyVal
•  trait IterableOnceOps[+A, +CC[_], +C] extends Any
  This implementation trait can be mixed into an IterableOnce to get the basic methods that are shared betweenIterator and Iterable.
•  trait IterableOps[+A, +CC[_], +C] extends IterableOnce[A] with IterableOnceOps[A, CC, C]
  Base trait for Iterable operations
•  trait Iterator[+A] extends IterableOnce[A] with IterableOnceOps[A, Iterator, Iterator[A]]
  Iterators are data structures that allow to iterate over a sequence of elements.
•  final class LazyZip2[+El1, +El2, C1] extends AnyRef
  Decorator representing lazily zipped pairs.
•  final class LazyZip3[+El1, +El2, +El3, C1] extends AnyRef
  Decorator representing lazily zipped triples.
•  final class LazyZip4[+El1, +El2, +El3, +El4, C1] extends AnyRef
  Decorator representing lazily zipped 4-tuples.
•  trait LinearSeq[+A] extends Seq[A] with LinearSeqOps[A, LinearSeq, LinearSeq[A]] with IterableFactoryDefaults[A, LinearSeq]
  Base trait for linearly accessed sequences that have efficient head andtail operations.
•  trait LinearSeqOps[+A, +CC[X] <: LinearSeq[X], +C <: LinearSeq[A] with LinearSeqOps[A, CC, C]] extends SeqOps[A, CC, C]
  Base trait for linear Seq operations
•  trait LongStepper extends Stepper[Long]
  A Stepper for Longs.
•  trait Map[K, +V] extends Iterable[(K, V)] with MapOps[K, V, Map, Map[K, V]] with MapFactoryDefaults[K, V, Map, Iterable] with Equals
  Base Map type
•  trait MapFactory[+CC[_, _]] extends Serializable
•  trait MapFactoryDefaults[K, +V, +CC[x, y] <: IterableOps[(x, y), Iterable, Iterable[(x, y)]], +WithFilterCC[x] <: IterableOps[x, WithFilterCC, WithFilterCC[x]] with Iterable[x]] extends MapOps[K, V, CC, CC[K, V]] with IterableOps[(K, V), WithFilterCC, CC[K, V]]
  This trait provides default implementations for the factory methods fromSpecific andnewSpecificBuilder that need to be refined when implementing a collection type that refines the CC and C type parameters.
•  trait MapOps[K, +V, +CC[_, _] <: IterableOps[_, collection.AnyConstr, _], +C] extends IterableOps[(K, V), Iterable, C] with PartialFunction[K, V]
  Base Map implementation type
•  trait MapView[K, +V] extends MapOps[K, V, [X, Y]View[(X, Y)], View[(K, V)]] with View[(K, V)]
•  trait MapViewFactory extends MapFactory[[X, Y]View[(X, Y)]]
•  trait Seq[+A] extends Iterable[A] with PartialFunction[Int, A] with SeqOps[A, Seq, Seq[A]] with IterableFactoryDefaults[A, Seq] with Equals
  Base trait for sequence collections
•  trait SeqFactory[+CC[A] <: SeqOps[A, Seq, Seq[A]]] extends IterableFactory[CC]
•  trait SeqMap[K, +V] extends Map[K, V] with MapOps[K, V, SeqMap, SeqMap[K, V]] with MapFactoryDefaults[K, V, SeqMap, Iterable]
  A generic trait for ordered maps.
•  trait SeqOps[+A, +CC[_], +C] extends IterableOps[A, CC, C]
  Base trait for Seq operations
•  trait SeqView[+A] extends SeqOps[A, View, View[A]] with View[A]
•  trait Set[A] extends Iterable[A] with SetOps[A, Set, Set[A]] with Equals with IterableFactoryDefaults[A, Set]
  Base trait for set collections.
•  trait SetOps[A, +CC[_], +C <: SetOps[A, CC, C]] extends IterableOps[A, CC, C] with (A) => Boolean
  Base trait for set operations
•  trait SortedIterableFactory[+CC[_]] extends EvidenceIterableFactory[CC, Ordering]
  Base trait for companion objects of collections that require an implicit Ordering.
•  trait SortedMap[K, +V] extends Map[K, V] with SortedMapOps[K, V, SortedMap, SortedMap[K, V]] with SortedMapFactoryDefaults[K, V, SortedMap, Iterable, Map]
  A Map whose keys are sorted according to a scala.math.Ordering
•  trait SortedMapFactory[+CC[_, _]] extends Serializable
•  trait SortedMapFactoryDefaults[K, +V, +CC[x, y] <: Map[x, y] with SortedMapOps[x, y, CC, CC[x, y]] with UnsortedCC[x, y], +WithFilterCC[x] <: IterableOps[x, WithFilterCC, WithFilterCC[x]] with Iterable[x], +UnsortedCC[x, y] <: Map[x, y]] extends SortedMapOps[K, V, CC, CC[K, V]] with MapOps[K, V, UnsortedCC, CC[K, V]]
  This trait provides default implementations for the factory methods fromSpecific andnewSpecificBuilder that need to be refined when implementing a collection type that refines the CC and C type parameters.
•  trait SortedMapOps[K, +V, +CC[X, Y] <: Map[X, Y] with SortedMapOps[X, Y, CC, _], +C <: SortedMapOps[K, V, CC, C]] extends MapOps[K, V, Map, C] with SortedOps[K, C]
•  trait SortedOps[A, +C] extends AnyRef
  Base trait for sorted collections
•  trait SortedSet[A] extends Set[A] with SortedSetOps[A, SortedSet, SortedSet[A]] with SortedSetFactoryDefaults[A, SortedSet, Set]
  Base type of sorted sets
•  trait SortedSetFactoryDefaults[+A, +CC[X] <: SortedSet[X] with SortedSetOps[X, CC, CC[X]], +WithFilterCC[x] <: IterableOps[x, WithFilterCC, WithFilterCC[x]] with Set[x]] extends SortedSetOps[A, CC, CC[A]]
  This trait provides default implementations for the factory methods fromSpecific andnewSpecificBuilder that need to be refined when implementing a collection type that refines the CC and C type parameters.
•  trait SortedSetOps[A, +CC[X] <: SortedSet[X], +C <: SortedSetOps[A, CC, C]] extends SetOps[A, Set, C] with SortedOps[A, C]
•  trait SpecificIterableFactory[-A, +C] extends Factory[A, C]
•  trait Stepper[+A] extends AnyRef
  Steppers exist to enable creating Java streams over Scala collections, seescala.jdk.StreamConverters.
•  sealed trait StepperShape[-T, S <: Stepper[_]] extends AnyRef
  An implicit StepperShape instance is used in the IterableOnce.stepper to return a possibly specialized Stepper S according to the element type T.
•  trait StepperShapeLowPriority1 extends StepperShapeLowPriority2
•  trait StepperShapeLowPriority2 extends AnyRef
•  trait StrictOptimizedClassTagSeqFactory[+CC[A] <: SeqOps[A, Seq, Seq[A]]] extends ClassTagSeqFactory[CC]
•  trait StrictOptimizedIterableOps[+A, +CC[_], +C] extends IterableOps[A, CC, C]
  Trait that overrides iterable operations to take advantage of strict builders.
•  trait StrictOptimizedLinearSeqOps[+A, +CC[X] <: LinearSeq[X], +C <: LinearSeq[A] with StrictOptimizedLinearSeqOps[A, CC, C]] extends LinearSeqOps[A, CC, C] with StrictOptimizedSeqOps[A, CC, C]
•  trait StrictOptimizedMapOps[K, +V, +CC[_, _] <: IterableOps[_, collection.AnyConstr, _], +C] extends MapOps[K, V, CC, C] with StrictOptimizedIterableOps[(K, V), Iterable, C]
  Trait that overrides map operations to take advantage of strict builders.
•  trait StrictOptimizedSeqFactory[+CC[A] <: SeqOps[A, Seq, Seq[A]]] extends SeqFactory[CC]
•  trait StrictOptimizedSeqOps[+A, +CC[_], +C] extends SeqOps[A, CC, C] with StrictOptimizedIterableOps[A, CC, C]
  Trait that overrides operations on sequences in order to take advantage of strict builders.
•  trait StrictOptimizedSetOps[A, +CC[_], +C <: SetOps[A, CC, C]] extends SetOps[A, CC, C] with StrictOptimizedIterableOps[A, CC, C]
  Trait that overrides set operations to take advantage of strict builders.
•  trait StrictOptimizedSortedMapOps[K, +V, +CC[X, Y] <: Map[X, Y] with SortedMapOps[X, Y, CC, _], +C <: SortedMapOps[K, V, CC, C]] extends SortedMapOps[K, V, CC, C] with StrictOptimizedMapOps[K, V, Map, C]
  Trait that overrides sorted map operations to take advantage of strict builders.
•  trait StrictOptimizedSortedSetOps[A, +CC[X] <: SortedSet[X], +C <: SortedSetOps[A, CC, C]] extends SortedSetOps[A, CC, C] with StrictOptimizedSetOps[A, Set, C]
  Trait that overrides sorted set operations to take advantage of strict builders.
•  final class StringOps extends AnyVal
•  final case class StringView(s: String) extends AbstractIndexedSeqView[Char] with Product with Serializable
•  trait View[+A] extends Iterable[A] with IterableOps[A, View, View[A]] with IterableFactoryDefaults[A, View] with Serializable
  Views are collections whose transformation operations are non strict: the resulting elements are evaluated only when the view is effectively traversed (e.g.
•  abstract class WithFilter[+A, +CC[_]] extends Serializable
  A template trait that contains just the map, flatMap, foreach and withFilter methods of trait Iterable.