MapLike

def + [B1 >: B] (kv: (A, B1)): Map[A, B1]

Add a key/value pair to this map, returning a new map.

def - (key: A): This

Removes a key from this map, returning a new map.

def empty : This

The empty map of the same type as this map

def get (key: A): Option[B]

Optionally returns the value associated with a key.

def iterator : Iterator[(A, B)]

Creates a new iterator over all key/value pairs of this map

def seq : Map[A, B]

def != (arg0: AnyRef): Boolean

def != (arg0: Any): Boolean

Test two objects for inequality.

def ## (): Int

Equivalent to x.hashCode except for boxed numeric types.

def + [B1 >: B] (elem1: (A, B1), elem2: (A, B1), elems: (A, B1)*): Map[A, B1]

Adds two or more elements to this collection and returns a new collection.

def ++ [B1 >: B] (xs: TraversableOnce[(A, B1)]): Map[A, B1]

def ++ [B1 >: B] (xs: GenTraversableOnce[(A, B1)]): Map[A, B1]

Adds a number of elements provided by a traversable object and returns a new collection with the added elements.

def ++ [B >: (A, B), That] (that: TraversableOnce[B])(implicit bf: CanBuildFrom[This, B, That]): That

def ++ [B] (that: GenTraversableOnce[B]): immutable.Map[B]

[use case] Concatenates this immutable map with the elements of a traversable collection.

def ++ [B >: (A, B), That] (that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[This, B, That]): That

Concatenates this immutable map with the elements of a traversable collection.

def ++: [B >: (A, B), That] (that: Traversable[B])(implicit bf: CanBuildFrom[This, B, That]): That

This overload exists because: for the implementation of ++: we should reuse that of ++ because many collections override it with more efficient versions.

def ++: [B] (that: TraversableOnce[B]): immutable.Map[B]

[use case] Concatenates this immutable map with the elements of a traversable collection.

def ++: [B >: (A, B), That] (that: TraversableOnce[B])(implicit bf: CanBuildFrom[This, B, That]): That

Concatenates this immutable map with the elements of a traversable collection.

def - (elem1: A, elem2: A, elems: A*): This

Creates a new immutable map from this immutable map with some elements removed.

def - (key: A): Map[A, B]

[use case] Removes a key from this map, returning a new map.

def -- (xs: TraversableOnce[A]): This

def -- (xs: GenTraversableOnce[A]): This

Creates a new immutable map from this immutable map by removing all elements of another collection.

def /: [B] (z: B)(op: (B, (A, B)) ⇒ B): B

Applies a binary operator to a start value and all elements of this immutable map, going left to right.

def /:\ [A1 >: (A, B)] (z: A1)(op: (A1, A1) ⇒ A1): A1

A syntactic sugar for out of order folding.

def :\ [B] (z: B)(op: ((A, B), B) ⇒ B): B

Applies a binary operator to all elements of this immutable map and a start value, going right to left.

def == (arg0: AnyRef): Boolean

def == (arg0: Any): Boolean

Test two objects for equality.

def addString (b: StringBuilder, start: String, sep: String, end: String): StringBuilder

Appends all bindings of this map to a string builder using start, end, and separator strings.

def addString (b: StringBuilder): StringBuilder

Appends all elements of this immutable map to a string builder.

def addString (b: StringBuilder, sep: String): StringBuilder

Appends all elements of this immutable map to a string builder using a separator string.

def aggregate [B] (z: B)(seqop: (B, (A, B)) ⇒ B, combop: (B, B) ⇒ B): B

Aggregates the results of applying an operator to subsequent elements.

   pc.aggregate(Set[Int]())(_ += process(_), _ ++ _)

def andThen [C] (k: (B) ⇒ C): PartialFunction[A, C]

Composes this partial function with a transformation function that gets applied to results of this partial function.

def apply (key: A): B

Retrieves the value which is associated with the given key.

def asInstanceOf [T0] : T0

Cast the receiver object to be of type T0.

def canEqual (that: Any): Boolean

Method called from equality methods, so that user-defined subclasses can refuse to be equal to other collections of the same kind.

