effect 4.0.0-beta.70 → 4.0.0-beta.72

package/dist/Order.d.ts

@@ -6,13 +6,12 @@ import * as Reducer from "./Reducer.ts";
  *
  * **When to use**
  *
- * - When you need to define how values of a type should be compared
+ * Use when when you need to define how values of a type should be compared
  * - When implementing sorting, searching, or ordered data structures
  * - When composing multiple comparison criteria
  *
  * **Details**
  *
- * - Pure function: does not mutate inputs or have side effects
  * - Returns `-1` if the first value is less than the second
  * - Returns `0` if the values are equal according to this ordering
  * - Returns `1` if the first value is greater than the second
@@ -34,8 +33,8 @@ import * as Reducer from "./Reducer.ts";
  * console.log(byAge(person1, person2)) // 1
  * ```
  *
- * @see {@link make} - Create an order from a comparison function
- * @see {@link Ordering} - The result type of comparisons
+ * @see {@link make} to create an order from a comparison function
+ * @see {@link Ordering} for the result type of comparisons
  * @category type class
  * @since 2.0.0
  */
@@ -47,7 +46,7 @@ export interface Order<in A> {
  *
  * **When to use**
  *
- * - When working with type-level operations that require higher-kinded types
+ * Use when when working with type-level operations that require higher-kinded types
  * - When implementing generic type classes that work with orders
  *
  * **Details**
@@ -66,13 +65,12 @@ export interface OrderTypeLambda extends TypeLambda {
  *
  * **When to use**
  *
- * - When creating a custom order for a type that doesn't have a built-in order
+ * Use when when creating a custom order for a type that doesn't have a built-in order
  * - When you need fine-grained control over comparison logic
  * - When implementing orders for complex types
  *
  * **Details**
  *
- * - Pure function: does not mutate inputs
  * - Uses reference equality (`===`) as a shortcut: if `self === that`, returns `0` without calling the comparison function
  * - The comparison function should return `-1`, `0`, or `1` based on the comparison result
  * - The returned order satisfies total ordering laws if the comparison function does
@@ -92,24 +90,23 @@ export interface OrderTypeLambda extends TypeLambda {
  * console.log(byAge({ name: "Alice", age: 25 }, { name: "Bob", age: 30 })) // -1
  * ```
  *
