effect 4.0.0-beta.70 → 4.0.0-beta.72

package/dist/Clock.d.ts

@@ -65,6 +65,11 @@ import type { Effect } from "./Effect.ts";
  * Represents a time-based clock which provides functionality related to time
  * and scheduling.
  *
+ * **When to use**
+ *
+ * Use to define or provide a clock service for current-time and sleep
+ * operations.
+ *
  * **Example** (Reading current time)
  *
  * ```ts
@@ -84,28 +89,55 @@ import type { Effect } from "./Effect.ts";
  */
 export interface Clock {
     /**
-     * Unsafely returns the current time in milliseconds.
+     * Returns the current time in milliseconds unsafely.
+     *
+     * **When to use**
+     *
+     * Use to read millisecond time synchronously when you already have a `Clock`
+     * service and can accept non-effectful access.
      */
     currentTimeMillisUnsafe(): number;
     /**
      * Returns the current time in milliseconds.
+     *
+     * **When to use**
+     *
+     * Use to read millisecond time through this `Clock` service in `Effect`.
      */
     readonly currentTimeMillis: Effect<number>;
     /**
-     * Unsafely returns the current time in nanoseconds.
+     * Returns the current time in nanoseconds unsafely.
+     *
+     * **When to use**
+     *
+     * Use to read nanosecond time synchronously when you already have a `Clock`
+     * service and can accept non-effectful access.
      */
     currentTimeNanosUnsafe(): bigint;
     /**
      * Returns the current time in nanoseconds.
+     *
+     * **When to use**
+     *
+     * Use to read nanosecond time through this `Clock` service in `Effect`.
      */
     readonly currentTimeNanos: Effect<bigint>;
     /**
      * Asynchronously sleeps for the specified duration.
+     *
+     * **When to use**
+     *
+     * Use to delay an `Effect` workflow by a duration through this `Clock` service.
      */
     sleep(duration: Duration.Duration): Effect<void>;
 }
 /**
- * A reference to the current Clock service in the environment.
+ * Context reference for the current Clock service in the environment.
+ *
+ * **When to use**
+ *
+ * Use when you need to access or provide the full Clock service rather than a
+ * single timestamp accessor.
  *
  * **Example** (Accessing the Clock service)
  *
@@ -118,6 +150,10 @@ export interface Clock {
  * })
  * ```
  *
+ * @see {@link clockWith} for using the current Clock service inside an effect
+ * @see {@link currentTimeMillis} for reading the current time in milliseconds
+ * @see {@link currentTimeNanos} for reading the current time in nanoseconds
+ *
  * @category references
  * @since 2.0.0
  */
@@ -125,6 +161,11 @@ export declare const Clock: Context.Reference<Clock>;
 /**
  * Accesses the current Clock service and uses it to run the provided function.
  *
+ * **When to use**
+ *
+ * Use when you need the full Clock service interface to perform multiple time
+ * operations or call unsafe variants within a single effect.
+ *
  * **Example** (Using the current Clock service)
  *
  * ```ts
@@ -139,6 +180,9 @@ export declare const Clock: Context.Reference<Clock>;
  * )
  * ```
  *
+ * @see {@link Clock} for the service reference
+ * @see {@link currentTimeMillis} for convenience accessor that returns milliseconds
+ * @see {@link currentTimeNanos} for convenience accessor that returns nanoseconds
  * @category constructors
  * @since 2.0.0
  */
@@ -146,6 +190,11 @@ export declare const clockWith: <A, E, R>(f: (clock: Clock) => Effect<A, E, R>)
 /**
  * Returns an Effect that succeeds with the current time in milliseconds.
  *
+ * **When to use**
+ *
+ * Use to read wall-clock time from the active Clock service with millisecond
+ * precision.
+ *
  * **Example** (Reading milliseconds)
  *
  * ```ts
@@ -158,6 +207,9 @@ export declare const clockWith: <A, E, R>(f: (clock: Clock) => Effect<A, E, R>)
  * })
  * ```
  *
+ * @see {@link currentTimeNanos} for nanosecond precision
+ * @see {@link clockWith} for accessing the full Clock service
+ *
  * @category constructors
  * @since 2.0.0
  */
