effect 4.0.0-beta.5 → 4.0.0-beta.51

package/dist/Equal.js

@@ -2,7 +2,39 @@ import * as Hash from "./Hash.js";
 import { byReferenceInstances, getAllObjectKeys } from "./internal/equal.js";
 import { hasProperty } from "./Predicate.js";
 /**
- * The unique identifier used to identify objects that implement the `Equal` interface.
+ * The unique string identifier for the {@link Equal} interface.
+ *
+ * Use this as a computed property key when implementing custom equality on a
+ * class or object literal.
+ *
+ * When to use:
+ * - As the method name when implementing the {@link Equal} interface.
+ * - To check manually whether an object carries an equality method (prefer
+ *   {@link isEqual} instead).
+ *
+ * Behavior:
+ * - Pure constant — no allocation or side effects.
+ *
+ * **Example** (implementing Equal on a class)
+ *
+ * ```ts
+ * import { Equal, Hash } from "effect"
+ *
+ * class UserId implements Equal.Equal {
+ *   constructor(readonly id: string) {}
+ *
+ *   [Equal.symbol](that: Equal.Equal): boolean {
+ *     return that instanceof UserId && this.id === that.id
+ *   }
+ *
+ *   [Hash.symbol](): number {
+ *     return Hash.string(this.id)
+ *   }
+ * }
+ * ```
+ *
+ * @see {@link Equal} — the interface that uses this symbol
+ * @see {@link isEqual} — type guard for `Equal` implementors
  *
  * @since 2.0.0
  */
@@ -79,6 +111,11 @@ function compareObjects(self, that) {
         return false;
       }
       return compareArrays(self, that);
