Класс scala.collection.Concat

@SerialVersionUID(3L)

class Concat[A](prefix: SomeIterableOps[A], suffix: SomeIterableOps[A]) extends AbstractView[A]

Вид, который конкатенирует элементы коллекции-префикса или итератора с элементами коллекции-суффикса или итератора.

Конкретные методы

Исходный код

override def isEmpty: Boolean

Исходный код

def iterator: Iterator[A]

Исходный код

override def knownSize: Int

Наследованные методы

Исходный код@inline

final def ++[B >: A](suffix: IterableOnce[B]): View[B]

Псевдоним для concat

Исходный код@inline

final 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

Исходный код@inline

final 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

Исходный код

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)

Исходный код

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

Исходный код

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

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

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

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

Исходный код

def concat[B >: A](suffix: IterableOnce[B]): View[B]

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

Исходный код

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

Копирует элементы в массив, возвращая количество скопированных элементов.

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

Копирование остановится, как только будут скопированы все элементы этого набора, или будет достигнут конец массива, или len элементов будут скопированы.

Источник@deprecatedOverriding("Это должно всегда перенаправлять на 3-аргументную версию этого метода", since = "2.13.4")

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

Копирует элементы в массив, возвращая количество записанных элементов.

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

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

Источник@deprecatedOverriding("This should always forward to the 3-arg version of this method", since = "2.13.4")

def copyToArray[B >: A](xs: Array[B]): Int

Копирует элементы в массив, возвращая количество записанных элементов.

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

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

Источник

def corresponds[B](that: IterableOnce[B])(p: (A, B) => Boolean): Boolean

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

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

Источник

def count(p: A => Boolean): Int

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

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

Источник

def drop(n: Int): View[A]

Источник

def dropRight(n: Int): View[A]

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

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

Источник

def dropWhile(p: A => Boolean): View[A]

Источник

override def empty: View[A]

Источник

def exists(p: A => Boolean): Boolean

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

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

Источник

def filter(pred: A => Boolean): View[A]

Источник

def filterNot(pred: A => Boolean): View[A]

Источник

def find(p: A => Boolean): Option[A]

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

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

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

Source

def flatMap[B](f: A => IterableOnce[B]): View[B]

Source

def flatten[B](implicit asIterable: A => IterableOnce[B]): View[B]

Source

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

Вычисляет результат применения заданного ассоциативного бинарного оператора к элементам этого набора. Реализация по умолчанию в IterableOnce эквивалентна foldLeft, но может быть переопределена для более эффективного порядка обхода.

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

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

Source

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

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

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

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

Source

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

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

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

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

Source

def forall(p: A => Boolean): Boolean

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

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

Source

def foreach[U](f: A => U): Unit

Применяет f к каждому элементу для его побочных эффектов. Примечание: параметр [U] необходим для помощи в выводе типов scalac.

Source

protected def fromSpecific(coll: IterableOnce[A]): View[A]

Source

def groupBy[K](f: A => K): Map[K, View[A]]

Разделяет этот итерируемый набор на карту итерируемых наборов в соответствии с некоторой функцией-дискриминатором.

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

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

Source

def groupMap[K, B](key: A => K)(f: A => B): Map[K, View[B]]

Разделяет этот итерируемый набор на карту итерируемых наборов в соответствии с функцией-дискриминатором key. Каждый элемент в группе преобразуется в значение типа B с помощью функции value.

Эквивалентно groupBy(key).mapValues(_.map(f)), но более эффективно.

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

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

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

Source

def groupMapReduce[K, B](key: A => K)(f: A => B)(reduce: (B, B) => B): Map[K, B]

Разделяет этот итерируемый набор на карту в соответствии с функцией-дискриминатором key. Все значения, имеющие одинаковый дискриминатор, затем преобразуются с помощью функции f и затем сводятся к одному значению с помощью функции reduce.

Эквивалентно groupBy(key).mapValues(_.map(f).reduce(reduce)), но более эффективно.

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

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

Source

def grouped(size: Int): Iterator[View[A]]

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

Источник

def head: A

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

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

Источник

def headOption: Option[A]

