effect 4.0.0-beta.0 → 4.0.0-beta.10

package/dist/Combiner.d.ts

@@ -1,15 +1,91 @@
 /**
+ * A module for combining two values of the same type into one.
+ *
+ * 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
+ * `initialValue`).
+ *
+ * ## Mental model
+ *
+ * - **Combiner** – an object with a `combine(self, that)` method that returns
+ *   a value of the same type.
+ * - **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.
+ * - **Purity** – all combiners produced by this module are pure; they never
+ *   mutate their arguments.
+ * - **Composability** – combiners can be lifted into `Option`, `Struct`,
+ *   `Tuple`, and other container types via helpers in those modules.
+ *
+ * ## Common tasks
+ *
+ * - Create a combiner from any binary function → {@link make}
+ * - Swap argument order → {@link flip}
+ * - Pick the smaller / larger of two values → {@link min} / {@link max}
+ * - Always keep the first or last value → {@link first} / {@link last}
+ * - Ignore both values and return a fixed result → {@link constant}
+ * - Insert a separator between combined values → {@link intercalate}
+ *
+ * ## Gotchas
+ *
+ * - `min` and `max` require an `Order<A>`, not a raw comparator. Import from
+ *   e.g. `Number.Order` or `String.Order`.
+ * - `intercalate` is curried: call it with the separator first, then pass the
+ *   base combiner.
+ * - A `Reducer` (which adds `initialValue`) is also a valid `Combiner` — you
+ *   can pass a `Reducer` anywhere a `Combiner` is expected.
+ *
+ * ## Quickstart
+ *
+ * **Example** (combining strings with a separator)
+ *
+ * ```ts
+ * import { Combiner, String } from "effect"
+ *
+ * const csv = Combiner.intercalate(",")(String.ReducerConcat)
+ *
+ * console.log(csv.combine("a", "b"))
+ * // Output: "a,b"
+ *
+ * console.log(csv.combine(csv.combine("a", "b"), "c"))
+ * // Output: "a,b,c"
+ * ```
+ *
+ * ## See also
+ *
+ * - {@link make} – the primary constructor
+ * - {@link Combiner} – the core interface
+ *
  * @since 4.0.0
  */
 import type * as Order from "./Order.ts";
 /**
- * A `Combiner` represents any type of value that can be combined
- * with another value of the same type to produce a new value.
+ * Represents a strategy for combining two values of the same type `A`.
+ *
+ * A `Combiner` contains a single `combine` method that takes two values and
+ * returns a merged result. It does not include an identity/empty value; use
+ * `Reducer` when you need one.
+ *
+ * When to use:
+ * - You need to describe how two values of the same type merge.
+ * - You want to pass a reusable combining strategy to library functions like
+ *   `Struct.makeCombiner` or `Option.makeCombinerFailFast`.
+ * - You are building a `Reducer` and need to define the combining step first.
+ *
+ * **Example** (number addition combiner)
+ *
+ * ```ts
+ * import { Combiner } from "effect"
+ *
+ * const Sum = Combiner.make<number>((self, that) => self + that)
  *
- * Examples:
- * - numbers with addition
- * - strings with concatenation
- * - arrays with merging
+ * console.log(Sum.combine(3, 4))
+ * // Output: 7
+ * ```
+ *
+ * @see {@link make} – create a `Combiner` from a function
  *
  * @category model
  * @since 4.0.0
@@ -21,47 +97,238 @@ export interface Combiner<A> {
     readonly combine: (self: A, that: A) => A;
 }
 /**
- * Creates a `Combiner` from a `combine` function.
+ * Creates a `Combiner` from a binary function.
+ *
+ * When to use:
+ * - You have a custom combining operation that is not covered by the built-in
+ *   constructors (`min`, `max`, `first`, `last`, `constant`).
+ *
+ * Behavior:
+ * - Returns a new `Combiner` whose `combine` method delegates to the provided
+ *   function.
+ * - Pure – the returned combiner does not mutate its arguments.
+ *
+ * **Example** (multiplying numbers)
+ *
+ * ```ts
+ * import { Combiner } from "effect"
+ *
+ * const Product = Combiner.make<number>((self, that) => self * that)
+ *
+ * console.log(Product.combine(3, 5))
+ * // Output: 15
+ * ```
+ *
+ * @see {@link Combiner} – the interface this creates
  *
  * @since 4.0.0
  */
 export declare function make<A>(combine: (self: A, that: A) => A): Combiner<A>;
 /**
+ * Reverses the argument order of a combiner'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 combiner
+ *   (e.g. string concatenation).
+ *
+ * Behavior:
+ * - Returns a new `Combiner` where `combine(self, that)` calls the original
+ *   combiner as `combine(that, self)`.
+ * - Does not mutate the input combiner.
+ *
+ * **Example** (reversing string concatenation)
+ *
+ * ```ts
+ * import { Combiner, String } from "effect"
+ *
+ * const Prepend = Combiner.flip(String.ReducerConcat)
+ *
+ * console.log(Prepend.combine("a", "b"))
+ * // Output: "ba"
+ * ```
+ *
+ * @see {@link make}
+ *
  * @since 4.0.0
  */
 export declare function flip<A>(combiner: Combiner<A>): Combiner<A>;
 /**
- * Creates a `Combiner` that returns the smaller of two values.
+ * Creates a `Combiner` that returns the smaller of two values according to
+ * the provided `Order`.
+ *
+ * When to use:
+ * - You want to accumulate the minimum value across a collection.
+ * - You are building a `Reducer` that tracks the running minimum.
+ *
+ * Behavior:
+ * - Compares using the given `Order`. When values are equal, returns `that`
+ *   (the second argument).
+ * - Pure – does not mutate either argument.
+ *
+ * **Example** (minimum of two numbers)
+ *
+ * ```ts
+ * import { Combiner, Number } from "effect"
+ *
+ * const Min = Combiner.min(Number.Order)
+ *
+ * console.log(Min.combine(3, 1))
+ * // Output: 1
+ *
+ * console.log(Min.combine(1, 3))
+ * // Output: 1
+ * ```
+ *
+ * @see {@link max}
  *
  * @since 4.0.0
  */
 export declare function min<A>(order: Order.Order<A>): Combiner<A>;
 /**
- * Creates a `Combiner` that returns the larger of two values.
+ * Creates a `Combiner` that returns the larger of two values according to
+ * the provided `Order`.
+ *
+ * When to use:
+ * - You want to accumulate the maximum value across a collection.
+ * - You are building a `Reducer` that tracks the running maximum.
+ *
+ * Behavior:
+ * - Compares using the given `Order`. When values are equal, returns `that`
+ *   (the second argument).
+ * - Pure – does not mutate either argument.
+ *
+ * **Example** (maximum of two numbers)
+ *
+ * ```ts
+ * import { Combiner, Number } from "effect"
+ *
+ * const Max = Combiner.max(Number.Order)
+ *
+ * console.log(Max.combine(3, 1))
+ * // Output: 3
+ *
+ * console.log(Max.combine(1, 3))
+ * // Output: 3
+ * ```
+ *
+ * @see {@link min}
  *
  * @since 4.0.0
  */
 export declare function max<A>(order: Order.Order<A>): Combiner<A>;
 /**
- * Creates a `Combiner` that returns the first value.
+ * Creates a `Combiner` that always returns the first (left) argument.
+ *
+ * When to use:
+ * - You want "first write wins" semantics when merging values.
+ * - You need a combiner but the combining logic should be a no-op that keeps
+ *   the existing value.
+ *
+ * Behavior:
+ * - `combine(self, that)` returns `self`, ignoring `that`.
+ * - Pure – the second argument is discarded, not mutated.
+ *
+ * **Example** (keeping the first value)
+ *
+ * ```ts
+ * import { Combiner } from "effect"
+ *
+ * const First = Combiner.first<number>()
+ *
+ * console.log(First.combine(1, 2))
+ * // Output: 1
+ * ```
+ *
+ * @see {@link last}
  *
  * @since 4.0.0
  */
 export declare function first<A>(): Combiner<A>;
 /**
- * Creates a `Combiner` that returns the last value.
+ * Creates a `Combiner` that always returns the last (right) argument.
+ *
+ * When to use:
+ * - You want "last write wins" semantics when merging values.
+ * - You need a combiner that replaces the accumulator with each new value.
+ *
+ * Behavior:
+ * - `combine(self, that)` returns `that`, ignoring `self`.
+ * - Pure – the first argument is discarded, not mutated.
+ *
+ * **Example** (keeping the last value)
+ *
+ * ```ts
+ * import { Combiner } from "effect"
+ *
+ * const Last = Combiner.last<number>()
+ *
+ * console.log(Last.combine(1, 2))
+ * // Output: 2
+ * ```
+ *
+ * @see {@link first}
  *
  * @since 4.0.0
  */
 export declare function last<A>(): Combiner<A>;
 /**
- * Creates a `Combiner` that returns a constant value.
+ * Creates a `Combiner` that ignores both arguments and always returns the
+ * given constant value.
+ *
+ * When to use:
+ * - You need a combiner that produces a fixed result regardless of input.
+ * - You are providing a combiner to a generic API but the combined value is
+ *   predetermined.
+ *
+ * Behavior:
+ * - `combine(self, that)` returns the constant `a`, ignoring both arguments.
+ * - Pure – no mutation occurs.
+ *
+ * **Example** (always returning zero)
+ *
+ * ```ts
+ * import { Combiner } from "effect"
+ *
+ * const Zero = Combiner.constant(0)
+ *
+ * console.log(Zero.combine(42, 99))
+ * // Output: 0
+ * ```
+ *
+ * @see {@link first}
+ * @see {@link last}
  *
  * @since 4.0.0
  */
 export declare function constant<A>(a: A): Combiner<A>;
 /**
- * Between each pair of elements insert `middle`.
+ * Wraps a `Combiner` so that a separator value is inserted between every
+ * pair of combined elements.
+ *
+ * When to use:
+ * - You are building delimited strings (CSV, paths, etc.) by repeated
+ *   combination.
+ * - You need to inject a fixed separator between accumulated values.
+ *
+ * Behavior:
+ * - `intercalate(middle)(combiner).combine(self, that)` is equivalent to
+ *   `combiner.combine(self, combiner.combine(middle, that))`.
+ * - Curried: first provide the separator, then the base combiner.
+ * - Does not mutate the input combiner; returns a new one.
+ *
+ * **Example** (joining strings with a separator)
+ *
+ * ```ts
+ * import { Combiner, String } from "effect"
+ *
+ * const commaSep = Combiner.intercalate(",")(String.ReducerConcat)
+ *
+ * console.log(commaSep.combine("a", "b"))
+ * // Output: "a,b"
+ * ```
+ *
+ * @see {@link make}
  *
  * @since 4.0.0
  */

