effect 4.0.0-beta.102 → 4.0.0-beta.103

package/src/Encoding.ts

@@ -64,7 +64,7 @@ export type EncodingErrorTypeId = typeof EncodingErrorTypeId
  * message.
  *
  * @see {@link isEncodingError} for checking whether a value is an EncodingError
- * @category constructors
+ * @category errors
  * @since 4.0.0
  */
 export class EncodingError extends Data.TaggedError("EncodingError")<{
@@ -126,15 +126,15 @@ export const isEncodingError = (u: unknown): u is EncodingError => hasProperty(u
  *
  * **Example** (Encoding Base64 strings and bytes)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Encoding } from "effect"
  *
  * // Encode a string
- * console.log(Encoding.encodeBase64("hello")) // "aGVsbG8="
+ * Encoding.encodeBase64("hello") // => "aGVsbG8="
  *
  * // Encode binary data
  * const bytes = new Uint8Array([72, 101, 108, 108, 111])
- * console.log(Encoding.encodeBase64(bytes)) // "SGVsbG8="
+ * Encoding.encodeBase64(bytes) // => "SGVsbG8="
  * ```
  *
  * @see {@link decodeBase64} for decoding standard Base64 to bytes
@@ -162,13 +162,10 @@ export const encodeBase64: (input: Uint8Array | string) => string = (input) =>
  *
  * **Example** (Decoding Base64 bytes)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Encoding, Result } from "effect"
  *
- * const result = Encoding.decodeBase64("SGVsbG8=")
- * if (Result.isSuccess(result)) {
- *   console.log(Array.from(result.success)) // [72, 101, 108, 108, 111]
- * }
+ * Encoding.decodeBase64("SGVsbG8=") // => Result.succeed(new Uint8Array([72, 101, 108, 108, 111]))
  * ```
  *
  * @category decoding
@@ -242,13 +239,10 @@ export const decodeBase64 = (str: string): Result.Result<Uint8Array, EncodingErr
  *
  * **Example** (Decoding Base64 strings)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Encoding, Result } from "effect"
  *
- * const result = Encoding.decodeBase64String("aGVsbG8=")
- * if (Result.isSuccess(result)) {
- *   console.log(result.success) // "hello"
- * }
+ * Encoding.decodeBase64String("aGVsbG8=") // => Result.succeed("hello")
  * ```
  *
  * @category decoding
@@ -276,14 +270,14 @@ export const decodeBase64String = (str: string) => Result.map(decodeBase64(str),
  *
  * **Example** (Encoding URL-safe Base64)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Encoding } from "effect"
  *
  * // URL-safe base64 encoding (uses - and _ instead of + and /)
- * console.log(Encoding.encodeBase64Url("hello?")) // "aGVsbG8_"
+ * Encoding.encodeBase64Url("hello?") // => "aGVsbG8_"
  *
  * const bytes = new Uint8Array([72, 101, 108, 108, 111, 63])
- * console.log(Encoding.encodeBase64Url(bytes)) // "SGVsbG8_"
+ * Encoding.encodeBase64Url(bytes) // => "SGVsbG8_"
  * ```
  *
  * @see {@link decodeBase64Url} for decoding URL-safe Base64 to bytes
@@ -313,13 +307,10 @@ export const encodeBase64Url: (input: Uint8Array | string) => string = (input) =
  *
  * **Example** (Decoding URL-safe Base64 bytes)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Encoding, Result } from "effect"
  *
- * const result = Encoding.decodeBase64Url("SGVsbG8_")
- * if (Result.isSuccess(result)) {
- *   console.log(Array.from(result.success)) // [72, 101, 108, 108, 111, 63]
- * }
+ * Encoding.decodeBase64Url("SGVsbG8_") // => Result.succeed(new Uint8Array([72, 101, 108, 108, 111, 63]))
  * ```
  *
  * @category decoding
@@ -373,13 +364,10 @@ export const decodeBase64Url = (str: string): Result.Result<Uint8Array, Encoding
  *
  * **Example** (Decoding URL-safe Base64 strings)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Encoding, Result } from "effect"
  *
- * const result = Encoding.decodeBase64UrlString("aGVsbG8_")
- * if (Result.isSuccess(result)) {
- *   console.log(result.success) // "hello?"
- * }
+ * Encoding.decodeBase64UrlString("aGVsbG8_") // => Result.succeed("hello?")
  * ```
  *
  * @category decoding
@@ -400,15 +388,15 @@ export const decodeBase64UrlString = (str: string) => Result.map(decodeBase64Url
  *
  * **Example** (Encoding hex strings and bytes)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Encoding } from "effect"
  *
  * // Encode a string to hex
