Трейт scala.collection.parallel.ParIterableLike

trait ParIterableLike[+T, +Repr <: ParIterable[T], +Sequential <: scala.Iterable[T] with IterableLike[T, Sequential]] extends GenIterableLike[T, Repr] with CustomParallelizable[T, Repr] with Parallel with HasNewCombiner[T, Repr]

Шаблонный трейт для параллельных коллекций типа ParIterable[T].

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

Параллельные операции реализуются с помощью алгоритмов «разделяй и властвуй», которые хорошо параллелизуются. Основная идея заключается в разделении коллекции на более мелкие части до тех пор, пока они не станут достаточно малыми для последовательной обработки.

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

def splitter: IterableSplitter[T]

который возвращает экземпляр IterableSplitter[T], который является подтипом Splitter[T]. Разделители имеют метод remaining для проверки оставшегося числа элементов и метод split, который определяется разделителями. Метод split делит итераторы разделителей на непересекающиеся подмножества:

def split: Seq[Splitter]

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

Задачи планируются для выполнения через объект scala.collection.parallel.TaskSupport, который может быть изменён через tasksupport установщик коллекции.

Метод newCombiner создаёт новый комбинировщик. Комбинировщики являются расширением билдеров. Они предоставляют метод combine, который объединяет два комбинировщика и возвращает комбинировщик, содержащий элементы обоих комбинировщиков. Этот метод может быть реализован путём агрессивного копирования всех элементов в новый комбинировщик или путём ленивого связывания их результатов. Рекомендуется избегать копирования всех элементов по причинам производительности, хотя эта стоимость может быть незначительной в зависимости от конкретного случая. Стандартные параллельные коллекции комбинировщики избегают копирования при объединении результатов, полагаясь либо на двухэтапную ленивую конструкцию, либо на специфические свойства структуры данных.

Методы:

def seq: Sequential
def par: Repr

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

Сочетание методов toMap, toSeq или toSet вместе с par и seq — это гибкий способ переключения между различными типами коллекций.

Поскольку этот трейт расширяет трейт GenIterable, методы, такие как size, также должны быть реализованы в конкретных коллекциях, в то время как iterator по умолчанию перенаправляет на splitter.

Каждая параллельная коллекция связана с определённым пулом fork/join, в котором хранятся бездействующие рабочие потоки. Пул fork/join содержит другую информацию, такую как уровень параллелизма, то есть количество используемых процессоров. Когда коллекция создаётся, ей назначается стандартный пул fork/join, найденный в scala.parallel объекте пакета.

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

Существующие реализации параллельных коллекций предоставляют строгие параллельные итераторы. Строгие параллельные итераторы знают, сколько элементов им ещё нужно пройти. Также возможно предоставить нестрогие параллельные итераторы, которые не знают количество оставшихся элементов. Для этого новая реализация коллекции должна переопределить isStrictSplitterCollection в false. Это сделает некоторые операции недоступными.

Для создания новой параллельной коллекции, расширьте трейт ParIterable, и реализуйте size, splitter, newCombiner и seq. Наличие неявной фабрики комбинировщиков требует расширения этого трейта, а также предоставления компаньон-объекта, как и в обычных коллекциях.

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

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

T: тип элементов коллекции
Repr: тип фактической коллекции, содержащей элементы

Self Type: ParIterableLike[T, Repr, Sequential]
Source: ParIterableLike.scala

Linear Supertypes

Known Subclasses

Члены типов

трайт Accessor[R, Tp] extends StrictSplitterCheckTask[R, Tp]

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

R: тип результата этого метода (R для результата).
Tp: тип представления текущей задачи.

Атрибуты: protected

класс Aggregate[S] extends Accessor[S, Aggregate[S]]

Атрибуты: protected[this]

трайт BuilderOps[Elem, To] extends AnyRef

класс Collect[S, That] extends Transformer[Combiner[S, That], Collect[S, That]]

Атрибуты: protected[this]

абстрактный класс Composite[FR, SR, R, First <: StrictSplitterCheckTask[FR, _], Second <: StrictSplitterCheckTask[SR, _]] extends NonDivisibleTask[R, Composite[FR, SR, R, First, Second]]

Атрибуты: protected[this]

класс Copy[U >: T, That] extends Transformer[Combiner[U, That], Copy[U, That]]

Атрибуты: protected

класс CopyToArray[U >: T, This >: Repr] extends Accessor[Unit, CopyToArray[U, This]]

Атрибуты: protected[this]

класс Count extends Accessor[Int, Count]

Атрибуты: protected[this]

класс CreateScanTree[U >: T] extends Transformer[ScanTree[U], CreateScanTree[U]]

Атрибуты: protected[this]

класс Drop[U >: T, This >: Repr] extends Transformer[Combiner[U, This], Drop[U, This]]

Атрибуты: protected[this]

класс Exists extends Accessor[Boolean, Exists]

Атрибуты: protected[this]

класс Filter[U >: T, This >: Repr] extends Transformer[Combiner[U, This], Filter[U, This]]

Атрибуты: protected[this]

класс FilterNot[U >: T, This >: Repr] extends Transformer[Combiner[U, This], FilterNot[U, This]]