def clone (): AnyRef

Create a copy of the receiver object.

def collect [B] (pf: PartialFunction[(A, B), B]): immutable.Map[B]

[use case] Builds a new collection by applying a partial function to all elements of this immutable map on which the function is defined.

def collect [B, That] (pf: PartialFunction[(A, B), B])(implicit bf: CanBuildFrom[This, B, That]): That

Builds a new collection by applying a partial function to all elements of this immutable map on which the function is defined.

def collectFirst [B] (pf: PartialFunction[(A, B), B]): Option[B]

Finds the first element of the immutable map for which the given partial function is defined, and applies the partial function to it.

def compose [A] (g: (A) ⇒ A): (A) ⇒ B

Composes two instances of Function1 in a new Function1, with this function applied last.

def contains (key: A): Boolean

Tests whether this map contains a binding for a key.

def copyToArray (xs: Array[(A, B)], start: Int, len: Int): Unit

[use case] Copies elements of this immutable map to an array.

def copyToArray [B >: (A, B)] (xs: Array[B], start: Int, len: Int): Unit

Copies elements of this immutable map to an array.

def copyToArray (xs: Array[(A, B)]): Unit

[use case] Copies values of this immutable map to an array.

def copyToArray [B >: (A, B)] (xs: Array[B]): Unit

Copies values of this immutable map to an array.

def copyToArray (xs: Array[(A, B)], start: Int): Unit

[use case] Copies values of this immutable map to an array.

def copyToArray [B >: (A, B)] (xs: Array[B], start: Int): Unit

Copies values of this immutable map to an array.

def copyToBuffer [B >: (A, B)] (dest: Buffer[B]): Unit

Copies all elements of this immutable map to a buffer.

def count (p: ((A, B)) ⇒ Boolean): Int

Counts the number of elements in the immutable map which satisfy a predicate.

def default (key: A): B

Defines the default value computation for the map, returned when a key is not found The method implemented here throws an exception, but it might be overridden in subclasses.

def drop (n: Int): This

Selects all elements except first n ones.

def dropRight (n: Int): This

Selects all elements except last n ones.

def dropWhile (p: ((A, B)) ⇒ Boolean): This

Drops longest prefix of elements that satisfy a predicate.

def eq (arg0: AnyRef): Boolean

Tests whether the argument (arg0) is a reference to the receiver object (this).

def equals (that: Any): Boolean

Compares two maps structurally; i.

def exists (p: ((A, B)) ⇒ Boolean): Boolean

Tests whether a predicate holds for some of the elements of this immutable map.

def filter (p: ((A, B)) ⇒ Boolean): This

Selects all elements of this immutable map which satisfy a predicate.

def filterKeys (p: (A) ⇒ Boolean): Map[A, B]

Filters this map by retaining only keys satisfying a predicate.

def filterNot (p: ((A, B)) ⇒ Boolean): This

Returns a new map with all key/value pairs for which the predicate p returns true.

def finalize (): Unit

Called by the garbage collector on the receiver object when there are no more references to the object.

def find (p: ((A, B)) ⇒ Boolean): Option[(A, B)]

Finds the first element of the immutable map satisfying a predicate, if any.

def flatMap [B] (f: ((A, B)) ⇒ GenTraversableOnce[B]): immutable.Map[B]

[use case] Builds a new collection by applying a function to all elements of this immutable map and concatenating the results.

def flatMap [B, That] (f: ((A, B)) ⇒ GenTraversableOnce[B])(implicit bf: CanBuildFrom[This, B, That]): That

Builds a new collection by applying a function to all elements of this immutable map and concatenating the results.

def fold [A1 >: (A, B)] (z: A1)(op: (A1, A1) ⇒ A1): A1

Folds the elements of this sequence using the specified associative binary operator.

def foldLeft [B] (z: B)(op: (B, (A, B)) ⇒ B): B

Applies a binary operator to a start value and all elements of this immutable map, going left to right.

def foldRight [B] (z: B)(op: ((A, B), B) ⇒ B): B

