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

package/src/Duration.ts

@@ -90,7 +90,7 @@ export type Unit =
  * @since 2.0.0
  * @category models
  */
-export type DurationInput =
+export type Input =
   | Duration
   | number // millis
   | bigint // nanos
@@ -100,23 +100,23 @@ export type DurationInput =
 const DURATION_REGEXP = /^(-?\d+(?:\.\d+)?)\s+(nanos?|micros?|millis?|seconds?|minutes?|hours?|days?|weeks?)$/
 
 /**
- * Decodes a `DurationInput` into a `Duration`.
+ * Decodes a `Duration.Input` into a `Duration`.
  *
- * If the input is not a valid `DurationInput`, it throws an error.
+ * If the input is not a valid `Duration.Input`, it throws an error.
  *
  * @example
  * ```ts
  * import { Duration } from "effect"
  *
- * const duration1 = Duration.fromDurationInputUnsafe(1000) // 1000 milliseconds
- * const duration2 = Duration.fromDurationInputUnsafe("5 seconds")
- * const duration3 = Duration.fromDurationInputUnsafe([2, 500_000_000]) // 2 seconds and 500ms
+ * const duration1 = Duration.fromInputUnsafe(1000) // 1000 milliseconds
+ * const duration2 = Duration.fromInputUnsafe("5 seconds")
+ * const duration3 = Duration.fromInputUnsafe([2, 500_000_000]) // 2 seconds and 500ms
  * ```
  *
  * @since 2.0.0
  * @category constructors
  */
-export const fromDurationInputUnsafe = (input: DurationInput): Duration => {
+export const fromInputUnsafe = (input: Input): Duration => {
   if (isDuration(input)) return input
   if (isNumber(input)) return millis(input)
   if (isBigInt(input)) return nanos(input)
@@ -168,11 +168,11 @@ export const fromDurationInputUnsafe = (input: DurationInput): Duration => {
       }
     }
   }
-  throw new Error(`Invalid DurationInput: ${input}`)
+  throw new Error(`Invalid Input: ${input}`)
 }
 
 /**
- * Safely decodes a `DurationInput` value into a `Duration`, returning
+ * Safely decodes a `Input` value into a `Duration`, returning
  * `undefined` if decoding fails.
  *
  * **Example**
@@ -180,16 +180,16 @@ export const fromDurationInputUnsafe = (input: DurationInput): Duration => {
  * ```ts
  * import { Duration } from "effect"
  *
- * Duration.fromDurationInput(1000)?.pipe(Duration.toSeconds) // 1
+ * Duration.fromInput(1000)?.pipe(Duration.toSeconds) // 1
  *
- * Duration.fromDurationInput("invalid" as any) // undefined
+ * Duration.fromInput("invalid" as any) // undefined
  * ```
  *
  * @category constructors
  * @since 4.0.0
  */