@@ -165,6 +217,11 @@ export declare const currentTimeMillis: Effect<number>;
 /**
  * Returns an Effect that succeeds with the current time in nanoseconds.
  *
+ * **When to use**
+ *
+ * Use to read wall-clock time from the active `Clock` service with nanosecond
+ * precision.
+ *
  * **Example** (Reading nanoseconds)
  *
  * ```ts

package/dist/Clock.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Clock.d.ts","sourceRoot":"","sources":["../src/Clock.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH,OAAO,KAAK,KAAK,OAAO,MAAM,cAAc,CAAA;AAC5C,OAAO,KAAK,KAAK,QAAQ,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAGzC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,KAAK;IACpB;;OAEG;IACH,uBAAuB,IAAI,MAAM,CAAA;IACjC;;OAEG;IACH,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC,MAAM,CAAC,CAAA;IAC1C;;OAEG;IACH,sBAAsB,IAAI,MAAM,CAAA;IAChC;;OAEG;IACH,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC,MAAM,CAAC,CAAA;IACzC;;OAEG;IACH,KAAK,CAAC,QAAQ,EAAE,QAAQ,CAAC,QAAQ,GAAG,MAAM,CAAC,IAAI,CAAC,CAAA;CACjD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,KAAK,EAAE,OAAO,CAAC,SAAS,CAAC,KAAK,CAAmB,CAAA;AAE9D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAoB,CAAA;AAE7G;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,CAA4B,CAAA;AAEzE;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,CAA2B,CAAA"}
+{"version":3,"file":"Clock.d.ts","sourceRoot":"","sources":["../src/Clock.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH,OAAO,KAAK,KAAK,OAAO,MAAM,cAAc,CAAA;AAC5C,OAAO,KAAK,KAAK,QAAQ,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAGzC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,WAAW,KAAK;IACpB;;;;;;;OAOG;IACH,uBAAuB,IAAI,MAAM,CAAA;IACjC;;;;;;OAMG;IACH,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC,MAAM,CAAC,CAAA;IAC1C;;;;;;;OAOG;IACH,sBAAsB,IAAI,MAAM,CAAA;IAChC;;;;;;OAMG;IACH,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC,MAAM,CAAC,CAAA;IACzC;;;;;;OAMG;IACH,KAAK,CAAC,QAAQ,EAAE,QAAQ,CAAC,QAAQ,GAAG,MAAM,CAAC,IAAI,CAAC,CAAA;CACjD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,KAAK,EAAE,OAAO,CAAC,SAAS,CAAC,KAAK,CAAmB,CAAA;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAoB,CAAA;AAE7G;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,CAA4B,CAAA;AAEzE;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,CAA2B,CAAA"}

package/dist/Clock.js

@@ -1,6 +1,11 @@
 import * as effect from "./internal/effect.js";
 /**
- * A reference to the current Clock service in the environment.
+ * Context reference for the current Clock service in the environment.
+ *
+ * **When to use**
+ *
+ * Use when you need to access or provide the full Clock service rather than a
+ * single timestamp accessor.
  *
  * **Example** (Accessing the Clock service)
  *
@@ -13,6 +18,10 @@ import * as effect from "./internal/effect.js";
  * })
  * ```
  *
+ * @see {@link clockWith} for using the current Clock service inside an effect
+ * @see {@link currentTimeMillis} for reading the current time in milliseconds
+ * @see {@link currentTimeNanos} for reading the current time in nanoseconds
+ *
  * @category references
  * @since 2.0.0
  */
@@ -20,6 +29,11 @@ export const Clock = effect.ClockRef;
 /**
  * Accesses the current Clock service and uses it to run the provided function.
  *
+ * **When to use**
+ *
+ * Use when you need the full Clock service interface to perform multiple time
+ * operations or call unsafe variants within a single effect.
+ *
  * **Example** (Using the current Clock service)
  *
  * ```ts
@@ -34,6 +48,9 @@ export const Clock = effect.ClockRef;
  * )
  * ```
  *
+ * @see {@link Clock} for the service reference
+ * @see {@link currentTimeMillis} for convenience accessor that returns milliseconds
+ * @see {@link currentTimeNanos} for convenience accessor that returns nanoseconds
  * @category constructors
  * @since 2.0.0
  */