Атрибуты: protected[this]

класс Find[U >: T] extends Accessor[Option[U], Find[U]]

Атрибуты: protected[this]

класс FlatMap[S, That] extends Transformer[Combiner[S, That], FlatMap[S, That]]

Атрибуты: protected[this]

класс Fold[U >: T] extends Accessor[U, Fold[U]]

Атрибуты: protected[this]

класс Forall extends Accessor[Boolean, Forall]

Атрибуты: protected[this]

класс Foreach[S] extends Accessor[Unit, Foreach[S]]

Атрибуты: protected[this]

класс FromScanTree[U >: T, That] extends StrictSplitterCheckTask[Combiner[U, That], FromScanTree[U, That]]

Атрибуты: protected[this]

класс GroupBy[K, U >: T] extends Transformer[HashMapCombiner[K, U], GroupBy[K, U]]

Атрибуты: protected[this]

класс Map[S, That] extends Transformer[Combiner[S, That], Map[S, That]]

Атрибуты: protected[this]

класс Max[U >: T] extends Accessor[Option[U], Max[U]]

Атрибуты: protected[this]

класс Min[U >: T] extends Accessor[Option[U], Min[U]]

Атрибуты: protected[this]

тракт NonDivisible[R] extends NonDivisibleTask[R, NonDivisible[R]]

Атрибуты: protected[this]

тракт NonDivisibleTask[R, Tp] extends StrictSplitterCheckTask[R, Tp]

Атрибуты: protected[this]

абстрактный класс ParComposite[FR, SR, R, First <: StrictSplitterCheckTask[FR, _], Second <: StrictSplitterCheckTask[SR, _]] extends Composite[FR, SR, R, First, Second]

Выполняет две задачи параллельно и ожидает завершения обеих.

Атрибуты: protected[this]

класс Partition[U >: T, This >: Repr] extends Transformer[(Combiner[U, This], Combiner[U, This]), Partition[U, This]]

Атрибуты: protected[this]

класс Product[U >: T] extends Accessor[U, Product[U]]

Атрибуты: protected[this]

класс Reduce[U >: T] extends Accessor[Option[U], Reduce[U]]

Атрибуты: protected[this]

абстрактный класс ResultMapping[R, Tp, R1] extends NonDivisibleTask[R1, ResultMapping[R, Tp, R1]]

Атрибуты: protected[this]

тип SSCTask[R, Tp] = StrictSplitterCheckTask[R, Tp]

служебный класс ScanLeaf[U >: T](pit: IterableSplitter[U], op: (U, U) ⇒ U, from: Int, len: Int, prev: Option[ScanLeaf[U]], acc: U) extends ScanTree[U] with scala.Product with Serializable

Атрибуты: protected[this]

служебный класс ScanNode[U >: T](left: ScanTree[U], right: ScanTree[U]) extends ScanTree[U] with scala.Product with Serializable

Атрибуты: protected[this]

тракт ScanTree[U >: T] extends AnyRef

Атрибуты: protected[this]

абстрактный класс SeqComposite[FR, SR, R, First <: StrictSplitterCheckTask[FR, _], Second <: StrictSplitterCheckTask[SR, _]] extends Composite[FR, SR, R, First, Second]

Последовательно выполняет одну задачу за другой.

Атрибуты: protected[this]

тракт SignallingOps[PI <: DelegatedSignalling] extends AnyRef

класс Slice[U >: T, This >: Repr] extends Transformer[Combiner[U, This], Slice[U, This]]

Атрибуты: protected[this]

класс Span[U >: T, This >: Repr] extends Transformer[(Combiner[U, This], Combiner[U, This]), Span[U, This]]

Атрибуты: protected[this]

класс SplitAt[U >: T, This >: Repr] extends Transformer[(Combiner[U, This], Combiner[U, This]), SplitAt[U, This]]

Атрибуты: protected[this]

тракт StrictSplitterCheckTask[R, Tp] extends Task[R, Tp]

Атрибуты: protected

класс Sum[U >: T] extends Accessor[U, Sum[U]]

Атрибуты: protected[this]

класс Take[U >: T, This >: Repr] extends Transformer[Combiner[U, This], Take[U, This]]

Атрибуты: protected[this]

класс TakeWhile[U >: T, This >: Repr] extends Transformer[(Combiner[U, This], Boolean), TakeWhile[U, This]]

Атрибуты: protected[this]

тракт TaskOps[R, Tp] extends AnyRef

класс ToParCollection[U >: T, That] extends Transformer[Combiner[U, That], ToParCollection[U, That]]

Атрибуты: protected[this]

класс ToParMap[K, V, That] extends Transformer[Combiner[(K, V), That], ToParMap[K, V, That]]

Атрибуты: protected[this]

тракт Transformer[R, Tp] extends Accessor[R, Tp]

Атрибуты: protected

класс Zip[U >: T, S, That] extends Transformer[Combiner[(U, S), That], Zip[U, S, That]]

Атрибуты: protected[this]

класс ZipAll[U >: T, S, That] extends Transformer[Combiner[(U, S), That], ZipAll[U, S, That]]

Атрибуты: protected[this]

Абстрактные члены-значения

абстрактный def newCombiner: Combiner[T, Repr]

