Трейт scala.collection.SeqLike

Компаньон объект SeqLike

трайт SeqLike[+A, +Repr] extends IterableLike[A, Repr] with GenSeqLike[A, Repr] with Parallelizable[A, ParSeq[A]]

Шаблонный трейт для последовательностей типа Seq[A]

Последовательности — это специальные случаи итерабельных коллекций класса Iterable. В отличие от итерабельных, последовательности всегда имеют определённый порядок элементов. Последовательности предоставляют метод apply для индексирования. Индексы варьируются от 0 до length последовательности. Последовательности поддерживают ряд методов для поиска вхождений элементов или подпоследовательностей, включая segmentLength, prefixLength, indexWhere, indexOf, lastIndexWhere, lastIndexOf, startsWith, endsWith, indexOfSlice.

Другой способ представления последовательности — как PartialFunction от Int значений до типа элементов последовательности. Метод isDefinedAt последовательности возвращает true для интервала от 0 до length.

Последовательности могут быть обработаны в обратном порядке их элементов, используя методы reverse и reverseIterator.

Последовательности имеют два основных подтрайта, IndexedSeq и LinearSeq, которые предоставляют различные гарантии производительности. IndexedSeq обеспечивает быстрый произвольный доступ к элементам и быструю операцию length. LinearSeq обеспечивает быстрый доступ только к первому элементу через head, но также имеет быструю операцию tail.

Тип самого объекта: SeqLike[A, Repr]
Источник: SeqLike.scala

Линейные надтипы

Известные подклассы

Типы-члены

тип Self = Repr

Тип, реализующий этот обход

Атрибуты: protected[this]
Классы-определения: TraversableLike

класс WithFilter extends FilterMonadic[A, Repr]

Класс, поддерживающий отфильтрованные операции. Экземпляры этого класса возвращаются методом withFilter.

Классы-определения: TraversableLike

Абстрактные члены-значения

абстрактный def apply(idx: Int): A

Выбирает элемент по его индексу в последовательности.

Пример:

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

scala> x(3)
res1: Int = 4

idx: Индекс для выбора.
возвращает: элемент этой последовательности по индексу idx, где 0 обозначает первый элемент.

Классы-определения: SeqLike → GenSeqLike
Исключения: IndexOutOfBoundsException, если idx не удовлетворяет 0 <= idx < length.

абстрактный def getClass(): Class[_]

Возвращает представление runtime-класса объекта.

возвращает: объект класса, соответствующий runtime-типу получателя.

Классы-определения: Any

абстрактный def iterator: Iterator[A]

Создаёт новый итератор по всем элементам, содержащимся в этом итерабельном объекте.

возвращает: новый итератор

Классы-определения: IterableLike → GenIterableLike

абстрактный def length: Int

Длина последовательности.

Примечание: не будет завершаться для бесконечных коллекций.

Примечание: xs.length и xs.size дают один и тот же результат.

возвращает: количество элементов в этой последовательности.

Классы-определения: SeqLike → GenSeqLike
Исключения: IllegalArgumentException, если длина последовательности не может быть представлена в Int, например, (-1 to Int.MaxValue).length.

абстрактный def newBuilder: Builder[A, Repr]

Создаёт новый билдер для этого типа коллекции.

Атрибуты: protected[this]
Классы-определения: TraversableLike → HasNewBuilder

абстрактный def seq: Seq[A]

Классы-определения: GenSeqLike → Parallelizable → GenTraversableOnce

Члены-значения в явном виде

final def !=(arg0: Any): Boolean

Проверка двух объектов на неравенство.

возвращает: true если !(this == that), иначе false.

Классы-определения: Any

final def ##(): Int

Эквивалентно x.hashCode, за исключением упакованных числовых типов и null. Для числовых типов возвращает значение хэша, соответствующее равенству значений: если два экземпляра типа значения сравниваются как true, то ## будет генерировать одно и то же значение хэша для каждого из них. Для null возвращает хэш-код, где null.hashCode генерирует NullPointerException.

возвращает: значение хэша, соответствующее ==

Классы-определения: Any

def +(other: String): String

Неявный: Этот член добавлен неявным преобразованием из SeqLike[A, Repr] в any2stringadd[SeqLike[A, Repr]] выполненным методом any2stringadd в scala.Predef.
Классы-определения: any2stringadd

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

Возвращает новую коллекцию, содержащую элементы из левого операнда, за которыми следуют элементы из правого операнда. Тип элементов возвращаемой коллекции — это самый общий суперкласс, охватывающий типы элементов двух операндов.

B: тип элемента возвращаемой коллекции.
That: класс возвращаемой коллекции. В случае возможности, That совпадает с текущим классом коллекции Repr, но это зависит от того, допустим ли тип элемента B для данного класса, что означает, что найден неявный экземпляр типа CanBuildFrom[Repr, B, That].
that: объект-коллекция, который необходимо добавить.
bf: неявное значение класса CanBuildFrom, которое определяет возвращаемый класс That по текущему типу представления Repr и новому типу элемента B.
возвращает: новую коллекцию типа That, которая содержит все элементы этой коллекции, за которыми следуют все элементы that.

Классы-определения: TraversableLike → GenTraversableLike

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

Как и в ++, возвращает новую коллекцию, содержащую элементы из левого операнда, за которыми следуют элементы из правого операнда.

Отличается от ++ тем, что правый операнд определяет тип возвращаемой коллекции, а не левый. Мемоническая подсказка: двоеточие стоит со стороны нового типа коллекции.

Пример:

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)

Этот перегруз существует, потому что: для реализации ++: следует использовать реализацию ++, так как многие коллекции переопределяют её более эффективными версиями.

Так как у TraversableOnce нет метода ++, нам необходимо реализовать его напрямую, но Traversable и ниже могут использовать этот перегруз.

B: тип элемента возвращаемой коллекции.
That: класс возвращаемой коллекции. В случае возможности, That совпадает с текущим классом коллекции Repr, но это зависит от того, допустим ли тип элемента B для данного класса, что означает, что найден неявный экземпляр типа CanBuildFrom[Repr, B, That].
that: объект-коллекция, который необходимо добавить.
bf: неявное значение класса CanBuildFrom, которое определяет возвращаемый класс That по текущему типу представления Repr и новому типу элемента B.
возвращает: новую коллекцию типа That, которая содержит все элементы этой коллекции, за которыми следуют все элементы that.

Классы-определения: TraversableLike

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

[use case]

Пример:

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)

B: тип элемента возвращаемой коллекции.
that: объект-коллекция, который необходимо добавить.
возвращает: новый массив, содержащий все элементы этого массива, за которыми следуют все элементы that.

Классы-определения: TraversableLike

def +:(elem: A): Seq[A]

[случай использования]

Копия последовательности с добавленным элементом в начало.

Обратите внимание, что операторы с окончанием двоеточием являются правоассоциативными (см. пример). Мнемоника для +: по сравнению с :+ такова: двоеточие ставится со стороны коллекции.

Также исходная последовательность не изменяется, поэтому вам нужно будет сохранить результат.

Пример:

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)

elem: элемент, добавляемый в начало
возвращает: новая последовательность, состоящая из elem и всех элементов этой последовательности.

Классы-определения: SeqLike → GenSeqLike

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

Неявный: Этот член добавлен благодаря неявной конверсии из SeqLike[A, Repr] в ArrowAssoc[SeqLike[A, Repr]], выполненной методом ArrowAssoc в scala.Predef.
Классы-определения: ArrowAssoc
Аннотации: @inline()

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

Применяет бинарный оператор к начальному значению и всем элементам этой итерируемой последовательности слева направо.

Примечание: /: — это альтернативная синтаксическая форма foldLeft; z /: xs — то же самое, что и xs foldLeft z.

Примеры:

Обратите внимание, что функция свёртки, используемая для вычисления b, эквивалентна функции, используемой для вычисления c.

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

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

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

Примечание: не завершится для коллекций бесконечного размера.

Примечание: может вернуть разные результаты для разных запусков, если только тип коллекции не упорядочен или оператор не является ассоциативным и коммутативным.

B

тип результата бинарного оператора.

z

начальное значение.

op

бинарный оператор.

возвращает

результат вставки op между последовательными элементами этой итерируемой последовательности слева направо с начальным значением z слева:

op(...op(op(z, x_1), x_2), ..., x_n)

где x₁, ..., x_n — это элементы этой итерируемой последовательности.

Классы-определения: TraversableOnce → GenTraversableOnce

def :+(elem: A): Seq[A]

[случай использования]

Копия этой последовательности с добавленным элементом в конец.

Мнемоника для +: по сравнению с :+ такова: двоеточие ставится со стороны коллекции.

Примечание: не завершится для коллекций бесконечного размера.

Пример:

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)

elem: элемент, добавляемый в конец
возвращает: новая последовательность, состоящая из всех элементов этой последовательности и elem.

Классы-определения: SeqLike → GenSeqLike

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

Применяет бинарный оператор ко всем элементам этой итерируемой последовательности и начальному значению справа налево.

