AbstractSeq

Alias for prepended.

Note that :-ending operators are right associative (see example). A mnemonic for +: vs. :+ is: the COLon goes on the COLlection side.

Alias for appended

Note that :-ending operators are right associative (see example). A mnemonic for +: vs. :+ is: the COLon goes on the COLlection side.

Appends all elements of this collection to a string builder. The written text consists of the string representations (w.r.t. the method toString) of all elements of this collection without any separator string.

Example:

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

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

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

Appends all elements of this collection to a string builder using a separator string. The written text consists of the string representations (w.r.t. the method toString) of all elements of this collection, separated by the string sep.

Example:

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

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

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

Appends all elements of this collection to a string builder using start, end, and separator strings. The written text begins with the string start and ends with the string end. Inside, the string representations (w.r.t. the method toString) of all elements of this collection are separated by the string sep.

Example:

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

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

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

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

Note that calling isDefinedAt on the resulting partial function may apply the first partial function and execute its side effect. It is highly recommended to call applyOrElse instead of isDefinedAt / apply for efficiency.

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

If the runtime type of the function is a PartialFunction then the other andThen method is used (note its cautions).

A copy of this sequence with an element appended.

Note: will not terminate for infinite-sized collections.

Example:

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

scala> val b = a :+ 2
b: List[Int] = List(1, 2)

scala> println(a)
List(1)

Applies this partial function to the given argument when it is contained in the function domain. Applies fallback function where this partial function is not defined.

Note that expression pf.applyOrElse(x, default) is equivalent to

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

except that applyOrElse method can be implemented more efficiently. For all partial function literals the compiler generates an applyOrElse implementation which avoids double evaluation of pattern matchers and guards. This makes applyOrElse the basis for the efficient implementation for many operations and scenarios, such as:

- combining partial functions into orElse/andThen chains does not lead to excessive apply/isDefinedAt evaluation - lift and unlift do not evaluate source functions twice on each invocation - runWith allows efficient imperative-style combining of partial functions with conditionally applied actions

For non-literal partial function classes with nontrivial isDefinedAt method it is recommended to override applyOrElse with custom implementation that avoids double isDefinedAt evaluation. This may result in better performance and more predictable behavior w.r.t. side effects.

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

Note: may not terminate for infinite-sized collections.

Note: might return different results for different runs, unless the underlying collection type is ordered.

Iterates over combinations. A _combination_ of length n is a subsequence of the original sequence, with the elements taken in order. Thus, "xy" and "yy" are both length-2 combinations of "xyy", but "yx" is not. If there is more than one way to generate the same subsequence, only one will be returned.

For example, "xyyy" has three different ways to generate "xy" depending on whether the first, second, or third "y" is selected. However, since all are identical, only one will be chosen. Which of the three will be taken is an implementation detail that is not defined.

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

Composes another partial function k with this partial function so that this partial function gets applied to results of k.

Note that calling isDefinedAt on the resulting partial function may apply the first partial function and execute its side effect. It is highly recommended to call applyOrElse instead of isDefinedAt / apply for efficiency.

Tests whether this sequence contains a given value as an element.

Note: may not terminate for infinite-sized collections.

Tests whether this sequence contains a given sequence as a slice.

Note: may not terminate for infinite-sized collections.

Copy elements to an array, returning the number of elements written.

Fills the given array xs starting at index start with at most len elements of this collection.

Copying will stop once either all the elements of this collection have been copied, or the end of the array is reached, or len elements have been copied.

Copy elements to an array, returning the number of elements written.

Fills the given array xs starting at index start with values of this collection.

Copying will stop once either all the elements of this collection have been copied, or the end of the array is reached.

Copy elements to an array, returning the number of elements written.

Fills the given array xs starting at index start with values of this collection.

Copying will stop once either all the elements of this collection have been copied, or the end of the array is reached.

Tests whether every element of this collection's iterator relates to the corresponding element of another collection by satisfying a test predicate.

Note: will not terminate for infinite-sized collections.

