A RetroSearch Logo

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Search Query:

Showing content from http://www.scala-lang.org/api/2.12.19/scala/collection/parallel/ParMap.html below:

Scala Standard Library 2.12.19 - scala.collection.parallel.ParMap

trait ParMap[K, +V] extends GenMap[K, V] with GenericParMapTemplate[K, V, ParMap] with ParIterable[(K, V)] with ParMapLike[K, V, ParMap[K, V], Map[K, V]]

 

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

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4