-export const fromDurationInput: (u: DurationInput) => Duration | undefined = UndefinedOr.liftThrowable(
-  fromDurationInputUnsafe
+export const fromInput: (u: Input) => Duration | undefined = UndefinedOr.liftThrowable(
+  fromInputUnsafe
 )
 
 const zeroDurationValue: DurationValue = { _tag: "Millis", millis: 0 }
@@ -611,8 +611,8 @@ export const weeks = (weeks: number): Duration => make(weeks * 604_800_000)
  * @since 2.0.0
  * @category getters
  */
-export const toMillis = (self: Duration): number =>
-  match(self, {
+export const toMillis = (self: Input): number =>
+  match(fromInputUnsafe(self), {
     onMillis: identity,
     onNanos: (nanos) => Number(nanos) / 1_000_000,
     onInfinity: () => Infinity,

package/src/Effect.ts

@@ -7224,7 +7224,7 @@ export const timeout: {
    * @since 2.0.0
    * @category Delays & Timeouts
    */
-  (duration: Duration.DurationInput): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E | Cause.TimeoutError, R>
+  (duration: Duration.Input): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E | Cause.TimeoutError, R>
   // -----------------------------------------------------------------------------
   // Delays & timeouts
   // -----------------------------------------------------------------------------
@@ -7275,7 +7275,7 @@ export const timeout: {
    * @since 2.0.0
    * @category Delays & Timeouts
    */
-  <A, E, R>(self: Effect<A, E, R>, duration: Duration.DurationInput): Effect<A, E | Cause.TimeoutError, R>
+  <A, E, R>(self: Effect<A, E, R>, duration: Duration.Input): Effect<A, E | Cause.TimeoutError, R>
 } = internal.timeout
 
 /**
@@ -7377,7 +7377,7 @@ export const timeoutOption: {
    * @since 3.1.0
    * @category Delays & Timeouts
    */
-  (duration: Duration.DurationInput): <A, E, R>(self: Effect<A, E, R>) => Effect<Option<A>, E, R>
+  (duration: Duration.Input): <A, E, R>(self: Effect<A, E, R>) => Effect<Option<A>, E, R>
   /**
    * Handles timeouts by returning an `Option` that represents either the result
    * or a timeout.
@@ -7427,7 +7427,7 @@ export const timeoutOption: {
    * @since 3.1.0
    * @category Delays & Timeouts
    */
-  <A, E, R>(self: Effect<A, E, R>, duration: Duration.DurationInput): Effect<Option<A>, E, R>
+  <A, E, R>(self: Effect<A, E, R>, duration: Duration.Input): Effect<Option<A>, E, R>
 } = internal.timeoutOption
 
 /**
@@ -7505,7 +7505,7 @@ export const timeoutOrElse: {
    */
   <A2, E2, R2>(
     options: {
-      readonly duration: Duration.DurationInput
+      readonly duration: Duration.Input
       readonly onTimeout: LazyArg<Effect<A2, E2, R2>>
     }
   ): <A, E, R>(self: Effect<A, E, R>) => Effect<A | A2, E | E2, R | R2>
@@ -7548,7 +7548,7 @@ export const timeoutOrElse: {
   <A, E, R, A2, E2, R2>(
     self: Effect<A, E, R>,
     options: {
-      readonly duration: Duration.DurationInput
+      readonly duration: Duration.Input
       readonly onTimeout: LazyArg<Effect<A2, E2, R2>>
     }
   ): Effect<A | A2, E | E2, R | R2>
@@ -7595,7 +7595,7 @@ export const delay: {
    * @since 2.0.0
    * @category Delays & Timeouts
    */
-  (duration: Duration.DurationInput): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>
+  (duration: Duration.Input): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>
   /**
    * Returns an effect that is delayed from this effect by the specified
    * `Duration`.
@@ -7616,7 +7616,7 @@ export const delay: {
    * @since 2.0.0
    * @category Delays & Timeouts
    */
-  <A, E, R>(self: Effect<A, E, R>, duration: Duration.DurationInput): Effect<A, E, R>
+  <A, E, R>(self: Effect<A, E, R>, duration: Duration.Input): Effect<A, E, R>
 } = internal.delay
 
 /**
@@ -7641,7 +7641,7 @@ export const delay: {
  * @since 2.0.0
  * @category Delays & Timeouts
  */
-export const sleep: (duration: Duration.DurationInput) => Effect<void> = internal.sleep
+export const sleep: (duration: Duration.Input) => Effect<void> = internal.sleep
 
 /**
  * Measures the runtime of an effect and returns the duration with its result.
@@ -12272,7 +12272,7 @@ export const cachedWithTTL: {
    * @since 2.0.0
    * @category Caching
    */
-  (timeToLive: Duration.DurationInput): <A, E, R>(self: Effect<A, E, R>) => Effect<Effect<A, E, R>>
+  (timeToLive: Duration.Input): <A, E, R>(self: Effect<A, E, R>) => Effect<Effect<A, E, R>>
   /**
    * Returns an effect that caches its result for a specified `Duration`,
    * known as "timeToLive" (TTL).
@@ -12339,7 +12339,7 @@ export const cachedWithTTL: {
    * @since 2.0.0
    * @category Caching
    */
-  <A, E, R>(self: Effect<A, E, R>, timeToLive: Duration.DurationInput): Effect<Effect<A, E, R>>
+  <A, E, R>(self: Effect<A, E, R>, timeToLive: Duration.Input): Effect<Effect<A, E, R>>
 } = internal.cachedWithTTL
 
 /**
@@ -12481,7 +12481,7 @@ export const cachedInvalidateWithTTL: {
    * @since 2.0.0
    * @category Caching
    */
-  (timeToLive: Duration.DurationInput): <A, E, R>(self: Effect<A, E, R>) => Effect<[Effect<A, E, R>, Effect<void>]>
+  (timeToLive: Duration.Input): <A, E, R>(self: Effect<A, E, R>) => Effect<[Effect<A, E, R>, Effect<void>]>
   /**
    * Caches an effect's result for a specified duration and allows manual
    * invalidation before expiration.
@@ -12551,7 +12551,7 @@ export const cachedInvalidateWithTTL: {
    * @since 2.0.0
    * @category Caching
    */
-  <A, E, R>(self: Effect<A, E, R>, timeToLive: Duration.DurationInput): Effect<[Effect<A, E, R>, Effect<void>]>
+  <A, E, R>(self: Effect<A, E, R>, timeToLive: Duration.Input): Effect<[Effect<A, E, R>, Effect<void>]>
 } = internal.cachedInvalidateWithTTL
 
 // -----------------------------------------------------------------------------
@@ -21905,8 +21905,8 @@ export const trackDuration: {
       return onExit(self, () => {
         const endTime = clock.currentTimeNanosUnsafe()
         const duration = Duration.subtract(
-          Duration.fromDurationInputUnsafe(endTime),
-          Duration.fromDurationInputUnsafe(startTime)
+          Duration.fromInputUnsafe(endTime),
+          Duration.fromInputUnsafe(startTime)
         )
         const input = f === undefined ? duration : internalCall(() => f(duration))
         return Metric.update(metric, input as any)

package/src/Formatter.ts

@@ -1,10 +1,85 @@
 /**
+ * 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
  */
 import * as Predicate from "./Predicate.ts"
 import { getRedacted, redact, symbolRedactable } from "./Redactable.ts"
 
 /**
+ * A callable interface representing a function that converts a `Value` into a
+ * `Format` (defaults to `string`).
+ *
+ * When to use:
+ * - You want to type a formatting / rendering function generically.
+ * - You are building a pipeline that accepts pluggable formatters.
+ *
+ * Behavior:
+ * - Pure callable type; carries no runtime implementation.
+ * - Contravariant in `Value`, covariant in `Format`.
+ *
+ * **Example** (Define a custom formatter)
+ *
+ * ```ts
+ * import type { Formatter } from "effect"
+ *
+ * const upper: Formatter.Formatter<string> = (s) => s.toUpperCase()
+ *
+ * console.log(upper("hello"))
+ * // HELLO
+ * ```
+ *
+ * See also: {@link format}, {@link formatJson}
+ *
  * @category Model
  * @since 4.0.0
  */
@@ -15,31 +90,71 @@ export interface Formatter<in Value, out Format = string> {
 /**
  * Converts any JavaScript value into a human-readable string.
  *
- * For objects that don't have a `toString` method, it applies redaction to
- * protect sensitive information.
- *
- * Unlike `JSON.stringify`, this formatter:
- * - Handles circular references (printed as `"[Circular]"`).
- * - Supports additional types like `BigInt`, `Symbol`, `Set`, `Map`, `Date`, `RegExp`, and
- *   objects with custom `toString` methods.
- * - Includes constructor names for class instances (e.g. `MyClass({"a":1})`).
- * - Does not guarantee valid JSON output — the result is intended for debugging and inspection.
- *
- * Formatting rules:
- * - Primitives are stringified naturally (`null`, `undefined`, `123`, `"abc"`, `true`).
- * - Strings are JSON-quoted.
- * - Arrays and objects with a single element/property are formatted inline.
- * - Larger arrays/objects are pretty-printed with optional indentation.
- * - Circular references are replaced with the literal `"[Circular]"`.
- *
- * **Options**:
- * - `space`: Indentation used when pretty-printing:
- *   - If a number, that many spaces will be used.
- *   - If a string, the string is used as the indentation unit (e.g. `"\t"`).
- *   - If `0`, empty string, or `undefined`, output is compact (no indentation).
- *   Defaults to `0`.
- * - `ignoreToString`: If `true`, the `toString` method is not called on the value.
- *   Defaults to `false`.
+ * When to use:
+ * - Pretty-printing values for debugging, logging, or error messages.
+ * - You need to handle `BigInt`, `Symbol`, `Set`, `Map`, `Date`, `RegExp`,
+ *   or class instances that `JSON.stringify` cannot represent.
+ * - You want circular references shown as `"[Circular]"` instead of
+ *   throwing.
+ *
+ * Behavior:
+ * - Does not mutate input.
+ * - Output is **not** valid JSON; use {@link formatJson} when you need
+ *   parseable JSON.
+ * - Primitives: stringified naturally (`null`, `undefined`, `123`, `true`).
+ *   Strings are JSON-quoted.
+ * - Objects with a custom `toString` (not `Object.prototype.toString`):
+ *   `toString()` is called unless `ignoreToString` is `true`.
+ * - Errors with a `cause`: formatted as `"<message> (cause: <cause>)"`.
+ * - Iterables (`Set`, `Map`, etc.): formatted as
+ *   `ClassName([...elements])`.
+ * - Class instances: wrapped as `ClassName({...})`.
+ * - `Redactable` values are automatically redacted.
+ * - Arrays/objects with 0–1 entries are inline; larger ones are
+ *   pretty-printed when `space` is set.
+ * - Circular references are replaced with `"[Circular]"`.
+ *
+ * Options:
+ * - `space` — indentation unit (number of spaces, or a string like
+ *   `"\t"`). Defaults to `0` (compact).
+ * - `ignoreToString` — skip calling `toString()`. Defaults to `false`.
+ *
+ * **Example** (Compact output)
+ *
+ * ```ts
+ * import { Formatter } from "effect"
+ *
+ * console.log(Formatter.format({ a: 1, b: [2, 3] }))
+ * // {"a":1,"b":[2,3]}
+ * ```
+ *
+ * **Example** (Pretty-printed output)
+ *
+ * ```ts
+ * import { Formatter } from "effect"
+ *
+ * console.log(Formatter.format({ a: 1, b: [2, 3] }, { space: 2 }))
+ * // {
+ * //   "a": 1,
+ * //   "b": [
+ * //     2,
+ * //     3
+ * //   ]
+ * // }
+ * ```
+ *
+ * **Example** (Circular reference handling)
+ *
+ * ```ts
+ * import { Formatter } from "effect"
+ *
+ * const obj: any = { name: "loop" }
+ * obj.self = obj
+ * console.log(Formatter.format(obj))
+ * // {"name":"loop","self":[Circular]}
+ * ```
+ *
+ * See also: {@link formatJson}, {@link Formatter}
  *
  * @since 4.0.0
  */
@@ -131,7 +246,29 @@ export function format(input: unknown, options?: {
 const CIRCULAR = "[Circular]"
 
 /**
- * Fast path for formatting property keys.
+ * Formats a single property key for display.
+ *
+ * When to use:
+ * - You are building a custom formatter that needs to render object keys.
+ *
+ * Behavior:
+ * - String keys are JSON-quoted (e.g. `"foo"`).
+ * - Symbol and number keys are converted with `String()`.
+ * - Pure function; does not mutate input.
+ *
+ * **Example** (Format property keys)
+ *
+ * ```ts
+ * import { Formatter } from "effect"
+ *
+ * console.log(Formatter.formatPropertyKey("name"))
+ * // "name"
+ *
+ * console.log(Formatter.formatPropertyKey(Symbol.for("id")))
+ * // Symbol(id)
+ * ```
+ *
+ * See also: {@link formatPath}, {@link format}
  *
  * @internal
  */
@@ -140,7 +277,28 @@ export function formatPropertyKey(name: PropertyKey): string {
 }
 
 /**
- * Fast path for formatting property paths.
+ * Formats an array of property keys as a bracket-notation path string.
+ *
+ * When to use:
+ * - You need to display a path through a nested object (e.g. in error
+ *   messages or schema validation output).
+ *
+ * Behavior:
+ * - Each key is wrapped in brackets and formatted via
+ *   {@link formatPropertyKey}.
+ * - Returns an empty string for an empty path.
+ * - Pure function; does not mutate input.
+ *
+ * **Example** (Render a property path)
+ *
+ * ```ts
+ * import { Formatter } from "effect"
+ *
+ * console.log(Formatter.formatPath(["users", 0, "name"]))
+ * // ["users"][0]["name"]
+ * ```
+ *
+ * See also: {@link formatPropertyKey}, {@link format}
  *
  * @internal
  */
@@ -149,7 +307,31 @@ export function formatPath(path: ReadonlyArray<PropertyKey>): string {
 }
 
 /**
- * Fast path for formatting dates.
+ * Formats a `Date` as an ISO 8601 string, returning `"Invalid Date"` for
+ * invalid dates instead of throwing.
+ *
+ * When to use:
+ * - You want a safe `toISOString()` that never throws.
+ *
+ * Behavior:
+ * - Returns `date.toISOString()` on success.
+ * - Returns `"Invalid Date"` if `toISOString()` throws (e.g. for
+ *   `new Date(NaN)`).
+ * - Pure function; does not mutate input.
+ *
+ * **Example** (Safe date formatting)
+ *
+ * ```ts
+ * import { Formatter } from "effect"
+ *
+ * console.log(Formatter.formatDate(new Date("2024-01-15T10:30:00Z")))
+ * // 2024-01-15T10:30:00.000Z
+ *
+ * console.log(Formatter.formatDate(new Date("invalid")))
+ * // Invalid Date
+ * ```
+ *
+ * See also: {@link format}
  *
  * @internal
  */
@@ -171,42 +353,62 @@ function safeToString(input: any): string {
 }
 
 /**
- * Safely stringifies objects that may contain circular references.
+ * Safely stringifies a value to JSON, silently dropping circular references.
+ *
+ * When to use:
+ * - You need valid JSON output (unlike {@link format}).
+ * - The input may contain circular references and you want them silently
+ *   omitted rather than throwing a `TypeError`.
  *
- * This function performs JSON.stringify with circular reference detection and handling.
- * It also applies redaction to sensitive values and provides a safe fallback for
- * any objects that can't be serialized normally.
+ * Behavior:
+ * - Does not mutate input.
+ * - Uses `JSON.stringify` internally with a replacer that tracks seen
+ *   objects.
+ * - Circular references are replaced with `undefined` (omitted from
+ *   output).
+ * - `Redactable` values are automatically redacted before serialization.
+ * - Types not supported by JSON (`BigInt`, `Symbol`, `undefined`,
+ *   functions) follow standard `JSON.stringify` behavior (omitted or
+ *   `null` in arrays).
  *
- * **Options**:
- * - `space`: Indentation used when pretty-printing:
- *   - If a number, that many spaces will be used.
- *   - If a string, the string is used as the indentation unit (e.g. `"\t"`).
- *   - If `0`, empty string, or `undefined`, output is compact (no indentation).
- *   Defaults to `0`.
+ * Options:
+ * - `space` — indentation unit (number of spaces, or a string like
+ *   `"\t"`). Defaults to `0` (compact).
+ *
+ * **Example** (Compact JSON)
  *
- * @example
  * ```ts
- * import { formatJson } from "effect/Formatter"
+ * import { Formatter } from "effect"
  *
- * // Normal object
- * const simple = { name: "Alice", age: 30 }
- * console.log(formatJson(simple))
+ * console.log(Formatter.formatJson({ name: "Alice", age: 30 }))
  * // {"name":"Alice","age":30}
+ * ```
+ *
+ * **Example** (Circular reference handling)
+ *
+ * ```ts
+ * import { Formatter } from "effect"
  *
- * // Object with circular reference
- * const circular: any = { name: "test" }
- * circular.self = circular
- * console.log(formatJson(circular))
- * // {"name":"test"} (circular reference omitted)
+ * const obj: any = { name: "test" }
+ * obj.self = obj
+ * console.log(Formatter.formatJson(obj))
+ * // {"name":"test"}
+ * ```
+ *
+ * **Example** (Pretty-printed JSON)
  *
- * // With formatting
- * console.log(formatJson(simple, { space: 2 }))
+ * ```ts
+ * import { Formatter } from "effect"
+ *
+ * console.log(Formatter.formatJson({ name: "Alice", age: 30 }, { space: 2 }))
  * // {
  * //   "name": "Alice",
  * //   "age": 30
  * // }
  * ```
  *
+ * See also: {@link format}, {@link Formatter}
+ *
  * @since 4.0.0
  */
 export function formatJson(input: unknown, options?: {