Класс DoubleAccumulator.DoubleAccumulator

final class DoubleAccumulator extends Accumulator[Double, AnyAccumulator, DoubleAccumulator] with SeqOps[Double, AnyAccumulator, DoubleAccumulator] with Serializable

Специализированный Accumulator, который хранит Double без автоматического преобразования типа, см. Accumulator.

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

Исходный код

def addOne(a: Double): DoubleAccumulator.this.type

Добавляет элемент в этот DoubleAccumulator.

Исходный код

def apply(ix: Long): Double

Возвращает элемент с индексом ix.

Исходный код

def apply(i: Int): Double

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

Исходный код

override def clear(): Unit

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

Исходный код

def collect(pf: PartialFunction[Double, Double]): DoubleAccumulator

Исходный код

override def count(p: Double => Boolean): Int

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

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

Исходный код

def countLong(p: Double => Boolean): Long

Исходный код

def drain(that: DoubleAccumulator): Unit

Удаляет все элементы из that и добавляет их в этот DoubleAccumulator.

Исходный код

def efficientStepper[S <: Stepper[_]](implicit shape: StepperShape[Double, S]): S & EfficientSplit

Исходный код

override def empty: DoubleAccumulator

Пустая итерируемая коллекция того же типа, что и эта итерируемая коллекция

Исходный код

override def exists(p: Double => Boolean): Boolean

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

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

Исходный код

override def filter(pred: Double => Boolean): DoubleAccumulator

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

Исходный код

override def filterNot(pred: Double => Boolean): DoubleAccumulator

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

Источник

def flatMap(f: Double => IterableOnce[Double]): DoubleAccumulator

Источник

override def forall(p: Double => Boolean): Boolean

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

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

Источник

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

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

Источник

override def iterableFactory: SeqFactory[AnyAccumulator]

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

Источник

def iterator: Iterator[Double]

Возвращает Iterator над содержимым этой DoubleAccumulator. Iterator не специализирована.

Источник

def map(f: Double => Double): DoubleAccumulator

Источник

override def result(): DoubleAccumulator

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

Источник

override def to[C1](factory: Factory[Double, C1]): C1

Копирует элементы в эту DoubleAccumulator в указанную коллекцию. Обратите внимание, что целевая коллекция не специализирована. Пример использования: acc.to(Vector)

Источник

def toArray: Array[Double]

Копирует элементы в эту DoubleAccumulator в Array[Double]

Источник

override def toList: List[Double]

Копирует элементы из этой DoubleAccumulator в List

Источник

def update(idx: Long, elem: Double): Unit

Источник

def update(idx: Int, elem: Double): Unit

Заменяет элемент с заданным индексом новым значением.

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

Источник

final def ++[B >: Double](suffix: IterableOnce[B]): CC[B]

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

Источник

final override def ++:[B >: Double](prefix: IterableOnce[B]): CC[B]

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

Источник

final def ++=(xs: IterableOnce[Double]): Growable.this.type

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

Источник

final def +:[B >: Double](elem: B): CC[B]

Псевдоним для prepended.

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

Источник

final def +=(elem: Double): Growable.this.type

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

Источник

final def :+[B >: Double](elem: B): CC[B]

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

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

Источник

final def :++[B >: Double](suffix: IterableOnce[B]): CC[B]

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

Source

def addAll(xs: IterableOnce[Double]): Growable.this.type

Добавляет все элементы, полученные из IterableOnce, в это изменяемое множество.

Source

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

Source

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

Source

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)

Source

def andThen[C](k: PartialFunction[Double, C]): PartialFunction[A, C]

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

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

Источник

override def andThen[C](k: Double => C): PartialFunction[A, C]

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

Если тип функции во время выполнения является PartialFunction, то используется другой метод andThen (обратите внимание на его предостережения).

Источник

def appended[B >: Double](elem: B): CC[B]

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

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

Пример:

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)

Источник

def appendedAll[B >: Double](suffix: IterableOnce[B]): CC[B]

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

Источник

def applyOrElse[A1 <: Int, B1 >: Double](x: A1, default: A1 => B1): B1

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

Обратите внимание, что выражение pf.applyOrElse(x, default) эквивалентно

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

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

