Scala Standard Library 2.12.18 - scala.collection.parallel.immutable.ParHashSet (original) (raw)

class ParHashSet[T] extends ParSet[T] with GenericParTemplate[T, ParHashSet] with ParSetLike[T, ParHashSet[T], HashSet[T]] with Serializable

 

Ordering

1. Alphabetic
2. By Inheritance

Inherited

1. ParHashSet
2. Serializable
3. Serializable
4. ParSet
5. ParIterable
6. Immutable
7. ParSet
8. ParSetLike
9. ParIterable
10. ParIterableLike
11. Parallel
12. CustomParallelizable
13. GenericParTemplate
14. HasNewCombiner
15. GenSet
16. GenericSetTemplate
17. GenIterable
18. GenTraversable
19. GenericTraversableTemplate
20. HasNewBuilder
21. GenSetLike
22. Equals
23. Function1
24. GenIterableLike
25. GenTraversableLike
26. Parallelizable
27. GenTraversableOnce
28. AnyRef
29. Any

Implicitly

1. by CollectionsHaveToParArray

2. by any2stringadd

3. by StringFormat

4. by Ensuring

5. by ArrowAssoc

6. Hide All

7. Show All

Instance Constructors

1.  new ParHashSet()

Type Members

1.  trait Accessor[R, Tp] extends StrictSplitterCheckTask[R, Tp]
2.  class Aggregate[S] extends Accessor[S, Aggregate[S]]
3.  trait BuilderOps[Elem, To] extends AnyRef
4.  class Collect[S, That] extends Transformer[Combiner[S, That], Collect[S, That]]
5.  abstract class Composite[FR, SR, R, First <: StrictSplitterCheckTask[FR, _], Second <: StrictSplitterCheckTask[SR, _]] extends NonDivisibleTask[R, Composite[FR, SR, R, First, Second]]
6.  class Copy[U >: T, That] extends Transformer[Combiner[U, That], Copy[U, That]]
7.  class CopyToArray[U >: T, This >: Repr] extends Accessor[Unit, CopyToArray[U, This]]
8.  class Count extends Accessor[Int, Count]
9.  class CreateScanTree[U >: T] extends Transformer[ScanTree[U], CreateScanTree[U]]
10.  class Drop[U >: T, This >: Repr] extends Transformer[Combiner[U, This], Drop[U, This]]
11.  class Exists extends Accessor[Boolean, Exists]
12.  class Filter[U >: T, This >: Repr] extends Transformer[Combiner[U, This], Filter[U, This]]
13.  class FilterNot[U >: T, This >: Repr] extends Transformer[Combiner[U, This], FilterNot[U, This]]
14.  class Find[U >: T] extends Accessor[Option[U], Find[U]]
15.  class FlatMap[S, That] extends Transformer[Combiner[S, That], FlatMap[S, That]]
16.  class Fold[U >: T] extends Accessor[U, Fold[U]]
17.  class Forall extends Accessor[Boolean, Forall]
18.  class Foreach[S] extends Accessor[Unit, Foreach[S]]
19.  class FromScanTree[U >: T, That] extends StrictSplitterCheckTask[Combiner[U, That], FromScanTree[U, That]]
20.  class GroupBy[K, U >: T] extends Transformer[HashMapCombiner[K, U], GroupBy[K, U]]
21.  class Map[S, That] extends Transformer[Combiner[S, That], Map[S, That]]
22.  class Max[U >: T] extends Accessor[Option[U], Max[U]]
23.  class Min[U >: T] extends Accessor[Option[U], Min[U]]
24.  trait NonDivisible[R] extends NonDivisibleTask[R, NonDivisible[R]]
25.  trait NonDivisibleTask[R, Tp] extends StrictSplitterCheckTask[R, Tp]
26.  abstract class ParComposite[FR, SR, R, First <: StrictSplitterCheckTask[FR, _], Second <: StrictSplitterCheckTask[SR, _]] extends Composite[FR, SR, R, First, Second]
27.  class Partition[U >: T, This >: Repr] extends Transformer[(Combiner[U, This], Combiner[U, This]), Partition[U, This]]
28.  class Product[U >: T] extends Accessor[U, Product[U]]
29.  class Reduce[U >: T] extends Accessor[Option[U], Reduce[U]]
30.  abstract class ResultMapping[R, Tp, R1] extends NonDivisibleTask[R1, ResultMapping[R, Tp, R1]]
31.  case class 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
32.  case class ScanNode[U >: T](left: ScanTree[U], right: ScanTree[U]) extends ScanTree[U] with scala.Product with Serializable
33.  trait ScanTree[U >: T] extends AnyRef
34.  abstract class SeqComposite[FR, SR, R, First <: StrictSplitterCheckTask[FR, _], Second <: StrictSplitterCheckTask[SR, _]] extends Composite[FR, SR, R, First, Second]
35.  trait SignallingOps[PI <: DelegatedSignalling] extends AnyRef
36.  class Slice[U >: T, This >: Repr] extends Transformer[Combiner[U, This], Slice[U, This]]
37.  class Span[U >: T, This >: Repr] extends Transformer[(Combiner[U, This], Combiner[U, This]), Span[U, This]]
38.  class SplitAt[U >: T, This >: Repr] extends Transformer[(Combiner[U, This], Combiner[U, This]), SplitAt[U, This]]
39.  trait StrictSplitterCheckTask[R, Tp] extends Task[R, Tp]
40.  class Sum[U >: T] extends Accessor[U, Sum[U]]
41.  class Take[U >: T, This >: Repr] extends Transformer[Combiner[U, This], Take[U, This]]
42.  class TakeWhile[U >: T, This >: Repr] extends Transformer[(Combiner[U, This], Boolean), TakeWhile[U, This]]
43.  trait TaskOps[R, Tp] extends AnyRef
44.  class ToParCollection[U >: T, That] extends Transformer[Combiner[U, That], ToParCollection[U, That]]
45.  class ToParMap[K, V, That] extends Transformer[Combiner[(K, V), That], ToParMap[K, V, That]]
46.  trait Transformer[R, Tp] extends Accessor[R, Tp]
47.  class Zip[U >: T, S, That] extends Transformer[Combiner[(U, S), That], Zip[U, S, That]]
48.  class ZipAll[U >: T, S, That] extends Transformer[Combiner[(U, S), That], ZipAll[U, S, That]]
49.  class ParHashSetIterator extends IterableSplitter[T]
50.  type SSCTask[R, Tp] = StrictSplitterCheckTask[R, Tp]

