effect 4.0.0-beta.6 → 4.0.0-beta.8

package/src/Stream.ts

@@ -472,7 +472,7 @@ export const fromEffectSchedule = <A, E, R, X, AS extends A, ES, RS>(
  * @since 2.0.0
  * @category Constructors
  */
-export const tick = (interval: Duration.DurationInput): Stream<void> =>
+export const tick = (interval: Duration.Input): Stream<void> =>
   fromPull(Effect.sync(() => {
     let first = true
     const effect = Effect.succeed(Arr.of<void>(undefined))
@@ -3317,7 +3317,7 @@ export const timeout: {
    * @since 2.0.0
    * @category Rate Limiting
    */
-  (duration: Duration.DurationInput): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>
+  (duration: Duration.Input): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>
   /**
    * Ends the stream if it does not produce a value within the specified duration.
    *
@@ -3341,10 +3341,10 @@ export const timeout: {
    * @since 2.0.0
    * @category Rate Limiting
    */
-  <A, E, R>(self: Stream<A, E, R>, duration: Duration.DurationInput): Stream<A, E, R>
+  <A, E, R>(self: Stream<A, E, R>, duration: Duration.Input): Stream<A, E, R>
 } = dual(
   2,
-  <A, E, R>(self: Stream<A, E, R>, duration: Duration.DurationInput): Stream<A, E, R> =>
+  <A, E, R>(self: Stream<A, E, R>, duration: Duration.Input): Stream<A, E, R> =>
     transformPull(self, (pull, _scope) =>
       Effect.succeed(Effect.timeoutOrElse(pull, {
         duration,
@@ -12175,7 +12175,7 @@ export const debounce: {
    * @since 2.0.0
    * @category Rate Limiting
    */
-  (duration: Duration.DurationInput): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>
+  (duration: Duration.Input): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>
   /**
    * Drops earlier elements within the debounce window and emits only the latest element after the pause.
    *
@@ -12199,15 +12199,15 @@ export const debounce: {
    * @since 2.0.0
    * @category Rate Limiting
    */
-  <A, E, R>(self: Stream<A, E, R>, duration: Duration.DurationInput): Stream<A, E, R>
+  <A, E, R>(self: Stream<A, E, R>, duration: Duration.Input): Stream<A, E, R>
 } = dual(
   2,
-  <A, E, R>(self: Stream<A, E, R>, duration: Duration.DurationInput): Stream<A, E, R> =>
+  <A, E, R>(self: Stream<A, E, R>, duration: Duration.Input): Stream<A, E, R> =>
     transformPull(
       self,
       Effect.fnUntraced(function*(pull, scope) {
         const clock = yield* Clock
-        const durationMs = Duration.toMillis(Duration.fromDurationInputUnsafe(duration))
+        const durationMs = Duration.toMillis(Duration.fromInputUnsafe(duration))
         let lastArr: Arr.NonEmptyReadonlyArray<A> | undefined
         let cause: Cause.Cause<Cause.Done | E> | undefined
         let emitAtMs = Infinity
@@ -12347,7 +12347,7 @@ export const throttleEffect: {
     options: {
       readonly cost: (arr: Arr.NonEmptyReadonlyArray<A>) => Effect.Effect<number, E2, R2>
       readonly units: number
-      readonly duration: Duration.DurationInput
+      readonly duration: Duration.Input
       readonly burst?: number | undefined
       readonly strategy?: "enforce" | "shape" | undefined
     }
@@ -12393,7 +12393,7 @@ export const throttleEffect: {
     options: {
       readonly cost: (arr: Arr.NonEmptyReadonlyArray<A>) => Effect.Effect<number, E2, R2>
       readonly units: number
-      readonly duration: Duration.DurationInput
+      readonly duration: Duration.Input
       readonly burst?: number | undefined
       readonly strategy?: "enforce" | "shape" | undefined
     }
@@ -12405,7 +12405,7 @@ export const throttleEffect: {
     options: {
       readonly cost: (arr: Arr.NonEmptyReadonlyArray<A>) => Effect.Effect<number, E2, R2>
       readonly units: number
-      readonly duration: Duration.DurationInput
+      readonly duration: Duration.Input
       readonly burst?: number | undefined
       readonly strategy?: "enforce" | "shape" | undefined
     }
@@ -12422,12 +12422,12 @@ const throttleEnforceEffect = <A, E, R, E2, R2>(
   self: Stream<A, E, R>,
   cost: (arr: Arr.NonEmptyReadonlyArray<A>) => Effect.Effect<number, E2, R2>,
   units: number,
-  duration: Duration.DurationInput,
+  duration: Duration.Input,
   burst: number
 ): Stream<A, E | E2, R | R2> =>
   transformPull(self, (pull) =>
     Effect.clockWith((clock) => {
-      const durationMs = Duration.toMillis(Duration.fromDurationInputUnsafe(duration))
+      const durationMs = Duration.toMillis(Duration.fromInputUnsafe(duration))
       const max = units + burst < 0 ? Number.POSITIVE_INFINITY : units + burst
       let tokens = units
       let timestampMs = clock.currentTimeMillisUnsafe()
@@ -12458,12 +12458,12 @@ const throttleShapeEffect = <A, E, R, E2, R2>(
   self: Stream<A, E, R>,
   cost: (arr: Arr.NonEmptyReadonlyArray<A>) => Effect.Effect<number, E2, R2>,
   units: number,
-  duration: Duration.DurationInput,
+  duration: Duration.Input,
   burst: number
 ): Stream<A, E | E2, R | R2> =>
   transformPull(self, (pull) =>
     Effect.clockWith((clock) => {
-      const durationMs = Duration.toMillis(Duration.fromDurationInputUnsafe(duration))
+      const durationMs = Duration.toMillis(Duration.fromInputUnsafe(duration))
       const max = units + burst < 0 ? Number.POSITIVE_INFINITY : units + burst
       let tokens = units
       let timestampMs = clock.currentTimeMillisUnsafe()
@@ -12576,7 +12576,7 @@ export const throttle: {
     options: {
       readonly cost: (arr: Arr.NonEmptyReadonlyArray<A>) => number
       readonly units: number
-      readonly duration: Duration.DurationInput
+      readonly duration: Duration.Input
       readonly burst?: number | undefined
       readonly strategy?: "enforce" | "shape" | undefined
     }
@@ -12621,7 +12621,7 @@ export const throttle: {
     options: {
       readonly cost: (arr: Arr.NonEmptyReadonlyArray<A>) => number
       readonly units: number
-      readonly duration: Duration.DurationInput
+      readonly duration: Duration.Input
       readonly burst?: number | undefined
       readonly strategy?: "enforce" | "shape" | undefined
     }
@@ -12633,7 +12633,7 @@ export const throttle: {
     options: {
       readonly cost: (arr: Arr.NonEmptyReadonlyArray<A>) => number
       readonly units: number
-      readonly duration: Duration.DurationInput
+      readonly duration: Duration.Input
       readonly burst?: number | undefined
       readonly strategy?: "enforce" | "shape" | undefined
     }
@@ -12771,7 +12771,7 @@ export const groupedWithin: {
    * @since 2.0.0
    * @category Grouping
    */
-  (chunkSize: number, duration: Duration.DurationInput): <A, E, R>(self: Stream<A, E, R>) => Stream<Array<A>, E, R>
+  (chunkSize: number, duration: Duration.Input): <A, E, R>(self: Stream<A, E, R>) => Stream<Array<A>, E, R>
   /**
    * Partitions the stream into arrays, emitting when the chunk size is reached
    * or the duration passes.
@@ -12795,11 +12795,11 @@ export const groupedWithin: {
    * @since 2.0.0
    * @category Grouping
    */
-  <A, E, R>(self: Stream<A, E, R>, chunkSize: number, duration: Duration.DurationInput): Stream<Array<A>, E, R>
+  <A, E, R>(self: Stream<A, E, R>, chunkSize: number, duration: Duration.Input): Stream<Array<A>, E, R>
 } = dual(3, <A, E, R>(
   self: Stream<A, E, R>,
   chunkSize: number,
-  duration: Duration.DurationInput
+  duration: Duration.Input
 ): Stream<Array<A>, E, R> =>
   aggregateWithin(
     self,
@@ -12874,7 +12874,7 @@ export const groupBy: {
     f: (a: NoInfer<A>) => Effect.Effect<readonly [K, V], E2, R2>,
     options?: {
       readonly bufferSize?: number | undefined
-      readonly idleTimeToLive?: Duration.DurationInput | undefined
+      readonly idleTimeToLive?: Duration.Input | undefined
     }
   ): <E, R>(self: Stream<A, E, R>) => Stream<readonly [K, Stream<V>], E | E2, R | R2>
   /**
@@ -12913,7 +12913,7 @@ export const groupBy: {
     f: (a: NoInfer<A>) => Effect.Effect<readonly [K, V], E2, R2>,
     options?: {
       readonly bufferSize?: number | undefined
-      readonly idleTimeToLive?: Duration.DurationInput | undefined
+      readonly idleTimeToLive?: Duration.Input | undefined
     }
   ): Stream<readonly [K, Stream<V>], E | E2, R | R2>
 } = dual((args) => isStream(args[0]), <A, E, R, K, V, E2, R2>(
@@ -12921,7 +12921,7 @@ export const groupBy: {
   f: (a: NoInfer<A>) => Effect.Effect<readonly [K, V], E2, R2>,
   options?: {
     readonly bufferSize?: number | undefined
-    readonly idleTimeToLive?: Duration.DurationInput | undefined
+    readonly idleTimeToLive?: Duration.Input | undefined
   }
 ): Stream<readonly [K, Stream<V>], E | E2, R | R2> =>
   groupByImpl(
@@ -13003,7 +13003,7 @@ export const groupByKey: {
     f: (a: NoInfer<A>) => K,
     options?: {
       readonly bufferSize?: number | undefined
-      readonly idleTimeToLive?: Duration.DurationInput | undefined
+      readonly idleTimeToLive?: Duration.Input | undefined
     }
   ): <E, R>(self: Stream<A, E, R>) => Stream<readonly [K, Stream<A>], E, R>
   /**
@@ -13040,7 +13040,7 @@ export const groupByKey: {
     f: (a: NoInfer<A>) => K,
     options?: {
       readonly bufferSize?: number | undefined
-      readonly idleTimeToLive?: Duration.DurationInput | undefined
+      readonly idleTimeToLive?: Duration.Input | undefined
     }
   ): Stream<readonly [K, Stream<A>], E, R>
 } = dual((args) => isStream(args[0]), <A, E, R, K>(
@@ -13048,7 +13048,7 @@ export const groupByKey: {
   f: (a: NoInfer<A>) => K,
   options?: {
     readonly bufferSize?: number | undefined
-    readonly idleTimeToLive?: Duration.DurationInput | undefined
+    readonly idleTimeToLive?: Duration.Input | undefined
   }
 ): Stream<readonly [K, Stream<A>], E, R> =>
   suspend(() => {
@@ -13146,7 +13146,7 @@ const groupByImpl = <A, E, R, K, V, E2, R2>(
   ) => Effect.Effect<void, E2, R2>,
   options?: {
     readonly bufferSize?: number | undefined
-    readonly idleTimeToLive?: Duration.DurationInput | undefined
+    readonly idleTimeToLive?: Duration.Input | undefined
   }
 ): Stream<readonly [K, Stream<V>], E | E2, R | R2> =>
   transformPullBracket(
@@ -13880,12 +13880,12 @@ export const share: {
     options: {
       readonly capacity: "unbounded"
       readonly replay?: number | undefined
-      readonly idleTimeToLive?: Duration.DurationInput | undefined
+      readonly idleTimeToLive?: Duration.Input | undefined
     } | {
       readonly capacity: number
       readonly strategy?: "sliding" | "dropping" | "suspend" | undefined
       readonly replay?: number | undefined
-      readonly idleTimeToLive?: Duration.DurationInput | undefined
+      readonly idleTimeToLive?: Duration.Input | undefined
     }
   ): <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<Stream<A, E>, never, Scope.Scope | R>
   /**
@@ -13924,12 +13924,12 @@ export const share: {
     options: {
       readonly capacity: "unbounded"
       readonly replay?: number | undefined
-      readonly idleTimeToLive?: Duration.DurationInput | undefined
+      readonly idleTimeToLive?: Duration.Input | undefined
     } | {
       readonly capacity: number
       readonly strategy?: "sliding" | "dropping" | "suspend" | undefined
       readonly replay?: number | undefined
-      readonly idleTimeToLive?: Duration.DurationInput | undefined
+      readonly idleTimeToLive?: Duration.Input | undefined
     }
   ): Effect.Effect<Stream<A, E>, never, Scope.Scope | R>
 } = dual(2, <A, E, R>(
@@ -13937,12 +13937,12 @@ export const share: {
   options: {
     readonly capacity: "unbounded"
     readonly replay?: number | undefined
-    readonly idleTimeToLive?: Duration.DurationInput | undefined
+    readonly idleTimeToLive?: Duration.Input | undefined
   } | {
     readonly capacity: number
     readonly strategy?: "sliding" | "dropping" | "suspend" | undefined
     readonly replay?: number | undefined
-    readonly idleTimeToLive?: Duration.DurationInput | undefined
+    readonly idleTimeToLive?: Duration.Input | undefined
   }
 ): Effect.Effect<Stream<A, E>, never, Scope.Scope | R> =>
   Effect.map(

package/src/index.ts

@@ -444,6 +444,65 @@ export * as Chunk from "./Chunk.ts"
 export * as Clock from "./Clock.ts"
 
 /**
+ * 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
  */
 export * as Combiner from "./Combiner.ts"
@@ -1137,6 +1196,57 @@ export * as FileSystem from "./FileSystem.ts"
 export * as Filter from "./Filter.ts"
 
 /**
+ * Utilities for converting arbitrary JavaScript values into human-readable
+ * strings, with support for circular references, redaction, and common JS
+ * types that `JSON.stringify` handles poorly.
+ *
+ * Mental model:
+ * - A `Formatter<Value, Format>` is a callable `(value: Value) => Format`.
+ * - {@link format} is the general-purpose pretty-printer: it handles
+ *   primitives, arrays, objects, `BigInt`, `Symbol`, `Date`, `RegExp`,
+ *   `Set`, `Map`, class instances, and circular references.
+ * - {@link formatJson} is a safe `JSON.stringify` wrapper that silently
+ *   drops circular references and applies redaction.
+ * - Both functions accept a `space` option for indentation control.
+ *
+ * Common tasks:
+ * - Pretty-print any value for debugging / logging -> {@link format}
+ * - Serialize to JSON safely (no circular throws) -> {@link formatJson}
+ * - Format a single object property key -> {@link formatPropertyKey}
+ * - Format a property path like `["a"]["b"]` -> {@link formatPath}
+ * - Format a `Date` to ISO string safely -> {@link formatDate}
+ *
+ * Gotchas:
+ * - {@link format} output is **not** valid JSON; use {@link formatJson} when
+ *   you need parseable JSON.
+ * - {@link format} calls `toString()` on objects by default; pass
+ *   `ignoreToString: true` to disable.
+ * - {@link formatJson} silently omits circular references (the key is
+ *   dropped from the output).
+ * - Values implementing the `Redactable` protocol are automatically
+ *   redacted by both {@link format} and {@link formatJson}.
+ *
+ * **Example** (Pretty-print a value)
+ *
+ * ```ts
+ * import { Formatter } from "effect"
+ *
+ * const obj = { name: "Alice", scores: [100, 97] }
+ * console.log(Formatter.format(obj))
+ * // {"name":"Alice","scores":[100,97]}
+ *
+ * console.log(Formatter.format(obj, { space: 2 }))
+ * // {
+ * //   "name": "Alice",
+ * //   "scores": [
+ * //     100,
+ * //     97
+ * //   ]
+ * // }
+ * ```
+ *
+ * See also: {@link Formatter}, {@link format}, {@link formatJson}
+ *
  * @since 4.0.0
  */
 export * as Formatter from "./Formatter.ts"
@@ -1401,6 +1511,89 @@ export * as JsonPatch from "./JsonPatch.ts"
 export * as JsonPointer from "./JsonPointer.ts"
 
 /**
+ * Convert JSON Schema documents between dialects (Draft-07, Draft-2020-12,
+ * OpenAPI 3.0, OpenAPI 3.1). All dialects are normalized to an internal
+ * `Document<"draft-2020-12">` representation before optional conversion to
+ * an output dialect.
+ *
+ * ## Mental model
+ *
+ * - **JsonSchema** — a plain object with string keys; represents any single
+ *   JSON Schema node.
+ * - **Dialect** — one of `"draft-07"`, `"draft-2020-12"`, `"openapi-3.1"`,
+ *   or `"openapi-3.0"`.
+ * - **Document** — a structured container holding a root `schema`, its
+ *   companion `definitions`, and the target `dialect`. Definitions are
+ *   stored separately from the root schema so they can be relocated when
+ *   converting between dialects.
+ * - **MultiDocument** — same as `Document` but carries multiple root
+ *   schemas (at least one). Useful when generating several schemas that
+ *   share a single definitions pool.
+ * - **Definitions** — a `Record<string, JsonSchema>` keyed by definition
+ *   name. The ref pointer prefix depends on the dialect.
+ * - **`from*` functions** — parse a raw JSON Schema object into the
+ *   canonical `Document<"draft-2020-12">`.
+ * - **`to*` functions** — convert from the canonical representation to a
+ *   specific output dialect.
+ *
+ * ## Common tasks
+ *
+ * - Parse a Draft-07 schema → {@link fromSchemaDraft07}
+ * - Parse a Draft-2020-12 schema → {@link fromSchemaDraft2020_12}
+ * - Parse an OpenAPI 3.1 schema → {@link fromSchemaOpenApi3_1}
+ * - Parse an OpenAPI 3.0 schema → {@link fromSchemaOpenApi3_0}
+ * - Convert to Draft-07 output → {@link toDocumentDraft07}
+ * - Convert to OpenAPI 3.1 output → {@link toMultiDocumentOpenApi3_1}
+ * - Resolve a `$ref` against definitions → {@link resolve$ref}
+ * - Inline the root `$ref` of a document → {@link resolveTopLevel$ref}
+ *
+ * ## Gotchas
+ *
+ * - All `from*` functions normalize to `Document<"draft-2020-12">`
+ *   regardless of the input dialect.
+ * - Unsupported or unrecognized JSON Schema keywords are silently dropped
+ *   during conversion.
+ * - Draft-07 tuple syntax (`items` as array + `additionalItems`) is
+ *   converted to 2020-12 form (`prefixItems` + `items`), and vice-versa.
+ * - OpenAPI 3.0 `nullable: true` is expanded into `type` arrays or
+ *   `anyOf` unions. The `nullable` keyword is removed.
+ * - OpenAPI 3.0 singular `example` is converted to `examples` (array).
+ * - {@link resolve$ref} only looks up the last segment of the ref path in
+ *   the definitions map; it does not follow arbitrary JSON Pointer paths.
+ *
+ * ## Quickstart
+ *
+ * **Example** (Parse a Draft-07 schema and convert to Draft-07 output)
+ *
+ * ```ts
+ * import { JsonSchema } from "effect"
+ *
+ * const raw: JsonSchema.JsonSchema = {
+ *   type: "object",
+ *   properties: {
+ *     name: { type: "string" }
+ *   },
+ *   required: ["name"]
+ * }
+ *
+ * // Parse into canonical form
+ * const doc = JsonSchema.fromSchemaDraft07(raw)
+ *
+ * // Convert back to Draft-07
+ * const draft07 = JsonSchema.toDocumentDraft07(doc)
+ *
+ * console.log(draft07.dialect) // "draft-07"
+ * console.log(draft07.schema) // { type: "object", properties: { name: { type: "string" } }, required: ["name"] }
+ * ```
+ *
+ * ## See also
+ *
+ * - {@link Document}
+ * - {@link MultiDocument}
+ * - {@link fromSchemaDraft07}
+ * - {@link toDocumentDraft07}
+ * - {@link resolve$ref}
+ *
  * @since 4.0.0
  */
 export * as JsonSchema from "./JsonSchema.ts"
@@ -2457,6 +2650,71 @@ export * as Redactable from "./Redactable.ts"
 export * as Redacted from "./Redacted.ts"
 
 /**
+ * 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
  */
 export * as Reducer from "./Reducer.ts"

package/src/internal/dateTime.ts

@@ -12,7 +12,6 @@ import * as Inspectable from "../Inspectable.ts"
 import * as order from "../Order.ts"
 import { pipeArguments } from "../Pipeable.ts"
 import * as Predicate from "../Predicate.ts"
-import * as Result from "../Result.ts"
 import type { Mutable } from "../Types.ts"
 import * as UndefinedOr from "../UndefinedOr.ts"
 import * as effect from "./effect.ts"
@@ -467,32 +466,12 @@ export const setZoneNamedUnsafe: {
 
 /** @internal */
 export const distance: {
-  (other: DateTime.DateTime): (self: DateTime.DateTime) => number
-  (self: DateTime.DateTime, other: DateTime.DateTime): number
-} = dual(2, (self: DateTime.DateTime, other: DateTime.DateTime): number => toEpochMillis(other) - toEpochMillis(self))
-
-/** @internal */
-export const distanceDurationResult: {
-  (other: DateTime.DateTime): (self: DateTime.DateTime) => Result.Result<Duration.Duration, Duration.Duration>
-  (self: DateTime.DateTime, other: DateTime.DateTime): Result.Result<Duration.Duration, Duration.Duration>
-} = dual(
-  2,
-  (self: DateTime.DateTime, other: DateTime.DateTime): Result.Result<Duration.Duration, Duration.Duration> => {
-    const diffMillis = distance(self, other)
-    return diffMillis > 0
-      ? Result.succeed(Duration.millis(diffMillis))
-      : Result.fail(Duration.millis(-diffMillis))
-  }
-)
-
-/** @internal */
-export const distanceDuration: {
   (other: DateTime.DateTime): (self: DateTime.DateTime) => Duration.Duration
   (self: DateTime.DateTime, other: DateTime.DateTime): Duration.Duration
 } = dual(
   2,
   (self: DateTime.DateTime, other: DateTime.DateTime): Duration.Duration =>
-    Duration.millis(Math.abs(distance(self, other)))
+    Duration.millis(toEpochMillis(other) - toEpochMillis(self))
 )
 
 /** @internal */
@@ -911,22 +890,22 @@ export const match: {
 
 /** @internal */
 export const addDuration: {
-  (duration: Duration.DurationInput): <A extends DateTime.DateTime>(self: A) => A
-  <A extends DateTime.DateTime>(self: A, duration: Duration.DurationInput): A
+  (duration: Duration.Input): <A extends DateTime.DateTime>(self: A) => A
+  <A extends DateTime.DateTime>(self: A, duration: Duration.Input): A
 } = dual(
   2,
-  (self: DateTime.DateTime, duration: Duration.DurationInput): DateTime.DateTime =>
-    mapEpochMillis(self, (millis) => millis + Duration.toMillis(Duration.fromDurationInputUnsafe(duration)))
+  (self: DateTime.DateTime, duration: Duration.Input): DateTime.DateTime =>
+    mapEpochMillis(self, (millis) => millis + Duration.toMillis(Duration.fromInputUnsafe(duration)))
 )
 
 /** @internal */
 export const subtractDuration: {
-  (duration: Duration.DurationInput): <A extends DateTime.DateTime>(self: A) => A
-  <A extends DateTime.DateTime>(self: A, duration: Duration.DurationInput): A
+  (duration: Duration.Input): <A extends DateTime.DateTime>(self: A) => A
+  <A extends DateTime.DateTime>(self: A, duration: Duration.Input): A
 } = dual(
   2,
-  (self: DateTime.DateTime, duration: Duration.DurationInput): DateTime.DateTime =>
-    mapEpochMillis(self, (millis) => millis - Duration.toMillis(Duration.fromDurationInputUnsafe(duration)))
+  (self: DateTime.DateTime, duration: Duration.Input): DateTime.DateTime =>
+    mapEpochMillis(self, (millis) => millis - Duration.toMillis(Duration.fromInputUnsafe(duration)))
 )
 
 const addMillis = (date: Date, amount: number): void => {