Трейт scala.collection.immutable.SetProxy

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

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

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

Примечание: То же самое, что и intersect.

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

Примечание: То же самое, что и diff.

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

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

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

Пример:

scala> val a = Set(1, 3) + 2 + 3
a: scala.collection.immutable.Set[Int] = Set(1, 3, 2)

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

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

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

Пример:

scala> val a = Set(1, 2) ++ Set(2, "a")
a: scala.collection.immutable.Set[Any] = Set(1, 2, a)

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

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

Пример:

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)

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

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

Этот метод принимает два или более элементов для удаления. Другой перегруженный вариант этого метода обрабатывает случай удаления одного элемента.

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

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

Примечание: /: — это альтернативная запись для 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

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

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

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

Примечание: :\ — это альтернативная запись для 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

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

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

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

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

Приводит объект-приемник к типу T0.

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

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

Создает копию объекта-приемника.

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

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

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

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

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

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

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

Проверяет, содержится ли некоторый элемент в этом множестве.

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

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

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

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

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

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

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

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

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

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

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

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

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

Пустое множество того же типа, что и это множество

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

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

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

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

Сравнивает объект-получатель (this) с объектом-аргументом (that) на эквивалентность.

Любая реализация этого метода должна быть отношением эквивалентности:

Он рефлексивен: для любого экземпляра x типа Any, x.equals(x) должен возвращать true.Он симметричен: для любых экземпляров x и y типа Any, x.equals(y) должен возвращать true тогда и только тогда, когда y.equals(x) возвращает true.Он транзитивен: для любых экземпляров x, y, и z типа Any если x.equals(y) возвращает true и y.equals(z) возвращает true, тогда x.equals(z) должен возвращать true.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Общее реализация newBuilder для всех множеств в терминах empty. Переопределено для изменяемых множеств в `mutable.SetLike`.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Объект представления типа Repr, содержащий элементы коллекции

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

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

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

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

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

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

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

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

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

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

Пример:

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

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

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

Размер этого итерируемого набора.

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

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

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

from <= indexOf(x) < until

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

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

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

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

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

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

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

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

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

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

Итератор по всем подмножествам этого множества.

Итератор по всем подмножествам этого множества заданного размера. Если запрос на размер невозможен, возвращается пустой итератор.

Вычисляет сумму элементов этой коллекции.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Преобразует эту итерируемую коллекцию в итерируемую коллекцию. Обратите внимание, что выбор целевого Iterable ленивый в этой реализации по умолчанию, поскольку этот TraversableOnce может быть ленивым и неоценённым (т.е. это может быть итератор, который можно проходить только один раз).

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

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

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

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

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

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

Преобразует это итерируемое множество в последовательность. Как и toIterable, оно ленивое в этом реализации по умолчанию, так как это TraversableOnce может быть ленивым и невычисленным.

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

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

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

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

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

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

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

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

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

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

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

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

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

Вычисляет объединение множества с другим множеством.

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

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

Создает нестрогую (lazy) «вью» среза этой итерируемой коллекции.

Примечание: разница между view и slice заключается в том, что view создаёт «вью» текущей итерируемой коллекции, а slice — новую итерируемую коллекцию.

Примечание: view(from, to) эквивалентно view.slice(from, to)

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

Создаёт нестрогую (lazy) «вью» всей этой итерируемой коллекции.

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

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

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

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

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

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

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

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

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

Вычисляет объединение этого множества и другого множества.

Примечание: То же, что и union.