Примечание: :\ — это альтернативная синтаксическая форма foldRight; xs :\ z — то же самое, что и xs foldRight z.

Примечание: не завершится для коллекций бесконечного размера.

Примеры:

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

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

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

B

тип результата бинарного оператора.

z

начальное значение

op

бинарный оператор

возвращает

результат вставки op между последовательными элементами этой итерируемой последовательности справа налево с начальным значением z справа:

op(x_1, op(x_2, ... op(x_n, z)...))

где x₁, ..., x_n — это элементы этой итерируемой последовательности.

Классы-определения: TraversableOnce → GenTraversableOnce

final def ==(arg0: Any): Boolean

Тестирует равенство двух объектов. Выражение x == that эквивалентно if (x eq null) that eq null else x.equals(that).

возвращает: true если объект-получатель эквивалентен аргументу; false в противном случае.

Классы-определения: Any

def addString(b: StringBuilder): StringBuilder

Добавляет все элементы этой итерируемой последовательности в строковый буфер. Записываемый текст состоит из строковых представлений (в отношении метода toString) всех элементов этой итерируемой последовательности без разделительной строки.

Пример:

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

b: строковый буфер, в который добавляются элементы.
возвращает: строковый буфер b, в который были добавлены элементы.

Классы-определения: TraversableOnce

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

Добавляет все элементы этого итерируемого объекта или итератора в строковый буфер с использованием разделительной строки. Записанный текст состоит из строковых представлений (относительно метода toString) всех элементов этого итерируемого объекта или итератора, разделенных строкой sep.

Пример:

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

b: строковый буфер, в который добавляются элементы.
sep: разделительная строка.
returns: строковый буфер b, в который были добавлены элементы.

Definition Classes: TraversableOnce

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

Добавляет все элементы этого итерируемого объекта или итератора в строковый буфер, используя начальную, конечную и разделительные строки. Записанный текст начинается со строки start и заканчивается строкой end. Внутри строковые представления (относительно метода toString) всех элементов этого итерируемого объекта или итератора разделяются строкой sep.

Пример:

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)

b: строковый буфер, в который добавляются элементы.
start: начальная строка.
sep: разделительная строка.
end: конечная строка.
returns: строковый буфер b, в который были добавлены элементы.

Definition Classes: TraversableOnce

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

Агрегирует результаты применения оператора к последующим элементам.

Это более общая форма fold и reduce. Это аналогично foldLeft, поскольку не требует, чтобы результат был супертипом типа элемента. Кроме того, это позволяет обрабатывать параллельные коллекции частями и затем объединять промежуточные результаты.

aggregate разбивает итерируемый объект или итератор на разделы и обрабатывает каждый раздел последовательно, применяя seqop, начиная с z (как foldLeft). Эти промежуточные результаты затем объединяются с помощью combop (как fold). Реализация этой операции может работать с произвольным количеством разделов коллекции (даже 1), поэтому combop может вызываться произвольное количество раз (даже 0).

В качестве примера рассмотрим суммирование целочисленных значений списка символов. Начальное значение суммы равно 0. Сначала seqop преобразует каждый символ ввода в Int и добавляет его к сумме (раздела). Затем combop просто суммирует промежуточные результаты разделов:

List('a', 'b', 'c').aggregate(0)({ (sum, ch) => sum + ch.toInt }, { (p1, p2) => p1 + p2 })

B: тип накопленных результатов
z: начальное значение для накопленного результата раздела - это обычно нейтральный элемент для оператора seqop (например, Nil для конкатенации списков или 0 для суммирования) и может быть вычислен более одного раза
seqop: оператор, используемый для накопления результатов внутри раздела
combop: ассоциативный оператор, используемый для объединения результатов из разных разделов

Definition Classes: TraversableOnce → GenTraversableOnce

final def asInstanceOf[T0]: T0

Приводит объект-получатель к типу T0.

Обратите внимание, что успех приведения типов во время выполнения зависит от семантики стирания Scala. Поэтому выражение 1.asInstanceOf[String] выбросит ClassCastException во время выполнения, а выражение List(1).asInstanceOf[List[String]] нет. В последнем примере, поскольку аргумент типа стирается при компиляции, проверить, содержат ли элементы списка требуемый тип, невозможно.

returns: объект-получатель.

Definition Classes: Any
Exceptions thrown: ClassCastException, если объект-получатель не является экземпляром стирания типа T0.

def canEqual(that: Any): Boolean

Метод, вызываемый из методов равенства, так что пользовательские подклассы могут отказываться от равенства с другими коллекциями того же типа.

that: Объект, с которым эта итерируемая коллекция должна быть сравнена
returns: true, если эта итерируемая коллекция может быть равна that, false в противном случае. Тест учитывает только типы объектов во время выполнения, но игнорирует их элементы.

Definition Classes: IterableLike → Equals

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

[use case]

Создаёт новую коллекцию, применяя частичную функцию ко всем элементам этой последовательности, для которых функция определена.

B: тип элементов возвращаемой коллекции.
pf: частичная функция, которая фильтрует и отображает последовательность.
returns: новая последовательность, полученная путём применения данной частичной функции pf к каждому элементу, для которого она определена, и сбора результатов. Порядок элементов сохраняется.

Definition Classes: TraversableLike → GenTraversableLike

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

Находит первый элемент перебираемого объекта или итератора, для которого заданная частичная функция определена, и применяет частичную функцию к нему.

Примечание: может не завершаться для коллекций бесконечного размера.

Примечание: может возвращать разные результаты при разных запусках, если тип базовой коллекции не упорядочен.

pf: частичная функция
returns: значение типа Option, содержащее результат применения pf к первому значению, для которого она определена, или None, если такого значения не существует.

Definition Classes: TraversableOnce

def combinations(n: Int): Iterator[Repr]

Итерация по комбинациям. _Комбинация_ длины n — это подпоследовательность исходной последовательности, с элементами, взятыми в порядке следования. Таким образом, "xy" и "yy" — это обе комбинации длины 2 из "xyy", но "yx" нет. Если существует более одного способа сгенерировать одну и ту же подпоследовательность, будет возвращена только одна.

Например, "xyyy" имеет три разных способа генерации "xy" в зависимости от того, какой первый, второй или третий "y" выбран. Однако, поскольку все они идентичны, будет выбран только один. Какой из трёх будет выбран — это деталь реализации, которая не определена.

returns: Итератор, который перебирает возможные комбинации из n элементов этой последовательности.

Пример:

"abbbc".combinations(2) = Iterator(ab, ac, bb, bc)

def contains[A1 >: A](elem: A1): Boolean

Проверяет, содержит ли эта последовательность заданное значение в качестве элемента.

Примечание: может не завершаться для коллекций бесконечного размера.

elem: элемент для проверки.
returns: true, если эта последовательность имеет элемент, равный (как определено ==) элементу elem, false в противном случае.

def containsSlice[B](that: GenSeq[B]): Boolean

Проверяет, содержит ли эта последовательность заданную последовательность в качестве среза.

Примечание: может не завершаться для коллекций бесконечного размера.

that: последовательность для проверки
returns: true, если эта последовательность содержит срез с теми же элементами, что и that, иначе false.

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

[use case]

Копирует элементы этой последовательности в массив. Заполняет данный массив xs не более чем len элементами этой последовательности, начиная с позиции start. Копирование остановится, когда будет достигнут конец текущей последовательности, конец целевого массива или len элементов будут скопированы.

Примечание: не будет завершаться для коллекций бесконечного размера.

xs: массив для заполнения.
start: начальный индекс.
len: максимальное количество элементов для копирования.

Definition Classes: IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce

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

[use case]

Копирует элементы этой последовательности в массив. Заполняет данный массив xs значениями этой последовательности. Копирование остановится, когда будет достигнут конец текущей последовательности или конец целевого массива.

Примечание: не будет завершаться для коллекций бесконечного размера.

xs: массив для заполнения.

Definition Classes: TraversableOnce → GenTraversableOnce

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

[use case]

Копирует элементы этой последовательности в массив. Заполняет данный массив xs значениями этой последовательности, начиная с индекса start. Копирование остановится, когда будет достигнут конец текущей последовательности или конец целевого массива.

Примечание: не будет завершаться для коллекций бесконечного размера.

xs: массив для заполнения.
start: начальный индекс.

Definition Classes: TraversableOnce → GenTraversableOnce

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

Копирует все элементы этого перебираемого объекта или итератора в буфер.

Примечание: не будет завершаться для коллекций бесконечного размера.

dest: Буфер, в который копируются элементы.

Definition Classes: TraversableOnce

def corresponds[B](that: GenSeq[B])(p: (A, B) ⇒ Boolean): Boolean

Проверяет, соответствует ли каждый элемент этой последовательности соответствующему элементу другой последовательности, удовлетворяя предикату проверки.

B: тип элементов that
that: другая последовательность
p: предикат проверки, который связывает элементы из обеих последовательностей
returns: true если обе последовательности имеют одинаковую длину и p(x, y) является true для всех соответствующих элементов x этой последовательности и y that, в противном случае false.

Definition Classes: SeqLike → GenSeqLike

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

