Класс scala.collection.Unfold

@SerialVersionUID(3L)

class Unfold[A, S](initial: S)(f: S => Option[(A, S)]) extends AbstractView[A]

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

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

Исходный код

def iterator: Iterator[A]

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

Исходный код@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("This should always forward to the 3-arg version of this method", 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]

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

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

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

Источник

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

Источник

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

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

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

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

Источник

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

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

Источник

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

Источник

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

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

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

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

Источник

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)

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

Источник

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)(_ + _)

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

Источник

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

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

Источник

def head: A

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

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

Источник

def headOption: Option[A]

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

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

Источник

def init: View[A]

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

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

Источник

def inits: Iterator[View[A]]

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

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

Источник

def isEmpty: Boolean

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

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

Источник

override def isTraversableAgain: Boolean

Источник

override def iterableFactory: IterableFactory[View]

Источник

def knownSize: Int

Источник

def last: A

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

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

Источник

def lastOption: Option[A]

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

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

Источник

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

Аналогично 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.

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник@inline

final def mkString: String

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

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

Source@inline

final def mkString(sep: String): String

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

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

Source

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

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

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

Source

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

Source@deprecatedOverriding("nonEmpty is defined as !isEmpty; override isEmpty instead", "2.13.0")

def nonEmpty: Boolean

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

Source

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

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

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

Source

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

Применяет функцию f к каждому элементу коллекции Iterable и возвращает пару коллекций Iterable: первая — из тех значений, возвращаемых 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 может быть применен более одного раза.

Источник

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

Исходный код

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

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

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

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

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

Пример:

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

Исходный код

def size: Int

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

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

Исходный код

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

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

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

Исходный код

def sizeCompare(otherSize: Int): Int

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

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

Исходный код@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

Исходный код

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

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

Исходный код

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

Исходный код

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

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

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

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

• Для коллекций целых чисел, чисел с плавающей точкой, длинных целых чисел или символов возвращается scala.collection.IntStepper

• Для коллекций чисел с плавающей точкой или чисел с двойной точностью возвращается scala.collection.DoubleStepper

• Для коллекций длинных целых чисел возвращается scala.collection.LongStepper

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

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

Источник

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. Примеры использования:

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