Counts the number of elements in the collection which satisfy a predicate.

Note: will not terminate for infinite-sized collections.

Selects all elements except last n ones.

Note: might return different results for different runs, unless the underlying collection type is ordered.

Tests whether this sequence ends with the given sequence.

Note: will not terminate for infinite-sized collections.

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

Note: may not terminate for infinite-sized collections.

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

Note: may not terminate for infinite-sized collections.

Note: might return different results for different runs, unless the underlying collection type is ordered.

Finds the last element of the sequence satisfying a predicate, if any.

Note: will not terminate for infinite-sized collections.

Folds the elements of this collection using the specified associative binary operator. The default implementation in IterableOnce is equivalent to foldLeft but may be overridden for more efficient traversal orders.

The order in which operations are performed on elements is unspecified and may be nondeterministic.

Note: will not terminate for infinite-sized collections.

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

Note: will not terminate for infinite-sized collections.

Note: might return different results for different runs, unless the underlying collection type is ordered or the operator is associative and commutative.

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

Note: will not terminate for infinite-sized collections.

Note: might return different results for different runs, unless the underlying collection type is ordered or the operator is associative and commutative.

Tests whether a predicate holds for all elements of this collection.

Note: may not terminate for infinite-sized collections.

Partitions this iterable collection into a map of iterable collections according to some discriminator function.

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

Partitions this iterable collection into a map of iterable collections 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)

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

Partitions this iterable collection into a map according to a discriminator function key. All the values that have the same discriminator are then transformed by the f 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)(_ + _)

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

Selects the first element of this iterable collection.

Note: might return different results for different runs, unless the underlying collection type is ordered.

Optionally selects the first element.

Note: might return different results for different runs, unless the underlying collection type is ordered.

Finds first index where this sequence contains a given sequence as a slice.

Note: may not terminate for infinite-sized collections.

Finds first index after or at a start index where this sequence contains a given sequence as a slice.

Note: may not terminate for infinite-sized collections.

Finds index of the first element satisfying some predicate.

Note: may not terminate for infinite-sized collections.

Finds index of the first element satisfying some predicate after or at some start index.

Note: may not terminate for infinite-sized collections.

Produces the range of all indices of this sequence.

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

The initial part of the collection without its last element.

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

Iterates over the inits of this iterable collection. The first value will be this iterable collection and the final one will be an empty iterable collection, with the intervening values the results of successive applications of init.

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

Tests whether this sequence contains given index.

The implementations of methods apply and isDefinedAt turn a Seq[A] into a PartialFunction[Int, A].

Selects the last element.

Note: might return different results for different runs, unless the underlying collection type is ordered.

Finds index of last occurrence of some value in this sequence before or at a given end index.

Note: will not terminate for infinite-sized collections.

Finds last index where this sequence contains a given sequence as a slice.

Note: will not terminate for infinite-sized collections.

Finds last index before or at a given end index where this sequence contains a given sequence as a slice.

Note: will not terminate for infinite-sized collections.

Finds index of last element satisfying some predicate.

Note: will not terminate for infinite-sized collections.

Finds index of last element satisfying some predicate before or at given end index.

Note: will not terminate for infinite-sized collections.

Optionally selects the last element.

Note: might return different results for different runs, unless the underlying collection type is ordered.

Analogous to zip except that the elements in each collection are not consumed until a strict operation is invoked on the returned LazyZip2 decorator.

Calls to lazyZip can be chained to support higher arities (up to 4) without incurring the expense of constructing and deconstructing intermediary tuples.

val xs = List(1, 2, 3)
val res = (xs lazyZip xs lazyZip xs lazyZip xs).map((a, b, c, d) => a + b + c + d)
// res == List(4, 8, 12)

Returns a value class containing operations for comparing the length of this sequence to a test value.

These operations are implemented in terms of lengthCompare(Int), and allow the following more readable usages:

