Skip to content

Reducer

Reusable strategies for reducing many values into one value. A Reducer<A> extends Combiner.Combiner with an initialValue for empty collections and a combineAll method for folding an entire iterable. This module provides a constructor for reducers and a helper for reversing the order in which values are combined.

3 exports Added in v4.0.0 Source

Combinators

flip

Added in v4.0.0 Source

Reverses the argument order of a reducer's combine method.

When to use

Use when you want the right-hand value to act as the accumulator, or need to reverse a non-commutative reducer such as string concatenation.

Details

- Returns a new Reducer where combine(self, that) calls the original reducer as combine(that, self). - The initialValue is preserved from the original reducer. - The combineAll is re-derived from the flipped combine (using the default left-to-right fold), not carried over from the original.

See

  • make
  • Combiner.flip – the same operation on a plain Combiner

Signature

declare function flip<A>(reducer: Reducer<A>): Reducer<A>;

Constructors

make

Added in v4.0.0 Source

Creates a Reducer from a combine function and an initialValue.

When to use

Use when you have a custom reducing operation not covered by a pre-built reducer. - You want to provide an optimized combineAll (e.g. short-circuiting on a known absorbing element like 0 for multiplication).

Details

- If combineAll is omitted, a default left-to-right fold starting from initialValue is used. - If combineAll is provided, it completely replaces the default fold.

See

  • Reducer – the interface this creates
  • flip – reverse the argument order

Signature

declare function make<A>(
  combine: (self: A, that: A) => A,
  initialValue: A,
  combineAll?: (collection: Iterable<A>) => A,
): Reducer<A>;

Models

Reducer interface

Added in v4.0.0 Source

Represents a strategy for reducing a collection of values of type A into a single result.

When to use

Use when you need to fold/reduce a collection into a single value. - You want a reusable reducing strategy that can be passed to library functions like Struct.makeReducer, Option.makeReducer, or Record.makeReducerUnion. - You need both the combining logic *and* a known starting value.

Details

Extends Combiner.Combiner with:

- initialValue – the identity/neutral element for combine. - combineAll – folds an entire Iterable<A> from initialValue.

Many modules ship pre-built reducers:

- Number.ReducerSum, Number.ReducerMultiply - String.ReducerConcat - Boolean.ReducerAnd, Boolean.ReducerOr

See

  • make – create a Reducer from a function and initial value
  • Combiner.Combiner – parent interface without initialValue

Signature

interface Reducer<A> extends Combiner<A> {
  readonly combineAll: (collection: Iterable<A>) => A;
  readonly initialValue: A;
}