Необязательно выбирает первый элемент.

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

Источник

def init: View[A]

Начальная часть коллекции без последнего элемента.

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

Источник

def inits: Iterator[View[A]]

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

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

Источник

override def isTraversableAgain: Boolean

Источник

override def iterableFactory: IterableFactory[View]

Источник

def last: A

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

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

Источник

def lastOption: Option[A]

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

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

Источник

def lazyZip[B](that: Iterable[B]): LazyZip2[A, B, Concat[A]]

Аналогично zip за исключением того, что элементы в каждой коллекции не потребляются до тех пор, пока не будет вызвана строгая операция над возвращенным LazyZip2 декоратором.

Вызовы lazyZip могут быть объединены для поддержки более высоких арностей (до 4) без затрат на создание и деструктуризацию промежуточных кортежей.

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)

Источник

def map[B](f: A => B): View[B]

Источник

def max[B >: A](implicit ord: Ordering[B]): A

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

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

Источник

def maxBy[B](f: A => B)(implicit cmp: Ordering[B]): A

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

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

Источник

def maxByOption[B](f: A => B)(implicit cmp: Ordering[B]): Option[A]

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

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

Source

def maxOption[B >: A](implicit ord: Ordering[B]): Option[A]

Находит максимальный элемент.

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

Source

def min[B >: A](implicit ord: Ordering[B]): A

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

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

Source

def minBy[B](f: A => B)(implicit cmp: Ordering[B]): A

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

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

Source

def minByOption[B](f: A => B)(implicit cmp: Ordering[B]): Option[A]

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

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

Source

def minOption[B >: A](implicit ord: Ordering[B]): Option[A]

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

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

Source@inline

final def mkString: String

Отображает все элементы этой коллекции в строке.

Делегирует вызов addString, который можно переопределить.

Источник@inline

final def mkString(sep: String): String

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

Делегирует вызов addString, который можно переопределить.

Источник

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

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

Делегирует вызов addString, который можно переопределить.

Источник

protected def newSpecificBuilder: Builder[A, View[A]]

Источник@deprecatedOverriding("nonEmpty is defined as !isEmpty; override isEmpty instead", "2.13.0")

def nonEmpty: Boolean

Проверяет, не пуста ли коллекция.

Источник

def partition(p: A => Boolean): (View[A], View[A])

Пара, во-первых, все элементы, которые удовлетворяют предикату p, и, во-вторых, все элементы, которые не удовлетворяют. Интересно, потому что разбивает коллекцию на две части.

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

Источник

def partitionMap[A1, A2](f: A => Either[A1, A2]): (View[A1], View[A2])

Применяет функцию f к каждому элементу итерируемого набора и возвращает пару итерируемых наборов: первый набор содержит значения, возвращённые f, заключённые в scala.util.Left, а второй — значения, заключённые в scala.util.Right.

Пример:

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

Источник

def product[B >: A](implicit num: Numeric[B]): B

Перемножает элементы этого набора.

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

Источник

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

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

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

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

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

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

protected def reversed: Iterable[A]

Источник

def scan[B >: A](z: B)(op: (B, B) => B): View[B]

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

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

Source

def scanLeft[B](z: B)(op: (B, A) => B): View[B]

Source

def scanRight[B](z: B)(op: (A, B) => B): View[B]

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

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

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

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

Пример:

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

Source

def size: Int

Размер этой коллекции.

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

Source

def sizeCompare(that: Iterable[_]): Int

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

Source

def sizeCompare(otherSize: Int): Int

Сравнивает размер этой итерабельной коллекции со значением.

x <  0       if this.size <  otherSize
x == 0       if this.size == otherSize
x >  0       if this.size >  otherSize

Source@inline

final def sizeIs: SizeCompareOps

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

Эти операции реализуются в терминах sizeCompare(Int) и позволяют использовать более удобочитаемый синтаксис:

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

Source

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

Source

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

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

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

Source

def sliding(size: Int): Iterator[View[A]]

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

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

Source

def span(p: A => Boolean): (View[A], View[A])

Source

override def splitAt(n: Int): (View[A], View[A])

Source