Подсчитывает количество элементов в итерируемой коллекции или итераторе, удовлетворяющих предикату.

p: предикат, используемый для проверки элементов.
returns: количество элементов, удовлетворяющих предикату p.

Definition Classes: TraversableOnce → GenTraversableOnce

def diff(that: Seq[A]): Seq[A]

[use case]

Вычисляет разность между этой последовательностью и другой последовательностью.

Примечание: не завершится для коллекций бесконечного размера.

that: последовательность элементов для удаления
returns: новая последовательность, которая содержит все элементы этой последовательности, за исключением некоторых вхождений элементов, которые также появляются в that. Если значение элемента x встречается n раз в that, то первые n вхождений x не будут частью результата, но любые последующие вхождения будут.

Definition Classes: SeqLike → GenSeqLike

def distinct: Repr

Создаёт новую последовательность из этой последовательности без дублируемых элементов.

Примечание: не завершится для коллекций бесконечного размера.

returns: Новая последовательность, содержащая первое вхождение каждого элемента из этой последовательности.

Definition Classes: SeqLike → GenSeqLike

def drop(n: Int): Repr

Выбирает все элементы, кроме первых n.

Примечание: может возвращать разные результаты для разных запусков, если тип коллекции, лежащий в основе, не упорядочен.

n: число элементов, которые нужно удалить из этой итерируемой коллекции.
returns: итерируемая коллекция, состоящая из всех элементов этой итерируемой коллекции, кроме первых n элементов, или пустая итерируемая коллекция, если у этой итерируемой коллекции меньше n элементов. Если n отрицательно, не удалять элементы.

Definition Classes: IterableLike → TraversableLike → GenTraversableLike

def dropRight(n: Int): Repr

Выбирает все элементы, кроме последних n.

n: Количество элементов для взятия
returns: итерируемая коллекция, состоящая из всех элементов этой итерируемой коллекции, кроме последних n элементов, или пустая итерируемая коллекция, если у этой итерируемой коллекции меньше n элементов.

Definition Classes: IterableLike

def dropWhile(p: (A) ⇒ Boolean): Repr

Удаляет самую длинную префиксную часть элементов, которые удовлетворяют предикату.

returns: самый длинный суффикс этой итерируемой коллекции, первый элемент которой не удовлетворяет предикату p.

Definition Classes: TraversableLike → GenTraversableLike

def endsWith[B](that: GenSeq[B]): Boolean

Проверяет, заканчивается ли эта последовательность заданной последовательностью.

Примечание: не завершится для коллекций бесконечного размера.

that: последовательность для проверки
returns: true если эта последовательность имеет that в качестве суффикса, false в противном случае.

Definition Classes: SeqLike → GenSeqLike

def ensuring(cond: (SeqLike[A, Repr]) ⇒ Boolean, msg: ⇒ Any): SeqLike[A, Repr]

Неявный: Этот член добавлен неявным преобразованием из SeqLike[A, Repr] в Ensuring[SeqLike[A, Repr]] с помощью метода Ensuring в scala.Predef.
Definition Classes: Ensuring

def ensuring(cond: (SeqLike[A, Repr]) ⇒ Boolean): SeqLike[A, Repr]

Неявный: Этот член добавлен неявным преобразованием из SeqLike[A, Repr] в Ensuring[SeqLike[A, Repr]] с помощью метода Ensuring в scala.Predef.
Определения классов: Ensuring

def ensuring(cond: Boolean, msg: ⇒ Any): SeqLike[A, Repr]

Неявный: Этот член добавлен неявным преобразованием из SeqLike[A, Repr] в Ensuring[SeqLike[A, Repr]] с помощью метода Ensuring в scala.Predef.
Определения классов: Ensuring

def ensuring(cond: Boolean): SeqLike[A, Repr]

Неявный: Этот член добавлен неявным преобразованием из SeqLike[A, Repr] в Ensuring[SeqLike[A, Repr]] с помощью метода Ensuring в scala.Predef.
Определения классов: Ensuring

def equals(that: Any): Boolean

Метод equals для произвольных последовательностей. Сравнивает эту последовательность с другим объектом.

that: Объект для сравнения с последовательностью
возвращает: true если that является последовательностью, которая содержит те же элементы, что и эта последовательность в том же порядке, false в противном случае

Определения классов: GenSeqLike → Equals → Any

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

Проверяет, выполняется ли предикат для хотя бы одного элемента этого итерируемого набора.

Примечание: может не завершаться для бесконечных коллекций.

p: предикат, используемый для проверки элементов.
возвращает: false если этот итерируемый набор пустой, в противном случае true если данный предикат p выполняется для некоторых элементов этого итерируемого набора, в противном случае false

Определения классов: IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce

def filter(p: (A) ⇒ Boolean): Repr

Выбирает все элементы этого перечислимого набора, которые удовлетворяют предикату.

p: предикат, используемый для проверки элементов.
возвращает: новый перечислимый набор, состоящий из всех элементов этого перечислимого набора, которые удовлетворяют данному предикату p. Порядок элементов сохраняется.

Определения классов: TraversableLike → GenTraversableLike

def filterNot(p: (A) ⇒ Boolean): Repr

Выбирает все элементы этого перечислимого набора, которые не удовлетворяют предикату.

p: предикат, используемый для проверки элементов.
возвращает: новый перечислимый набор, состоящий из всех элементов этого перечислимого набора, которые не удовлетворяют данному предикату p. Порядок элементов сохраняется.

Определения классов: TraversableLike → GenTraversableLike

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

Находит первый элемент перечислимого набора, удовлетворяющий предикату, если таковой существует.

Примечание: может не завершаться для бесконечных коллекций.

p: предикат, используемый для проверки элементов.
возвращает: значение типа Option, содержащее первый элемент в перечислимом наборе, удовлетворяющий p, или None если таковой не существует.

Определения классов: IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce

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

[use case]

Создаёт новую коллекцию, применяя функцию ко всем элементам этой последовательности и используя элементы полученных коллекций.

Например:

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)

B: тип элемента возвращаемой коллекции.
f: функция, которая применяется к каждому элементу.
returns: новая последовательность, полученная путём применения заданной функции, возвращающей коллекцию f к каждому элементу этой последовательности и конкатенации результатов.

Definition Classes: TraversableLike → GenTraversableLike → FilterMonadic

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

Вычисляет результат применения заданного ассоциативного бинарного оператора к элементам этой последовательности.

Порядок выполнения операций над элементами не определён и может быть не детерминированным.

Примечание: не завершит работу для коллекций бесконечного размера.

A1: тип параметра для бинарного оператора, тип-супертип A.
z: нейтральный элемент для операции сворачивания; может быть добавлен к результату произвольное количество раз, и не должен изменять результат (например, Nil для конкатенации списков, 0 для сложения или 1 для умножения).
op: бинарный оператор, который должен быть ассоциативным.
returns: результат применения оператора сворачивания op между всеми элементами и z, или z если эта последовательность пуста.

Definition Classes: TraversableOnce → GenTraversableOnce

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

Применяет бинарный оператор к начальному значению и всем элементам этой последовательности слева направо.

Примечание: не завершит работу для коллекций бесконечного размера.

Примечание: может возвращать разные результаты при разных запусках, если тип коллекции не упорядочен, или оператор не ассоциативен и не коммутативен.

B

тип результата бинарного оператора.

z

начальное значение.

op

бинарный оператор.

returns

результат вставки op между последовательными элементами этой последовательности слева направо с начальным значением z слева:

op(...op(z, x_1), x_2, ..., x_n)

где x₁, ..., x_n — элементы этой последовательности. Возвращает z если эта последовательность пуста.

Definition Classes: TraversableOnce → GenTraversableOnce

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

Применяет бинарный оператор ко всем элементам этой коллекции и начальному значению, справа налево.

Примечание: не завершит работу для коллекций бесконечного размера.

Примечание: может возвращать разные результаты при разных запусках, если тип коллекции не упорядочен или оператор не ассоциативен и не коммутативен.

B

тип результата бинарного оператора.

z

начальное значение.

op

бинарный оператор.

returns

результат вставки op между последовательными элементами этой коллекции, справа налево с начальным значением z справа:

op(x_1, op(x_2, ... op(x_n, z)...))

где x₁, ..., x_n — элементы этой коллекции. Возвращает z если эта коллекция пуста.

Definition Classes: IterableLike → TraversableOnce → GenTraversableOnce

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

Проверяет, выполняется ли предикат для всех элементов этой коллекции.

Примечание: может не завершиться для коллекций бесконечного размера.

p: предикат, используемый для проверки элементов.
returns: true если эта коллекция пуста или заданный предикат p выполняется для всех элементов этой коллекции, в противном случае false.

Definition Classes: IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce

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

[use case]

Применяет функцию f ко всем элементам этой последовательности.

Примечание: этот метод лежит в основе реализации большинства других операций над наборами. Подклассы должны переопределить этот метод, если существует более эффективная реализация.

f: функция, которая применяется как побочный эффект к каждому элементу. Результат функции f игнорируется.