package/dist/Combiner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Combiner.d.ts","sourceRoot":"","sources":["../src/Combiner.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,KAAK,KAAK,MAAM,YAAY,CAAA;AAExC;;;;;;;;;;;GAWG;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;;;;GAIG;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;;GAEG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAE1D;AAED;;;;GAIG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAEzD;AAED;;;;GAIG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAEzD;AAED;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAEtC;AAED;;;;GAIG;AACH,wBAAgB,IAAI,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAErC;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAE7C;AAED;;;;GAIG;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;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;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;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;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAE1D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAEzD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;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;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,IAAI,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAErC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAE7C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;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

@@ -1,5 +1,27 @@
 /**
- * Creates a `Combiner` from a `combine` function.
+ * Creates a `Combiner` from a binary function.
+ *
+ * When to use:
+ * - You have a custom combining operation that is not covered by the built-in
+ *   constructors (`min`, `max`, `first`, `last`, `constant`).
+ *
+ * Behavior:
+ * - Returns a new `Combiner` whose `combine` method delegates to the provided
+ *   function.
+ * - Pure – the returned combiner does not mutate its arguments.
+ *
+ * **Example** (multiplying numbers)
+ *
+ * ```ts
+ * import { Combiner } from "effect"
+ *
+ * const Product = Combiner.make<number>((self, that) => self * that)
+ *
+ * console.log(Product.combine(3, 5))
+ * // Output: 15
+ * ```
+ *
+ * @see {@link Combiner} – the interface this creates
  *
  * @since 4.0.0
  */