@@ -41,6 +58,11 @@ export const clockWith = effect.clockWith;
 /**
  * Returns an Effect that succeeds with the current time in milliseconds.
  *
+ * **When to use**
+ *
+ * Use to read wall-clock time from the active Clock service with millisecond
+ * precision.
+ *
  * **Example** (Reading milliseconds)
  *
  * ```ts
@@ -53,6 +75,9 @@ export const clockWith = effect.clockWith;
  * })
  * ```
  *
+ * @see {@link currentTimeNanos} for nanosecond precision
+ * @see {@link clockWith} for accessing the full Clock service
+ *
  * @category constructors
  * @since 2.0.0
  */
@@ -60,6 +85,11 @@ export const currentTimeMillis = effect.currentTimeMillis;
 /**
  * Returns an Effect that succeeds with the current time in nanoseconds.
  *
+ * **When to use**
+ *
+ * Use to read wall-clock time from the active `Clock` service with nanosecond
+ * precision.
+ *
  * **Example** (Reading nanoseconds)
  *
  * ```ts

package/dist/Clock.js.map

@@ -1 +1 @@
-{"version":3,"file":"Clock.js","names":["effect","Clock","ClockRef","clockWith","currentTimeMillis","currentTimeNanos"],"sources":["../src/Clock.ts"],"sourcesContent":[null],"mappings":"AA+DA,OAAO,KAAKA,MAAM,MAAM,sBAAsB;AA8C9C;;;;;;;;;;;;;;;;;AAiBA,OAAO,MAAMC,KAAK,GAA6BD,MAAM,CAACE,QAAQ;AAE9D;;;;;;;;;;;;;;;;;;;;AAoBA,OAAO,MAAMC,SAAS,GAAuEH,MAAM,CAACG,SAAS;AAE7G;;;;;;;;;;;;;;;;;;AAkBA,OAAO,MAAMC,iBAAiB,GAAmBJ,MAAM,CAACI,iBAAiB;AAEzE;;;;;;;;;;;;;;;;;;AAkBA,OAAO,MAAMC,gBAAgB,GAAmBL,MAAM,CAACK,gBAAgB","ignoreList":[]}
+{"version":3,"file":"Clock.js","names":["effect","Clock","ClockRef","clockWith","currentTimeMillis","currentTimeNanos"],"sources":["../src/Clock.ts"],"sourcesContent":[null],"mappings":"AA+DA,OAAO,KAAKA,MAAM,MAAM,sBAAsB;AAyE9C;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,OAAO,MAAMC,KAAK,GAA6BD,MAAM,CAACE,QAAQ;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,OAAO,MAAMC,SAAS,GAAuEH,MAAM,CAACG,SAAS;AAE7G;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,OAAO,MAAMC,iBAAiB,GAAmBJ,MAAM,CAACI,iBAAiB;AAEzE;;;;;;;;;;;;;;;;;;;;;;;AAuBA,OAAO,MAAMC,gBAAgB,GAAmBL,MAAM,CAACK,gBAAgB","ignoreList":[]}

package/dist/Combiner.d.ts

@@ -3,7 +3,7 @@
  *
  * A `Combiner<A>` wraps a single binary function `(self: A, that: A) => A`.
  * It describes *how* two values merge but carries no initial/empty value
- * (for that, see {@link Reducer} which extends `Combiner` with an
+ * (for that, see `Reducer` which extends `Combiner` with an
  * `initialValue`).
  *
  * ## Mental model
@@ -13,7 +13,7 @@
  * - **Argument order** – `self` is the "left" / accumulator side, `that` is
  *   the "right" / incoming side.
  * - **No identity element** – unlike a monoid, a `Combiner` does not require
- *   a neutral element. Use {@link Reducer} when you need one.
+ *   a neutral element. Use `Reducer` when you need one.
  * - **Purity** – all combiners produced by this module are pure; they never
  *   mutate their arguments.
  * - **Composability** – combiners can be lifted into `Option`, `Struct`,
@@ -69,7 +69,7 @@ import type * as Order from "./Order.ts";
  *
  * **When to use**
  *
- * Use `Combiner` when you need to describe how two values of the same type
+ * Use when you need to describe how two values of the same type
  * merge, pass a reusable combining strategy to library functions like
  * `Struct.makeCombiner` or `Option.makeCombinerFailFast`, or define the
  * combining step for a `Reducer`.
@@ -92,6 +92,10 @@ import type * as Order from "./Order.ts";
 export interface Combiner<A> {
     /**
      * Combines two values into a new value.
+     *
+     * **When to use**
+     *
+     * Use to merge two values according to this combining strategy.
      */
     readonly combine: (self: A, that: A) => A;
 }