- * console.log(Encoding.encodeHex("hello")) // "68656c6c6f"
+ * Encoding.encodeHex("hello") // => "68656c6c6f"
  *
  * // Encode binary data to hex
  * const bytes = new Uint8Array([72, 101, 108, 108, 111])
- * console.log(Encoding.encodeHex(bytes)) // "48656c6c6f"
+ * Encoding.encodeHex(bytes) // => "48656c6c6f"
  * ```
  *
  * @category encoding
@@ -432,13 +420,10 @@ export const encodeHex: (input: Uint8Array | string) => string = (input) =>
  *
  * **Example** (Decoding hex bytes)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Encoding, Result } from "effect"
  *
- * const result = Encoding.decodeHex("48656c6c6f")
- * if (Result.isSuccess(result)) {
- *   console.log(Array.from(result.success)) // [72, 101, 108, 108, 111]
- * }
+ * Encoding.decodeHex("48656c6c6f") // => Result.succeed(new Uint8Array([72, 101, 108, 108, 111]))
  * ```
  *
  * @category decoding
@@ -494,13 +479,10 @@ export const decodeHex = (str: string): Result.Result<Uint8Array, EncodingError>
  *
  * **Example** (Decoding hex strings)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Encoding, Result } from "effect"
  *
- * const result = Encoding.decodeHexString("68656c6c6f")
- * if (Result.isSuccess(result)) {
- *   console.log(result.success) // "hello"
- * }
+ * Encoding.decodeHexString("68656c6c6f") // => Result.succeed("hello")
  * ```
  *
  * @category decoding

package/src/Equal.ts

@@ -28,7 +28,7 @@ import { hasProperty } from "./Predicate.ts"
  *
  * **Example** (Implementing Equal on a class)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Equal, Hash } from "effect"
  *
  * class UserId implements Equal.Equal {
@@ -42,6 +42,9 @@ import { hasProperty } from "./Predicate.ts"
  *     return Hash.string(this.id)
  *   }
  * }
+ *
+ * Equal.equals(new UserId("1"), new UserId("1")) // => true
+ * Equal.equals(new UserId("1"), new UserId("2")) // => false
  * ```
  *
  * @see {@link Equal} — the interface that uses this symbol
@@ -76,7 +79,7 @@ export const symbol = "~effect/interfaces/Equal"
  *
  * **Example** (Comparing coordinates by value)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Equal, Hash } from "effect"
  *
  * class Coordinate implements Equal.Equal {
@@ -93,8 +96,8 @@ export const symbol = "~effect/interfaces/Equal"
  *   }
  * }
  *
- * console.log(Equal.equals(new Coordinate(1, 2), new Coordinate(1, 2))) // true
- * console.log(Equal.equals(new Coordinate(1, 2), new Coordinate(3, 4))) // false
+ * Equal.equals(new Coordinate(1, 2), new Coordinate(1, 2)) // => true
+ * Equal.equals(new Coordinate(1, 2), new Coordinate(3, 4)) // => false
  * ```
  *
  * @see {@link symbol} — the property key used by the equality method
@@ -139,30 +142,25 @@ export interface Equal extends Hash.Hash {
  *
  * **Example** (Comparing values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Equal } from "effect"
  *
- * // Primitives
- * console.log(Equal.equals(1, 1))         // true
- * console.log(Equal.equals(NaN, NaN))     // true
- * console.log(Equal.equals("a", "b"))     // false
+ * Equal.equals(1, 1) // => true
+ * Equal.equals(NaN, NaN) // => true
+ * Equal.equals("a", "b") // => false
  *
- * // Objects and arrays
- * console.log(Equal.equals({ a: 1, b: 2 }, { a: 1, b: 2 })) // true
- * console.log(Equal.equals([1, [2, 3]], [1, [2, 3]]))         // true
+ * Equal.equals({ a: 1, b: 2 }, { a: 1, b: 2 }) // => true
+ * Equal.equals([1, [2, 3]], [1, [2, 3]]) // => true
  *
- * // Dates
- * console.log(Equal.equals(new Date("2024-01-01"), new Date("2024-01-01"))) // true
+ * Equal.equals(new Date("2024-01-01"), new Date("2024-01-01")) // => true
  *
- * // Maps (order-independent)
  * const m1 = new Map([["a", 1], ["b", 2]])
  * const m2 = new Map([["b", 2], ["a", 1]])
- * console.log(Equal.equals(m1, m2)) // true
+ * Equal.equals(m1, m2) // => true
  *
- * // Curried form
  * const is5 = Equal.equals(5)
- * console.log(is5(5)) // true
- * console.log(is5(3)) // false
+ * is5(5) // => true
+ * is5(3) // => false
  * ```
  *
  * @see {@link Equal} — the interface for custom equality