@@ -9,13 +31,64 @@ export function make(combine) {
   };
 }
 /**
+ * Reverses the argument order of a combiner'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 combiner
+ *   (e.g. string concatenation).
+ *
+ * Behavior:
+ * - Returns a new `Combiner` where `combine(self, that)` calls the original
+ *   combiner as `combine(that, self)`.
+ * - Does not mutate the input combiner.
+ *
+ * **Example** (reversing string concatenation)
+ *
+ * ```ts
+ * import { Combiner, String } from "effect"
+ *
+ * const Prepend = Combiner.flip(String.ReducerConcat)
+ *
+ * console.log(Prepend.combine("a", "b"))
+ * // Output: "ba"
+ * ```
+ *
+ * @see {@link make}
+ *
  * @since 4.0.0
  */
 export function flip(combiner) {
   return make((self, that) => combiner.combine(that, self));
 }
 /**
- * Creates a `Combiner` that returns the smaller of two values.
+ * Creates a `Combiner` that returns the smaller of two values according to
+ * the provided `Order`.
+ *
+ * When to use:
+ * - You want to accumulate the minimum value across a collection.
+ * - You are building a `Reducer` that tracks the running minimum.
+ *
+ * Behavior:
+ * - Compares using the given `Order`. When values are equal, returns `that`
+ *   (the second argument).
+ * - Pure – does not mutate either argument.
+ *
+ * **Example** (minimum of two numbers)
+ *
+ * ```ts
+ * import { Combiner, Number } from "effect"
+ *
+ * const Min = Combiner.min(Number.Order)
+ *
+ * console.log(Min.combine(3, 1))
+ * // Output: 1
+ *
+ * console.log(Min.combine(1, 3))
+ * // Output: 1
+ * ```
+ *
+ * @see {@link max}
  *
  * @since 4.0.0
  */
