Trait #

import { Equal } from "effect"

const a = { id: 1, tags: ["x", "y"] }
const b = { id: 1, tags: ["x", "y"] }

console.log(a === b, Equal.equals(a, b))
console.log(Equal.equals([1, [2, 3]], [1, [2, 3]]))
console.log(Equal.equals(new Map([["k", 1]]), new Map([["k", 1]])), Equal.equals(new Set([1, 2]), new Set([2, 1])))
console.log(Equal.equals(new Date("2024-01-01"), new Date("2024-01-01")), Equal.equals(NaN, NaN))

// Different shape or different value: false
console.log(Equal.equals({ id: 1 }, { id: 1, extra: true }), Equal.equals({ id: 1 }, { id: "1" }))

// Opt out when identity is what you mean (a live connection, a DOM node)
const conn = Equal.byReference({ id: 1 })
console.log(Equal.equals(conn, { id: 1 }), Equal.equals(conn, conn))

import { Equal, Hash } from "effect"

// An email address: equal when the same address, ignoring case and surrounding spaces
class Email implements Equal.Equal {
  readonly normalized: string

  constructor(readonly raw: string) {
    this.normalized = raw.trim().toLowerCase()
  }

  [Equal.symbol](that: Equal.Equal): boolean {
    return that instanceof Email && this.normalized === that.normalized
  }

  // The law: equal values must hash the same. So hash the normalized form, not raw.
  [Hash.symbol](): number {
    return Hash.string(this.normalized)
  }
}

const a = new Email("Ada@Example.com ")
const b = new Email("ada@example.com")

console.log(a.raw === b.raw, Equal.equals(a, b))
console.log(Hash.hash(a) === Hash.hash(b))
console.log(Equal.equals(a, new Email("lin@example.com")))

import { Equal, Hash, HashMap, HashSet, Option } from "effect"

class Email implements Equal.Equal {
  readonly normalized: string
  constructor(readonly raw: string) {
    this.normalized = raw.trim().toLowerCase()
  }
  [Equal.symbol](that: Equal.Equal): boolean {
    return that instanceof Email && this.normalized === that.normalized
  }
  [Hash.symbol](): number {
    return Hash.string(this.normalized)
  }
}

// JS Map: a second Email object for the same address is a different key
const jsMap = new Map<Email, string>([[new Email("ada@example.com"), "Ada"]])
console.log(jsMap.get(new Email("ADA@example.com")))

// HashMap: keys are bucketed with Hash and matched with Equal
const users = HashMap.make(
  [new Email("ada@example.com"), "Ada"],
  [new Email("lin@example.com"), "Lin"]
)
console.log(HashMap.get(users, new Email("ADA@example.com")).pipe(Option.getOrElse(() => "not found")))

// HashSet: one entry per equality class
const seen = HashSet.fromIterable([new Email("a@x.io"), new Email("A@X.IO "), new Email("b@x.io")])
console.log(HashSet.size(seen), HashSet.has(seen, new Email("b@x.io")))

// Plain objects work too, thanks to v4 structural equality
const grid = HashMap.make([{ x: 0, y: 0 }, "origin"])
console.log(HashMap.has(grid, { x: 0, y: 0 }), new Map([[{ x: 0, y: 0 }, "origin"]]).has({ x: 0, y: 0 }))

import { Array as Arr, Chunk, DateTime, Duration, Equal, Option, Result } from "effect"

console.log(Equal.equals(Option.some({ id: 1 }), Option.some({ id: 1 })), Equal.equals(Option.some(1), Option.none()))
console.log(Equal.equals(Result.succeed([1, 2]), Result.succeed([1, 2])), Equal.equals(Result.fail("x"), Result.succeed("x")))
console.log(Equal.equals(Chunk.make(1, 2, 3), Chunk.fromIterable([1, 2, 3])))
console.log(Equal.equals(Duration.seconds(90), Duration.minutes(1.5)))
console.log(Equal.equals(DateTime.makeUnsafe("2024-01-01T00:00:00Z"), DateTime.makeUnsafe("2024-01-01")))

// A Chunk is not an array, even with the same elements
console.log(Equal.equals(Chunk.make(1, 2), [1, 2]))

// Equal as an Equivalence: structural equality as a plain (a, b) => boolean
const sameRecord = Equal.asEquivalence<{ id: number }>()
console.log(sameRecord({ id: 1 }, { id: 1 }))

// Array.dedupe uses Equal by default, so objects dedupe by content
console.log(Arr.dedupe([{ id: 1 }, { id: 1 }, { id: 2 }]).length)

import { HashSet } from "effect"

const visits = [
  { page: "/home", user: 1 },
  { page: "/home", user: 1 },
  { page: "/docs", user: 2 }
]

const unique = new Set(visits)

console.log("unique visits:", unique.size)

import { Equal, Hash } from "effect"

class Version implements Equal.Equal {
  constructor(readonly major: number, readonly minor: number) {}

  [Equal.symbol](that: Equal.Equal): boolean {
    return that instanceof Version && this.major === that.major && this.minor === that.minor
  }
}

console.log(Equal.equals(new Version(1, 2), new Version(1, 2)))

import { Equal, Hash, HashSet } from "effect"

class Tag implements Equal.Equal {
  constructor(readonly name: string) {}

  [Equal.symbol](that: Equal.Equal): boolean {
    return that instanceof Tag && this.name.toLowerCase() === that.name.toLowerCase()
  }

  [Hash.symbol](): number {
    return Hash.string(this.name)
  }
}

const tags = HashSet.make(new Tag("effect"), new Tag("typescript"))

console.log(Equal.equals(new Tag("Effect"), new Tag("effect")))
console.log(HashSet.has(tags, new Tag("Effect")))

import { Chunk, Equal } from "effect"

const expected = [3, 1, 2]
const received = Chunk.make(3, 1, 2)   // what a stream handed us

console.log("matches:", Equal.equals(received, expected))