Атрибуты: protected[this]
Классы определений: HasNewCombiner

абстрактный def seq: Sequential

Классы определений: ParIterableLike → Parallelizable → GenTraversableOnce

абстрактный def size: Int

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

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

возвращает: количество элементов в этом общем наборе.

Классы определений: GenTraversableLike → GenTraversableOnce

абстрактный def splitter: IterableSplitter[T]

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

возвращает: параллельный итератор

Атрибуты: protected[parallel]

абстрактный def stringPrefix: String

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

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

Классы определений: GenTraversableLike

Члены-значения конкретного типа

final def !=(arg0: Any): Boolean

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

возвращает: true если !(this == that), в противном случае false.

Definition Classes: AnyRef → Any

final def ##(): Int

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

возвращает: значение хэша, согласованное с ==

Definition Classes: AnyRef → Any

def +(other: String): String

Неявный: Этот член добавлен неявным преобразованием из ParIterableLike[T, Repr, Sequential] в any2stringadd[ParIterableLike[T, Repr, Sequential]] выполненным методом any2stringadd в scala.Predef.
Definition Classes: any2stringadd

def ++[U >: T, That](that: GenTraversableOnce[U])(implicit bf: CanBuildFrom[Repr, U, That]): That

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

That: класс возвращаемого набора. В случае возможности That является тем же классом, что и текущий класс коллекции Repr, но это зависит от типа элемента B является допустимым для этого класса, что означает, что найден неявный экземпляр типа CanBuildFrom[Repr, B, That].
that: итерируемое значение для добавления.
bf: неявное значение класса CanBuildFrom, которое определяет класс результата That из текущего типа представления Repr и нового типа элемента B.
возвращает: новый набор типа That, который содержит все элементы этого параллельного итерируемого значения, за которыми следуют все элементы that.

Definition Classes: ParIterableLike → GenTraversableLike

def ->[B](y: B): (ParIterableLike[T, Repr, Sequential], B)

Неявный: Этот член добавлен неявным преобразованием из ParIterableLike[T, Repr, Sequential] в ArrowAssoc[ParIterableLike[T, Repr, Sequential]] выполненным методом ArrowAssoc в scala.Predef.
Definition Classes: ArrowAssoc
Annotations: @inline()

def /:[S](z: S)(op: (S, T) ⇒ S): S

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

Примечание: /: - альтернативный синтаксис для 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

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

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

z

начальное значение.

op

бинарный оператор.

возвращает

результат вставки op между последовательными элементами этого параллельного итерируемого значения слева направо с начальным значением z слева:

op(...op(op(z, x_1), x_2), ..., x_n)

где x₁, ..., x_n - элементы этого параллельного итерируемого значения.

Definition Classes: ParIterableLike → GenTraversableOnce

def :\[S](z: S)(op: (T, S) ⇒ S): S

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

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

z

начальное значение

op

бинарный оператор

возвращает

результат вставки op между последовательными элементами этого параллельного итерируемого объекта, двигаясь справа налево с начальным значением z справа:

op(x_1, op(x_2, ... op(x_n, z)...))

где x₁, ..., x_n — элементы этого параллельного итерируемого объекта.

Классы-определения: ParIterableLike → GenTraversableOnce

final def ==(arg0: Any): Boolean

Выражение x == that эквивалентно if (x eq null) that eq null else x.equals(that).

возвращает: true если объект-получатель эквивалентен аргументу; false в противном случае.

Классы-определения: AnyRef → Any

def aggregate[S](z: ⇒ S)(seqop: (S, T) ⇒ S, combop: (S, S) ⇒ S): S

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

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

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

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

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

S: тип накопленных результатов
z: начальное значение накопленного результата раздела — обычно это нейтральный элемент для оператора seqop (например, Nil для конкатенации списков или 0 для суммирования) и может быть вычислен более одного раза
seqop: оператор, используемый для накопления результатов в пределах раздела
combop: ассоциативный оператор, используемый для объединения результатов из разных разделов

Классы-определения: ParIterableLike → GenTraversableOnce

final def asInstanceOf[T0]: T0

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

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

возвращает: объект-получатель.

Классы-определения: Any
Исключения: ClassCastException, если объект-получатель не является экземпляром стирания типа T0.

def bf2seq[S, That](bf: CanBuildFrom[Repr, S, That]): CanBuildFrom[Sequential, S, That]

Атрибуты: protected[this]

implicit def builder2ops[Elem, To](cb: Builder[Elem, To]): BuilderOps[Elem, To]

Атрибуты: protected

def canEqual(other: Any): Boolean

def clone(): AnyRef

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

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

возвращает: копию объекта-получателя.

Атрибуты: protected[lang]
Классы-определения: AnyRef
Аннотации: @throws( ... ) @native()
Примечание: не определен SLS как член AnyRef

def collect[B](pf: PartialFunction[A, B]): ParIterable[B]

[use case]

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

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

Definition Classes: ParIterableLike → GenTraversableLike

def combinerFactory[S, That](cbf: () ⇒ Combiner[S, That]): CombinerFactory[S, That]

Attributes: protected[this]

def combinerFactory: CombinerFactory[T, Repr]

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

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