+    } else if (ArrayBuffer.isView(self)) {
+      if (!ArrayBuffer.isView(that) || self.byteLength !== that.byteLength) {
+        return false;
+      }
+      return compareTypedArrays(self, that);
     } else if (self instanceof Map) {
       if (!(that instanceof Map) || self.size !== that.size) {
         return false;
@@ -123,6 +160,17 @@ function compareArrays(self, that) {
   }
   return true;
 }
+function compareTypedArrays(self, that) {
+  if (self.length !== that.length) {
+    return false;
+  }
+  for (let i = 0; i < self.length; i++) {
+    if (self[i] !== that[i]) {
+      return false;
+    }
+  }
+  return true;
+}
 function compareRecords(self, that) {
   const selfKeys = getAllObjectKeys(self);
   const thatKeys = getAllObjectKeys(that);
@@ -175,37 +223,61 @@ export function makeCompareSet(equivalence) {
 }
 const compareSets = /*#__PURE__*/makeCompareSet(compareBoth);
 /**
- * Determines if a value implements the `Equal` interface.
+ * Checks whether a value implements the {@link Equal} interface.
+ *
+ * When to use:
+ * - To branch on whether a value supports custom equality before calling
+ *   its `[Equal.symbol]` method directly.
+ * - In generic utility code that needs to distinguish `Equal` implementors
+ *   from plain values.
+ *
+ * Behavior:
+ * - Pure function, no side effects.
+ * - Returns `true` if and only if `u` has a property keyed by
+ *   {@link symbol}.
+ * - Acts as a TypeScript type guard, narrowing the input to {@link Equal}.
+ *
+ * **Example** (type guard)
  *
- * @example
  * ```ts
  * import { Equal, Hash } from "effect"
- * import * as assert from "node:assert"
  *
- * class MyClass implements Equal.Equal {
+ * class Token implements Equal.Equal {
+ *   constructor(readonly value: string) {}
  *   [Equal.symbol](that: Equal.Equal): boolean {
- *     return that instanceof MyClass
+ *     return that instanceof Token && this.value === that.value
  *   }
  *   [Hash.symbol](): number {
- *     return 0
+ *     return Hash.string(this.value)
  *   }
  * }
  *
- * const instance = new MyClass()
- * assert(Equal.isEqual(instance) === true)
- * assert(Equal.isEqual({}) === false)
- * assert(Equal.isEqual(42) === false)
+ * console.log(Equal.isEqual(new Token("abc"))) // true
+ * console.log(Equal.isEqual({ x: 1 }))         // false
+ * console.log(Equal.isEqual(42))                // false
  * ```
  *
+ * @see {@link Equal} — the interface being checked
+ * @see {@link symbol} — the property key that signals `Equal` support
+ *
  * @category guards
  * @since 2.0.0
  */
 export const isEqual = u => hasProperty(u, symbol);
 /**
- * Creates an `Equivalence` instance using the `equals` function.
- * This allows the equality logic to be used with APIs that expect an `Equivalence`.
+ * Wraps {@link equals} as an `Equivalence<A>`.
+ *
+ * When to use:
+ * - When an API (e.g. `Array.dedupeWith`, `Equivalence.mapInput`) requires an
+ *   `Equivalence` and you want to reuse `Equal.equals`.
+ *
+ * Behavior:
+ * - Returns a function `(a: A, b: A) => boolean` that delegates to
+ *   {@link equals}.
+ * - Pure; allocates a thin wrapper on each call.
+ *
+ * **Example** (deduplicating with Equal semantics)
  *
- * @example
  * ```ts
  * import { Array, Equal } from "effect"
  *
@@ -214,70 +286,90 @@ export const isEqual = u => hasProperty(u, symbol);
  * console.log(result) // [1, 2, 3]
  * ```
  *
+ * @see {@link equals} — the underlying comparison function
+ *
  * @category instances
  * @since 2.0.0
  */
 export const asEquivalence = () => equals;
 /**
- * Creates a proxy of an object that uses reference equality instead of structural equality.
+ * Creates a proxy that uses reference equality instead of structural equality.
  *
- * By default, plain objects and arrays use structural equality. This function creates
- * a proxy that behaves exactly like the original object but uses reference equality
- * for comparison purposes.
+ * When to use:
+ * - When you have a plain object or array that should be compared by identity
+ *   (reference), not by contents.
+ * - When you want to preserve the original object unchanged and get a new
+ *   reference-equal handle.
  *
- * @example
- * ```ts
- * import { Equal } from "effect"
- * import * as assert from "node:assert"
+ * Behavior:
+ * - Returns a `Proxy` wrapping `obj`. The proxy reads through to the
+ *   original, so property access is unchanged.
+ * - The proxy is registered in an internal WeakSet; {@link equals} returns
+ *   `false` for any pair where at least one operand is in that set (unless
+ *   they are the same reference).
+ * - Each call creates a **new** proxy, so `byReference(x) !== byReference(x)`.
+ * - Does **not** mutate the original object (unlike {@link byReferenceUnsafe}).
  *
- * const obj1 = { a: 1, b: 2 }
- * const obj2 = { a: 1, b: 2 }
+ * **Example** (opting out of structural equality)
  *
- * // Normal structural equality
- * assert(Equal.equals(obj1, obj2) === true)
+ * ```ts
+ * import { Equal } from "effect"
  *
- * // Create reference equality version
- * const obj1ByRef = Equal.byReference(obj1)
- * assert(Equal.equals(obj1ByRef, obj2) === false) // uses reference equality
- * assert(Equal.equals(obj1ByRef, obj1ByRef) === true) // same reference
+ * const a = { x: 1 }
+ * const b = { x: 1 }
  *
- * // Each call creates a new proxy instance
- * const obj1ByRef2 = Equal.byReference(obj1)
- * assert(Equal.equals(obj1ByRef, obj1ByRef2) === false) // different instances
+ * console.log(Equal.equals(a, b)) // true  (structural)
  *
- * // Proxy behaves like the original
- * assert(obj1ByRef.a === 1)
+ * const aRef = Equal.byReference(a)
+ * console.log(Equal.equals(aRef, b))    // false (reference)
+ * console.log(Equal.equals(aRef, aRef)) // true  (same reference)
+ * console.log(aRef.x)                   // 1     (proxy reads through)
  * ```
  *
+ * @see {@link byReferenceUnsafe} — same effect without a proxy (mutates the
+ *   original)
+ * @see {@link equals} — the comparison function affected by this opt-out
+ *
  * @category utility
  * @since 2.0.0
  */
 export const byReference = obj => byReferenceUnsafe(new Proxy(obj, {}));
 /**
- * Marks an object to use reference equality instead of structural equality, without creating a proxy.
+ * Permanently marks an object to use reference equality, without creating a
+ * proxy.
+ *
+ * When to use:
+ * - When you want reference equality semantics and can accept that the
+ *   original object is **permanently** modified.
+ * - When proxy overhead is unacceptable (hot paths, large collections).
  *
- * Unlike `byReference`, this function directly modifies the object's equality behavior
- * without creating a proxy wrapper. This is more performant but "unsafe" because
- * it permanently changes how the object is compared.
+ * Behavior:
+ * - Adds `obj` to an internal WeakSet. From that point on, {@link equals}
+ *   treats it as reference-only.
+ * - Returns the **same** object (not a copy or proxy), so
+ *   `byReferenceUnsafe(x) === x`.
+ * - The marking is irreversible for the lifetime of the object.
+ * - Does **not** affect the object's prototype, properties, or behavior
+ *   beyond equality checks.
+ *
+ * **Example** (marking an object for reference equality)
  *
- * @example
  * ```ts
  * import { Equal } from "effect"
- * import * as assert from "node:assert"
  *
  * const obj1 = { a: 1, b: 2 }
  * const obj2 = { a: 1, b: 2 }
  *
- * // Mark obj1 for reference equality (modifies obj1 directly)
- * const obj1ByRef = Equal.byReferenceUnsafe(obj1)
- * assert(obj1ByRef === obj1) // Same object, no proxy created
- * assert(Equal.equals(obj1ByRef, obj2) === false) // uses reference equality
- * assert(Equal.equals(obj1ByRef, obj1ByRef) === true) // same reference
+ * Equal.byReferenceUnsafe(obj1)
  *
- * // The original obj1 is now permanently marked for reference equality
- * assert(Equal.equals(obj1, obj2) === false) // obj1 uses reference equality
+ * console.log(Equal.equals(obj1, obj2))   // false (reference)
+ * console.log(Equal.equals(obj1, obj1))   // true  (same reference)
+ * console.log(obj1 === Equal.byReferenceUnsafe(obj1)) // true (same object)
  * ```
  *
+ * @see {@link byReference} — safer alternative that creates a proxy
+ * @see {@link equals} — the comparison function affected by this opt-out
+ *
  * @category utility
  * @since 2.0.0
  */

package/dist/Equal.js.map

@@ -1 +1 @@
-{"version":3,"file":"Equal.js","names":["Hash","byReferenceInstances","getAllObjectKeys","hasProperty","symbol","equals","arguments","length","self","compareBoth","that","selfType","has","withCache","compareObjects","withVisitedTracking","fn","hasLeft","visitedLeft","hasRight","visitedRight","add","result","delete","WeakSet","hash","Date","toISOString","RegExp","toString","selfIsEqual","isEqual","thatIsEqual","bothEquals","Array","isArray","compareArrays","Map","size","compareMaps","Set","compareSets","compareRecords","f","selfMap","equalityCache","get","WeakMap","set","thatMap","i","selfKeys","thatKeys","key","makeCompareMap","keyEquivalence","valueEquivalence","selfKey","selfValue","found","thatKey","thatValue","makeCompareSet","equivalence","u","asEquivalence","byReference","obj","byReferenceUnsafe","Proxy"],"sources":["../src/Equal.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}
+{"version":3,"file":"Equal.js","names":["Hash","byReferenceInstances","getAllObjectKeys","hasProperty","symbol","equals","arguments","length","self","compareBoth","that","selfType","has","withCache","compareObjects","withVisitedTracking","fn","hasLeft","visitedLeft","hasRight","visitedRight","add","result","delete","WeakSet","hash","Date","toISOString","RegExp","toString","selfIsEqual","isEqual","thatIsEqual","bothEquals","Array","isArray","compareArrays","ArrayBuffer","isView","byteLength","compareTypedArrays","Map","size","compareMaps","Set","compareSets","compareRecords","f","selfMap","equalityCache","get","WeakMap","set","thatMap","i","selfKeys","thatKeys","key","makeCompareMap","keyEquivalence","valueEquivalence","selfKey","selfValue","found","thatKey","thatValue","makeCompareSet","equivalence","u","asEquivalence","byReference","obj","byReferenceUnsafe","Proxy"],"sources":["../src/Equal.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/dist/Equivalence.d.ts

@@ -697,7 +697,7 @@ export declare const mapInput: {
  * ) // true
  * ```
  *
- * See also: {@link Array}, {@link Struct}
+ * See also: {@link Array_}, {@link Struct}
  *
  * @category combinators
  * @since 4.0.0
@@ -705,6 +705,11 @@ export declare const mapInput: {
 export declare function Tuple<const Elements extends ReadonlyArray<Equivalence<any>>>(elements: Elements): Equivalence<{
     readonly [I in keyof Elements]: [Elements[I]] extends [Equivalence<infer A>] ? A : never;
 }>;
+/**
+ * @since 4.0.0
+ */
+declare function Array_<A>(item: Equivalence<A>): Equivalence<ReadonlyArray<A>>;
+export { 
 /**
  * Creates an equivalence for arrays where all elements are compared using the same equivalence.
  *
@@ -755,7 +760,7 @@ export declare function Tuple<const Elements extends ReadonlyArray<Equivalence<a
  * @category combinators
  * @since 4.0.0
  */
-export declare function Array<A>(item: Equivalence<A>): Equivalence<ReadonlyArray<A>>;
+Array_ as Array };
 /**
  * Creates an equivalence for objects by comparing their properties using provided equivalences.
  *
@@ -877,7 +882,7 @@ export declare function Struct<R extends Record<string, Equivalence<any>>>(field
  * console.log(numberRecordEq(scores1, scores3)) // false
  * ```
  *
- * See also: {@link Struct}, {@link Array}
+ * See also: {@link Struct}, {@link Array_}
  *
  * @category combinators
  * @since 4.0.0
@@ -923,4 +928,56 @@ export declare function Record<A>(value: Equivalence<A>): Equivalence<Record<Pro
  * @since 4.0.0
  */
 export declare function makeReducer<A>(): Reducer.Reducer<Equivalence<A>>;
+/**
+ * An `Equivalence` instance for `Date` objects.
+ *
+ * Dates are compared by their time value (milliseconds since the Unix epoch),
+ * using {@link Date.prototype.getTime}.
+ *
+ * When to use this:
+ * - When comparing `Date` objects by their exact point in time
+ * - When you need value-based equality instead of reference equality
+ * - When working with collections that contain `Date` values
+ *
+ * Behavior:
+ * - Does not mutate inputs
+ * - Two dates are equivalent if `self.getTime() === that.getTime()`
+ * - Internally uses {@link Number} equivalence
+ * - Different `Date` instances representing the same time are considered equivalent
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Equivalence } from "effect"
+ *
+ * const d1 = new Date("2020-01-01T00:00:00.000Z")
+ * const d2 = new Date("2020-01-01T00:00:00.000Z")
+ * const d3 = new Date("2021-01-01T00:00:00.000Z")
+ * const invalidDate1 = new Date("foo")
+ * const invalidDate2 = new Date("bar")
+ *
+ * console.log(Equivalence.Date(d1, d2)) // true
+ * console.log(Equivalence.Date(d1, d3)) // false
+ * console.log(Equivalence.Date(invalidDate1, invalidDate2)) // true
+ * console.log(Equivalence.Date(invalidDate1, d1)) // false
+ * ```
+ *
+ * **Example** (Reference vs value equality)
+ *
+ * ```ts
+ * import { Equivalence } from "effect"
+ *
+ * const d1 = new Date(0)
+ * const d2 = new Date(0)
+ *
+ * console.log(d1 === d2) // false (different references)
+ * console.log(Equivalence.Date(d1, d2)) // true (same time value)
+ * ```
+ *
+ * See also: {@link Number}, {@link mapInput}, {@link strictEqual}
+ *
+ * @category instances
+ * @since 4.0.0
+ */
+export declare const Date: Equivalence<Date>;
 //# sourceMappingURL=Equivalence.d.ts.map

package/dist/Equivalence.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Equivalence.d.ts","sourceRoot":"","sources":["../src/Equivalence.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"Equivalence.d.ts","sourceRoot":"","sources":["../src/Equivalence.ts"],"names":[],"mappings":"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"}

package/dist/Equivalence.js

@@ -18,7 +18,7 @@
  * - Using strict equality (`===`) → {@link strictEqual}
  * - Combining multiple equivalences (AND logic) → {@link combine}, {@link combineAll}
  * - Transforming input before comparison → {@link mapInput}
- * - Creating equivalences for structured types → {@link Struct}, {@link Tuple}, {@link Array}, {@link Record}
+ * - Creating equivalences for structured types → {@link Struct}, {@link Tuple}, {@link Array_}, {@link Record}
  *
  * ## Gotchas
  *
@@ -46,7 +46,7 @@
  * ## See also
  *
  * - {@link Equal} - For structural equality (can convert to Equivalence)
- * - {@link Array.dedupeWith} - Remove duplicates using an equivalence
+ * - {@link Array_.dedupeWith} - Remove duplicates using an equivalence
  * - {@link Chunk} - Collections that use equivalences for operations
  *
  * @since 2.0.0
@@ -451,7 +451,7 @@ export const mapInput = /*#__PURE__*/dual(2, (self, f) => make((x, y) => self(f(
  * ) // true
  * ```
  *
- * See also: {@link Array}, {@link Struct}
+ * See also: {@link Array_}, {@link Struct}
  *
  * @category combinators
  * @since 4.0.0
@@ -469,6 +469,19 @@ export function Tuple(elements) {
     return true;
   });
 }
+/**
+ * @since 4.0.0
+ */
+function Array_(item) {
+  return make((self, that) => {
+    if (self.length !== that.length) return false;
+    for (let i = 0; i < self.length; i++) {
+      if (!item(self[i], that[i])) return false;
+    }
+    return true;
+  });
+}
+export {
 /**
  * Creates an equivalence for arrays where all elements are compared using the same equivalence.
  *
@@ -519,15 +532,7 @@ export function Tuple(elements) {
  * @category combinators
  * @since 4.0.0
  */
-export function Array(item) {
-  return make((self, that) => {
-    if (self.length !== that.length) return false;
-    for (let i = 0; i < self.length; i++) {
-      if (!item(self[i], that[i])) return false;
-    }
-    return true;
-  });
-}
+Array_ as Array };
 /**
  * Creates an equivalence for objects by comparing their properties using provided equivalences.
  *
@@ -655,7 +660,7 @@ export function Struct(fields) {
  * console.log(numberRecordEq(scores1, scores3)) // false
  * ```
  *
- * See also: {@link Struct}, {@link Array}
+ * See also: {@link Struct}, {@link Array_}
  *
  * @category combinators
  * @since 4.0.0
@@ -715,4 +720,56 @@ export function Record(value) {
 export function makeReducer() {
   return Reducer.make(combine, () => true, combineAll);
 }
+/**
+ * An `Equivalence` instance for `Date` objects.
+ *
+ * Dates are compared by their time value (milliseconds since the Unix epoch),
+ * using {@link Date.prototype.getTime}.
+ *
+ * When to use this:
+ * - When comparing `Date` objects by their exact point in time
+ * - When you need value-based equality instead of reference equality
+ * - When working with collections that contain `Date` values
+ *
+ * Behavior:
+ * - Does not mutate inputs
+ * - Two dates are equivalent if `self.getTime() === that.getTime()`
+ * - Internally uses {@link Number} equivalence
+ * - Different `Date` instances representing the same time are considered equivalent
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Equivalence } from "effect"
+ *
+ * const d1 = new Date("2020-01-01T00:00:00.000Z")
+ * const d2 = new Date("2020-01-01T00:00:00.000Z")
+ * const d3 = new Date("2021-01-01T00:00:00.000Z")
+ * const invalidDate1 = new Date("foo")
+ * const invalidDate2 = new Date("bar")
+ *
+ * console.log(Equivalence.Date(d1, d2)) // true
+ * console.log(Equivalence.Date(d1, d3)) // false
+ * console.log(Equivalence.Date(invalidDate1, invalidDate2)) // true
+ * console.log(Equivalence.Date(invalidDate1, d1)) // false
+ * ```
+ *
+ * **Example** (Reference vs value equality)
+ *
+ * ```ts
+ * import { Equivalence } from "effect"
+ *
+ * const d1 = new Date(0)
+ * const d2 = new Date(0)
+ *
+ * console.log(d1 === d2) // false (different references)
+ * console.log(Equivalence.Date(d1, d2)) // true (same time value)
+ * ```
+ *
+ * See also: {@link Number}, {@link mapInput}, {@link strictEqual}
+ *
+ * @category instances
+ * @since 4.0.0
+ */
+export const Date = /*#__PURE__*/mapInput(Number, d => d.getTime());
 //# sourceMappingURL=Equivalence.js.map

package/dist/Equivalence.js.map

@@ -1 +1 @@
-{"version":3,"file":"Equivalence.js","names":["dual","Reducer","make","isEquivalent","self","that","isStrictEquivalent","x","y","strictEqual","String","Number","globalThis","isNaN","Boolean","BigInt","combine","combineAll","collection","equivalence","mapInput","f","Tuple","elements","length","i","Array","item","Struct","fields","keys","Reflect","ownKeys","key","Record","value","selfKeys","thatKeys","Object","hasOwn","makeReducer"],"sources":["../src/Equivalence.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}
+{"version":3,"file":"Equivalence.js","names":["dual","Reducer","make","isEquivalent","self","that","isStrictEquivalent","x","y","strictEqual","String","Number","globalThis","isNaN","Boolean","BigInt","combine","combineAll","collection","equivalence","mapInput","f","Tuple","elements","length","i","Array_","item","Array","Struct","fields","keys","Reflect","ownKeys","key","Record","value","selfKeys","thatKeys","Object","hasOwn","makeReducer","Date","d","getTime"],"sources":["../src/Equivalence.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}