effect 4.0.0-beta.2 → 4.0.0-beta.20

package/src/Record.ts

@@ -7,6 +7,7 @@
 import type * as Combiner from "./Combiner.ts"
 import * as Equal from "./Equal.ts"
 import type { Equivalence } from "./Equivalence.ts"
+import type * as Filter from "./Filter.ts"
 import { dual, identity } from "./Function.ts"
 import type { TypeLambda } from "./HKT.ts"
 import * as Option from "./Option.ts"
@@ -1002,16 +1003,16 @@ export const mapEntries: {
 )
 
 /**
- * Transforms a record into a record by applying the function `f` to each key and value in the original record.
- * If the function returns `Some`, the key-value pair is included in the output record.
+ * Transforms a record by applying the function `f` to each key and value in the original record.
+ * If the function succeeds, the key-value pair is included in the output record.
  *
  * @example
  * ```ts
- * import { Option, Record } from "effect"
+ * import { Record, Result } from "effect"
  * import * as assert from "node:assert"
  *
  * const x = { a: 1, b: 2, c: 3 }
- * const f = (a: number, key: string) => a > 2 ? Option.some(a * 2) : Option.none()
+ * const f = (a: number, key: string) => a > 2 ? Result.succeed(a * 2) : Result.failVoid
  * assert.deepStrictEqual(Record.filterMap(x, f), { c: 6 })
  * ```
  *
@@ -1020,52 +1021,52 @@ export const mapEntries: {
  */
 export const filterMap: {
   /**
-   * Transforms a record into a record by applying the function `f` to each key and value in the original record.
-   * If the function returns `Some`, the key-value pair is included in the output record.
+   * Transforms a record by applying the function `f` to each key and value in the original record.
+   * If the function succeeds, the key-value pair is included in the output record.
    *
    * @example
    * ```ts
-   * import { Option, Record } from "effect"
+   * import { Record, Result } from "effect"
    * import * as assert from "node:assert"
    *
    * const x = { a: 1, b: 2, c: 3 }
-   * const f = (a: number, key: string) => a > 2 ? Option.some(a * 2) : Option.none()
+   * const f = (a: number, key: string) => a > 2 ? Result.succeed(a * 2) : Result.failVoid
    * assert.deepStrictEqual(Record.filterMap(x, f), { c: 6 })
    * ```
    *
    * @category filtering
    * @since 2.0.0
    */
-  <K extends string, A, B>(f: (a: A, key: K) => Option.Option<B>): (self: ReadonlyRecord<K, A>) => Record<ReadonlyRecord.NonLiteralKey<K>, B>
+  <K extends string, A, B, X>(f: Filter.Filter<A, B, X, [key: K]>): (self: ReadonlyRecord<K, A>) => Record<ReadonlyRecord.NonLiteralKey<K>, B>
   /**
-   * Transforms a record into a record by applying the function `f` to each key and value in the original record.
-   * If the function returns `Some`, the key-value pair is included in the output record.
+   * Transforms a record by applying the function `f` to each key and value in the original record.
+   * If the function succeeds, the key-value pair is included in the output record.
    *
    * @example
    * ```ts
-   * import { Option, Record } from "effect"
+   * import { Record, Result } from "effect"
    * import * as assert from "node:assert"
    *
    * const x = { a: 1, b: 2, c: 3 }
-   * const f = (a: number, key: string) => a > 2 ? Option.some(a * 2) : Option.none()
+   * const f = (a: number, key: string) => a > 2 ? Result.succeed(a * 2) : Result.failVoid
    * assert.deepStrictEqual(Record.filterMap(x, f), { c: 6 })
    * ```
    *
    * @category filtering
    * @since 2.0.0
    */
-  <K extends string, A, B>(self: ReadonlyRecord<K, A>, f: (a: A, key: K) => Option.Option<B>): Record<ReadonlyRecord.NonLiteralKey<K>, B>
+  <K extends string, A, B, X>(self: ReadonlyRecord<K, A>, f: Filter.Filter<A, B, X, [key: K]>): Record<ReadonlyRecord.NonLiteralKey<K>, B>
 } = dual(
   2,
-  <K extends string, A, B>(
+  <K extends string, A, B, X>(
     self: ReadonlyRecord<K, A>,
-    f: (a: A, key: K) => Option.Option<B>
+    f: Filter.Filter<A, B, X, [key: K]>
   ): Record<ReadonlyRecord.NonLiteralKey<K>, B> => {
     const out: Record<string, B> = empty()
     for (const key of keys(self)) {
-      const o = f(self[key], key)
-      if (Option.isSome(o)) {
-        out[key] = o.value
+      const result = f(self[key], key)
+      if (R.isSuccess(result)) {
+        out[key] = result.success
       }
     }
     return out
@@ -1187,9 +1188,18 @@ export const filter: {
  */
 export const getSomes: <K extends string, A>(
   self: ReadonlyRecord<K, Option.Option<A>>
-) => Record<ReadonlyRecord.NonLiteralKey<K>, A> = filterMap(
-  identity
-)
+) => Record<ReadonlyRecord.NonLiteralKey<K>, A> = <K extends string, A>(
+  self: ReadonlyRecord<K, Option.Option<A>>
+): Record<ReadonlyRecord.NonLiteralKey<K>, A> => {
+  const out: Record<string, A> = empty()
+  for (const key of keys(self)) {
+    const option = self[key]
+    if (Option.isSome(option)) {
+      out[key] = option.value
+    }
+  }
+  return out
+}
 
 /**
  * Given a record with `Result` values, returns a new record containing only the `Err` values, preserving the original keys.
@@ -1262,7 +1272,7 @@ export const getSuccesses = <K extends string, A, E>(
 }
 
 /**
- * Partitions the elements of a record into two groups: those that match a predicate, and those that don't.
+ * Partitions the elements of a record into two groups: those that match a filter, and those that don't.
  *
  * @example
  * ```ts
@@ -1271,15 +1281,15 @@ export const getSuccesses = <K extends string, A, E>(
  *
  * const x = { a: 1, b: 2, c: 3 }
  * const f = (n: number) => (n % 2 === 0 ? Result.succeed(n) : Result.fail(n))
- * assert.deepStrictEqual(Record.partitionMap(x, f), [{ a: 1, c: 3 }, { b: 2 }])
+ * assert.deepStrictEqual(Record.partition(x, f), [{ a: 1, c: 3 }, { b: 2 }])
  * ```
  *
  * @category filtering
  * @since 2.0.0
  */
-export const partitionMap: {
+export const partition: {
   /**
-   * Partitions the elements of a record into two groups: those that match a predicate, and those that don't.
+   * Partitions the elements of a record into two groups: those that match a filter, and those that don't.
    *
    * @example
    * ```ts
@@ -1288,17 +1298,17 @@ export const partitionMap: {
    *
    * const x = { a: 1, b: 2, c: 3 }
    * const f = (n: number) => (n % 2 === 0 ? Result.succeed(n) : Result.fail(n))
-   * assert.deepStrictEqual(Record.partitionMap(x, f), [{ a: 1, c: 3 }, { b: 2 }])
+   * assert.deepStrictEqual(Record.partition(x, f), [{ a: 1, c: 3 }, { b: 2 }])
    * ```
    *
    * @category filtering
    * @since 2.0.0
    */
-  <K extends string, A, B, C>(f: (a: A, key: K) => Result<C, B>): (
+  <K extends string, A, B, C>(f: Filter.Filter<A, C, B, [key: K]>): (
     self: ReadonlyRecord<K, A>
   ) => [left: Record<ReadonlyRecord.NonLiteralKey<K>, B>, right: Record<ReadonlyRecord.NonLiteralKey<K>, C>]
   /**
-   * Partitions the elements of a record into two groups: those that match a predicate, and those that don't.
+   * Partitions the elements of a record into two groups: those that match a filter, and those that don't.
    *
    * @example
    * ```ts
@@ -1307,18 +1317,18 @@ export const partitionMap: {
    *
    * const x = { a: 1, b: 2, c: 3 }
    * const f = (n: number) => (n % 2 === 0 ? Result.succeed(n) : Result.fail(n))
-   * assert.deepStrictEqual(Record.partitionMap(x, f), [{ a: 1, c: 3 }, { b: 2 }])
+   * assert.deepStrictEqual(Record.partition(x, f), [{ a: 1, c: 3 }, { b: 2 }])
    * ```
    *
    * @category filtering
    * @since 2.0.0
    */
-  <K extends string, A, B, C>(self: ReadonlyRecord<K, A>, f: (a: A, key: K) => Result<C, B>): [left: Record<ReadonlyRecord.NonLiteralKey<K>, B>, right: Record<ReadonlyRecord.NonLiteralKey<K>, C>]
+  <K extends string, A, B, C>(self: ReadonlyRecord<K, A>, f: Filter.Filter<A, C, B, [key: K]>): [left: Record<ReadonlyRecord.NonLiteralKey<K>, B>, right: Record<ReadonlyRecord.NonLiteralKey<K>, C>]
 } = dual(
   2,
   <K extends string, A, B, C>(
     self: ReadonlyRecord<K, A>,
-    f: (a: A, key: K) => Result<C, B>
+    f: Filter.Filter<A, C, B, [key: K]>
   ): [left: Record<ReadonlyRecord.NonLiteralKey<K>, B>, right: Record<ReadonlyRecord.NonLiteralKey<K>, C>] => {
     const left: Record<string, B> = empty()
     const right: Record<string, C> = empty()
@@ -1354,126 +1364,7 @@ export const partitionMap: {
  */
 export const separate: <K extends string, A, B>(
   self: ReadonlyRecord<K, Result<B, A>>
-) => [Record<ReadonlyRecord.NonLiteralKey<K>, A>, Record<ReadonlyRecord.NonLiteralKey<K>, B>] = partitionMap(identity)
-
-/**
- * Partitions a record into two separate records based on the result of a predicate function.
- *
- * @example
- * ```ts
- * import { Record } from "effect"
- * import * as assert from "node:assert"
- *
- * assert.deepStrictEqual(
- *   Record.partition({ a: 1, b: 3 }, (n) => n > 2),
- *   [{ a: 1 }, { b: 3 }]
- * )
- * ```
- *
- * @category filtering
- * @since 2.0.0
- */
-export const partition: {
-  /**
-   * Partitions a record into two separate records based on the result of a predicate function.
-   *
-   * @example
-   * ```ts
-   * import { Record } from "effect"
-   * import * as assert from "node:assert"
-   *
-   * assert.deepStrictEqual(
-   *   Record.partition({ a: 1, b: 3 }, (n) => n > 2),
-   *   [{ a: 1 }, { b: 3 }]
-   * )
-   * ```
-   *
-   * @category filtering
-   * @since 2.0.0
-   */
-  <K extends string, A, B extends A>(refinement: (a: NoInfer<A>, key: K) => a is B): (
-    self: ReadonlyRecord<K, A>
-  ) => [
-    excluded: Record<ReadonlyRecord.NonLiteralKey<K>, Exclude<A, B>>,
-    satisfying: Record<ReadonlyRecord.NonLiteralKey<K>, B>
-  ]
-  /**
-   * Partitions a record into two separate records based on the result of a predicate function.
-   *
-   * @example
-   * ```ts
-   * import { Record } from "effect"
-   * import * as assert from "node:assert"
-   *
-   * assert.deepStrictEqual(
-   *   Record.partition({ a: 1, b: 3 }, (n) => n > 2),
-   *   [{ a: 1 }, { b: 3 }]
-   * )
-   * ```
-   *
-   * @category filtering
-   * @since 2.0.0
-   */
-  <K extends string, A>(predicate: (a: NoInfer<A>, key: K) => boolean): (
-    self: ReadonlyRecord<K, A>
-  ) => [excluded: Record<ReadonlyRecord.NonLiteralKey<K>, A>, satisfying: Record<ReadonlyRecord.NonLiteralKey<K>, A>]
-  /**
-   * Partitions a record into two separate records based on the result of a predicate function.
-   *
-   * @example
-   * ```ts
-   * import { Record } from "effect"
-   * import * as assert from "node:assert"
-   *
-   * assert.deepStrictEqual(
-   *   Record.partition({ a: 1, b: 3 }, (n) => n > 2),
-   *   [{ a: 1 }, { b: 3 }]
-   * )
-   * ```
-   *
-   * @category filtering
-   * @since 2.0.0
-   */
-  <K extends string, A, B extends A>(self: ReadonlyRecord<K, A>, refinement: (a: A, key: K) => a is B): [
-    excluded: Record<ReadonlyRecord.NonLiteralKey<K>, Exclude<A, B>>,
-    satisfying: Record<ReadonlyRecord.NonLiteralKey<K>, B>
-  ]
-  /**
-   * Partitions a record into two separate records based on the result of a predicate function.
-   *
-   * @example
-   * ```ts
-   * import { Record } from "effect"
-   * import * as assert from "node:assert"
-   *
-   * assert.deepStrictEqual(
-   *   Record.partition({ a: 1, b: 3 }, (n) => n > 2),
-   *   [{ a: 1 }, { b: 3 }]
-   * )
-   * ```
-   *
-   * @category filtering
-   * @since 2.0.0
-   */
-  <K extends string, A>(self: ReadonlyRecord<K, A>, predicate: (a: A, key: K) => boolean): [excluded: Record<ReadonlyRecord.NonLiteralKey<K>, A>, satisfying: Record<ReadonlyRecord.NonLiteralKey<K>, A>]
-} = dual(
-  2,
-  <K extends string, A>(
-    self: ReadonlyRecord<K, A>,
-    predicate: (a: A, key: K) => boolean
-  ): [excluded: Record<ReadonlyRecord.NonLiteralKey<K>, A>, satisfying: Record<ReadonlyRecord.NonLiteralKey<K>, A>] => {
-    const left: Record<string, A> = empty()
-    const right: Record<string, A> = empty()
-    for (const key of keys(self)) {
-      if (predicate(self[key], key)) {
-        right[key] = self[key]
-      } else {
-        left[key] = self[key]
-      }
-    }
-    return [left, right]
-  }
-)
+) => [Record<ReadonlyRecord.NonLiteralKey<K>, A>, Record<ReadonlyRecord.NonLiteralKey<K>, B>] = partition(identity)
 
 /**
  * Retrieve the keys of a given record as an array.

package/src/Reducer.ts

@@ -1,17 +1,107 @@
 /**
+ * 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
@@ -27,7 +117,44 @@ 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
  */
@@ -51,6 +178,38 @@ export function make<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 function flip<A>(reducer: Reducer<A>): Reducer<A> {

package/src/References.ts

@@ -11,7 +11,7 @@
  * @since 4.0.0
  */
 import { constTrue, constUndefined } from "./Function.ts"
-import type { LogLevel } from "./LogLevel.ts"
+import type { LogLevel, Severity } from "./LogLevel.ts"
 import type { ReadonlyRecord } from "./Record.ts"
 import { MaxOpsBeforeYield } from "./Scheduler.ts"
 import * as ServiceMap from "./ServiceMap.ts"
@@ -451,7 +451,7 @@ export const CurrentLogAnnotations = ServiceMap.Reference<ReadonlyRecord<string,
  * @category references
  * @since 4.0.0
  */
-export const CurrentLogLevel: ServiceMap.Reference<LogLevel> = ServiceMap.Reference<LogLevel>(
+export const CurrentLogLevel: ServiceMap.Reference<Severity> = ServiceMap.Reference<Severity>(
   "effect/References/CurrentLogLevel",
   { defaultValue: () => "Info" }
 )
@@ -516,9 +516,9 @@ export const MinimumLogLevel = ServiceMap.Reference<
  * @category references
  * @since 4.0.0
  */
-export const UnhandledLogLevel: ServiceMap.Reference<LogLevel | undefined> = ServiceMap.Reference(
+export const UnhandledLogLevel: ServiceMap.Reference<Severity | undefined> = ServiceMap.Reference(
   "effect/References/UnhandledLogLevel",
-  { defaultValue: (): LogLevel | undefined => "Error" }
+  { defaultValue: (): Severity | undefined => "Error" }
 )
 
 /**

package/src/Request.ts

@@ -88,7 +88,7 @@ export interface Variance<out A, out E, out R> {
  * @category models
  */
 export interface Constructor<R extends Request<any, any, any>, T extends keyof R = never> {
-  (args: Omit<R, T | keyof (Variance<any, any, any>)>): R
+  (args: Types.VoidIfEmpty<Types.Simplify<Omit<R, T | keyof (Variance<any, any, any>)>>>): R
 }
 
 /**
@@ -285,7 +285,8 @@ export const tagged = <R extends Request<any, any, any> & { _tag: string }>(
   tag: R["_tag"]
 ): Constructor<R, "_tag"> =>
 (args) => {
-  const request = Object.assign(Object.create(RequestPrototype), args)
+  const request = Object.create(RequestPrototype)
+  if (args) Object.assign(request, args)
   request._tag = tag
   return request
 }

package/src/RequestResolver.ts

@@ -652,7 +652,7 @@ export const setDelay: {
    * @since 4.0.0
    * @category delay
    */
-  (duration: Duration.DurationInput): <A extends Request.Any>(self: RequestResolver<A>) => RequestResolver<A>
+  (duration: Duration.Input): <A extends Request.Any>(self: RequestResolver<A>) => RequestResolver<A>
   /**
    * Sets the batch delay window for this request resolver to the specified duration.
    *
@@ -683,10 +683,10 @@ export const setDelay: {
    * @since 4.0.0
    * @category delay
    */
-  <A extends Request.Any>(self: RequestResolver<A>, duration: Duration.DurationInput): RequestResolver<A>
+  <A extends Request.Any>(self: RequestResolver<A>, duration: Duration.Input): RequestResolver<A>
 } = dual(
   2,
-  <A extends Request.Any>(self: RequestResolver<A>, duration: Duration.DurationInput): RequestResolver<A> =>
+  <A extends Request.Any>(self: RequestResolver<A>, duration: Duration.Input): RequestResolver<A> =>
     makeWith({
       ...self,
       delay: Effect.sleep(duration)
@@ -841,26 +841,6 @@ export const around: {
 /**
  * A request resolver that never executes requests.
  *
- * @example
- * ```ts
- * import { Effect, Request, RequestResolver } from "effect"
- *
- * // A resolver that will never complete
- * const neverResolver = RequestResolver.never
- *
- * // For testing timeout behavior with any request type
- * interface TestRequest extends Request.Request<string> {
- *   readonly _tag: "TestRequest"
- * }
- * const TestRequest = Request.tagged<TestRequest>("TestRequest")
- *
- * // This will never resolve
- * const neverEffect = Effect.request(TestRequest({}), Effect.succeed(neverResolver) as any)
- *
- * // Useful for testing timeout behavior
- * const timeoutTest = Effect.timeout(neverEffect, "1 second")
- * ```
- *
  * @since 2.0.0
  * @category constructors
  */
@@ -1468,7 +1448,7 @@ export const asCache: {
   >(
     options: {
       readonly capacity: number
-      readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.DurationInput) | undefined
+      readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined
       readonly requireServicesAt?: ServiceMode | undefined
     }
   ): (self: RequestResolver<A>) => Effect.Effect<
@@ -1495,7 +1475,7 @@ export const asCache: {
     self: RequestResolver<A>,
     options: {
       readonly capacity: number
-      readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.DurationInput) | undefined
+      readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined
       readonly requireServicesAt?: ServiceMode | undefined
     }
   ): Effect.Effect<
@@ -1513,7 +1493,7 @@ export const asCache: {
   ServiceMode extends "lookup" | "construction" = never
 >(self: RequestResolver<A>, options: {
   readonly capacity: number
-  readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.DurationInput) | undefined
+  readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined
   readonly requireServicesAt?: ServiceMode | undefined
 }): Effect.Effect<
   Cache.Cache<
@@ -1649,7 +1629,7 @@ export const persisted: {
   <A extends Request.Request<any, Persistence.PersistenceError | Schema.SchemaError, any> & Persistable.Any>(
     options: {
       readonly storeId: string
-      readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.DurationInput) | undefined
+      readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined
       readonly staleWhileRevalidate?: ((exit: Request.Result<A>, request: A) => boolean) | undefined
     }
   ): (self: RequestResolver<A>) => Effect.Effect<
@@ -1667,7 +1647,7 @@ export const persisted: {
     self: RequestResolver<A>,
     options: {
       readonly storeId: string
-      readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.DurationInput) | undefined
+      readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined
       readonly staleWhileRevalidate?: ((exit: Request.Result<A>, request: A) => boolean) | undefined
     }
   ): Effect.Effect<
@@ -1683,7 +1663,7 @@ export const persisted: {
     self: RequestResolver<A>,
     options: {
       readonly storeId: string
-      readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.DurationInput) | undefined
+      readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined
       readonly staleWhileRevalidate?: ((exit: Request.Result<A>, request: A) => boolean) | undefined
     }
   ) {

package/src/Result.ts

@@ -374,6 +374,19 @@ export {
   void_ as void
 }
 
+/**
+ * A pre-built `Result<void>` holding `undefined` as its failure value.
+ *
+ * - Use when you need a `Result` that represents "failed with no meaningful value"
+ * - Equivalent to `Result.fail(undefined)` but avoids an extra allocation
+ *
+ * @see {@link fail}
+ *
+ * @category Constructors
+ * @since 4.0.0
+ */
+export const failVoid: Result<never, void> = fail(void 0)
+
 /**
  * Converts a possibly `null` or `undefined` value into a `Result`.
  *