def stepper[S <: Stepper[_]](implicit shape: StepperShape[A, S]): S

Возвращает scala.collection.Stepper для элементов этой коллекции.

Stepper позволяет создавать Java-поток для работы с коллекцией, см. scala.jdk.StreamConverters. Для коллекций, хранящих примитивные значения, Stepper может использоваться как итератор, который не упаковывает элементы.

Неявный параметр scala.collection.StepperShape определяет тип результирующего Stepper в соответствии с типом элементов этой коллекции.

• Для коллекций Int, Short, Byte или Char, возвращается scala.collection.IntStepper

• Для коллекций Double или Float, возвращается scala.collection.DoubleStepper

• Для коллекций Long возвращается scala.collection.LongStepper

• Для любого другого типа элементов, возвращается scala.collection.AnyStepper

Обратите внимание, что этот метод переопределён в подклассах, и тип возвращаемого значения уточняется до S with EfficientSplit, например, scala.collection.IndexedSeqOps.stepper. Для Steppers, помеченных scala.collection.Stepper.EfficientSplit, конвертеры в scala.jdk.StreamConverters позволяют создавать параллельные потоки, в то время как обычные Steppers могут быть преобразованы только в последовательные потоки.

Исходный код

def sum[B >: A](implicit num: Numeric[B]): B

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

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

Исходный код

def tail: View[A]

Остальная часть коллекции без её первого элемента.

Исходный код

def tails: Iterator[View[A]]

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

Исходный код

def take(n: Int): View[A]

Исходный код

def takeRight(n: Int): View[A]

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

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

Исходный код

def takeWhile(p: A => Boolean): View[A]

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

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

Исходный код

override def tapEach[U](f: A => U): View[A]

Исходный код

def to[C1](factory: Factory[A, C1]): C1

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

xs.to(List) xs.to(ArrayBuffer) xs.to(BitSet) // для xs: Iterable[Int]

Исходный код

def toArray[B >: A : ClassTag]: Array[B]

Преобразовать коллекцию в массив.

Примечание реализации: НЕ вызывайте Array.from из этого метода.

Исходный код@inline

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

Исходный код

def toIndexedSeq: IndexedSeq[A]

Исходный код

def toList: List[A]

Исходный код

def toMap[K, V](implicit ev: A <:< (K, V)): Map[K, V]

Исходный код

def toSeq: Seq[A]

Исходный код

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

Исходный код

override def toString: String

Исходный код

def toVector: Vector[A]

Источник

def transpose[B](implicit asIterable: A => Iterable[B]): View[View[B]]

Транспонирует это итерируемое множество итерируемых множеств в итерируемое множество итерируемых множеств.

Тип результирующего множества будет определяться статическим типом итерируемого множества. Например:

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

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

Источник

def unzip[A1, A2](implicit asPair: A => (A1, A2)): (View[A1], View[A2])

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

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

Источник

def unzip3[A1, A2, A3](implicit asTriple: A => (A1, A2, A3)): (View[A1], View[A2], View[A3])

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

val xs = Iterable(
           (1, "one", '1'),
           (2, "two", '2'),
           (3, "three", '3')).unzip3
// xs == (Iterable(1, 2, 3),
//        Iterable(one, two, three),
//        Iterable(1, 2, 3))

Источник

override def view: View[A]

Источник

def withFilter(p: A => Boolean): WithFilter[A, View]

Создаёт нестрогое фильтрование этого итерируемого множества.

Примечание: разница между c filter p и c withFilter p заключается в том, что первый создаёт новое множество, а второй только ограничивает область действия последующих map, flatMap, foreach, и withFilter операций.

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

Источник

def zip[B](that: IterableOnce[B]): View[(A, B)]

Возвращает итерируемое множество, образованное из этого итерируемого множества и другого итерируемого множества, объединяя соответствующие элементы в пары. Если одно из двух множеств длиннее другого, оставшиеся элементы игнорируются.

Источник

def zipAll[A1 >: A, B](that: Iterable[B], thisElem: A1, thatElem: B): View[(A1, B)]

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

Источник

def zipWithIndex: View[(A, Int)]