@@ -100,7 +104,7 @@ export interface Combiner<A> {
  *
  * **When to use**
  *
- * Use this when you have a custom combining operation that is not covered by
+ * Use when you have a custom combining operation that is not covered by
  * the built-in constructors (`min`, `max`, `first`, `last`, `constant`).
  *
  * **Details**
@@ -129,14 +133,14 @@ export declare function make<A>(combine: (self: A, that: A) => A): Combiner<A>;
  *
  * **When to use**
  *
- * Use this when the "right" value should act as the accumulator side, or when
+ * Use when the "right" value should act as the accumulator side, or when
  * you want to reverse the natural direction of a non-commutative combiner such
  * as string concatenation.
  *
  * **Details**
  *
  * Returns a new `Combiner` where `combine(self, that)` calls the original
- * combiner as `combine(that, self)`. The input combiner is not mutated.
+ * combiner as `combine(that, self)`.
  *
  * **Example** (reversing string concatenation)
  *
@@ -160,13 +164,13 @@ export declare function flip<A>(combiner: Combiner<A>): Combiner<A>;
  *
  * **When to use**
  *
- * Use this when you want to accumulate the minimum value across a collection or
+ * Use when you want to accumulate the minimum value across a collection or
  * build a `Reducer` that tracks the running minimum.
  *
  * **Details**
  *
  * The combiner compares values using the given `Order`. When values are equal,
- * it returns `that` (the second argument). It does not mutate either argument.
+ * it returns `that` (the second argument).
  *
  * **Example** (minimum of two numbers)
  *
@@ -193,13 +197,13 @@ export declare function min<A>(order: Order.Order<A>): Combiner<A>;
  *
  * **When to use**
  *
- * Use this when you want to accumulate the maximum value across a collection or
+ * Use when you want to accumulate the maximum value across a collection or
  * build a `Reducer` that tracks the running maximum.
  *
  * **Details**
  *
  * The combiner compares values using the given `Order`. When values are equal,
- * it returns `that` (the second argument). It does not mutate either argument.
+ * it returns `that` (the second argument).
  *
  * **Example** (maximum of two numbers)
  *
@@ -225,13 +229,12 @@ export declare function max<A>(order: Order.Order<A>): Combiner<A>;
  *
  * **When to use**
  *
- * Use this when you want "first write wins" semantics while merging values, or
+ * Use when you want "first write wins" semantics while merging values, or
  * when the combining logic should keep the existing value.
  *
  * **Details**
  *
- * `combine(self, that)` returns `self` and ignores `that`. The second argument
- * is discarded, not mutated.
+ * `combine(self, that)` returns `self` and ignores `that`.
  *
  * **Example** (keeping the first value)
  *
@@ -254,13 +257,12 @@ export declare function first<A>(): Combiner<A>;
  *
  * **When to use**
  *
- * Use this when you want "last write wins" semantics while merging values, or
+ * Use when you want "last write wins" semantics while merging values, or
  * when each new value should replace the accumulator.
  *
  * **Details**
  *
- * `combine(self, that)` returns `that` and ignores `self`. The first argument
- * is discarded, not mutated.
+ * `combine(self, that)` returns `that` and ignores `self`.
  *
  * **Example** (keeping the last value)
  *
@@ -284,14 +286,13 @@ export declare function last<A>(): Combiner<A>;
  *
  * **When to use**
  *
- * Use this when a combiner should produce a fixed result regardless of input,
+ * Use when a combiner should produce a fixed result regardless of input,
  * or when a generic API needs a combiner but the combined value is
  * predetermined.
  *
  * **Details**
  *
  * `combine(self, that)` returns the constant `a` and ignores both arguments.
- * No mutation occurs.
  *
  * **Example** (always returning zero)
  *
@@ -316,7 +317,7 @@ export declare function constant<A>(a: A): Combiner<A>;
  *
  * **When to use**
  *
- * Use this when you are building delimited strings (CSV, paths, etc.) by
+ * Use when you are building delimited strings (CSV, paths, etc.) by
  * repeated combination, or when you need to inject a fixed separator between
  * accumulated values.
  *
@@ -324,8 +325,7 @@ export declare function constant<A>(a: A): Combiner<A>;
  *
  * `intercalate(middle)(combiner).combine(self, that)` is equivalent to
  * `combiner.combine(self, combiner.combine(middle, that))`. This function is
- * curried: first provide the separator, then the base combiner. It returns a
- * new combiner and does not mutate the input combiner.
+ * curried: first provide the separator, then the base combiner.
  *
  * **Example** (joining strings with a separator)
  *

package/dist/Combiner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Combiner.d.ts","sourceRoot":"","sources":["../src/Combiner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH,OAAO,KAAK,KAAK,KAAK,MAAM,YAAY,CAAA;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,WAAW,QAAQ,CAAC,CAAC;IACzB;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,CAAC,CAAA;CAC1C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAErE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAE1D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAEzD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAEzD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,KAAK,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAEtC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,IAAI,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAErC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAE7C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,IAC9B,UAAU,QAAQ,CAAC,CAAC,CAAC,KAAG,QAAQ,CAAC,CAAC,CAAC,CAE5C"}
+{"version":3,"file":"Combiner.d.ts","sourceRoot":"","sources":["../src/Combiner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH,OAAO,KAAK,KAAK,KAAK,MAAM,YAAY,CAAA;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,WAAW,QAAQ,CAAC,CAAC;IACzB;;;;;;OAMG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,CAAC,CAAA;CAC1C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAErE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAE1D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAEzD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAEzD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,KAAK,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAEtC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,IAAI,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAErC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAE7C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,IAC9B,UAAU,QAAQ,CAAC,CAAC,CAAC,KAAG,QAAQ,CAAC,CAAC,CAAC,CAE5C"}

package/dist/Combiner.js

@@ -3,7 +3,7 @@
  *
  * **When to use**
  *
- * Use this when you have a custom combining operation that is not covered by
+ * Use when you have a custom combining operation that is not covered by
  * the built-in constructors (`min`, `max`, `first`, `last`, `constant`).
  *
  * **Details**
@@ -36,14 +36,14 @@ export function make(combine) {
  *
  * **When to use**
  *
- * Use this when the "right" value should act as the accumulator side, or when
+ * Use when the "right" value should act as the accumulator side, or when
  * you want to reverse the natural direction of a non-commutative combiner such
  * as string concatenation.
  *
  * **Details**
  *
  * Returns a new `Combiner` where `combine(self, that)` calls the original
- * combiner as `combine(that, self)`. The input combiner is not mutated.
+ * combiner as `combine(that, self)`.
  *
  * **Example** (reversing string concatenation)
  *
@@ -69,13 +69,13 @@ export function flip(combiner) {
  *
  * **When to use**
  *
- * Use this when you want to accumulate the minimum value across a collection or
+ * Use when you want to accumulate the minimum value across a collection or
  * build a `Reducer` that tracks the running minimum.
  *
  * **Details**
  *
  * The combiner compares values using the given `Order`. When values are equal,
- * it returns `that` (the second argument). It does not mutate either argument.
+ * it returns `that` (the second argument).
  *
  * **Example** (minimum of two numbers)
  *
@@ -104,13 +104,13 @@ export function min(order) {
  *
  * **When to use**
  *
- * Use this when you want to accumulate the maximum value across a collection or
+ * Use when you want to accumulate the maximum value across a collection or
  * build a `Reducer` that tracks the running maximum.
  *
  * **Details**
  *
  * The combiner compares values using the given `Order`. When values are equal,
- * it returns `that` (the second argument). It does not mutate either argument.
+ * it returns `that` (the second argument).
  *
  * **Example** (maximum of two numbers)
  *
@@ -138,13 +138,12 @@ export function max(order) {
  *
  * **When to use**
  *
- * Use this when you want "first write wins" semantics while merging values, or
+ * Use when you want "first write wins" semantics while merging values, or
  * when the combining logic should keep the existing value.
  *
  * **Details**
  *
- * `combine(self, that)` returns `self` and ignores `that`. The second argument
- * is discarded, not mutated.
+ * `combine(self, that)` returns `self` and ignores `that`.
  *
  * **Example** (keeping the first value)
  *
@@ -169,13 +168,12 @@ export function first() {
  *
  * **When to use**
  *
- * Use this when you want "last write wins" semantics while merging values, or
+ * Use when you want "last write wins" semantics while merging values, or
  * when each new value should replace the accumulator.
  *
  * **Details**
  *
- * `combine(self, that)` returns `that` and ignores `self`. The first argument
- * is discarded, not mutated.
+ * `combine(self, that)` returns `that` and ignores `self`.
  *
  * **Example** (keeping the last value)
  *
@@ -201,14 +199,13 @@ export function last() {
  *
  * **When to use**
  *
- * Use this when a combiner should produce a fixed result regardless of input,
+ * Use when a combiner should produce a fixed result regardless of input,
  * or when a generic API needs a combiner but the combined value is
  * predetermined.
  *
  * **Details**
  *
  * `combine(self, that)` returns the constant `a` and ignores both arguments.
- * No mutation occurs.
  *
  * **Example** (always returning zero)
  *
@@ -235,7 +232,7 @@ export function constant(a) {
  *
  * **When to use**
  *
- * Use this when you are building delimited strings (CSV, paths, etc.) by
+ * Use when you are building delimited strings (CSV, paths, etc.) by
  * repeated combination, or when you need to inject a fixed separator between
  * accumulated values.
  *
@@ -243,8 +240,7 @@ export function constant(a) {
  *
  * `intercalate(middle)(combiner).combine(self, that)` is equivalent to
  * `combiner.combine(self, combiner.combine(middle, that))`. This function is
- * curried: first provide the separator, then the base combiner. It returns a
- * new combiner and does not mutate the input combiner.
+ * curried: first provide the separator, then the base combiner.
  *
  * **Example** (joining strings with a separator)
  *

package/dist/Combiner.js.map

@@ -1 +1 @@
-{"version":3,"file":"Combiner.js","names":["make","combine","flip","combiner","self","that","min","order","max","first","_","last","constant","a","intercalate","middle"],"sources":["../src/Combiner.ts"],"sourcesContent":[null],"mappings":"AAmGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,OAAM,SAAUA,IAAIA,CAAIC,OAAgC;EACtD,OAAO;IAAEA;EAAO,CAAE;AACpB;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,OAAM,SAAUC,IAAIA,CAAIC,QAAqB;EAC3C,OAAOH,IAAI,CAAC,CAACI,IAAI,EAAEC,IAAI,KAAKF,QAAQ,CAACF,OAAO,CAACI,IAAI,EAAED,IAAI,CAAC,CAAC;AAC3D;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,OAAM,SAAUE,GAAGA,CAAIC,KAAqB;EAC1C,OAAOP,IAAI,CAAC,CAACI,IAAI,EAAEC,IAAI,KAAKE,KAAK,CAACH,IAAI,EAAEC,IAAI,CAAC,KAAK,CAAC,CAAC,GAAGD,IAAI,GAAGC,IAAI,CAAC;AACrE;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,OAAM,SAAUG,GAAGA,CAAID,KAAqB;EAC1C,OAAOP,IAAI,CAAC,CAACI,IAAI,EAAEC,IAAI,KAAKE,KAAK,CAACH,IAAI,EAAEC,IAAI,CAAC,KAAK,CAAC,GAAGD,IAAI,GAAGC,IAAI,CAAC;AACpE;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,OAAM,SAAUI,KAAKA,CAAA;EACnB,OAAOT,IAAI,CAAC,CAACI,IAAI,EAAEM,CAAC,KAAKN,IAAI,CAAC;AAChC;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,OAAM,SAAUO,IAAIA,CAAA;EAClB,OAAOX,IAAI,CAAC,CAACU,CAAC,EAAEL,IAAI,KAAKA,IAAI,CAAC;AAChC;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,OAAM,SAAUO,QAAQA,CAAIC,CAAI;EAC9B,OAAOb,IAAI,CAAC,MAAMa,CAAC,CAAC;AACtB;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,OAAM,SAAUC,WAAWA,CAAIC,MAAS;EACtC,OAAQZ,QAAqB,IAC3BH,IAAI,CAAC,CAACI,IAAI,EAAEC,IAAI,KAAKF,QAAQ,CAACF,OAAO,CAACG,IAAI,EAAED,QAAQ,CAACF,OAAO,CAACc,MAAM,EAAEV,IAAI,CAAC,CAAC,CAAC;AAChF","ignoreList":[]}
+{"version":3,"file":"Combiner.js","names":["make","combine","flip","combiner","self","that","min","order","max","first","_","last","constant","a","intercalate","middle"],"sources":["../src/Combiner.ts"],"sourcesContent":[null],"mappings":"AAuGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,OAAM,SAAUA,IAAIA,CAAIC,OAAgC;EACtD,OAAO;IAAEA;EAAO,CAAE;AACpB;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,OAAM,SAAUC,IAAIA,CAAIC,QAAqB;EAC3C,OAAOH,IAAI,CAAC,CAACI,IAAI,EAAEC,IAAI,KAAKF,QAAQ,CAACF,OAAO,CAACI,IAAI,EAAED,IAAI,CAAC,CAAC;AAC3D;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,OAAM,SAAUE,GAAGA,CAAIC,KAAqB;EAC1C,OAAOP,IAAI,CAAC,CAACI,IAAI,EAAEC,IAAI,KAAKE,KAAK,CAACH,IAAI,EAAEC,IAAI,CAAC,KAAK,CAAC,CAAC,GAAGD,IAAI,GAAGC,IAAI,CAAC;AACrE;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,OAAM,SAAUG,GAAGA,CAAID,KAAqB;EAC1C,OAAOP,IAAI,CAAC,CAACI,IAAI,EAAEC,IAAI,KAAKE,KAAK,CAACH,IAAI,EAAEC,IAAI,CAAC,KAAK,CAAC,GAAGD,IAAI,GAAGC,IAAI,CAAC;AACpE;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,OAAM,SAAUI,KAAKA,CAAA;EACnB,OAAOT,IAAI,CAAC,CAACI,IAAI,EAAEM,CAAC,KAAKN,IAAI,CAAC;AAChC;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,OAAM,SAAUO,IAAIA,CAAA;EAClB,OAAOX,IAAI,CAAC,CAACU,CAAC,EAAEL,IAAI,KAAKA,IAAI,CAAC;AAChC;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,OAAM,SAAUO,QAAQA,CAAIC,CAAI;EAC9B,OAAOb,IAAI,CAAC,MAAMa,CAAC,CAAC;AACtB;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,OAAM,SAAUC,WAAWA,CAAIC,MAAS;EACtC,OAAQZ,QAAqB,IAC3BH,IAAI,CAAC,CAACI,IAAI,EAAEC,IAAI,KAAKF,QAAQ,CAACF,OAAO,CAACG,IAAI,EAAED,QAAQ,CAACF,OAAO,CAACc,MAAM,EAAEV,IAAI,CAAC,CAAC,CAAC;AAChF","ignoreList":[]}