Attributes: protected[this]

def copyToArray(xs: Array[A], start: Int, len: Int): Unit

[use case]

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

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

xs: массив для заполнения.
start: начальный индекс.
len: максимальное количество копируемых элементов.

Definition Classes: ParIterableLike → GenTraversableOnce

def copyToArray(xs: Array[A], start: Int): Unit

[use case]

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

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

xs: массив для заполнения.
start: начальный индекс.

Definition Classes: ParIterableLike → GenTraversableOnce

def copyToArray(xs: Array[A]): Unit

[use case]

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

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

xs: массив для заполнения.

Definition Classes: ParIterableLike → GenTraversableOnce

def count(p: (T) ⇒ Boolean): Int

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

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

Definition Classes: ParIterableLike → GenTraversableOnce

def debugBuffer: ArrayBuffer[String]

implicit def delegatedSignalling2ops[PI <: DelegatedSignalling](it: PI): SignallingOps[PI]

Attributes: protected

def drop(n: Int): Repr

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

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

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

Definition Classes: ParIterableLike → GenTraversableLike

def dropWhile(pred: (T) ⇒ Boolean): Repr

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

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

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

Definition Classes: ParIterableLike → GenTraversableLike

def ensuring(cond: (ParIterableLike[T, Repr, Sequential]) ⇒ Boolean, msg: ⇒ Any): ParIterableLike[T, Repr, Sequential]

Неявный: Этот член добавлен неявным преобразованием из ParIterableLike[T, Repr, Sequential] в Ensuring[ParIterableLike[T, Repr, Sequential]] с помощью метода Ensuring в scala.Predef.
Definition Classes: Ensuring

def ensuring(cond: (ParIterableLike[T, Repr, Sequential]) ⇒ Boolean): ParIterableLike[T, Repr, Sequential]

Неявный: Этот член добавлен неявным преобразованием из ParIterableLike[T, Repr, Sequential] в Ensuring[ParIterableLike[T, Repr, Sequential]] с помощью метода Ensuring в scala.Predef.
Definition Classes: Ensuring

def ensuring(cond: Boolean, msg: ⇒ Any): ParIterableLike[T, Repr, Sequential]

Неявный: Этот член добавлен неявным преобразованием из ParIterableLike[T, Repr, Sequential] в Ensuring[ParIterableLike[T, Repr, Sequential]] с помощью метода Ensuring в scala.Predef.
Definition Classes: Ensuring

def ensuring(cond: Boolean): ParIterableLike[T, Repr, Sequential]

Неявный: Этот член добавлен неявным преобразованием из ParIterableLike[T, Repr, Sequential] в Ensuring[ParIterableLike[T, Repr, Sequential]] с помощью метода Ensuring в scala.Predef.
Definition Classes: Ensuring

final def eq(arg0: AnyRef): Boolean

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

Метод eq реализует отношение эквивалентности на не-null экземплярах 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).

returns: true если аргумент является ссылкой на объект-получатель; false в противном случае.

Definition Classes: AnyRef

def equals(arg0: Any): Boolean

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

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

returns: true если объект-получатель эквивалентен аргументу; false в противном случае.

Definition Classes: AnyRef → Any

def exists(p: (T) ⇒ Boolean): Boolean

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

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

p: предикат для проверки элементов
returns: true, если p выполняется для некоторого элемента, иначе false

Definition Classes: ParIterableLike → GenTraversableOnce

def filter(pred: (T) ⇒ Boolean): Repr

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

pred: предикат для проверки элементов.
returns: новый параллельный итерируемый объект, состоящий из всех элементов этого параллельного итерируемого объекта, которые удовлетворяют данному предикату p. Их порядок может не сохраняться.

Definition Classes: ParIterableLike → GenTraversableLike

def filterNot(pred: (T) ⇒ Boolean): Repr

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

pred: предикат для проверки элементов.
returns: новый параллельный итерируемый объект, состоящий из всех элементов этого параллельного итерируемого объекта, которые не удовлетворяют данному предикату p. Их порядок может не сохраняться.

Definition Classes: ParIterableLike → GenTraversableLike

def finalize(): Unit

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

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

Attributes: protected[lang]
Definition Classes: AnyRef
Annotations: @throws( classOf[java.lang.Throwable] )
Note: не указано SLS в качестве члена AnyRef

def find(p: (T) ⇒ Boolean): Option[T]

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

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

p: предикат для проверки элементов
returns: объект типа Option с элементом, если такой элемент существует, или None в противном случае

Definition Classes: ParIterableLike → GenTraversableOnce

def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): ParIterable[B]

[use case]

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

Например:

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)

B: тип элементов возвращаемой коллекции.
f: функция, применяемая к каждому элементу.
returns: новый параллельный итерируемый объект, полученный путем применения заданной функции, принимающей коллекцию f к каждому элементу этого параллельного итерируемого объекта и конкатенации результатов.

Definition Classes: ParIterableLike → GenTraversableLike

def fold[U >: T](z: U)(op: (U, U) ⇒ U): U

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

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

