effect 4.0.0-beta.69 → 4.0.0-beta.70

package/dist/Equivalence.d.ts

@@ -3,12 +3,14 @@ import * as Reducer from "./Reducer.ts";
 /**
  * Represents an equivalence relation over type `A`.
  *
- * When to use this:
- * - As a type annotation for equivalence functions
- * - When implementing custom equivalence logic
- * - When working with collection operations that require equivalence relations
+ * **When to use**
+ *
+ * - Use as a type annotation for equivalence functions
+ * - Use when implementing custom equivalence logic
+ * - Use when working with collection operations that require equivalence relations
+ *
+ * **Details**
  *
- * Behavior:
  * - Pure function: does not mutate inputs or have side effects
  * - Returns `boolean`: `true` if values are equivalent, `false` otherwise
  * - Must satisfy reflexive, symmetric, and transitive properties
@@ -40,8 +42,8 @@ import * as Reducer from "./Reducer.ts";
  * console.log(pointEq({ x: 1, y: 2 }, { x: 1, y: 2 })) // true
  * ```
  *
- * See also: {@link make}, {@link strictEqual}
- *
+ * @see {@link make}
+ * @see {@link strictEqual}
  * @category type class
  * @since 2.0.0
  */
@@ -49,12 +51,14 @@ export type Equivalence<in A> = (self: A, that: A) => boolean;
 /**
  * Type lambda for `Equivalence`, used for higher-kinded type operations.
  *
- * When to use this:
+ * **When to use**
+ *
  * - Rarely needed in application code
- * - Primarily for internal type system operations and HKT (Higher-Kinded Types) abstractions
- * - When working with generic type constructors that require type lambdas
+ * - Use primarily for internal type system operations and HKT (Higher-Kinded Types) abstractions
+ * - Use when working with generic type constructors that require type lambdas
+ *
+ * **Details**
  *
- * Behavior:
  * - Enables `Equivalence` to work with the Effect type system's HKT infrastructure
  * - Used internally for type-level computations and generic abstractions
  *
@@ -74,8 +78,8 @@ export type Equivalence<in A> = (self: A, that: A) => boolean;
  * // Equivalent to: Equivalence.Equivalence<number>
  * ```
  *
- * See also: {@link Equivalence}, {@link TypeLambda}
- *
+ * @see {@link Equivalence}
+ * @see {@link TypeLambda}
  * @category type lambdas
  * @since 2.0.0
  */