@@ -235,7 +233,9 @@ function compareObjects(self: object, that: object): boolean {
     return false
   } else if (self instanceof Date) {
     if (!(that instanceof Date)) return false
-    return self.toISOString() === that.toISOString()
+    const selfTime = self.getTime()
+    const thatTime = that.getTime()
+    return selfTime === thatTime || (Number.isNaN(selfTime) && Number.isNaN(thatTime))
   } else if (self instanceof RegExp) {
     if (!(that instanceof RegExp)) return false
     return self.toString() === that.toString()
@@ -256,9 +256,21 @@ function compareObjects(self: object, that: object): boolean {
       }
       return compareArrays(self, that)
     } else if (ArrayBuffer.isView(self)) {
-      if (!ArrayBuffer.isView(that) || self.byteLength !== that.byteLength) {
+      const selfIsDataView = self instanceof DataView
+      if (
+        !ArrayBuffer.isView(that) ||
+        self.byteLength !== that.byteLength ||
+        selfIsDataView !== (that instanceof DataView)
+      ) {
         return false
       }
+      if (selfIsDataView) {
+        const thatDataView = that as DataView
+        return compareTypedArrays(
+          new Uint8Array(self.buffer, self.byteOffset, self.byteLength),
+          new Uint8Array(thatDataView.buffer, thatDataView.byteOffset, thatDataView.byteLength)
+        )
+      }
       return compareTypedArrays(self as Uint8Array, that as Uint8Array)
     } else if (self instanceof Map) {
       if (!(that instanceof Map) || self.size !== that.size) {
@@ -406,7 +418,7 @@ const compareSets = makeCompareSet(compareBoth)
  *
  * **Example** (Checking Equal values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Equal, Hash } from "effect"
  *
  * class Token implements Equal.Equal {
@@ -419,9 +431,9 @@ const compareSets = makeCompareSet(compareBoth)
  *   }
  * }
  *
- * console.log(Equal.isEqual(new Token("abc"))) // true
- * console.log(Equal.isEqual({ x: 1 }))         // false
- * console.log(Equal.isEqual(42))                // false
+ * Equal.isEqual(new Token("abc")) // => true
+ * Equal.isEqual({ x: 1 }) // => false
+ * Equal.isEqual(42) // => false
  * ```
  *
  * @see {@link Equal} — the interface being checked
@@ -447,12 +459,10 @@ export const isEqual = (u: unknown): u is Equal => hasProperty(u, symbol)
  *
  * **Example** (Deduplicating with Equal semantics)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array, Equal } from "effect"
  *
- * const eq = Equal.asEquivalence<number>()
- * const result = Array.dedupeWith([1, 2, 2, 3, 1], eq)
- * console.log(result) // [1, 2, 3]
+ * Array.dedupeWith([1, 2, 2, 3, 1], Equal.asEquivalence<number>()) // => [1, 2, 3]
  * ```
  *
  * @see {@link equals} — the underlying comparison function
@@ -481,18 +491,18 @@ export const asEquivalence: <A>() => Equivalence<A> = () => equals
  *
  * **Example** (Opting out of structural equality)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Equal } from "effect"
  *
  * const a = { x: 1 }
  * const b = { x: 1 }
  *
- * console.log(Equal.equals(a, b)) // true  (structural)
+ * Equal.equals(a, b) // => true
  *
  * 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)
+ * Equal.equals(aRef, b) // => false
+ * Equal.equals(aRef, aRef) // => true
+ * aRef.x // => 1
  * ```
  *
  * @see {@link byReferenceUnsafe} — same effect without a proxy (mutates the
@@ -526,17 +536,17 @@ export const byReference = <T extends object>(obj: T): T => byReferenceUnsafe(ne
  *
  * **Example** (Marking an object for reference equality)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Equal } from "effect"
  *
  * const obj1 = { a: 1, b: 2 }
  * const obj2 = { a: 1, b: 2 }
  *
- * Equal.byReferenceUnsafe(obj1)
+ * const marked = Equal.byReferenceUnsafe(obj1)
  *
- * 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)
+ * Equal.equals(obj1, obj2) // => false
+ * Equal.equals(obj1, obj1) // => true
+ * marked === obj1 // => true
  * ```
  *
  * @see {@link byReference} — safer alternative that creates a proxy