U: параметр типа для бинарного оператора, надтип T.
z: нейтральный элемент для операции свёртки, его можно добавлять к результату произвольное количество раз, не изменяя результат (например, Nil для конкатенации списков, 0 для сложения или 1 для умножения)
op: бинарный оператор, который должен быть ассоциативным
returns: результат применения оператора свёртки op между всеми элементами и z

Definition Classes: ParIterableLike → GenTraversableOnce

def foldLeft[S](z: S)(op: (S, T) ⇒ S): S

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

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

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

z

начальное значение.

op

бинарный оператор.

returns

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

op(...op(z, x_1), x_2, ..., x_n)

где x₁, ..., x_n — элементы этого параллельного итерируемого объекта. Возвращает z , если этот параллельный итерируемый объект пуст.

Definition Classes: ParIterableLike → GenTraversableOnce

def foldRight[S](z: S)(op: (T, S) ⇒ S): S

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

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

z

начальное значение.

op

бинарный оператор.

returns

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

op(x_1, op(x_2, ... op(x_n, z)...))

Definition Classes: ParIterableLike → GenTraversableOnce

def forall(p: (T) ⇒ Boolean): Boolean

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

p: предикат, используемый для проверки элементов
returns: true, если p выполняется для всех элементов, иначе false

Definition Classes: ParIterableLike → GenTraversableOnce

def foreach[U](f: (T) ⇒ U): Unit

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

U: тип результата функции, применяемой к каждому элементу, который всегда отбрасывается
f: функция, применяемая к каждому элементу

Definition Classes: ParIterableLike → GenTraversableLike → GenTraversableOnce

def formatted(fmtstr: String): String

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

Implicit: Этот член добавлен неявным преобразованием из ParIterableLike[T, Repr, Sequential] в StringFormat[ParIterableLike[T, Repr, Sequential]] , выполненное методом StringFormat в scala.Predef.
Definition Classes: StringFormat
Annotations: @inline()

final def getClass(): Class[_]

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

returns: объект класса, соответствующий типу получателя во время выполнения.

Definition Classes: AnyRef → Any
Annotations: @native()

def groupBy[K](f: (T) ⇒ K): immutable.ParMap[K, Repr]

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

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

K

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

f

функция дискриминатора.

returns

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

(xs groupBy f)(k) = xs filter (x => f(x) == k)

То есть, каждый ключ k связан с параллельным итерируемым объектом тех элементов x, для которых f(x) равно k.

Definition Classes: ParIterableLike → GenTraversableLike

def hasDefiniteSize: Boolean

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

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

returns: true , если известно, что у этой коллекции конечный размер, false в противном случае.

Definition Classes: ParIterableLike → GenTraversableOnce

def hashCode(): Int

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

returns: значение хэш-кода для этого объекта.

Definition Classes: AnyRef → Any
Annotations: @native()

def head: T

Выбирает первый элемент этого параллельного итерируемого объекта.

returns: первый элемент этого параллельного итерируемого объекта.

Definition Classes: ParIterableLike → GenTraversableLike
Exceptions thrown: NoSuchElementException, если параллельный итерируемый объект пуст.

def headOption: Option[T]

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

returns: первый элемент этого параллельного итерируемого объекта, если он непустой, None если он пустой.

Definition Classes: ParIterableLike → GenTraversableLike

def init: Repr

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

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

Definition Classes: ParIterableLike → GenTraversableLike
Exceptions thrown: UnsupportedOperationException, если параллельный итерируемый объект пуст.

def initTaskSupport(): Unit

Attributes: protected

def isEmpty: Boolean

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

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

returns: true , если параллельный итерируемый объект не содержит элементов, false в противном случае.

Definition Classes: ParIterableLike → GenTraversableOnce

final def isInstanceOf[T0]: Boolean

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

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

returns: true , если объект получателя является экземпляром стирания типа T0, false в противном случае.

Definition Classes: Any

def isStrictSplitterCollection: Boolean

Указывает, имеет ли данное параллельное множество жёсткие разделители.

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

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

final def isTraversableAgain: Boolean

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

returns: true

Definition Classes: ParIterableLike → GenTraversableLike → GenTraversableOnce

def iterator: Splitter[T]

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

По умолчанию этот метод реализован через защищённый метод splitter.

returns: итератор разбиений

Definition Classes: ParIterableLike → GenIterableLike

def last: T

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

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

returns: Последний элемент этого параллельного итерируемого множества.

Definition Classes: ParIterableLike → GenTraversableLike
Exceptions thrown: NoSuchElementException Если параллельное итерируемое множество пустое.

def lastOption: Option[T]

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

returns: последний элемент этого параллельного итерируемого множества, если оно непустое, None если оно пустое.

Definition Classes: ParIterableLike → GenTraversableLike

def map[B](f: (A) ⇒ B): ParIterable[B]

[use case]

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

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

Definition Classes: ParIterableLike → GenTraversableLike

def max: A

[use case]

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

returns: наибольший элемент этого параллельного итерируемого множества.

Definition Classes: ParIterableLike → GenTraversableOnce
Exceptions thrown: UnsupportedOperationException если это параллельное итерируемое множество пустое.

def maxBy[B](f: (A) ⇒ B): A

[use case]

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

B: Тип результата функции f.
f: Функция измерения.
returns: первый элемент этого параллельного итерируемого множества с наибольшим значением, измеренным функцией f.

