${Add}s a single element to this $coll.

Clears the $coll's contents. After this operation, the $coll is empty.

The empty map of the same type as this map

Optionally returns the value associated with a key.

Iterator can be used only once

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. x.keysIteratorFrom(y) is equivalent to but often more efficient than x.from(y).keysIterator.

Creates a ranged projection of this collection. Any mutations in the ranged projection will update this collection and vice versa.

Note: keys are not guaranteed to be consistent between this collection and the projection. This is the case for buffers where indexing is relative to the projection.

Removes a single element from this shrinkable collection.

Alias for concat

Alias for concat

Alias for concat

Alias for addAllInPlace

${Add}s two or more elements to this $coll.

Alias for add

Alias for subtractAll

Alias for subtract

Alias for subtract

${Add}s all elements produced by a TraversableOnce to this $coll.

Retrieves the value which is associated with the given key. This method invokes the default method of the map if there is no mapping from the given key to a value. Unless overridden, the default method throws a NoSuchElementException.

The class name of this collection. To be used for converting to string. Collections generally print like this:

<className>(elem_1, ..., elem_n)

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

$mayNotTerminateInf $orderDependent

Returns a new $coll containing the elements from the left hand operand followed by the elements from the right hand operand. The element type of the $coll is the most specific superclass encompassing the element types of the two operands.

Tests whether this map contains a binding for a key.

Copy all elements of this collection to array xs, starting at start.

Counts the number of elements in the $coll which satisfy a predicate.

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.

The rest of the collection without its n first elements. For linear, immutable collections this should avoid making a copy.

The rest of the collection without its n last elements. For linear, immutable collections this should avoid making a copy.

Skips longest sequence of elements of this iterator which satisfy given predicate p, and returns an iterator of the remaining elements.

Tests whether a predicate holds for at least one element of this $coll.

$mayNotTerminateInf

Selects all elements of this $coll which satisfy a predicate.

Filters this map by retaining only keys satisfying a predicate.

Selects all elements of this $coll which do not satisfy a predicate.

Finds the first element of the $coll satisfying a predicate, if any.

$mayNotTerminateInf $orderDependent

Returns the first key of the collection.

Flatmap

Fold left

Fold right

Tests whether a predicate holds for all elements of this $coll.

$mayNotTerminateInf

Apply f to each element for its side effects Note: [U] parameter needed to help scalac's type inference.

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

If given key is already in this map, returns associated value.

Otherwise, computes value from given expression op, stores with key in map and returns that value.

Concurrent map implementations may evaluate the expression op multiple times, or may evaluate op without inserting the result.

Partitions this $coll into a map of ${coll}s according to some discriminator function.

Note: When applied to a view or a lazy collection it will always force the elements.

Partitions this $coll into a map of ${coll}s according to a discriminator function key. Each element in a group is transformed into a value of type B using the value function.

It is equivalent to groupBy(key).mapValues(_.map(f)), but more efficient.

case class User(name: String, age: Int)

def namesByAge(users: Seq[User]): Map[Int, Seq[String]] =
  users.groupMap(_.age)(_.name)

Partitions this $coll into a map according to a discriminator function key. All the values that have the same discriminator are then transformed by the value function and then reduced into a single value with the reduce function.

It is equivalent to groupBy(key).mapValues(_.map(f).reduce(reduce)), but more efficient.

def occurrences[A](as: Seq[A]): Map[A, Int] =
  as.groupMapReduce(identity)(_ => 1)(_ + _)

Partitions elements in fixed size ${coll}s.

The first element of the collection.

The initial part of the collection without its last element.

Tests whether this map contains a binding for a key. This method, which implements an abstract method of trait PartialFunction, is equivalent to contains.

Is the collection empty?

Collects all keys of this map in a set.

Collects all keys of this map in an iterable collection.

Creates an iterator for all keys.

The number of elements in this collection, if it can be cheaply computed, -1 otherwise. Cheaply usually means: Not requiring a collection traversal.

