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/immutable/ParSeq.html below:

Scala Standard Library 2.12.19 - scala.collection.parallel.immutable.ParSeq

trait ParSeq[+T] extends GenSeq[T] with parallel.ParSeq[T] with ParIterable[T] with GenericParTemplate[T, ParSeq] with ParSeqLike[T, ParSeq[T], immutable.Seq[T]]

 

Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. ParSeq
  2. ParIterable
  3. Immutable
  4. ParSeq
  5. ParSeqLike
  6. ParIterable
  7. ParIterableLike
  8. Parallel
  9. CustomParallelizable
  10. GenericParTemplate
  11. HasNewCombiner
  12. GenSeq
  13. GenIterable
  14. GenTraversable
  15. GenericTraversableTemplate
  16. HasNewBuilder
  17. GenSeqLike
  18. Equals
  19. GenIterableLike
  20. GenTraversableLike
  21. Parallelizable
  22. GenTraversableOnce
  23. AnyRef
  24. Any
Implicitly
  1. by CollectionsHaveToParArray
  2. by any2stringadd
  3. by StringFormat
  4. by Ensuring
  5. by ArrowAssoc
Type Members
  1.  class Aggregate[S] extends Accessor[S, Aggregate[S]]
  2.  trait BuilderOps[Elem, To] extends AnyRef
  3.  class Collect[S, That] extends Transformer[Combiner[S, That], Collect[S, That]]
  4.  abstract class Composite[FR, SR, R, First <: StrictSplitterCheckTask[FR, _], Second <: StrictSplitterCheckTask[SR, _]] extends NonDivisibleTask[R, Composite[FR, SR, R, First, Second]]
  5.  class Copy[U >: T, That] extends Transformer[Combiner[U, That], Copy[U, That]]
  6.  class CopyToArray[U >: T, This >: Repr] extends Accessor[Unit, CopyToArray[U, This]]
  7.  class Count extends Accessor[Int, Count]
  8.  class CreateScanTree[U >: T] extends Transformer[ScanTree[U], CreateScanTree[U]]
  9.  class Drop[U >: T, This >: Repr] extends Transformer[Combiner[U, This], Drop[U, This]]
  10.  class Exists extends Accessor[Boolean, Exists]
  11.  class Filter[U >: T, This >: Repr] extends Transformer[Combiner[U, This], Filter[U, This]]
  12.  class FilterNot[U >: T, This >: Repr] extends Transformer[Combiner[U, This], FilterNot[U, This]]
  13.  class Find[U >: T] extends Accessor[Option[U], Find[U]]
  14.  class FlatMap[S, That] extends Transformer[Combiner[S, That], FlatMap[S, That]]
  15.  class Fold[U >: T] extends Accessor[U, Fold[U]]
  16.  class Forall extends Accessor[Boolean, Forall]
  17.  class Foreach[S] extends Accessor[Unit, Foreach[S]]
  18.  class FromScanTree[U >: T, That] extends StrictSplitterCheckTask[Combiner[U, That], FromScanTree[U, That]]
  19.  class GroupBy[K, U >: T] extends Transformer[HashMapCombiner[K, U], GroupBy[K, U]]
  20.  class Map[S, That] extends Transformer[Combiner[S, That], Map[S, That]]
  21.  class Max[U >: T] extends Accessor[Option[U], Max[U]]
  22.  class Min[U >: T] extends Accessor[Option[U], Min[U]]
  23.  trait NonDivisible[R] extends NonDivisibleTask[R, NonDivisible[R]]
  24.  trait NonDivisibleTask[R, Tp] extends StrictSplitterCheckTask[R, Tp]
  25.  abstract class ParComposite[FR, SR, R, First <: StrictSplitterCheckTask[FR, _], Second <: StrictSplitterCheckTask[SR, _]] extends Composite[FR, SR, R, First, Second]
  26.  class Partition[U >: T, This >: Repr] extends Transformer[(Combiner[U, This], Combiner[U, This]), Partition[U, This]]
  27.  class Product[U >: T] extends Accessor[U, Product[U]]
  28.  class Reduce[U >: T] extends Accessor[Option[U], Reduce[U]]
  29.  abstract class ResultMapping[R, Tp, R1] extends NonDivisibleTask[R1, ResultMapping[R, Tp, R1]]
  30.  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
  31.  case class ScanNode[U >: T](left: ScanTree[U], right: ScanTree[U]) extends ScanTree[U] with scala.Product with Serializable
  32.  trait ScanTree[U >: T] extends AnyRef
  33.  abstract class SeqComposite[FR, SR, R, First <: StrictSplitterCheckTask[FR, _], Second <: StrictSplitterCheckTask[SR, _]] extends Composite[FR, SR, R, First, Second]
  34.  trait SignallingOps[PI <: DelegatedSignalling] extends AnyRef
  35.  class Slice[U >: T, This >: Repr] extends Transformer[Combiner[U, This], Slice[U, This]]
  36.  class Span[U >: T, This >: Repr] extends Transformer[(Combiner[U, This], Combiner[U, This]), Span[U, This]]
  37.  class SplitAt[U >: T, This >: Repr] extends Transformer[(Combiner[U, This], Combiner[U, This]), SplitAt[U, This]]
  38.  trait StrictSplitterCheckTask[R, Tp] extends Task[R, Tp]
  39.  class Sum[U >: T] extends Accessor[U, Sum[U]]
  40.  class Take[U >: T, This >: Repr] extends Transformer[Combiner[U, This], Take[U, This]]
  41.  class TakeWhile[U >: T, This >: Repr] extends Transformer[(Combiner[U, This], Boolean), TakeWhile[U, This]]
  42.  trait TaskOps[R, Tp] extends AnyRef
  43.  class ToParCollection[U >: T, That] extends Transformer[Combiner[U, That], ToParCollection[U, That]]
  44.  class ToParMap[K, V, That] extends Transformer[Combiner[(K, V), That], ToParMap[K, V, That]]
  45.  class ZipAll[U >: T, S, That] extends Transformer[Combiner[(U, S), That], ZipAll[U, S, That]]
  46.  trait Accessor[R, Tp] extends ParSeqLike.Accessor[R, Tp]
  47.  class Corresponds[S] extends Accessor[Boolean, Corresponds[S]]
  48.  abstract class Elements extends SeqSplitter[T] with scala.BufferedIterator[T]
  49.  class IndexWhere extends Accessor[Int, IndexWhere]
  50.  class LastIndexWhere extends Accessor[Int, LastIndexWhere]
  51.  class Reverse[U >: T, This >: Repr] extends Transformer[Combiner[U, This], Reverse[U, This]]
  52.  class ReverseMap[S, That] extends Transformer[Combiner[S, That], ReverseMap[S, That]]
  53.  class SameElements[U >: T] extends Accessor[Boolean, SameElements[U]]
  54.  class SegmentLength extends Accessor[(Int, Boolean), SegmentLength]
  55.  trait Transformer[R, Tp] extends Accessor[R, Tp] with ParSeqLike.Transformer[R, Tp]
  56.  class Updated[U >: T, That] extends Transformer[Combiner[U, That], Updated[U, That]]
  57.  class Zip[U >: T, S, That] extends Transformer[Combiner[(U, S), That], Zip[U, S, That]]
  58.  type SSCTask[R, Tp] = StrictSplitterCheckTask[R, Tp]
  59.  type SuperParIterator = IterableSplitter[T]
