The empty map of the same type as this map

Optionally returns the value associated with a key.

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.

Similar to fromIterable, but returns a Map collection type

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.

Alias for concat

Alias for concat

Alias for concat

Alias for prependAll

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)

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.

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.

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.

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 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?

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.

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.

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

It differs from ++ in that the right operand determines the type of the resulting collection rather than the left one. Mnemonic: the COLon is on the side of the new COLlection type.

Example:

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

scala> val y = Vector(2)
y: scala.collection.immutable.Vector[Int] = Vector(2)

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

Multiplies up the elements of this collection.

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

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

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 fi, 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.

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))

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.