Класс View.Updated

class Updated[A](underlying: SomeIterableOps[A], index: Int, elem: A) extends AbstractView[A]

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

Исходный код

override def isEmpty: Boolean

Проверяет, пуст ли вью.

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

Исходный код

def iterator: Iterator[A]

Итератор может быть использован только один раз

Исходный код

override def knownSize: Int

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

Исходный код

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

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

Исходный код

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

Исходный код

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]): CC[B]

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

Источник

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

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

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

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

Источник

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

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

Источник

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

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

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

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

Исходный код

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

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

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

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

Исходный код

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

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

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

Исходный код

def dropRight(n: Int): C

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

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

Исходный код

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

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

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

Исходный код

override def empty: View[A]

Пустой итерируемый набор того же типа, что и этот итерируемый набор

Исходный код

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

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

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

Исходный код

def filter(pred: A => Boolean): C

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

Source

def filterNot(pred: A => Boolean): C

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

Source

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

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

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

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

Source

def flatMap[B](f: A => 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)

Source

def flatten[B](implicit asIterable: A => 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)

Source

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]): CC[A]

Определяет, как преобразовать заданную Iterable[A] в коллекцию типа C.

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

Источник

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

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

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

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

Источник

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

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

Источник

def head: A

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

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

Источник

def headOption: Option[A]

Опционально выбирает первый элемент.

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

Источник

def init: C

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

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

Источник

def inits: Iterator[C]

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

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

Источник

override def isTraversableAgain: Boolean

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

Источник

override def iterableFactory: IterableFactory[View]

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

Источник

def last: A

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

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

Источник

def lastOption: Option[A]

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

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

Источник

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)

Источник

def map[B](f: A => B): CC[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]

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

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

Исходный код

final def mkString: String

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

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

Исходный код

final def mkString(sep: String): String

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

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

Исходный код

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

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

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

Исходный код

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

Исходный код

def nonEmpty: Boolean

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

Исходный код

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

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

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

Исходный код

def partitionMap[A1, A2](f: A => 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 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): CC[B]

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

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

Исходный код

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

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

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

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

Исходный код

def scanRight[B](z: B)(op: (A, B) => B): CC[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

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

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): 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 span(p: A => Boolean): (C, C)

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

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

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

Source

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

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

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

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

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

Source

def sum[B >: A](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: A => Boolean): C

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

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

Исходный код

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

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

Исходный код

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

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

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

Исходный код

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

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

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

Исходный код

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

Источник

override def view: View[A]

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

Источник

def withFilter(p: A => 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 >: A, B](that: Iterable[B], thisElem: A1, thatElem: B): CC[(A1, B)]

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

Источник

def zipWithIndex: CC[(A, Int)]

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