Definition Classes: ParIterableLike → GenTraversableOnce
Exceptions thrown: UnsupportedOperationException если это параллельное итерируемое множество пустое.

def min: A

[use case]

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

returns: наименьший элемент этого параллельного итерируемого множества

Definition Classes: ParIterableLike → GenTraversableOnce
Exceptions thrown: UnsupportedOperationException если это параллельное итерируемое множество пустое.

def minBy[B](f: (A) ⇒ B): A

[use case]

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

B: Тип результата функции f.
f: Функция измерения.
returns: первый элемент этого параллельного итерируемого с наименьшим значением, измеренным функцией f.

Definition Classes: ParIterableLike → GenTraversableOnce
Исключения: UnsupportedOperationException, если этот параллельный итерируемый пустой.

def mkString: String

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

returns: строковое представление этого параллельного итерируемого. В результирующей строке строковые представления (в отношении метода toString) всех элементов этого параллельного итерируемого следуют друг за другом без разделительной строки.

Definition Classes: ParIterableLike → GenTraversableOnce

def mkString(sep: String): String

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

sep: разделительная строка.
returns: строковое представление этого параллельного итерируемого. В результирующей строке строковые представления (в отношении метода toString) всех элементов этого параллельного итерируемого разделены строкой sep.

Definition Classes: ParIterableLike → GenTraversableOnce

def mkString(start: String, sep: String, end: String): String

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

start: начальная строка.
sep: разделительная строка.
end: конечная строка.
returns: строковое представление этого параллельного итерируемого. Результирующая строка начинается со строки start и заканчивается строкой end. Внутри строковые представления (в отношении метода toString) всех элементов этого параллельного итерируемого разделены строкой sep.

Definition Classes: ParIterableLike → GenTraversableOnce

final def ne(arg0: AnyRef): Boolean

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

returns: true если аргумент не является ссылкой на объект получателя; false в противном случае.

Definition Classes: AnyRef

def nonEmpty: Boolean

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

returns: true если параллельный итерируемый содержит по крайней мере один элемент, false в противном случае.

Definition Classes: ParIterableLike → GenTraversableOnce

final def notify(): Unit

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

Definition Classes: AnyRef
Annotations: @native()
Примечание: не указано SLS как член AnyRef

final def notifyAll(): Unit

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

Definition Classes: AnyRef
Annotations: @native()
Примечание: не указано SLS как член AnyRef

def par: Repr

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

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

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

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

returns: параллельная реализация этого набора

Definition Classes: ParIterableLike → CustomParallelizable → Parallelizable

def parCombiner: Combiner[T, Repr]

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

returns: комбинирующее устройство для параллельной коллекции типа ParRepr

Attributes: protected[this]
Definition Classes: CustomParallelizable → Parallelizable

def partition(pred: (T) ⇒ Boolean): (Repr, Repr)

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

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

Definition Classes: ParIterableLike → GenTraversableLike

def product: A

[use case]

Произведение элементов этого набора.

returns: произведение всех элементов в этом параллельном итерируемом наборе чисел типа Int. Вместо Int, может использоваться любой другой тип T с неявным Numeric[T] реализацией, который может быть использован в качестве типа элемента параллельного итерируемого набора и как тип возвращаемого значения product. Примеры таких типов: Long, Float, Double, BigInt.

Definition Classes: ParIterableLike → GenTraversableOnce

def reduce[U >: T](op: (U, U) ⇒ U): U

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

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

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

U: Параметр типа для бинарного оператора, надтип T.
op: Бинарный оператор, который должен быть ассоциативным.
returns: Результат применения оператора reduce op между всеми элементами, если коллекция не пуста.

Definition Classes: ParIterableLike → GenTraversableOnce
Исключения: UnsupportedOperationException, если эта параллельная итерируемая последовательность пуста.

def reduceLeft[U >: T](op: (U, T) ⇒ U): U

def reduceLeftOption[U >: T](op: (U, T) ⇒ U): Option[U]

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

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

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

op: бинарный оператор.
returns: значение Option, содержащее результат reduceLeft(op), если эта параллельная итерируемая последовательность не пустая, None в противном случае.

Definition Classes: ParIterableLike → GenTraversableOnce

def reduceOption[U >: T](op: (U, U) ⇒ U): Option[U]

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

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

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

U: Параметр типа для бинарного оператора, надтип T.
op: Бинарный оператор, который должен быть ассоциативным.
returns: Значение Option, содержащее результат применения оператора reduce op между всеми элементами, если коллекция не пуста, и None в противном случае.

Definition Classes: ParIterableLike → GenTraversableOnce

def reduceRight[U >: T](op: (T, U) ⇒ U): U

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

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

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

op

бинарный оператор.

returns

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

op(x_1, op(x_2, ..., op(x_{n-1}, x_n)...))

где x₁, ..., x_n — элементы этого параллельного итерируемого объекта.

Definition Classes: ParIterableLike → GenTraversableOnce
Exceptions thrown: UnsupportedOperationException, если этот параллельный итерируемый объект пустой.

def reduceRightOption[U >: T](op: (T, U) ⇒ U): Option[U]

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

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