Value Members

1.  final def !=(arg0: Any): Boolean
2.  final def ##(): Int
3.  def &(that: GenSet[T]): ParHashSet[T]
4.  def &~(that: GenSet[T]): ParHashSet[T]
5.  def +(e: T): ParHashSet[T]
6.  def ++[U >: T, That](that: GenTraversableOnce[U])(implicit bf: CanBuildFrom[ParHashSet[T], U, That]): That
7.  def -(e: T): ParHashSet[T]
8.  def ->[B](y: B): (ParHashSet[T], B)
9.  final def ==(arg0: Any): Boolean
10.  def aggregate[S](z: ⇒ S)(seqop: (S, T) ⇒ S, combop: (S, S) ⇒ S): S
11.  def andThen[A](g: (Boolean) ⇒ A): (T) ⇒ A
12.  def apply(elem: T): Boolean
13.  final def asInstanceOf[T0]: T0
14.  def bf2seq[S, That](bf: CanBuildFrom[ParHashSet[T], S, That]): CanBuildFrom[HashSet[T], S, That]
15.  implicit def builder2ops[Elem, To](cb: Builder[Elem, To]): BuilderOps[Elem, To]
16.  def canEqual(other: Any): Boolean
17.  def clone(): AnyRef
18.  def collect[B](pf: PartialFunction[A, B]): ParHashSet[B]
19.  def combinerFactory[S, That](cbf: () ⇒ Combiner[S, That]): CombinerFactory[S, That]
20.  def combinerFactory: CombinerFactory[T, ParHashSet[T]]
21.  def companion: GenericCompanion[ParHashSet] with GenericParCompanion[ParHashSet]
22.  def compose[A](g: (A) ⇒ T): (A) ⇒ Boolean
23.  def contains(e: T): Boolean
24.  def copyToArray(xs: Array[A], start: Int, len: Int): Unit
25.  def copyToArray(xs: Array[A], start: Int): Unit
26.  def copyToArray(xs: Array[A]): Unit
27.  def count(p: (T) ⇒ Boolean): Int
28.  def debugBuffer: ArrayBuffer[String]
29.  implicit def delegatedSignalling2ops[PI <: DelegatedSignalling](it: PI): SignallingOps[PI]
30.  def diff(that: GenSet[T]): ParHashSet[T]
31.  def drop(n: Int): ParHashSet[T]
32.  def dropWhile(pred: (T) ⇒ Boolean): ParHashSet[T]
33.  def empty: ParHashSet[T]
34.  def ensuring(cond: (ParHashSet[T]) ⇒ Boolean, msg: ⇒ Any): ParHashSet[T]
35.  def ensuring(cond: (ParHashSet[T]) ⇒ Boolean): ParHashSet[T]
36.  def ensuring(cond: Boolean, msg: ⇒ Any): ParHashSet[T]
37.  def ensuring(cond: Boolean): ParHashSet[T]
38.  final def eq(arg0: AnyRef): Boolean
39.  def equals(that: Any): Boolean
40.  def exists(p: (T) ⇒ Boolean): Boolean
41.  def filter(pred: (T) ⇒ Boolean): ParHashSet[T]
42.  def filterNot(pred: (T) ⇒ Boolean): ParHashSet[T]
43.  def finalize(): Unit
44.  def find(p: (T) ⇒ Boolean): Option[T]
45.  def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): ParHashSet[B]
46.  def flatten[B]: ParHashSet[B]
47.  def fold[U >: T](z: U)(op: (U, U) ⇒ U): U
48.  def foldLeft[S](z: S)(op: (S, T) ⇒ S): S
49.  def foldRight[S](z: S)(op: (T, S) ⇒ S): S
50.  def forall(p: (T) ⇒ Boolean): Boolean
51.  def foreach[U](f: (T) ⇒ U): Unit
52.  def genericBuilder[B]: Combiner[B, ParHashSet[B]]
53.  def genericCombiner[B]: Combiner[B, ParHashSet[B]]
54.  final def getClass(): Class[_]
55.  def groupBy[K](f: (T) ⇒ K): ParMap[K, ParHashSet[T]]
56.  def hasDefiniteSize: Boolean
57.  def hashCode(): Int
58.  def head: T
59.  def headOption: Option[T]
60.  def init: ParHashSet[T]
61.  def initTaskSupport(): Unit
62.  def intersect(that: GenSet[T]): ParHashSet[T]
63.  def isEmpty: Boolean
64.  final def isInstanceOf[T0]: Boolean
65.  def isStrictSplitterCollection: Boolean
66.  final def isTraversableAgain: Boolean
67.  def iterator: Splitter[T]
68.  def last: T
69.  def lastOption: Option[T]
70.  def map[B](f: (A) ⇒ B): ParHashSet[B]
71.  def max: A
72.  def maxBy[B](f: (A) ⇒ B): A
73.  def min: A
74.  def minBy[B](f: (A) ⇒ B): A
75.  def mkString: String
76.  def mkString(sep: String): String
77.  def mkString(start: String, sep: String, end: String): String
78.  final def ne(arg0: AnyRef): Boolean
79.  def newBuilder: Builder[T, ParHashSet[T]]
80.  def newCombiner: Combiner[T, ParHashSet[T]]
81.  def nonEmpty: Boolean
82.  final def notify(): Unit
83.  final def notifyAll(): Unit
84.  def par: ParHashSet[T]
85.  def parCombiner: Combiner[T, ParHashSet[T]]
86.  def partition(pred: (T) ⇒ Boolean): (ParHashSet[T], ParHashSet[T])
87.  def product: A
88.  def reduce[U >: T](op: (U, U) ⇒ U): U
89.  def reduceLeft[U >: T](op: (U, T) ⇒ U): U
90.  def reduceLeftOption[U >: T](op: (U, T) ⇒ U): Option[U]
91.  def reduceOption[U >: T](op: (U, U) ⇒ U): Option[U]
92.  def reduceRight[U >: T](op: (T, U) ⇒ U): U
93.  def reduceRightOption[U >: T](op: (T, U) ⇒ U): Option[U]
94.  def repr: ParHashSet[T]
95.  def reuse[S, That](oldc: Option[Combiner[S, That]], newc: Combiner[S, That]): Combiner[S, That]
96.  def sameElements(that: GenIterable[A]): Boolean
97.  def scan(z: T)(op: (T, T) ⇒ T): ParHashSet[T]
98.  def scanBlockSize: Int
99.  def scanLeft[S, That](z: S)(op: (S, T) ⇒ S)(implicit bf: CanBuildFrom[ParHashSet[T], S, That]): That
100.  def scanRight[S, That](z: S)(op: (T, S) ⇒ S)(implicit bf: CanBuildFrom[ParHashSet[T], S, That]): That
101.  def seq: HashSet[T]
102.  def sequentially[S, That <: Parallel](b: (HashSet[T]) ⇒ Parallelizable[S, That]): ParHashSet[T]
103.  def size: Int
104.  def sizeHintIfCheap: Int
105.  def slice(unc_from: Int, unc_until: Int): ParHashSet[T]
106.  def span(pred: (T) ⇒ Boolean): (ParHashSet[T], ParHashSet[T])
107.  def splitAt(n: Int): (ParHashSet[T], ParHashSet[T])
108.  def splitter: IterableSplitter[T]
109.  def stringPrefix: String
110.  def subsetOf(that: GenSet[T]): Boolean
111.  def sum: A
112.  final def synchronized[T0](arg0: ⇒ T0): T0
113.  def tail: ParHashSet[T]
114.  def take(n: Int): ParHashSet[T]
115.  def takeWhile(pred: (T) ⇒ Boolean): ParHashSet[T]
116.  implicit def task2ops[R, Tp](tsk: SSCTask[R, Tp]): TaskOps[R, Tp]
117.  def tasksupport: TaskSupport
118.  def tasksupport_=(ts: TaskSupport): Unit
119.  def to[Col[_]]: Col[A]
120.  def toArray: Array[A]
121.  def toBuffer[U >: T]: Buffer[U]
122.  def toIndexedSeq: immutable.IndexedSeq[T]
123.  def toIterable: ParIterable[T]
124.  def toIterator: scala.Iterator[T]
125.  def toList: List[T]
126.  def toMap[T, U]: collection.Map[T, U]
127.  def toParArray: ParArray[T]
128.  def toParCollection[U >: T, That](cbf: () ⇒ Combiner[U, That]): That
129.  def toParMap[K, V, That](cbf: () ⇒ Combiner[(K, V), That])(implicit ev: <:<[T, (K, V)]): That
130.  def toSeq: ParSeq[T]
131.  def toSet[U >: T]: ParSet[U]
132.  def toStream: Stream[T]
133.  def toString(): String
134.  def toTraversable: GenTraversable[T]
135.  def toVector: Vector[T]
136.  def transpose[B](implicit asTraversable: (T) ⇒ GenTraversableOnce[B]): ParHashSet[ParHashSet[B]]
137.  def union(that: GenSet[T]): ParHashSet[T]
138.  def unzip[A1, A2](implicit asPair: (T) ⇒ (A1, A2)): (ParHashSet[A1], ParHashSet[A2])
139.  def unzip3[A1, A2, A3](implicit asTriple: (T) ⇒ (A1, A2, A3)): (ParHashSet[A1], ParHashSet[A2], ParHashSet[A3])
140.  final def wait(): Unit
141.  final def wait(arg0: Long, arg1: Int): Unit
142.  final def wait(arg0: Long): Unit
143.  def withFilter(pred: (T) ⇒ Boolean): ParHashSet[T]
144.  def wrap[R](body: ⇒ R): NonDivisible[R]
145.  def zip[B](that: GenIterable[B]): ParHashSet[(A, B)]
146.  def zipAll[B](that: Iterable[B], thisElem: A, thatElem: B): ParHashSet[(A, B)]
147.  def zipWithIndex: ParHashSet[(A, Int)]
148.  def |(that: GenSet[T]): ParHashSet[T]
149.  def →[B](y: B): (ParHashSet[T], B)

