Трейт scala.collection.mutable.IndexedSeqOptimized

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

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

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

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

Отличается от ++ тем, что тип возвращаемой коллекции определяется правым операндом, а не левым. Мемоническая подсказка: символ ДВОЕТОЧИЯ находится рядом с новым типом КОЛЛЕКЦИИ.

Пример:

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 и ниже могут использовать перегруз.

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

Отличается от ++ тем, что тип возвращаемой коллекции определяется правым операндом, а не левым. Мемоническая подсказка: символ ДВОЕТОЧИЯ находится рядом с новым типом КОЛЛЕКЦИИ.

Пример:

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)

A copy of the mutable indexed sequence with an element prepended.

Note that :-ending operators are right associative (see example). A mnemonic for +: vs. :+ is: the COLon goes on the COLlection side.

Also, the original mutable indexed sequence is not modified, so you will want to capture the result.

Example:

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)

Applies a binary operator to a start value and all elements of this traversable or iterator, going left to right.

Note: /: is alternate syntax for foldLeft; z /: xs is the same as xs foldLeft z.

Examples:

Note that the folding function used to compute b is equivalent to that used to compute 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

Note: will not terminate for infinite-sized collections.

Note: might return different results for different runs, unless the underlying collection type is ordered or the operator is associative and commutative.

A copy of this mutable indexed sequence with an element appended.

A mnemonic for +: vs. :+ is: the COLon goes on the COLlection side.

Example:

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)

Applies a binary operator to all elements of this traversable or iterator and a start value, going right to left.

Note: :\ is alternate syntax for foldRight; xs :\ z is the same as xs foldRight z.

Note: will not terminate for infinite-sized collections.

Note: might return different results for different runs, unless the underlying collection type is ordered or the operator is associative and commutative.

Examples:

Note that the folding function used to compute b is equivalent to that used to compute 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

Test two objects for equality. The expression x == that is equivalent to 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

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

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

Это более общий вид 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 })

Преобразует получаемый объект в объект типа T0.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Например:

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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Специфические коллекции (например, ParArray или mutable.ParHashMap) переопределяют это поведение по умолчанию, создавая параллельную коллекцию, которая использует тот же базовый набор данных. Для этих коллекций par занимает постоянное или подлинейное время.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Пример:

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

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

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

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

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

Суммирует элементы этого набора.

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

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

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

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

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

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

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

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

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

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

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

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

Возвращает эту итеративную коллекцию как итеративную коллекцию.

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

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

Возвращает итератор по элементам в этой итеративной коллекции. Даёт тот же результат, что и iterator.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

A sub-sequence view starting at index from and extending up to (but not including) index until.

Creates a view of this iterable @see Iterable.View

Creates a non-strict filter of this traversable 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.

Returns a mutable indexed sequence formed from this mutable indexed sequence and another iterable collection by combining corresponding elements in pairs. If one of the two collections is longer than the other, its remaining elements are ignored.

Returns a mutable indexed sequence formed from this mutable indexed sequence and another iterable collection by combining corresponding elements in pairs. If one of the two collections is shorter than the other, placeholder elements are used to extend the shorter collection to the length of the longer.

Zips this mutable indexed sequence with its indices.