op: бинарный оператор.
returns: объект Option, содержащий результат применения оператора reduceRight(op), если этот параллельный итерируемый объект не пустой, None в противном случае.

Definition Classes: ParIterableLike → GenTraversableOnce

def repr: Repr

Definition Classes: ParIterableLike → GenTraversableLike

def reuse[S, That](oldc: Option[Combiner[S, That]], newc: Combiner[S, That]): Combiner[S, That]

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

oldc: Комбинатор, являющийся результатом предыдущей задачи, или None, если предыдущей задачи не было.
newc: Новый, пустой комбинатор, который может быть использован.
returns: Либо newc, либо oldc.

Attributes: protected

def sameElements(that: GenIterable[A]): Boolean

[use case]

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

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

that: коллекция для сравнения.
returns: true, если обе коллекции содержат те же элементы в том же порядке, false в противном случае.

Definition Classes: ParIterableLike → GenIterableLike

def scan(z: T)(op: (T, T) ⇒ T): ParIterable[T]

[use case]

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

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

z: нейтральный элемент для оператора op
op: ассоциативный оператор для сканирования
returns: новый параллельный итерируемый объект, содержащий префиксную сумму элементов в этом параллельном итерируемом объекте

Definition Classes: ParIterableLike → GenTraversableLike

def scanBlockSize: Int

Attributes: protected[this]

def scanLeft[S, That](z: S)(op: (S, T) ⇒ S)(implicit bf: CanBuildFrom[Repr, S, That]): That

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

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

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

That: фактический тип результирующей коллекции
z: начальное значение
op: бинарный оператор, применяемый к промежуточному результату и элементу
bf: явное значение класса CanBuildFrom, определяющее класс результата That из текущего типа представления Repr и нового типа элемента B.
возвращает: коллекцию с промежуточными результатами

Definition Classes: ParIterableLike → GenTraversableLike

def scanRight[S, That](z: S)(op: (T, S) ⇒ S)(implicit bf: CanBuildFrom[Repr, S, That]): That

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

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

Пример:

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

That: фактический тип результирующей коллекции
z: начальное значение
op: бинарный оператор, применяемый к промежуточному результату и элементу
bf: явное значение класса CanBuildFrom, определяющее класс результата That из текущего типа представления Repr и нового типа элемента B.
возвращает: коллекцию с промежуточными результатами

Definition Classes: ParIterableLike → GenTraversableLike

def sequentially[S, That <: Parallel](b: (Sequential) ⇒ Parallelizable[S, That]): Repr

Attributes: protected[this]

def sizeHintIfCheap: Int

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

возвращает: количество элементов в этой коллекции или итераторе, или -1, если размер не может быть определён с малой затратой

Attributes: protected[collection]
Definition Classes: GenTraversableOnce

def slice(unc_from: Int, unc_until: Int): Repr

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

from <= indexOf(x) < until

unc_from: наименьший индекс для включения из этой параллельной итерируемой коллекции.
unc_until: наименьший индекс для исключения из этой параллельной итерируемой коллекции.
возвращает: параллельную итерируемую коллекцию, содержащую элементы, большие или равные индексу from, простирающуюся до (но не включая) индекса until этой параллельной итерируемой коллекции.

Definition Classes: ParIterableLike → GenTraversableLike

def span(pred: (T) ⇒ Boolean): (Repr, Repr)

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

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

pred: предикат, используемый для проверки элементов
возвращает: пару, состоящую из самого длинного префикса коллекции, для которого все элементы удовлетворяют pred, и остальной частью коллекции

Definition Classes: ParIterableLike → GenTraversableLike

def splitAt(n: Int): (Repr, Repr)

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

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

Definition Classes: ParIterableLike → GenTraversableLike

def sum: A

[случай использования]

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

возвращает: сумму всех элементов в этом параллельном итерируемом наборе чисел типа Int. Вместо Int, может использоваться любой другой тип T с неявной Numeric[T] реализацией в качестве типа элементов параллельного итерируемого набора и как типа результата sum. Примеры таких типов: Long, Float, Double, BigInt.

Классы-определения: ParIterableLike → GenTraversableOnce

final def synchronized[T0](arg0: ⇒ T0): T0

Классы-определения: AnyRef

def tail: Repr

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

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

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

Классы-определения: ParIterableLike → GenTraversableLike
Исключения: UnsupportedOperationException, если параллельный итерируемый набор пуст.

def take(n: Int): Repr

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

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

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

Классы-определения: ParIterableLike → GenTraversableLike

def takeWhile(pred: (T) ⇒ Boolean): Repr

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

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

pred: предикат для проверки элементов
возвращает: самое длинное префиксное подмножество элементов из этого параллельного итерируемого набора, которое удовлетворяет предикату pred

Классы-определения: ParIterableLike → GenTraversableLike

implicit def task2ops[R, Tp](tsk: SSCTask[R, Tp]): TaskOps[R, Tp]

Атрибуты: protected

def tasksupport: TaskSupport

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

См. также: scala.collection.parallel.TaskSupport

def tasksupport_=(ts: TaskSupport): Unit

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

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

Вот как изменить поддержку задач параллельного набора:

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

См. также: scala.collection.parallel.TaskSupport