Applies a binary operator to all elements of this immutable map and a start value, going right to left.

def forall (p: ((A, B)) ⇒ Boolean): Boolean

Tests whether a predicate holds for all elements of this immutable map.

def foreach (f: ((A, B)) ⇒ Unit): Unit

[use case] Applies a function f to all elements of this immutable map.

def foreach [U] (f: ((A, B)) ⇒ U): Unit

Applies a function f to all elements of this immutable map.

def getClass (): java.lang.Class[_]

A representation that corresponds to the dynamic class of the receiver object.

def getOrElse (key: A, default: ⇒ B): B

[use case] Returns the value associated with a key, or a default value if the key is not contained in the map.

def getOrElse [B1 >: B] (key: A, default: ⇒ B1): B1

Returns the value associated with a key, or a default value if the key is not contained in the map.

def groupBy [K] (f: ((A, B)) ⇒ K): Map[K, This]

Partitions this immutable map into a map of immutable maps according to some discriminator function.

def grouped (size: Int): Iterator[This]

Partitions elements in fixed size immutable maps.

def hasDefiniteSize : Boolean

Tests whether this immutable map is known to have a finite size.

def hashCode (): Int

The hashCode method for reference types.

def head : (A, B)

Selects the first element of this immutable map.

def headOption : Option[(A, B)]

Optionally selects the first element.

def init : This

Selects all elements except the last.

def inits : Iterator[This]

Iterates over the inits of this immutable map.

def isDefinedAt (key: A): Boolean

Tests whether this map contains a binding for a key.

def isEmpty : Boolean

Tests whether the map is empty.

def isInstanceOf [T0] : Boolean

Test whether the dynamic type of the receiver object is T0.

def isTraversableAgain : Boolean

Tests whether this immutable map can be repeatedly traversed.

def keySet : Set[A]

Collects all keys of this map in a set.

def keys : Iterable[A]

Creates an iterator for all keys.

def keysIterator : Iterator[A]

Creates an iterator for all keys.

def last : (A, B)

Selects the last element.

def lastOption : Option[(A, B)]

Optionally selects the last element.

def lift : (A) ⇒ Option[B]

Turns this partial function into an plain function returning an Option result.

def map [B] (f: ((A, B)) ⇒ B): immutable.Map[B]

[use case] Builds a new collection by applying a function to all elements of this immutable map.

def map [B, That] (f: ((A, B)) ⇒ B)(implicit bf: CanBuildFrom[This, B, That]): That

Builds a new collection by applying a function to all elements of this immutable map.

def mapValues [C] (f: (B) ⇒ C): Map[A, C]

Transforms this map by applying a function to every retrieved value.

def max : (A, B)

[use case] Finds the largest element.

def max [B >: (A, B)] (implicit cmp: Ordering[B]): (A, B)

Finds the largest element.

def maxBy [B] (f: ((A, B)) ⇒ B)(implicit cmp: Ordering[B]): (A, B)

def min : (A, B)

[use case] Finds the smallest element.

def min [B >: (A, B)] (implicit cmp: Ordering[B]): (A, B)

Finds the smallest element.

def minBy [B] (f: ((A, B)) ⇒ B)(implicit cmp: Ordering[B]): (A, B)

def mkString : String

Displays all elements of this immutable map in a string.

def mkString (sep: String): String

Displays all elements of this immutable map in a string using a separator string.

def mkString (start: String, sep: String, end: String): String

Displays all elements of this immutable map in a string using start, end, and separator strings.

def ne (arg0: AnyRef): Boolean

Equivalent to !(this eq that).

def newBuilder : Builder[(A, B), This]

A common implementation of newBuilder for all maps in terms of empty.

def nonEmpty : Boolean

Tests whether the immutable map is not empty.

def notify (): Unit

Wakes up a single thread that is waiting on the receiver object's monitor.

def notifyAll (): Unit

Wakes up all threads that are waiting on the receiver object's monitor.

def orElse [A1 <: A, B1 >: B] (that: PartialFunction[A1, B1]): PartialFunction[A1, B1]