- * @see {@link mapInput} - Transform an order by mapping the input type
- * @see {@link combine} - Combine multiple orders
+ * @see {@link mapInput} to transform an order by mapping the input type
+ * @see {@link combine} to combine multiple orders
  * @category constructors
  * @since 2.0.0
  */
 export declare function make<A>(compare: (self: A, that: A) => -1 | 0 | 1): Order<A>;
 /**
- * An `Order` instance for strings that compares them lexicographically using JavaScript's `<` operator.
+ * Order instance for strings that compares them lexicographically using JavaScript's `<` operator.
  *
  * **When to use**
  *
- * - When comparing strings alphabetically
+ * Use when when comparing strings alphabetically
  * - When sorting string collections
  * - As a base for creating orders on types containing strings
  *
  * **Details**
  *
- * - Pure function: does not mutate inputs
  * - Uses lexicographic (dictionary) ordering
  * - Empty string is less than any non-empty string
  * - Comparison is case-sensitive
@@ -124,24 +121,23 @@ export declare function make<A>(compare: (self: A, that: A) => -1 | 0 | 1): Orde
  * console.log(Order.String("apple", "apple")) // 0
  * ```
  *
- * @see {@link mapInput} - Use this order to compare objects by a string property
- * @see {@link Struct} - Combine with other orders for struct comparison
+ * @see {@link mapInput} to compare objects by a string property
+ * @see {@link Struct} to combine with other orders for struct comparison
  * @category instances
  * @since 4.0.0
  */
 export declare const String: Order<string>;
 /**
- * An `Order` instance for numbers that compares them numerically.
+ * Order instance for numbers that compares them numerically.
  *
  * **When to use**
  *
- * - When comparing numbers for sorting or searching
+ * Use when when comparing numbers for sorting or searching
  * - As a base for creating orders on types containing numbers
  * - When implementing numeric comparisons in data structures
  *
  * **Details**
  *
- * - Pure function: does not mutate inputs
  * - `0` is considered equal to `-0`
  * - All `NaN` values are considered equal to each other
  * - Any `NaN` is considered less than any non-NaN number
@@ -160,24 +156,23 @@ export declare const String: Order<string>;
  * console.log(Order.Number(NaN, 1)) // -1
  * ```
  *
- * @see {@link mapInput} - Use this order to compare objects by a number property
- * @see {@link BigInt} - For bigint comparisons
+ * @see {@link mapInput} to compare objects by a number property
+ * @see {@link BigInt} for bigint comparisons
  * @category instances
  * @since 4.0.0
  */
 export declare const Number: Order<number>;
 /**
- * An `Order` instance for booleans where `false` is considered less than `true`.
+ * Order instance for booleans where `false` is considered less than `true`.
  *
  * **When to use**
  *
- * - When comparing booleans for sorting or searching
+ * Use when when comparing booleans for sorting or searching
  * - As a base for creating orders on types containing booleans
  * - When implementing boolean-based comparisons
  *
  * **Details**
  *
- * - Pure function: does not mutate inputs
  * - `false` is less than `true`
  * - Equal values return `0`
  *
@@ -191,23 +186,22 @@ export declare const Number: Order<number>;
  * console.log(Order.Boolean(true, true)) // 0
  * ```
  *
- * @see {@link mapInput} - Use this order to compare objects by a boolean property
+ * @see {@link mapInput} to compare objects by a boolean property
  * @category instances
  * @since 4.0.0
  */
 export declare const Boolean: Order<boolean>;
 /**
- * An `Order` instance for bigints that compares them numerically.
+ * Order instance for bigints that compares them numerically.
  *
  * **When to use**
  *
- * - When comparing bigint values for sorting or searching
+ * Use when when comparing bigint values for sorting or searching
  * - As a base for creating orders on types containing bigints
  * - When working with large integers that exceed number precision
  *
  * **Details**
  *
- * - Pure function: does not mutate inputs
  * - Uses standard numeric comparison for bigint values
  * - Handles arbitrarily large integers
  *
@@ -221,8 +215,8 @@ export declare const Boolean: Order<boolean>;
  * console.log(Order.BigInt(1n, 1n)) // 0
  * ```
  *
- * @see {@link Number} - For regular number comparisons
- * @see {@link mapInput} - Use this order to compare objects by a bigint property
+ * @see {@link Number} for regular number comparisons
+ * @see {@link mapInput} to compare objects by a bigint property
  * @category instances
  * @since 4.0.0
  */
@@ -232,13 +226,12 @@ export declare const BigInt: Order<bigint>;
  *
  * **When to use**
  *
- * - When you need descending order instead of ascending
+ * Use when when you need descending order instead of ascending
  * - When reversing an existing order without modifying the original
  * - When creating orders that compare in the opposite direction
  *
  * **Details**
  *
- * - Pure function: does not mutate inputs
  * - Returns a new order that swaps the arguments before comparison
  * - If the original order returns `-1`, the flipped order returns `1`, and vice versa
  * - Equal comparisons remain `0`
@@ -255,7 +248,7 @@ export declare const BigInt: Order<bigint>;
  * console.log(flip(1, 1)) // 0
  * ```
  *
- * @see {@link combine} - Combine orders for multi-criteria comparison
+ * @see {@link combine} to combine orders for multi-criteria comparison
  * @category combinators
  * @since 4.0.0
  */
@@ -266,13 +259,12 @@ export declare function flip<A>(O: Order<A>): Order<A>;
  *
  * **When to use**
  *
- * - When you need multi-criteria comparison (e.g., sort by age, then by name)
+ * Use when when you need multi-criteria comparison (e.g., sort by age, then by name)
  * - When creating composite orders from simpler orders
  * - When implementing lexicographic ordering
  *
  * **Details**
  *
- * - Pure function: does not mutate inputs
  * - First applies the first order; if the result is non-zero, returns that result
  * - If the first order returns `0` (equal), applies the second order
  * - Returns the first non-zero result, or `0` if both orders return `0`
@@ -300,8 +292,8 @@ export declare function flip<A>(O: Order<A>): Order<A>;
  * console.log(byAgeAndName(person1, person3)) // 1 (Alice (30) > Charlie (25))
  * ```
  *
- * @see {@link combineAll} - Combine multiple orders from a collection
- * @see {@link mapInput} - Transform orders to work with different types
+ * @see {@link combineAll} to combine multiple orders from a collection
+ * @see {@link mapInput} to transform orders to work with different types
  * @category combining
  * @since 2.0.0
  */