@@ -23,7 +96,33 @@ export function min(order) {
   return make((self, that) => order(self, that) === -1 ? self : that);
 }
 /**
- * Creates a `Combiner` that returns the larger of two values.
+ * Creates a `Combiner` that returns the larger of two values according to
+ * the provided `Order`.
+ *
+ * When to use:
+ * - You want to accumulate the maximum value across a collection.
+ * - You are building a `Reducer` that tracks the running maximum.
+ *
+ * Behavior:
+ * - Compares using the given `Order`. When values are equal, returns `that`
+ *   (the second argument).
+ * - Pure – does not mutate either argument.
+ *
+ * **Example** (maximum of two numbers)
+ *
+ * ```ts
+ * import { Combiner, Number } from "effect"
+ *
+ * const Max = Combiner.max(Number.Order)
+ *
+ * console.log(Max.combine(3, 1))
+ * // Output: 3
+ *
+ * console.log(Max.combine(1, 3))
+ * // Output: 3
+ * ```
+ *
+ * @see {@link min}
  *
  * @since 4.0.0
  */
@@ -31,7 +130,29 @@ export function max(order) {
   return make((self, that) => order(self, that) === 1 ? self : that);
 }
 /**
- * Creates a `Combiner` that returns the first value.
+ * Creates a `Combiner` that always returns the first (left) argument.
+ *
+ * When to use:
+ * - You want "first write wins" semantics when merging values.
+ * - You need a combiner but the combining logic should be a no-op that keeps
+ *   the existing value.
+ *
+ * Behavior:
+ * - `combine(self, that)` returns `self`, ignoring `that`.
+ * - Pure – the second argument is discarded, not mutated.
+ *
+ * **Example** (keeping the first value)
+ *
+ * ```ts
+ * import { Combiner } from "effect"
+ *
+ * const First = Combiner.first<number>()
+ *
+ * console.log(First.combine(1, 2))
+ * // Output: 1
+ * ```
+ *
+ * @see {@link last}
  *
  * @since 4.0.0
  */
