SortedMap

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

Optionally returns the value associated with a key.

abstract def iterator: Iterator[(A, B)]

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

abstract def iteratorFrom(start: A): Iterator[(A, B)]

Creates an iterator over all the key/value pairs contained in this map having a key greater than or equal to start according to the ordering of this map.

abstract def keysIteratorFrom(start: A): Iterator[A]

Creates an iterator over all the keys(or elements) contained in this collection greater than or equal to start according to the ordering of this collection.

implicit abstract def ordering: Ordering[A]

abstract def rangeImpl(from: Option[A], until: Option[A]): SortedMap[A, B]

Creates a ranged projection of this collection.

abstract def valuesIteratorFrom(start: A): Iterator[B]

Creates an iterator over all the values contained in this map that are associated with a key greater than or equal to start according to the ordering of this map.

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

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

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

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

Add a key/value pair to this map.

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

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

def ++[B](that: GenTraversableOnce[B]): SortedMap[B]

[use case] Returns a new immutable sorted map containing the elements from the left hand operand followed by the elements from the right hand operand.

scala> val a = LinkedList(1)
a: scala.collection.mutable.LinkedList[Int] = LinkedList(1)

scala> val b = LinkedList(2)
b: scala.collection.mutable.LinkedList[Int] = LinkedList(2)

scala> val c = a ++ b
c: scala.collection.mutable.LinkedList[Int] = LinkedList(1, 2)

scala> val d = LinkedList('a')
d: scala.collection.mutable.LinkedList[Char] = LinkedList(a)

scala> val e = c ++ d
e: scala.collection.mutable.LinkedList[AnyVal] = LinkedList(1, 2, a)

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

As with ++, returns a new collection containing the elements from the left operand followed by the elements from the right operand.

scala> val x = List(1)
x: List[Int] = List(1)

scala> val y = LinkedList(2)
y: scala.collection.mutable.LinkedList[Int] = LinkedList(2)

scala> val z = x ++: y
z: scala.collection.mutable.LinkedList[Int] = LinkedList(1, 2)

def ++:[B](that: TraversableOnce[B]): SortedMap[B]

[use case] As with ++, returns a new collection containing the elements from the left operand followed by the elements from the right operand.

scala> val x = List(1)
x: List[Int] = List(1)

scala> val y = LinkedList(2)
y: scala.collection.mutable.LinkedList[Int] = LinkedList(2)

scala> val z = x ++: y
z: scala.collection.mutable.LinkedList[Int] = LinkedList(1, 2)

def -(elem1: A, elem2: A, elems: A*): SortedMap[A, B]

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

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

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

def --(xs: GenTraversableOnce[A]): SortedMap[A, B]

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

def ->[B](y: B): (SortedMap[A, B], B)

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

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

scala> val a = LinkedList(1,2,3,4)
a: scala.collection.mutable.LinkedList[Int] = LinkedList(1, 2, 3, 4)

scala> val b = (5 /: a)(_+_)
b: Int = 15

scala> val c = (5 /: a)((x,y) => x + y)
c: Int = 15

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

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

scala> val a = LinkedList(1,2,3,4)
a: scala.collection.mutable.LinkedList[Int] = LinkedList(1, 2, 3, 4)

scala> val b = (a :\ 5)(_+_)
b: Int = 15

scala> val c = (a :\ 5)((x,y) => x + y)
c: Int = 15

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

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 sorted map to a string builder.

scala> val a = LinkedList(1,2,3,4)
a: scala.collection.mutable.LinkedList[Int] = LinkedList(1, 2, 3, 4)

scala> val b = new StringBuilder()
b: StringBuilder =

scala> val h = a.addString(b)
b: StringBuilder = 1234

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

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

scala> val a = LinkedList(1,2,3,4)
a: scala.collection.mutable.LinkedList[Int] = LinkedList(1, 2, 3, 4)

scala> val b = new StringBuilder()
b: StringBuilder =

scala> a.addString(b, ", ")
res0: StringBuilder = 1, 2, 3, 4

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 applyOrElse[A1 <: A, B1 >: B](x: A1, default: (A1) ⇒ B1): B1

Applies this partial function to the given argument when it is contained in the function domain.

if(pf isDefinedAt x) pf(x) else default(x)

final def asInstanceOf[T0]: T0

def asParIterable: ParIterable[(A, B)]

def asParSeq: ParSeq[(A, B)]

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

def collect[B](pf: PartialFunction[A, B]): SortedMap[B]

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

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

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

def companion: GenericCompanion[Iterable]

The factory companion object that builds instances of class immutable.

def compare(k0: A, k1: A): Int

Comparison function that orders keys.

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], start: Int, len: Int): Unit

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

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

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

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

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

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

Copies all elements of this immutable sorted map to a buffer.

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

Counts the number of elements in the immutable sorted 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): SortedMap[A, B]