@@ -85,12 +89,14 @@ export interface EquivalenceTypeLambda extends TypeLambda {
 /**
  * Creates a custom equivalence relation with an optimized reference equality check.
  *
- * When to use this:
- * - When you need a custom equivalence that isn't just strict equality
- * - When creating equivalences for complex types with custom comparison logic
- * - When you want the performance benefit of reference equality optimization
+ * **When to use**
+ *
+ * - Use when you need a custom equivalence that is not just strict equality
+ * - Use when creating equivalences for complex types with custom comparison logic
+ * - Use when you want the performance benefit of reference equality optimization
+ *
+ * **Details**
  *
- * Behavior:
  * - Does not mutate inputs
  * - First checks reference equality (`===`) for performance; if values are identical, returns `true` without calling the function
  * - Falls back to the provided equivalence function if values are not the same reference
@@ -120,12 +126,12 @@ export interface EquivalenceTypeLambda extends TypeLambda {
  *
  * const tolerance = Equivalence.make<number>((a, b) => Math.abs(a - b) < 0.0001)
  *
- * console.log(tolerance(1.0, 1.0001)) // false
+ * console.log(tolerance(1.0, 1.001)) // false
  * console.log(tolerance(1.0, 1.00001)) // true
  * ```
  *
- * See also: {@link strictEqual}, {@link mapInput}
- *
+ * @see {@link strictEqual}
+ * @see {@link mapInput}
  * @category constructors
  * @since 2.0.0
  */
@@ -133,18 +139,23 @@ export declare const make: <A>(isEquivalent: (self: A, that: A) => boolean) => E
 /**
  * Creates an equivalence relation that uses strict equality (`===`) to compare values.
  *
- * When to use this:
- * - For primitive types (numbers, strings, booleans) where `===` is appropriate
- * - When you need reference equality for objects (same object instance)
- * - As a building block for more complex equivalences via {@link mapInput} or {@link combine}
- * - When performance is critical and you don't need structural equality
+ * **When to use**
+ *
+ * - Use for primitive types where `===` is appropriate
+ * - Use when you need reference equality for objects
+ * - Use as a building block for more complex equivalences via {@link mapInput} or {@link combine}
+ * - Use when performance is critical and you do not need structural equality
+ *
+ * **Details**
  *
- * Behavior:
  * - Does not mutate inputs
  * - Uses JavaScript's strict equality operator (`===`)
  * - For primitives: compares values directly
- * - For objects: compares by reference (same object instance)
- * - Note: `NaN !== NaN`, so `NaN` values are never considered equivalent
+ * - For objects: compares by reference, so only the same object instance is equivalent
+ *
+ * **Gotchas**
+ *
+ * `NaN !== NaN`, so `NaN` values are never considered equivalent.
  *
  * **Example** (Primitive types)
  *
@@ -170,8 +181,8 @@ export declare const make: <A>(isEquivalent: (self: A, that: A) => boolean) => E
  * console.log(strictObjEq(obj, { value: 42 })) // false (different references)
  * ```
  *
- * See also: {@link make}, {@link Equal} (for structural equality)
- *
+ * @see {@link make}
+ * @see {@link Equal} for structural equality
  * @category constructors
  * @since 4.0.0
  */
@@ -195,6 +206,8 @@ export declare const String: Equivalence<string>;
 /**
  * An `Equivalence` instance for numbers.
  *
+ * **Details**
+ *
  * `NaN` is considered equal to `NaN`.
  *
  * **Example** (Comparing numbers)
@@ -246,16 +259,18 @@ export declare const BigInt: Equivalence<bigint>;
 /**
  * Combines two equivalence relations using logical AND.
  *
- * When to use this:
- * - When you need to combine exactly two equivalences
- * - When building complex equivalences from simpler ones
- * - When you want both conditions to be satisfied (AND logic)
+ * **When to use**
+ *
+ * - Use when you need to combine exactly two equivalences
+ * - Use when building complex equivalences from simpler ones
+ * - Use when you want both conditions to be satisfied
+ *
+ * **Details**
  *
- * Behavior:
  * - Does not mutate inputs
  * - Returns `true` only if both equivalences return `true`
  * - Short-circuits: if the first equivalence returns `false`, the second is not called
- * - The result is also an equivalence (satisfies reflexive, symmetric, transitive properties)
+ * - The result is also an equivalence that satisfies reflexive, symmetric, and transitive properties
  *
  * **Example** (Combining name and age equivalences)
  *
@@ -287,8 +302,8 @@ export declare const BigInt: Equivalence<bigint>;
  * console.log(personEquivalence(person1, person3)) // false (different age)
  * ```
  *
- * See also: {@link combineAll}, {@link mapInput}
- *
+ * @see {@link combineAll}
+ * @see {@link mapInput}
  * @category combining
  * @since 2.0.0
  */
@@ -296,16 +311,18 @@ export declare const combine: {
     /**
      * Combines two equivalence relations using logical AND.
      *
-     * When to use this:
-     * - When you need to combine exactly two equivalences
-     * - When building complex equivalences from simpler ones
-     * - When you want both conditions to be satisfied (AND logic)
+     * **When to use**
+     *
+     * - Use when you need to combine exactly two equivalences
+     * - Use when building complex equivalences from simpler ones
+     * - Use when you want both conditions to be satisfied
+     *
+     * **Details**
      *
-     * Behavior:
      * - Does not mutate inputs
      * - Returns `true` only if both equivalences return `true`
      * - Short-circuits: if the first equivalence returns `false`, the second is not called
-     * - The result is also an equivalence (satisfies reflexive, symmetric, transitive properties)
+     * - The result is also an equivalence that satisfies reflexive, symmetric, and transitive properties
      *
      * **Example** (Combining name and age equivalences)
      *
@@ -337,8 +354,8 @@ export declare const combine: {
      * console.log(personEquivalence(person1, person3)) // false (different age)
      * ```
      *
-     * See also: {@link combineAll}, {@link mapInput}
-     *
+     * @see {@link combineAll}
+     * @see {@link mapInput}
      * @category combining
      * @since 2.0.0
      */
@@ -346,16 +363,18 @@ export declare const combine: {
     /**
      * Combines two equivalence relations using logical AND.
      *
-     * When to use this:
-     * - When you need to combine exactly two equivalences
-     * - When building complex equivalences from simpler ones
-     * - When you want both conditions to be satisfied (AND logic)
+     * **When to use**
+     *
+     * - Use when you need to combine exactly two equivalences
+     * - Use when building complex equivalences from simpler ones
+     * - Use when you want both conditions to be satisfied
+     *
+     * **Details**
      *
-     * Behavior:
      * - Does not mutate inputs
      * - Returns `true` only if both equivalences return `true`
      * - Short-circuits: if the first equivalence returns `false`, the second is not called
-     * - The result is also an equivalence (satisfies reflexive, symmetric, transitive properties)
+     * - The result is also an equivalence that satisfies reflexive, symmetric, and transitive properties
      *
      * **Example** (Combining name and age equivalences)
      *
@@ -387,8 +406,8 @@ export declare const combine: {
      * console.log(personEquivalence(person1, person3)) // false (different age)
      * ```
      *
-     * See also: {@link combineAll}, {@link mapInput}
-     *
+     * @see {@link combineAll}
+     * @see {@link mapInput}
      * @category combining
      * @since 2.0.0
      */
@@ -397,18 +416,20 @@ export declare const combine: {
 /**
  * Combines multiple equivalence relations into a single equivalence using logical AND.
  *
- * When to use this:
- * - When you need to combine three or more equivalences
- * - When you have a dynamic collection of equivalences to combine
- * - When building equivalences from arrays or iterables
- * - Prefer over multiple `combine` calls when you have many equivalences
+ * **When to use**
+ *
+ * - Use when you need to combine three or more equivalences
+ * - Use when you have a dynamic collection of equivalences to combine
+ * - Use when building equivalences from arrays or iterables
+ * - Prefer this over multiple `combine` calls when you have many equivalences
+ *
+ * **Details**
  *
- * Behavior:
  * - Does not mutate inputs
  * - Returns `true` only if all equivalences in the collection return `true`
  * - Short-circuits: stops at the first equivalence that returns `false`
- * - Empty collection edge case: returns an equivalence that always returns `true`
- * - The result is also an equivalence (satisfies reflexive, symmetric, transitive properties)
+ * - Empty collections return an equivalence that always returns `true`
+ * - The result is also an equivalence that satisfies reflexive, symmetric, and transitive properties
  *
  * **Example** (Combining multiple field equivalences)
  *
@@ -454,8 +475,8 @@ export declare const combine: {
  * console.log(alwaysEq("anything", "else")) // true
  * ```
  *
- * See also: {@link combine}, {@link mapInput}
- *
+ * @see {@link combine}
+ * @see {@link mapInput}
  * @category combining
  * @since 2.0.0
  */
@@ -463,18 +484,20 @@ export declare const combineAll: <A>(collection: Iterable<Equivalence<A>>) => Eq
 /**
  * Transforms an equivalence relation by mapping the input values before comparison.
  *
- * When to use this:
- * - When you need an equivalence for a complex type based on a single property
- * - When you want to normalize values before comparison (e.g., case-insensitive strings)
- * - When creating equivalences that focus on specific fields of objects
- * - As a building block for creating equivalences via {@link combine} or {@link combineAll}
+ * **When to use**
+ *
+ * - Use when you need an equivalence for a complex type based on a single property
+ * - Use when you want to normalize values before comparison, such as case-insensitive strings
+ * - Use when creating equivalences that focus on specific fields of objects
+ * - Use as a building block for creating equivalences via {@link combine} or {@link combineAll}
+ *
+ * **Details**
  *
- * Behavior:
  * - Does not mutate inputs
  * - Applies the transformation function to both values before comparing
- * - The transformation function should be pure (no side effects)
+ * - The transformation function should be pure and have no side effects
  * - The resulting equivalence compares the transformed values using the provided equivalence
- * - The result is also an equivalence (satisfies reflexive, symmetric, transitive properties)
+ * - The result is also an equivalence that satisfies reflexive, symmetric, and transitive properties
  *
  * **Example** (Equivalence based on object property)
  *
@@ -515,8 +538,8 @@ export declare const combineAll: <A>(collection: Iterable<Equivalence<A>>) => Eq
  * console.log(caseInsensitiveEq("Hello", "World")) // false
  * ```
  *
- * See also: {@link combine}, {@link Struct}
- *
+ * @see {@link combine}
+ * @see {@link Struct}
  * @category mapping
  * @since 2.0.0
  */
@@ -524,18 +547,20 @@ export declare const mapInput: {
     /**
      * Transforms an equivalence relation by mapping the input values before comparison.
      *
-     * When to use this:
-     * - When you need an equivalence for a complex type based on a single property
-     * - When you want to normalize values before comparison (e.g., case-insensitive strings)
-     * - When creating equivalences that focus on specific fields of objects
-     * - As a building block for creating equivalences via {@link combine} or {@link combineAll}
+     * **When to use**
+     *
+     * - Use when you need an equivalence for a complex type based on a single property
+     * - Use when you want to normalize values before comparison, such as case-insensitive strings
+     * - Use when creating equivalences that focus on specific fields of objects
+     * - Use as a building block for creating equivalences via {@link combine} or {@link combineAll}
+     *
+     * **Details**
      *
-     * Behavior:
      * - Does not mutate inputs
      * - Applies the transformation function to both values before comparing
-     * - The transformation function should be pure (no side effects)
+     * - The transformation function should be pure and have no side effects
      * - The resulting equivalence compares the transformed values using the provided equivalence
-     * - The result is also an equivalence (satisfies reflexive, symmetric, transitive properties)
+     * - The result is also an equivalence that satisfies reflexive, symmetric, and transitive properties
      *
      * **Example** (Equivalence based on object property)
      *
@@ -576,8 +601,8 @@ export declare const mapInput: {
      * console.log(caseInsensitiveEq("Hello", "World")) // false
      * ```
      *
-     * See also: {@link combine}, {@link Struct}
-     *
+     * @see {@link combine}
+     * @see {@link Struct}
      * @category mapping
      * @since 2.0.0
      */
@@ -585,18 +610,20 @@ export declare const mapInput: {
     /**
      * Transforms an equivalence relation by mapping the input values before comparison.
      *
-     * When to use this:
-     * - When you need an equivalence for a complex type based on a single property
-     * - When you want to normalize values before comparison (e.g., case-insensitive strings)
-     * - When creating equivalences that focus on specific fields of objects
-     * - As a building block for creating equivalences via {@link combine} or {@link combineAll}
+     * **When to use**
+     *
+     * - Use when you need an equivalence for a complex type based on a single property
+     * - Use when you want to normalize values before comparison, such as case-insensitive strings
+     * - Use when creating equivalences that focus on specific fields of objects
+     * - Use as a building block for creating equivalences via {@link combine} or {@link combineAll}
+     *
+     * **Details**
      *
-     * Behavior:
      * - Does not mutate inputs
      * - Applies the transformation function to both values before comparing
-     * - The transformation function should be pure (no side effects)
+     * - The transformation function should be pure and have no side effects
      * - The resulting equivalence compares the transformed values using the provided equivalence
-     * - The result is also an equivalence (satisfies reflexive, symmetric, transitive properties)
+     * - The result is also an equivalence that satisfies reflexive, symmetric, and transitive properties
      *
      * **Example** (Equivalence based on object property)
      *
@@ -637,8 +664,8 @@ export declare const mapInput: {
      * console.log(caseInsensitiveEq("Hello", "World")) // false
      * ```
      *
-     * See also: {@link combine}, {@link Struct}
-     *
+     * @see {@link combine}
+     * @see {@link Struct}
      * @category mapping
      * @since 2.0.0
      */
@@ -647,18 +674,20 @@ export declare const mapInput: {
 /**
  * Creates an equivalence for tuples with heterogeneous element types.
  *
- * When to use this:
- * - When comparing tuples with different types at each position
- * - When you need different equivalence logic for each tuple element
- * - When working with fixed-length tuples (not arrays)
- * - Prefer over `Array` when you have a known tuple structure with different types
+ * **When to use**
+ *
+ * - Use when comparing tuples with different types at each position
+ * - Use when you need different equivalence logic for each tuple element
+ * - Use when working with fixed-length tuples instead of arrays
+ * - Prefer this over `Array` when you have a known tuple structure with different types
+ *
+ * **Details**
  *
- * Behavior:
  * - Does not mutate inputs
  * - Requires tuples to have the same length; different lengths are never equivalent
  * - Applies each equivalence to the corresponding element position
  * - Returns `true` only if all elements are equivalent according to their respective equivalences
- * - The result is also an equivalence (satisfies reflexive, symmetric, transitive properties)
+ * - The result is also an equivalence that satisfies reflexive, symmetric, and transitive properties
  *
  * **Example** (Homogeneous tuple equivalence)
  *
@@ -679,7 +708,7 @@ export declare const mapInput: {
  * console.log(stringTupleEq(tuple1, tuple3)) // false (different third element)
  * ```
  *
- * **Example** (Heterogeneous tuple with custom equivalences)
+ * **Example** (Tuple with custom equivalences)
  *
  * ```ts
  * import { Equivalence } from "effect"
@@ -700,8 +729,8 @@ export declare const mapInput: {
  * ) // true
  * ```
  *
- * See also: {@link Array_}, {@link Struct}
- *
+ * @see {@link Array_}
+ * @see {@link Struct}
  * @category combinators
  * @since 4.0.0
  */
@@ -716,19 +745,21 @@ export {
 /**
  * Creates an equivalence for arrays where all elements are compared using the same equivalence.
  *
- * When to use this:
- * - When comparing arrays with homogeneous element types
- * - When all elements should use the same equivalence logic
- * - When working with variable-length arrays (not fixed tuples)
- * - Prefer over `Tuple` when you have arrays of the same type
+ * **When to use**
+ *
+ * - Use when comparing arrays with homogeneous element types
+ * - Use when all elements should use the same equivalence logic
+ * - Use when working with variable-length arrays instead of fixed tuples
+ * - Prefer this over `Tuple` when you have arrays of the same type
+ *
+ * **Details**
  *
- * Behavior:
  * - Does not mutate inputs
  * - Requires arrays to have the same length; different lengths are never equivalent
- * - Compares elements positionally (index 0 with index 0, etc.)
+ * - Compares elements positionally, such as index `0` with index `0`
  * - Returns `true` only if all corresponding elements are equivalent
  * - Empty arrays are considered equivalent
- * - The result is also an equivalence (satisfies reflexive, symmetric, transitive properties)
+ * - The result is also an equivalence that satisfies reflexive, symmetric, and transitive properties
  *
  * **Example** (Number array equivalence)
  *
@@ -758,8 +789,8 @@ export {
  * console.log(stringArrayEq([], [])) // true (empty arrays)
  * ```
  *
- * See also: {@link Tuple}, {@link Record}
- *
+ * @see {@link Tuple}
+ * @see {@link Record}
  * @category combinators
  * @since 4.0.0
  */
@@ -767,19 +798,21 @@ Array_ as Array };
 /**
  * Creates an equivalence for objects by comparing their properties using provided equivalences.
  *
- * When to use this:
- * - When comparing objects with known, fixed property names
- * - When you need different equivalence logic for different properties
- * - When working with struct/interface types with specific fields
- * - Prefer over `Record` when you have a fixed set of known properties
+ * **When to use**
+ *
+ * - Use when comparing objects with known, fixed property names
+ * - Use when you need different equivalence logic for different properties
+ * - Use when working with struct or interface types with specific fields
+ * - Prefer this over `Record` when you have a fixed set of known properties
+ *
+ * **Details**
  *
- * Behavior:
  * - Does not mutate inputs
  * - Compares only the properties specified in the struct definition
  * - Properties not in the struct are ignored
  * - Returns `true` only if all specified properties are equivalent according to their equivalences
- * - Supports both string and symbol keys (via `Reflect.ownKeys`)
- * - The result is also an equivalence (satisfies reflexive, symmetric, transitive properties)
+ * - Supports both string and symbol keys via `Reflect.ownKeys`
+ * - The result is also an equivalence that satisfies reflexive, symmetric, and transitive properties
  *
  * **Example** (Struct with different equivalences per field)
  *
@@ -827,8 +860,9 @@ Array_ as Array };
  * console.log(nameAgeEq(obj1, obj2)) // true
  * ```
  *
- * See also: {@link Record}, {@link mapInput}, {@link combine}
- *
+ * @see {@link Record}
+ * @see {@link mapInput}
+ * @see {@link combine}
  * @category combinators
  * @since 4.0.0
  */
@@ -838,20 +872,22 @@ export declare function Struct<R extends Record<string, Equivalence<any>>>(field
 /**
  * Creates an equivalence for objects by comparing all properties using the same equivalence.
  *
- * When to use this:
- * - When comparing objects with dynamic or unknown property names
- * - When all property values should use the same equivalence logic
- * - When working with record/dictionary types (key-value maps)
- * - Prefer over `Struct` when you have variable properties or need to compare all properties uniformly
+ * **When to use**
+ *
+ * - Use when comparing objects with dynamic or unknown property names
+ * - Use when all property values should use the same equivalence logic
+ * - Use when working with record or dictionary types
+ * - Prefer this over `Struct` when you have variable properties or need to compare all properties uniformly
+ *
+ * **Details**
  *
- * Behavior:
  * - Does not mutate inputs
  * - Compares all properties present in both objects
  * - Requires both objects to have the same set of keys; different keys result in `false`
  * - All property values must be equivalent according to the provided equivalence
- * - Supports both string and symbol keys (via `Reflect.ownKeys`)
+ * - Supports both string and symbol keys via `Reflect.ownKeys`
  * - Empty objects are considered equivalent
- * - The result is also an equivalence (satisfies reflexive, symmetric, transitive properties)
+ * - The result is also an equivalence that satisfies reflexive, symmetric, and transitive properties
  *
  * **Example** (Record with string values)
  *
@@ -885,8 +921,8 @@ export declare function Struct<R extends Record<string, Equivalence<any>>>(field
  * console.log(numberRecordEq(scores1, scores3)) // false
  * ```
  *
- * See also: {@link Struct}, {@link Array_}
- *
+ * @see {@link Struct}
+ * @see {@link Array_}
  * @category combinators
  * @since 4.0.0
  */
@@ -894,14 +930,16 @@ export declare function Record<A>(value: Equivalence<A>): Equivalence<Record<Pro
 /**
  * Creates a `Reducer` for combining `Equivalence` instances, useful for aggregating equivalences in collections.
  *
- * When to use this:
- * - When you need to combine multiple equivalences from a collection using reducer patterns
- * - When implementing fold operations over collections of equivalences
- * - When working with reducers that operate on equivalences
+ * **When to use**
+ *
+ * - Use when you need to combine multiple equivalences from a collection using reducer patterns
+ * - Use when implementing fold operations over collections of equivalences
+ * - Use when working with reducers that operate on equivalences
+ *
+ * **Details**
  *
- * Behavior:
  * - Returns a reducer that combines equivalences using {@link combine}
- * - Uses an equivalence that always returns `true` as the identity element (for empty collections)
+ * - Uses an equivalence that always returns `true` as the identity element for empty collections
  * - Uses {@link combineAll} for combining collections of equivalences
  * - The reducer can be used with fold operations on collections
  *
@@ -922,22 +960,20 @@ export declare function Record<A>(value: Equivalence<A>): Equivalence<Record<Pro
  * console.log(combined(1, 1.5)) // false (strict equal fails)
  * ```
  *
- * See also:
- * - {@link combine} - Combine two equivalences
- * - {@link combineAll} - Combine multiple equivalences
- * - {@link Reducer} - Reducer type for collection operations
- *
+ * @see {@link combine} Combine two equivalences
+ * @see {@link combineAll} Combine multiple equivalences
+ * @see {@link Reducer} Reducer type for collection operations
  * @category utils
  * @since 4.0.0
  */
 export declare function makeReducer<A>(): Reducer.Reducer<Equivalence<A>>;
 /**
- * An `Equivalence` instance for `Date` objects that compares their
- * `getTime()` values using `Equivalence.Number`.
+ * An `Equivalence` instance for `Date` objects that compares their `getTime()` values using `Equivalence.Number`.
+ *
+ * **Details**
  *
- * Different `Date` instances that represent the same millisecond timestamp are
- * equivalent. Because `Equivalence.Number` treats `NaN` as equal to `NaN`, two
- * invalid `Date` values are also considered equivalent.
+ * Different `Date` instances that represent the same millisecond timestamp are equivalent. Because `Equivalence.Number`
+ * treats `NaN` as equal to `NaN`, two invalid `Date` values are also considered equivalent.
  *
  * **Example** (Comparing Date values)
  *
@@ -968,8 +1004,9 @@ export declare function makeReducer<A>(): Reducer.Reducer<Equivalence<A>>;
  * console.log(Equivalence.Date(d1, d2)) // true (same time value)
  * ```
  *
- * See also: {@link Number}, {@link mapInput}, {@link strictEqual}
- *
+ * @see {@link Number}
+ * @see {@link mapInput}
+ * @see {@link strictEqual}
  * @category instances
  * @since 2.0.0
  */