WithDefault

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +[U >: V](kv: (K, U)): WithDefault[K, U]

def ++[B](that: GenTraversableOnce[B]): Shrinkable[B]

[use case] Returns a new shrinkable collection containing the elements from the left hand operand followed by the elements from the right hand operand.

scala> val a = LinkedList(1)
a: scala.collection.mutable.LinkedList[Int] = LinkedList(1)

scala> val b = LinkedList(2)
b: scala.collection.mutable.LinkedList[Int] = LinkedList(2)

scala> val c = a ++ b
c: scala.collection.mutable.LinkedList[Int] = LinkedList(1, 2)

scala> val d = LinkedList('a')
d: scala.collection.mutable.LinkedList[Char] = LinkedList(a)

scala> val e = c ++ d
e: scala.collection.mutable.LinkedList[AnyVal] = LinkedList(1, 2, a)

def ++=(xs: TraversableOnce[(K, V)]): WithDefault.this.type

adds all elements produced by a TraversableOnce to this growable collection.

def +=(kv: (K, V)): WithDefault.this.type

adds a single element to this shrinkable collection.

def +=(elem1: (K, V), elem2: (K, V), elems: (K, V)*): WithDefault.this.type

adds two or more elements to this growable collection.

def -(key: K): WithDefault[K, V]

def --=(xs: TraversableOnce[K]): WithDefault.this.type

Removes all elements produced by an iterator from this shrinkable collection.

def -=(key: K): WithDefault.this.type

Removes a single element from this shrinkable collection.

def -=(elem1: K, elem2: K, elems: K*): WithDefault.this.type

Removes two or more elements from this shrinkable collection.

def ->[B](y: B): (WithDefault[K, V], B)

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

Applies a binary operator to a start value and all elements of this general iterable collection , going left to right.

scala> val a = LinkedList(1,2,3,4)
a: scala.collection.mutable.LinkedList[Int] = LinkedList(1, 2, 3, 4)

scala> val b = (5 /: a)(_+_)
b: Int = 15

scala> val c = (5 /: a)((x,y) => x + y)
c: Int = 15

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

Applies a binary operator to all elements of this general iterable collection and a start value, going right to left.

scala> val a = LinkedList(1,2,3,4)
a: scala.collection.mutable.LinkedList[Int] = LinkedList(1, 2, 3, 4)

scala> val b = (a :\ 5)(_+_)
b: Int = 15

scala> val c = (a :\ 5)((x,y) => x + y)
c: Int = 15

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

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

Aggregates the results of applying an operator to subsequent elements.

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

def apply(key: K): V

final def asInstanceOf[T0]: T0

def asParIterable: parallel.ParIterable[(K, V)]

def asParSeq: parallel.ParSeq[(K, V)]

def bf2seq[S, That](bf: CanBuildFrom[ParMap[K, V], S, That]): CanBuildFrom[mutable.Map[K, V], S, That]

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

def canEqual(other: Any): Boolean

def clear(): Unit

Clears the shrinkable collection's contents.

def clone(): ParMap[K, V]

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

[use case] Builds a new collection by applying a partial function to all elements of this shrinkable collection on which the function is defined.

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

def combinerFactory: CombinerFactory[(K, V), ParMap[K, V]]

Creates a combiner factory.

def companion: GenericCompanion[ParIterable] with GenericParCompanion[ParIterable]

The factory companion object that builds instances of class ParIterable.

def contains(key: K): Boolean

Tests whether this map contains a binding for a key.

def copyToArray[U >: (K, V)](xs: Array[U], start: Int, len: Int): Unit

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

[use case] Copies values of this shrinkable collection to an array.

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

[use case] Copies values of this shrinkable collection to an array.

def count(p: ((K, V)) ⇒ Boolean): Int

Counts the number of elements in the general iterable collection which satisfy a predicate.

def debugBuffer: ArrayBuffer[String]

def default(key: K): V

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

def drop(n: Int): ParMap[K, V]

Selects all elements except first n ones.

def dropWhile(pred: ((K, V)) ⇒ Boolean): ParMap[K, V]

Drops all elements in the longest prefix of elements that satisfy the predicate, and returns a collection composed of the remaining elements.

