effect 4.0.0-beta.6 → 4.0.0-beta.62

package/dist/Redactable.js

@@ -1,75 +1,65 @@
-/**
- * @since 4.0.0
- */
 import { pipeArguments } from "./Pipeable.js";
 import { hasProperty } from "./Predicate.js";
 /**
- * Symbol used to identify objects that implement redaction capabilities.
+ * Symbol used to identify objects that implement the {@link Redactable}
+ * protocol.
  *
- * @since 4.0.0
- * @category symbol
- */
-export const symbolRedactable = /*#__PURE__*/Symbol.for("~effect/Inspectable/redactable");
-/**
- * Checks if a value implements the `Redactable` interface.
+ * Add a method under this key to make an object redactable. The method
+ * receives the current `Context` and must return the replacement value.
  *
- * This function determines whether a given value has redaction capabilities,
- * meaning it can provide alternative representations based on context.
+ * - Use this symbol as the property key when implementing {@link Redactable}.
+ * - Registered globally via `Symbol.for("~effect/Redactable")`,
+ *   so it is identical across multiple copies of the library at runtime.
  *
- * @param u - The value to check
+ * **Example** (Masking an API key)
  *
- * @example
  * ```ts
- * import { Redactable } from "effect"
+ * import { Context, Redactable } from "effect"
  *
- * class RedactableSecret {
- *   [Redactable.symbolRedactable]() {
- *     return "[REDACTED]"
+ * class ApiKey {
+ *   constructor(readonly raw: string) {}
+ *
+ *   [Redactable.symbolRedactable](_ctx: Context.Context<never>) {
+ *     return this.raw.slice(0, 4) + "..."
  *   }
  * }
- *
- * const secret = new RedactableSecret()
- * const normal = { value: 42 }
- *
- * console.log(Redactable.isRedactable(secret)) // true
- * console.log(Redactable.isRedactable(normal)) // false
- * console.log(Redactable.isRedactable("string")) // false
  * ```
  *
+ * See also:
+ * - {@link Redactable} - the interface this symbol belongs to
+ * - {@link isRedactable} - check whether a value has this symbol
+ *
  * @since 4.0.0
- * @category redactable
+ * @category symbol
  */
-export const isRedactable = u => hasProperty(u, symbolRedactable);
+export const symbolRedactable = /*#__PURE__*/Symbol.for("~effect/Redactable");
 /**
- * Applies redaction to a value if it implements the Redactable interface.
- *
- * This function checks if the value is redactable and applies the redaction
- * transformation if a current fiber context is available. Otherwise, it returns
- * the value unchanged.
+ * Type guard that checks whether a value implements the {@link Redactable}
+ * interface.
  *
- * @param u - The value to potentially redact
+ * See also:
+ * - {@link Redactable} - the interface being checked
+ * - {@link redact} - applies redaction if the value is redactable
  *
- * @example
- * ```ts
- * import { Redactable } from "effect"
- *
- * class CreditCard {
- *   constructor(private number: string) {}
- *
- *   [Redactable.symbolRedactable]() {
- *     return {
- *       number: this.number.slice(0, 4) + "****"
- *     }
- *   }
- * }
+ * @since 4.0.0
+ * @category guards
+ */
+export const isRedactable = u => hasProperty(u, symbolRedactable);
+/**
+ * Redacts a value if it implements {@link Redactable}, otherwise returns it
+ * unchanged.
  *
- * const card = new CreditCard("1234567890123456")
- * console.log(Redactable.redact(card)) // { number: "1234****" }
+ * - Use this as the general-purpose entry point for redaction: it is safe to
+ *   call on any value.
+ * - Internally calls {@link isRedactable} and, if `true`, delegates to
+ *   {@link getRedacted}.
+ * - Not recursive: nested redactable values inside the returned object are not
+ *   automatically redacted.
+ * - Pure with respect to its argument (does not mutate the input).
  *
- * // Non-redactable values are returned unchanged
- * console.log(Redactable.redact("normal string")) // "normal string"
- * console.log(Redactable.redact({ id: 123 })) // { id: 123 }
- * ```
+ * See also:
+ * - {@link isRedactable} - check before redacting
+ * - {@link getRedacted} - lower-level variant for known redactables
  *
  * @since 4.0.0
  */
