Reducer

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

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

import { Reducer, String } from "effect"

const Prepend = Reducer.flip(String.ReducerConcat)

Prepend.combine("a", "b") // => "ba"
Prepend.combineAll(["a", "b", "c"]) // => "cba"

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

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

import { Reducer } from "effect"

const Product = Reducer.make<number>(
  (a, b) => a * b,
  1,
  (collection) => {
    let acc = 1
    for (const n of collection) {
      if (n === 0) return 0
      acc *= n
    }
    return acc
  }
)

Product.combineAll([2, 3, 4]) // => 24
Product.combineAll([2, 0, 4]) // => 0

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

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

import { Reducer } from "effect"

const Concat = Reducer.make<string>((a, b) => a + b, "")

Concat.combineAll(["hello", " ", "world"]) // => "hello world"