Concrete Value Members
  1.  final def !=(arg0: Any): Boolean
  2.  final def ##(): Int
  3.  def +(other: String): String
  4.  def ++[U >: T, That](that: GenTraversableOnce[U])(implicit bf: CanBuildFrom[ParSeq[T], U, That]): That
  5.  def +:(elem: A): mutable.ParSeq[A]
  6.  def ->[B](y: B): (ParSeq[T], B)
  7.  def :+(elem: A): mutable.ParSeq[A]
  8.  final def ==(arg0: Any): Boolean
  9.  def aggregate[S](z: ⇒ S)(seqop: (S, T) ⇒ S, combop: (S, S) ⇒ S): S
  10.  final def asInstanceOf[T0]: T0
  11.  def bf2seq[S, That](bf: CanBuildFrom[ParSeq[T], S, That]): CanBuildFrom[immutable.Seq[T], S, That]
  12.  implicit def builder2ops[Elem, To](cb: Builder[Elem, To]): BuilderOps[Elem, To]
  13.  def canEqual(other: Any): Boolean
  14.  def clone(): AnyRef
  15.  def collect[B](pf: PartialFunction[A, B]): mutable.ParSeq[B]
  16.  def combinerFactory[S, That](cbf: () ⇒ Combiner[S, That]): CombinerFactory[S, That]
  17.  def combinerFactory: CombinerFactory[T, ParSeq[T]]
  18.  def companion: GenericCompanion[ParSeq] with GenericParCompanion[ParSeq]
  19.  def copyToArray(xs: Array[A], start: Int, len: Int): Unit
  20.  def copyToArray(xs: Array[A], start: Int): Unit
  21.  def copyToArray(xs: Array[A]): Unit
  22.  def corresponds[S](that: GenSeq[S])(p: (T, S) ⇒ Boolean): Boolean
  23.  def count(p: (T) ⇒ Boolean): Int
  24.  def debugBuffer: ArrayBuffer[String]
  25.  implicit def delegatedSignalling2ops[PI <: DelegatedSignalling](it: PI): SignallingOps[PI]
  26.  def diff(that: GenSeq[A]): mutable.ParSeq[A]
  27.  def distinct: ParSeq[T]
  28.  def down(p: IterableSplitter[_]): SeqSplitter[T]
  29.  def drop(n: Int): ParSeq[T]
  30.  def dropWhile(pred: (T) ⇒ Boolean): ParSeq[T]
  31.  def endsWith[S](that: GenSeq[S]): Boolean
  32.  def ensuring(cond: (ParSeq[T]) ⇒ Boolean, msg: ⇒ Any): ParSeq[T]
  33.  def ensuring(cond: (ParSeq[T]) ⇒ Boolean): ParSeq[T]
  34.  def ensuring(cond: Boolean, msg: ⇒ Any): ParSeq[T]
  35.  def ensuring(cond: Boolean): ParSeq[T]
  36.  final def eq(arg0: AnyRef): Boolean
  37.  def equals(that: Any): Boolean
  38.  def exists(p: (T) ⇒ Boolean): Boolean
  39.  def filter(pred: (T) ⇒ Boolean): ParSeq[T]
  40.  def filterNot(pred: (T) ⇒ Boolean): ParSeq[T]
  41.  def finalize(): Unit
  42.  def find(p: (T) ⇒ Boolean): Option[T]
  43.  def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): mutable.ParSeq[B]
  44.  def flatten[B]: mutable.ParSeq[B]
  45.  def fold[U >: T](z: U)(op: (U, U) ⇒ U): U
  46.  def foldLeft[S](z: S)(op: (S, T) ⇒ S): S
  47.  def foldRight[S](z: S)(op: (T, S) ⇒ S): S
  48.  def forall(p: (T) ⇒ Boolean): Boolean
  49.  def foreach[U](f: (T) ⇒ U): Unit
  50.  def genericBuilder[B]: Combiner[B, ParSeq[B]]
  51.  def genericCombiner[B]: Combiner[B, ParSeq[B]]
  52.  final def getClass(): Class[_]
  53.  def groupBy[K](f: (T) ⇒ K): ParMap[K, ParSeq[T]]
  54.  def hasDefiniteSize: Boolean
  55.  def hashCode(): Int
  56.  def head: T
  57.  def headOption: Option[T]
  58.  def indexOf(elem: T, from: Int): Int
  59.  def indexOf(elem: T): Int
  60.  def indexWhere(p: (T) ⇒ Boolean, from: Int): Int
  61.  def indexWhere(p: (T) ⇒ Boolean): Int
  62.  def init: ParSeq[T]
  63.  def initTaskSupport(): Unit
  64.  def intersect(that: scala.Seq[T]): mutable.ParSeq[T]
  65.  def isDefinedAt(idx: Int): Boolean
  66.  def isEmpty: Boolean
  67.  final def isInstanceOf[T0]: Boolean
  68.  def isStrictSplitterCollection: Boolean
  69.  final def isTraversableAgain: Boolean
  70.  def iterator: PreciseSplitter[T]
  71.  def last: T
  72.  def lastIndexOf(elem: T, end: Int): Int
  73.  def lastIndexOf(elem: T): Int
  74.  def lastIndexWhere(p: (T) ⇒ Boolean, end: Int): Int
  75.  def lastIndexWhere(p: (T) ⇒ Boolean): Int
  76.  def lastOption: Option[T]
  77.  def map[B](f: (A) ⇒ B): mutable.ParSeq[B]
  78.  def max: A
  79.  def maxBy[B](f: (A) ⇒ B): A
  80.  def min: A
  81.  def minBy[B](f: (A) ⇒ B): A
  82.  def mkString: String
  83.  def mkString(sep: String): String
  84.  def mkString(start: String, sep: String, end: String): String
  85.  final def ne(arg0: AnyRef): Boolean
  86.  def newBuilder: Builder[T, ParSeq[T]]
  87.  def newCombiner: Combiner[T, ParSeq[T]]
  88.  def nonEmpty: Boolean
  89.  final def notify(): Unit
  90.  final def notifyAll(): Unit
  91.  def padTo(len: Int, elem: A): mutable.ParSeq[A]
  92.  def par: ParSeq[T]
  93.  def parCombiner: Combiner[T, ParSeq[T]]
  94.  def partition(pred: (T) ⇒ Boolean): (ParSeq[T], ParSeq[T])
  95.  def patch(from: Int, that: GenSeq[A], replaced: Int): mutable.ParSeq[A]
  96.  def prefixLength(p: (T) ⇒ Boolean): Int
  97.  def product: A
  98.  def reduce[U >: T](op: (U, U) ⇒ U): U
  99.  def reduceLeft[U >: T](op: (U, T) ⇒ U): U
  100.  def reduceLeftOption[U >: T](op: (U, T) ⇒ U): Option[U]
  101.  def reduceOption[U >: T](op: (U, U) ⇒ U): Option[U]
  102.  def reduceRight[U >: T](op: (T, U) ⇒ U): U
  103.  def reduceRightOption[U >: T](op: (T, U) ⇒ U): Option[U]
  104.  def repr: ParSeq[T]
  105.  def reuse[S, That](oldc: Option[Combiner[S, That]], newc: Combiner[S, That]): Combiner[S, That]
  106.  def reverse: ParSeq[T]
  107.  def reverseMap[B](f: (A) ⇒ B): mutable.ParSeq[B]
  108.  def sameElements(that: GenIterable[A]): Boolean
  109.  def scan(z: T)(op: (T, T) ⇒ T): mutable.ParSeq[T]
  110.  def scanBlockSize: Int
  111.  def scanLeft[S, That](z: S)(op: (S, T) ⇒ S)(implicit bf: CanBuildFrom[ParSeq[T], S, That]): That
  112.  def scanRight[S, That](z: S)(op: (T, S) ⇒ S)(implicit bf: CanBuildFrom[ParSeq[T], S, That]): That
  113.  def segmentLength(p: (T) ⇒ Boolean, from: Int): Int
  114.  def sequentially[S, That <: Parallel](b: (immutable.Seq[T]) ⇒ Parallelizable[S, That]): ParSeq[T]
  115.  def size: Int
  116.  def sizeHintIfCheap: Int
  117.  def slice(unc_from: Int, unc_until: Int): ParSeq[T]
  118.  def span(pred: (T) ⇒ Boolean): (ParSeq[T], ParSeq[T])
  119.  def splitAt(n: Int): (ParSeq[T], ParSeq[T])
  120.  def startsWith[S](that: GenSeq[S], offset: Int): Boolean
  121.  def startsWith[B](that: GenSeq[B]): Boolean
  122.  def stringPrefix: String
  123.  def sum: A
  124.  final def synchronized[T0](arg0: ⇒ T0): T0
  125.  def tail: ParSeq[T]
  126.  def take(n: Int): ParSeq[T]
  127.  def takeWhile(pred: (T) ⇒ Boolean): ParSeq[T]
  128.  implicit def task2ops[R, Tp](tsk: SSCTask[R, Tp]): TaskOps[R, Tp]
  129.  def tasksupport: TaskSupport
  130.  def tasksupport_=(ts: TaskSupport): Unit
  131.  def to[Col[_]]: Col[A]
  132.  def toArray: Array[A]
  133.  def toBuffer[U >: T]: Buffer[U]
  134.  def toIndexedSeq: immutable.IndexedSeq[T]
  135.  def toIterable: ParIterable[T]
  136.  def toIterator: scala.Iterator[T]
  137.  def toList: List[T]
  138.  def toMap[T, U]: collection.Map[T, U]
  139.  def toParArray: ParArray[T]
  140.  def toParCollection[U >: T, That](cbf: () ⇒ Combiner[U, That]): That
  141.  def toParMap[K, V, That](cbf: () ⇒ Combiner[(K, V), That])(implicit ev: <:<[T, (K, V)]): That
  142.  def toSeq: ParSeq[T]
  143.  def toSet[U >: T]: ParSet[U]
  144.  def toStream: Stream[T]
  145.  def toString(): String
  146.  def toTraversable: GenTraversable[T]
  147.  def toVector: Vector[T]
  148.  def transpose[B](implicit asTraversable: (T) ⇒ GenTraversableOnce[B]): ParSeq[ParSeq[B]]
  149.  def union(that: GenSeq[T]): mutable.ParSeq[T]
  150.  def unzip[A1, A2](implicit asPair: (T) ⇒ (A1, A2)): (ParSeq[A1], ParSeq[A2])
  151.  def unzip3[A1, A2, A3](implicit asTriple: (T) ⇒ (A1, A2, A3)): (ParSeq[A1], ParSeq[A2], ParSeq[A3])
  152.  def updated(index: Int, elem: A): mutable.ParSeq[A]
  153.  final def wait(): Unit
  154.  final def wait(arg0: Long, arg1: Int): Unit
  155.  final def wait(arg0: Long): Unit
  156.  def withFilter(pred: (T) ⇒ Boolean): ParSeq[T]
  157.  def wrap[R](body: ⇒ R): NonDivisible[R]
  158.  def zip[B](that: GenIterable[B]): mutable.ParSeq[(A, B)]
  159.  def zipAll[B](that: Iterable[B], thisElem: A, thatElem: B): mutable.ParSeq[(A, B)]
  160.  def zipWithIndex: mutable.ParSeq[(A, Int)]
  161.  def →[B](y: B): (ParSeq[T], B)
Inherited from HasNewCombiner[T, scala.collection.parallel.immutable.ParSeq[T] @scala.annotation.unchecked.uncheckedVariance] Inherited from HasNewBuilder[T, scala.collection.parallel.immutable.ParSeq[T] @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