def to[Col[_]]: Col[A]

[случай использования]

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

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

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

Классы-определения: ParIterableLike → GenTraversableOnce

def toArray: Array[A]

[случай использования]

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

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

возвращает: массив, содержащий все элементы этого параллельного итерируемого набора. Должен быть доступен ClassTag для типа элементов этого параллельного итерируемого набора.

Классы-определения: ParIterableLike → GenTraversableOnce

def toBuffer[U >: T]: Buffer[U]

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

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

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

Определяющие классы: ParIterableLike → GenTraversableOnce

def toIndexedSeq: immutable.IndexedSeq[T]

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

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

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

Определяющие классы: ParIterableLike → GenTraversableOnce

def toIterable: ParIterable[T]

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

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

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

Определяющие классы: ParIterableLike → GenTraversableOnce

def toIterator: scala.Iterator[T]

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

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

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

Определяющие классы: ParIterableLike → GenTraversableOnce

def toList: List[T]

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

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

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

Определяющие классы: ParIterableLike → GenTraversableOnce

def toMap[T, U]: collection.Map[T, U]

[use case]

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

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

возвращает: карта типа immutable.Map[T, U] содержащая все пары ключ/значение типа (T, U) этого параллельного итерируемого объекта.

Определяющие классы: ParIterableLike → GenTraversableOnce

def toParArray: ParArray[T]

Неявный: Этот член добавляется неявным преобразованием из ParIterableLike[T, Repr, Sequential] в CollectionsHaveToParArray[ParIterableLike[T, Repr, Sequential], T] с помощью метода CollectionsHaveToParArray в scala.collection.parallel. Это преобразование будет выполняться только в том случае, если неявное значение типа (ParIterableLike[T, Repr, Sequential]) ⇒ GenTraversableOnce[T] находится в области видимости.
Определяющие классы: CollectionsHaveToParArray

def toParCollection[U >: T, That](cbf: () ⇒ Combiner[U, That]): That

Атрибуты: защищенный

def toParMap[K, V, That](cbf: () ⇒ Combiner[(K, V), That])(implicit ev: <:<[T, (K, V)]): That

Атрибуты: защищенный

def toSeq: ParSeq[T]

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

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

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

Определяющие классы: ParIterableLike → GenTraversableOnce

def toSet[U >: T]: immutable.ParSet[U]

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

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

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

Определяющие классы: ParIterableLike → GenTraversableOnce

def toStream: Stream[T]

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

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

Определяющие классы: ParIterableLike → GenTraversableOnce

def toString(): String

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

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

Определяющие классы: ParIterableLike → AnyRef → Any

def toTraversable: GenTraversable[T]

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

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

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

Определяющие классы: ParIterableLike → GenTraversableOnce

def toVector: Vector[T]

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

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

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

Определяющие классы: ParIterableLike → GenTraversableOnce

final def wait(): Unit

Определяющие классы: AnyRef
Аннотации: @throws( ... )

final def wait(arg0: Long, arg1: Int): Unit

Определяющие классы: AnyRef
Аннотации: @throws( ... )

final def wait(arg0: Long): Unit

Определяющие классы: AnyRef
Аннотации: @throws( ... ) @native()

def withFilter(pred: (T) ⇒ Boolean): Repr

def wrap[R](body: ⇒ R): NonDivisible[R]

Атрибуты: protected

def zip[B](that: GenIterable[B]): ParIterable[(A, B)]

[use case]

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

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

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

Определяющие классы: ParIterableLike → GenIterableLike

def zipAll[B](that: Iterable[B], thisElem: A, thatElem: B): ParIterable[(A, B)]

[use case]

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

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

B: тип второй половины возвращаемых пар
that: Множество, предоставляющее вторую половину каждой пары результатов
thisElem: элемент, используемый для заполнения результата, если это параллельное множество короче that.
thatElem: элемент, используемый для заполнения результата, если that короче, чем это параллельное множество.
returns: новое параллельное множество, содержащее пары, состоящие из соответствующих элементов этого параллельного множества и that. Длина возвращаемого множества является максимальной из длин этого параллельного множества и that. Если это параллельное множество короче that, значения thisElem используются для заполнения результата. Если that короче, чем это параллельное множество, значения thatElem используются для заполнения результата.

Definition Classes: ParIterableLike → GenIterableLike

def zipWithIndex: ParIterable[(A, Int)]

[use case]

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

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

returns: Новое параллельное множество, содержащее пары, состоящие из всех элементов этого параллельного множества, соединенных с их индексом. Индексы начинаются с 0.

Definition Classes: ParIterableLike → GenIterableLike

def →[B](y: B): (ParIterableLike[T, Repr, Sequential], B)

Неявный: Этот член добавлен неявным преобразованием из ParIterableLike[T, Repr, Sequential] в ArrowAssoc[ParIterableLike[T, Repr, Sequential]] выполняемое методом ArrowAssoc в scala.Predef.
Definition Classes: ArrowAssoc

© 2002-2019 EPFL, with contributions from Lightbend.
Licensed under the Apache License, Version 2.0.
https://www.scala-lang.org/api/2.12.9/scala/collection/parallel/ParIterableLike.html