effect 4.0.0-beta.5 → 4.0.0-beta.7

package/src/Equal.ts

@@ -269,7 +269,7 @@ function compareRecords(
 
 /** @internal */
 export function makeCompareMap<K, V>(keyEquivalence: Equivalence<K>, valueEquivalence: Equivalence<V>) {
-  return function compareMaps(self: ReadonlyMap<K, V>, that: ReadonlyMap<K, V>): boolean {
+  return function compareMaps(self: Iterable<[K, V]>, that: Iterable<[K, V]>): boolean {
     for (const [selfKey, selfValue] of self) {
       let found = false
       for (const [thatKey, thatValue] of that) {
@@ -291,7 +291,7 @@ const compareMaps = makeCompareMap(compareBoth, compareBoth)
 
 /** @internal */
 export function makeCompareSet<A>(equivalence: Equivalence<A>) {
-  return function compareSets(self: ReadonlySet<A>, that: ReadonlySet<A>): boolean {
+  return function compareSets(self: Iterable<A>, that: Iterable<A>): boolean {
     for (const selfValue of self) {
       let found = false
       for (const thatValue of that) {

package/src/FileSystem.ts

@@ -756,16 +756,16 @@ export const make = (
       const bytesToRead = options?.bytesToRead !== undefined ? Size(options.bytesToRead) : undefined
       let totalBytesRead = BigInt(0)
       const chunkSize = Size(options?.chunkSize ?? 64 * 1024)
+      const readChunk = file.readAlloc(chunkSize)
       return Stream.fromPull(Effect.succeed(
         Effect.flatMap(
           Effect.suspend((): Pull.Pull<Uint8Array | undefined, PlatformError> => {
             if (bytesToRead !== undefined && bytesToRead <= totalBytesRead) {
               return Cause.done()
             }
-            const toRead = bytesToRead !== undefined && (bytesToRead - totalBytesRead) < chunkSize
-              ? bytesToRead - totalBytesRead
-              : chunkSize
-            return file.readAlloc(toRead)
+            return bytesToRead !== undefined && (bytesToRead - totalBytesRead) < chunkSize
+              ? file.readAlloc(bytesToRead - totalBytesRead)
+              : readChunk
           }),
           (buf) => {
             if (!buf) return Cause.done()

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
  */
@@ -101,7 +216,7 @@ export function format(input: unknown, options?: {
 
     if (typeof v === "bigint") return String(v) + "n"
 
-    if (Predicate.isObject(v)) {
+    if (typeof v === "object" || typeof v === "function") {
       if (seen.has(v)) return CIRCULAR
       seen.add(v)
 
@@ -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?: {

package/src/Graph.ts

@@ -1200,11 +1200,14 @@ export const reverse = <N, E, T extends Kind = "directed">(
 ): void => {
   // Reverse all edges by swapping source and target
   for (const [index, edgeData] of mutable.edges) {
-    mutable.edges.set(index, {
-      source: edgeData.target,
-      target: edgeData.source,
-      data: edgeData.data
-    })
+    mutable.edges.set(
+      index,
+      new Edge({
+        source: edgeData.target,
+        target: edgeData.source,
+        data: edgeData.data
+      })
+    )
   }
 
   // Clear and rebuild adjacency lists with reversed directions