@@ -78,15 +68,29 @@ export function redact(u) {
   return u;
 }
 /**
+ * Calls `[symbolRedactable]` on a value that is already known to be
+ * {@link Redactable} and returns the result.
+ *
+ * - Use this when you have already verified the value is `Redactable` (e.g.,
+ *   via {@link isRedactable}) and want to avoid a second check.
+ * - Reads the current fiber's `Context` from the global fiber reference. If
+ *   no fiber is active, an empty `Context` is passed to the redaction
+ *   method.
+ * - Does not mutate the input.
+ *
+ * See also:
+ * - {@link redact} - higher-level variant that handles non-redactable values
+ * - {@link isRedactable} - type guard to verify before calling this
+ *
  * @since 4.0.0
  */
 export function getRedacted(redactable) {
-  return redactable[symbolRedactable](globalThis[currentFiberTypeId]?.services ?? emptyServiceMap);
+  return redactable[symbolRedactable](globalThis[currentFiberTypeId]?.context ?? emptyContext);
 }
 /** @internal */
 export const currentFiberTypeId = "~effect/Fiber/currentFiber";
-const emptyServiceMap = {
-  "~effect/ServiceMap": {},
+const emptyContext = {
+  "~effect/Context": {},
   mapUnsafe: /*#__PURE__*/new Map(),
   pipe() {
     return pipeArguments(this, arguments);

package/dist/Redactable.js.map

@@ -1 +1 @@
-{"version":3,"file":"Redactable.js","names":["pipeArguments","hasProperty","symbolRedactable","Symbol","for","isRedactable","u","redact","getRedacted","redactable","globalThis","currentFiberTypeId","services","emptyServiceMap","mapUnsafe","Map","pipe","arguments"],"sources":["../src/Redactable.ts"],"sourcesContent":[null],"mappings":"AAAA;;;AAGA,SAASA,aAAa,QAAQ,eAAe;AAC7C,SAASC,WAAW,QAAQ,gBAAgB;AAG5C;;;;;;AAMA,OAAO,MAAMC,gBAAgB,gBAAkBC,MAAM,CAACC,GAAG,CAAC,gCAAgC,CAAC;AAkC3F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,OAAO,MAAMC,YAAY,GAAIC,CAAU,IAAsBL,WAAW,CAACK,CAAC,EAAEJ,gBAAgB,CAAC;AAE7F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,OAAM,SAAUK,MAAMA,CAACD,CAAU;EAC/B,IAAID,YAAY,CAACC,CAAC,CAAC,EAAE,OAAOE,WAAW,CAACF,CAAC,CAAC;EAC1C,OAAOA,CAAC;AACV;AAEA;;;AAGA,OAAM,SAAUE,WAAWA,CAACC,UAAsB;EAChD,OAAOA,UAAU,CAACP,gBAAgB,CAAC,CAAEQ,UAAkB,CAACC,kBAAkB,CAAC,EAAEC,QAAQ,IAAIC,eAAe,CAAC;AAC3G;AAEA;AACA,OAAO,MAAMF,kBAAkB,GAAG,4BAA4B;AAE9D,MAAME,eAAe,GAAiC;EACpD,oBAAoB,EAAE,EAAS;EAC/BC,SAAS,eAAE,IAAIC,GAAG,EAAE;EACpBC,IAAIA,CAAA;IACF,OAAOhB,aAAa,CAAC,IAAI,EAAEiB,SAAS,CAAC;EACvC;CACM","ignoreList":[]}
+{"version":3,"file":"Redactable.js","names":["pipeArguments","hasProperty","symbolRedactable","Symbol","for","isRedactable","u","redact","getRedacted","redactable","globalThis","currentFiberTypeId","context","emptyContext","mapUnsafe","Map","pipe","arguments"],"sources":["../src/Redactable.ts"],"sourcesContent":[null],"mappings":"AAqEA,SAASA,aAAa,QAAQ,eAAe;AAC7C,SAASC,WAAW,QAAQ,gBAAgB;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,OAAO,MAAMC,gBAAgB,gBAAkBC,MAAM,CAACC,GAAG,CAAC,oBAAoB,CAAC;AAoC/E;;;;;;;;;;;AAWA,OAAO,MAAMC,YAAY,GAAIC,CAAU,IAAsBL,WAAW,CAACK,CAAC,EAAEJ,gBAAgB,CAAC;AAE7F;;;;;;;;;;;;;;;;;;AAkBA,OAAM,SAAUK,MAAMA,CAACD,CAAU;EAC/B,IAAID,YAAY,CAACC,CAAC,CAAC,EAAE,OAAOE,WAAW,CAACF,CAAC,CAAC;EAC1C,OAAOA,CAAC;AACV;AAEA;;;;;;;;;;;;;;;;;AAiBA,OAAM,SAAUE,WAAWA,CAACC,UAAsB;EAChD,OAAOA,UAAU,CAACP,gBAAgB,CAAC,CAAEQ,UAAkB,CAACC,kBAAkB,CAAC,EAAEC,OAAO,IAAIC,YAAY,CAAC;AACvG;AAEA;AACA,OAAO,MAAMF,kBAAkB,GAAG,4BAA4B;AAE9D,MAAME,YAAY,GAA2B;EAC3C,iBAAiB,EAAE,EAAS;EAC5BC,SAAS,eAAE,IAAIC,GAAG,EAAE;EACpBC,IAAIA,CAAA;IACF,OAAOhB,aAAa,CAAC,IAAI,EAAEiB,SAAS,CAAC;EACvC;CACM","ignoreList":[]}

package/dist/Reducer.d.ts

@@ -1,15 +1,105 @@
 /**
+ * A module for reducing collections of values into a single result.
+ *
+ * A `Reducer<A>` extends {@link Combiner.Combiner} by adding an
+ * `initialValue` (identity element) and a `combineAll` method that folds an
+ * entire collection. Think `Array.prototype.reduce`, but packaged as a
+ * reusable, composable value.
+ *
+ * ## Mental model
+ *
+ * - **Reducer** – a {@link Combiner.Combiner} plus an `initialValue` and a
+ *   `combineAll` method.
+ * - **initialValue** – the neutral/identity element. Combining any value with
+ *   `initialValue` should return the original value unchanged (e.g. `0` for
+ *   addition, `""` for string concatenation).
+ * - **combineAll** – folds an `Iterable<A>` starting from `initialValue`.
+ *   When omitted from {@link make}, a default left-to-right fold is used.
+ * - **Purity** – all reducers produced by this module are pure; they never
+ *   mutate their arguments.
+ * - **Composability** – reducers can be lifted into `Option`, `Struct`,
+ *   `Tuple`, `Record`, and other container types via helpers in those modules.
+ * - **Subtype of Combiner** – every `Reducer` is also a valid
+ *   `Combiner`, so you can pass a `Reducer` anywhere a `Combiner` is
+ *   expected.
+ *
+ * ## Common tasks
+ *
+ * - Create a reducer from a combine function and initial value → {@link make}
+ * - Swap argument order → {@link flip}
+ * - Combine two values without an initial value → use {@link Combiner.Combiner}
+ *   instead
+ *
+ * ## Gotchas
+ *
+ * - `combineAll` on an empty iterable returns `initialValue`, not an error.
+ * - The default `combineAll` folds left-to-right. If your `combine` is not
+ *   associative, order matters. Pass a custom `combineAll` to {@link make} if
+ *   you need different traversal or short-circuiting.
+ * - A `Reducer` is also a valid `Combiner` — but a `Combiner` is *not* a
+ *   `Reducer` (it lacks `initialValue`).
+ *
+ * ## Quickstart
+ *
+ * **Example** (summing a list of numbers)
+ *
+ * ```ts
+ * import { Reducer } from "effect"
+ *
+ * const Sum = Reducer.make<number>((a, b) => a + b, 0)
+ *
+ * console.log(Sum.combine(3, 4))
+ * // Output: 7
+ *
+ * console.log(Sum.combineAll([1, 2, 3, 4]))
+ * // Output: 10
+ *
+ * console.log(Sum.combineAll([]))
+ * // Output: 0
+ * ```
+ *
+ * ## See also
+ *
+ * - {@link make} – the primary constructor
+ * - {@link Reducer} – the core interface
+ * - {@link Combiner.Combiner} – the parent interface (no `initialValue`)
+ *
  * @since 4.0.0
  */
 import type * as Combiner from "./Combiner.ts";
 /**
- * A `Reducer` is a `Combiner` with an `initialValue` and a way to
- * combine a whole collection. Think `Array.prototype.reduce`, but reusable.
+ * Represents a strategy for reducing a collection of values of type `A` into
+ * a single result.
+ *
+ * Extends {@link Combiner.Combiner} with:
+ * - `initialValue` – the identity/neutral element for `combine`.
+ * - `combineAll` – folds an entire `Iterable<A>` from `initialValue`.
+ *
+ * When to use:
+ * - 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.
+ *
+ * Many modules ship pre-built reducers:
+ * - `Number.ReducerSum`, `Number.ReducerMultiply`
+ * - `String.ReducerConcat`
+ * - `Boolean.ReducerAnd`, `Boolean.ReducerOr`
  *
- * Common initial values:
- * - numbers with addition: `0`
- * - strings with concatenation: `""`
- * - arrays with concatenation: `[]`
+ * **Example** (string concatenation reducer)
+ *
+ * ```ts
+ * import { Reducer } from "effect"
+ *
+ * const Concat = Reducer.make<string>((a, b) => a + b, "")
+ *
+ * console.log(Concat.combineAll(["hello", " ", "world"]))
+ * // Output: "hello world"
+ * ```
+ *
+ * @see {@link make} – create a `Reducer` from a function and initial value
+ * @see {@link Combiner.Combiner} – parent interface without `initialValue`
  *
  * @category model
  * @since 4.0.0
@@ -23,12 +113,81 @@ export interface Reducer<A> extends Combiner.Combiner<A> {
 /**
  * Creates a `Reducer` from a `combine` function and an `initialValue`.
  *
- * If `combineAll` is omitted, a default implementation reduces left-to-right.
+ * When to use:
+ * - 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).
+ *
+ * Behavior:
+ * - 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.
+ * - Pure – the returned reducer does not mutate its arguments.
+ *
+ * **Example** (multiplication with short-circuit)
+ *
+ * ```ts
+ * 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
+ * ```
+ *
+ * @see {@link Reducer} – the interface this creates
+ * @see {@link flip} – reverse the argument order
  *
  * @since 4.0.0
  */
 export declare function make<A>(combine: (self: A, that: A) => A, initialValue: A, combineAll?: (collection: Iterable<A>) => A): Reducer<A>;
 /**
+ * Reverses the argument order of a reducer's `combine` method.
+ *
+ * When to use:
+ * - You need the "right" value to act as the accumulator side.
+ * - You want to reverse the natural direction of a non-commutative reducer
+ *   (e.g. string concatenation becomes prepend).
+ *
+ * Behavior:
+ * - 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.
+ * - Does not mutate the input reducer.
+ *
+ * **Example** (reversing string concatenation)
+ *
+ * ```ts
+ * import { Reducer, String } from "effect"
+ *
+ * const Prepend = Reducer.flip(String.ReducerConcat)
+ *
+ * console.log(Prepend.combine("a", "b"))
+ * // Output: "ba"
+ *
+ * console.log(Prepend.combineAll(["a", "b", "c"]))
+ * // Output: "cba"
+ * ```
+ *
+ * @see {@link make}
+ * @see {@link Combiner.flip} – the same operation on a plain `Combiner`
+ *
  * @since 4.0.0
  */
 export declare function flip<A>(reducer: Reducer<A>): Reducer<A>;

package/dist/Reducer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Reducer.d.ts","sourceRoot":"","sources":["../src/Reducer.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,KAAK,QAAQ,MAAM,eAAe,CAAA;AAE9C;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,OAAO,CAAC,CAAC,CAAE,SAAQ,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC;IACtD,oEAAoE;IACpE,QAAQ,CAAC,YAAY,EAAE,CAAC,CAAA;IAExB,2EAA2E;IAC3E,QAAQ,CAAC,UAAU,EAAE,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAA;CACpD;AAED;;;;;;GAMG;AACH,wBAAgB,IAAI,CAAC,CAAC,EACpB,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,CAAC,EAChC,YAAY,EAAE,CAAC,EACf,UAAU,CAAC,EAAE,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,GAC1C,OAAO,CAAC,CAAC,CAAC,CAaZ;AAED;;GAEG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAEvD"}
+{"version":3,"file":"Reducer.d.ts","sourceRoot":"","sources":["../src/Reducer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AAEH,OAAO,KAAK,KAAK,QAAQ,MAAM,eAAe,CAAA;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,MAAM,WAAW,OAAO,CAAC,CAAC,CAAE,SAAQ,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC;IACtD,oEAAoE;IACpE,QAAQ,CAAC,YAAY,EAAE,CAAC,CAAA;IAExB,2EAA2E;IAC3E,QAAQ,CAAC,UAAU,EAAE,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAA;CACpD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAgB,IAAI,CAAC,CAAC,EACpB,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,CAAC,EAChC,YAAY,EAAE,CAAC,EACf,UAAU,CAAC,EAAE,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,GAC1C,OAAO,CAAC,CAAC,CAAC,CAaZ;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAEvD"}

package/dist/Reducer.js

@@ -1,10 +1,112 @@
 /**
+ * A module for reducing collections of values into a single result.
+ *
+ * A `Reducer<A>` extends {@link Combiner.Combiner} by adding an
+ * `initialValue` (identity element) and a `combineAll` method that folds an
+ * entire collection. Think `Array.prototype.reduce`, but packaged as a
+ * reusable, composable value.
+ *
+ * ## Mental model
+ *
+ * - **Reducer** – a {@link Combiner.Combiner} plus an `initialValue` and a
+ *   `combineAll` method.
+ * - **initialValue** – the neutral/identity element. Combining any value with
+ *   `initialValue` should return the original value unchanged (e.g. `0` for
+ *   addition, `""` for string concatenation).
+ * - **combineAll** – folds an `Iterable<A>` starting from `initialValue`.
+ *   When omitted from {@link make}, a default left-to-right fold is used.
+ * - **Purity** – all reducers produced by this module are pure; they never
+ *   mutate their arguments.
+ * - **Composability** – reducers can be lifted into `Option`, `Struct`,
+ *   `Tuple`, `Record`, and other container types via helpers in those modules.
+ * - **Subtype of Combiner** – every `Reducer` is also a valid
+ *   `Combiner`, so you can pass a `Reducer` anywhere a `Combiner` is
+ *   expected.
+ *
+ * ## Common tasks
+ *
+ * - Create a reducer from a combine function and initial value → {@link make}
+ * - Swap argument order → {@link flip}
+ * - Combine two values without an initial value → use {@link Combiner.Combiner}
+ *   instead
+ *
+ * ## Gotchas
+ *
+ * - `combineAll` on an empty iterable returns `initialValue`, not an error.
+ * - The default `combineAll` folds left-to-right. If your `combine` is not
+ *   associative, order matters. Pass a custom `combineAll` to {@link make} if
+ *   you need different traversal or short-circuiting.
+ * - A `Reducer` is also a valid `Combiner` — but a `Combiner` is *not* a
+ *   `Reducer` (it lacks `initialValue`).
+ *
+ * ## Quickstart
+ *
+ * **Example** (summing a list of numbers)
+ *
+ * ```ts
+ * import { Reducer } from "effect"
+ *
+ * const Sum = Reducer.make<number>((a, b) => a + b, 0)
+ *
+ * console.log(Sum.combine(3, 4))
+ * // Output: 7
+ *
+ * console.log(Sum.combineAll([1, 2, 3, 4]))
+ * // Output: 10
+ *
+ * console.log(Sum.combineAll([]))
+ * // Output: 0
+ * ```
+ *
+ * ## See also
+ *
+ * - {@link make} – the primary constructor
+ * - {@link Reducer} – the core interface
+ * - {@link Combiner.Combiner} – the parent interface (no `initialValue`)
+ *
  * @since 4.0.0
  */
 /**
  * Creates a `Reducer` from a `combine` function and an `initialValue`.
  *
- * If `combineAll` is omitted, a default implementation reduces left-to-right.
+ * When to use:
+ * - 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).
+ *
+ * Behavior:
+ * - 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.
+ * - Pure – the returned reducer does not mutate its arguments.
+ *
+ * **Example** (multiplication with short-circuit)
+ *
+ * ```ts
+ * 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
+ * ```
+ *
+ * @see {@link Reducer} – the interface this creates
+ * @see {@link flip} – reverse the argument order
  *
  * @since 4.0.0
  */
@@ -22,6 +124,38 @@ export function make(combine, initialValue, combineAll) {
   };
 }
 /**
+ * Reverses the argument order of a reducer's `combine` method.
+ *
+ * When to use:
+ * - You need the "right" value to act as the accumulator side.
+ * - You want to reverse the natural direction of a non-commutative reducer
+ *   (e.g. string concatenation becomes prepend).
+ *
+ * Behavior:
+ * - 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.
+ * - Does not mutate the input reducer.
+ *
+ * **Example** (reversing string concatenation)
+ *
+ * ```ts
+ * import { Reducer, String } from "effect"
+ *
+ * const Prepend = Reducer.flip(String.ReducerConcat)
+ *
+ * console.log(Prepend.combine("a", "b"))
+ * // Output: "ba"
+ *
+ * console.log(Prepend.combineAll(["a", "b", "c"]))
+ * // Output: "cba"
+ * ```
+ *
+ * @see {@link make}
+ * @see {@link Combiner.flip} – the same operation on a plain `Combiner`
+ *
  * @since 4.0.0
  */
 export function flip(reducer) {

package/dist/Reducer.js.map

@@ -1 +1 @@
-{"version":3,"file":"Reducer.js","names":["make","combine","initialValue","combineAll","collection","out","value","flip","reducer","self","that"],"sources":["../src/Reducer.ts"],"sourcesContent":[null],"mappings":"AAAA;;;AA0BA;;;;;;;AAOA,OAAM,SAAUA,IAAIA,CAClBC,OAAgC,EAChCC,YAAe,EACfC,UAA2C;EAE3C,OAAO;IACLF,OAAO;IACPC,YAAY;IACZC,UAAU,EAAEA,UAAU,KAClBC,UAAU,IAAI;MACd,IAAIC,GAAG,GAAGH,YAAY;MACtB,KAAK,MAAMI,KAAK,IAAIF,UAAU,EAAE;QAC9BC,GAAG,GAAGJ,OAAO,CAACI,GAAG,EAAEC,KAAK,CAAC;MAC3B;MACA,OAAOD,GAAG;IACZ,CAAC;GACJ;AACH;AAEA;;;AAGA,OAAM,SAAUE,IAAIA,CAAIC,OAAmB;EACzC,OAAOR,IAAI,CAAC,CAACS,IAAI,EAAEC,IAAI,KAAKF,OAAO,CAACP,OAAO,CAACS,IAAI,EAAED,IAAI,CAAC,EAAED,OAAO,CAACN,YAAY,CAAC;AAChF","ignoreList":[]}
+{"version":3,"file":"Reducer.js","names":["make","combine","initialValue","combineAll","collection","out","value","flip","reducer","self","that"],"sources":["../src/Reducer.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoHA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CA,OAAM,SAAUA,IAAIA,CAClBC,OAAgC,EAChCC,YAAe,EACfC,UAA2C;EAE3C,OAAO;IACLF,OAAO;IACPC,YAAY;IACZC,UAAU,EAAEA,UAAU,KAClBC,UAAU,IAAI;MACd,IAAIC,GAAG,GAAGH,YAAY;MACtB,KAAK,MAAMI,KAAK,IAAIF,UAAU,EAAE;QAC9BC,GAAG,GAAGJ,OAAO,CAACI,GAAG,EAAEC,KAAK,CAAC;MAC3B;MACA,OAAOD,GAAG;IACZ,CAAC;GACJ;AACH;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,OAAM,SAAUE,IAAIA,CAAIC,OAAmB;EACzC,OAAOR,IAAI,CAAC,CAACS,IAAI,EAAEC,IAAI,KAAKF,OAAO,CAACP,OAAO,CAACS,IAAI,EAAED,IAAI,CAAC,EAAED,OAAO,CAACN,YAAY,CAAC;AAChF","ignoreList":[]}