Definition Classes: IterableLike → TraversableLike → GenTraversableLike → TraversableOnce → GenTraversableOnce → FilterMonadic

def formatted(fmtstr: String): String

Возвращает строку, отформатированную в соответствии с заданной строкой format. Строки форматирования аналогичны String.format (@see java.lang.String.format).

Implicit: Этот член добавлен неявным преобразованием из SeqLike[A, Repr] в StringFormat[SeqLike[A, Repr]] посредством метода StringFormat в scala.Predef.
Definition Classes: StringFormat
Annotations: @inline()

def groupBy[K](f: (A) ⇒ K): immutable.Map[K, Repr]

Разделяет эту коллекцию с помощью функции-дискриминатора на карту коллекций.

Примечание: этот метод не переопределяется для представлений. Это означает, что при применении к представлению он всегда принудительно вычисляет представление и возвращает новую коллекцию.

K

тип ключей, возвращаемых функцией-дискриминатором.

f

функция-дискриминатор.

returns

Карта, сопоставляющая ключи коллекциям, при этом выполняется следующее условие:

(xs groupBy f)(k) = xs filter (x => f(x) == k)

То есть, каждый ключ k сопоставляется с коллекцией элементов x для которых f(x) равно k.

Definition Classes: TraversableLike → GenTraversableLike

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

Разделяет элементы на наборы фиксированного размера.

size: количество элементов в группе
returns: Итератор, генерирующий наборы размером size, за исключением последнего, размер которого будет меньше, чем size size, если элементы не делятся на размер группы без остатка.

Definition Classes: IterableLike
See also: scala.collection.Iterator, метод grouped

def hasDefiniteSize: Boolean

Проверяет, известно ли, что эта коллекция имеет конечный размер. Все строгие коллекции имеют конечный размер. Для нестрогой коллекции, такой как Stream, предикат возвращает true если все элементы были вычислены. Он возвращает false если поток еще не был вычислен до конца. Непустые итераторы обычно возвращают false даже если они были созданы из коллекции с известным конечным размером.

Примечание: многие методы коллекций не будут работать с бесконечными коллекциями. Типичный режим сбоя — бесконечный цикл. Эти методы всегда пытаются выполнить обход, не проверяя предварительно, что hasDefiniteSize возвращает true. Однако, проверка hasDefiniteSize может гарантировать, что размер определен и бесконечное выполнение не является проблемой.

returns: true если эта коллекция имеет конечный размер, false в противном случае.

Definition Classes: TraversableLike → TraversableOnce → GenTraversableOnce

def hashCode(): Int

Хеш-коды для GenSeq генерируют значение из хеш-кодов всех элементов общей последовательности.

returns: значение хеш-кода для этого объекта.

Definition Classes: GenSeqLike → Any

def head: A

Выбирает первый элемент этой итерируемой коллекции.

returns: первый элемент этой итерируемой коллекции.

Definition Classes: IterableLike → TraversableLike → GenTraversableLike
Exceptions thrown: NoSuchElementException, если итерируемая коллекция пуста.

def headOption: Option[A]

Возвращает первый элемент, если он существует.

returns: первый элемент этой коллекции, если она непуста, None в противном случае.

Definition Classes: TraversableLike → GenTraversableLike

def indexOf(elem: A, from: Int): Int

[use case]

Находит индекс первого вхождения некоторого значения в эту последовательность после или на определенном начальном индексе.

Примечание: может не завершаться для коллекций бесконечного размера.

elem: значение искомого элемента.
from: начальный индекс
returns: индекс >= from первого элемента этой последовательности, равного (как определяется ==) elem, или -1, если такового нет.

Definition Classes: GenSeqLike

def indexOf(elem: A): Int

[use case]

Находит индекс первого вхождения некоторого значения в этой последовательности.

Примечание: может не завершаться для коллекций бесконечного размера.

elem: значение искомого элемента.
returns: индекс первого элемента этой последовательности, равного (как определяется ==) elem, или -1, если такового нет.

Definition Classes: GenSeqLike

def indexOfSlice[B >: A](that: GenSeq[B], from: Int): Int

Находит первый индекс после или на начальном индексе, где эта последовательность содержит заданную последовательность как срез.

Примечание: может не завершаться для коллекций бесконечного размера.

that: последовательность для проверки
from: начальный индекс
returns: первый индекс >= from такой, что элементы этой последовательности, начиная с этого индекса, соответствуют элементам последовательности that, или -1 если такой подпоследовательности не существует.

def indexOfSlice[B >: A](that: GenSeq[B]): Int

Находит первый индекс, где эта последовательность содержит заданную последовательность как срез.

Примечание: может не завершаться для коллекций бесконечного размера.

that: последовательность для проверки
returns: первый индекс, такой что элементы этой последовательности, начиная с этого индекса, соответствуют элементам последовательности that, или -1 если такой подпоследовательности не существует.

def indexWhere(p: (A) ⇒ Boolean, from: Int): Int

Находит индекс первого элемента, удовлетворяющего некоторому предикату после или на определенном начальном индексе.

Примечание: может не завершаться для коллекций бесконечного размера.

p: предикат, используемый для проверки элементов.
from: начальный индекс
returns: индекс >= from первого элемента этой последовательности, удовлетворяющего предикату p, или -1, если такового нет.

Definition Classes: SeqLike → GenSeqLike

def indexWhere(p: (A) ⇒ Boolean): Int

Находит индекс первого элемента, удовлетворяющего некоторому предикату.

Примечание: может не завершаться для коллекций бесконечного размера.

p: предикат, используемый для проверки элементов.
returns: индекс первого элемента этой общей последовательности, удовлетворяющего предикату p, или -1, если такового нет.

Definition Classes: GenSeqLike

def indices: immutable.Range

Создает диапазон всех индексов этой последовательности.

returns: значение Range от 0 до значения, на единицу меньшего длины этой последовательности.

def init: Repr

Выбирает все элементы, кроме последнего.

Примечание: может возвращать разные результаты для разных запусков, если тип базовой коллекции не упорядочен.

returns: коллекция итерируемых элементов, состоящая из всех элементов этой итерируемой коллекции, кроме последнего.

Definition Classes: TraversableLike → GenTraversableLike
Исключения: UnsupportedOperationException если итерируемая коллекция пуста.

def inits: Iterator[Repr]

Итерируется по начальным фрагментам этой итерируемой коллекции. Первое значение будет этой итерируемой коллекцией, а последнее — пустой итерируемой коллекцией, а промежуточные значения — результатами последовательных применений init.

returns: итератор по всем начальным фрагментам этой итерируемой коллекции

Definition Classes: TraversableLike

def intersect(that: Seq[A]): Seq[A]

[use case]

Вычисляет пересечение мультимножества между этой последовательностью и другой последовательностью.

Примечание: может не завершаться для коллекций бесконечного размера.

that: последовательность элементов для пересечения.
returns: новая последовательность, которая содержит все элементы этой последовательности, которые также присутствуют в that. Если значение элемента x встречается n раз в that, то первые n вхождений x будут сохранены в результате, но любые последующие вхождения будут опущены.

Definition Classes: SeqLike → GenSeqLike

def isDefinedAt(idx: Int): Boolean

Проверяет, содержит ли эта общая последовательность заданный индекс.

Реализации методов apply и isDefinedAt преобразуют Seq[A] в PartialFunction[Int, A].

idx: индекс для проверки
returns: true если эта общая последовательность содержит элемент в позиции idx, false в противном случае.

Definition Classes: GenSeqLike

def isEmpty: Boolean

Проверяет, является ли эта последовательность пустой.

returns: true если последовательность не содержит элементов, false в противном случае.

Definition Classes: SeqLike → IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce

final def isInstanceOf[T0]: Boolean

Проверяет, является ли динамический тип объекта получателя T0.

Обратите внимание, что результат теста выполняется с учетом семантики стирания Scala. Таким образом, выражение 1.isInstanceOf[String] вернет false, а выражение List(1).isInstanceOf[List[String]] вернет true. В последнем примере, поскольку аргумент типа стирается во время компиляции, невозможно проверить, соответствуют ли элементы списка указанному типу.

returns: true если объект получателя является экземпляром стирания типа T0; false в противном случае.

Definition Classes: Any

final def isTraversableAgain: Boolean

Проверяет, можно ли многократно проходить по этому итерируемому набору.

returns: true

Definition Classes: TraversableLike → GenTraversableLike → GenTraversableOnce

def last: A

Выбирает последний элемент.

Примечание: может возвращать разные результаты для разных запусков, если только тип базового набора не упорядочен.

returns: Последний элемент этого итерируемого набора.

Definition Classes: TraversableLike → GenTraversableLike
Exceptions thrown: NoSuchElementException Если итерируемый набор пустой.

def lastIndexOf(elem: A, end: Int): Int

[use case]

Находит индекс последнего вхождения некоторого значения в этой последовательности перед или в заданном индексе конца.

elem: значение элемента для поиска.
end: индекс конца.
returns: индекс <= end последнего элемента этой последовательности, который равен (как определяется ==) elem, или -1, если таковой не существует.