def empty: WithDefault[K, V]

def ensuring(cond: (WithDefault[K, V]) ⇒ Boolean, msg: ⇒ Any): WithDefault[K, V]

def ensuring(cond: (WithDefault[K, V]) ⇒ Boolean): WithDefault[K, V]

def ensuring(cond: Boolean, msg: ⇒ Any): WithDefault[K, V]

def ensuring(cond: Boolean): WithDefault[K, V]

final def eq(arg0: AnyRef): Boolean

def equals(that: Any): Boolean

Compares two maps structurally; i.

def exists(pred: ((K, V)) ⇒ Boolean): Boolean

Tests whether a predicate holds for some element of this general iterable collection .

def filter(pred: ((K, V)) ⇒ Boolean): ParMap[K, V]

Selects all elements of this general iterable collection which satisfy a predicate.

def filterKeys(p: (K) ⇒ Boolean): parallel.ParMap[K, V]

Filters this map by retaining only keys satisfying a predicate.

def filterNot(pred: ((K, V)) ⇒ Boolean): ParMap[K, V]

Selects all elements of this general iterable collection which do not satisfy a predicate.

def finalize(): Unit

def find(pred: ((K, V)) ⇒ Boolean): Option[(K, V)]

Finds some element in the collection for which the predicate holds, if such an element exists.

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

[use case] Builds a new collection by applying a function to all elements of this shrinkable collection and using the elements of the resulting collections.

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)

def flatten[B]: Shrinkable[B]

[use case] Converts this shrinkable collection of traversable collections into a shrinkable collection formed by the elements of these traversable collections.

val xs = List(
           Set(1, 2, 3),
           Set(1, 2, 3)
         ).flatten
// xs == List(1, 2, 3, 1, 2, 3)

val ys = Set(
           List(1, 2, 3),
           List(3, 2, 1)
         ).flatten
// ys == Set(1, 2, 3)

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

Folds the elements of this sequence using the specified associative binary operator.

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

Applies a binary operator to a start value and all elements of this general iterable collection , going left to right.

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

Applies a binary operator to all elements of this general iterable collection and a start value, going right to left.

def forall(pred: ((K, V)) ⇒ Boolean): Boolean

Tests whether a predicate holds for all elements of this general iterable collection .

def foreach[U](f: ((K, V)) ⇒ U): Unit

Applies a function f to all the elements of general iterable collection in an undefined order.

def formatted(fmtstr: String): String

Returns string formatted according to given format string.

def genericBuilder[B]: Combiner[B, ParIterable[B]]

The generic builder that builds instances of CC at arbitrary element types.

def genericCombiner[B]: Combiner[B, ParIterable[B]]

def genericMapCombiner[P, Q]: Combiner[(P, Q), ParMap[P, Q]]

def get(key: K): Option[V]

final def getClass(): Class[_]

def getOrElse(key: A, default: ⇒ B): B

[use case] Returns the value associated with a key, or a default value if the key is not contained in the map.

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

Partitions this general iterable collection into a map of general iterable collection s according to some discriminator function.

def hasDefiniteSize: Boolean

def hashCode(): Int

def head: (K, V)

Selects the first element of this general iterable collection .

def headOption: Option[(K, V)]

Optionally selects the first element.

def ifParSeq[R](isbody: (parallel.ParSeq[(K, V)]) ⇒ R): (TraversableOps[(K, V)])#Otherwise[R]

def init: ParMap[K, V]

Selects all elements except the last.

def initTaskSupport(): Unit

def isDefinedAt(key: K): Boolean

Tests whether this map contains a binding for a key.

def isEmpty: Boolean

Tests whether the general iterable collection is empty.

final def isInstanceOf[T0]: Boolean

def isParIterable: Boolean

def isParSeq: Boolean

def isParallel: Boolean

def isStrictSplitterCollection: Boolean

Denotes whether this parallel collection has strict splitters.

final def isTraversableAgain: Boolean

Tests whether this general iterable collection can be repeatedly traversed.

def iterator: Splitter[(K, V)]

Creates a new split iterator used to traverse the elements of this collection.

def keySet: parallel.ParSet[K]

def keys: parallel.ParIterable[K]