this.lengthIs < len     // this.lengthCompare(len) < 0
this.lengthIs <= len    // this.lengthCompare(len) <= 0
this.lengthIs == len    // this.lengthCompare(len) == 0
this.lengthIs != len    // this.lengthCompare(len) != 0
this.lengthIs >= len    // this.lengthCompare(len) >= 0
this.lengthIs > len     // this.lengthCompare(len) > 0

Finds the largest element.

Note: will not terminate for infinite-sized collections.

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

Note: will not terminate for infinite-sized collections.

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

Note: will not terminate for infinite-sized collections.

Finds the largest element.

Note: will not terminate for infinite-sized collections.

Finds the smallest element.

Note: will not terminate for infinite-sized collections.

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

Note: will not terminate for infinite-sized collections.

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

Note: will not terminate for infinite-sized collections.

Finds the smallest element.

Note: will not terminate for infinite-sized collections.

Displays all elements of this collection in a string.

Delegates to addString, which can be overridden.

Displays all elements of this collection in a string using a separator string.

Delegates to addString, which can be overridden.

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

Delegates to addString, which can be overridden.

A pair of, first, all elements that satisfy predicate 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 StrictOptimizedIterableOps, which requires only a single traversal.

Applies a function f to each element of the iterable collection and returns a pair of iterable collections: the first one made of those values returned by f that were wrapped in scala.util.Left, and the second one made of those wrapped in scala.util.Right.

Example:

val xs = Iterable(1, "one", 2, "two", 3, "three") partitionMap {
 case i: Int => Left(i)
 case s: String => Right(s)
}
// xs == (Iterable(1, 2, 3),
//        Iterable(one, two, three))

Produces a new sequence where a slice of elements in this sequence is replaced by another sequence.

Patching at negative indices is the same as patching starting at 0. Patching at indices at or larger than the length of the original sequence appends the patch to the end. If more values are replaced than actually exist, the excess is ignored.

Iterates over distinct permutations.

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

A copy of the sequence with an element prepended.

Also, the original sequence is not modified, so you will want to capture the result.

Example:

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

scala> val y = 2 +: x
y: List[Int] = List(2, 1)

scala> println(x)
List(1)

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.

Multiplies up the elements of this collection.

Note: will not terminate for infinite-sized collections.

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

The order in which operations are performed on elements is unspecified and may be nondeterministic.

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

Note: will not terminate for infinite-sized collections.

Note: might return different results for different runs, unless the underlying collection type is ordered or the operator is associative and commutative.

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

Note: will not terminate for infinite-sized collections.

Note: might return different results for different runs, unless the underlying collection type is ordered or the operator is associative and commutative.

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

The order in which operations are performed on elements is unspecified and may be nondeterministic.

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

Note: will not terminate for infinite-sized collections.

Note: might return different results for different runs, unless the underlying collection type is ordered or the operator is associative and commutative.

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

Note: will not terminate for infinite-sized collections.

Note: might return different results for different runs, unless the underlying collection type is ordered or the operator is associative and commutative.

Returns new sequence with elements in reversed order.

Note: will not terminate for infinite-sized collections.

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

An iterator yielding elements in reversed order.

Note: will not terminate for infinite-sized collections.

Note: xs.reverseIterator is the same as xs.reverse.iterator but might be more efficient.

Composes this partial function with an action function which gets applied to results of this partial function. The action function is invoked only for its side effects; its result is ignored.

Note that expression pf.runWith(action)(x) is equivalent to

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

except that runWith is implemented via applyOrElse and thus potentially more efficient. Using runWith avoids double evaluation of pattern matchers and guards for partial function literals.

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 right to left. The head of the collection is the last cumulative result.

Note: will not terminate for infinite-sized collections.

Note: might return different results for different runs, unless the underlying collection type is ordered.

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

Example:

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

Search within an interval in this sorted sequence for a specific element. If this sequence is an IndexedSeq, a binary search is used. Otherwise, a linear search is used.

The sequence should be sorted with the same Ordering before calling; otherwise, the results are undefined.