Definition Classes: GenSeqLike

def lastIndexOf(elem: A): Int

[use case]

Находит индекс последнего вхождения некоторого значения в эту последовательность.

Примечание: не завершится для коллекций бесконечного размера.

elem: значение элемента для поиска.
returns: индекс последнего элемента этой последовательности, который равен (как определяется ==) elem, или -1, если таковой не существует.

Definition Classes: GenSeqLike

def lastIndexOfSlice[B >: A](that: GenSeq[B], end: Int): Int

Находит последний индекс перед или в заданном индексе конца, где эта последовательность содержит заданную последовательность как срез.

that: последовательность для проверки
end: индекс конца
returns: последний индекс <= end такой, что элементы этой последовательности, начиная с этого индекса, соответствуют элементам последовательности that, или -1 если такой подпоследовательности не существует.

def lastIndexOfSlice[B >: A](that: GenSeq[B]): Int

Находит последний индекс, где эта последовательность содержит заданную последовательность как срез.

Примечание: не завершится для коллекций бесконечного размера.

that: последовательность для проверки
returns: последний индекс такой, что элементы этой последовательности, начиная с этого индекса, соответствуют элементам последовательности that, или -1 если такой подпоследовательности не существует.

def lastIndexWhere(p: (A) ⇒ Boolean, end: Int): Int

Находит индекс последнего элемента, удовлетворяющего некоторому предикату до или на заданном индексе конца.

p: предикат, используемый для проверки элементов.
returns: индекс <= end последнего элемента этой последовательности, удовлетворяющего предикату p, или -1, если такого элемента нет.

Definition Classes: SeqLike → GenSeqLike

def lastIndexWhere(p: (A) ⇒ Boolean): Int

Находит индекс последнего элемента, удовлетворяющего некоторому предикату.

Примечание: не завершит работу для коллекций бесконечного размера.

p: предикат, используемый для проверки элементов.
returns: индекс последнего элемента этой общей последовательности, удовлетворяющего предикату p, или -1, если такого элемента нет.

Definition Classes: GenSeqLike

def lastOption: Option[A]

Возвращает последний элемент (если он есть).

Примечание: может возвращать разные результаты для разных запусков, если только тип базовой коллекции не упорядочен.

returns: последний элемент этой коллекции итерируемых элементов, если она не пуста, None если она пуста.

Definition Classes: TraversableLike → GenTraversableLike

def lengthCompare(len: Int): Int

Сравнивает длину этой последовательности со значением теста.

len

тестовое значение, которое сравнивается с длиной.

returns

Значение x где

x <  0       if this.length <  len
x == 0       if this.length == len
x >  0       if this.length >  len

Реализованный здесь метод не вызывает length напрямую; его время выполнения составляет O(length min len) вместо O(length). Метод должен быть переопределен, если вычисление length является быстрым.

def map[B](f: (A) ⇒ B): Seq[B]

[use case]

Создает новую коллекцию, применяя функцию ко всем элементам этой последовательности.

B: тип элементов возвращаемой коллекции.
f: функция, применяемая к каждому элементу.
returns: новая последовательность, полученная путем применения заданной функции f к каждому элементу этой последовательности и сбора результатов.

Definition Classes: TraversableLike → GenTraversableLike → FilterMonadic

def max: A

[use case]

Находит наибольший элемент.

returns: наибольший элемент этой последовательности.

Definition Classes: TraversableOnce → GenTraversableOnce
Исключения: UnsupportedOperationException, если эта последовательность пуста.

def maxBy[B](f: (A) ⇒ B): A

[use case]

Находит первый элемент, который дает наибольшее значение, измеренное функцией f.

B: Тип результата функции f.
f: Функция измерения.
returns: первый элемент этой последовательности с наибольшим значением, измеренным функцией f.

Definition Classes: TraversableOnce → GenTraversableOnce
Исключения: UnsupportedOperationException если эта последовательность пуста.

def min: A

[use case]

Находит наименьший элемент.

returns: наименьший элемент этой последовательности

Definition Classes: TraversableOnce → GenTraversableOnce
Исключения: UnsupportedOperationException, если эта последовательность пуста.

def minBy[B](f: (A) ⇒ B): A

[use case]

Находит первый элемент, который дает наименьшее значение, измеренное функцией f.

B: Тип результата функции f.
f: Функция измерения.
returns: первый элемент этой последовательности с наименьшим значением, измеренным функцией f.

Definition Classes: TraversableOnce → GenTraversableOnce
Исключения: UnsupportedOperationException, если эта последовательность пуста.

def mkString: String

Отображает все элементы этого итерируемого объекта или итератора в строке.

returns: строковое представление этого итерируемого объекта или итератора. В результирующей строке строковые представления (в соответствии с методом toString) всех элементов этого итерируемого объекта или итератора следуют друг за другом без разделителя.

Definition Classes: TraversableOnce → GenTraversableOnce

def mkString(sep: String): String

Отображает все элементы этого итерируемого объекта или итератора в строке с использованием разделителя.

sep: строка-разделитель.
returns: строковое представление этого итерируемого объекта или итератора. В результирующей строке строковые представления (в соответствии с методом toString) всех элементов этого итерируемого объекта или итератора разделены строкой sep.

Definition Classes: TraversableOnce → GenTraversableOnce

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

Отображает все элементы этого итерируемого объекта или итератора в строке с использованием начальной, конечной и разделительной строк.

start: начальная строка.
sep: строка-разделитель.
end: конечная строка.
returns: строковое представление этого итерируемого объекта или итератора. Результирующая строка начинается со строки start и заканчивается строкой end. Внутри строковые представления (в соответствии с методом toString) всех элементов этого итерируемого объекта или итератора разделены строкой sep.

Definition Classes: TraversableOnce → GenTraversableOnce

def nonEmpty: Boolean

Проверяет, не пуст ли итерируемый объект или итератор.

returns: true если итерируемый объект или итератор содержит хотя бы один элемент, false в противном случае.

Definition Classes: TraversableOnce → GenTraversableOnce

def padTo(len: Int, elem: A): Seq[A]

[use case]

Копия этой последовательности с добавленными элементами до достижения заданной длины.

len: целевая длина
elem: значение для заполнения
returns: новая последовательность, состоящая из всех элементов этой последовательности, за которыми следует минимальное количество вхождений elem, так что результирующая последовательность имеет длину не менее len.

Definition Classes: SeqLike → GenSeqLike

def par: ParSeq[A]

Возвращает параллельную реализацию этого набора.

Для большинства типов наборов этот метод создает новый параллельный набор, копируя все элементы. Для этих наборов метод par занимает линейное время. Изменяемые наборы в этой категории не создают изменяемый параллельный набор, имеющий ту же базовую структуру данных, поэтому изменения в одном наборе не будут отражаться в другом.

Специфические наборы (например, ParArray или mutable.ParHashMap) переопределяют это поведение по умолчанию, создавая параллельный набор, который использует ту же самую базовую структуру данных. Для этих наборов par занимает постоянное или подлинейное время.

Все параллельные наборы возвращают ссылку на себя.

returns: параллельная реализация этого набора

Definition Classes: Parallelizable

def parCombiner: Combiner[A, ParSeq[A]]

Реализация par по умолчанию использует комбинирующий элемент, предоставленный этим методом, для создания нового параллельного набора.

returns: комбинирующий элемент для параллельного набора типа ParRepr

Attributes: protected[this]
Definition Classes: SeqLike → TraversableLike → Parallelizable

def partition(p: (A) ⇒ Boolean): (Repr, Repr)

Разделяет этот коллектор на два коллектора в соответствии с предикатом.

p: предикат для разделения.
returns: пара коллекторов: первый коллектор состоит из всех элементов, удовлетворяющих предикату p, а второй коллектор состоит из всех элементов, которые не удовлетворяют. Относительный порядок элементов в результирующих коллекторах такой же, как и в исходном коллекторе.

Definition Classes: TraversableLike → GenTraversableLike

def patch(from: Int, that: GenSeq[A], replaced: Int): Seq[A]

[использование]

Создает новую последовательность, где фрагмент элементов в этой последовательности заменяется другой последовательностью.

from: индекс первого заменяемого элемента
replaced: количество элементов для удаления в исходной последовательности
returns: новая последовательность, состоящая из всех элементов этой последовательности, за исключением того, что replaced элементы, начиная с from, заменяются на patch.

Классы-определения: SeqLike → GenSeqLike

def permutations: Iterator[Repr]

Итерируется по различным перестановкам.

returns: Итератор, который проходит по различным перестановкам этой последовательности.

Пример:

"abb".permutations = Iterator(abb, bab, bba)

def prefixLength(p: (A) ⇒ Boolean): Int

Возвращает длину самого длинного префикса, чьи элементы удовлетворяют некоторому предикату.

Примечание: может не завершаться для коллекций бесконечной длины.

p: предикат, используемый для проверки элементов.
returns: длина самого длинного префикса этой общей последовательности, такой что каждый элемент сегмента удовлетворяет предикату p.

Классы-определения: GenSeqLike