- объединение частичных функций в цепочки orElse/andThen не приводит к чрезмерному вычислению apply/isDefinedAt - lift и unlift не вычисляют исходные функции дважды при каждом вызове - runWith позволяет эффективно объединять частичные функции в императивном стиле с условно примененными действиями

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

Источник

def canEqual(that: Any): Boolean

Метод, который должен вызываться из каждого хорошо спроектированного метода equals, который может быть переопределен в подклассе. См. Программирование на Scala, глава 28 для обсуждения и проектирования.

Источник

override def clone(): C

Создает копию объекта-получателя.

Реализация метода clone по умолчанию зависит от платформы.

Источник

def collect[B](pf: PartialFunction[Double, B]): CC[B]

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

def compose[R](k: PartialFunction[R, Int]): PartialFunction[R, B]

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

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

Источник

def compose[A](g: A => Int): A => R

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

Источник

final override def concat[B >: Double](suffix: IterableOnce[B]): CC[B]

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

Источник

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

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

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

Источник

def containsSlice[B >: Double](that: Seq[B]): Boolean

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

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

def corresponds[B](that: Seq[B])(p: (Double, B) => Boolean): Boolean

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

Источник

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

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

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

Источник

def diff[B >: Double](that: Seq[B]): C

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

Источник

def distinct: C

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

Источник

def distinctBy[B](f: Double => B): C

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

Источник

def drop(n: Int): C

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

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

Source

def dropRight(n: Int): C

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

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

Source

def dropWhile(p: Double => Boolean): C

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

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

Source

def elementWise: ElementWiseExtractor[A, B]

Возвращает объект-экстрактор с методом unapplySeq, который извлекает каждый элемент данных последовательности.

val firstChar: String => Option[Char] = _.headOption
Seq("foo", "bar", "baz") match {
  case firstChar.unlift.elementWise(c0, c1, c2) =>
    println(s"$c0, $c1, $c2") // Output: f, b, b
}

Source

def endsWith[B >: Double](that: Iterable[B]): Boolean

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

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

Source

override def equals(o: Any): Boolean

Универсальный метод равенства, определенный в AnyRef.

Source

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

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

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

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

Source

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

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

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

Исходный код

def flatMap[B](f: Double => IterableOnce[B]): CC[B]

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

Например:

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: String) => 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)

Исходный код

def flatten[B](implicit asIterable: Double => IterableOnce[B]): CC[B]

Преобразует эту итерируемую коллекцию коллекций итераций в итерируемую коллекцию, образованную элементами этих коллекций итераций.

Тип результирующей коллекции будет определяться типом итерируемой коллекции. Например:

val xs = List(
           Set(1, 2, 3),
           Set(1, 2, 3)
         ).flatten
// xs == List(1, 2, 3, 1, 2, 3)

val ys = Set(
           List(1, 2, 3),
           List(3, 2, 1)
         ).flatten
// ys == Set(1, 2, 3)

Исходный код

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

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

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

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

Исходный код

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

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

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

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

Источник

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

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

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

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

Источник

def groupBy[K](f: Double => K): Map[K, C]

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

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

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

Источник