Selects the last element. $orderDependent

Returns the last key of the collection.

Optionally selects the last element. $orderDependent

Builds a new collection by applying a function to all elements of this $coll.

Similar to fromIterable, but returns a Map collection type

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

Finds the largest element.

Finds the first element which yields the largest value measured by function f.

Finds the smallest element.

Finds the first element which yields the smallest value measured by function f.

A string showing all elements of this collection, separated by string sep.

Is the collection not empty?

A pair of, first, all elements that satisfy prediacte p and, second, all elements that do not. Interesting because it splits a collection in two.

The default implementation provided here needs to traverse the collection twice. Strict collections have an overridden version of partition in Buildable, which requires only a single traversal.

Multiplies up the elements of this collection.

Adds a new key/value pair to this map and optionally returns previously bound value. If the map already contains a mapping for the key, it will be overridden by the new value.

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

Reduces the elements of this $coll using the specified associative binary operator.

$undefinedorder

Applies a binary operator to all elements of this $coll, going left to right. $willNotTerminateInf $orderDependentFold

Optionally applies a binary operator to all elements of this $coll, going left to right. $willNotTerminateInf $orderDependentFold

Reduces the elements of this $coll, if any, using the specified associative binary operator.

$undefinedorder

Applies a binary operator to all elements of this $coll, going right to left. $willNotTerminateInf $orderDependentFold

Optionally applies a binary operator to all elements of this $coll, going right to left. $willNotTerminateInf $orderDependentFold

Removes a key from this map, returning the value associated previously with that key as an option.

Computes a prefix scan of the elements of the collection.

Note: The neutral element z may be applied more than once.

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

$willNotTerminateInf $orderDependent

Produces a collection containing cumulative results of applying the operator going right to left. The head of the collection is the last cumulative result. $willNotTerminateInf $orderDependent

Example:

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

The number of elements in this collection. Does not terminate for infinite collections.

Selects an interval of elements. The returned collection is made up of all elements x which satisfy the invariant:

from <= indexOf(x) < until

$orderDependent

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

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

Splits this $coll into a prefix/suffix pair according to a predicate.

Note: c span p is equivalent to (but possibly more efficient than) (c takeWhile p, c dropWhile p), provided the evaluation of the predicate p does not cause any side-effects. $orderDependent

Splits this $coll into two at a given position. Note: c splitAt n is equivalent to (but possibly more efficient than) (c take n, c drop n). $orderDependent

Removes two or more elements from this shrinkable collection.

Removes all elements produced by an iterator from this shrinkable collection.

Sums up the elements of this collection.

The rest of the collection without its first element.

A collection containing the first n elements of this collection.

A collection containing the last n elements of this collection.

Takes longest prefix of elements that satisfy a predicate. $orderDependent

Given a collection factory factory, convert this collection to the appropriate representation for the current element type A. Example uses:

xs.to(List) xs.to(ArrayBuffer) xs.to(BitSet) // for xs: Iterable[Int]

Convert collection to array.

The collection itself

Converts this $coll of pairs into two collections of the first and second half of each pair.

val xs = $Coll(
           (1, "one"),
           (2, "two"),
           (3, "three")).unzip
// xs == ($Coll(1, 2, 3),
//        $Coll(one, two, three))

Adds a new key/value pair to this map. If the map already contains a mapping for the key, it will be overridden by the new value.

Collects all values of this map in an iterable collection.

Creates an iterator for all values in this map.

A view representing the elements of this collection.

Creates a non-strict filter of this $coll.

Note: the difference between c filter p and c withFilter p is that the former creates a new collection, whereas the latter only restricts the domain of subsequent map, flatMap, foreach, and withFilter operations. $orderDependent

Returns a $coll formed from this $coll and another iterable collection by combining corresponding elements in pairs. If one of the two collections is longer than the other, its remaining elements are ignored.

Zips this $coll with its indices.