def product: A

[использование]

Перемножает элементы этой коллекции.

returns: произведение всех элементов в этой последовательности чисел типа Int. Вместо Int, любой другой тип T с неявным Numeric[T] реализацией может быть использован в качестве типа элементов последовательности и как тип результата product. Примеры таких типов: Long, Float, Double, BigInt.

Классы-определения: TraversableOnce → GenTraversableOnce

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

Сводит элементы этой итерируемой структуры или итератора используя указанный ассоциативный бинарный оператор.

Порядок выполнения операций над элементами не определён и может быть не детерминированным.

A1: Тип параметра для бинарного оператора, надтип A.
op: Бинарный оператор, который должен быть ассоциативным.
returns: Результат применения оператора reduce op между всеми элементами, если итерируемая структура или итератор не пустые.

Классы-определения: TraversableOnce → GenTraversableOnce
Исключения: UnsupportedOperationException если эта итерируемая структура или итератор пустые.

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

Применяет бинарный оператор ко всем элементам этой итерируемой структуры или итератора, слева направо.

Примечание: не завершится для коллекций бесконечной длины.

Примечание: может возвращать разные результаты для разных запусков, если тип базовой коллекции не упорядочен или оператор не ассоциативен и коммутативен.

B

тип результата бинарного оператора.

op

бинарный оператор.

returns

результат вставки op между последовательными элементами этой итерируемой структуры или итератора, слева направо:

op( op( ... op(x_1, x_2) ..., x_{n-1}), x_n)

где x₁, ..., x_n - элементы этой итерируемой структуры или итератора.

Классы-определения: TraversableOnce
Исключения: UnsupportedOperationException если эта итерируемая структура или итератор пустые.

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

Возможно применит бинарный оператор ко всем элементам этой итерируемой структуры или итератора, слева направо.

Примечание: не завершится для коллекций бесконечной длины.

B: тип результата бинарного оператора.
op: бинарный оператор.
returns: значение option, содержащее результат reduceLeft(op) если эта итерируемая структура или итератор не пустые, None в противном случае.

Классы-определения: TraversableOnce → GenTraversableOnce

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

Сокращает элементы этого обходного или итераторного объекта, если таковые имеются, используя указанный ассоциативный бинарный оператор.

Порядок, в котором операции выполняются над элементами, не указан и может быть недетерминированным.

A1: Параметр типа для бинарного оператора, супертип A.
op: Бинарный оператор, который должен быть ассоциативным.
returns: Необязательное значение, содержащее результат применения оператора reduce op ко всем элементам, если коллекция не пуста, и None в противном случае.

Определяющие классы: TraversableOnce → GenTraversableOnce

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

Применяет бинарный оператор ко всем элементам этой итерируемой коллекции, справа налево.

Примечание: не будет завершаться для коллекций бесконечного размера.

Примечание: может возвращать разные результаты для разных запусков, если только базовый тип коллекции не упорядочен или оператор не является ассоциативным и коммутативным.

B

тип результата бинарного оператора.

op

бинарный оператор.

returns

результат вставки op между последовательными элементами этой итерируемой коллекции, справа налево:

op(x_1, op(x_2, ..., op(x_{n-1}, x_n)...))

где x₁, ..., x_n — элементы этой итерируемой коллекции.

Определяющие классы: IterableLike → TraversableOnce → GenTraversableOnce
Выбрасываемые исключения: UnsupportedOperationException если эта итерируемая коллекция пуста.

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

Необязательно применяет бинарный оператор ко всем элементам этого обходного объекта или итератора, справа налево.

Примечание: не будет завершаться для коллекций бесконечного размера.

B: тип результата бинарного оператора.
op: бинарный оператор.
returns: необязательное значение, содержащее результат reduceRight(op), если этот обходной объект или итератор не пуст, None в противном случае.

Определяющие классы: TraversableOnce → GenTraversableOnce

def repr: Repr

Коллекция типа обходной коллекции, лежащая в основе этого объекта TraversableLike. По умолчанию это реализовано как сам объект TraversableLike, но это может быть переопределено.

Определяющие классы: TraversableLike → GenTraversableLike

def reverse: Repr

Возвращает новую последовательность с элементами в обратном порядке.

Примечание: не будет завершаться для коллекций бесконечного размера.

returns: Новая последовательность со всеми элементами этой последовательности в обратном порядке.

Определяющие классы: SeqLike → GenSeqLike

def reverseIterator: Iterator[A]

Итератор, возвращающий элементы в обратном порядке.

Примечание: не будет завершаться для коллекций бесконечного размера.

Примечание: xs.reverseIterator — то же самое, что и xs.reverse.iterator, но может быть эффективнее.

returns: итератор, возвращающий элементы этой последовательности в обратном порядке

def reverseMap[B](f: (A) ⇒ B): Seq[B]

[use case]

Создает новую коллекцию, применяя функцию ко всем элементам этой последовательности и собирая результаты в обратном порядке.

Примечание: не будет завершаться для коллекций бесконечного размера.

Примечание: xs.reverseMap(f) — то же самое, что и xs.reverse.map(f), но может быть эффективнее.

B: тип элемента возвращаемой коллекции.
f: функция, которую нужно применить к каждому элементу.
returns: новая последовательность, полученная в результате применения данной функции f к каждому элементу этой последовательности и сбора результатов в обратном порядке.

Определяющие классы: SeqLike → GenSeqLike

def reversed: List[A]

Атрибуты: protected[this]
Определяющие классы: TraversableOnce

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

[use case]

Проверяет, содержит ли другая итерируемая коллекция те же элементы в том же порядке, что и эта последовательность.

Примечание: не будет завершаться для коллекций бесконечного размера.

that: коллекция для сравнения.
returns: true, если обе коллекции содержат одни и те же элементы в одном и том же порядке, false в противном случае.

Определяющие классы: IterableLike → GenIterableLike

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

Вычисляет префиксное сканирование элементов коллекции.

Примечание: Нейтральный элемент z может применяться более одного раза.

B: тип элементов результирующей коллекции
That: тип результирующей коллекции
z: нейтральный элемент для оператора op
op: ассоциативный оператор для сканирования
cbf: фабрика комбинирования, которая предоставляет комбиниратор
returns: новая коллекция итерируемых элементов, содержащая префиксное сканирование элементов в этой коллекции итерируемых элементов

Definition Classes: TraversableLike → GenTraversableLike

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

Создаёт коллекцию, содержащую кумулятивные результаты применения оператора слева направо.

Примечание: не завершится для коллекций бесконечного размера.

B: тип элементов в результирующей коллекции
That: фактический тип результирующей коллекции
z: начальное значение
op: бинарный оператор, применяемый к промежуточному результату и элементу
bf: явное значение класса CanBuildFrom, которое определяет класс результата That из текущего типа представления Repr и нового типа элементов B.
returns: коллекция с промежуточными результатами

Definition Classes: TraversableLike → GenTraversableLike

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

Создаёт коллекцию, содержащую кумулятивные результаты применения оператора справа налево. Головка коллекции — последний кумулятивный результат.

Примечание: не завершится для коллекций бесконечного размера.

Пример:

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

B: тип элементов в результирующей коллекции
That: фактический тип результирующей коллекции
z: начальное значение
op: бинарный оператор, применяемый к промежуточному результату и элементу
bf: явное значение класса CanBuildFrom, которое определяет класс результата That из текущего типа представления Repr и нового типа элементов B.
returns: коллекция с промежуточными результатами

Definition Classes: TraversableLike → GenTraversableLike
Annotations: @migration
Migration: (Изменено в версии 2.9.0) Поведение scanRight изменилось. Предыдущее поведение можно воспроизвести с помощью scanRight.reverse.

def segmentLength(p: (A) ⇒ Boolean, from: Int): Int

Вычисляет длину самого длинного сегмента, чьи элементы удовлетворяют некоторому предикату.

Примечание: может не завершиться для коллекций бесконечного размера.

p: предикат, используемый для проверки элементов
from: индекс, с которого начинается поиск
returns: длина самого длинного сегмента этой последовательности, начинающегося с индекса from, такого, что каждый элемент сегмента удовлетворяет предикату p.

Definition Classes: SeqLike → GenSeqLike

def size: Int

Размер этой последовательности, эквивалентный length.

Примечание: не завершится для коллекций бесконечного размера.

returns: количество элементов в этой последовательности.

Definition Classes: SeqLike → GenTraversableLike → TraversableOnce → GenTraversableOnce

def sizeHintIfCheap: Int

Размер этой коллекции или итератора, если он может быть вычислен недорого.

returns: количество элементов в этой коллекции или итераторе, или -1, если размер не может быть определён недорого

Attributes: protected[collection]
Definition Classes: GenTraversableOnce

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

Выбирает интервал элементов. Полученная коллекция состоит из всех элементов x, которые удовлетворяют инварианту:

from <= indexOf(x) < until

Примечание: результаты могут отличаться при разных запусках, если тип базовой коллекции не упорядочен.

returns: итерируемую коллекцию, содержащую элементы, большие или равные индексу from, и простирающуюся до (но не включая) индекс until этой итерируемой коллекции.