@@ -312,13 +304,12 @@ export declare const combine: {
      *
      * **When to use**
      *
-     * - When you need multi-criteria comparison (e.g., sort by age, then by name)
+     * Use when when you need multi-criteria comparison (e.g., sort by age, then by name)
      * - When creating composite orders from simpler orders
      * - When implementing lexicographic ordering
      *
      * **Details**
      *
-     * - Pure function: does not mutate inputs
      * - First applies the first order; if the result is non-zero, returns that result
      * - If the first order returns `0` (equal), applies the second order
      * - Returns the first non-zero result, or `0` if both orders return `0`
@@ -346,8 +337,8 @@ export declare const combine: {
      * console.log(byAgeAndName(person1, person3)) // 1 (Alice (30) > Charlie (25))
      * ```
      *
-     * @see {@link combineAll} - Combine multiple orders from a collection
-     * @see {@link mapInput} - Transform orders to work with different types
+     * @see {@link combineAll} to combine multiple orders from a collection
+     * @see {@link mapInput} to transform orders to work with different types
      * @category combining
      * @since 2.0.0
      */
@@ -358,13 +349,12 @@ export declare const combine: {
      *
      * **When to use**
      *
-     * - When you need multi-criteria comparison (e.g., sort by age, then by name)
+     * Use when when you need multi-criteria comparison (e.g., sort by age, then by name)
      * - When creating composite orders from simpler orders
      * - When implementing lexicographic ordering
      *
      * **Details**
      *
-     * - Pure function: does not mutate inputs
      * - First applies the first order; if the result is non-zero, returns that result
      * - If the first order returns `0` (equal), applies the second order
      * - Returns the first non-zero result, or `0` if both orders return `0`
@@ -392,8 +382,8 @@ export declare const combine: {
      * console.log(byAgeAndName(person1, person3)) // 1 (Alice (30) > Charlie (25))
      * ```
      *
-     * @see {@link combineAll} - Combine multiple orders from a collection
-     * @see {@link mapInput} - Transform orders to work with different types
+     * @see {@link combineAll} to combine multiple orders from a collection
+     * @see {@link mapInput} to transform orders to work with different types
      * @category combining
      * @since 2.0.0
      */
@@ -404,13 +394,12 @@ export declare const combine: {
  *
  * **When to use**
  *
- * - When you need an order that doesn't distinguish between values
+ * Use when when you need an order that doesn't distinguish between values
  * - As a default or fallback order when no meaningful comparison exists
  * - When implementing optional ordering where equality is sufficient
  *
  * **Details**
  *
- * - Pure function: does not mutate inputs
  * - Always returns `0` regardless of input values
  * - Useful as a neutral element in order composition
  *
@@ -426,7 +415,7 @@ export declare const combine: {
  * console.log(alwaysEqualOrder(1, 1)) // 0
  * ```
  *
- * @see {@link combine} - Combine with other orders
+ * @see {@link combine} to combine with other orders
  * @category constructors
  * @since 4.0.0
  */
@@ -437,13 +426,12 @@ export declare function alwaysEqual<A>(): Order<A>;
  *
  * **When to use**
  *
- * - When you have a variable number of orders to combine
+ * Use when when you have a variable number of orders to combine
  * - When combining orders from a collection or array
  * - When implementing dynamic multi-criteria sorting
  *
  * **Details**
  *
- * - Pure function: does not mutate inputs
  * - Applies orders in iteration order
  * - Returns the first non-zero result from any order
  * - Returns `0` only if all orders return `0`
@@ -471,8 +459,8 @@ export declare function alwaysEqual<A>(): Order<A>;
  * console.log(combinedOrder(person1, person2)) // -1 (Same age, Alice < Bob)
  * ```
  *
- * @see {@link combine} - Combine two orders
- * @see {@link makeReducer} - Create a reducer for combining orders
+ * @see {@link combine} to combine two orders
+ * @see {@link makeReducer} to create a reducer for combining orders
  * @category combining
  * @since 2.0.0
  */
@@ -483,13 +471,12 @@ export declare function combineAll<A>(collection: Iterable<Order<A>>): Order<A>;
  *
  * **When to use**
  *
- * - When you have an order for a property type and want to compare objects by that property
+ * Use when when you have an order for a property type and want to compare objects by that property
  * - When extracting a comparable value from a complex type
  * - When creating orders for types that contain comparable values
  *
  * **Details**
  *
- * - Pure function: does not mutate inputs
  * - Applies the mapping function to both values before comparison
  * - The mapping function should be pure and not have side effects
  * - Preserves the ordering properties of the original order
@@ -506,8 +493,8 @@ export declare function combineAll<A>(collection: Iterable<Order<A>>): Order<A>;
  * console.log(byLength("aa", "bb")) // 0
  * ```
  *
- * @see {@link combine} - Combine mapped orders for multi-criteria comparison
- * @see {@link Struct} - Create orders for structs with multiple fields
+ * @see {@link combine} to combine mapped orders for multi-criteria comparison
+ * @see {@link Struct} to create orders for structs with multiple fields
  * @category mapping
  * @since 2.0.0
  */
@@ -518,13 +505,12 @@ export declare const mapInput: {
      *
      * **When to use**
      *
-     * - When you have an order for a property type and want to compare objects by that property
+     * Use when when you have an order for a property type and want to compare objects by that property
      * - When extracting a comparable value from a complex type
      * - When creating orders for types that contain comparable values
      *
      * **Details**
      *
-     * - Pure function: does not mutate inputs
      * - Applies the mapping function to both values before comparison
      * - The mapping function should be pure and not have side effects
      * - Preserves the ordering properties of the original order
@@ -541,8 +527,8 @@ export declare const mapInput: {
      * console.log(byLength("aa", "bb")) // 0
      * ```
      *
-     * @see {@link combine} - Combine mapped orders for multi-criteria comparison
-     * @see {@link Struct} - Create orders for structs with multiple fields
+     * @see {@link combine} to combine mapped orders for multi-criteria comparison
+     * @see {@link Struct} to create orders for structs with multiple fields
      * @category mapping
      * @since 2.0.0
      */
@@ -553,13 +539,12 @@ export declare const mapInput: {
      *
      * **When to use**
      *
-     * - When you have an order for a property type and want to compare objects by that property
+     * Use when when you have an order for a property type and want to compare objects by that property
      * - When extracting a comparable value from a complex type
      * - When creating orders for types that contain comparable values
      *
      * **Details**
      *
-     * - Pure function: does not mutate inputs
      * - Applies the mapping function to both values before comparison
      * - The mapping function should be pure and not have side effects
      * - Preserves the ordering properties of the original order
@@ -576,25 +561,24 @@ export declare const mapInput: {
      * console.log(byLength("aa", "bb")) // 0
      * ```
      *
-     * @see {@link combine} - Combine mapped orders for multi-criteria comparison
-     * @see {@link Struct} - Create orders for structs with multiple fields
+     * @see {@link combine} to combine mapped orders for multi-criteria comparison
+     * @see {@link Struct} to create orders for structs with multiple fields
      * @category mapping
      * @since 2.0.0
      */
     <A, B>(self: Order<A>, f: (b: B) => A): Order<B>;
 };
 /**
- * An `Order` instance for `Date` objects that compares them chronologically by their timestamp.
+ * Order instance for `Date` objects that compares them chronologically by their timestamp.
  *
  * **When to use**
  *
- * - When comparing dates for sorting or searching
+ * Use when when comparing dates for sorting or searching
  * - As a base for creating orders on types containing dates
  * - When implementing time-based comparisons
  *
  * **Details**
  *
- * - Pure function: does not mutate inputs
  * - Compares dates by their underlying timestamp (milliseconds since epoch)
  * - Earlier dates are less than later dates
  * - Invalid dates are compared as if they were valid (uses `getTime()` result)
@@ -612,7 +596,7 @@ export declare const mapInput: {
  * console.log(Order.Date(date1, date1)) // 0
  * ```
  *
- * @see {@link mapInput} - Use this order to compare objects by a date property
+ * @see {@link mapInput} to compare objects by a date property
  * @category instances
  * @since 2.0.0
  */
@@ -622,13 +606,12 @@ export declare const Date: Order<Date>;
  *
  * **When to use**
  *
- * - When comparing tuples with different types for each position
+ * Use when when comparing tuples with different types for each position
  * - When you need type-safe tuple ordering
  * - When working with fixed-length heterogeneous collections
  *
  * **Details**
  *
- * - Pure function: does not mutate inputs
  * - Compares tuples element-by-element using the corresponding order
  * - Stops at the first non-zero comparison result
  * - Requires tuples to have the same length as the order collection
@@ -646,7 +629,7 @@ export declare const Date: Order<Date>;
  * console.log(tupleOrder([1, "a"], [1, "a"])) // 0
  * ```
  *
- * @see {@link Array} - Compare arrays with length consideration
+ * @see {@link Array} to compare arrays with length consideration
  * @category combinators
  * @since 4.0.0
  */
@@ -663,13 +646,12 @@ export {
  *
  * **When to use**
  *
- * - When comparing arrays of the same element type
+ * Use when when comparing arrays of the same element type
  * - When you want shorter arrays to be considered less than longer arrays
  * - When sorting collections of arrays
  *
  * **Details**
  *
- * - Pure function: does not mutate inputs
  * - Compares arrays element-by-element using the provided order
  * - Stops at the first non-zero comparison result
  * - If all elements are equal, shorter arrays are less than longer arrays
@@ -688,7 +670,7 @@ export {
  * console.log(arrayOrder([1, 2], [1, 2])) // 0
  * ```
  *
- * @see {@link Tuple} - Type-safe tuple ordering
+ * @see {@link Tuple} for type-safe tuple ordering
  * @category combinators
  * @since 4.0.0
  */
@@ -698,13 +680,12 @@ Array_ as Array };
  *
  * **When to use**
  *
- * - When comparing objects with multiple properties
+ * Use when when comparing objects with multiple properties
  * - When you need multi-field comparison for structs
  * - When creating orders for complex data types
  *
  * **Details**
  *
- * - Pure function: does not mutate inputs
  * - Compares structs field-by-field in the order of keys in the fields object
  * - Stops at the first non-zero comparison result
  * - Returns `0` only if all fields are equal
@@ -729,8 +710,8 @@ Array_ as Array };
  * console.log(personOrder(person1, person1)) // 0
  * ```
  *
- * @see {@link combine} - Combine orders manually
- * @see {@link mapInput} - Extract and compare by a single property
+ * @see {@link combine} to combine orders manually
+ * @see {@link mapInput} to extract and compare by a single property
  * @category combinators
  * @since 4.0.0
  */
@@ -740,17 +721,16 @@ export declare function Struct<const R extends {
     [K in keyof R]: [R[K]] extends [Order<infer A>] ? A : never;
 }>;
 /**
- * Tests whether one value is strictly less than another according to the given order.
+ * Checks whether one value is strictly less than another according to the given order.
  *
  * **When to use**
  *
- * - When you need a boolean predicate instead of an ordering result
+ * Use when when you need a boolean predicate instead of an ordering result
  * - When checking if a value is less than another in conditional logic
  * - When implementing range checks or comparisons
  *
  * **Details**
  *
- * - Pure function: does not mutate inputs
  * - Returns `true` if the order returns `-1` (first value is less than second)
  * - Returns `false` for equal or greater values
  * - Supports curried and uncurried call styles
@@ -767,8 +747,8 @@ export declare function Struct<const R extends {
  * console.log(isLessThanNumber(1, 1)) // false
  * ```
  *
- * @see {@link isLessThanOrEqualTo} - Non-strict less than or equal
- * @see {@link isGreaterThan} - Strict greater than
+ * @see {@link isLessThanOrEqualTo} for non-strict less than or equal
+ * @see {@link isGreaterThan} for strict greater than
  * @category predicates
  * @since 4.0.0
  */
@@ -777,17 +757,16 @@ export declare const isLessThan: <A>(O: Order<A>) => {
     (self: A, that: A): boolean;
 };
 /**
- * Tests whether one value is strictly greater than another according to the given order.
+ * Checks whether one value is strictly greater than another according to the given order.
  *
  * **When to use**
  *
- * - When you need a boolean predicate instead of an ordering result
+ * Use when when you need a boolean predicate instead of an ordering result
  * - When checking if a value is greater than another in conditional logic
  * - When implementing range checks or comparisons
  *
  * **Details**
  *
- * - Pure function: does not mutate inputs
  * - Returns `true` if the order returns `1` (first value is greater than second)
  * - Returns `false` for equal or lesser values
  * - Supports curried and uncurried call styles
@@ -804,8 +783,8 @@ export declare const isLessThan: <A>(O: Order<A>) => {
  * console.log(isGreaterThanNumber(1, 1)) // false
  * ```
  *
- * @see {@link isGreaterThanOrEqualTo} - Non-strict greater than or equal
- * @see {@link isLessThan} - Strict less than
+ * @see {@link isGreaterThanOrEqualTo} for non-strict greater than or equal
+ * @see {@link isLessThan} for strict less than
  * @category predicates
  * @since 4.0.0
  */
@@ -814,17 +793,16 @@ export declare const isGreaterThan: <A>(O: Order<A>) => {
     (self: A, that: A): boolean;
 };
 /**
- * Tests whether one value is less than or equal to another according to the given order.
+ * Checks whether one value is less than or equal to another according to the given order.
  *
  * **When to use**
  *
- * - When you need a boolean predicate for non-strict comparison
+ * Use when when you need a boolean predicate for non-strict comparison
  * - When checking if a value is within a range (inclusive lower bound)
  * - When implementing inclusive comparisons
  *
  * **Details**
  *
- * - Pure function: does not mutate inputs
  * - Returns `true` if the order returns `-1` or `0` (less than or equal)
  * - Returns `false` only if the order returns `1` (greater than)
  * - Supports curried and uncurried call styles
@@ -841,8 +819,8 @@ export declare const isGreaterThan: <A>(O: Order<A>) => {
  * console.log(isLessThanOrEqualToNumber(2, 1)) // false
  * ```
  *
- * @see {@link isLessThan} - Strict less than
- * @see {@link isGreaterThan} - Strict greater than
+ * @see {@link isLessThan} for strict less than
+ * @see {@link isGreaterThan} for strict greater than
  * @category predicates
  * @since 4.0.0
  */
@@ -851,17 +829,16 @@ export declare const isLessThanOrEqualTo: <A>(O: Order<A>) => {
     (self: A, that: A): boolean;
 };
 /**
- * Tests whether one value is greater than or equal to another according to the given order.
+ * Checks whether one value is greater than or equal to another according to the given order.
  *
  * **When to use**
  *
- * - When you need a boolean predicate for non-strict comparison
+ * Use when when you need a boolean predicate for non-strict comparison
  * - When checking if a value is within a range (inclusive upper bound)
  * - When implementing inclusive comparisons
  *
  * **Details**
  *
- * - Pure function: does not mutate inputs
  * - Returns `true` if the order returns `1` or `0` (greater than or equal)
  * - Returns `false` only if the order returns `-1` (less than)
  * - Supports curried and uncurried call styles
@@ -878,8 +855,8 @@ export declare const isLessThanOrEqualTo: <A>(O: Order<A>) => {
  * console.log(isGreaterThanOrEqualToNumber(1, 2)) // false
  * ```
  *
- * @see {@link isGreaterThan} - Strict greater than
- * @see {@link isLessThanOrEqualTo} - Less than or equal
+ * @see {@link isGreaterThan} for strict greater than
+ * @see {@link isLessThanOrEqualTo} for less than or equal
  * @category predicates
  * @since 4.0.0
  */
@@ -892,13 +869,12 @@ export declare const isGreaterThanOrEqualTo: <A>(O: Order<A>) => {
  *
  * **When to use**
  *
- * - When you need to find the smaller of two values
+ * Use when when you need to find the smaller of two values
  * - When implementing min/max operations
  * - When selecting values based on ordering
  *
  * **Details**
  *
- * - Pure function: does not mutate inputs
  * - Returns the value that compares as less than or equal to the other
  * - If values are equal, returns the first argument
  * - Supports curried and uncurried call styles
@@ -915,8 +891,8 @@ export declare const isGreaterThanOrEqualTo: <A>(O: Order<A>) => {
  * console.log(minNumber(1, 1)) // 1
  * ```
  *
- * @see {@link max} - Maximum of two values
- * @see {@link clamp} - Clamp a value between min and max
+ * @see {@link max} for the maximum of two values
+ * @see {@link clamp} to clamp a value between min and max
  * @category comparisons
  * @since 2.0.0
  */
@@ -929,13 +905,12 @@ export declare const min: <A>(O: Order<A>) => {
  *
  * **When to use**
  *
- * - When you need to find the larger of two values
+ * Use when when you need to find the larger of two values
  * - When implementing min/max operations
  * - When selecting values based on ordering
  *
  * **Details**
  *
- * - Pure function: does not mutate inputs
  * - Returns the value that compares as greater than or equal to the other
  * - If values are equal, returns the first argument
  * - Supports curried and uncurried call styles
@@ -952,8 +927,8 @@ export declare const min: <A>(O: Order<A>) => {
  * console.log(maxNumber(1, 1)) // 1
  * ```
  *
- * @see {@link min} - Minimum of two values
- * @see {@link clamp} - Clamp a value between min and max
+ * @see {@link min} for the minimum of two values
+ * @see {@link clamp} to clamp a value between min and max
  * @category comparisons
  * @since 2.0.0
  */
@@ -962,17 +937,16 @@ export declare const max: <A>(O: Order<A>) => {
     (self: A, that: A): A;
 };
 /**
- * Clamps a value between a minimum and a maximum according to the given order.
+ * Restricts a value between a minimum and a maximum according to the given order.
  *
  * **When to use**
  *
- * - When you need to restrict a value to a specific range
+ * Use when when you need to restrict a value to a specific range
  * - When implementing bounds checking and normalization
  * - When ensuring values stay within valid ranges
  *
  * **Details**
  *
- * - Pure function: does not mutate inputs
  * - Returns the value if it's between minimum and maximum (inclusive)
  * - Returns minimum if the value is less than minimum
  * - Returns maximum if the value is greater than maximum
@@ -991,9 +965,9 @@ export declare const max: <A>(O: Order<A>) => {
  * console.log(clamp(6)) // 5
  * ```
  *
- * @see {@link min} - Minimum of two values
- * @see {@link max} - Maximum of two values
- * @see {@link isBetween} - Check if a value is within a range
+ * @see {@link min} for the minimum of two values
+ * @see {@link max} for the maximum of two values
+ * @see {@link isBetween} to check if a value is within a range
  * @category comparisons
  * @since 2.0.0
  */
@@ -1008,17 +982,16 @@ export declare const clamp: <A>(O: Order<A>) => {
     }): A;
 };
 /**
- * Tests whether a value is between a minimum and a maximum (inclusive) according to the given order.
+ * Checks whether a value is between a minimum and a maximum (inclusive) according to the given order.
  *
  * **When to use**
  *
- * - When validating that a value is within a valid range
+ * Use when when validating that a value is within a valid range
  * - When implementing range checks for bounds validation
  * - When filtering or selecting values within a range
  *
  * **Details**
  *
- * - Pure function: does not mutate inputs
  * - Returns `true` if the value is greater than or equal to minimum and less than or equal to maximum
  * - Returns `false` if the value is outside the range
  * - Supports curried and uncurried call styles
@@ -1038,9 +1011,9 @@ export declare const clamp: <A>(O: Order<A>) => {
  * console.log(betweenNumber(11, { minimum: 1, maximum: 10 })) // false
  * ```
  *
- * @see {@link clamp} - Clamp a value to a range
- * @see {@link isLessThanOrEqualTo} - Less than or equal check
- * @see {@link isGreaterThanOrEqualTo} - Greater than or equal check
+ * @see {@link clamp} to clamp a value to a range
+ * @see {@link isLessThanOrEqualTo} for less than or equal check
+ * @see {@link isGreaterThanOrEqualTo} for greater than or equal check
  * @category predicates
  * @since 4.0.0
  */
@@ -1059,7 +1032,7 @@ export declare const isBetween: <A>(O: Order<A>) => {
  *
  * **When to use**
  *
- * - When you need to combine multiple orders from a collection using reducer patterns
+ * Use when when you need to combine multiple orders from a collection using reducer patterns
  * - When implementing fold operations over collections of orders
  * - When working with reducers that operate on orders
  *
@@ -1082,9 +1055,9 @@ export declare const isBetween: <A>(O: Order<A>) => {
  * console.log(combined(1, 2)) // -1 (uses first order)
  * ```
  *
- * @see {@link combine} - Combine two orders
- * @see {@link combineAll} - Combine multiple orders
- * @see {@link Reducer} - Reducer type for collection operations
+ * @see {@link combine} to combine two orders
+ * @see {@link combineAll} to combine multiple orders
+ * @see {@link Reducer} for reducing orders as a collection operation
  * @category utils
  * @since 4.0.0
  */