Класс scala.collection.Filter

@SerialVersionUID(3L)

class Filter[A](val underlying: SomeIterableOps[A], val p: A => Boolean, val isFlipped: Boolean) 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("Это всегда должно передавать управление в 3-аргументную версию этого метода", 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, Filter[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

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

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

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. Для Степеров, помеченных 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

Преобразует эту коллекцию в соответствующее представление для текущего типа элементов A с использованием фабрики коллекций 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]): Вид[Вид[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)): (Вид[A1], Вид[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)): (Вид[A1], Вид[A2], Вид[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: Вид[A]

Источник

def withFilter(p: A => Boolean): WithFilter[A, Вид]

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

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

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

Источник

def zip[B](that: IterableOnce[B]): Вид[(A, B)]

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

Источник

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

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

Источник

def zipWithIndex: Вид[(A, Целое)]

Конкретные поля

Источник

val isFlipped: Булево

Источник

val p: A => Boolean

Источник

val underlying: SomeIterableOps[A]