Deprecated Value Members

1.  def /:[S](z: S)(op: (S, T) ⇒ S): S
2.  def :\[S](z: S)(op: (T, S) ⇒ S): S
3.  def formatted(fmtstr: String): String
4.  def view: IterableView[T, HashSet[T]]

Inherited from Serializable

Inherited from java.io.Serializable

Inherited from ParSet[T]

Inherited from ParIterable[T]

Inherited from Immutable

Inherited from parallel.ParSet[T]

Inherited from ParSetLike[T, ParHashSet[T], HashSet[T]]

Inherited from parallel.ParIterable[T]

Inherited from ParIterableLike[T, ParHashSet[T], HashSet[T]]

Inherited from Parallel

Inherited from CustomParallelizable[T, ParHashSet[T]]

Inherited from GenericParTemplate[T, ParHashSet]

Inherited from HasNewCombiner[T, scala.collection.parallel.immutable.ParHashSet[T] @scala.annotation.unchecked.uncheckedVariance]

Inherited from GenSet[T]

Inherited from GenericSetTemplate[T, GenSet]

Inherited from GenIterable[T]

Inherited from GenTraversable[T]

Inherited from GenericTraversableTemplate[T, ParHashSet]

Inherited from HasNewBuilder[T, scala.collection.parallel.immutable.ParHashSet[T] @scala.annotation.unchecked.uncheckedVariance]

Inherited from GenSetLike[T, ParHashSet[T]]

Inherited from Equals

Inherited from (T) ⇒ Boolean

Inherited from GenIterableLike[T, ParHashSet[T]]

Inherited from GenTraversableLike[T, ParHashSet[T]]

Inherited from Parallelizable[T, ParHashSet[T]]

Inherited from GenTraversableOnce[T]

Inherited from AnyRef

Inherited from Any

Inherited by implicit conversion CollectionsHaveToParArray fromParHashSet[T] to CollectionsHaveToParArray[ParHashSet[T], T]

Inherited by implicit conversion any2stringadd fromParHashSet[T] to any2stringadd[ParHashSet[T]]

Inherited by implicit conversion StringFormat fromParHashSet[T] to StringFormat[ParHashSet[T]]

Inherited by implicit conversion Ensuring fromParHashSet[T] to Ensuring[ParHashSet[T]]

Inherited by implicit conversion ArrowAssoc fromParHashSet[T] to ArrowAssoc[ParHashSet[T]]

Ungrouped