Object Accumulator.Accumulator

object Accumulator

Contains factory methods to build Accumulators.

Note that the Accumulator object itself is not a factory, but it is implicitly convert to a factory according to the element type, see Accumulator.toFactory.

This allows passing the Accumulator object as argument when a collection.Factory, and the implicit Accumulator.AccumulatorFactoryShape instance is used to build a specialized Accumulator according to the element type:

scala> val intAcc = Accumulator(1,2,3)
intAcc: scala.collection.convert.IntAccumulator = IntAccumulator(1, 2, 3)

scala> val anyAccc = Accumulator("K")
anyAccc: scala.collection.convert.AnyAccumulator[String] = AnyAccumulator(K)

scala> val intAcc2 = List(1,2,3).to(Accumulator)
intAcc2: scala.jdk.IntAccumulator = IntAccumulator(1, 2, 3)

scala> val anyAcc2 = List("K").to(Accumulator)
anyAcc2: scala.jdk.AnyAccumulator[String] = AnyAccumulator(K)

Supertypes	class Object trait Matchable class Any
Self type	Accumulator.type

Classlikes

Source

object AccumulatorFactoryShape extends LowPriorityAccumulatorFactoryShape

Companion	class

Source

sealed trait AccumulatorFactoryShape[A, C]

An implicit AccumulatorFactoryShape is used in Accumulator factory method to return specialized variants according to the element type.

Companion	object

Source

sealed trait LowPriorityAccumulatorFactoryShape

Concrete methods

Source

def apply[A, C](elems: A*)(implicit canAccumulate: AccumulatorFactoryShape[A, C]): C

Creates an Accumulator with the specified elements.

Type parameters	A the type of the Accumulator's elements C the (inferred) specific type of the Accumulator
Value parameters	elems the elements of the created Accumulator
Returns	a new Accumulator with elements elems

Source

def concat[A, C](xss: Iterable[A]*)(implicit canAccumulate: AccumulatorFactoryShape[A, C]): C

Concatenates all argument collections into a single Accumulator.

Value parameters	xss the collections that are to be concatenated.
Returns	the concatenation of all the collections.

Source

def empty[A, C](implicit canAccumulate: AccumulatorFactoryShape[A, C]): C

An empty collection

Type parameters	A the type of the Accumulator's elements

Source

def fill[A, C](n: Int)(elem: => A)(implicit canAccumulate: AccumulatorFactoryShape[A, C]): C

Produces an Accumulator containing the results of some element computation a number of times.

Value parameters	elem the element computation n the number of elements contained in the Accumulator.
Returns	An Accumulator that contains the results of n evaluations of elem.

Source

def fill[A, C](n1: Int, n2: Int)(elem: => A)(implicit canAccumulate: AccumulatorFactoryShape[A, C]): AnyAccumulator[C]

Produces a two-dimensional Accumulator containing the results of some element computation a number of times.

Value parameters	elem the element computation n1 the number of elements in the 1st dimension n2 the number of elements in the 2nd dimension
Returns	An Accumulator that contains the results of n1 x n2 evaluations of elem.

Source

def fill[A, C](n1: Int, n2: Int, n3: Int)(elem: => A)(implicit canAccumulate: AccumulatorFactoryShape[A, C]): AnyAccumulator[AnyAccumulator[C]]

Produces a three-dimensional Accumulator containing the results of some element computation a number of times.

Value parameters	elem the element computation n1 the number of elements in the 1st dimension n2 the number of elements in the 2nd dimension n3 the number of elements in the 3rd dimension
Returns	An Accumulator that contains the results of n1 x n2 x n3 evaluations of elem.

Source

def fill[A, C](n1: Int, n2: Int, n3: Int, n4: Int)(elem: => A)(implicit canAccumulate: AccumulatorFactoryShape[A, C]): AnyAccumulator[AnyAccumulator[AnyAccumulator[C]]]

Produces a four-dimensional Accumulator containing the results of some element computation a number of times.

Value parameters	elem the element computation n1 the number of elements in the 1st dimension n2 the number of elements in the 2nd dimension n3 the number of elements in the 3rd dimension n4 the number of elements in the 4th dimension
Returns	An Accumulator that contains the results of n1 x n2 x n3 x n4 evaluations of elem.

Source