Search this sorted sequence for a specific element. If the sequence is an IndexedSeq, a binary search is used. Otherwise, a linear search is used.

The sequence should be sorted with the same Ordering before calling; otherwise, the results are undefined.

Computes the length of the longest segment that starts from some index and whose elements all satisfy some predicate.

Note: may not terminate for infinite-sized collections.

Computes the length of the longest segment that starts from the first element and whose elements all satisfy some predicate.

Note: may not terminate for infinite-sized collections.

Returns a value class containing operations for comparing the size of this iterable collection to a test value.

These operations are implemented in terms of sizeCompare(Int), and allow the following more readable usages:

this.sizeIs < size     // this.sizeCompare(size) < 0
this.sizeIs <= size    // this.sizeCompare(size) <= 0
this.sizeIs == size    // this.sizeCompare(size) == 0
this.sizeIs != size    // this.sizeCompare(size) != 0
this.sizeIs >= size    // this.sizeCompare(size) >= 0
this.sizeIs > size     // this.sizeCompare(size) > 0

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

The returned iterator will be empty when called on an empty collection. The last element the iterator produces may be smaller than the window size when the original collection isn't exhausted by the window before it and its last element isn't skipped by the step before it.

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

An empty collection returns an empty iterator, and a non-empty collection containing fewer elements than the window size returns an iterator that will produce the original collection as its only element.

Sorts this sequence according to the Ordering which results from transforming an implicitly given Ordering with a transformation function.

Note: will not terminate for infinite-sized collections.

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

The sort is stable. That is, elements that are equal (as determined by ord.compare) appear in the same order in the sorted sequence as in the original.

Sorts this sequence according to a comparison function.

Note: will not terminate for infinite-sized collections.

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

The sort is stable. That is, elements that are equal (as determined by lt) appear in the same order in the sorted sequence as in the original.

Sorts this sequence according to an Ordering.

The sort is stable. That is, elements that are equal (as determined by ord.compare) appear in the same order in the sorted sequence as in the original.

Tests whether this sequence contains the given sequence at a given index.

Note: If the both the receiver object this and the argument that are infinite sequences this method may not terminate.

Returns a scala.collection.Stepper for the elements of this collection.

The Stepper enables creating a Java stream to operate on the collection, see scala.jdk.StreamConverters. For collections holding primitive values, the Stepper can be used as an iterator which doesn't box the elements.

The implicit scala.collection.StepperShape parameter defines the resulting Stepper type according to the element type of this collection.

• For collections of Int, Short, Byte or Char, an scala.collection.IntStepper is returned

• For collections of Double or Float, a scala.collection.DoubleStepper is returned

• For collections of Long a scala.collection.LongStepper is returned

• For any other element type, an scala.collection.AnyStepper is returned

Note that this method is overridden in subclasses and the return type is refined to S with EfficientSplit, for example scala.collection.IndexedSeqOps.stepper. For Steppers marked with scala.collection.Stepper.EfficientSplit, the converters in scala.jdk.StreamConverters allow creating parallel streams, whereas bare Steppers can be converted only to sequential streams.

Sums up the elements of this collection.

Note: will not terminate for infinite-sized collections.

Selects the last n elements.

Note: might return different results for different runs, unless the underlying collection type is ordered.

Takes longest prefix of elements that satisfy a predicate.

Note: might return different results for different runs, unless the underlying collection type is ordered.

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.

Implementation note: DO NOT call Array.from from this method.

Transposes this iterable collection of iterable collections into a iterable collection of iterable collections.

The resulting collection's type will be guided by the static type of iterable collection. For example:

val xs = List(
           Set(1, 2, 3),
           Set(4, 5, 6)).transpose
// xs == List(
//         List(1, 4),
//         List(2, 5),
//         List(3, 6))

val ys = Vector(
           List(1, 2, 3),
           List(4, 5, 6)).transpose
// ys == Vector(
//         Vector(1, 4),
//         Vector(2, 5),
//         Vector(3, 6))

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