<K extends string, A>(combiner: Combiner.Combiner<A>): Reducer.Reducer<
Record<K, A>
>Creates a Reducer whose combine operation intersects two records and
combines values for keys present in both records.
When to use
Use to build a Reducer that combines records by retaining only keys shared
by both inputs and combining matching values with a Combiner.
Gotchas
The reducer's initialValue is an empty record. Because intersection with
an empty record is empty, the default combineAll folds from {} and
therefore produces {} for ordinary non-empty inputs.
export function function makeReducerIntersection<
K extends string,
A
>(
combiner: Combiner.Combiner<A>
): Reducer.Reducer<Record<K, A>>
Creates a Reducer whose combine operation intersects two records and
combines values for keys present in both records.
When to use
Use to build a Reducer that combines records by retaining only keys shared
by both inputs and combining matching values with a Combiner.
Gotchas
The reducer's initialValue is an empty record. Because intersection with
an empty record is empty, the default combineAll folds from {} and
therefore produces {} for ordinary non-empty inputs.
makeReducerIntersection<function (type parameter) K in makeReducerIntersection<K extends string, A>(combiner: Combiner.Combiner<A>): Reducer.Reducer<Record<K, A>>K extends string, function (type parameter) A in makeReducerIntersection<K extends string, A>(combiner: Combiner.Combiner<A>): Reducer.Reducer<Record<K, A>>A>(
combiner: Combiner.Combiner<A>(parameter) combiner: {
combine: (self: A, that: A) => A;
}
import CombinerCombiner.type Combiner.Combiner = /*unresolved*/ anyCombiner<function (type parameter) A in makeReducerIntersection<K extends string, A>(combiner: Combiner.Combiner<A>): Reducer.Reducer<Record<K, A>>A>
): import ReducerReducer.interface Reducer<A>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.ReducerMultiplyString.ReducerConcatBoolean.ReducerAnd, Boolean.ReducerOr
Example (String concatenation reducer)
import { Reducer } from "effect"
const Concat = Reducer.make<string>((a, b) => a + b, "")
console.log(Concat.combineAll(["hello", " ", "world"]))
// Output: "hello world"
Reducer<type Record<K extends keyof any, T> = {
[P in K]: T
}
Construct a type with a set of properties K of type T
Record<function (type parameter) K in makeReducerIntersection<K extends string, A>(combiner: Combiner.Combiner<A>): Reducer.Reducer<Record<K, A>>K, function (type parameter) A in makeReducerIntersection<K extends string, A>(combiner: Combiner.Combiner<A>): Reducer.Reducer<Record<K, A>>A>> {
return import ReducerReducer.function make<A>(
combine: (self: A, that: A) => A,
initialValue: A,
combineAll?: (collection: Iterable<A>) => A
): Reducer<A>
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.
Example (Multiplying with short-circuit)
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
}
)
console.log(Product.combineAll([2, 3, 4]))
// Output: 24
console.log(Product.combineAll([2, 0, 4]))
// Output: 0
make(
(self: Record<K, A>self, that: Record<K, A>that) => const intersection: {
<K1 extends string, A, B, C>(
that: ReadonlyRecord<K1, B>,
combine: (selfValue: A, thatValue: B) => C
): <K0 extends string>(
self: ReadonlyRecord<K0, A>
) => Record<
ReadonlyRecord.IntersectKeys<K0, K1>,
C
>
<K0 extends string, A, K1 extends string, B, C>(
self: ReadonlyRecord<K0, A>,
that: ReadonlyRecord<K1, B>,
combine: (selfValue: A, thatValue: B) => C
): Record<
ReadonlyRecord.IntersectKeys<K0, K1>,
C
>
}
self: Record<K, A>self, that: Record<K, A>that, combiner: Combiner.Combiner<A>(parameter) combiner: {
combine: (self: A, that: A) => A;
}
type Record<K extends keyof any, T> = {
[P in K]: T
}
Construct a type with a set of properties K of type T
Record<function (type parameter) K in makeReducerIntersection<K extends string, A>(combiner: Combiner.Combiner<A>): Reducer.Reducer<Record<K, A>>K, function (type parameter) A in makeReducerIntersection<K extends string, A>(combiner: Combiner.Combiner<A>): Reducer.Reducer<Record<K, A>>A>
)
}