Трейт scala.collection.SeqViewLike.Patched

Проверка двух объектов на неравенство.

Эквивалентно x.hashCode за исключением упакованных числовых типов и null. Для чисел возвращает значение хэша, согласованное с равенством значений: если два экземпляра типа значения сравниваются как true, то ## вернёт одинаковое значение хэша для каждого из них. Для null возвращает хэш-код, где null.hashCode выбрасывает NullPointerException.

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

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

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

Пример:

scala> val x = List(1)
x: List[Int] = List(1)

scala> val y = LinkedList(2)
y: scala.collection.mutable.LinkedList[Int] = LinkedList(2)

scala> val z = x ++: y
z: scala.collection.mutable.LinkedList[Int] = LinkedList(1, 2)

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

Так как у TraversableOnce нет метода ++, нам нужно реализовать его напрямую, но Traversable и ниже могут использовать перегрузку.

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

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

Пример:

scala> val x = List(1)
x: List[Int] = List(1)

scala> val y = LinkedList(2)
y: scala.collection.mutable.LinkedList[Int] = LinkedList(2)

scala> val z = x ++: y
z: scala.collection.mutable.LinkedList[Int] = LinkedList(1, 2)

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

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

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

Пример:

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)

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

Примечание: /: — это альтернативная синтаксическая запись для foldLeft; z /: xs эквивалентно xs foldLeft z.

Примеры:

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

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

scala> val b = (5 /: a)(_+_)
b: Int = 15

scala> val c = (5 /: a)((x,y) => x + y)
c: Int = 15

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

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

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

Мемоническая подсказка для +: против :+: двоеточие относится к коллекции.

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

Пример:

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)

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

Примечание: :\ — это альтернативная синтаксическая запись для foldRight; xs :\ z эквивалентно xs foldRight z.

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

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

Примеры:

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

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

scala> val b = (a :\ 5)(_+_)
b: Int = 15

scala> val c = (a :\ 5)((x,y) => x + y)
c: Int = 15

Выражение x == that эквивалентно if (x eq null) that eq null else x.equals(that).

