<const Elements extends ReadonlyArray<Equivalence.Equivalence<any>>>(
elements: Elements
): Equivalence.Equivalence<{
readonly [I in keyof Elements]: [Elements[I]] extends [
Equivalence.Equivalence<infer A>
]
? A
: never
}>Creates an Equivalence for tuples by comparing corresponding elements
using the provided per-position Equivalences. Two tuples are equivalent
when all their corresponding elements are equivalent.
When to use
Use when you need an Equivalence to compare tuples element-by-element.
Details
This is an alias of Equivalence.Tuple.
Example (Comparing tuples for equivalence)
import { Equivalence, Tuple } from "effect"
const eq = Tuple.makeEquivalence([
Equivalence.strictEqual<string>(),
Equivalence.strictEqual<number>()
])
console.log(eq(["Alice", 30], ["Alice", 30])) // true
console.log(eq(["Alice", 30], ["Bob", 30])) // falseexport const const makeEquivalence: <
Elements extends ReadonlyArray<Equivalence<any>>
>(
elements: Elements
) => Equivalence<{
readonly [I in keyof Elements]: [
Elements[I]
] extends [Equivalence<infer A>]
? A
: never
}>
Creates an Equivalence for tuples by comparing corresponding elements
using the provided per-position Equivalences. Two tuples are equivalent
when all their corresponding elements are equivalent.
When to use
Use when you need an Equivalence to compare tuples element-by-element.
Details
This is an alias of Equivalence.Tuple.
Example (Comparing tuples for equivalence)
import { Equivalence, Tuple } from "effect"
const eq = Tuple.makeEquivalence([
Equivalence.strictEqual<string>(),
Equivalence.strictEqual<number>()
])
console.log(eq(["Alice", 30], ["Alice", 30])) // true
console.log(eq(["Alice", 30], ["Bob", 30])) // false
makeEquivalence = import EquivalenceEquivalence.function Tuple<
Elements extends ReadonlyArray<Equivalence<any>>
>(
elements: Elements
): Equivalence<{
readonly [I in keyof Elements]: [
Elements[I]
] extends [Equivalence<infer A>]
? A
: never
}>
Creates an equivalence for tuples with heterogeneous element types.
When to use
Use when you need an Equivalence for fixed-length tuples with per-position
equivalences.
Details
Tuples must have the same length; different lengths are never equivalent.
Each equivalence is applied to the corresponding element position. The result
returns true only if all elements are equivalent according to their
respective equivalences, and it also satisfies reflexive, symmetric, and
transitive properties.
Example (Comparing homogeneous tuples)
import { Equivalence } from "effect"
const stringTupleEq = Equivalence.Tuple([
Equivalence.strictEqual<string>(),
Equivalence.strictEqual<string>(),
Equivalence.strictEqual<string>()
])
const tuple1 = ["hello", "world", "test"] as const
const tuple2 = ["hello", "world", "test"] as const
const tuple3 = ["hello", "world", "different"] as const
console.log(stringTupleEq(tuple1, tuple2)) // true
console.log(stringTupleEq(tuple1, tuple3)) // false (different third element)
Example (Comparing tuples with custom equivalences)
import { Equivalence } from "effect"
const caseInsensitive = Equivalence.mapInput(
Equivalence.strictEqual<string>(),
(s: string) => s.toLowerCase()
)
const customTupleEq = Equivalence.Tuple([
caseInsensitive,
caseInsensitive,
caseInsensitive
])
console.log(
customTupleEq(["Hello", "World", "Test"], ["HELLO", "WORLD", "TEST"])
) // true
Tuple