Класс scala.collection.parallel.ParMapLike.DefaultValuesIterable

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

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

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

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

Примечание: /: — это альтернативная синтаксическая конструкция для 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(_), _ ++ _)

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

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

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

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

Значение метода clone зависит от платформы.

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

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

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

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

Копирует элементы этого параллельного итератора в массив. Заполняет данный массив 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).

Метод равенства для ссылочных типов. Реализация по умолчанию делегирует вызов к eq.

Смотрите также equals в scala.Any.

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

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

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

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

Определяет префикс представления этого объекта в виде 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 это конкатенация имени класса, "@" и хэш-кода объекта в шестнадцатеричном формате.

Преобразует это параллельное итерируемое множество в неопределённое множество 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))

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

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

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

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

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

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