Добавляет все элементы этого итерируемого объекта или итератора в строковый буфер. Записываемый текст состоит из строковых представлений (относительно метода 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

Добавляет все элементы этого итерируемого объекта или итератора в строковый буфер с использованием разделительной строки. Записываемый текст состоит из строковых представлений (относительно метода 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

Агрегирует результаты применения оператора к последующим элементам.

Это более общий вид fold и reduce. Он похож на foldLeft тем, что не требует, чтобы результат был супертипом типа элемента. Кроме того, он позволяет обрабатывать параллельные коллекции в блоках, а затем объединять промежуточные результаты.

aggregate разбивает итерируемый объект или итератор на разделы и обрабатывает каждый раздел, последовательно применяя seqop, начиная с z (как foldLeft). Эти промежуточные результаты затем объединяются с помощью combop (как fold). Реализация этой операции может работать с произвольным количеством разделов коллекции (даже 1), поэтому combop может быть вызвана произвольное количество раз (даже 0).

Например, рассмотрим суммирование целочисленных значений списка символов. Начальное значение суммы равно 0. Сначала seqop преобразует каждый входной символ в целое число и добавляет его к сумме (раздела). Затем combop просто нужно сложить промежуточные результаты разделов:

List('a', 'b', 'c').aggregate(0)({ (sum, ch) => sum + ch.toInt }, { (p1, p2) => p1 + p2 })

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

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

Пример:

scala> val x = List(1, 2, 3, 4, 5)
x: List[Int] = List(1, 2, 3, 4, 5)

scala> x(3)
res1: Int = 4

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

Обратите внимание, что выражение 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. Это может привести к лучшей производительности и более предсказуемому поведению с точки зрения побочных эффектов.

Преобразует объект-получатель к типу T0.

Обратите внимание, что успех преобразования во время выполнения зависит от семантики стирания типов в Scala. Поэтому выражение 1.asInstanceOf[String] вызовет ClassCastException во время выполнения, в то время как выражение List(1).asInstanceOf[List[String]] не вызовет. В последнем примере, поскольку аргумент типа стирается при компиляции, невозможно проверить, относятся ли содержимое списка к требуемому типу.

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

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

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

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

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

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

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

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

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

Объект-компаньон фабрики, создающий экземпляры класса Seq. (или его Iterable суперкласса, если класс Seq не является Seq. )

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

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

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

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

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

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

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

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

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

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

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

Копирует все элементы этой структуры или итератора в буфер.

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

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

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

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

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

Создаёт новую последовательность из этой последовательности без дублируемых элементов.

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

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

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

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

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

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

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

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

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

Проверяет, является ли аргумент (that) ссылкой на объект-получатель (this).

Метод eq реализует отношение эквивалентности на не-нулевых экземплярах AnyRef, и имеет три дополнительных свойства:

Он согласован: для любых не-нулевых экземпляров x и y типа AnyRef, многократные вызовы x.eq(y) последовательно возвращают true или последовательно возвращают false.Для любого не-нулевого экземпляра x типа AnyRef, x.eq(null) и null.eq(x) возвращают false. null.eq(null) возвращает true.

При переопределении методов equals или hashCode важно обеспечить, чтобы их поведение было согласованным с равенством ссылок. Поэтому, если два объекта являются ссылками друг на друга (o1 eq o2), они должны быть равны друг другу (o1 == o2) и они должны хэшироваться к одному значению (o1.hashCode == o2.hashCode).

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

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

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

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

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

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

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

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

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

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

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

Например:

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

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

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

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)

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

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

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

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

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

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

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

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

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

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

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

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

Возвращает строку, отформатированную в соответствии с данной format строкой. Строки форматирования аналогичны строкам форматирования String.format (@см. java.lang.String.format).

Общий билдер, который строит экземпляры Traversable для произвольных типов элементов.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Проверяет, является ли динамический тип объекта-получателя T0.

Обратите внимание, что результат теста зависит от стирания семантики Scala. Поэтому выражение 1.isInstanceOf[String] вернёт false, а выражение List(1).isInstanceOf[List[String]] вернёт true. В последнем примере, из-за стирания аргумента типа во время компиляции невозможно проверить, соответствуют ли элементы списка указанному типу.

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

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

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

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

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

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

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

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

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

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

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

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

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

Возвращает последний элемент (если он существует).

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

Длина последовательности.

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

Примечание: xs.length и xs.size дают один и тот же результат.

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

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

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

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

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

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

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

Эквивалентно !(this eq that).

Билдер, который создает экземпляры типа Traversable[A]

Шаблонный метод, для переопределения в каждом подклассе. Этот метод можно было бы устранить, если бы в Scala были виртуальные классы

Шаблонный метод, для переопределения в каждом подклассе. Этот метод можно было бы устранить, если бы в Scala были виртуальные классы

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

Разбуждает единственную нить, ожидающую монитора объекта-получателя.

Разбуждает все нити, ожидающие монитора объекта-получателя.

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

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

Возвращает параллельное выполнение этой коллекции.

Для большинства типов коллекций этот метод создаёт новую параллельную коллекцию, копируя все элементы. Для этих коллекций метод `par` занимает линейное время. Изменяемые коллекции в этой категории не генерируют изменяемую параллельную коллекцию, которая имеет те же самые данные, поэтому изменения в одной коллекции не будут отражены в другой.

Конкретные коллекции (например, … или …) переопределяют это поведение по умолчанию, создавая параллельную коллекцию, которая использует те же самые данные. Для этих коллекций `par` занимает постоянное или подлинейное время.

Все параллельные коллекции возвращают ссылку на себя.

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

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

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

Итерируется по различным перестановкам.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Коллекция типа traversable collection, лежащая в основе этого объекта TraversableLike. По умолчанию она реализована как сам объект TraversableLike, но это можно переопределить.

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

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

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

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

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

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

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

Примечание: xs.reverseMap(f) эквивалентно xs.reverse.map(f), но может быть более эффективным.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Пример:

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

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

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

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

Этот метод возвращает ссылку на эту коллекцию. В параллельных коллекциях он переопределён для возвращения последовательной реализации этой коллекции. В обоих случаях сложность O(1).

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

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

Размер этой коллекции или итератора, если его можно вычислить дёшево.

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

from <= indexOf(x) < until

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

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

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

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

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

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

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

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

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

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

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

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

Разделяет эту коллекцию на две части по заданной позиции. Примечание: c splitAt n эквивалентно (но, возможно, более эффективно), чем (c take n, c drop n).

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

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

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

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

Определяет префикс представления этого объекта.

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

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

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

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

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

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

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

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

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

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

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

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

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

Преобразует эту последовательность в массив.

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

Использует содержимое этого итерируемого объекта или итератора для создания нового изменяемого буфера.

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

Преобразование из наборов типа Repr в объекты Seq. По умолчанию это реализовано как просто приведение типов, но это можно переопределить.

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

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

Возвращает этот итерируемый набор как итерируемый набор.

Новый набор не будет создан; ленивые наборы останутся ленивыми.

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

Возвращает итератор над элементами в этом итерируемом наборе. Возвращает тот же результат, что и iterator.

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

Преобразует это итерируемое или итератор в список.

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

Преобразует эту последовательность в карту. Этот метод недоступен, если элементы не являются членами Tuple2, причем каждый ((T, U)) становится парой ключ-значение в карте. Дублирующиеся ключи будут перезаписаны последующими ключами: если это неупорядоченная коллекция, то ключ, присутствующий в результирующей карте, не определен.

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

Преобразует эту последовательность в последовательность.

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

Новая коллекция не будет построена; в частности, ленивые последовательности останутся ленивыми.

Преобразует это итерируемое или итератор в множество.

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

Преобразует этот итерируемый набор в поток.

Преобразует эту последовательность в строку.

Преобразует это итерируемое множество в неуказанное итерируемое множество. Вернёт то же самое множество, если этот экземпляр уже итерируемое.

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

Преобразует это итерируемое множество или итератор в вектор.

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

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

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

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

Создаёт новую последовательность, которая содержит все элементы этой последовательности и также все элементы заданной последовательности. xs union ys эквивалентно xs ++ ys.

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

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

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

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

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

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

A copy of this sequence with one single replaced element.

Creates a non-strict view of a slice of this sequence.

Note: the difference between view and slice is that view produces a view of the current sequence, whereas slice produces a new sequence.

Note: view(from, to) is equivalent to view.slice(from, to)

Creates a non-strict view of this sequence.

Creates a non-strict filter of this collection.

Note: the difference between c filter p and c withFilter p is that the former creates a new collection, whereas the latter only restricts the domain of subsequent map, flatMap, foreach, and withFilter operations.

Note: might return different results for different runs, unless the underlying collection type is ordered.

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

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

Объединяет эту последовательность с ее индексами.