def fill[A, C](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(elem: => A)(implicit canAccumulate: AccumulatorFactoryShape[A, C]): AnyAccumulator[AnyAccumulator[AnyAccumulator[AnyAccumulator[C]]]]

Produces a five-dimensional Accumulator containing the results of some element computation a number of times.

Value parameters	elem the element computation n1 the number of elements in the 1st dimension n2 the number of elements in the 2nd dimension n3 the number of elements in the 3rd dimension n4 the number of elements in the 4th dimension n5 the number of elements in the 5th dimension
Returns	An Accumulator that contains the results of n1 x n2 x n3 x n4 x n5 evaluations of elem.

Source

def from[A, C](source: IterableOnce[A])(implicit canAccumulate: AccumulatorFactoryShape[A, C]): C

Creates a target Accumulator from an existing source collection

Type parameters	A the type of the Accumulator’s elements C the (inferred) specific type of the Accumulator
Value parameters	source Source collection
Returns	a new Accumulator with the elements of source

Source

def iterate[A, C](start: A, len: Int)(f: A => A)(implicit canAccumulate: AccumulatorFactoryShape[A, C]): C

Produces an Accumulator containing repeated applications of a function to a start value.

Value parameters	f the function that's repeatedly applied len the number of elements contained in the Accumulator start the start value of the Accumulator
Returns	an Accumulator with len values in the sequence start, f(start), f(f(start)), ...

Source

def newBuilder[A, C](implicit canAccumulate: AccumulatorFactoryShape[A, C]): Builder[A, C]

Type parameters	A the type of the Accumulator’s elements C the specific type of the Accumulator
Returns	A builder for Accumulator objects.

Source

def range[A : Integral, C](start: A, end: A)(implicit evidence$1: Integral[A], canAccumulate: AccumulatorFactoryShape[A, C]): C

Produces an Accumulator containing a sequence of increasing of integers.

Value parameters	end the end value of the Accumulator (the first value NOT contained) start the first element of the Accumulator
Returns	an Accumulator with values start, start + 1, ..., end - 1

Source

def range[A : Integral, C](start: A, end: A, step: A)(implicit evidence$2: Integral[A], canAccumulate: AccumulatorFactoryShape[A, C]): C

Produces an Accumulator containing equally spaced values in some integer interval.

Value parameters	end the end value of the Accumulator (the first value NOT contained) start the start value of the Accumulator step the difference between successive elements of the Accumulator (must be positive or negative)
Returns	an Accumulator with values start, start + step, ... up to, but excluding end

Source

def tabulate[A, C](n: Int)(f: Int => A)(implicit canAccumulate: AccumulatorFactoryShape[A, C]): C

Produces an Accumulator containing values of a given function over a range of integer values starting from 0.

Value parameters	f The function computing element values n The number of elements in the Accumulator
Returns	An Accumulator consisting of elements f(0), ..., f(n -1)

Source

def tabulate[A, C](n1: Int, n2: Int)(f: (Int, Int) => A)(implicit canAccumulate: AccumulatorFactoryShape[A, C]): AnyAccumulator[C]

Produces a two-dimensional Accumulator containing values of a given function over ranges of integer values starting from 0.

Value parameters	f The function computing element values n1 the number of elements in the 1st dimension n2 the number of elements in the 2nd dimension
Returns	An Accumulator consisting of elements f(i1, i2) for 0 <= i1 < n1 and 0 <= i2 < n2.

Source

def tabulate[A, C](n1: Int, n2: Int, n3: Int)(f: (Int, Int, Int) => A)(implicit canAccumulate: AccumulatorFactoryShape[A, C]): AnyAccumulator[AnyAccumulator[C]]

Produces a three-dimensional Accumulator containing values of a given function over ranges of integer values starting from 0.

Value parameters	f The function computing element values n1 the number of elements in the 1st dimension n2 the number of elements in the 2nd dimension n3 the number of elements in the 3rd dimension
Returns	An Accumulator consisting of elements f(i1, i2, i3) for 0 <= i1 < n1, 0 <= i2 < n2, and 0 <= i3 < n3.

Source

def tabulate[A, C](n1: Int, n2: Int, n3: Int, n4: Int)(f: (Int, Int, Int, Int) => A)(implicit canAccumulate: AccumulatorFactoryShape[A, C]): AnyAccumulator[AnyAccumulator[AnyAccumulator[C]]]

Produces a four-dimensional Accumulator containing values of a given function over ranges of integer values starting from 0.

Value parameters	f The function computing element values n1 the number of elements in the 1st dimension n2 the number of elements in the 2nd dimension n3 the number of elements in the 3rd dimension n4 the number of elements in the 4th dimension
Returns	An Accumulator consisting of elements f(i1, i2, i3, i4) for 0 <= i1 < n1, 0 <= i2 < n2, 0 <= i3 < n3, and 0 <= i4 < n4.

Source

def tabulate[A, C](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(f: (Int, Int, Int, Int, Int) => A)(implicit canAccumulate: AccumulatorFactoryShape[A, C]): AnyAccumulator[AnyAccumulator[AnyAccumulator[AnyAccumulator[C]]]]

Produces a five-dimensional Accumulator containing values of a given function over ranges of integer values starting from 0.

Value parameters	f The function computing element values n1 the number of elements in the 1st dimension n2 the number of elements in the 2nd dimension n3 the number of elements in the 3rd dimension n4 the number of elements in the 4th dimension n5 the number of elements in the 5th dimension
Returns	An Accumulator consisting of elements f(i1, i2, i3, i4, i5) for 0 <= i1 < n1, 0 <= i2 < n2, 0 <= i3 < n3, 0 <= i4 < n4, and 0 <= i5 < n5.

Source

def unfold[A, S, C](init: S)(f: S => Option[(A, S)])(implicit canAccumulate: AccumulatorFactoryShape[A, C]): C

Produces an Accumulator that uses a function f to produce elements of type A and update an internal state of type S.

Type parameters	A Type of the elements C Type (usually inferred) of the Accumulator S Type of the internal state
Value parameters	f Computes the next element (or returns None to signal the end of the collection) init State initial value
Returns	an Accumulator that produces elements using f until f returns None

Implicits

Source

implicit def toFactory[A, C](sa: Accumulator.type)(implicit canAccumulate: AccumulatorFactoryShape[A, C]): Factory[A, C]