<N extends Newtype.Any>(
equivalence: Equivalence.Equivalence<Newtype.Carrier<N>>
): Equivalence.Equivalence<N>Lifts an Equivalence for the carrier type into an Equivalence for the
newtype.
When to use
Use when you need equality for newtype-wrapped values to behave like equality for the wrapped carrier value, without manually unwrapping.
Details
The returned equivalence delegates to the provided carrier equivalence and has zero runtime cost beyond the underlying equivalence check.
Example (Comparing newtypes)
import { Equivalence, Newtype } from "effect"
interface Label extends Newtype.Newtype<"Label", string> {}
const eq = Newtype.makeEquivalence<Label>(Equivalence.String)
const iso = Newtype.makeIso<Label>()
eq(iso.set("a"), iso.set("a")) // true
eq(iso.set("a"), iso.set("b")) // falseexport const const makeEquivalence: <
N extends Newtype.Any
>(
equivalence: Equivalence.Equivalence<
Newtype.Carrier<N>
>
) => Equivalence.Equivalence<N>
Lifts an Equivalence for the carrier type into an Equivalence for the
newtype.
When to use
Use when you need equality for newtype-wrapped values to behave like
equality for the wrapped carrier value, without manually unwrapping.
Details
The returned equivalence delegates to the provided carrier equivalence and
has zero runtime cost beyond the underlying equivalence check.
Example (Comparing newtypes)
import { Equivalence, Newtype } from "effect"
interface Label extends Newtype.Newtype<"Label", string> {}
const eq = Newtype.makeEquivalence<Label>(Equivalence.String)
const iso = Newtype.makeIso<Label>()
eq(iso.set("a"), iso.set("a")) // true
eq(iso.set("a"), iso.set("b")) // false
makeEquivalence: <function (type parameter) N in <N extends Newtype.Any>(equivalence: Equivalence.Equivalence<Newtype.Carrier<N>>): Equivalence.Equivalence<N>N extends Newtype.type Newtype<in out Key extends string, out Carrier>.Any = Newtype<any, unknown>A type that matches any Newtype, useful as a generic constraint:
<N extends Newtype.Any>.
When to use
Use as a generic constraint when a type parameter can be any Newtype.
Any>(
equivalence: Equivalence.Equivalence<
Newtype.Carrier<N>
>
import EquivalenceEquivalence.type Equivalence<in A> = (
self: A,
that: A
) => boolean
Represents an equivalence relation over type A.
When to use
Use as a type annotation when you accept or return an equivalence function.
Details
- Returns
boolean: true if values are equivalent, false otherwise
- Must satisfy reflexive, symmetric, and transitive properties
Example (Defining simple number equivalence)
import type { Equivalence } from "effect"
const numberEq: Equivalence.Equivalence<number> = (a, b) => a === b
console.log(numberEq(1, 1)) // true
console.log(numberEq(1, 2)) // false
Example (Defining custom object equivalence)
import type { Equivalence } from "effect"
interface Point {
x: number
y: number
}
const pointEq: Equivalence.Equivalence<Point> = (a, b) =>
a.x === b.x && a.y === b.y
console.log(pointEq({ x: 1, y: 2 }, { x: 1, y: 2 })) // true
Equivalence<Newtype.type Newtype<in out Key extends string, out Carrier>.Carrier<N extends Newtype.Any> = N extends Newtype<infer _Key extends string, infer Carrier> ? Carrier : neverExtracts the carrier (underlying) type from a newtype.
When to use
Use when you need to refer to the wrapped type in generic utilities.
Carrier<function (type parameter) N in <N extends Newtype.Any>(equivalence: Equivalence.Equivalence<Newtype.Carrier<N>>): Equivalence.Equivalence<N>N>>
) => import EquivalenceEquivalence.type Equivalence<in A> = (
self: A,
that: A
) => boolean
Represents an equivalence relation over type A.
When to use
Use as a type annotation when you accept or return an equivalence function.
Details
- Returns
boolean: true if values are equivalent, false otherwise
- Must satisfy reflexive, symmetric, and transitive properties
Example (Defining simple number equivalence)
import type { Equivalence } from "effect"
const numberEq: Equivalence.Equivalence<number> = (a, b) => a === b
console.log(numberEq(1, 1)) // true
console.log(numberEq(1, 2)) // false
Example (Defining custom object equivalence)
import type { Equivalence } from "effect"
interface Point {
x: number
y: number
}
const pointEq: Equivalence.Equivalence<Point> = (a, b) =>
a.x === b.x && a.y === b.y
console.log(pointEq({ x: 1, y: 2 }, { x: 1, y: 2 })) // true
Equivalence<function (type parameter) N in <N extends Newtype.Any>(equivalence: Equivalence.Equivalence<Newtype.Carrier<N>>): Equivalence.Equivalence<N>N> = const cast: <A, B>(a: A) => BReturns the input value with a different static type.
When to use
Use when you need an explicit type-level cast and accept that the value is
returned unchanged at runtime.
Gotchas
This is a type-level cast only; it performs no runtime validation or
conversion.
cast