@@ -39,7 +160,28 @@ export function first() {
   return make((self, _) => self);
 }
 /**
- * Creates a `Combiner` that returns the last value.
+ * Creates a `Combiner` that always returns the last (right) argument.
+ *
+ * When to use:
+ * - You want "last write wins" semantics when merging values.
+ * - You need a combiner that replaces the accumulator with each new value.
+ *
+ * Behavior:
+ * - `combine(self, that)` returns `that`, ignoring `self`.
+ * - Pure – the first argument is discarded, not mutated.
+ *
+ * **Example** (keeping the last value)
+ *
+ * ```ts
+ * import { Combiner } from "effect"
+ *
+ * const Last = Combiner.last<number>()
+ *
+ * console.log(Last.combine(1, 2))
+ * // Output: 2
+ * ```
+ *
+ * @see {@link first}
  *
  * @since 4.0.0
  */
@@ -47,7 +189,31 @@ export function last() {
   return make((_, that) => that);
 }
 /**
- * Creates a `Combiner` that returns a constant value.
+ * Creates a `Combiner` that ignores both arguments and always returns the
+ * given constant value.
+ *
+ * When to use:
+ * - You need a combiner that produces a fixed result regardless of input.
+ * - You are providing a combiner to a generic API but the combined value is
+ *   predetermined.
+ *
+ * Behavior:
+ * - `combine(self, that)` returns the constant `a`, ignoring both arguments.
+ * - Pure – no mutation occurs.
+ *
+ * **Example** (always returning zero)
+ *
+ * ```ts
+ * import { Combiner } from "effect"
+ *
+ * const Zero = Combiner.constant(0)
+ *
+ * console.log(Zero.combine(42, 99))
+ * // Output: 0
+ * ```
+ *
+ * @see {@link first}
+ * @see {@link last}
  *
  * @since 4.0.0
  */
@@ -55,7 +221,32 @@ export function constant(a) {
   return make(() => a);
 }
 /**
- * Between each pair of elements insert `middle`.
+ * Wraps a `Combiner` so that a separator value is inserted between every
+ * pair of combined elements.
+ *
+ * When to use:
+ * - You are building delimited strings (CSV, paths, etc.) by repeated
+ *   combination.
+ * - You need to inject a fixed separator between accumulated values.
+ *
+ * Behavior:
+ * - `intercalate(middle)(combiner).combine(self, that)` is equivalent to
+ *   `combiner.combine(self, combiner.combine(middle, that))`.
+ * - Curried: first provide the separator, then the base combiner.
+ * - Does not mutate the input combiner; returns a new one.
+ *
+ * **Example** (joining strings with a separator)
+ *
+ * ```ts
+ * import { Combiner, String } from "effect"
+ *
+ * const commaSep = Combiner.intercalate(",")(String.ReducerConcat)
+ *
+ * console.log(commaSep.combine("a", "b"))
+ * // Output: "a,b"
+ * ```
+ *
+ * @see {@link make}
  *
  * @since 4.0.0
  */

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":"AAwBA;;;;;AAKA,OAAM,SAAUA,IAAIA,CAAIC,OAAgC;EACtD,OAAO;IAAEA;EAAO,CAAE;AACpB;AAEA;;;AAGA,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;;;;;AAKA,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;;;;;AAKA,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;;;;;AAKA,OAAM,SAAUI,KAAKA,CAAA;EACnB,OAAOT,IAAI,CAAC,CAACI,IAAI,EAAEM,CAAC,KAAKN,IAAI,CAAC;AAChC;AAEA;;;;;AAKA,OAAM,SAAUO,IAAIA,CAAA;EAClB,OAAOX,IAAI,CAAC,CAACU,CAAC,EAAEL,IAAI,KAAKA,IAAI,CAAC;AAChC;AAEA;;;;;AAKA,OAAM,SAAUO,QAAQA,CAAIC,CAAI;EAC9B,OAAOb,IAAI,CAAC,MAAMa,CAAC,CAAC;AACtB;AAEA;;;;;AAKA,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":"AAoGA;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,OAAM,SAAUA,IAAIA,CAAIC,OAAgC;EACtD,OAAO;IAAEA;EAAO,CAAE;AACpB;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,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;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,OAAM,SAAUO,IAAIA,CAAA;EAClB,OAAOX,IAAI,CAAC,CAACU,CAAC,EAAEL,IAAI,KAAKA,IAAI,CAAC;AAChC;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,OAAM,SAAUO,QAAQA,CAAIC,CAAI;EAC9B,OAAOb,IAAI,CAAC,MAAMa,CAAC,CAAC;AACtB;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,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":[]}