Composes this partial function with a fallback partial function which gets applied where this partial function is not defined.

def par : ParMap[A, B]

Returns a parallel implementation of this collection.

def parCombiner : Combiner[(A, B), ParMap[A, B]]

The default par implementation uses the combiner provided by this method to create a new parallel collection.

def partition (p: ((A, B)) ⇒ Boolean): (This, This)

Partitions this immutable map in two immutable maps according to a predicate.

def product : (A, B)

[use case] Multiplies up the elements of this collection.

def product [B >: (A, B)] (implicit num: Numeric[B]): B

Multiplies up the elements of this collection.

def reduce [A1 >: (A, B)] (op: (A1, A1) ⇒ A1): A1

Reduces the elements of this sequence using the specified associative binary operator.

def reduceLeft [B >: (A, B)] (op: (B, (A, B)) ⇒ B): B

def reduceLeftOption [B >: (A, B)] (op: (B, (A, B)) ⇒ B): Option[B]

Optionally applies a binary operator to all elements of this immutable map, going left to right.

def reduceOption [A1 >: (A, B)] (op: (A1, A1) ⇒ A1): Option[A1]

Optionally reduces the elements of this sequence using the specified associative binary operator.

def reduceRight [B >: (A, B)] (op: ((A, B), B) ⇒ B): B

Applies a binary operator to all elements of this immutable map, going right to left.

def reduceRightOption [B >: (A, B)] (op: ((A, B), B) ⇒ B): Option[B]

Optionally applies a binary operator to all elements of this immutable map, going right to left.

def repr : This

The collection of type immutable map underlying this TraversableLike object.

def reversed : List[(A, B)]

def sameElements [B >: (A, B)] (that: Iterable[B]): Boolean

def sameElements (that: GenIterable[(A, B)]): Boolean

[use case] Checks if the other iterable collection contains the same elements in the same order as this immutable map.

def sameElements [B >: (A, B)] (that: GenIterable[B]): Boolean

Checks if the other iterable collection contains the same elements in the same order as this immutable map.

def scan [B >: (A, B), That] (z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[This, B, That]): That

Computes a prefix scan of the elements of the collection.

def scanLeft [B, That] (z: B)(op: (B, (A, B)) ⇒ B)(implicit bf: CanBuildFrom[This, B, That]): That

Produces a collection containing cummulative results of applying the operator going left to right.

def scanRight [B, That] (z: B)(op: ((A, B), B) ⇒ B)(implicit bf: CanBuildFrom[This, B, That]): That

Produces a collection containing cummulative results of applying the operator going right to left.

   List(1, 2, 3, 4).scanRight(0)(_ + _) == List(10, 9, 7, 4, 0)

def size : Int

The size of this immutable map.

def slice (from: Int, until: Int): This

Selects an interval of elements.

   from <= indexOf(x) < until

def sliding [B >: (A, B)] (size: Int, step: Int): Iterator[This]

def sliding [B >: (A, B)] (size: Int): Iterator[This]

