Трейт scala.collection.parallel.immutable.ParSet

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

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

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

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

Разность данного набора и другого набора.

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

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

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

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

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

Примечание: Это операция содержит неконтролируемое приведение типов: если 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)

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

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

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

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

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

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

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

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

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

Выбирает первые 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.