Scala 3
3.6.4-RC1-bin-20241217-ae80285-NIGHTLY
LearnInstallPlaygroundFind A LibraryCommunityBlog
LearnInstallPlaygroundFind A LibraryCommunityBlog
DocsAPI
Generated with
Copyright (c) 2002-2024, LAMP/EPFL
Copyright (c) 2002-2024, LAMP/EPFL
Scala 3/scala/scala.collection

scala.collection

package scala.collection

Members list

Packages

package scala.collection.concurrent
package scala.collection.convert
package scala.collection.generic
package scala.collection.immutable
package scala.collection.mutable

Type members

Classlikes

object +:

An extractor used to head/tail deconstruct sequences.

An extractor used to head/tail deconstruct sequences.

Attributes

Source
package.scala
Supertypes
class Object
trait Matchable
class Any
Self type
+:.type
object :+

An extractor used to init/last deconstruct sequences.

An extractor used to init/last deconstruct sequences.

Attributes

Source
package.scala
Supertypes
class Object
trait Matchable
class Any
Self type
:+.type
abstract class AbstractIndexedSeqView[+A] extends AbstractSeqView[A], IndexedSeqView[A]

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

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

Attributes

Source
IndexedSeqView.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
Known subtypes
class ArrayBufferView[A]
class Slice[A]
class StringView
abstract class AbstractIterable[+A] extends 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]
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]
class AbstractMap[K, V]
class AbstractMap[K, V]
class HashMap[K, V]
class IntMap[T]
class ListMap[K, V]
class LongMap[T]
class Map1[K, V]
class Map2[K, V]
class Map3[K, V]
class Map4[K, V]
class WithDefault[K, V]
class WithDefault[K, V]
class TreeMap[K, V]
class TreeSeqMap[K, V]
class VectorMap[K, V]
class AbstractMap[K, V]
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]
class AbstractSeq[A]
class AbstractSeq[A]
class ArraySeq[A]
class ofBoolean
class ofByte
class ofChar
class ofDouble
class ofFloat
class ofInt
class ofLong
class ofRef[T]
class ofShort
class ofUnit
class LazyList[A]
class List[A]
class ::[A]
object Nil
class NumericRange[T]
class Exclusive[T]
class Inclusive[T]
class Queue[A]
class Range
class Exclusive
class Inclusive
class Stream[A]
class Cons[A]
object Empty
class Vector[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
class AbstractSet[A]
class AbstractSet[A]
class BitSet
class BitSet1
class BitSet2
class BitSetN
class HashSet[A]
class ListSet[A]
class Set1[A]
class Set2[A]
class Set3[A]
class Set4[A]
class TreeSet[A]
class ValueSet
class AbstractSet[A]
class BitSet
class HashSet[A]
class LinkedHashSet[A]
class TreeSet[A]
class AbstractView[A]
class AbstractMapView[K, V]
class Filter[K, V]
class FilterKeys[K, V]
class Id[K, V]
class MapValues[K, V, W]
class TapEach[K, V, U]
class AbstractSeqView[A]
class ArrayBufferView[A]
class Slice[A]
class StringView
class Id[A]
class Id[A]
class Reverse[A]
class Reverse[A]
class Appended[A]
class Appended[A]
class Appended[A]
class Collect[A, B]
class Concat[A]
class Concat[A]
class Concat[A]
class DistinctBy[A, B]
class Drop[A]
class Drop[A]
class Drop[A]
class DropRight[A]
class DropRight[A]
class DropRight[A]
class DropWhile[A]
class Elems[A]
object Empty
class Fill[A]
class Filter[A]
class FlatMap[A, B]
class Iterate[A]
class LeftPartitionMapped[A, A1, A2]
class Map[A, B]
class Map[A, B]
class Map[A, B]
class PadTo[A]
class Prepended[A]
class Prepended[A]
class Prepended[A]
class RightPartitionMapped[A, A1, A2]
class ScanLeft[A, B]
class Single[A]
class Tabulate[A]
class Take[A]
class Take[A]
class Take[A]
class TakeRight[A]
class TakeRight[A]
class TakeRight[A]
class TakeWhile[A]
class Unfold[A, S]
class Updated[A]
class Zip[A, B]
class ZipAll[A, B]
class ZipWithIndex[A]
Show all
abstract class AbstractIterator[+A] extends Iterator[A]

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

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

Attributes

Source
Iterator.scala
Supertypes
trait Iterator[A]
trait IterableOnce[A]
class Object
trait Matchable
class Any
Show all
Known subtypes
class GroupedIterator[B]
class LineIterator
abstract class AbstractMap[K, +V] extends AbstractIterable[(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 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 AbstractMap[K, V]
class HashMap[K, V]
class IntMap[T]
class ListMap[K, V]
class LongMap[T]
class Map1[K, V]
class Map2[K, V]
class Map3[K, V]
class Map4[K, V]
class WithDefault[K, V]
class WithDefault[K, V]
class TreeMap[K, V]
class TreeSeqMap[K, V]
class VectorMap[K, V]
class AbstractMap[K, V]
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 AbstractMapView[K, +V] extends AbstractView[(K, V)], MapView[K, V]

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

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

Attributes

Source
MapView.scala
Supertypes
trait MapView[K, V]
trait MapOps[K, V, { type l = [X, Y] =>> View[(X, Y)]; }#<none>, View[(K, V)]]
trait PartialFunction[K, V]
trait K => V
class AbstractView[(K, V)]
trait View[(K, V)]
trait Serializable
class AbstractIterable[(K, V)]
trait Iterable[(K, V)]
trait IterableFactoryDefaults[(K, V), View]
trait IterableOps[(K, V), View, View[(K, V)]]
trait IterableOnceOps[(K, V), View, View[(K, V)]]
trait IterableOnce[(K, V)]
class Object
trait Matchable
class Any
Show all
Known subtypes
class Filter[K, V]
class FilterKeys[K, V]
class Id[K, V]
class MapValues[K, V, W]
class TapEach[K, V, U]
abstract class AbstractSeq[+A] extends AbstractIterable[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 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 AbstractSeq[A]
class ArraySeq[A]
class ofBoolean
class ofByte
class ofChar
class ofDouble
class ofFloat
class ofInt
class ofLong
class ofRef[T]
class ofShort
class ofUnit
class LazyList[A]
class List[A]
class ::[A]
object Nil
class NumericRange[T]
class Exclusive[T]
class Inclusive[T]
class Queue[A]
class Range
class Exclusive
class Inclusive
class Stream[A]
class Cons[A]
object Empty
class Vector[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
Show all
abstract class AbstractSeqView[+A] extends AbstractView[A], SeqView[A]

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

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

Attributes

Source
SeqView.scala
Supertypes
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
Known subtypes
class ArrayBufferView[A]
class Slice[A]
class StringView
class Id[A]
class Id[A]
class Reverse[A]
class Reverse[A]
Show all
abstract class AbstractSet[A] extends AbstractIterable[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 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 AbstractSet[A]
class BitSet
class BitSet1
class BitSet2
class BitSetN
class HashSet[A]
class ListSet[A]
class Set1[A]
class Set2[A]
class Set3[A]
class Set4[A]
class TreeSet[A]
class ValueSet
class AbstractSet[A]
class BitSet
class HashSet[A]
class LinkedHashSet[A]
class TreeSet[A]
Show all
abstract class AbstractView[+A] extends AbstractIterable[A], View[A]

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

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

Attributes

Source
View.scala
Supertypes
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
Known subtypes
class AbstractMapView[K, V]
class Filter[K, V]
class FilterKeys[K, V]
class Id[K, V]
class MapValues[K, V, W]
class TapEach[K, V, U]
class AbstractSeqView[A]
class ArrayBufferView[A]
class Slice[A]
class StringView
class Id[A]
class Id[A]
class Reverse[A]
class Reverse[A]
class Appended[A]
class Appended[A]
class Appended[A]
class Collect[A, B]
class Concat[A]
class Concat[A]
class Concat[A]
class DistinctBy[A, B]
class Drop[A]
class Drop[A]
class Drop[A]
class DropRight[A]
class DropRight[A]
class DropRight[A]
class DropWhile[A]
class Elems[A]
object Empty
class Fill[A]
class Filter[A]
class FlatMap[A, B]
class Iterate[A]
class LeftPartitionMapped[A, A1, A2]
class Map[A, B]
class Map[A, B]
class Map[A, B]
class PadTo[A]
class Prepended[A]
class Prepended[A]
class Prepended[A]
class RightPartitionMapped[A, A1, A2]
class ScanLeft[A, B]
class Single[A]
class Tabulate[A]
class Take[A]
class Take[A]
class Take[A]
class TakeRight[A]
class TakeRight[A]
class TakeRight[A]
class TakeWhile[A]
class Unfold[A, S]
class Updated[A]
class Zip[A, B]
class ZipAll[A, B]
class ZipWithIndex[A]
Show all
trait AnyStepper[+A] extends Stepper[A]

A Stepper for arbitrary element types.

A Stepper for arbitrary element types. See Stepper.

Attributes

Companion
object
Source
Stepper.scala
Supertypes
trait Stepper[A]
class Object
trait Matchable
class Any
object AnyStepper

Attributes

Companion
trait
Source
Stepper.scala
Supertypes
class Object
trait Matchable
class Any
Self type
AnyStepper.type
object ArrayOps

Attributes

Companion
class
Source
ArrayOps.scala
Supertypes
class Object
trait Matchable
class Any
Self type
ArrayOps.type
final class ArrayOps[A](xs: Array[A]) extends AnyVal

This class serves as a wrapper for Arrays with many of the operations found in indexed sequences.

This class serves as a wrapper for Arrays with many of the operations found in indexed sequences. Where needed, instances of arrays are implicitly converted into this class. There is generally no reason to create an instance explicitly or use an ArrayOps type. It is better to work with plain Array types instead and rely on the implicit conversion to ArrayOps when calling a method (which does not actually allocate an instance of ArrayOps because it is a value class).

Neither Array nor ArrayOps are proper collection types (i.e. they do not extend Iterable or even IterableOnce). mutable.ArraySeq and immutable.ArraySeq serve this purpose.

The difference between this class and ArraySeqs is that calling transformer methods such as filter and map will yield an array, whereas an ArraySeq will remain an ArraySeq.

Type parameters

A

type of the elements contained in this array.

Attributes

Companion
object
Source
ArrayOps.scala
Supertypes
class AnyVal
trait Matchable
class Any
trait BitSet extends SortedSet[Int], BitSetOps[BitSet]

Base type of bitsets.

Base type of bitsets.

This trait provides most of the operations of a BitSet independently of its representation. It is inherited by all concrete implementations of bitsets.

Attributes

Companion
object
Source
BitSet.scala
Supertypes
trait BitSetOps[BitSet]
trait SortedSet[Int]
trait SortedOps[Int, BitSet]
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
Known subtypes
class BitSet
class BitSet1
class BitSet2
class BitSetN
class BitSet
object BitSet extends SpecificIterableFactory[Int, BitSet]

Attributes

Companion
trait
Source
BitSet.scala
Supertypes
trait Factory[Int, BitSet]
class Object
trait Matchable
class Any
Self type
BitSet.type
trait BitSetOps[+C <: BitSet & BitSetOps[C]] extends SortedSetOps[Int, SortedSet, C]

Base implementation type of bitsets

Base implementation type of bitsets

Attributes

Companion
object
Source
BitSet.scala
Supertypes
trait SortedOps[Int, C]
trait SetOps[Int, Set, C]
trait Int => Boolean
trait IterableOps[Int, Set, C]
trait IterableOnceOps[Int, Set, C]
trait IterableOnce[Int]
class Object
trait Matchable
class Any
Show all
Known subtypes
class BitSet
class BitSet1
class BitSet2
class BitSetN
class BitSet
trait BitSet
Show all
Self type
object BitSetOps

Attributes

Companion
trait
Source
BitSet.scala
Supertypes
class Object
trait Matchable
class Any
Self type
BitSetOps.type
trait BufferedIterator[+A] extends Iterator[A]

Buffered iterators are iterators which provide a method head that inspects the next element without discarding it.

Buffered iterators are iterators which provide a method head that inspects the next element without discarding it.

Attributes

Source
BufferedIterator.scala
Supertypes
trait Iterator[A]
trait IterableOnce[A]
class Object
trait Matchable
class Any
Show all
trait BuildFrom[-From, -A, +C]

Builds a collection of type C from elements of type A when a source collection of type From is available.

Builds a collection of type C from elements of type A when a source collection of type From is available. Implicit instances of BuildFrom are available for all collection types.

Type parameters

A

Type of elements (e.g. Int, Boolean, etc.)

C

Type of collection (e.g. List[Int], TreeMap[Int, String], etc.)

From

Type of source collection

Attributes

Companion
object
Source
BuildFrom.scala
Supertypes
class Any
Self type
BuildFrom[From, A, C]
object BuildFrom extends BuildFromLowPriority1

Attributes

Companion
trait
Source
BuildFrom.scala
Supertypes
class Object
trait Matchable
class Any
Self type
BuildFrom.type
trait BuildFromLowPriority1 extends BuildFromLowPriority2

Attributes

Source
BuildFrom.scala
Supertypes
class Object
trait Matchable
class Any
Known subtypes
object BuildFrom
trait BuildFromLowPriority2

Attributes

Source
BuildFrom.scala
Supertypes
class Object
trait Matchable
class Any
Known subtypes
object BuildFrom
trait ClassTagIterableFactory[+CC[_]] extends EvidenceIterableFactory[CC, ClassTag]

Base trait for companion objects of collections that require an implicit ClassTag.

Base trait for companion objects of collections that require an implicit ClassTag.

Type parameters

CC

Collection type constructor (e.g. ArraySeq)

Attributes

Companion
object
Source
Factory.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Known subtypes
class Delegate[CC]
class Delegate[CC]
trait ClassTagSeqFactory[CC]
object ArraySeq
object ArraySeq
Show all
object ClassTagIterableFactory

Attributes

Companion
trait
Source
Factory.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Self type
trait ClassTagSeqFactory[+CC <: (SeqOps)] extends ClassTagIterableFactory[CC]

Type parameters

CC

Collection type constructor (e.g. ArraySeq)

Attributes

Companion
object
Source
Factory.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Show all
Known subtypes
class Delegate[CC]
object ArraySeq
object ArraySeq
object ClassTagSeqFactory

Attributes

Companion
trait
Source
Factory.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Self type
trait DoubleStepper extends Stepper[Double]

A Stepper for Doubles.

A Stepper for Doubles. See Stepper.

Attributes

Companion
object
Source
Stepper.scala
Supertypes
trait Stepper[Double]
class Object
trait Matchable
class Any
object DoubleStepper

Attributes

Companion
trait
Source
Stepper.scala
Supertypes
class Object
trait Matchable
class Any
Self type
trait EvidenceIterableFactory[+CC[_], Ev[_]] extends Serializable

Base trait for companion objects of collections that require an implicit evidence.

Base trait for companion objects of collections that require an implicit evidence.

Type parameters

CC

Collection type constructor (e.g. ArraySeq)

Ev

Unary type constructor for the implicit evidence required for an element type (typically Ordering or ClassTag)

Attributes

Companion
object
Source
Factory.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Known subtypes
class Delegate[CC]
class Delegate[CC]
trait ClassTagSeqFactory[CC]
object ArraySeq
object ArraySeq
class Delegate[CC, Ev]
class Delegate[CC]
object SortedSet
object SortedSet
object SortedSet
object TreeSet
object PriorityQueue
object TreeSet
Show all
object EvidenceIterableFactory

Attributes

Companion
trait
Source
Factory.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Self type
trait EvidenceIterableFactoryDefaults[+A, +CC <: (IterableOps), Ev[_]] extends IterableOps[A, CC, CC[A]]

This trait provides default implementations for the factory methods fromSpecific and newSpecificBuilder that need to be refined when implementing a collection type that refines the CC and C type parameters.

This trait provides default implementations for the factory methods fromSpecific and newSpecificBuilder that need to be refined when implementing a collection type that refines the CC and C type parameters. It is used for collections that have an additional constraint, expressed by the evidenceIterableFactory method.

The default implementations in this trait can be used in the common case when CC[A] is the same as C.

Attributes

Source
Iterable.scala
Supertypes
trait IterableOps[A, CC, CC[A]]
trait IterableOnceOps[A, CC, CC[A]]
trait IterableOnce[A]
class Object
trait Matchable
class Any
Show all
Known subtypes
class ArraySeq[A]
class ofBoolean
class ofByte
class ofChar
class ofDouble
class ofFloat
class ofInt
class ofLong
class ofRef[T]
class ofShort
class ofUnit
class UnrolledBuffer[T]
Show all
trait Factory[-A, +C]

A factory that builds a collection of type C with elements of type A.

A factory that builds a collection of type C with elements of type A.

This is a general form of any factory (IterableFactory, SortedIterableFactory, MapFactory and SortedMapFactory) whose element type is fixed.

Type parameters

A

Type of elements (e.g. Int, Boolean, etc.)

C

Type of collection (e.g. List[Int], TreeMap[Int, String], etc.)

Attributes

Companion
object
Source
Factory.scala
Supertypes
class Any
Known subtypes
object BitSet
object WrappedString
object BitSet
object BitSet
object ValueSet
Show all
object Factory

Attributes

Companion
trait
Source
Factory.scala
Supertypes
class Object
trait Matchable
class Any
Self type
Factory.type
trait IndexedSeq[+A] extends Seq[A], IndexedSeqOps[A, IndexedSeq, IndexedSeq[A]], IterableFactoryDefaults[A, IndexedSeq]

Base trait for indexed sequences that have efficient apply and length

Base trait for indexed sequences that have efficient apply and length

Attributes

Companion
object
Source
IndexedSeq.scala
Supertypes
trait Seq[A]
trait Equals
trait SeqOps[A, IndexedSeq, IndexedSeq[A]]
trait PartialFunction[Int, A]
trait Int => A
trait Iterable[A]
trait IterableOnce[A]
class Object
trait Matchable
class Any
Show all
Known subtypes
trait IndexedSeq[A]
class ArraySeq[A]
class ofBoolean
class ofByte
class ofChar
class ofDouble
class ofFloat
class ofInt
class ofLong
class ofRef[T]
class ofShort
class ofUnit
class NumericRange[T]
class Exclusive[T]
class Inclusive[T]
class Range
class Exclusive
class Inclusive
class Vector[A]
trait IndexedSeq[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 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] extends SeqOps[A, CC, C]

Base trait for indexed Seq operations

Base trait for indexed Seq operations

Attributes

Source
IndexedSeq.scala
Supertypes
trait SeqOps[A, CC, C]
trait IterableOps[A, CC, C]
trait IterableOnceOps[A, CC, C]
trait IterableOnce[A]
class Any
Known subtypes
trait IndexedSeqOps[A, CC, C]
class ArraySeq[A]
class ofBoolean
class ofByte
class ofChar
class ofDouble
class ofFloat
class ofInt
class ofLong
class ofRef[T]
class ofShort
class ofUnit
trait IndexedSeq[A]
class NumericRange[T]
class Exclusive[T]
class Inclusive[T]
class Range
class Exclusive
class Inclusive
class Vector[A]
trait IndexedSeqOps[A, CC, C]
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]
trait IndexedSeq[A]
trait IndexedSeqView[A]
class ArrayBufferView[A]
class Slice[A]
class StringView
class Appended[A]
class Concat[A]
class Drop[A]
class DropRight[A]
class Id[A]
class Map[A, B]
class Prepended[A]
class Reverse[A]
class Take[A]
class TakeRight[A]
Show all
Self type
IndexedSeqOps[A, CC, C]
trait IndexedSeqView[+A] extends IndexedSeqOps[A, View, View[A]], SeqView[A]

View defined in terms of indexing a range

View defined in terms of indexing a range

Attributes

Companion
object
Source
IndexedSeqView.scala
Supertypes
trait SeqView[A]
trait View[A]
trait Serializable
trait Iterable[A]
trait IndexedSeqOps[A, View, View[A]]
trait SeqOps[A, View, View[A]]
trait IterableOps[A, View, View[A]]
trait IterableOnceOps[A, View, View[A]]
trait IterableOnce[A]
class Object
trait Matchable
class Any
Show all
Known subtypes
class ArrayBufferView[A]
class Slice[A]
class StringView
class Appended[A]
class Concat[A]
class Drop[A]
class DropRight[A]
class Id[A]
class Map[A, B]
class Prepended[A]
class Reverse[A]
class Take[A]
class TakeRight[A]
Show all
Self type
object IndexedSeqView

Attributes

Companion
trait
Source
IndexedSeqView.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Self type
trait IntStepper extends Stepper[Int]

A Stepper for Ints.

A Stepper for Ints. See Stepper.

Attributes

Companion
object
Source
Stepper.scala
Supertypes
trait Stepper[Int]
class Object
trait Matchable
class Any
object IntStepper

Attributes

Companion
trait
Source
Stepper.scala
Supertypes
class Object
trait Matchable
class Any
Self type
IntStepper.type
trait Iterable[+A] extends IterableOnce[A], IterableOps[A, Iterable, Iterable[A]], IterableFactoryDefaults[A, Iterable]

Base trait for generic collections.

Base trait for generic collections.

Type parameters

A

the element type of the collection

Attributes

Companion
object
Source
Iterable.scala
Supertypes
trait IterableOps[A, Iterable, Iterable[A]]
trait IterableOnce[A]
class Object
trait Matchable
class Any
Show all
Known subtypes
trait Iterable[A]
trait Map[K, V]
class AbstractMap[K, V]
class HashMap[K, V]
class IntMap[T]
class ListMap[K, V]
class LongMap[T]
class Map1[K, V]
class Map2[K, V]
class Map3[K, V]
class Map4[K, V]
class WithDefault[K, V]
class WithDefault[K, V]
class TreeMap[K, V]
class TreeSeqMap[K, V]
class VectorMap[K, V]
trait SeqMap[K, V]
trait SortedMap[K, V]
trait Seq[A]
class AbstractSeq[A]
class ArraySeq[A]
class ofBoolean
class ofByte
class ofChar
class ofDouble
class ofFloat
class ofInt
class ofLong
class ofRef[T]
class ofShort
class ofUnit
class LazyList[A]
class List[A]
class ::[A]
object Nil
class NumericRange[T]
class Exclusive[T]
class Inclusive[T]
class Queue[A]
class Range
class Exclusive
class Inclusive
class Stream[A]
class Cons[A]
object Empty
class Vector[A]
trait IndexedSeq[A]
trait LinearSeq[A]
trait Set[A]
class AbstractSet[A]
class BitSet
class BitSet1
class BitSet2
class BitSetN
class HashSet[A]
class ListSet[A]
class Set1[A]
class Set2[A]
class Set3[A]
class Set4[A]
class TreeSet[A]
class ValueSet
trait SortedSet[A]
trait Iterable[A]
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]
class AbstractIterable[A]
class AbstractMap[K, V]
class AbstractSeq[A]
class AbstractSet[A]
class AbstractView[A]
class AbstractMapView[K, V]
class Filter[K, V]
class FilterKeys[K, V]
class Id[K, V]
class MapValues[K, V, W]
class TapEach[K, V, U]
class AbstractSeqView[A]
class ArrayBufferView[A]
class Slice[A]
class StringView
class Id[A]
class Id[A]
class Reverse[A]
class Reverse[A]
class Appended[A]
class Appended[A]
class Appended[A]
class Collect[A, B]
class Concat[A]
class Concat[A]
class Concat[A]
class DistinctBy[A, B]
class Drop[A]
class Drop[A]
class Drop[A]
class DropRight[A]
class DropRight[A]
class DropRight[A]
class DropWhile[A]
class Elems[A]
object Empty
class Fill[A]
class Filter[A]
class FlatMap[A, B]
class Iterate[A]
class LeftPartitionMapped[A, A1, A2]
class Map[A, B]
class Map[A, B]
class Map[A, B]
class PadTo[A]
class Prepended[A]
class Prepended[A]
class Prepended[A]
class RightPartitionMapped[A, A1, A2]
class ScanLeft[A, B]
class Single[A]
class Tabulate[A]
class Take[A]
class Take[A]
class Take[A]
class TakeRight[A]
class TakeRight[A]
class TakeRight[A]
class TakeWhile[A]
class Unfold[A, S]
class Updated[A]
class Zip[A, B]
class ZipAll[A, B]
class ZipWithIndex[A]
trait Map[K, V]
trait DefaultMap[K, V]
trait SeqMap[K, V]
trait SortedMap[K, V]
trait Seq[A]
trait IndexedSeq[A]
trait LinearSeq[A]
trait Set[A]
trait SortedSet[A]
trait BitSet
trait View[A]
trait MapView[K, V]
trait SeqView[A]
trait IndexedSeqView[A]
class Sorted[A, B]
Show all
object Iterable extends Delegate[Iterable]

Attributes

Companion
trait
Source
Iterable.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Show all
Self type
Iterable.type
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.

Base trait for companion objects of unconstrained collection types that may require multiple traversals of a source collection to build a target collection CC.

Type parameters

CC

Collection type constructor (e.g. List)

Attributes

Companion
object
Source
Factory.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Known subtypes
object HashSet
object ListSet
object Set
object HashSet
object LinkedHashSet
class AnySeqDelegate[CC]
class Delegate[CC]
object Iterable
object Iterable
object Set
object Iterable
object Set
object Iterator
trait SeqFactory[CC]
object LazyList
object Stream
class Delegate[CC]
object IndexedSeq
object LinearSeq
object Seq
object Buffer
object IndexedBuffer
object IndexedSeq
object Seq
object IndexedSeq
object LinearSeq
object Seq
object List
object Queue
object Vector
object ArrayBuffer
object ArrayDeque
object ListBuffer
object Queue
object Stack
object View
Show all
object IterableFactory

Attributes

Companion
trait
Source
Factory.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Self type
trait IterableFactoryDefaults[+A, +CC <: (IterableOps)] extends IterableOps[A, CC, CC[A]]

This trait provides default implementations for the factory methods fromSpecific and newSpecificBuilder that need to be refined when implementing a collection type that refines the CC and C type parameters.

This trait provides default implementations for the factory methods fromSpecific and newSpecificBuilder that need to be refined when implementing a collection type that refines the CC and C type parameters.

The default implementations in this trait can be used in the common case when CC[A] is the same as C.

Attributes

Source
Iterable.scala
Supertypes
trait IterableOps[A, CC, CC[A]]
trait IterableOnceOps[A, CC, CC[A]]
trait IterableOnce[A]
class Object
trait Matchable
class Any
Show all
Known subtypes
class HashSet[A]
trait IndexedSeq[A]
class ArraySeq[A]
class ofBoolean
class ofByte
class ofChar
class ofDouble
class ofFloat
class ofInt
class ofLong
class ofRef[T]
class ofShort
class ofUnit
class NumericRange[T]
class Exclusive[T]
class Inclusive[T]
class Range
class Exclusive
class Inclusive
class Vector[A]
trait Iterable[A]
trait Map[K, V]
class AbstractMap[K, V]
class HashMap[K, V]
class IntMap[T]
class ListMap[K, V]
class LongMap[T]
class Map1[K, V]
class Map2[K, V]
class Map3[K, V]
class Map4[K, V]
class WithDefault[K, V]
class WithDefault[K, V]
class TreeMap[K, V]
class TreeSeqMap[K, V]
class VectorMap[K, V]
trait SeqMap[K, V]
trait SortedMap[K, V]
trait Seq[A]
class AbstractSeq[A]
class LazyList[A]
class List[A]
class ::[A]
object Nil
class Queue[A]
class Stream[A]
class Cons[A]
object Empty
trait LinearSeq[A]
trait Set[A]
class AbstractSet[A]
class BitSet
class BitSet1
class BitSet2
class BitSetN
class ListSet[A]
class Set1[A]
class Set2[A]
class Set3[A]
class Set4[A]
class TreeSet[A]
class ValueSet
trait SortedSet[A]
class ArrayBuffer[A]
class ArrayDeque[A]
class Queue[A]
class Stack[A]
trait Buffer[A]
class AbstractBuffer[A]
class ListBuffer[A]
class UnrolledBuffer[T]
trait IndexedBuffer[A]
class HashSet[A]
trait IndexedSeq[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 Iterable[A]
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 Accumulator[A, CC, C]
class AnyAccumulator[A]
trait Set[A]
class AbstractSet[A]
class BitSet
class LinkedHashSet[A]
class TreeSet[A]
trait SortedSet[A]
trait IndexedSeq[A]
trait Iterable[A]
class AbstractIterable[A]
class AbstractMap[K, V]
class AbstractSeq[A]
class AbstractSet[A]
class AbstractView[A]
class AbstractMapView[K, V]
class Filter[K, V]
class FilterKeys[K, V]
class Id[K, V]
class MapValues[K, V, W]
class TapEach[K, V, U]
class AbstractSeqView[A]
class ArrayBufferView[A]
class Slice[A]
class StringView
class Id[A]
class Id[A]
class Reverse[A]
class Reverse[A]
class Appended[A]
class Appended[A]
class Appended[A]
class Collect[A, B]
class Concat[A]
class Concat[A]
class Concat[A]
class DistinctBy[A, B]
class Drop[A]
class Drop[A]
class Drop[A]
class DropRight[A]
class DropRight[A]
class DropRight[A]
class DropWhile[A]
class Elems[A]
object Empty
class Fill[A]
class Filter[A]
class FlatMap[A, B]
class Iterate[A]
class LeftPartitionMapped[A, A1, A2]
class Map[A, B]
class Map[A, B]
class Map[A, B]
class PadTo[A]
class Prepended[A]
class Prepended[A]
class Prepended[A]
class RightPartitionMapped[A, A1, A2]
class ScanLeft[A, B]
class Single[A]
class Tabulate[A]
class Take[A]
class Take[A]
class Take[A]
class TakeRight[A]
class TakeRight[A]
class TakeRight[A]
class TakeWhile[A]
class Unfold[A, S]
class Updated[A]
class Zip[A, B]
class ZipAll[A, B]
class ZipWithIndex[A]
trait Map[K, V]
trait DefaultMap[K, V]
trait SeqMap[K, V]
trait SortedMap[K, V]
trait Seq[A]
trait LinearSeq[A]
trait Set[A]
trait SortedSet[A]
trait BitSet
trait View[A]
trait MapView[K, V]
trait SeqView[A]
trait IndexedSeqView[A]
class Sorted[A, B]
Show all
trait IterableOnce[+A]

A template trait for collections which can be traversed either once only or one or more times.

A template trait for collections which can be traversed either once only or one or more times.

Note: IterableOnce does not extend IterableOnceOps. This is different than the general design of the collections library, which uses the following pattern:

trait Seq extends Iterable with SeqOps
trait SeqOps extends IterableOps

trait IndexedSeq extends Seq with IndexedSeqOps
trait IndexedSeqOps extends SeqOps

The goal is to provide a minimal interface without any sequential operations. This allows third-party extension like Scala parallel collections to integrate at the level of IterableOnce without inheriting unwanted implementations.

Attributes

Companion
object
Source
IterableOnce.scala
Supertypes
class Any
Known subtypes
trait Iterable[A]
trait Iterable[A]
trait Map[K, V]
class AbstractMap[K, V]
class HashMap[K, V]
class IntMap[T]
class ListMap[K, V]
class LongMap[T]
class Map1[K, V]
class Map2[K, V]
class Map3[K, V]
class Map4[K, V]
class WithDefault[K, V]
class WithDefault[K, V]
class TreeMap[K, V]
class TreeSeqMap[K, V]
class VectorMap[K, V]
trait SeqMap[K, V]
trait SortedMap[K, V]
trait Seq[A]
class AbstractSeq[A]
class ArraySeq[A]
class ofBoolean
class ofByte
class ofChar
class ofDouble
class ofFloat
class ofInt
class ofLong
class ofRef[T]
class ofShort
class ofUnit
class LazyList[A]
class List[A]
class ::[A]
object Nil
class NumericRange[T]
class Exclusive[T]
class Inclusive[T]
class Queue[A]
class Range
class Exclusive
class Inclusive
class Stream[A]
class Cons[A]
object Empty
class Vector[A]
trait IndexedSeq[A]
trait LinearSeq[A]
trait Set[A]
class AbstractSet[A]
class BitSet
class BitSet1
class BitSet2
class BitSetN
class HashSet[A]
class ListSet[A]
class Set1[A]
class Set2[A]
class Set3[A]
class Set4[A]
class TreeSet[A]
class ValueSet
trait SortedSet[A]
trait Iterable[A]
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]
class AbstractIterable[A]
class AbstractMap[K, V]
class AbstractSeq[A]
class AbstractSet[A]
class AbstractView[A]
class AbstractMapView[K, V]
class Filter[K, V]
class FilterKeys[K, V]
class Id[K, V]
class MapValues[K, V, W]
class TapEach[K, V, U]
class AbstractSeqView[A]
class ArrayBufferView[A]
class Slice[A]
class StringView
class Id[A]
class Id[A]
class Reverse[A]
class Reverse[A]
class Appended[A]
class Appended[A]
class Appended[A]
class Collect[A, B]
class Concat[A]
class Concat[A]
class Concat[A]
class DistinctBy[A, B]
class Drop[A]
class Drop[A]
class Drop[A]
class DropRight[A]
class DropRight[A]
class DropRight[A]
class DropWhile[A]
class Elems[A]
object Empty
class Fill[A]
class Filter[A]
class FlatMap[A, B]
class Iterate[A]
class LeftPartitionMapped[A, A1, A2]
class Map[A, B]
class Map[A, B]
class Map[A, B]
class PadTo[A]
class Prepended[A]
class Prepended[A]
class Prepended[A]
class RightPartitionMapped[A, A1, A2]
class ScanLeft[A, B]
class Single[A]
class Tabulate[A]
class Take[A]
class Take[A]
class Take[A]
class TakeRight[A]
class TakeRight[A]
class TakeRight[A]
class TakeWhile[A]
class Unfold[A, S]
class Updated[A]
class Zip[A, B]
class ZipAll[A, B]
class ZipWithIndex[A]
trait Map[K, V]
trait DefaultMap[K, V]
trait SeqMap[K, V]
trait SortedMap[K, V]
trait Seq[A]
trait IndexedSeq[A]
trait LinearSeq[A]
trait Set[A]
trait SortedSet[A]
trait BitSet
trait View[A]
trait MapView[K, V]
trait SeqView[A]
trait IndexedSeqView[A]
class Sorted[A, B]
trait IterableOps[A, CC, C]
trait MapOps[K, V, CC, C]
trait SortedMapOps[K, V, CC, C]
trait StrictOptimizedSortedMapOps[K, V, CC, C]
trait StrictOptimizedMapOps[K, V, CC, C]
trait MapOps[K, V, CC, C]
trait SortedMapOps[K, V, CC, C]
trait SetOps[A, CC, C]
trait SortedSetOps[A, CC, C]
trait MapFactoryDefaults[K, V, CC, WithFilterCC]
class WeakHashMap[K, V]
trait MapOps[K, V, CC, C]
trait SortedMapFactoryDefaults[K, V, CC, WithFilterCC, UnsortedCC]
trait SortedMapOps[K, V, CC, C]
trait StrictOptimizedSortedMapOps[K, V, CC, C]
trait StrictOptimizedMapOps[K, V, CC, C]
trait SeqOps[A, CC, C]
trait SeqOps[A, CC, C]
trait IndexedSeqOps[A, CC, C]
trait LinearSeqOps[A, CC, C]
trait StrictOptimizedSeqOps[A, CC, C]
trait SeqOps[A, CC, C]
trait IndexedSeqOps[A, CC, C]
trait IndexedSeqOps[A, CC, C]
trait LinearSeqOps[A, CC, C]
trait StrictOptimizedLinearSeqOps[A, CC, C]
trait StrictOptimizedSeqOps[A, CC, C]
trait ArrayDequeOps[A, CC, C]
trait SetOps[A, CC, C]
trait SetOps[A, CC, C]
trait SortedSetOps[A, CC, C]
trait StrictOptimizedSortedSetOps[A, CC, C]
trait StrictOptimizedSetOps[A, CC, C]
trait SortedSetOps[A, CC, C]
trait BitSetOps[C]
trait SortedSetFactoryDefaults[A, CC, WithFilterCC]
trait StrictOptimizedSortedSetOps[A, CC, C]
trait StrictOptimizedSetOps[A, CC, C]
trait StrictOptimizedIterableOps[A, CC, C]
trait Iterator[A]
class AbstractIterator[A]
class GroupedIterator[B]
class LineIterator
trait BufferedIterator[A]
class Source
class Option[A]
object None
class Some[A]
Show all
object IterableOnce

Attributes

Companion
trait
Source
IterableOnce.scala
Supertypes
class Object
trait Matchable
class Any
Self type
final class IterableOnceExtensionMethods[A](it: IterableOnce[A]) extends AnyVal

Attributes

Source
IterableOnce.scala
Supertypes
class AnyVal
trait Matchable
class Any
trait IterableOnceOps[+A, +CC[_], +C]

This implementation trait can be mixed into an IterableOnce to get the basic methods that are shared between Iterator and Iterable.

This implementation trait can be mixed into an IterableOnce to get the basic methods that are shared between Iterator and Iterable. The IterableOnce must support multiple calls to iterator but may or may not return the same Iterator every time.

Attributes

Source
IterableOnce.scala
Supertypes
class Any
Known subtypes
trait IterableOps[A, CC, C]
trait Iterable[A]
trait Map[K, V]
class AbstractMap[K, V]
class HashMap[K, V]
class IntMap[T]
class ListMap[K, V]
class LongMap[T]
class Map1[K, V]
class Map2[K, V]
class Map3[K, V]
class Map4[K, V]
class WithDefault[K, V]
class WithDefault[K, V]
class TreeMap[K, V]
class TreeSeqMap[K, V]
class VectorMap[K, V]
trait SeqMap[K, V]
trait SortedMap[K, V]
trait Seq[A]
class AbstractSeq[A]
class ArraySeq[A]
class ofBoolean
class ofByte
class ofChar
class ofDouble
class ofFloat
class ofInt
class ofLong
class ofRef[T]
class ofShort
class ofUnit
class LazyList[A]
class List[A]
class ::[A]
object Nil
class NumericRange[T]
class Exclusive[T]
class Inclusive[T]
class Queue[A]
class Range
class Exclusive
class Inclusive
class Stream[A]
class Cons[A]
object Empty
class Vector[A]
trait IndexedSeq[A]
trait LinearSeq[A]
trait Set[A]
class AbstractSet[A]
class BitSet
class BitSet1
class BitSet2
class BitSetN
class HashSet[A]
class ListSet[A]
class Set1[A]
class Set2[A]
class Set3[A]
class Set4[A]
class TreeSet[A]
class ValueSet
trait SortedSet[A]
trait MapOps[K, V, CC, C]
trait SortedMapOps[K, V, CC, C]
trait StrictOptimizedSortedMapOps[K, V, CC, C]
trait StrictOptimizedMapOps[K, V, CC, C]
trait Iterable[A]
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]
trait MapOps[K, V, CC, C]
trait SortedMapOps[K, V, CC, C]
trait SetOps[A, CC, C]
trait SortedSetOps[A, CC, C]
trait Iterable[A]
class AbstractIterable[A]
class AbstractMap[K, V]
class AbstractSeq[A]
class AbstractSet[A]
class AbstractView[A]
class AbstractMapView[K, V]
class Filter[K, V]
class FilterKeys[K, V]
class Id[K, V]
class MapValues[K, V, W]
class TapEach[K, V, U]
class AbstractSeqView[A]
class ArrayBufferView[A]
class Slice[A]
class StringView
class Id[A]
class Id[A]
class Reverse[A]
class Reverse[A]
class Appended[A]
class Appended[A]
class Appended[A]
class Collect[A, B]
class Concat[A]
class Concat[A]
class Concat[A]
class DistinctBy[A, B]
class Drop[A]
class Drop[A]
class Drop[A]
class DropRight[A]
class DropRight[A]
class DropRight[A]
class DropWhile[A]
class Elems[A]
object Empty
class Fill[A]
class Filter[A]
class FlatMap[A, B]
class Iterate[A]
class LeftPartitionMapped[A, A1, A2]
class Map[A, B]
class Map[A, B]
class Map[A, B]
class PadTo[A]
class Prepended[A]
class Prepended[A]
class Prepended[A]
class RightPartitionMapped[A, A1, A2]
class ScanLeft[A, B]
class Single[A]
class Tabulate[A]
class Take[A]
class Take[A]
class Take[A]
class TakeRight[A]
class TakeRight[A]
class TakeRight[A]
class TakeWhile[A]
class Unfold[A, S]
class Updated[A]
class Zip[A, B]
class ZipAll[A, B]
class ZipWithIndex[A]
trait Map[K, V]
trait DefaultMap[K, V]
trait SeqMap[K, V]
trait SortedMap[K, V]
trait Seq[A]
trait IndexedSeq[A]
trait LinearSeq[A]
trait Set[A]
trait SortedSet[A]
trait BitSet
trait View[A]
trait MapView[K, V]
trait SeqView[A]
trait IndexedSeqView[A]
class Sorted[A, B]
trait MapFactoryDefaults[K, V, CC, WithFilterCC]
class WeakHashMap[K, V]
trait MapOps[K, V, CC, C]
trait SortedMapFactoryDefaults[K, V, CC, WithFilterCC, UnsortedCC]
trait SortedMapOps[K, V, CC, C]
trait StrictOptimizedSortedMapOps[K, V, CC, C]
trait StrictOptimizedMapOps[K, V, CC, C]
trait SeqOps[A, CC, C]
trait SeqOps[A, CC, C]
trait IndexedSeqOps[A, CC, C]
trait LinearSeqOps[A, CC, C]
trait StrictOptimizedSeqOps[A, CC, C]
trait SeqOps[A, CC, C]
trait IndexedSeqOps[A, CC, C]
trait IndexedSeqOps[A, CC, C]
trait LinearSeqOps[A, CC, C]
trait StrictOptimizedLinearSeqOps[A, CC, C]
trait StrictOptimizedSeqOps[A, CC, C]
trait ArrayDequeOps[A, CC, C]
trait SetOps[A, CC, C]
trait SetOps[A, CC, C]
trait SortedSetOps[A, CC, C]
trait StrictOptimizedSortedSetOps[A, CC, C]
trait StrictOptimizedSetOps[A, CC, C]
trait SortedSetOps[A, CC, C]
trait BitSetOps[C]
trait SortedSetFactoryDefaults[A, CC, WithFilterCC]
trait StrictOptimizedSortedSetOps[A, CC, C]
trait StrictOptimizedSetOps[A, CC, C]
trait StrictOptimizedIterableOps[A, CC, C]
trait Iterator[A]
class AbstractIterator[A]
class GroupedIterator[B]
class LineIterator
trait BufferedIterator[A]
class Source
Show all
Self type
trait IterableOps[+A, +CC[_], +C] extends IterableOnce[A], IterableOnceOps[A, CC, C]

Base trait for Iterable operations

Base trait for Iterable operations

VarianceNote

We require that for all child classes of Iterable the variance of the child class and the variance of the C parameter passed to IterableOps are the same. We cannot express this since we lack variance polymorphism. That's why we have to resort at some places to write C[A @uncheckedVariance].

Type parameters

C

type of the collection (e.g. List[Int], String, BitSet). Operations returning a collection with the same type of element (e.g. drop, filter) return a C.

CC

type constructor of the collection (e.g. List, Set). Operations returning a collection with a different type of element B (e.g. map) return a CC[B].

Attributes

Companion
object
Source
Iterable.scala
Supertypes
trait IterableOnceOps[A, CC, C]
trait IterableOnce[A]
class Any
Known subtypes
trait Iterable[A]
trait Map[K, V]
class AbstractMap[K, V]
class HashMap[K, V]
class IntMap[T]
class ListMap[K, V]
class LongMap[T]
class Map1[K, V]
class Map2[K, V]
class Map3[K, V]
class Map4[K, V]
class WithDefault[K, V]
class WithDefault[K, V]
class TreeMap[K, V]
class TreeSeqMap[K, V]
class VectorMap[K, V]
trait SeqMap[K, V]
trait SortedMap[K, V]
trait Seq[A]
class AbstractSeq[A]
class ArraySeq[A]
class ofBoolean
class ofByte
class ofChar
class ofDouble
class ofFloat
class ofInt
class ofLong
class ofRef[T]
class ofShort
class ofUnit
class LazyList[A]
class List[A]
class ::[A]
object Nil
class NumericRange[T]
class Exclusive[T]
class Inclusive[T]
class Queue[A]
class Range
class Exclusive
class Inclusive
class Stream[A]
class Cons[A]
object Empty
class Vector[A]
trait IndexedSeq[A]
trait LinearSeq[A]
trait Set[A]
class AbstractSet[A]
class BitSet
class BitSet1
class BitSet2
class BitSetN
class HashSet[A]
class ListSet[A]
class Set1[A]
class Set2[A]
class Set3[A]
class Set4[A]
class TreeSet[A]
class ValueSet
trait SortedSet[A]
trait MapOps[K, V, CC, C]
trait SortedMapOps[K, V, CC, C]
trait StrictOptimizedSortedMapOps[K, V, CC, C]
trait StrictOptimizedMapOps[K, V, CC, C]
trait Iterable[A]
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]
trait MapOps[K, V, CC, C]
trait SortedMapOps[K, V, CC, C]
trait SetOps[A, CC, C]
trait SortedSetOps[A, CC, C]
trait Iterable[A]
class AbstractIterable[A]
class AbstractMap[K, V]
class AbstractSeq[A]
class AbstractSet[A]
class AbstractView[A]
class AbstractMapView[K, V]
class Filter[K, V]
class FilterKeys[K, V]
class Id[K, V]
class MapValues[K, V, W]
class TapEach[K, V, U]
class AbstractSeqView[A]
class ArrayBufferView[A]
class Slice[A]
class StringView
class Id[A]
class Id[A]
class Reverse[A]
class Reverse[A]
class Appended[A]
class Appended[A]
class Appended[A]
class Collect[A, B]
class Concat[A]
class Concat[A]
class Concat[A]
class DistinctBy[A, B]
class Drop[A]
class Drop[A]
class Drop[A]
class DropRight[A]
class DropRight[A]
class DropRight[A]
class DropWhile[A]
class Elems[A]
object Empty
class Fill[A]
class Filter[A]
class FlatMap[A, B]
class Iterate[A]
class LeftPartitionMapped[A, A1, A2]
class Map[A, B]
class Map[A, B]
class Map[A, B]
class PadTo[A]
class Prepended[A]
class Prepended[A]
class Prepended[A]
class RightPartitionMapped[A, A1, A2]
class ScanLeft[A, B]
class Single[A]
class Tabulate[A]
class Take[A]
class Take[A]
class Take[A]
class TakeRight[A]
class TakeRight[A]
class TakeRight[A]
class TakeWhile[A]
class Unfold[A, S]
class Updated[A]
class Zip[A, B]
class ZipAll[A, B]
class ZipWithIndex[A]
trait Map[K, V]
trait DefaultMap[K, V]
trait SeqMap[K, V]
trait SortedMap[K, V]
trait Seq[A]
trait IndexedSeq[A]
trait LinearSeq[A]
trait Set[A]
trait SortedSet[A]
trait BitSet
trait View[A]
trait MapView[K, V]
trait SeqView[A]
trait IndexedSeqView[A]
class Sorted[A, B]
trait MapFactoryDefaults[K, V, CC, WithFilterCC]
class WeakHashMap[K, V]
trait MapOps[K, V, CC, C]
trait SortedMapFactoryDefaults[K, V, CC, WithFilterCC, UnsortedCC]
trait SortedMapOps[K, V, CC, C]
trait StrictOptimizedSortedMapOps[K, V, CC, C]
trait StrictOptimizedMapOps[K, V, CC, C]
trait SeqOps[A, CC, C]
trait SeqOps[A, CC, C]
trait IndexedSeqOps[A, CC, C]
trait LinearSeqOps[A, CC, C]
trait StrictOptimizedSeqOps[A, CC, C]
trait SeqOps[A, CC, C]
trait IndexedSeqOps[A, CC, C]
trait IndexedSeqOps[A, CC, C]
trait LinearSeqOps[A, CC, C]
trait StrictOptimizedLinearSeqOps[A, CC, C]
trait StrictOptimizedSeqOps[A, CC, C]
trait ArrayDequeOps[A, CC, C]
trait SetOps[A, CC, C]
trait SetOps[A, CC, C]
trait SortedSetOps[A, CC, C]
trait StrictOptimizedSortedSetOps[A, CC, C]
trait StrictOptimizedSetOps[A, CC, C]
trait SortedSetOps[A, CC, C]
trait BitSetOps[C]
trait SortedSetFactoryDefaults[A, CC, WithFilterCC]
trait StrictOptimizedSortedSetOps[A, CC, C]
trait StrictOptimizedSetOps[A, CC, C]
trait StrictOptimizedIterableOps[A, CC, C]
Show all
object IterableOps

Attributes

Companion
trait
Source
Iterable.scala
Supertypes
class Object
trait Matchable
class Any
Self type
trait Iterator[+A] extends IterableOnce[A], IterableOnceOps[A, Iterator, Iterator[A]]

Iterators are data structures that allow to iterate over a sequence of elements.

Iterators are data structures that allow to iterate over a sequence of elements. They have a hasNext method for checking if there is a next element available, and a next method which returns the next element and advances the iterator.

An iterator is mutable: most operations on it change its state. While it is often used to iterate through the elements of a collection, it can also be used without being backed by any collection (see constructors on the companion object).

It is of particular importance to note that, unless stated otherwise, one should never use an iterator after calling a method on it. The two most important exceptions are also the sole abstract methods: next and hasNext.

Both these methods can be called any number of times without having to discard the iterator. Note that even hasNext may cause mutation -- such as when iterating from an input stream, where it will block until the stream is closed or some input becomes available.

Consider this example for safe and unsafe use:

def f[A](it: Iterator[A]) = {
 if (it.hasNext) {            // Safe to reuse "it" after "hasNext"
   it.next()                  // Safe to reuse "it" after "next"
   val remainder = it.drop(2) // it is *not* safe to use "it" again after this line!
   remainder.take(2)          // it is *not* safe to use "remainder" after this line!
 } else it
}

Attributes

Companion
object
Source
Iterator.scala
Supertypes
trait IterableOnce[A]
class Object
trait Matchable
class Any
Known subtypes
class AbstractIterator[A]
class GroupedIterator[B]
class LineIterator
trait BufferedIterator[A]
class Source
Show all
Self type
object Iterator extends IterableFactory[Iterator]

Attributes

Companion
trait
Source
Iterator.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Self type
Iterator.type
final class LazyZip2[+El1, +El2, C1]

Decorator representing lazily zipped pairs.

Decorator representing lazily zipped pairs.

Attributes

Companion
object
Source
LazyZipOps.scala
Supertypes
class Object
trait Matchable
class Any
object LazyZip2

Attributes

Companion
class
Source
LazyZipOps.scala
Supertypes
class Object
trait Matchable
class Any
Self type
LazyZip2.type
final class LazyZip3[+El1, +El2, +El3, C1]

Decorator representing lazily zipped triples.

Decorator representing lazily zipped triples.

Attributes

Companion
object
Source
LazyZipOps.scala
Supertypes
class Object
trait Matchable
class Any
object LazyZip3

Attributes

Companion
class
Source
LazyZipOps.scala
Supertypes
class Object
trait Matchable
class Any
Self type
LazyZip3.type
final class LazyZip4[+El1, +El2, +El3, +El4, C1]

Decorator representing lazily zipped 4-tuples.

Decorator representing lazily zipped 4-tuples.

Attributes

Companion
object
Source
LazyZipOps.scala
Supertypes
class Object
trait Matchable
class Any
object LazyZip4

Attributes

Companion
class
Source
LazyZipOps.scala
Supertypes
class Object
trait Matchable
class Any
Self type
LazyZip4.type
trait LinearSeq[+A] extends Seq[A], LinearSeqOps[A, LinearSeq, LinearSeq[A]], IterableFactoryDefaults[A, LinearSeq]

Base trait for linearly accessed sequences that have efficient head and tail operations.

Base trait for linearly accessed sequences that have efficient head and tail operations. Known subclasses: List, LazyList

Attributes

Companion
object
Source
LinearSeq.scala
Supertypes
trait Seq[A]
trait Equals
trait SeqOps[A, LinearSeq, LinearSeq[A]]
trait PartialFunction[Int, A]
trait Int => A
trait Iterable[A]
trait IterableOnce[A]
class Object
trait Matchable
class Any
Show all
Known subtypes
trait LinearSeq[A]
class LazyList[A]
class List[A]
class ::[A]
object Nil
class Queue[A]
class Stream[A]
class Cons[A]
object Empty
Show all
object LinearSeq extends Delegate[LinearSeq]

Attributes

Companion
trait
Source
LinearSeq.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Show all
Self type
LinearSeq.type
trait LinearSeqOps[+A, +CC <: (LinearSeq), +C <: LinearSeq[A] & LinearSeqOps[A, CC, C]] extends SeqOps[A, CC, C]

Base trait for linear Seq operations

Base trait for linear Seq operations

Attributes

Source
LinearSeq.scala
Supertypes
trait SeqOps[A, CC, C]
trait IterableOps[A, CC, C]
trait IterableOnceOps[A, CC, C]
trait IterableOnce[A]
class Any
Known subtypes
trait LinearSeqOps[A, CC, C]
class LazyList[A]
trait LinearSeq[A]
class List[A]
class ::[A]
object Nil
class Queue[A]
class Stream[A]
class Cons[A]
object Empty
trait LinearSeq[A]
trait StrictOptimizedLinearSeqOps[A, CC, C]
Show all
trait LongStepper extends Stepper[Long]

A Stepper for Longs.

A Stepper for Longs. See Stepper.

Attributes

Companion
object
Source
Stepper.scala
Supertypes
trait Stepper[Long]
class Object
trait Matchable
class Any
object LongStepper

Attributes

Companion
trait
Source
Stepper.scala
Supertypes
class Object
trait Matchable
class Any
Self type
trait Map[K, +V] extends Iterable[(K, V)], MapOps[K, V, Map, Map[K, V]], MapFactoryDefaults[K, V, Map, Iterable], Equals

Base Map type

Base Map type

Attributes

Companion
object
Source
Map.scala
Supertypes
trait Equals
trait MapOps[K, V, Map, Map[K, V]]
trait PartialFunction[K, V]
trait 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 AbstractMap[K, V]
class HashMap[K, V]
class IntMap[T]
class ListMap[K, V]
class LongMap[T]
class Map1[K, V]
class Map2[K, V]
class Map3[K, V]
class Map4[K, V]
class WithDefault[K, V]
class WithDefault[K, V]
class TreeMap[K, V]
class TreeSeqMap[K, V]
class VectorMap[K, V]
trait SeqMap[K, V]
trait SortedMap[K, V]
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]
class AbstractMap[K, V]
trait DefaultMap[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 MapFactory[+CC[_, _]] extends Serializable

Attributes

Companion
object
Source
Factory.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Known subtypes
object TrieMap
object HashMap
object ListMap
object Map
object SeqMap
object TreeSeqMap
object VectorMap
object HashMap
object LinkedHashMap
object ListMap
object OpenHashMap
object WeakHashMap
class Delegate[C]
object Map
object SeqMap
object Map
object SeqMap
object MapView
Show all
object MapFactory

Attributes

Companion
trait
Source
Factory.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Self type
MapFactory.type
trait MapFactoryDefaults[K, +V, +CC <: ([x, y] =>> IterableOps[(x, y), Iterable, Iterable[(x, y)]]), +WithFilterCC <: ([x] =>> IterableOps[x, WithFilterCC, WithFilterCC[x]] & Iterable[x])] extends MapOps[K, V, CC, CC[K, V]], IterableOps[(K, V), WithFilterCC, CC[K, V]]

This trait provides default implementations for the factory methods fromSpecific and newSpecificBuilder that need to be refined when implementing a collection type that refines the CC and C type parameters.

This trait provides default implementations for the factory methods fromSpecific and newSpecificBuilder that need to be refined when implementing a collection type that refines the CC and C type parameters. It is used for maps.

Note that in maps, the CC type of the map is not the same as the CC type for the underlying iterable (which is fixed to Map in MapOps). This trait has therefore two type parameters CC and WithFilterCC. The withFilter method inherited from IterableOps is overridden with a compatible default implementation.

The default implementations in this trait can be used in the common case when CC[A] is the same as C.

Attributes

Source
Iterable.scala
Supertypes
trait MapOps[K, V, CC, CC[K, V]]
trait PartialFunction[K, V]
trait K => V
trait IterableOps[(K, V), WithFilterCC, CC[K, V]]
trait IterableOnceOps[(K, V), WithFilterCC, CC[K, V]]
trait IterableOnce[(K, V)]
class Object
trait Matchable
class Any
Show all
Known subtypes
class TrieMap[K, V]
class HashMap[K, V]
class ListMap[K, V]
trait Map[K, V]
class AbstractMap[K, V]
class IntMap[T]
class LongMap[T]
class Map1[K, V]
class Map2[K, V]
class Map3[K, V]
class Map4[K, V]
class WithDefault[K, V]
class WithDefault[K, V]
class TreeMap[K, V]
class TreeSeqMap[K, V]
class VectorMap[K, V]
trait SeqMap[K, V]
trait SortedMap[K, V]
class HashMap[K, V]
class LinkedHashMap[K, V]
class ListMap[K, V]
trait Map[K, V]
trait Map[K, V]
class AbstractMap[K, V]
class AnyRefMap[K, V]
class CollisionProofHashMap[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]
class WeakHashMap[K, V]
trait Map[K, V]
class AbstractMap[K, V]
trait DefaultMap[K, V]
trait SeqMap[K, V]
trait SortedMap[K, V]
Show all
trait MapOps[K, +V, +CC <: ([_, _] =>> IterableOps[_, AnyConstr, _]), +C] extends IterableOps[(K, V), Iterable, C], PartialFunction[K, V]

Base Map implementation type

Base Map implementation type

Type parameters

C

type of the map (e.g. HashMap[Int, String]). Operations returning a collection with the same type of element (e.g. drop, filter) return a C.

CC

type constructor of the map (e.g. HashMap). Operations returning a collection with a different type of entries (L, W) (e.g. map) return a CC[L, W].

K

Type of keys

V

Type of values

Attributes

Companion
object
Source
Map.scala
Supertypes
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 MapOps[K, V, CC, C]
trait Map[K, V]
class AbstractMap[K, V]
class HashMap[K, V]
class IntMap[T]
class ListMap[K, V]
class LongMap[T]
class Map1[K, V]
class Map2[K, V]
class Map3[K, V]
class Map4[K, V]
class WithDefault[K, V]
class WithDefault[K, V]
class TreeMap[K, V]
class TreeSeqMap[K, V]
class VectorMap[K, V]
trait SeqMap[K, V]
trait SortedMap[K, V]
trait SortedMapOps[K, V, CC, C]
trait StrictOptimizedSortedMapOps[K, V, CC, C]
trait StrictOptimizedMapOps[K, V, CC, C]
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]
trait Map[K, V]
class AbstractMap[K, V]
trait DefaultMap[K, V]
trait SeqMap[K, V]
trait SortedMap[K, V]
trait MapFactoryDefaults[K, V, CC, WithFilterCC]
class WeakHashMap[K, V]
trait MapView[K, V]
class AbstractMapView[K, V]
class Filter[K, V]
class FilterKeys[K, V]
class Id[K, V]
class MapValues[K, V, W]
class TapEach[K, V, U]
trait SortedMapFactoryDefaults[K, V, CC, WithFilterCC, UnsortedCC]
trait SortedMapOps[K, V, CC, C]
trait StrictOptimizedSortedMapOps[K, V, CC, C]
trait StrictOptimizedMapOps[K, V, CC, C]
Show all
object MapOps

Attributes

Companion
trait
Source
Map.scala
Supertypes
class Object
trait Matchable
class Any
Self type
MapOps.type
trait MapView[K, +V] extends MapOps[K, V, { type l = [X, Y] =>> View[(X, Y)]; }#<none>, View[(K, V)]], View[(K, V)]

Attributes

Companion
object
Source
MapView.scala
Supertypes
trait View[(K, V)]
trait Serializable
trait Iterable[(K, V)]
trait IterableFactoryDefaults[(K, V), View]
trait MapOps[K, V, { type l = [X, Y] =>> View[(X, Y)]; }#<none>, View[(K, V)]]
trait PartialFunction[K, V]
trait K => V
trait IterableOps[(K, V), View, View[(K, V)]]
trait IterableOnceOps[(K, V), View, View[(K, V)]]
trait IterableOnce[(K, V)]
class Object
trait Matchable
class Any
Show all
Known subtypes
class AbstractMapView[K, V]
class Filter[K, V]
class FilterKeys[K, V]
class Id[K, V]
class MapValues[K, V, W]
class TapEach[K, V, U]
Show all
object MapView extends MapViewFactory

Attributes

Companion
trait
Source
MapView.scala
Supertypes
trait MapFactory[{ type l = [X, Y] =>> View[(X, Y)]; }#<none>]
trait Serializable
class Object
trait Matchable
class Any
Show all
Self type
MapView.type
trait MapViewFactory extends MapFactory[{ type l = [X, Y] =>> View[(X, Y)]; }#<none>]

Attributes

Source
MapView.scala
Supertypes
trait MapFactory[{ type l = [X, Y] =>> View[(X, Y)]; }#<none>]
trait Serializable
class Object
trait Matchable
class Any
Known subtypes
object MapView
object Searching

Attributes

Source
Searching.scala
Supertypes
class Object
trait Matchable
class Any
Self type
Searching.type
trait Seq[+A] extends Iterable[A], PartialFunction[Int, A], SeqOps[A, Seq, Seq[A]], IterableFactoryDefaults[A, Seq], Equals

Base trait for sequence collections

Base trait for sequence collections

Type parameters

A

the element type of the collection

Attributes

Companion
object
Source
Seq.scala
Supertypes
trait Equals
trait SeqOps[A, Seq, Seq[A]]
trait PartialFunction[Int, A]
trait Int => 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
trait Seq[A]
class AbstractSeq[A]
class ArraySeq[A]
class ofBoolean
class ofByte
class ofChar
class ofDouble
class ofFloat
class ofInt
class ofLong
class ofRef[T]
class ofShort
class ofUnit
class LazyList[A]
class List[A]
class ::[A]
object Nil
class NumericRange[T]
class Exclusive[T]
class Inclusive[T]
class Queue[A]
class Range
class Exclusive
class Inclusive
class Stream[A]
class Cons[A]
object Empty
class Vector[A]
trait IndexedSeq[A]
trait LinearSeq[A]
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]
class AbstractSeq[A]
trait IndexedSeq[A]
trait LinearSeq[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 SeqFactory[+CC <: (SeqOps)] extends IterableFactory[CC]

Type parameters

CC

Collection type constructor (e.g. List)

Attributes

Companion
object
Source
Factory.scala
Supertypes
trait IterableFactory[CC]
trait Serializable
class Object
trait Matchable
class Any
Known subtypes
object LazyList
object Stream
class AnySeqDelegate[CC]
class Delegate[CC]
object IndexedSeq
object LinearSeq
object Seq
object Buffer
object IndexedBuffer
object IndexedSeq
object Seq
object IndexedSeq
object LinearSeq
object Seq
object List
object Queue
object Vector
object ArrayBuffer
object ArrayDeque
object ListBuffer
object Queue
object Stack
Show all
object SeqFactory

Attributes

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

A generic trait for ordered maps.

A generic trait for ordered 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 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 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
trait SeqMap[K, V]
class ListMap[K, V]
class TreeSeqMap[K, V]
class VectorMap[K, V]
trait SeqMap[K, V]
class LinkedHashMap[K, V]
Show all
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] extends IterableOps[A, CC, C]

Base trait for Seq operations

Base trait for Seq operations

Type parameters

A

the element type of the collection

C

type of the collection (e.g. List[Int], String, BitSet). Operations returning a collection with the same type of element (e.g. drop, filter) return a C.

CC

type constructor of the collection (e.g. List, Set). Operations returning a collection with a different type of element B (e.g. map) return a CC[B].

Attributes

Companion
object
Source
Seq.scala
Supertypes
trait IterableOps[A, CC, C]
trait IterableOnceOps[A, CC, C]
trait IterableOnce[A]
class Any
Known subtypes
trait SeqOps[A, CC, C]
trait IndexedSeqOps[A, CC, C]
class ArraySeq[A]
class ofBoolean
class ofByte
class ofChar
class ofDouble
class ofFloat
class ofInt
class ofLong
class ofRef[T]
class ofShort
class ofUnit
trait IndexedSeq[A]
class NumericRange[T]
class Exclusive[T]
class Inclusive[T]
class Range
class Exclusive
class Inclusive
class Vector[A]
trait LinearSeqOps[A, CC, C]
class LazyList[A]
trait LinearSeq[A]
class List[A]
class ::[A]
object Nil
class Queue[A]
class Stream[A]
class Cons[A]
object Empty
trait Seq[A]
class AbstractSeq[A]
trait StrictOptimizedSeqOps[A, CC, C]
trait SeqOps[A, CC, C]
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]
trait IndexedSeqOps[A, CC, C]
trait IndexedSeq[A]
trait IndexedSeqView[A]
class ArrayBufferView[A]
class Slice[A]
class StringView
class Appended[A]
class Concat[A]
class Drop[A]
class DropRight[A]
class Id[A]
class Map[A, B]
class Prepended[A]
class Reverse[A]
class Take[A]
class TakeRight[A]
trait LinearSeqOps[A, CC, C]
trait LinearSeq[A]
trait StrictOptimizedLinearSeqOps[A, CC, C]
trait Seq[A]
class AbstractSeq[A]
trait SeqView[A]
class AbstractSeqView[A]
class Id[A]
class Reverse[A]
class Appended[A]
class Concat[A]
class Drop[A]
class DropRight[A]
class Map[A, B]
class Prepended[A]
class Sorted[A, B]
class Take[A]
class TakeRight[A]
trait StrictOptimizedSeqOps[A, CC, C]
trait ArrayDequeOps[A, CC, C]
Show all
Self type
SeqOps[A, CC, C]
object SeqOps

Attributes

Companion
trait
Source
Seq.scala
Supertypes
class Object
trait Matchable
class Any
Self type
SeqOps.type
trait SeqView[+A] extends SeqOps[A, View, View[A]], View[A]

Attributes

Companion
object
Source
SeqView.scala
Supertypes
trait View[A]
trait Serializable
trait Iterable[A]
trait SeqOps[A, View, View[A]]
trait IterableOps[A, View, View[A]]
trait IterableOnceOps[A, View, View[A]]
trait IterableOnce[A]
class Object
trait Matchable
class Any
Show all
Known subtypes
class AbstractSeqView[A]
class ArrayBufferView[A]
class Slice[A]
class StringView
class Id[A]
class Id[A]
class Reverse[A]
class Reverse[A]
trait IndexedSeqView[A]
class Appended[A]
class Concat[A]
class Drop[A]
class DropRight[A]
class Map[A, B]
class Prepended[A]
class Take[A]
class TakeRight[A]
class Appended[A]
class Concat[A]
class Drop[A]
class DropRight[A]
class Map[A, B]
class Prepended[A]
class Sorted[A, B]
class Take[A]
class TakeRight[A]
Show all
object SeqView

Attributes

Companion
trait
Source
SeqView.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Self type
SeqView.type
trait Set[A] extends Iterable[A], SetOps[A, Set, Set[A]], Equals, IterableFactoryDefaults[A, Set]

Base trait for set collections.

Base trait for set collections.

Attributes

Companion
object
Source
Set.scala
Supertypes
trait Equals
trait SetOps[A, Set, Set[A]]
trait A => Boolean
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
trait Set[A]
class AbstractSet[A]
class BitSet
class BitSet1
class BitSet2
class BitSetN
class HashSet[A]
class ListSet[A]
class Set1[A]
class Set2[A]
class Set3[A]
class Set4[A]
class TreeSet[A]
class ValueSet
trait SortedSet[A]
trait Set[A]
class AbstractSet[A]
class BitSet
class HashSet[A]
class LinkedHashSet[A]
class TreeSet[A]
trait SortedSet[A]
class AbstractSet[A]
trait SortedSet[A]
trait BitSet
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[_], +C <: SetOps[A, CC, C]] extends IterableOps[A, CC, C], A => Boolean

Base trait for set operations

Base trait for set operations

Attributes

Source
Set.scala
Supertypes
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
trait SetOps[A, CC, C]
trait Set[A]
class AbstractSet[A]
class BitSet
class BitSet1
class BitSet2
class BitSetN
class HashSet[A]
class ListSet[A]
class Set1[A]
class Set2[A]
class Set3[A]
class Set4[A]
class TreeSet[A]
class ValueSet
trait SortedSet[A]
trait SortedSetOps[A, CC, C]
trait StrictOptimizedSortedSetOps[A, CC, C]
trait StrictOptimizedSetOps[A, 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]
trait Set[A]
class AbstractSet[A]
trait SortedSet[A]
trait BitSet
trait SortedSetOps[A, CC, C]
trait BitSetOps[C]
trait SortedSetFactoryDefaults[A, CC, WithFilterCC]
trait StrictOptimizedSortedSetOps[A, CC, C]
trait StrictOptimizedSetOps[A, CC, C]
Show all
trait SortedIterableFactory[+CC[_]] extends EvidenceIterableFactory[CC, Ordering]

Base trait for companion objects of collections that require an implicit Ordering.

Base trait for companion objects of collections that require an implicit Ordering.

Type parameters

CC

Collection type constructor (e.g. SortedSet)

Attributes

Companion
object
Source
Factory.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Known subtypes
object TreeSet
object PriorityQueue
object TreeSet
class Delegate[CC]
object SortedSet
object SortedSet
object SortedSet
Show all
object SortedIterableFactory

Attributes

Companion
trait
Source
Factory.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Self type
trait SortedMap[K, +V] extends Map[K, V], SortedMapOps[K, V, SortedMap, SortedMap[K, V]], SortedMapFactoryDefaults[K, V, SortedMap, Iterable, Map]

A Map whose keys are sorted according to a scala.math.Ordering

A Map whose keys are sorted according to a scala.math.Ordering

Attributes

Companion
object
Source
SortedMap.scala
Supertypes
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
trait SortedMap[K, V]
class WithDefault[K, V]
class TreeMap[K, V]
trait SortedMap[K, V]
class WithDefault[K, V]
class TreeMap[K, V]
Show all
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 SortedMapFactory[+CC[_, _]] extends Serializable

Attributes

Companion
object
Source
Factory.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Known subtypes
object TreeMap
object TreeMap
class Delegate[CC]
object SortedMap
object SortedMap
object SortedMap
Show all
object SortedMapFactory

Attributes

Companion
trait
Source
Factory.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Self type
trait SortedMapFactoryDefaults[K, +V, +CC <: ([x, y] =>> Map[x, y] & SortedMapOps[x, y, CC, CC[x, y]] & UnsortedCC[x, y]), +WithFilterCC <: ([x] =>> IterableOps[x, WithFilterCC, WithFilterCC[x]] & Iterable[x]), +UnsortedCC <: (Map)] extends SortedMapOps[K, V, CC, CC[K, V]], MapOps[K, V, UnsortedCC, CC[K, V]]

This trait provides default implementations for the factory methods fromSpecific and newSpecificBuilder that need to be refined when implementing a collection type that refines the CC and C type parameters.

This trait provides default implementations for the factory methods fromSpecific and newSpecificBuilder that need to be refined when implementing a collection type that refines the CC and C type parameters. It is used for sorted maps.

Note that in sorted maps, the CC type of the map is not the same as the CC type for the underlying map (which is fixed to Map in SortedMapOps). This trait has therefore three type parameters CC, WithFilterCC and UnsortedCC. The withFilter method inherited from IterableOps is overridden with a compatible default implementation.

The default implementations in this trait can be used in the common case when CC[A] is the same as C.

Attributes

Source
Iterable.scala
Supertypes
trait SortedMapOps[K, V, CC, CC[K, V]]
trait SortedOps[K, CC[K, V]]
trait MapOps[K, V, UnsortedCC, CC[K, V]]
trait PartialFunction[K, V]
trait K => V
trait IterableOps[(K, V), Iterable, CC[K, V]]
trait IterableOnceOps[(K, V), Iterable, CC[K, V]]
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 SortedMap[K, V]
class WithDefault[K, V]
class TreeMap[K, V]
trait SortedMap[K, V]
Show all
Self type
IterableOps[(K, V), WithFilterCC, _]
trait SortedMapOps[K, +V, +CC <: ([X, Y] =>> Map[X, Y] & SortedMapOps[X, Y, CC, _]), +C <: SortedMapOps[K, V, CC, C]] extends MapOps[K, V, Map, C], SortedOps[K, C]

Attributes

Companion
object
Source
SortedMap.scala
Supertypes
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 SortedMapOps[K, V, CC, C]
trait SortedMap[K, V]
class WithDefault[K, V]
class TreeMap[K, V]
trait StrictOptimizedSortedMapOps[K, V, CC, C]
trait SortedMapOps[K, V, CC, C]
trait SortedMap[K, V]
class WithDefault[K, V]
class TreeMap[K, V]
trait SortedMap[K, V]
trait SortedMapFactoryDefaults[K, V, CC, WithFilterCC, UnsortedCC]
trait StrictOptimizedSortedMapOps[K, V, CC, C]
Show all
object SortedMapOps

Attributes

Companion
trait
Source
SortedMap.scala
Supertypes
class Object
trait Matchable
class Any
Self type
trait SortedOps[A, +C]

Base trait for sorted collections

Base trait for sorted collections

Attributes

Source
SortedOps.scala
Supertypes
class Object
trait Matchable
class Any
Known subtypes
trait SortedMapOps[K, V, CC, C]
trait SortedMapOps[K, V, CC, C]
trait SortedMap[K, V]
class WithDefault[K, V]
class TreeMap[K, V]
trait StrictOptimizedSortedMapOps[K, V, CC, C]
trait SortedMapOps[K, V, CC, C]
trait SortedMap[K, V]
class WithDefault[K, V]
class TreeMap[K, V]
trait SortedMap[K, V]
trait SortedMapFactoryDefaults[K, V, CC, WithFilterCC, UnsortedCC]
trait StrictOptimizedSortedMapOps[K, V, CC, C]
trait SortedSetOps[A, CC, C]
trait SortedSetOps[A, CC, C]
class BitSet
class BitSet1
class BitSet2
class BitSetN
trait SortedSet[A]
class TreeSet[A]
class ValueSet
trait StrictOptimizedSortedSetOps[A, CC, C]
trait SortedSetOps[A, CC, C]
class BitSet
trait SortedSet[A]
class TreeSet[A]
trait BitSetOps[C]
trait BitSet
trait SortedSet[A]
trait SortedSetFactoryDefaults[A, CC, WithFilterCC]
trait StrictOptimizedSortedSetOps[A, CC, C]
Show all
trait SortedSet[A] extends Set[A], SortedSetOps[A, SortedSet, SortedSet[A]], SortedSetFactoryDefaults[A, SortedSet, Set]

Base type of sorted sets

Base type of sorted sets

Attributes

Companion
object
Source
SortedSet.scala
Supertypes
trait SortedOps[A, SortedSet[A]]
trait Set[A]
trait Equals
trait SetOps[A, Set, SortedSet[A]]
trait A => Boolean
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
trait SortedSet[A]
class BitSet
class BitSet1
class BitSet2
class BitSetN
class TreeSet[A]
class ValueSet
trait SortedSet[A]
class BitSet
class TreeSet[A]
trait BitSet
Show all
object SortedSet extends Delegate[SortedSet]

Attributes

Companion
trait
Source
SortedSet.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Show all
Self type
SortedSet.type
trait SortedSetFactoryDefaults[+A, +CC <: ([X] =>> SortedSet[X] & SortedSetOps[X, CC, CC[X]]), +WithFilterCC <: ([x] =>> IterableOps[x, WithFilterCC, WithFilterCC[x]] & Set[x])] extends SortedSetOps[A, CC, CC[A]]

This trait provides default implementations for the factory methods fromSpecific and newSpecificBuilder that need to be refined when implementing a collection type that refines the CC and C type parameters.

This trait provides default implementations for the factory methods fromSpecific and newSpecificBuilder that need to be refined when implementing a collection type that refines the CC and C type parameters. It is used for sorted sets.

Note that in sorted sets, the CC type of the set is not the same as the CC type for the underlying iterable (which is fixed to Set in SortedSetOps). This trait has therefore two type parameters CC and WithFilterCC. The withFilter method inherited from IterableOps is overridden with a compatible default implementation.

The default implementations in this trait can be used in the common case when CC[A] is the same as C.

Attributes

Source
Iterable.scala
Supertypes
trait SortedSetOps[A, CC, CC[A]]
trait SortedOps[A, CC[A]]
trait SetOps[A, Set, CC[A]]
trait A => Boolean
trait IterableOps[A, Set, CC[A]]
trait IterableOnceOps[A, Set, CC[A]]
trait IterableOnce[A]
class Object
trait Matchable
class Any
Show all
Known subtypes
trait SortedSet[A]
class BitSet
class BitSet1
class BitSet2
class BitSetN
class TreeSet[A]
class ValueSet
trait SortedSet[A]
class BitSet
class TreeSet[A]
trait SortedSet[A]
trait BitSet
Show all
Self type
IterableOps[A, WithFilterCC, _]
trait SortedSetOps[A, +CC <: (SortedSet), +C <: SortedSetOps[A, CC, C]] extends SetOps[A, Set, C], SortedOps[A, C]

Attributes

Companion
object
Source
SortedSet.scala
Supertypes
trait SortedOps[A, C]
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
trait SortedSetOps[A, CC, C]
class BitSet
class BitSet1
class BitSet2
class BitSetN
trait SortedSet[A]
class TreeSet[A]
class ValueSet
trait StrictOptimizedSortedSetOps[A, CC, C]
trait SortedSetOps[A, CC, C]
class BitSet
trait SortedSet[A]
class TreeSet[A]
trait BitSetOps[C]
trait BitSet
trait SortedSet[A]
trait SortedSetFactoryDefaults[A, CC, WithFilterCC]
trait StrictOptimizedSortedSetOps[A, CC, C]
Show all
object SortedSetOps

Attributes

Companion
trait
Source
SortedSet.scala
Supertypes
class Object
trait Matchable
class Any
Self type
trait SpecificIterableFactory[-A, +C] extends Factory[A, C]

Type parameters

A

Type of elements (e.g. Int, Boolean, etc.)

C

Type of collection (e.g. List[Int], TreeMap[Int, String], etc.)

Attributes

Source
Factory.scala
Supertypes
trait Factory[A, C]
class Object
trait Matchable
class Any
Known subtypes
object BitSet
object WrappedString
object BitSet
object BitSet
object ValueSet
Show all
trait Stepper[+A]

Steppers exist to enable creating Java streams over Scala collections, see scala.jdk.StreamConverters.

Steppers exist to enable creating Java streams over Scala collections, see scala.jdk.StreamConverters. Besides that use case, they allow iterating over collections holding unboxed primitives (e.g., Array[Int]) without boxing the elements.

Steppers have an iterator-like interface with methods hasStep and nextStep(). The difference to iterators - and the reason Stepper is not a subtype of Iterator - is that there are hand-specialized variants of Stepper for Int, Long and Double (IntStepper, etc.). These enable iterating over collections holding unboxed primitives (e.g., Arrays, scala.jdk.Accumulators) without boxing the elements.

The selection of primitive types (Int, Long and Double) matches the hand-specialized variants of Java Streams (java.util.stream.Stream, java.util.stream.IntStream, etc.) and the corresponding Java Spliterators (java.util.Spliterator, java.util.Spliterator.OfInt, etc.).

Steppers can be converted to Scala Iterators, Java Iterators and Java Spliterators. Primitive Steppers are converted to the corresponding primitive Java Iterators and Spliterators.

Type parameters

A

the element type of the Stepper

Attributes

Companion
object
Source
Stepper.scala
Supertypes
class Object
trait Matchable
class Any
Known subtypes
trait AnyStepper[A]
trait IntStepper
trait LongStepper
object Stepper

Attributes

Companion
trait
Source
Stepper.scala
Supertypes
class Object
trait Matchable
class Any
Self type
Stepper.type
sealed trait StepperShape[-T, S <: Stepper[_]]

An implicit StepperShape instance is used in the IterableOnce.stepper to return a possibly specialized Stepper S according to the element type T.

An implicit StepperShape instance is used in the IterableOnce.stepper to return a possibly specialized Stepper S according to the element type T.

Attributes

Companion
object
Source
StepperShape.scala
Supertypes
class Object
trait Matchable
class Any
object StepperShape extends StepperShapeLowPriority1

Attributes

Companion
trait
Source
StepperShape.scala
Supertypes
class Object
trait Matchable
class Any
Self type
trait StepperShapeLowPriority1 extends StepperShapeLowPriority2

Attributes

Source
StepperShape.scala
Supertypes
class Object
trait Matchable
class Any
Known subtypes
object StepperShape
trait StepperShapeLowPriority2

Attributes

Source
StepperShape.scala
Supertypes
class Object
trait Matchable
class Any
Known subtypes
object StepperShape
trait StrictOptimizedClassTagSeqFactory[+CC <: (SeqOps)] extends ClassTagSeqFactory[CC]

Attributes

Source
Factory.scala
Supertypes
trait ClassTagSeqFactory[CC]
trait Serializable
class Object
trait Matchable
class Any
Show all
Known subtypes
object ArraySeq
object ArraySeq
trait StrictOptimizedIterableOps[+A, +CC[_], +C] extends IterableOps[A, CC, C]

Trait that overrides iterable operations to take advantage of strict builders.

Trait that overrides iterable operations to take advantage of strict builders.

Type parameters

A

Elements type

C

Collection type

CC

Collection type constructor

Attributes

Source
StrictOptimizedIterableOps.scala
Supertypes
trait IterableOps[A, CC, C]
trait IterableOnceOps[A, CC, C]
trait IterableOnce[A]
class Any
Known subtypes
class Map1[K, V]
class Map2[K, V]
class Map3[K, V]
class Map4[K, V]
class Set1[A]
class Set2[A]
class Set3[A]
class Set4[A]
trait StrictOptimizedMapOps[K, V, CC, C]
class HashMap[K, V]
class IntMap[T]
class ListMap[K, V]
class LongMap[T]
trait StrictOptimizedSortedMapOps[K, V, CC, C]
class TreeMap[K, V]
class TreeSeqMap[K, V]
class VectorMap[K, V]
trait StrictOptimizedSeqOps[A, CC, C]
class ArraySeq[A]
class ofBoolean
class ofByte
class ofChar
class ofDouble
class ofFloat
class ofInt
class ofLong
class ofRef[T]
class ofShort
class ofUnit
class List[A]
class ::[A]
object Nil
class NumericRange[T]
class Exclusive[T]
class Inclusive[T]
class Queue[A]
class Range
class Exclusive
class Inclusive
class Vector[A]
trait StrictOptimizedSetOps[A, CC, C]
class HashSet[A]
class ListSet[A]
trait StrictOptimizedSortedSetOps[A, CC, C]
class BitSet
class BitSet1
class BitSet2
class BitSetN
class TreeSet[A]
class AnyRefMap[K, V]
class BitSet
class CollisionProofHashMap[K, V]
class HashMap[K, V]
class HashSet[A]
class LinkedHashMap[K, V]
class LinkedHashSet[A]
class ListMap[K, V]
class LongMap[V]
class OpenHashMap[Key, Value]
class PriorityQueue[A]
class TreeMap[K, V]
class TreeSet[A]
trait StrictOptimizedMapOps[K, V, CC, C]
trait StrictOptimizedSortedMapOps[K, V, CC, C]
trait StrictOptimizedSeqOps[A, CC, C]
class ArrayBuffer[A]
class ArrayDeque[A]
class Queue[A]
class Stack[A]
trait ArrayDequeOps[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
class ListBuffer[A]
class UnrolledBuffer[T]
trait StrictOptimizedLinearSeqOps[A, CC, C]
trait StrictOptimizedSetOps[A, CC, C]
trait StrictOptimizedSortedSetOps[A, CC, C]
class ValueSet
Show all
trait StrictOptimizedLinearSeqOps[+A, +CC <: (LinearSeq), +C <: LinearSeq[A] & StrictOptimizedLinearSeqOps[A, CC, C]] extends LinearSeqOps[A, CC, C], StrictOptimizedSeqOps[A, CC, C]

Attributes

Source
LinearSeq.scala
Supertypes
trait StrictOptimizedSeqOps[A, CC, C]
trait StrictOptimizedIterableOps[A, CC, C]
trait LinearSeqOps[A, CC, C]
trait SeqOps[A, CC, C]
trait IterableOps[A, CC, C]
trait IterableOnceOps[A, CC, C]
trait IterableOnce[A]
class Any
Show all
Known subtypes
class List[A]
class ::[A]
object Nil
class Queue[A]
trait StrictOptimizedMapOps[K, +V, +CC <: ([_, _] =>> IterableOps[_, AnyConstr, _]), +C] extends MapOps[K, V, CC, C], StrictOptimizedIterableOps[(K, V), Iterable, C]

Trait that overrides map operations to take advantage of strict builders.

Trait that overrides map operations to take advantage of strict builders.

Type parameters

C

Collection type

CC

Collection type constructor

K

Type of keys

V

Type of values

Attributes

Source
StrictOptimizedMapOps.scala
Supertypes
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
trait StrictOptimizedMapOps[K, V, CC, C]
class HashMap[K, V]
class IntMap[T]
class ListMap[K, V]
class LongMap[T]
trait StrictOptimizedSortedMapOps[K, V, CC, C]
class TreeMap[K, V]
class TreeSeqMap[K, V]
class VectorMap[K, V]
class CollisionProofHashMap[K, V]
class HashMap[K, V]
class LinkedHashMap[K, V]
class ListMap[K, V]
class TreeMap[K, V]
trait StrictOptimizedSortedMapOps[K, V, CC, C]
Show all
trait StrictOptimizedSeqFactory[+CC <: (SeqOps)] extends SeqFactory[CC]

Attributes

Source
Factory.scala
Supertypes
trait SeqFactory[CC]
trait IterableFactory[CC]
trait Serializable
class Object
trait Matchable
class Any
Show all
Known subtypes
object List
object Queue
object Vector
object ArrayBuffer
object ArrayDeque
object ListBuffer
object Queue
object Stack
Show all
trait StrictOptimizedSeqOps[+A, +CC[_], +C] extends SeqOps[A, CC, C], StrictOptimizedIterableOps[A, CC, C]

Trait that overrides operations on sequences in order to take advantage of strict builders.

Trait that overrides operations on sequences in order to take advantage of strict builders.

Attributes

Source
StrictOptimizedSeqOps.scala
Supertypes
trait StrictOptimizedIterableOps[A, CC, C]
trait SeqOps[A, CC, C]
trait IterableOps[A, CC, C]
trait IterableOnceOps[A, CC, C]
trait IterableOnce[A]
class Any
Show all
Known subtypes
trait StrictOptimizedSeqOps[A, CC, C]
class ArraySeq[A]
class ofBoolean
class ofByte
class ofChar
class ofDouble
class ofFloat
class ofInt
class ofLong
class ofRef[T]
class ofShort
class ofUnit
class List[A]
class ::[A]
object Nil
class NumericRange[T]
class Exclusive[T]
class Inclusive[T]
class Queue[A]
class Range
class Exclusive
class Inclusive
class Vector[A]
class ArrayBuffer[A]
class ArrayDeque[A]
class Queue[A]
class Stack[A]
trait ArrayDequeOps[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
class ListBuffer[A]
class UnrolledBuffer[T]
trait StrictOptimizedLinearSeqOps[A, CC, C]
Show all
trait StrictOptimizedSetOps[A, +CC[_], +C <: SetOps[A, CC, C]] extends SetOps[A, CC, C], StrictOptimizedIterableOps[A, CC, C]

Trait that overrides set operations to take advantage of strict builders.

Trait that overrides set operations to take advantage of strict builders.

Type parameters

A

Elements type

C

Collection type

CC

Collection type constructor

Attributes

Source
StrictOptimizedSetOps.scala
Supertypes
trait StrictOptimizedIterableOps[A, CC, C]
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
trait StrictOptimizedSetOps[A, CC, C]
class HashSet[A]
class ListSet[A]
trait StrictOptimizedSortedSetOps[A, CC, C]
class BitSet
class BitSet1
class BitSet2
class BitSetN
class TreeSet[A]
trait StrictOptimizedSortedSetOps[A, CC, C]
class BitSet
class TreeSet[A]
Show all
trait StrictOptimizedSortedMapOps[K, +V, +CC <: ([X, Y] =>> Map[X, Y] & SortedMapOps[X, Y, CC, _]), +C <: SortedMapOps[K, V, CC, C]] extends SortedMapOps[K, V, CC, C], StrictOptimizedMapOps[K, V, Map, C]

Trait that overrides sorted map operations to take advantage of strict builders.

Trait that overrides sorted map operations to take advantage of strict builders.

Type parameters

C

Collection type

CC

Collection type constructor

K

Type of keys

V

Type of values

Attributes

Source
StrictOptimizedSortedMapOps.scala
Supertypes
trait StrictOptimizedMapOps[K, V, Map, C]
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 StrictOptimizedSortedMapOps[K, V, CC, C]
class TreeMap[K, V]
class TreeMap[K, V]
trait StrictOptimizedSortedSetOps[A, +CC <: (SortedSet), +C <: SortedSetOps[A, CC, C]] extends SortedSetOps[A, CC, C], StrictOptimizedSetOps[A, Set, C]

Trait that overrides sorted set operations to take advantage of strict builders.

Trait that overrides sorted set operations to take advantage of strict builders.

Type parameters

A

Elements type

C

Collection type

CC

Collection type constructor

Attributes

Source
StrictOptimizedSortedSetOps.scala
Supertypes
trait StrictOptimizedSetOps[A, Set, C]
trait SortedSetOps[A, CC, C]
trait SortedOps[A, C]
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
trait StrictOptimizedSortedSetOps[A, CC, C]
class BitSet
class BitSet1
class BitSet2
class BitSetN
class TreeSet[A]
class BitSet
class TreeSet[A]
Show all
object StringOps

Attributes

Companion
class
Source
StringOps.scala
Supertypes
class Object
trait Matchable
class Any
Self type
StringOps.type
final class StringOps(s: String) extends AnyVal

Provides extension methods for strings.

Provides extension methods for strings.

Some of these methods treat strings as a plain collection of Chars without any regard for Unicode handling. Unless the user takes Unicode handling in to account or makes sure the strings don't require such handling, these methods may result in unpaired or invalidly paired surrogate code units.

Attributes

Companion
object
Source
StringOps.scala
Supertypes
class AnyVal
trait Matchable
class Any
final case class StringView(s: String) extends AbstractIndexedSeqView[Char]

Attributes

Source
StringOps.scala
Supertypes
trait Product
trait Equals
trait SeqView[Char]
trait SeqOps[Char, View, View[Char]]
trait View[Char]
trait Serializable
trait Iterable[Char]
class Object
trait Matchable
class Any
Show all
trait View[+A] extends Iterable[A], IterableOps[A, View, View[A]], IterableFactoryDefaults[A, View], Serializable

Views are collections whose transformation operations are non strict: the resulting elements are evaluated only when the view is effectively traversed (e.g.

Views are collections whose transformation operations are non strict: the resulting elements are evaluated only when the view is effectively traversed (e.g. using foreach or foldLeft), or when the view is converted to a strict collection type (using the to operation).

Attributes

Companion
object
Source
View.scala
Supertypes
trait Serializable
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
Known subtypes
class AbstractView[A]
class AbstractMapView[K, V]
class Filter[K, V]
class FilterKeys[K, V]
class Id[K, V]
class MapValues[K, V, W]
class TapEach[K, V, U]
class AbstractSeqView[A]
class ArrayBufferView[A]
class Slice[A]
class StringView
class Id[A]
class Id[A]
class Reverse[A]
class Reverse[A]
class Appended[A]
class Appended[A]
class Appended[A]
class Collect[A, B]
class Concat[A]
class Concat[A]
class Concat[A]
class DistinctBy[A, B]
class Drop[A]
class Drop[A]
class Drop[A]
class DropRight[A]
class DropRight[A]
class DropRight[A]
class DropWhile[A]
class Elems[A]
object Empty
class Fill[A]
class Filter[A]
class FlatMap[A, B]
class Iterate[A]
class LeftPartitionMapped[A, A1, A2]
class Map[A, B]
class Map[A, B]
class Map[A, B]
class PadTo[A]
class Prepended[A]
class Prepended[A]
class Prepended[A]
class RightPartitionMapped[A, A1, A2]
class ScanLeft[A, B]
class Single[A]
class Tabulate[A]
class Take[A]
class Take[A]
class Take[A]
class TakeRight[A]
class TakeRight[A]
class TakeRight[A]
class TakeWhile[A]
class Unfold[A, S]
class Updated[A]
class Zip[A, B]
class ZipAll[A, B]
class ZipWithIndex[A]
trait MapView[K, V]
trait SeqView[A]
trait IndexedSeqView[A]
class Sorted[A, B]
Show all
object View extends IterableFactory[View]

This object reifies operations on views as case classes

This object reifies operations on views as case classes

Attributes

Companion
trait
Source
View.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Self type
View.type
abstract class WithFilter[+A, +CC[_]] extends Serializable

A template trait that contains just the map, flatMap, foreach and withFilter methods of trait Iterable.

A template trait that contains just the map, flatMap, foreach and withFilter methods of trait Iterable.

Type parameters

A

Element type (e.g. Int)

CC

Collection type constructor (e.g. List)

Attributes

Source
WithFilter.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Known subtypes
class WithFilter[A, CC]
class WithFilter[K, V, IterableCC, CC]
class WithFilter[K, V, IterableCC, MapCC, CC]
class WithFilter[A, IterableCC, CC]

Deprecated classlikes

trait DefaultMap[K, +V] extends Map[K, V]

A default map which builds a default immutable.Map implementation for all transformations.

A default map which builds a default immutable.Map implementation for all transformations.

Attributes

Deprecated
true
Source
DefaultMap.scala
Supertypes
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 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
object JavaConverters extends AsJavaConverters, AsScalaConverters

A variety of decorators that enable converting between Scala and Java collections using extension methods, asScala and asJava.

A variety of decorators that enable converting between Scala and Java collections using extension methods, asScala and asJava.

The extension methods return adapters for the corresponding API.

The following conversions are supported via asScala and asJava:

scala.collection.Iterable       <=> java.lang.Iterable
scala.collection.Iterator       <=> java.util.Iterator
scala.collection.mutable.Buffer <=> java.util.List
scala.collection.mutable.Set    <=> java.util.Set
scala.collection.mutable.Map    <=> java.util.Map
scala.collection.concurrent.Map <=> java.util.concurrent.ConcurrentMap

The following conversions are supported via asScala and through specially-named extension methods to convert to Java collections, as shown:

scala.collection.Iterable    <=> java.util.Collection   (via asJavaCollection)
scala.collection.Iterator    <=> java.util.Enumeration  (via asJavaEnumeration)
scala.collection.mutable.Map <=> java.util.Dictionary   (via asJavaDictionary)

In addition, the following one-way conversions are provided via asJava:

scala.collection.Seq         => java.util.List
scala.collection.mutable.Seq => java.util.List
scala.collection.Set         => java.util.Set
scala.collection.Map         => java.util.Map

The following one way conversion is provided via asScala:

java.util.Properties => scala.collection.mutable.Map

In all cases, converting from a source type to a target type and back again will return the original source object. For example:

import scala.collection.JavaConverters._

val source = new scala.collection.mutable.ListBuffer[Int]
val target: java.util.List[Int] = source.asJava
val other: scala.collection.mutable.Buffer[Int] = target.asScala
assert(source eq other)

Alternatively, the conversion methods have descriptive names and can be invoked explicitly.

scala> val vs = java.util.Arrays.asList("hi", "bye")
vs: java.util.List[String] = [hi, bye]

scala> val ss = asScalaIterator(vs.iterator)
ss: Iterator[String] = <iterator>

scala> .toList
res0: List[String] = List(hi, bye)

scala> val ss = asScalaBuffer(vs)
ss: scala.collection.mutable.Buffer[String] = Buffer(hi, bye)

Attributes

Deprecated
true
Source
JavaConverters.scala
Supertypes
class Object
trait Matchable
class Any
Self type

Deprecated types

type ArrayLike[A] = SeqOps[A, Seq, Seq[A]]

Attributes

Deprecated
true
Source
package.scala
type GenIterable[+X] = Iterable[X]

Attributes

Deprecated
true
Source
package.scala
type GenMap[K, +V] = Map[K, V]

Attributes

Deprecated
true
Source
package.scala
type GenSeq[+X] = Seq[X]

Attributes

Deprecated
true
Source
package.scala
type GenSet[X] = Set[X]

Attributes

Deprecated
true
Source
package.scala
type GenTraversable[+X] = Iterable[X]

Attributes

Deprecated
true
Source
package.scala
type GenTraversableOnce[+X] = IterableOnce[X]

Attributes

Deprecated
true
Source
package.scala
type SeqLike[A, T] = SeqOps[A, Seq, T]

Attributes

Deprecated
true
Source
package.scala
type Traversable[+X] = Iterable[X]

Attributes

Deprecated
true
Source
package.scala
type TraversableOnce[+X] = IterableOnce[X]

Attributes

Deprecated
true
Source
package.scala

Value members

Deprecated fields

val GenIterable: Iterable.type

Attributes

Deprecated
true
Source
package.scala
val GenMap: Map.type

Attributes

Deprecated
true
Source
package.scala
val GenSeq: Seq.type

Attributes

Deprecated
true
Source
package.scala
val GenSet: Set.type

Attributes

Deprecated
true
Source
package.scala
val GenTraversable: Iterable.type

Attributes

Deprecated
true
Source
package.scala
val GenTraversableOnce: IterableOnce.type

Attributes

Deprecated
true
Source
package.scala
val Traversable: Iterable.type

Attributes

Deprecated
true
Source
package.scala
val TraversableOnce: IterableOnce.type

Attributes

Deprecated
true
Source
package.scala
Generated with
Copyright (c) 2002-2024, LAMP/EPFL
Copyright (c) 2002-2024, LAMP/EPFL