Groups elements in fixed size blocks by passing a "sliding window" over them (as opposed to partitioning them, as is done in grouped.

def span (p: ((A, B)) ⇒ Boolean): (This, This)

Splits this immutable map into a prefix/suffix pair according to a predicate.

def splitAt (n: Int): (This, This)

Splits this immutable map into two at a given position.

def stringPrefix : String

Defines the prefix of this object's toString representation.

def sum : (A, B)

[use case] Sums up the elements of this collection.

def sum [B >: (A, B)] (implicit num: Numeric[B]): B

Sums up the elements of this collection.

def synchronized [T0] (arg0: ⇒ T0): T0

def tail : This

Selects all elements except the first.

def tails : Iterator[This]

Iterates over the tails of this immutable map.

def take (n: Int): This

Selects first n elements.

def takeRight (n: Int): This

Selects last n elements.

def takeWhile (p: ((A, B)) ⇒ Boolean): This

Takes longest prefix of elements that satisfy a predicate.

def thisCollection : Iterable[(A, B)]

The underlying collection seen as an instance of immutable.Map.

def toArray : Array[(A, B)]

[use case] Converts this immutable map to an array.

def toArray [B >: (A, B)] (implicit arg0: ClassManifest[B]): Array[B]

Converts this immutable map to an array.

def toBuffer [C >: (A, B)] : Buffer[C]

Converts this immutable map to a mutable buffer.

def toCollection (repr: This): Iterable[(A, B)]

A conversion from collections of type Repr to immutable.Map objects.

def toIndexedSeq [B >: (A, B)] : IndexedSeq[B]

Converts this immutable map to an indexed sequence.

def toIterable : Iterable[(A, B)]

Converts this immutable map to an iterable collection.

def toIterator : Iterator[(A, B)]

Returns an Iterator over the elements in this immutable map.

def toList : List[(A, B)]

Converts this immutable map to a list.

def toMap [T, U] : Map[T, U]

[use case] Converts this immutable map to a map.

def toMap [T, U] (implicit ev: <:<[(A, B), (T, U)]): Map[T, U]

Converts this immutable map to a map.

def toSeq : Seq[(A, B)]

Overridden for efficiency.

def toSet [B >: (A, B)] : Set[B]

Converts this immutable map to a set.

def toStream : Stream[(A, B)]

Converts this immutable map to a stream.

def toString (): String

Converts this immutable map to a string.

def toTraversable : Traversable[(A, B)]

Converts this immutable map to an unspecified Traversable.

def transform [C, That] (f: (A, B) ⇒ C)(implicit bf: CanBuildFrom[This, (A, C), That]): That

This function transforms all the values of mappings contained in this map with function f.

def updated [B1 >: B] (key: A, value: B1): Map[A, B1]

A new immutable map containing updating this map with a given key/value mapping.

def values : Iterable[B]

Collects all values of this map in an iterable collection.

def valuesIterator : Iterator[B]

Creates an iterator for all values in this map.

def view (from: Int, until: Int): IterableView[(A, B), This]

Creates a non-strict view of a slice of this immutable map.

def view : IterableView[(A, B), This]

Creates a non-strict view of this immutable map.

def wait (): Unit

def wait (arg0: Long, arg1: Int): Unit

def wait (arg0: Long): Unit

def withFilter (p: ((A, B)) ⇒ Boolean): FilterMonadic[(A, B), This]

Creates a non-strict filter of this immutable map.

def zip [A1 >: (A, B), B, That] (that: Iterable[B])(implicit bf: CanBuildFrom[This, (A1, B), That]): That

def zip [B] (that: GenIterable[B]): immutable.Map[((A, B), B)]

[use case] Returns a immutable map formed from this immutable map and another iterable collection by combining corresponding elements in pairs.

def zip [A1 >: (A, B), B, That] (that: GenIterable[B])(implicit bf: CanBuildFrom[This, (A1, B), That]): That

Returns a immutable map formed from this immutable map and another iterable collection by combining corresponding elements in pairs.

def zipAll [B, A1 >: (A, B), That] (that: Iterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[This, (A1, B), That]): That

def zipAll [B] (that: Iterable[B], thisElem: (A, B), thatElem: B): immutable.Map[((A, B), B)]

[use case] Returns a immutable map formed from this immutable map and another iterable collection by combining corresponding elements in pairs.

def zipAll [B, A1 >: (A, B), That] (that: GenIterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[This, (A1, B), That]): That

Returns a immutable map formed from this immutable map and another iterable collection by combining corresponding elements in pairs.

def zipWithIndex : immutable.Map[((A, B), Int)]

[use case] Zips this immutable map with its indices.

def zipWithIndex [A1 >: (A, B), That] (implicit bf: CanBuildFrom[This, (A1, Int), That]): That

Zips this immutable map with its indices.

def elements : Iterator[(A, B)]

def first : (A, B)

def firstOption : Option[(A, B)]

None if iterable is empty.

def mapElements [C] (f: (B) ⇒ C): Map[A, C]

def projection : IterableView[(A, B), This]

returns a projection that can be used to call non-strict filter, map, and flatMap methods that build projections of the collection.