Collects all keys of this map in an iterable collection.

def keysIterator: IterableSplitter[K]

Creates an iterator for all keys.

def last: (K, V)

Selects the last element.

def lastOption: Option[(K, V)]

Optionally selects the last element.

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

[use case] Builds a new collection by applying a function to all elements of this shrinkable collection.

def mapCompanion: GenericParMapCompanion[ParMap]

def mapValues[S](f: (V) ⇒ S): parallel.ParMap[K, S]

Transforms this map by applying a function to every retrieved value.

def max: A

[use case] Finds the largest element.

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

[use case] Finds the first element which yields the largest value measured by function f.

def min: A

[use case] Finds the smallest element.

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

[use case] Finds the first element which yields the smallest value measured by function f.

def mkString: String

Displays all elements of this general iterable collection in a string.

def mkString(sep: String): String

Displays all elements of this general iterable collection in a string using a separator string.

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

Displays all elements of this general iterable collection in a string using start, end, and separator strings.

final def ne(arg0: AnyRef): Boolean

def newBuilder: Builder[(K, V), ParIterable[(K, V)]]

The builder that builds instances of type CC[A]

def newCombiner: Combiner[(K, V), ParMap[K, V]]

def nonEmpty: Boolean

Tests whether the general iterable collection is not empty.

final def notify(): Unit

final def notifyAll(): Unit

def par: ParMap[K, V]

Returns a parallel implementation of this collection.

def parCombiner: Combiner[(K, V), ParMap[K, V]]

The default par implementation uses the combiner provided by this method to create a new parallel collection.

def partition(pred: ((K, V)) ⇒ Boolean): (ParMap[K, V], ParMap[K, V])

Partitions this general iterable collection in two general iterable collection s according to a predicate.

def product: A

[use case] Multiplies up the elements of this collection.

def put(key: K, value: V): Option[V]

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

Reduces the elements of this sequence using the specified associative binary operator.

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

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

Optionally applies a binary operator to all elements of this general iterable collection , going left to right.

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

Optionally reduces the elements of this sequence using the specified associative binary operator.

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

Applies a binary operator to all elements of this general iterable collection , going right to left.

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

Optionally applies a binary operator to all elements of this general iterable collection , going right to left.

def repr: ParMap[K, V]

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

Optionally reuses an existing combiner for better performance.

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

[use case] Checks if the other iterable collection contains the same elements in the same order as this shrinkable collection.

def scan(z: (K, V))(op: ((K, V), (K, V)) ⇒ (K, V)): Shrinkable[(K, V)]

[use case] Computes a prefix scan of the elements of the collection.

def scanBlockSize: Int

def scanLeft[S, That](z: S)(op: (S, (K, V)) ⇒ S)(implicit bf: CanBuildFrom[ParMap[K, V], S, That]): That

Produces a collection containing cumulative results of applying the operator going left to right.

def scanRight[S, That](z: S)(op: ((K, V), S) ⇒ S)(implicit bf: CanBuildFrom[ParMap[K, V], S, That]): That

Produces a collection containing cumulative results of applying the operator going right to left.

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

def seq: mutable.Map[K, V]

def sequentially[S, That <: Parallel](b: (mutable.Map[K, V]) ⇒ Parallelizable[S, That]): ParMap[K, V]

def size: Int

The size of this parallel iterable.

def slice(unc_from: Int, unc_until: Int): ParMap[K, V]

Selects an interval of elements.

from <= indexOf(x) < until

def span(pred: ((K, V)) ⇒ Boolean): (ParMap[K, V], ParMap[K, V])

Splits this general iterable collection into a prefix/suffix pair according to a predicate.

def splitAt(n: Int): (ParMap[K, V], ParMap[K, V])

Splits this general iterable collection into two at a given position.

def splitter: IterableSplitter[(K, V)]

Creates a new parallel iterator used to traverse the elements of this parallel collection.

def stringPrefix: String

Defines the prefix of this object's toString representation.

def sum: A

[use case] Sums up the elements of this collection.

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

def tail: ParMap[K, V]

Selects all elements except the first.

def take(n: Int): ParMap[K, V]

Selects first n elements.

def takeWhile(pred: ((K, V)) ⇒ Boolean): ParMap[K, V]