Selects all elements except first n ones.

def dropRight(n: Int): SortedMap[A, B]

Selects all elements except last n ones.

def dropWhile(p: ((A, B)) ⇒ Boolean): SortedMap[A, B]

Drops longest prefix of elements that satisfy a predicate.

def empty: SortedMap[A, B]

Needs to be overridden in subclasses.

def ensuring(cond: (SortedMap[A, B]) ⇒ Boolean, msg: ⇒ Any): SortedMap[A, B]

def ensuring(cond: (SortedMap[A, B]) ⇒ Boolean): SortedMap[A, B]

def ensuring(cond: Boolean, msg: ⇒ Any): SortedMap[A, B]

def ensuring(cond: Boolean): SortedMap[A, B]

final def eq(arg0: AnyRef): Boolean

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 sorted map.

def filter(p: ((A, B)) ⇒ Boolean): SortedMap[A, B]

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

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

Filters this map by retaining only keys satisfying a predicate.

def filterNot(p: ((A, B)) ⇒ Boolean): SortedMap[A, B]

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

def finalize(): Unit

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

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

def firstKey: A

Returns the first key of the collection.

def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): SortedMap[B]

[use case] Builds a new collection by applying a function to all elements of this immutable sorted map and using the elements of the resulting collections.

def getWords(lines: Seq[String]): Seq[String] = lines flatMap (line => line split "\\W+")

// lettersOf will return a Seq[Char] of likely repeated letters, instead of a Set
def lettersOf(words: Seq[String]) = words flatMap (word => word.toSet)

// lettersOf will return a Set[Char], not a Seq
def lettersOf(words: Seq[String]) = words.toSet flatMap (word => word.toSeq)

// xs will be an Iterable[Int]
val xs = Map("a" -> List(11,111), "b" -> List(22,222)).flatMap(_._2)

// ys will be a Map[Int, Int]
val ys = Map("a" -> List(1 -> 11,1 -> 111), "b" -> List(2 -> 22,2 -> 222)).flatMap(_._2)

def flatten[B]: SortedMap[B]

[use case] Converts this immutable sorted map of traversable collections into a immutable sorted map formed by the elements of these traversable collections.

val xs = List(Set(1, 2, 3), Set(1, 2, 3))
// xs == List(1, 2, 3, 1, 2, 3)

val ys = Set(List(1, 2, 3), List(3, 2, 1))
// ys == Set(1, 2, 3)

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

Folds the elements of this immutable sorted map 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 sorted 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 sorted 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 sorted map.

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

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

def formatted(fmtstr: String): String

Returns string formatted according to given format string.

def from(from: A): SortedMap[A, B]

Creates a ranged projection of this collection with no upper-bound.

def genericBuilder[B]: Builder[B, Iterable[B]]

The generic builder that builds instances of immutable.

final def getClass(): Class[_]

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 groupBy[K](f: ((A, B)) ⇒ K): Map[K, SortedMap[A, B]]

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

def grouped(size: Int): Iterator[SortedMap[A, B]]

Partitions elements in fixed size immutable sorted maps.

def hasAll(j: Iterator[A]): Boolean

def hasDefiniteSize: Boolean

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

def hashCode(): Int

def head: (A, B)

Selects the first element of this immutable sorted map.

def headOption: Option[(A, B)]

Optionally selects the first element.

def ifParSeq[R](isbody: (ParSeq[(A, B)]) ⇒ R): (TraversableOps[(A, B)])#Otherwise[R]

def init: SortedMap[A, B]

Selects all elements except the last.

def inits: Iterator[SortedMap[A, B]]

Iterates over the inits of this immutable sorted 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.

final def isInstanceOf[T0]: Boolean

def isParIterable: Boolean

def isParSeq: Boolean

def isParallel: Boolean

final def isTraversableAgain: Boolean

Tests whether this immutable sorted map can be repeatedly traversed.

def keySet: SortedSet[A]

Collects all keys of this map in a set.

def keys: collection.Iterable[A]

Collects all keys of this map in an iterable collection.

def keysIterator: Iterator[A]

Creates an iterator for all keys.

def last: (A, B)

Selects the last element.

def lastKey: A

Returns the last key of the collection.

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): SortedMap[B]

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

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

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

def max: A

[use case] Finds the largest element.

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

def min: A

[use case] 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 sorted map in a string.

def mkString(sep: String): String

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

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

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

final def ne(arg0: AnyRef): Boolean

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

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

def nonEmpty: Boolean

Tests whether the immutable sorted map is not empty.

final def notify(): Unit

final def notifyAll(): Unit

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): (SortedMap[A, B], SortedMap[A, B])

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

def product: A

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

def range(from: A, until: A): SortedMap[A, B]

Creates a ranged projection of this collection with both a lower-bound and an upper-bound.

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

Reduces the elements of this immutable sorted map using the specified associative binary operator.

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

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

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

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

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