package/dist/Config.d.ts

@@ -689,7 +689,7 @@ export declare const Boolean: Schema.decodeTo<Schema.Boolean, Schema.Literals<re
  * - Pass to {@link schema} for custom paths, or use the {@link duration}
  *   convenience constructor.
  *
- * Accepts any string that `Duration.fromDurationInput` can parse (e.g.
+ * Accepts any string that `Duration.fromInput` can parse (e.g.
  * `"10 seconds"`, `"500 millis"`).
  *
  * @see {@link duration} – convenience constructor
@@ -768,7 +768,7 @@ export declare const LogLevel: Schema.Literals<readonly LogLevel_.LogLevel[]>;
 export declare const Record: <K extends Schema.Record.Key, V extends Schema.Top>(key: K, value: V, options?: {
     readonly separator?: string | undefined;
     readonly keyValueSeparator?: string | undefined;
-}) => Schema.Union<readonly [Schema.Record$<K, V>, Schema.compose<Schema.Record$<K, V>, Schema.decodeTo<Schema.Record$<Schema.String, Schema.String>, Schema.String, never, never>>]>;
+}) => Schema.Union<readonly [Schema.$Record<K, V>, Schema.compose<Schema.$Record<K, V>, Schema.decodeTo<Schema.$Record<Schema.String, Schema.String>, Schema.String, never, never>>]>;
 /**
  * Creates a config that always fails with the given error.
  *
@@ -934,7 +934,7 @@ export declare function boolean(name?: string): Config<boolean>;
  *
  * Shortcut for `Config.schema(Config.Duration, name)`.
  *
- * Accepts any string that `Duration.fromDurationInput` can parse (e.g.
+ * Accepts any string that `Duration.fromInput` can parse (e.g.
  * `"10 seconds"`, `"500 millis"`, `"2 minutes"`).
  *
  * **Example** (Reading a duration)

package/dist/Config.js

@@ -528,7 +528,7 @@ export const Boolean = /*#__PURE__*/Schema.Literals([...TrueValues.literals, ...
  * - Pass to {@link schema} for custom paths, or use the {@link duration}
  *   convenience constructor.
  *
- * Accepts any string that `Duration.fromDurationInput` can parse (e.g.
+ * Accepts any string that `Duration.fromInput` can parse (e.g.
  * `"10 seconds"`, `"500 millis"`).
  *
  * @see {@link duration} – convenience constructor
@@ -538,7 +538,7 @@ export const Boolean = /*#__PURE__*/Schema.Literals([...TrueValues.literals, ...
  */
 export const Duration = /*#__PURE__*/Schema.String.pipe(/*#__PURE__*/Schema.decodeTo(Schema.Duration, {
   decode: /*#__PURE__*/Getter.transformOrFail(s => {
-    const d = Duration_.fromDurationInput(s);
+    const d = Duration_.fromInput(s);
     return d ? Effect.succeed(d) : Effect.fail(new Issue.InvalidValue(Option.some(s)));
   }),
   encode: /*#__PURE__*/Getter.forbidden(() => "Encoding Duration is not supported")
@@ -804,7 +804,7 @@ export function boolean(name) {
  *
  * Shortcut for `Config.schema(Config.Duration, name)`.
  *
- * Accepts any string that `Duration.fromDurationInput` can parse (e.g.
+ * Accepts any string that `Duration.fromInput` can parse (e.g.
  * `"10 seconds"`, `"500 millis"`, `"2 minutes"`).
  *
  * **Example** (Reading a duration)