Takes the longest prefix of elements that satisfy the predicate.

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

def tasksupport: TaskSupport

The task support object which is responsible for scheduling and load-balancing tasks to processors.

def tasksupport_=(ts: TaskSupport): Unit

Changes the task support object which is responsible for scheduling and load-balancing tasks to processors.

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

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

[use case] Converts this shrinkable collection into another by copying all elements.

def toArray: Array[A]

[use case] Converts this shrinkable collection to an array.

def toBuffer[U >: (K, V)]: Buffer[U]

Uses the contents of this general iterable collection to create a new mutable buffer.

def toIndexedSeq: immutable.IndexedSeq[(K, V)]

Converts this general iterable collection to an indexed sequence.

def toIterable: ParIterable[(K, V)]

Converts this parallel iterable to an iterable collection.

def toIterator: scala.Iterator[(K, V)]

Returns an Iterator over the elements in this general iterable collection .

def toList: List[(K, V)]

Converts this general iterable collection to a list.

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

[use case] Converts this shrinkable collection to a map.

def toParArray: ParArray[(K, V)]

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

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

def toSeq: ParSeq[(K, V)]

Converts this parallel iterable to a sequence.

def toSet[U >: (K, V)]: immutable.ParSet[U]

Converts this general iterable collection to a set.

def toStream: Stream[(K, V)]

Converts this general iterable collection to a stream.

def toString(): String

def toTraversable: GenTraversable[(K, V)]

Converts this general iterable collection to an unspecified Traversable.

def toVector: Vector[(K, V)]

Converts this general iterable collection to a Vector.

def transpose[B](implicit asTraversable: ((K, V)) ⇒ GenTraversableOnce[B]): ParIterable[ParIterable[B]]

Transposes this collection of traversable collections into a collection of collections.

val xs = List(
           Set(1, 2, 3),
           Set(4, 5, 6)).transpose
// xs == List(
//         List(1, 4),
//         List(2, 5),
//         List(3, 6))

val ys = Vector(
           List(1, 2, 3),
           List(4, 5, 6)).transpose
// ys == Vector(
//         Vector(1, 4),
//         Vector(2, 5),
//         Vector(3, 6))

def unzip[A1, A2](implicit asPair: ((K, V)) ⇒ (A1, A2)): (ParIterable[A1], ParIterable[A2])

Converts this collection of pairs into two collections of the first and second half of each pair.

val xs = CC(
           (1, "one"),
           (2, "two"),
           (3, "three")).unzip
// xs == (CC(1, 2, 3),
//        CC(one, two, three))

def unzip3[A1, A2, A3](implicit asTriple: ((K, V)) ⇒ (A1, A2, A3)): (ParIterable[A1], ParIterable[A2], ParIterable[A3])

Converts this collection of triples into three collections of the first, second, and third element of each triple.

val xs = CC(
           (1, "one", '1'),
           (2, "two", '2'),
           (3, "three", '3')).unzip3
// xs == (CC(1, 2, 3),
//        CC(one, two, three),
//        CC(1, 2, 3))

def updated[U >: V](key: K, value: U): WithDefault[K, U]

def values: parallel.ParIterable[V]

Collects all values of this map in an iterable collection.

def valuesIterator: IterableSplitter[V]

Creates an iterator for all values in this map.

def view: ParIterableView[(K, V), ParMap[K, V], mutable.Map[K, V]]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withDefault(d: (K) ⇒ V): ParMap[K, V]

If these methods aren't overridden to thread through the underlying map, successive calls to withDefault* have no effect.

def withDefaultValue(d: V): ParMap[K, V]

The same map with a given default value.

def withFilter(pred: ((K, V)) ⇒ Boolean): ParMap[K, V]

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

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

[use case] Returns a shrinkable collection formed from this shrinkable collection and another iterable collection by combining corresponding elements in pairs.

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

[use case] Returns a shrinkable collection formed from this shrinkable collection and another iterable collection by combining corresponding elements in pairs.

def zipWithIndex: Shrinkable[(A, Int)]

[use case] Zips this shrinkable collection with its indices.

def →[B](y: B): (WithDefault[K, V], B)

def +(other: String): String