Reduces the elements of this immutable sorted map, if any, 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 sorted 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 sorted map, going right to left.

def repr: SortedMap[A, B]

The collection of type immutable sorted map underlying this TraversableLike object.

def reversed: scala.List[(A, B)]

def runWith[U](action: (B) ⇒ U): (A) ⇒ Boolean

Composes this partial function with an action function which gets applied to results of this partial function.

if(pf isDefinedAt x) { action(pf(x)); true } else false

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

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

def scan[B >: (A, B), That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[SortedMap[A, B], 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[SortedMap[A, B], B, That]): That

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

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

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

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

def seq: Map[A, B]

A version of this collection with all of the operations implemented sequentially (i.

def size: Int

The size of this immutable sorted map.

def slice(from: Int, until: Int): SortedMap[A, B]

Selects an interval of elements.

from <= indexOf(x) < until

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

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

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

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): (SortedMap[A, B], SortedMap[A, B])

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

def splitAt(n: Int): (SortedMap[A, B], SortedMap[A, B])

Splits this immutable sorted map into two at a given position.

def stringPrefix: String

Defines the prefix of this object's toString representation.

def sum: A

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

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

def tail: SortedMap[A, B]

Selects all elements except the first.

def tails: Iterator[SortedMap[A, B]]

Iterates over the tails of this immutable sorted map.

def take(n: Int): SortedMap[A, B]

Selects first n elements.

def takeRight(n: Int): SortedMap[A, B]

Selects last n elements.

def takeWhile(p: ((A, B)) ⇒ Boolean): SortedMap[A, B]

Takes longest prefix of elements that satisfy a predicate.

def thisCollection: collection.Iterable[(A, B)]

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

def to(to: A): SortedMap[A, B]

Create a range projection of this collection with no lower-bound.

def to[Col[_]]: Col[A]

[use case] Converts this immutable sorted map into another by copying all elements.

def toArray: Array[A]

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

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

Converts this immutable sorted map to a mutable buffer.

def toCollection(repr: SortedMap[A, B]): collection.Iterable[(A, B)]

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

def toIndexedSeq: IndexedSeq[(A, B)]

Converts this immutable sorted map to an indexed sequence.

def toIterable: collection.Iterable[(A, B)]

Converts this immutable sorted map to an iterable collection.

def toIterator: Iterator[(A, B)]

Returns an Iterator over the elements in this immutable sorted map.

def toList: scala.List[(A, B)]

Converts this immutable sorted map to a list.

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

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

def toParArray: ParArray[(A, B)]

def toSeq: collection.Seq[(A, B)]

Converts this immutable sorted map to a sequence.

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

Converts this immutable sorted map to a set.

def toStream: Stream[(A, B)]

Converts this immutable sorted map to a stream.

def toString(): String

Converts this immutable sorted map to a string.

def toTraversable: collection.Traversable[(A, B)]

Converts this immutable sorted map to an unspecified Traversable.

def toVector: scala.Vector[(A, B)]

Converts this immutable sorted map to a Vector.

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

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

def transpose[B](implicit asTraversable: ((A, B)) ⇒ GenTraversableOnce[B]): Iterable[Iterable[B]]

Transposes this immutable sorted map of traversable collections into a immutable sorted map of immutable sorted maps.

def until(until: A): SortedMap[A, B]

Creates a ranged projection of this collection with no lower-bound.

def unzip[A1, A2](implicit asPair: ((A, B)) ⇒ (A1, A2)): (Iterable[A1], Iterable[A2])

Converts this immutable sorted map of pairs into two collections of the first and second half of each pair.

def unzip3[A1, A2, A3](implicit asTriple: ((A, B)) ⇒ (A1, A2, A3)): (Iterable[A1], Iterable[A2], Iterable[A3])

Converts this immutable sorted map of triples into three collections of the first, second, and third element of each triple.

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

Add a key/value pair to this map.

def values: collection.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), SortedMap[A, B]]

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

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

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

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withDefault[B1 >: B](d: (A) ⇒ B1): Map[A, B1]

The same map with a given default function.

def withDefaultValue[B1 >: B](d: B1): Map[A, B1]

The same map with a given default value.

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

Creates a non-strict filter of this immutable sorted map.

def zip[B](that: GenIterable[B]): SortedMap[(A, B)]

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

def zipAll[B](that: collection.Iterable[B], thisElem: A, thatElem: B): SortedMap[(A, B)]

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

def zipWithIndex: SortedMap[(A, Int)]

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

def →[B](y: B): (SortedMap[A, B], B)

def +(other: String): String

def filter(p: ((A, B)) ⇒ Boolean): TraversableOnce[(A, B)]

def flatMap[B](f: ((A, B)) ⇒ GenTraversableOnce[B]): TraversableOnce[B]

def map[B](f: ((A, B)) ⇒ B): TraversableOnce[B]

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