def groupMap[K, B](key: Double => K)(f: Double => B): Map[K, CC[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: Double => K)(f: Double => 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[C]

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

Source

override def hashCode(): Int

Вычисляет значение хэш-кода для объекта.

Алгоритм хэширования по умолчанию зависит от платформы.

Обратите внимание, что для двух объектов могут быть одинаковые хэш-коды (o1.hashCode.equals(o2.hashCode)) но они могут не быть равными (o1.equals(o2) возвращает false). Вырожденная реализация может всегда возвращать 0. Однако, требуется, чтобы если два объекта равны (o1.equals(o2) возвращает true) у них должны быть идентичные хэш-коды (o1.hashCode.equals(o2.hashCode)). Поэтому, при переопределении этого метода, убедитесь, что поведение согласуется с методом equals.

Source

def head: A

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

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

Source

def headOption: Option[A]

Возвращает опцию с первым элементом.

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

Source

def indexOf[B >: Double](elem: B): Int

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

Source

def indexOf[B >: Double](elem: B, from: Int): Int

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

Источник

def indexOfSlice[B >: Double](that: Seq[B]): Int

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

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

Источник

def indexOfSlice[B >: Double](that: Seq[B], from: Int): Int

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

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

Источник

def indexWhere(p: Double => Boolean): Int

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

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

Источник

def indexWhere(p: Double => Boolean, from: Int): Int

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

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

Источник

def indices: Range

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

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

Источник

def init: C

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

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

Источник

def inits: Iterator[C]

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

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

Источник

def intersect[B >: Double](that: Seq[B]): C

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

Источник

def isDefinedAt(idx: Int): Boolean

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

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

Источник

override def isEmpty: Boolean

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

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

Источник

override def isTraversableAgain: Boolean

Проверяет, может ли эта итерируемая коллекция быть многократно пройдена. Всегда true для Iterables и false для Iterators, если не переопределено.

Источник

final override def knownSize: Int

Исходный код

def last: A

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

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

Исходный код

def lastIndexOf[B >: Double](elem: B, end: Int): Int

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

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

Исходный код

def lastIndexOfSlice[B >: Double](that: Seq[B]): Int

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

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

Исходный код

def lastIndexOfSlice[B >: Double](that: Seq[B], end: Int): Int

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

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

Исходный код

def lastIndexWhere(p: Double => Boolean): Int

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

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

Source

def lastIndexWhere(p: Double => Boolean, end: Int): Int

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

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

Source

def lastOption: Option[A]

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

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

Source

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

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

Source

final override def length: Int

Длина (количество элементов) наращиваемой коллекции. size — псевдоним для length в коллекциях Seq.

Source

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

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

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

Source

def lengthCompare(len: Int): Int

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

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

Источник

final def lengthIs: SizeCompareOps

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

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

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

Источник

def lift: A => Option[B]

Преобразует эту частичную функцию в обычную функцию, возвращающую Option результат.

Источник

def map[B](f: Double => B): CC[B]

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

Источник

def mapResult[NewTo](f: DoubleAccumulator => NewTo): Builder[A, NewTo]

Билдер, полученный из этого билдера путём отображения результата с использованием f.

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

final def mkString: String

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

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

Источник

final def mkString(sep: String): String

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

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

Источник

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

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

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

Источник

def nonEmpty: Boolean

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

Источник

def orElse[A1 <: Int, B1 >: Double](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]

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

Источник

def padTo[B >: Double](len: Int, elem: B): CC[B]

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

Источник

def partition(p: Double => Boolean): (C, C)

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

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

Источник

def partitionMap[A1, A2](f: Double => Either[A1, A2]): (CC[A1], CC[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 patch[B >: Double](from: Int, other: IterableOnce[B], replaced: Int): CC[B]

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

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

Исходный код

def permutations: Iterator[C]

Перебирает все различные перестановки.

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

Исходный код

def prepended[B >: Double](elem: B): CC[B]

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

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

Пример:

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)

Исходный код

def prependedAll[B >: Double](prefix: IterableOnce[B]): CC[B]

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

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

Исходный код

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

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

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

Исходный код

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

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

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

Источник

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

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

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

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

Источник

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

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

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

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

Источник

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

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

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

Источник

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

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

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

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

Источник

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

Опционально применяет бинарную операцию ко всем элементам этого набора, справа налево.

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

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

Источник

def reverse: C

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

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

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

Источник

def reverseIterator: Iterator[A]

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

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

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

Источник

protected def reversed: Iterable[A]

Источник

def runWith[U](action: Double => U): A => Boolean

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

Обратите внимание, что выражение pf.runWith(action)(x) эквивалентно

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

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

Источник

def sameElements[B >: Double](that: IterableOnce[B]): Boolean

Являются ли элементы этого набора одинаковыми (и в том же порядке) что и элементы that?

Источник

def scan[B >: Double](z: B)(op: (B, B) => B): CC[B]

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

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

Источник

def scanLeft[B](z: B)(op: (B, Double) => B): CC[B]

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

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

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

Источник

def scanRight[B](z: B)(op: (Double, B) => B): CC[B]

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

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

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

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

Пример:

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

Источник

def search[B >: Double](elem: B, from: Int, to: Int)(implicit ord: Ordering[B]): SearchResult

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

Перед вызовом набор должен быть отсортирован с использованием того же Ordering; в противном случае результаты будут неопределёнными.

Исходный код

def search[B >: Double](elem: B)(implicit ord: Ordering[B]): SearchResult

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

Набор должен быть отсортирован с тем же Ordering перед вызовом; в противном случае результаты не определены.

Исходный код

def segmentLength(p: Double => Boolean, from: Int): Int

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

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

Исходный код

final def segmentLength(p: Double => Boolean): Int

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

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

Исходный код

final override def size: Int

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

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

Исходный код

final override 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

Исходный код

final override def sizeCompare(otherSize: Int): Int

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

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

Исходный код

final def sizeHint(coll: IterableOnce[_], delta: Int): Unit

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

Исходный код

def sizeHint(size: Int): Unit

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

Исходный код

final def sizeHintBounded(size: Int, boundingColl: Iterable[_]): Unit

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

Source

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

final def sizeLong: Long

Размер накопленной коллекции в виде Long

Source

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

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

from <= indexOf(x) < until

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

Source

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

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

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

Source

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

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

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

Source

def sortBy[B](f: Double => B)(implicit ord: Ordering[B]): C

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

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

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

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

val words = "The quick brown fox jumped over the lazy dog".split(' ')
// this works because scala.Ordering will implicitly provide an Ordering[Tuple2[Int, Char]]
words.sortBy(x => (x.length, x.head))
res0: Array[String] = Array(The, dog, fox, the, lazy, over, brown, quick, jumped)

Исходный код

def sortWith(lt: (Double, Double) => Boolean): C

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

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

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

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

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

Исходный код

def sorted[B >: Double](implicit ord: Ordering[B]): C

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

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

Исходный код

def span(p: Double => Boolean): (C, C)

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

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

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

Исходный код

override def splitAt(n: Int): (C, C)

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

Примечание: c splitAt n эквивалентно (но, возможно, более эффективно), чем (c take n, c drop n).

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

Источник

def startsWith[B >: Double](that: IterableOnce[B], offset: Int): Boolean

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

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

Источник

final override def stepper[S <: Stepper[_]](implicit shape: StepperShape[Double, S]): S & EfficientSplit

Возвращает 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. Для Stepper, помеченных с помощью scala.collection.Stepper.EfficientSplit, конвертеры в scala.jdk.StreamConverters позволяют создавать параллельные потоки, тогда как обычные Stepper можно преобразовать только в последовательные потоки.

Источник

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

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

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

Источник

def tail: C

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

Источник

def tails: Iterator[C]

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

Источник

def take(n: Int): C

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

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

Источник

def takeRight(n: Int): C

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

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

Источник

def takeWhile(p: Double => Boolean): C

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

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

Источник

override def tapEach[U](f: Double => U): C

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

Источник

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

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

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

Исходный код

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

Исходный код

def toIndexedSeq: IndexedSeq[A]

Исходный код

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

Исходный код

def toSeq: Seq[A]

Исходный код

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

Исходный код

override def toString(): String

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

Представление по умолчанию зависит от платформы.

Исходный код

def toVector: Vector[A]

Исходный код

def transpose[B](implicit asIterable: Double => Iterable[B]): CC[CC[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 unapply(a: Int): Option[B]

Попытка извлечь B из A в выражении сопоставления с образцом.

Исходный код

def unzip[A1, A2](implicit asPair: Double => (A1, A2)): (CC[A1], CC[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: Double => (A1, A2, A3)): (CC[A1], CC[A2], CC[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))

Исходный код

def updated[B >: Double](index: Int, elem: B): CC[B]

Копия этого последовательности с одним заменённым элементом.

Исходный код

override def view: SeqView[A]

Представление над элементами этого множества.

Исходный код

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

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

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

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

Исходный код

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

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

Исходный код

def zipAll[A1 >: Double, B](that: Iterable[B], thisElem: A1, thatElem: B): CC[(A1, B)]

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

Исходный код

def zipWithIndex: CC[(A, Int)]

Объединяет этот итерируемый набор с его индексами.