Definition Classes: IterableLike → TraversableLike → GenTraversableLike

def sliding(size: Int, step: Int): Iterator[Repr]

Группирует элементы в блоки фиксированного размера, пропуская по ним «скользящее окно» (в отличие от разделения на части, как в grouped).

size: количество элементов в группе
step: расстояние между первыми элементами последовательных групп
returns: Итератор, генерирующий итерируемые коллекции размера size, за исключением последнего элемента (который может быть единственным элементом), который будет усечён, если оставшихся элементов для группировки меньше size.

Definition Classes: IterableLike
See also: scala.collection.Iterator, метод sliding

def sliding(size: Int): Iterator[Repr]

Группирует элементы в блоки фиксированного размера, пропуская по ним «скользящее окно» (в отличие от разделения на части, как в grouped). Шаг «скользящего окна» устанавливается в единицу.

size: количество элементов в группе
returns: Итератор, генерирующий итерируемые коллекции размера size, за исключением последнего элемента (который может быть единственным элементом), который будет усечён, если оставшихся элементов для группировки меньше size.

Definition Classes: IterableLike
See also: scala.collection.Iterator, метод sliding

def sortBy[B](f: (A) ⇒ B)(implicit ord: math.Ordering[B]): Repr

Сортирует эту Seq согласно упорядочению, полученному из неявного упорядочения с помощью функции преобразования.

B: целевой тип преобразования f, и тип, где определено упорядочение ord.
f: функция преобразования, отображающая элементы в другую область B.
ord: установленное упорядочение в области B.
returns: последовательность, состоящую из элементов этой последовательности, отсортированных согласно упорядочению, где x < y если ord.lt(f(x), f(y)).

See also: scala.math.Ordering Примечание: не будет завершаться для коллекций бесконечного размера.

def sortWith(lt: (A, A) ⇒ Boolean): Repr

Сортирует эту последовательность согласно функции сравнения.

Примечание: не будет завершаться для коллекций бесконечного размера.

Сортировка устойчивая. То есть, элементы, которые равны (как определяется lt), появляются в отсортированной последовательности в том же порядке, что и в исходной.

lt: функция сравнения, которая проверяет, предшествует ли её первый аргумент второму аргументу в желаемом упорядочении.
returns: последовательность, состоящую из элементов этой последовательности, отсортированных согласно функции сравнения lt.

Пример:

List("Steve", "Tom", "John", "Bob").sortWith(_.compareTo(_) < 0) =
List("Bob", "John", "Steve", "Tom")

def sorted[B >: A](implicit ord: math.Ordering[B]): Repr

Сортирует эту последовательность согласно упорядочению.

ord: упорядочение, используемое для сравнения элементов.
returns: последовательность, состоящую из элементов этой последовательности, отсортированных согласно упорядочению ord.

See also: scala.math.Ordering

def span(p: (A) ⇒ Boolean): (Repr, Repr)

Разделяет эту коллекцию с итерациями на пару префикс/суффикс согласно предикату.

Примечание: c span p эквивалентно (но, возможно, более эффективно, чем) (c takeWhile p, c dropWhile p), при условии, что вычисление предиката p не вызывает побочных эффектов.

Примечание: результаты могут отличаться при разных запусках, если тип базовой коллекции не упорядочен.

returns: пару, состоящую из самого длинного префикса этой коллекции с итерациями, элементы которого все удовлетворяют p, и остальной части этой коллекции с итерациями.

Definition Classes: TraversableLike → GenTraversableLike

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

Разделяет эту коллекцию на две части в заданной позиции. Примечание: c splitAt n эквивалентно (но, возможно, более эффективно, чем) (c take n, c drop n).

n: позиция, в которой необходимо разделить.
returns: пара коллекций, состоящих из первых n элементов этой коллекции и остальных элементов.

Definition Classes: TraversableLike → GenTraversableLike

def startsWith[B](that: GenSeq[B], offset: Int): Boolean

Проверяет, содержит ли эта последовательность заданную последовательность в заданном индексе.

Примечание: Если и получающий объект this и аргумент that являются бесконечными последовательностями, этот метод может не завершиться.

that: тестируемая последовательность
offset: индекс, в котором ищется последовательность.
returns: true, если последовательность that содержится в этой последовательности в индексе offset, в противном случае false.

Definition Classes: SeqLike → GenSeqLike

def startsWith[B](that: GenSeq[B]): Boolean

Проверяет, начинается ли эта общая последовательность с заданной последовательности.

that: тестируемая последовательность
returns: true, если эта коллекция имеет that в качестве префикса, false в противном случае.

Definition Classes: GenSeqLike

def stringPrefix: String

Определяет префикс представления этого объекта.

returns: строковое представление, которое начинает результат применения toString к этой коллекции. По умолчанию строковый префикс — это простое имя класса коллекции.

Definition Classes: TraversableLike → GenTraversableLike

def sum: A

[use case]

Суммирует элементы этой коллекции.

returns: сумма всех элементов в этой последовательности чисел типа Int. Вместо Int, может использоваться любой другой тип T с неявным Numeric[T] реализацией в качестве типа элемента последовательности и типа результата sum. Примеры таких типов: Long, Float, Double, BigInt.

Definition Classes: TraversableOnce → GenTraversableOnce

def tail: Repr

Выбирает все элементы, кроме первого.

returns: коллекция, содержащая все элементы этой коллекции, кроме первого.

Definition Classes: TraversableLike → GenTraversableLike
Исключения: java.lang.UnsupportedOperationException если коллекция пуста.

def tails: Iterator[Repr]

Перебирает хвосты этой коллекции. Первое значение будет этой коллекцией, а последнее — пустой коллекцией, а промежуточные значения — результатами последовательных применений tail.

returns: итератор по всем хвостам этой коллекции

Definition Classes: TraversableLike

def take(n: Int): Repr

Выбирает первые n элементов.

n: количество элементов, которые нужно взять из этой итерируемой коллекции.
returns: итерируемая коллекция, содержащая только первые n элементов этой итерируемой коллекции, или же вся итерируемая коллекция, если она содержит меньше n элементов. Если n отрицательное, возвращается пустая итерируемая коллекция.

Definition Classes: IterableLike → TraversableLike → GenTraversableLike

def takeRight(n: Int): Repr

Выбирает последние n элементов.

n: количество элементов для извлечения
returns: итерируемая коллекция, содержащая только последние n элементов этой итерируемой коллекции, или вся итерируемая коллекция, если она содержит меньше n элементов.

Definition Classes: IterableLike

def takeWhile(p: (A) ⇒ Boolean): Repr

Берёт самый длинный префикс элементов, удовлетворяющих предикату.

Примечание: может возвращать разные результаты для разных запусков, если тип базового набора не упорядочен.

возвращает: самый длинный префикс этого итерируемого набора, элементы которого удовлетворяют предикату p.

Классы-определения: IterableLike → TraversableLike → GenTraversableLike

def thisCollection: Seq[A]

Базовый набор, рассматриваемый как экземпляр Seq. По умолчанию он реализован как сам текущий набор, но это можно переопределить.

Атрибуты: protected[this]
Классы-определения: SeqLike → IterableLike → TraversableLike

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

[use case]

Преобразует эту последовательность в другую, копируя все элементы.

Примечание: не будет завершаться для коллекций бесконечного размера.

Col: Тип коллекции для построения.
возвращает: новая коллекция, содержащая все элементы этой последовательности.

Классы-определения: TraversableLike → TraversableOnce → GenTraversableOnce

def toArray: Array[A]

[use case]

Преобразует эту последовательность в массив.

Примечание: не будет завершаться для коллекций бесконечного размера.

возвращает: массив, содержащий все элементы этой последовательности. Для типа элементов этой последовательности должен быть доступен ClassTag.

Классы-определения: TraversableOnce → GenTraversableOnce

def toBuffer[B >: A]: Buffer[B]

Использует содержимое этого итерируемого или итератора для создания нового изменяемого буфера.

Примечание: не будет завершаться для коллекций бесконечного размера.

возвращает: буфер, содержащий все элементы этого итерируемого или итератора.

Классы-определения: TraversableOnce → GenTraversableOnce

def toCollection(repr: Repr): Seq[A]

Преобразование из коллекций типа Repr в объекты типа Seq. По умолчанию это реализовано как просто приведение типов, но это можно переопределить.

Атрибуты: protected[this]
Классы-определения: SeqLike → IterableLike → TraversableLike

def toIndexedSeq: immutable.IndexedSeq[A]

Преобразует этот итерируемый или итератор в индексированную последовательность.

Примечание: не будет завершаться для коллекций бесконечного размера.

возвращает: индексированная последовательность, содержащая все элементы этого итерируемого или итератора.

Классы-определения: TraversableOnce → GenTraversableOnce

def toIterable: Iterable[A]

Возвращает этот итерируемый набор в виде итерируемого набора.

Новая коллекция не будет построена; ленивые коллекции останутся ленивыми.

Примечание: не будет завершаться для коллекций бесконечного размера.

