Особенность scala.collection.parallel.mutable.ParSet

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

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

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

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

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

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

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

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

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

Удаляет все элементы, сгенерированные итератором, из этого изменяемого множества.

Удаляет два или более элементов из этого изменяемого множества.

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

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

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

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

Например, можно обработать некоторые элементы и затем произвести Set. В этом случае, seqop будет обрабатывать элемент и добавлять его в множество, а combop будет конкатенировать два множества из разных разделов вместе. Начальное значение z будет пустым множеством.

pc.aggregate(Set[Int]())(_ += process(_), _ ++ _)

Другой пример — вычисление геометрического среднего из набора чисел с плавающей точкой (для этого обычно требуются большие числа с плавающей точкой).

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

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

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

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

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

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

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

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

на которых функция определена.

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

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

Фабрика-компаньон, которая создаёт экземпляры класса mutable.ParSet. (или его Iterable суперкласса, где класс mutable.ParSet не является Seq.)

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

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

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

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

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

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

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

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

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

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

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

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

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

Проверяет, является ли аргумент (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).

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

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

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

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

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

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

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

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

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

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

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

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

и используя элементы получившихся коллекций.

Например:

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)

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

Обратите внимание, что у этого метода отличается сигнатура от методов foldLeft и foldRight в трайте Traversable. Результатом свертки может быть только супертип параметра типа этой параллельной коллекции T.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Метод hashCode для ссылочных типов. См. hashCode в scala.Any.

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

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

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

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

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

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

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

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

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

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

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

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

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

Этот метод помогает гарантировать, что такие ошибки возникнут при вызове метода, а не позже и непредсказуемым образом.

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

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

По умолчанию этот метод реализуется с помощью защищённого метода splitter.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Обратите внимание, что у этого метода другая сигнатура, чем у методов reduceLeft и reduceRight в трайте Traversable. Результатом редукции может быть только тип, являющийся супертипом параметра типа T этой параллельной коллекции.

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

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

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

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

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

Обратите внимание, что у этого метода другая сигнатура, чем у методов reduceLeftOption и reduceRightOption в трайте Traversable. Результатом редукции может быть только тип, являющийся супертипом параметра типа T этой параллельной коллекции.

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

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

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

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

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

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

Необязательно повторно использует существующий комбинатор для лучшей производительности. По умолчанию этого не делает — подклассы могут переопределить это поведение. Предоставленный комбинатор oldc который потенциально может быть повторно использован, будет либо некоторым комбинатором из предыдущей вычислительной задачи, или None если фаза отсутствовала (в этом случае этот метод должен вернуть newc).

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

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

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

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

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

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

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

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

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

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

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

Пример:

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

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

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

from <= indexOf(x) < until

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Объект поддержки задач, отвечающий за планирование и балансировку нагрузки задач на процессоры.

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

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

Вот способ изменения поддержки задач параллельной коллекции:

import scala.collection.parallel._
val pc = mutable.ParArray(1, 2, 3)
pc.tasksupport = new ForkJoinTaskSupport(
  new java.util.concurrent.ForkJoinPool(2))

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Создаёт строковое представление этого объекта. По умолчанию представление зависит от платформы. На платформе Java это объединение имени класса, "@" и хэш-кода объекта в шестнадцатеричном формате.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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