package immutable
- Alphabetic
- By Inheritance
- immutable
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Type Members
- final case class ::[+A](head: A, next: List[A]) extends List[A] with Product with Serializable
- abstract class AbstractMap[K, +V] extends collection.AbstractMap[K, V] with Map[K, V]
Explicit instantiation of the
Map
trait to reduce class file size in subclasses. - abstract class AbstractSeq[+A] extends collection.AbstractSeq[A] with Seq[A]
Explicit instantiation of the
Seq
trait to reduce class file size in subclasses. - abstract class AbstractSet[A] extends collection.AbstractSet[A] with Set[A]
Explicit instantiation of the
Set
trait to reduce class file size in subclasses. - sealed abstract class ArraySeq[+A] extends AbstractSeq[A] with IndexedSeq[A] with IndexedSeqOps[A, ArraySeq, ArraySeq[A]] with StrictOptimizedSeqOps[A, ArraySeq, ArraySeq[A]] with EvidenceIterableFactoryDefaults[A, ArraySeq, ClassTag] with Serializable
An immutable array.
An immutable array.
Supports efficient indexed access and has a small memory footprint.
- sealed abstract class BitSet extends AbstractSet[Int] with SortedSet[Int] with SortedSetOps[Int, SortedSet, BitSet] with StrictOptimizedSortedSetOps[Int, SortedSet, BitSet] with collection.BitSet with BitSetOps[BitSet] with Serializable
A class for immutable bitsets.
A class for immutable bitsets.
Bitsets are sets of non-negative integers which are represented as variable-size arrays of bits packed into 64-bit words. The lower bound of memory footprint of a bitset is determined by the largest number stored in it.
- See also
"Scala's Collection Library overview" section on
Immutable BitSets
for more information.
- final class HashMap[K, +V] extends AbstractMap[K, V] with StrictOptimizedMapOps[K, V, HashMap, HashMap[K, V]] with MapFactoryDefaults[K, V, HashMap, Iterable] with DefaultSerializable
This class implements immutable maps using a Compressed Hash-Array Mapped Prefix-tree.
This class implements immutable maps using a Compressed Hash-Array Mapped Prefix-tree. See paper https://michael.steindorfer.name/publications/oopsla15.pdf for more details.
- K
the type of the keys contained in this hash set.
- V
the type of the values associated with the keys in this hash map.
- final class HashSet[A] extends AbstractSet[A] with StrictOptimizedSetOps[A, HashSet, HashSet[A]] with IterableFactoryDefaults[A, HashSet] with DefaultSerializable
This class implements immutable sets using a Compressed Hash-Array Mapped Prefix-tree.
This class implements immutable sets using a Compressed Hash-Array Mapped Prefix-tree. See paper https://michael.steindorfer.name/publications/oopsla15.pdf for more details.
- A
the type of the elements contained in this hash set.
- trait IndexedSeq[+A] extends Seq[A] with collection.IndexedSeq[A] with IndexedSeqOps[A, IndexedSeq, IndexedSeq[A]] with IterableFactoryDefaults[A, IndexedSeq]
Base trait for immutable indexed sequences that have efficient
apply
andlength
- trait IndexedSeqOps[+A, +CC[_], +C] extends SeqOps[A, CC, C] with collection.IndexedSeqOps[A, CC, C]
Base trait for immutable indexed Seq operations
- sealed abstract class IntMap[+T] extends AbstractMap[immutable.IntMapUtils.Int, T] with StrictOptimizedMapOps[immutable.IntMapUtils.Int, T, Map, IntMap[T]] with Serializable
Specialised immutable map structure for integer keys, based on Fast Mergeable Integer Maps by Okasaki and Gill.
Specialised immutable map structure for integer keys, based on Fast Mergeable Integer Maps by Okasaki and Gill. Essentially a trie based on binary digits of the integers.
Note: This class is as of 2.8 largely superseded by HashMap.
- T
type of the values associated with integer keys.
- trait Iterable[+A] extends collection.Iterable[A] with IterableOps[A, Iterable, Iterable[A]] with IterableFactoryDefaults[A, Iterable]
A trait for collections that are guaranteed immutable.
A trait for collections that are guaranteed immutable.
- A
the element type of the collection
- final class LazyList[+A] extends AbstractSeq[A] with LinearSeq[A] with LinearSeqOps[A, LazyList, LazyList[A]] with IterableFactoryDefaults[A, LazyList] with Serializable
This class implements an immutable linked list.
This class implements an immutable linked list. We call it "lazy" because it computes its elements only when they are needed.
Elements are memoized; that is, the value of each element is computed at most once.
Elements are computed in-order and are never skipped. In other words, accessing the tail causes the head to be computed first.
How lazy is a
LazyList
? When you have a value of typeLazyList
, you don't know yet whether the list is empty or not. If you learn that it is non-empty, then you also know that the head has been computed. But the tail is itself aLazyList
, whose emptiness-or-not might remain undetermined.A
LazyList
may be infinite. For example,LazyList.from(0)
contains all of the natural numbers 0, 1, 2, and so on. For infinite sequences, some methods (such ascount
,sum
,max
ormin
) will not terminate.Here is an example:
import scala.math.BigInt object Main extends App { val fibs: LazyList[BigInt] = BigInt(0) #:: BigInt(1) #:: fibs.zip(fibs.tail).map{ n => n._1 + n._2 } fibs.take(5).foreach(println) } // prints // // 0 // 1 // 1 // 2 // 3
To illustrate, let's add some output to the definition
fibs
, so we see what's going on.import scala.math.BigInt object Main extends App { val fibs: LazyList[BigInt] = BigInt(0) #:: BigInt(1) #:: fibs.zip(fibs.tail).map{ n => println(s"Adding ${n._1} and ${n._2}") n._1 + n._2 } fibs.take(5).foreach(println) fibs.take(6).foreach(println) } // prints // // 0 // 1 // Adding 0 and 1 // 1 // Adding 1 and 1 // 2 // Adding 1 and 2 // 3 // And then prints // // 0 // 1 // 1 // 2 // 3 // Adding 2 and 3 // 5
Note that the definition of
fibs
usesval
notdef
. The memoization of theLazyList
requires us to have somewhere to store the information and aval
allows us to do that.Further remarks about the semantics of
LazyList
:- Though the
LazyList
changes as it is accessed, this does not contradict its immutability. Once the values are memoized they do not change. Values that have yet to be memoized still "exist", they simply haven't been computed yet. - One must be cautious of memoization; it can eat up memory if you're not
careful. That's because memoization of the
LazyList
creates a structure much like scala.collection.immutable.List. As long as something is holding on to the head, the head holds on to the tail, and so on recursively. If, on the other hand, there is nothing holding on to the head (e.g. if we useddef
to define theLazyList
) then once it is no longer being used directly, it disappears. - Note that some operations, including drop, dropWhile, flatMap or collect may process a large number of intermediate elements before returning.
Here's another example. Let's start with the natural numbers and iterate over them.
// We'll start with a silly iteration def loop(s: String, i: Int, iter: Iterator[Int]): Unit = { // Stop after 200,000 if (i < 200001) { if (i % 50000 == 0) println(s + i) loop(s, iter.next(), iter) } } // Our first LazyList definition will be a val definition val lazylist1: LazyList[Int] = { def loop(v: Int): LazyList[Int] = v #:: loop(v + 1) loop(0) } // Because lazylist1 is a val, everything that the iterator produces is held // by virtue of the fact that the head of the LazyList is held in lazylist1 val it1 = lazylist1.iterator loop("Iterator1: ", it1.next(), it1) // We can redefine this LazyList such that all we have is the Iterator left // and allow the LazyList to be garbage collected as required. Using a def // to provide the LazyList ensures that no val is holding onto the head as // is the case with lazylist1 def lazylist2: LazyList[Int] = { def loop(v: Int): LazyList[Int] = v #:: loop(v + 1) loop(0) } val it2 = lazylist2.iterator loop("Iterator2: ", it2.next(), it2) // And, of course, we don't actually need a LazyList at all for such a simple // problem. There's no reason to use a LazyList if you don't actually need // one. val it3 = new Iterator[Int] { var i = -1 def hasNext = true def next(): Int = { i += 1; i } } loop("Iterator3: ", it3.next(), it3)
- In the
fibs
example earlier, the fact thattail
works at all is of interest.fibs
has an initial(0, 1, LazyList(...))
, sotail
is deterministic. If we definedfibs
such that only0
were concretely known, then the act of determiningtail
would require the evaluation oftail
, so the computation would be unable to progress, as in this code:
// The first time we try to access the tail we're going to need more // information which will require us to recurse, which will require us to // recurse, which... lazy val sov: LazyList[Vector[Int]] = Vector(0) #:: sov.zip(sov.tail).map { n => n._1 ++ n._2 }
The definition of
fibs
above creates a larger number of objects than necessary depending on how you might want to implement it. The following implementation provides a more "cost effective" implementation due to the fact that it has a more direct route to the numbers themselves:lazy val fib: LazyList[Int] = { def loop(h: Int, n: Int): LazyList[Int] = h #:: loop(n, h + n) loop(1, 1) }
The head, the tail and whether the list is empty or not can be initially unknown. Once any of those are evaluated, they are all known, though if the tail is built with
#::
or#:::
, it's content still isn't evaluated. Instead, evaluating the tails content is deferred until the tails empty status, head or tail is evaluated.Delaying the evaluation of whether a LazyList is empty or not until it's needed allows LazyList to not eagerly evaluate any elements on a call to
filter
.Only when it's further evaluated (which may be never!) any of the elements gets forced.
for example:
def tailWithSideEffect: LazyList[Nothing] = { println("getting empty LazyList") LazyList.empty } val emptyTail = tailWithSideEffect // prints "getting empty LazyList" val suspended = 1 #:: tailWithSideEffect // doesn't print anything val tail = suspended.tail // although the tail is evaluated, *still* nothing is yet printed val filtered = tail.filter(_ => false) // still nothing is printed filtered.isEmpty // prints "getting empty LazyList"
- A
the type of the elements contained in this lazy list.
- Annotations
- @SerialVersionUID()
- See also
"Scala's Collection Library overview" section on
LazyLists
for more information.
- Though the
- trait LinearSeq[+A] extends Seq[A] with collection.LinearSeq[A] with LinearSeqOps[A, LinearSeq, LinearSeq[A]] with IterableFactoryDefaults[A, LinearSeq]
Base trait for immutable linear sequences that have efficient
head
andtail
- trait LinearSeqOps[+A, +CC[X] <: LinearSeq[X], +C <: LinearSeq[A] with LinearSeqOps[A, CC, C]] extends SeqOps[A, CC, C] with collection.LinearSeqOps[A, CC, C]
- sealed abstract class List[+A] extends AbstractSeq[A] with LinearSeq[A] with LinearSeqOps[A, List, List[A]] with StrictOptimizedLinearSeqOps[A, List, List[A]] with StrictOptimizedSeqOps[A, List, List[A]] with IterableFactoryDefaults[A, List] with DefaultSerializable
A class for immutable linked lists representing ordered collections of elements of type
A
.A class for immutable linked lists representing ordered collections of elements of type
A
.This class comes with two implementing case classes
scala.Nil
andscala.::
that implement the abstract membersisEmpty
,head
andtail
.This class is optimal for last-in-first-out (LIFO), stack-like access patterns. If you need another access pattern, for example, random access or FIFO, consider using a collection more suited to this than
List
.Performance
Time:
List
hasO(1)
prepend and head/tail access. Most other operations areO(n)
on the number of elements in the list. This includes the index-based lookup of elements,length
,append
andreverse
.Space:
List
implements structural sharing of the tail list. This means that many operations are either zero- or constant-memory cost.val mainList = List(3, 2, 1) val with4 = 4 :: mainList // re-uses mainList, costs one :: instance val with42 = 42 :: mainList // also re-uses mainList, cost one :: instance val shorter = mainList.tail // costs nothing as it uses the same 2::1::Nil instances as mainList
- Annotations
- @SerialVersionUID()
// Make a list via the companion object factory val days = List("Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday") // Make a list element-by-element val when = "AM" :: "PM" :: Nil // Pattern match days match { case firstDay :: otherDays => println("The first day of the week is: " + firstDay) case Nil => println("There don't seem to be any week days.") }
- Note
The functional list is characterized by persistence and structural sharing, thus offering considerable performance and space consumption benefits in some scenarios if used correctly. However, note that objects having multiple references into the same functional list (that is, objects that rely on structural sharing), will be serialized and deserialized with multiple lists, one for each reference to it. I.e. structural sharing is lost after serialization/deserialization.
- See also
"Scala's Collection Library overview" section on
Lists
for more information.
Example: - sealed class ListMap[K, +V] extends AbstractMap[K, V] with SeqMap[K, V] with StrictOptimizedMapOps[K, V, ListMap, ListMap[K, V]] with MapFactoryDefaults[K, V, ListMap, Iterable] with DefaultSerializable
This class implements immutable maps using a list-based data structure.
This class implements immutable maps using a list-based data structure. List map iterators and traversal methods visit key-value pairs in the order they were first inserted.
Entries are stored internally in reversed insertion order, which means the newest key is at the head of the list. As such, methods such as
head
andtail
are O(n), whilelast
andinit
are O(1). Other operations, such as inserting or removing entries, are also O(n), which makes this collection suitable only for a small number of elements.Instances of
ListMap
represent empty maps; they can be either created by calling the constructor directly, or by applying the functionListMap.empty
.- K
the type of the keys contained in this list map
- V
the type of the values associated with the keys
- sealed class ListSet[A] extends AbstractSet[A] with StrictOptimizedSetOps[A, ListSet, ListSet[A]] with IterableFactoryDefaults[A, ListSet] with DefaultSerializable
This class implements immutable sets using a list-based data structure.
This class implements immutable sets using a list-based data structure. List set iterators and traversal methods visit elements in the order they were first inserted.
Elements are stored internally in reversed insertion order, which means the newest element is at the head of the list. As such, methods such as
head
andtail
are O(n), whilelast
andinit
are O(1). Other operations, such as inserting or removing entries, are also O(n), which makes this collection suitable only for a small number of elements.Instances of
ListSet
represent empty sets; they can be either created by calling the constructor directly, or by applying the functionListSet.empty
.- A
the type of the elements contained in this list set
- sealed abstract class LongMap[+T] extends AbstractMap[immutable.LongMapUtils.Long, T] with StrictOptimizedMapOps[immutable.LongMapUtils.Long, T, Map, LongMap[T]] with Serializable
Specialised immutable map structure for long keys, based on Fast Mergeable Long Maps by Okasaki and Gill.
Specialised immutable map structure for long keys, based on Fast Mergeable Long Maps by Okasaki and Gill. Essentially a trie based on binary digits of the integers.
Note: This class is as of 2.8 largely superseded by HashMap.
- T
type of the values associated with the long keys.
- trait Map[K, +V] extends Iterable[(K, V)] with collection.Map[K, V] with MapOps[K, V, Map, Map[K, V]] with MapFactoryDefaults[K, V, Map, Iterable]
Base type of immutable Maps
- trait MapOps[K, +V, +CC[X, +Y] <: MapOps[X, Y, CC, _], +C <: MapOps[K, V, CC, C]] extends IterableOps[(K, V), Iterable, C] with collection.MapOps[K, V, CC, C]
Base trait of immutable Maps implementations
- sealed class NumericRange[T] extends AbstractSeq[T] with IndexedSeq[T] with IndexedSeqOps[T, IndexedSeq, IndexedSeq[T]] with StrictOptimizedSeqOps[T, IndexedSeq, IndexedSeq[T]] with IterableFactoryDefaults[T, IndexedSeq] with Serializable
NumericRange
is a more generic version of theRange
class which works with arbitrary types.NumericRange
is a more generic version of theRange
class which works with arbitrary types. It must be supplied with anIntegral
implementation of the range type.Factories for likely types include
Range.BigInt
,Range.Long
, andRange.BigDecimal
.Range.Int
exists for completeness, but theInt
-basedscala.Range
should be more performant.val r1 = Range(0, 100, 1) val veryBig = Int.MaxValue.toLong + 1 val r2 = Range.Long(veryBig, veryBig + 100, 1) assert(r1 sameElements r2.map(_ - veryBig))
- Annotations
- @SerialVersionUID()
- sealed class Queue[+A] extends AbstractSeq[A] with LinearSeq[A] with LinearSeqOps[A, Queue, Queue[A]] with StrictOptimizedLinearSeqOps[A, Queue, Queue[A]] with StrictOptimizedSeqOps[A, Queue, Queue[A]] with IterableFactoryDefaults[A, Queue] with DefaultSerializable
Queue
objects implement data structures that allow to insert and retrieve elements in a first-in-first-out (FIFO) manner.Queue
objects implement data structures that allow to insert and retrieve elements in a first-in-first-out (FIFO) manner.Queue
is implemented as a pair ofList
s, one containing the in elements and the other the out elements. Elements are added to the in list and removed from the out list. When the out list runs dry, the queue is pivoted by replacing the out list by in.reverse, and in by Nil.Adding items to the queue always has cost
O(1)
. Removing items has costO(1)
, except in the case where a pivot is required, in which case, a cost ofO(n)
is incurred, wheren
is the number of elements in the queue. When this happens,n
remove operations withO(1)
cost are guaranteed. Removing an item is on averageO(1)
.- See also
"Scala's Collection Library overview" section on
Immutable Queues
for more information.
- sealed abstract class Range extends AbstractSeq[Int] with IndexedSeq[Int] with IndexedSeqOps[Int, IndexedSeq, IndexedSeq[Int]] with StrictOptimizedSeqOps[Int, IndexedSeq, IndexedSeq[Int]] with IterableFactoryDefaults[Int, IndexedSeq] with Serializable
The
Range
class represents integer values in range [start;end) with non-zero step valuestep
.The
Range
class represents integer values in range [start;end) with non-zero step valuestep
. It's a special case of an indexed sequence. For example:val r1 = 0 until 10 val r2 = r1.start until r1.end by r1.step + 1 println(r2.length) // = 5
Ranges that contain more than
Int.MaxValue
elements can be created, but these overfull ranges have only limited capabilities. Any method that could require a collection of overInt.MaxValue
length to be created, or could be asked to index beyondInt.MaxValue
elements will throw an exception. Overfull ranges can safely be reduced in size by changing the step size (e.g.by 3
) or taking/dropping elements.contains
,equals
, and access to the ends of the range (head
,last
,tail
,init
) are also permitted on overfull ranges.- Annotations
- @SerialVersionUID()
- trait Seq[+A] extends Iterable[A] with collection.Seq[A] with SeqOps[A, Seq, Seq[A]] with IterableFactoryDefaults[A, Seq]
- trait SeqMap[K, +V] extends Map[K, V] with collection.SeqMap[K, V] with MapOps[K, V, SeqMap, SeqMap[K, V]] with MapFactoryDefaults[K, V, SeqMap, Iterable]
A generic trait for ordered immutable maps.
A generic trait for ordered immutable 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.
- 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.
- trait SeqOps[+A, +CC[_], +C] extends collection.SeqOps[A, CC, C]
- trait Set[A] extends Iterable[A] with collection.Set[A] with SetOps[A, Set, Set[A]] with IterableFactoryDefaults[A, Set]
Base trait for immutable set collections
- trait SetOps[A, +CC[X], +C <: SetOps[A, CC, C]] extends collection.SetOps[A, CC, C]
Base trait for immutable set operations
- trait SortedMap[K, +V] extends Map[K, V] with collection.SortedMap[K, V] with SortedMapOps[K, V, SortedMap, SortedMap[K, V]] with SortedMapFactoryDefaults[K, V, SortedMap, Iterable, Map]
An immutable map whose key-value pairs are sorted according to an scala.math.Ordering on the keys.
An immutable map whose key-value pairs are sorted according to an scala.math.Ordering on the keys.
Allows for range queries to be performed on its keys, and implementations must guarantee that traversal happens in sorted order, according to the map's scala.math.Ordering.
- K
the type of the keys contained in this tree map.
- V
the type of the values associated with the keys.
import scala.collection.immutable.SortedMap // Make a SortedMap via the companion object factory val weekdays = SortedMap( 2 -> "Monday", 3 -> "Tuesday", 4 -> "Wednesday", 5 -> "Thursday", 6 -> "Friday" ) // TreeMap(2 -> Monday, 3 -> Tuesday, 4 -> Wednesday, 5 -> Thursday, 6 -> Friday) val days = weekdays ++ List(1 -> "Sunday", 7 -> "Saturday") // TreeMap(1 -> Sunday, 2 -> Monday, 3 -> Tuesday, 4 -> Wednesday, 5 -> Thursday, 6 -> Friday, 7 -> Saturday) val day3 = days.get(3) // Some("Tuesday") val rangeOfDays = days.range(2, 5) // TreeMap(2 -> Monday, 3 -> Tuesday, 4 -> Wednesday) val daysUntil2 = days.rangeUntil(2) // TreeMap(1 -> Sunday) val daysTo2 = days.rangeTo(2) // TreeMap(1 -> Sunday, 2 -> Monday) val daysAfter5 = days.rangeFrom(5) // TreeMap(5 -> Thursday, 6 -> Friday, 7 -> Saturday)
Example: - trait SortedMapOps[K, +V, +CC[X, +Y] <: Map[X, Y] with SortedMapOps[X, Y, CC, _], +C <: SortedMapOps[K, V, CC, C]] extends MapOps[K, V, Map, C] with collection.SortedMapOps[K, V, CC, C]
- trait SortedSet[A] extends Set[A] with collection.SortedSet[A] with SortedSetOps[A, SortedSet, SortedSet[A]] with SortedSetFactoryDefaults[A, SortedSet, Set]
Base trait for sorted sets
- trait SortedSetOps[A, +CC[X] <: SortedSet[X], +C <: SortedSetOps[A, CC, C]] extends SetOps[A, Set, C] with collection.SortedSetOps[A, CC, C]
- trait StrictOptimizedMapOps[K, +V, +CC[X, +Y] <: MapOps[X, Y, CC, _], +C <: MapOps[K, V, CC, C]] extends MapOps[K, V, CC, C] with collection.StrictOptimizedMapOps[K, V, CC, C] with StrictOptimizedIterableOps[(K, V), Iterable, C]
- trait StrictOptimizedSeqOps[+A, +CC[_], +C] extends SeqOps[A, CC, C] with collection.StrictOptimizedSeqOps[A, CC, C] with StrictOptimizedIterableOps[A, CC, C]
Trait that overrides operations to take advantage of strict builders.
- trait StrictOptimizedSetOps[A, +CC[X], +C <: SetOps[A, CC, C]] extends SetOps[A, CC, C] with collection.StrictOptimizedSetOps[A, CC, C] with StrictOptimizedIterableOps[A, CC, C]
- trait StrictOptimizedSortedMapOps[K, +V, +CC[X, +Y] <: Map[X, Y] with SortedMapOps[X, Y, CC, _], +C <: SortedMapOps[K, V, CC, C]] extends SortedMapOps[K, V, CC, C] with collection.StrictOptimizedSortedMapOps[K, V, CC, C] with StrictOptimizedMapOps[K, V, Map, C]
- trait StrictOptimizedSortedSetOps[A, +CC[X] <: SortedSet[X], +C <: SortedSetOps[A, CC, C]] extends SortedSetOps[A, CC, C] with collection.StrictOptimizedSortedSetOps[A, CC, C] with StrictOptimizedSetOps[A, Set, C]
- type StringOps = collection.StringOps
- type StringView = collection.StringView
- final class TreeMap[K, +V] extends AbstractMap[K, V] with SortedMap[K, V] with StrictOptimizedSortedMapOps[K, V, TreeMap, TreeMap[K, V]] with SortedMapFactoryDefaults[K, V, TreeMap, Iterable, Map] with DefaultSerializable
An immutable SortedMap whose values are stored in a red-black tree.
An immutable SortedMap whose values are stored in a red-black tree.
This class is optimal when range queries will be performed, or when traversal in order of an ordering is desired. If you only need key lookups, and don't care in which order key-values are traversed in, consider using * scala.collection.immutable.HashMap, which will generally have better performance. If you need insertion order, consider a * scala.collection.immutable.SeqMap, which does not need to have an ordering supplied.
- K
the type of the keys contained in this tree map.
- V
the type of the values associated with the keys.
import scala.collection.immutable.TreeMap // Make a TreeMap via the companion object factory val weekdays = TreeMap( 2 -> "Monday", 3 -> "Tuesday", 4 -> "Wednesday", 5 -> "Thursday", 6 -> "Friday" ) // TreeMap(2 -> Monday, 3 -> Tuesday, 4 -> Wednesday, 5 -> Thursday, 6 -> Friday) val days = weekdays ++ List(1 -> "Sunday", 7 -> "Saturday") // TreeMap(1 -> Sunday, 2 -> Monday, 3 -> Tuesday, 4 -> Wednesday, 5 -> Thursday, 6 -> Friday, 7 -> Saturday) val day3 = days.get(3) // Some("Tuesday") val rangeOfDays = days.range(2, 5) // TreeMap(2 -> Monday, 3 -> Tuesday, 4 -> Wednesday) val daysUntil2 = days.rangeUntil(2) // TreeMap(1 -> Sunday) val daysTo2 = days.rangeTo(2) // TreeMap(1 -> Sunday, 2 -> Monday) val daysAfter5 = days.rangeFrom(5) // TreeMap(5 -> Thursday, 6 -> Friday, 7 -> Saturday)
- See also
"Scala's Collection Library overview" section on
Red-Black Trees
for more information.
Example: - final class TreeSeqMap[K, +V] extends AbstractMap[K, V] with SeqMap[K, V] with MapOps[K, V, TreeSeqMap, TreeSeqMap[K, V]] with StrictOptimizedIterableOps[(K, V), Iterable, TreeSeqMap[K, V]] with StrictOptimizedMapOps[K, V, TreeSeqMap, TreeSeqMap[K, V]] with MapFactoryDefaults[K, V, TreeSeqMap, Iterable]
This class implements an immutable map that preserves order using a hash map for the key to value mapping to provide efficient lookup, and a tree for the ordering of the keys to provide efficient insertion/modification order traversal and destructuring.
This class implements an immutable map that preserves order using a hash map for the key to value mapping to provide efficient lookup, and a tree for the ordering of the keys to provide efficient insertion/modification order traversal and destructuring.
By default insertion order (
TreeSeqMap.OrderBy.Insertion
) is used, but modification order (TreeSeqMap.OrderBy.Modification
) can be used instead if so specified at creation.The
orderingBy(orderBy: TreeSeqMap.OrderBy): TreeSeqMap[K, V]
method can be used to switch to the specified ordering for the returned map.A key can be manually refreshed (i.e. placed at the end) via the
refresh(key: K): TreeSeqMap[K, V]
method (regardless of the ordering in use).Internally, an ordinal counter is increased for each insertion/modification and then the current ordinal is used as key in the tree map. After 232 insertions/modifications the entire map is copied (thus resetting the ordinal counter).
- K
the type of the keys contained in this map.
- V
the type of the values associated with the keys in this map.
- final class TreeSet[A] extends AbstractSet[A] with SortedSet[A] with SortedSetOps[A, TreeSet, TreeSet[A]] with StrictOptimizedSortedSetOps[A, TreeSet, TreeSet[A]] with SortedSetFactoryDefaults[A, TreeSet, Set] with DefaultSerializable
This class implements immutable sorted sets using a tree.
This class implements immutable sorted sets using a tree.
- A
the type of the elements contained in this tree set
- See also
"Scala's Collection Library overview" section on
Red-Black Trees
for more information.
- sealed abstract class Vector[+A] extends AbstractSeq[A] with IndexedSeq[A] with IndexedSeqOps[A, Vector, Vector[A]] with StrictOptimizedSeqOps[A, Vector, Vector[A]] with IterableFactoryDefaults[A, Vector] with DefaultSerializable
Vector is a general-purpose, immutable data structure.
Vector is a general-purpose, immutable data structure. It provides random access and updates in O(log n) time, as well as very fast append/prepend/tail/init (amortized O(1), worst case O(log n)). Because vectors strike a good balance between fast random selections and fast random functional updates, they are currently the default implementation of immutable indexed sequences.
Vectors are implemented by radix-balanced finger trees of width 32. There is a separate subclass for each level (0 to 6, with 0 being the empty vector and 6 a tree with a maximum width of 64 at the top level).
Tree balancing: - Only the first dimension of an array may have a size < WIDTH - In a
data
(central) array the first dimension may be up to WIDTH-2 long, inprefix1
andsuffix1
up to WIDTH, and in otherprefix
andsuffix
arrays up to WIDTH-1 -prefix1
andsuffix1
are never empty - Balancing does not cross the main data array (i.e. prepending never touches the suffix and appending never touches the prefix). The level is increased/decreased when the affected side plus main data is already full/empty - All arrays are left-aligned and truncatedIn addition to the data slices (
prefix1
,prefix2
, ...,dataN
, ...,suffix2
,suffix1
) we store a running count of elements after each prefix for more efficient indexing without having to dereference all prefix arrays. - final class VectorBuilder[A] extends ReusableBuilder[A, Vector[A]]
- final class VectorMap[K, +V] extends AbstractMap[K, V] with SeqMap[K, V] with StrictOptimizedMapOps[K, V, VectorMap, VectorMap[K, V]] with MapFactoryDefaults[K, V, VectorMap, Iterable]
This class implements immutable maps using a vector/map-based data structure, which preserves insertion order.
This class implements immutable maps using a vector/map-based data structure, which preserves insertion order.
Unlike
ListMap
,VectorMap
has amortized effectively constant lookup at the expense of using extra memory and generally lower performance for other operations- K
the type of the keys contained in this vector map.
- V
the type of the values associated with the keys in this vector map.
- final class WrappedString extends AbstractSeq[Char] with IndexedSeq[Char] with IndexedSeqOps[Char, IndexedSeq, WrappedString] with Serializable
This class serves as a wrapper augmenting
String
s with all the operations found in indexed sequences.This class serves as a wrapper augmenting
String
s with all the operations found in indexed sequences.The difference between this class and
StringOps
is that calling transformer methods such asfilter
andmap
will yield an object of typeWrappedString
rather than aString
.- Annotations
- @SerialVersionUID()
Deprecated Type Members
- type DefaultMap[K, +V] = Map[K, V]
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) Use Map instead of DefaultMap
- sealed abstract class Stream[+A] extends AbstractSeq[A] with LinearSeq[A] with LinearSeqOps[A, Stream, Stream[A]] with IterableFactoryDefaults[A, Stream] with Serializable
- Annotations
- @deprecated @SerialVersionUID()
- Deprecated
(Since version 2.13.0) Use LazyList (which is fully lazy) instead of Stream (which has a lazy tail only)
- type Traversable[+X] = Iterable[X]
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) Use Iterable instead of Traversable
Value Members
- val StringOps: collection.StringOps.type
- val StringView: collection.StringView.type
- object ArraySeq extends StrictOptimizedClassTagSeqFactory[ArraySeq]
This object provides a set of operations to create
ArraySeq
values.This object provides a set of operations to create
ArraySeq
values.- Annotations
- @SerialVersionUID()
- object BitSet extends SpecificIterableFactory[Int, BitSet] with java.io.Serializable
This object provides a set of operations to create
immutable.BitSet
values.This object provides a set of operations to create
immutable.BitSet
values.- Annotations
- @nowarn() @SerialVersionUID()
- object HashMap extends MapFactory[HashMap]
This object provides a set of operations to create
immutable.HashMap
values.This object provides a set of operations to create
immutable.HashMap
values.- Annotations
- @SerialVersionUID()
- object HashSet extends IterableFactory[HashSet]
This object provides a set of operations to create
immutable.HashSet
values.This object provides a set of operations to create
immutable.HashSet
values.- Annotations
- @SerialVersionUID()
- object IndexedSeq extends Delegate[IndexedSeq]
- Annotations
- @SerialVersionUID()
- object IndexedSeqDefaults
- object IntMap extends java.io.Serializable
A companion object for integer maps.
- object Iterable extends Delegate[Iterable]
- Annotations
- @SerialVersionUID()
- object LazyList extends SeqFactory[LazyList]
This object provides a set of operations to create
LazyList
values.This object provides a set of operations to create
LazyList
values.- Annotations
- @SerialVersionUID()
- object LinearSeq extends Delegate[LinearSeq]
- Annotations
- @SerialVersionUID()
- object List extends StrictOptimizedSeqFactory[List]
This object provides a set of operations to create
List
values.This object provides a set of operations to create
List
values.- Annotations
- @SerialVersionUID()
- object ListMap extends MapFactory[ListMap]
This object provides a set of operations to create ListMap values.
This object provides a set of operations to create ListMap values.
Note that each element insertion takes O(n) time, which means that creating a list map with n elements will take O(n2) time. This makes the builder suitable only for a small number of elements.
- Annotations
- @SerialVersionUID()
- See also
"Scala's Collection Library overview" section on
List Maps
for more information.
- object ListSet extends IterableFactory[ListSet]
This object provides a set of operations to create ListSet values.
This object provides a set of operations to create ListSet values.
Note that each element insertion takes O(n) time, which means that creating a list set with n elements will take O(n2) time. This makes the builder suitable only for a small number of elements.
- Annotations
- @SerialVersionUID()
- object LongMap extends java.io.Serializable
A companion object for long maps.
- object Map extends MapFactory[Map]
This object provides a set of operations to create
immutable.Map
values.This object provides a set of operations to create
immutable.Map
values.- Annotations
- @SerialVersionUID()
- case object Nil extends List[Nothing] with Product with Serializable
- object NumericRange extends java.io.Serializable
A companion object for numeric ranges.
- object Queue extends StrictOptimizedSeqFactory[Queue]
This object provides a set of operations to create
immutable.Queue
values.This object provides a set of operations to create
immutable.Queue
values.- Annotations
- @SerialVersionUID()
- object Range extends java.io.Serializable
Companion object for ranges.
- object Seq extends Delegate[Seq]
This object provides a set of operations to create
immutable.Seq
values.This object provides a set of operations to create
immutable.Seq
values.- Annotations
- @SerialVersionUID()
- object SeqMap extends MapFactory[SeqMap]
- object Set extends IterableFactory[Set]
This object provides a set of operations to create
immutable.Set
values.This object provides a set of operations to create
immutable.Set
values.- Annotations
- @SerialVersionUID()
- object SortedMap extends Delegate[SortedMap]
- Annotations
- @SerialVersionUID()
- object SortedSet extends Delegate[SortedSet]
This object provides a set of operations to create
immutable.SortedSet
values.This object provides a set of operations to create
immutable.SortedSet
values.- Annotations
- @SerialVersionUID()
- object TreeMap extends SortedMapFactory[TreeMap]
This object provides a set of operations to create immutable.TreeMap values.
This object provides a set of operations to create immutable.TreeMap values.
- Annotations
- @SerialVersionUID()
- object TreeSeqMap extends MapFactory[TreeSeqMap]
- object TreeSet extends SortedIterableFactory[TreeSet]
This object provides a set of operations to create
immutable.TreeSet
values.This object provides a set of operations to create
immutable.TreeSet
values.- Annotations
- @SerialVersionUID()
- object Vector extends StrictOptimizedSeqFactory[Vector]
This object provides a set of operations to create
Vector
values.This object provides a set of operations to create
Vector
values.- Annotations
- @SerialVersionUID()
- object VectorMap extends MapFactory[VectorMap]
- object WrappedString extends SpecificIterableFactory[Char, WrappedString] with java.io.Serializable
A companion object for wrapped strings.
A companion object for wrapped strings.
- Annotations
- @SerialVersionUID()
Deprecated Value Members
- val Traversable: Iterable.type
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) Use Iterable instead of Traversable
- object Stream extends SeqFactory[Stream]
- Annotations
- @deprecated @SerialVersionUID()
- Deprecated
(Since version 2.13.0) Use LazyList (which is fully lazy) instead of Stream (which has a lazy tail only)
This is the documentation for the Scala standard library.
Package structure
The scala package contains core types like
Int
,Float
,Array
orOption
which are accessible in all Scala compilation units without explicit qualification or imports.Notable packages include:
scala.collection
and its sub-packages contain Scala's collections frameworkscala.collection.immutable
- Immutable, sequential data-structures such asVector
,List
,Range
,HashMap
orHashSet
scala.collection.mutable
- Mutable, sequential data-structures such asArrayBuffer
,StringBuilder
,HashMap
orHashSet
scala.collection.concurrent
- Mutable, concurrent data-structures such asTrieMap
scala.concurrent
- Primitives for concurrent programming such asFutures
andPromises
scala.io
- Input and output operationsscala.math
- Basic math functions and additional numeric types likeBigInt
andBigDecimal
scala.sys
- Interaction with other processes and the operating systemscala.util.matching
- Regular expressionsOther packages exist. See the complete list on the right.
Additional parts of the standard library are shipped as separate libraries. These include:
scala.reflect
- Scala's reflection API (scala-reflect.jar)scala.xml
- XML parsing, manipulation, and serialization (scala-xml.jar)scala.collection.parallel
- Parallel collections (scala-parallel-collections.jar)scala.util.parsing
- Parser combinators (scala-parser-combinators.jar)scala.swing
- A convenient wrapper around Java's GUI framework called Swing (scala-swing.jar)Automatic imports
Identifiers in the scala package and the
scala.Predef
object are always in scope by default.Some of these identifiers are type aliases provided as shortcuts to commonly used classes. For example,
List
is an alias forscala.collection.immutable.List
.Other aliases refer to classes provided by the underlying platform. For example, on the JVM,
String
is an alias forjava.lang.String
.