возвращает: итерируемый набор, содержащий все элементы этого итерируемого набора.

Классы-определения: IterableLike → TraversableOnce → GenTraversableOnce

def toIterator: Iterator[A]

Возвращает итератор по элементам в этом итерируемом наборе. Возвращает тот же результат, что и iterator.

Примечание: не будет завершаться для коллекций бесконечного размера.

возвращает: итератор, содержащий все элементы этого итерируемого набора.

Классы-определения: IterableLike → TraversableLike → GenTraversableOnce
Аннотации: @deprecatedOverriding( message = ... , since = "2.11.0" )

def toList: List[A]

Преобразует этот итерируемый или итератор в список.

Примечание: не будет завершаться для коллекций бесконечного размера.

возвращает: список, содержащий все элементы этого итерируемого или итератора.

Классы-определения: TraversableOnce → GenTraversableOnce

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

[use case]

Преобразует эту последовательность в карту. Этот метод недоступен, если элементы не являются членами Tuple2, каждый ((T, U)) становится парой ключ-значение в карте. Повторяющиеся ключи будут перезаписаны последующими ключами: если это неупорядоченная коллекция, какой ключ находится в результирующей карте, не определено.

Примечание: не завершится для коллекций бесконечного размера.

returns: карта типа immutable.Map[T, U], содержащая все пары ключ/значение типа (T, U) этой последовательности.

Definition Classes: TraversableOnce → GenTraversableOnce

def toParArray: ParArray[T]

Implicit: Этот член добавлен неявным преобразованием из SeqLike[A, Repr] в CollectionsHaveToParArray[SeqLike[A, Repr], T] выполняемым методом CollectionsHaveToParArray в scala.collection.parallel. Это преобразование произойдёт только если неявное значение типа (SeqLike[A, Repr]) ⇒ GenTraversableOnce[T] находится в области видимости.
Definition Classes: CollectionsHaveToParArray

def toSeq: Seq[A]

Преобразует эту последовательность в последовательность.

Примечание: не завершится для коллекций бесконечного размера.

Новая коллекция не будет создана; в частности, ленивые последовательности останутся ленивыми.

returns: последовательность, содержащая все элементы этой последовательности.

Definition Classes: SeqLike → GenSeqLike → TraversableOnce → GenTraversableOnce

def toSet[B >: A]: immutable.Set[B]

Преобразует это обозримое или итератор в множество.

Примечание: не завершится для коллекций бесконечного размера.

returns: множество, содержащее все элементы этого обозримого или итератора.

Definition Classes: TraversableOnce → GenTraversableOnce

def toStream: immutable.Stream[A]

Преобразует эту итерируемую коллекцию в поток.

returns: поток, содержащий все элементы этой итерируемой коллекции.

Definition Classes: IterableLike → TraversableLike → GenTraversableOnce

def toString(): String

Преобразует эту последовательность в строку.

returns: строковое представление этой коллекции. По умолчанию эта строка состоит из stringPrefix этой последовательности, за которой следуют все элементы, разделенные запятыми и заключенные в скобки.

Definition Classes: SeqLike → TraversableLike → Any

def toTraversable: Traversable[A]

Преобразует эту обозримую коллекцию в неуказанное Обозримое. Вернёт ту же самую коллекцию, если этот экземпляр уже Обозримый.

Примечание: не завершится для коллекций бесконечного размера.

returns: Обозримое, содержащее все элементы этой обозримой коллекции.

Definition Classes: TraversableLike → TraversableOnce → GenTraversableOnce
Annotations: @deprecatedOverriding( message = ... , since = "2.11.0" )

def toVector: Vector[A]

Преобразует это обозримое или итератор в Вектор.

Примечание: не завершится для коллекций бесконечного размера.

returns: вектор, содержащий все элементы этого обозримого или итератора.

Definition Classes: TraversableOnce → GenTraversableOnce

def union(that: Seq[A]): Seq[A]

[use case]

Создаёт новую последовательность, содержащую все элементы этой последовательности и также все элементы заданной последовательности. xs union ys эквивалентно xs ++ ys.

Другой способ выразить это заключается в том, что xs union ys вычисляет сохраняющую порядок мультимножество-объединение xs и ys. union - это, следовательно, аналог diff и intersect, которые также работают с мультимножествами.

Примечание: не завершится для коллекций бесконечного размера.

that: последовательность для добавления.
returns: новая последовательность, содержащая все элементы этой последовательности, за которыми следуют все элементы that.

Definition Classes: SeqLike → GenSeqLike

def updated(index: Int, elem: A): Seq[A]

[use case]

A copy of this sequence with one single replaced element.

index: the position of the replacement
elem: the replacing element
returns: a copy of this sequence with the element at position index replaced by elem.

Definition Classes: SeqLike → GenSeqLike

def view(from: Int, until: Int): SeqView[A, Repr]

Creates a non-strict view of a slice of this sequence.

Note: the difference between view and slice is that view produces a view of the current sequence, whereas slice produces a new sequence.

Note: view(from, to) is equivalent to view.slice(from, to)

from: the index of the first element of the view
until: the index of the element following the view
returns: a non-strict view of a slice of this sequence, starting at index from and extending up to (but not including) index until.

Definition Classes: SeqLike → IterableLike → TraversableLike

def view: SeqView[A, Repr]

Creates a non-strict view of this sequence.

returns: a non-strict view of this sequence.

Definition Classes: SeqLike → IterableLike → TraversableLike

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

Creates a non-strict filter of this traversable collection.

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.

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

p: the predicate used to test elements.
returns: an object of class WithFilter, which supports map, flatMap, foreach, and withFilter operations. All these operations apply to those elements of this traversable collection which satisfy the predicate p.

Definition Classes: TraversableLike → FilterMonadic

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

[use case]

Returns a sequence formed from this sequence 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.

B: the type of the second half of the returned pairs
that: The iterable providing the second half of each result pair
returns: a new sequence containing pairs consisting of corresponding elements of this sequence and that. The length of the returned collection is the minimum of the lengths of this sequence and that.

Definition Classes: IterableLike → GenIterableLike

def zipAll[B](that: Iterable[B], thisElem: A, thatElem: B): Seq[(A, B)]

[use case]

Returns a sequence formed from this sequence and another iterable collection by combining corresponding elements in pairs. If one of the two collections is shorter than the other, placeholder elements are used to extend the shorter collection to the length of the longer.

B: the type of the second half of the returned pairs
that: The iterable providing the second half of each result pair
thisElem: the element to be used to fill up the result if this sequence is shorter than that.
thatElem: the element to be used to fill up the result if that is shorter than this sequence.
returns: a new sequence containing pairs consisting of corresponding elements of this sequence and that. The length of the returned collection is the maximum of the lengths of this sequence and that. If this sequence is shorter than that, thisElem values are used to pad the result. If that is shorter than this sequence, thatElem values are used to pad the result.

Definition Classes: IterableLike → GenIterableLike

def zipWithIndex: Seq[(A, Int)]

[use case]

Zips this sequence with its indices.

returns: A new sequence containing pairs consisting of all elements of this sequence paired with their index. Indices start at 0.

Definition Classes: IterableLike → GenIterableLike

def →[B](y: B): (SeqLike[A, Repr], B)

Implicit: This member is added by an implicit conversion from SeqLike[A, Repr] to ArrowAssoc[SeqLike[A, Repr]] performed by method ArrowAssoc in scala.Predef.
Definition Classes: ArrowAssoc

Hidden Implicit Value Members

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

Implicit

This member is added by an implicit conversion from SeqLike[A, Repr] to MonadOps[A] performed by method MonadOps in scala.collection.TraversableOnce.

Hidden

This implicitly inherited member is hidden by one or more members in this class.
To access this member you can use a type ascription:

(seqLike: MonadOps[A]).filter(p)

Definition Classes

MonadOps

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

Implicit

This member is added by an implicit conversion from SeqLike[A, Repr] to MonadOps[A] performed by method MonadOps in scala.collection.TraversableOnce.

Hidden

This implicitly inherited member is hidden by one or more members in this class.
To access this member you can use a type ascription:

(seqLike: MonadOps[A]).flatMap(f)

Definition Classes

MonadOps

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

Implicit

This member is added by an implicit conversion from SeqLike[A, Repr] to MonadOps[A] performed by method MonadOps in scala.collection.TraversableOnce.

Hidden

This implicitly inherited member is hidden by one or more members in this class.
To access this member you can use a type ascription:

(seqLike: MonadOps[A]).map(f)

Definition Classes

MonadOps

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

Implicit

This member is added by an implicit conversion from SeqLike[A, Repr] to MonadOps[A] performed by method MonadOps in scala.collection.TraversableOnce.

Hidden

This implicitly inherited member is hidden by one or more members in this class.
To access this member you can use a type ascription:

(seqLike: MonadOps[A]).withFilter(p)

Definition Classes

MonadOps

© 2002-2019 EPFL, with contributions from Lightbend.
Licensed under the Apache License, Version 2.0.
https://www.scala-lang.org/api/2.12.9/scala/collection/SeqLike.html