effect 4.0.0-beta.66 → 4.0.0-beta.68

package/dist/Number.d.ts

@@ -12,9 +12,10 @@ import * as Reducer from "./Reducer.ts";
 /**
  * The global `Number` constructor.
  *
- * @example
+ * **Example** (Coercing values to numbers)
+ *
  * ```ts
- * import * as N from "effect/Number"
+ * import { Number as N } from "effect"
  *
  * const num = N.Number("42")
  * console.log(num) // 42
@@ -30,13 +31,14 @@ export declare const Number: NumberConstructor;
 /**
  * Tests if a value is a `number`.
  *
- * @example
+ * **Example** (Checking for numbers)
+ *
  * ```ts
- * import { isNumber } from "effect/Number"
+ * import { Number } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(isNumber(2), true)
- * assert.deepStrictEqual(isNumber("2"), false)
+ * assert.deepStrictEqual(Number.isNumber(2), true)
+ * assert.deepStrictEqual(Number.isNumber("2"), false)
  * ```
  *
  * @category guards
@@ -46,12 +48,13 @@ export declare const isNumber: (input: unknown) => input is number;
 /**
  * Provides an addition operation on `number`s.
  *
- * @example
+ * **Example** (Adding numbers)
+ *
  * ```ts
- * import { sum } from "effect/Number"
+ * import { Number } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(sum(2, 3), 5)
+ * assert.deepStrictEqual(Number.sum(2, 3), 5)
  * ```
  *
  * @category math
@@ -61,12 +64,13 @@ export declare const sum: {
     /**
      * Provides an addition operation on `number`s.
      *
-     * @example
+     * **Example** (Adding numbers)
+     *
      * ```ts
-     * import { sum } from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(sum(2, 3), 5)
+     * assert.deepStrictEqual(Number.sum(2, 3), 5)
      * ```
      *
      * @category math
@@ -76,12 +80,13 @@ export declare const sum: {
     /**
      * Provides an addition operation on `number`s.
      *
-     * @example
+     * **Example** (Adding numbers)
+     *
      * ```ts
-     * import { sum } from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(sum(2, 3), 5)
+     * assert.deepStrictEqual(Number.sum(2, 3), 5)
      * ```
      *
      * @category math
@@ -92,12 +97,13 @@ export declare const sum: {
 /**
  * Provides a multiplication operation on `number`s.
  *
- * @example
+ * **Example** (Multiplying numbers)
+ *
  * ```ts
- * import { multiply } from "effect/Number"
+ * import { Number } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(multiply(2, 3), 6)
+ * assert.deepStrictEqual(Number.multiply(2, 3), 6)
  * ```
  *
  * @category math
@@ -107,12 +113,13 @@ export declare const multiply: {
     /**
      * Provides a multiplication operation on `number`s.
      *
-     * @example
+     * **Example** (Multiplying numbers)
+     *
      * ```ts
-     * import { multiply } from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(multiply(2, 3), 6)
+     * assert.deepStrictEqual(Number.multiply(2, 3), 6)
      * ```
      *
      * @category math
@@ -122,12 +129,13 @@ export declare const multiply: {
     /**
      * Provides a multiplication operation on `number`s.
      *
-     * @example
+     * **Example** (Multiplying numbers)
+     *
      * ```ts
-     * import { multiply } from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(multiply(2, 3), 6)
+     * assert.deepStrictEqual(Number.multiply(2, 3), 6)
      * ```
      *
      * @category math
@@ -138,12 +146,13 @@ export declare const multiply: {
 /**
  * Provides a subtraction operation on `number`s.
  *
- * @example
+ * **Example** (Subtracting numbers)
+ *
  * ```ts
- * import { subtract } from "effect/Number"
+ * import { Number } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(subtract(2, 3), -1)
+ * assert.deepStrictEqual(Number.subtract(2, 3), -1)
  * ```
  *
  * @category math
@@ -153,12 +162,13 @@ export declare const subtract: {
     /**
      * Provides a subtraction operation on `number`s.
      *
-     * @example
+     * **Example** (Subtracting numbers)
+     *
      * ```ts
-     * import { subtract } from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(subtract(2, 3), -1)
+     * assert.deepStrictEqual(Number.subtract(2, 3), -1)
      * ```
      *
      * @category math
@@ -168,12 +178,13 @@ export declare const subtract: {
     /**
      * Provides a subtraction operation on `number`s.
      *
-     * @example
+     * **Example** (Subtracting numbers)
+     *
      * ```ts
-     * import { subtract } from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(subtract(2, 3), -1)
+     * assert.deepStrictEqual(Number.subtract(2, 3), -1)
      * ```
      *
      * @category math
@@ -186,7 +197,7 @@ export declare const subtract: {
  *
  * Returns `Option.none()` if the divisor is `0`.
  *
- * **Example**
+ * **Example** (Dividing numbers safely)
  *
  * ```ts
  * import { Number } from "effect"
@@ -204,7 +215,7 @@ export declare const divide: {
      *
      * Returns `Option.none()` if the divisor is `0`.
      *
-     * **Example**
+     * **Example** (Dividing numbers safely)
      *
      * ```ts
      * import { Number } from "effect"
@@ -222,7 +233,7 @@ export declare const divide: {
      *
      * Returns `Option.none()` if the divisor is `0`.
      *
-     * **Example**
+     * **Example** (Dividing numbers safely)
      *
      * ```ts
      * import { Number } from "effect"
@@ -241,17 +252,18 @@ export declare const divide: {
  *
  * Throws a `RangeError` if the divisor is `0`.
  *
- * **Example**
+ * **Example** (Dividing numbers unsafely)
  *
  * ```ts
  * import { Number } from "effect"
  *
- * Number.divideUnsafe(6, 3) // 2
- * Number.divideUnsafe(6, 0) // throws RangeError("Division by zero")
+ * console.log(Number.divideUnsafe(6, 3)) // 2
+ *
+ * // Passing 0 as the divisor throws a RangeError("Division by zero").
  * ```
  *
  * @category math
- * @since 2.0.0
+ * @since 4.0.0
  */
 export declare const divideUnsafe: {
     /**
@@ -259,17 +271,18 @@ export declare const divideUnsafe: {
      *
      * Throws a `RangeError` if the divisor is `0`.
      *
-     * **Example**
+     * **Example** (Dividing numbers unsafely)
      *
      * ```ts
      * import { Number } from "effect"
      *
-     * Number.divideUnsafe(6, 3) // 2
-     * Number.divideUnsafe(6, 0) // throws RangeError("Division by zero")
+     * console.log(Number.divideUnsafe(6, 3)) // 2
+     *
+     * // Passing 0 as the divisor throws a RangeError("Division by zero").
      * ```
      *
      * @category math
-     * @since 2.0.0
+     * @since 4.0.0
      */
     (that: number): (self: number) => number;
     /**
@@ -277,29 +290,31 @@ export declare const divideUnsafe: {
      *
      * Throws a `RangeError` if the divisor is `0`.
      *
-     * **Example**
+     * **Example** (Dividing numbers unsafely)
      *
      * ```ts
      * import { Number } from "effect"
      *
-     * Number.divideUnsafe(6, 3) // 2
-     * Number.divideUnsafe(6, 0) // throws RangeError("Division by zero")
+     * console.log(Number.divideUnsafe(6, 3)) // 2
+     *
+     * // Passing 0 as the divisor throws a RangeError("Division by zero").
      * ```
      *
      * @category math
-     * @since 2.0.0
+     * @since 4.0.0
      */
     (self: number, that: number): number;
 };
 /**
  * Returns the result of adding `1` to a given number.
  *
- * @example
+ * **Example** (Incrementing a number)
+ *
  * ```ts
- * import { increment } from "effect/Number"
+ * import { Number } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(increment(2), 3)
+ * assert.deepStrictEqual(Number.increment(2), 3)
  * ```
  *
  * @category math
@@ -309,12 +324,13 @@ export declare const increment: (n: number) => number;
 /**
  * Decrements a number by `1`.
  *
- * @example
+ * **Example** (Decrementing a number)
+ *
  * ```ts
- * import { decrement } from "effect/Number"
+ * import { Number } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(decrement(3), 2)
+ * assert.deepStrictEqual(Number.decrement(3), 2)
  * ```
  *
  * @category math
@@ -324,9 +340,10 @@ export declare const decrement: (n: number) => number;
 /**
  * An `Order` instance for `number` values.
  *
- * @example
+ * **Example** (Comparing numbers)
+ *
  * ```ts
- * import * as Number from "effect/Number"
+ * import { Number } from "effect"
  *
  * console.log(Number.Order(1, 2)) // -1
  * console.log(Number.Order(2, 1)) // 1
@@ -342,7 +359,8 @@ export declare const Order: order.Order<number>;
  *
  * `NaN` is considered equal to `NaN`.
  *
- * @example
+ * **Example** (Comparing numbers for equivalence)
+ *
  * ```ts
  * import { Number } from "effect"
  *
@@ -352,223 +370,236 @@ export declare const Order: order.Order<number>;
  * ```
  *
  * @category instances
- * @since 4.0.0
+ * @since 2.0.0
  */
 export declare const Equivalence: Equ.Equivalence<number>;
 /**
  * Returns `true` if the first argument is less than the second, otherwise `false`.
  *
- * @example
+ * **Example** (Checking less-than comparisons)
+ *
  * ```ts
- * import { isLessThan } from "effect/Number"
+ * import { Number } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(isLessThan(2, 3), true)
- * assert.deepStrictEqual(isLessThan(3, 3), false)
- * assert.deepStrictEqual(isLessThan(4, 3), false)
+ * assert.deepStrictEqual(Number.isLessThan(2, 3), true)
+ * assert.deepStrictEqual(Number.isLessThan(3, 3), false)
+ * assert.deepStrictEqual(Number.isLessThan(4, 3), false)
  * ```
  *
  * @category predicates
- * @since 2.0.0
+ * @since 4.0.0
  */
 export declare const isLessThan: {
     /**
      * Returns `true` if the first argument is less than the second, otherwise `false`.
      *
-     * @example
+     * **Example** (Checking less-than comparisons)
+     *
      * ```ts
-     * import { isLessThan } from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(isLessThan(2, 3), true)
-     * assert.deepStrictEqual(isLessThan(3, 3), false)
-     * assert.deepStrictEqual(isLessThan(4, 3), false)
+     * assert.deepStrictEqual(Number.isLessThan(2, 3), true)
+     * assert.deepStrictEqual(Number.isLessThan(3, 3), false)
+     * assert.deepStrictEqual(Number.isLessThan(4, 3), false)
      * ```
      *
      * @category predicates
-     * @since 2.0.0
+     * @since 4.0.0
      */
     (that: number): (self: number) => boolean;
     /**
      * Returns `true` if the first argument is less than the second, otherwise `false`.
      *
-     * @example
+     * **Example** (Checking less-than comparisons)
+     *
      * ```ts
-     * import { isLessThan } from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(isLessThan(2, 3), true)
-     * assert.deepStrictEqual(isLessThan(3, 3), false)
-     * assert.deepStrictEqual(isLessThan(4, 3), false)
+     * assert.deepStrictEqual(Number.isLessThan(2, 3), true)
+     * assert.deepStrictEqual(Number.isLessThan(3, 3), false)
+     * assert.deepStrictEqual(Number.isLessThan(4, 3), false)
      * ```
      *
      * @category predicates
-     * @since 2.0.0
+     * @since 4.0.0
      */
     (self: number, that: number): boolean;
 };
 /**
  * Returns a function that checks if a given `number` is less than or equal to the provided one.
  *
- * @example
+ * **Example** (Checking less-than-or-equal comparisons)
+ *
  * ```ts
- * import { isLessThanOrEqualTo } from "effect/Number"
+ * import { Number } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(isLessThanOrEqualTo(2, 3), true)
- * assert.deepStrictEqual(isLessThanOrEqualTo(3, 3), true)
- * assert.deepStrictEqual(isLessThanOrEqualTo(4, 3), false)
+ * assert.deepStrictEqual(Number.isLessThanOrEqualTo(2, 3), true)
+ * assert.deepStrictEqual(Number.isLessThanOrEqualTo(3, 3), true)
+ * assert.deepStrictEqual(Number.isLessThanOrEqualTo(4, 3), false)
  * ```
  *
  * @category predicates
- * @since 2.0.0
+ * @since 4.0.0
  */
 export declare const isLessThanOrEqualTo: {
     /**
      * Returns a function that checks if a given `number` is less than or equal to the provided one.
      *
-     * @example
+     * **Example** (Checking less-than-or-equal comparisons)
+     *
      * ```ts
-     * import { isLessThanOrEqualTo } from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(isLessThanOrEqualTo(2, 3), true)
-     * assert.deepStrictEqual(isLessThanOrEqualTo(3, 3), true)
-     * assert.deepStrictEqual(isLessThanOrEqualTo(4, 3), false)
+     * assert.deepStrictEqual(Number.isLessThanOrEqualTo(2, 3), true)
+     * assert.deepStrictEqual(Number.isLessThanOrEqualTo(3, 3), true)
+     * assert.deepStrictEqual(Number.isLessThanOrEqualTo(4, 3), false)
      * ```
      *
      * @category predicates
-     * @since 2.0.0
+     * @since 4.0.0
      */
     (that: number): (self: number) => boolean;
     /**
      * Returns a function that checks if a given `number` is less than or equal to the provided one.
      *
-     * @example
+     * **Example** (Checking less-than-or-equal comparisons)
+     *
      * ```ts
-     * import { isLessThanOrEqualTo } from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(isLessThanOrEqualTo(2, 3), true)
-     * assert.deepStrictEqual(isLessThanOrEqualTo(3, 3), true)
-     * assert.deepStrictEqual(isLessThanOrEqualTo(4, 3), false)
+     * assert.deepStrictEqual(Number.isLessThanOrEqualTo(2, 3), true)
+     * assert.deepStrictEqual(Number.isLessThanOrEqualTo(3, 3), true)
+     * assert.deepStrictEqual(Number.isLessThanOrEqualTo(4, 3), false)
      * ```
      *
      * @category predicates
-     * @since 2.0.0
+     * @since 4.0.0
      */
     (self: number, that: number): boolean;
 };
 /**
  * Returns `true` if the first argument is greater than the second, otherwise `false`.
  *
- * @example
+ * **Example** (Checking greater-than comparisons)
+ *
  * ```ts
- * import { isGreaterThan } from "effect/Number"
+ * import { Number } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(isGreaterThan(2, 3), false)
- * assert.deepStrictEqual(isGreaterThan(3, 3), false)
- * assert.deepStrictEqual(isGreaterThan(4, 3), true)
+ * assert.deepStrictEqual(Number.isGreaterThan(2, 3), false)
+ * assert.deepStrictEqual(Number.isGreaterThan(3, 3), false)
+ * assert.deepStrictEqual(Number.isGreaterThan(4, 3), true)
  * ```
  *
  * @category predicates
- * @since 2.0.0
+ * @since 4.0.0
  */
 export declare const isGreaterThan: {
     /**
      * Returns `true` if the first argument is greater than the second, otherwise `false`.
      *
-     * @example
+     * **Example** (Checking greater-than comparisons)
+     *
      * ```ts
-     * import { isGreaterThan } from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(isGreaterThan(2, 3), false)
-     * assert.deepStrictEqual(isGreaterThan(3, 3), false)
-     * assert.deepStrictEqual(isGreaterThan(4, 3), true)
+     * assert.deepStrictEqual(Number.isGreaterThan(2, 3), false)
+     * assert.deepStrictEqual(Number.isGreaterThan(3, 3), false)
+     * assert.deepStrictEqual(Number.isGreaterThan(4, 3), true)
      * ```
      *
      * @category predicates
-     * @since 2.0.0
+     * @since 4.0.0
      */
     (that: number): (self: number) => boolean;
     /**
      * Returns `true` if the first argument is greater than the second, otherwise `false`.
      *
-     * @example
+     * **Example** (Checking greater-than comparisons)
+     *
      * ```ts
-     * import { isGreaterThan } from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(isGreaterThan(2, 3), false)
-     * assert.deepStrictEqual(isGreaterThan(3, 3), false)
-     * assert.deepStrictEqual(isGreaterThan(4, 3), true)
+     * assert.deepStrictEqual(Number.isGreaterThan(2, 3), false)
+     * assert.deepStrictEqual(Number.isGreaterThan(3, 3), false)
+     * assert.deepStrictEqual(Number.isGreaterThan(4, 3), true)
      * ```
      *
      * @category predicates
-     * @since 2.0.0
+     * @since 4.0.0
      */
     (self: number, that: number): boolean;
 };
 /**
  * Returns a function that checks if a given `number` is greater than or equal to the provided one.
  *
- * @example
+ * **Example** (Checking greater-than-or-equal comparisons)
+ *
  * ```ts
- * import { isGreaterThanOrEqualTo } from "effect/Number"
+ * import { Number } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(isGreaterThanOrEqualTo(2, 3), false)
- * assert.deepStrictEqual(isGreaterThanOrEqualTo(3, 3), true)
- * assert.deepStrictEqual(isGreaterThanOrEqualTo(4, 3), true)
+ * assert.deepStrictEqual(Number.isGreaterThanOrEqualTo(2, 3), false)
+ * assert.deepStrictEqual(Number.isGreaterThanOrEqualTo(3, 3), true)
+ * assert.deepStrictEqual(Number.isGreaterThanOrEqualTo(4, 3), true)
  * ```
  *
  * @category predicates
- * @since 2.0.0
+ * @since 4.0.0
  */
 export declare const isGreaterThanOrEqualTo: {
     /**
      * Returns a function that checks if a given `number` is greater than or equal to the provided one.
      *
-     * @example
+     * **Example** (Checking greater-than-or-equal comparisons)
+     *
      * ```ts
-     * import { isGreaterThanOrEqualTo } from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(isGreaterThanOrEqualTo(2, 3), false)
-     * assert.deepStrictEqual(isGreaterThanOrEqualTo(3, 3), true)
-     * assert.deepStrictEqual(isGreaterThanOrEqualTo(4, 3), true)
+     * assert.deepStrictEqual(Number.isGreaterThanOrEqualTo(2, 3), false)
+     * assert.deepStrictEqual(Number.isGreaterThanOrEqualTo(3, 3), true)
+     * assert.deepStrictEqual(Number.isGreaterThanOrEqualTo(4, 3), true)
      * ```
      *
      * @category predicates
-     * @since 2.0.0
+     * @since 4.0.0
      */
     (that: number): (self: number) => boolean;
     /**
      * Returns a function that checks if a given `number` is greater than or equal to the provided one.
      *
-     * @example
+     * **Example** (Checking greater-than-or-equal comparisons)
+     *
      * ```ts
-     * import { isGreaterThanOrEqualTo } from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(isGreaterThanOrEqualTo(2, 3), false)
-     * assert.deepStrictEqual(isGreaterThanOrEqualTo(3, 3), true)
-     * assert.deepStrictEqual(isGreaterThanOrEqualTo(4, 3), true)
+     * assert.deepStrictEqual(Number.isGreaterThanOrEqualTo(2, 3), false)
+     * assert.deepStrictEqual(Number.isGreaterThanOrEqualTo(3, 3), true)
+     * assert.deepStrictEqual(Number.isGreaterThanOrEqualTo(4, 3), true)
      * ```
      *
      * @category predicates
-     * @since 2.0.0
+     * @since 4.0.0
      */
     (self: number, that: number): boolean;
 };
 /**
  * Checks if a `number` is between a `minimum` and `maximum` value (inclusive).
  *
- * @example
+ * **Example** (Checking inclusive ranges)
+ *
  * ```ts
- * import * as Number from "effect/Number"
+ * import { Number } from "effect"
  * import * as assert from "node:assert"
  *
  * const between = Number.between({ minimum: 0, maximum: 5 })
@@ -585,9 +616,10 @@ export declare const between: {
     /**
      * Checks if a `number` is between a `minimum` and `maximum` value (inclusive).
      *
-     * @example
+     * **Example** (Checking inclusive ranges)
+     *
      * ```ts
-     * import * as Number from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
      * const between = Number.between({ minimum: 0, maximum: 5 })
@@ -607,9 +639,10 @@ export declare const between: {
     /**
      * Checks if a `number` is between a `minimum` and `maximum` value (inclusive).
      *
-     * @example
+     * **Example** (Checking inclusive ranges)
+     *
      * ```ts
-     * import * as Number from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
      * const between = Number.between({ minimum: 0, maximum: 5 })
@@ -634,9 +667,10 @@ export declare const between: {
  * - If the `number` is greater than the `maximum` value, the function returns the `maximum` value.
  * - Otherwise, it returns the original `number`.
  *
- * @example
+ * **Example** (Clamping to a range)
+ *
  * ```ts
- * import * as Number from "effect/Number"
+ * import { Number } from "effect"
  * import * as assert from "node:assert"
  *
  * const clamp = Number.clamp({ minimum: 1, maximum: 5 })
@@ -657,9 +691,10 @@ export declare const clamp: {
      * - If the `number` is greater than the `maximum` value, the function returns the `maximum` value.
      * - Otherwise, it returns the original `number`.
      *
-     * @example
+     * **Example** (Clamping to a range)
+     *
      * ```ts
-     * import * as Number from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
      * const clamp = Number.clamp({ minimum: 1, maximum: 5 })
@@ -683,9 +718,10 @@ export declare const clamp: {
      * - If the `number` is greater than the `maximum` value, the function returns the `maximum` value.
      * - Otherwise, it returns the original `number`.
      *
-     * @example
+     * **Example** (Clamping to a range)
+     *
      * ```ts
-     * import * as Number from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
      * const clamp = Number.clamp({ minimum: 1, maximum: 5 })
@@ -706,12 +742,13 @@ export declare const clamp: {
 /**
  * Returns the minimum between two `number`s.
  *
- * @example
+ * **Example** (Finding the minimum)
+ *
  * ```ts
- * import { min } from "effect/Number"
+ * import { Number } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(min(2, 3), 2)
+ * assert.deepStrictEqual(Number.min(2, 3), 2)
  * ```
  *
  * @category math
@@ -721,12 +758,13 @@ export declare const min: {
     /**
      * Returns the minimum between two `number`s.
      *
-     * @example
+     * **Example** (Finding the minimum)
+     *
      * ```ts
-     * import { min } from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(min(2, 3), 2)
+     * assert.deepStrictEqual(Number.min(2, 3), 2)
      * ```
      *
      * @category math
@@ -736,12 +774,13 @@ export declare const min: {
     /**
      * Returns the minimum between two `number`s.
      *
-     * @example
+     * **Example** (Finding the minimum)
+     *
      * ```ts
-     * import { min } from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(min(2, 3), 2)
+     * assert.deepStrictEqual(Number.min(2, 3), 2)
      * ```
      *
      * @category math
@@ -752,12 +791,13 @@ export declare const min: {
 /**
  * Returns the maximum between two `number`s.
  *
- * @example
+ * **Example** (Finding the maximum)
+ *
  * ```ts
- * import { max } from "effect/Number"
+ * import { Number } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(max(2, 3), 3)
+ * assert.deepStrictEqual(Number.max(2, 3), 3)
  * ```
  *
  * @category math
@@ -767,12 +807,13 @@ export declare const max: {
     /**
      * Returns the maximum between two `number`s.
      *
-     * @example
+     * **Example** (Finding the maximum)
+     *
      * ```ts
-     * import { max } from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(max(2, 3), 3)
+     * assert.deepStrictEqual(Number.max(2, 3), 3)
      * ```
      *
      * @category math
@@ -782,12 +823,13 @@ export declare const max: {
     /**
      * Returns the maximum between two `number`s.
      *
-     * @example
+     * **Example** (Finding the maximum)
+     *
      * ```ts
-     * import { max } from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(max(2, 3), 3)
+     * assert.deepStrictEqual(Number.max(2, 3), 3)
      * ```
      *
      * @category math
@@ -798,14 +840,15 @@ export declare const max: {
 /**
  * Determines the sign of a given `number`.
  *
- * @example
+ * **Example** (Determining the sign)
+ *
  * ```ts
- * import { sign } from "effect/Number"
+ * import { Number } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(sign(-5), -1)
- * assert.deepStrictEqual(sign(0), 0)
- * assert.deepStrictEqual(sign(5), 1)
+ * assert.deepStrictEqual(Number.sign(-5), -1)
+ * assert.deepStrictEqual(Number.sign(0), 0)
+ * assert.deepStrictEqual(Number.sign(5), 1)
  * ```
  *
  * @category math
@@ -815,12 +858,13 @@ export declare const sign: (n: number) => Ordering;
 /**
  * Takes an `Iterable` of `number`s and returns their sum as a single `number`.
  *
- * @example
+ * **Example** (Summing an iterable)
+ *
  * ```ts
- * import { sumAll } from "effect/Number"
+ * import { Number } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(sumAll([2, 3, 4]), 9)
+ * assert.deepStrictEqual(Number.sumAll([2, 3, 4]), 9)
  * ```
  *
  * @category math
@@ -830,12 +874,13 @@ export declare const sumAll: (collection: Iterable<number>) => number;
 /**
  * Takes an `Iterable` of `number`s and returns their multiplication as a single `number`.
  *
- * @example
+ * **Example** (Multiplying an iterable)
+ *
  * ```ts
- * import { multiplyAll } from "effect/Number"
+ * import { Number } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(multiplyAll([2, 3, 4]), 24)
+ * assert.deepStrictEqual(Number.multiplyAll([2, 3, 4]), 24)
  * ```
  *
  * @category math
@@ -847,14 +892,15 @@ export declare const multiplyAll: (collection: Iterable<number>) => number;
  *
  * It always takes the sign of the dividend.
  *
- * @example
+ * **Example** (Calculating remainders)
+ *
  * ```ts
- * import { remainder } from "effect/Number"
+ * import { Number } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(remainder(2, 2), 0)
- * assert.deepStrictEqual(remainder(3, 2), 1)
- * assert.deepStrictEqual(remainder(-4, 2), -0)
+ * assert.deepStrictEqual(Number.remainder(2, 2), 0)
+ * assert.deepStrictEqual(Number.remainder(3, 2), 1)
+ * assert.deepStrictEqual(Number.remainder(-4, 2), -0)
  * ```
  *
  * @category math
@@ -866,14 +912,15 @@ export declare const remainder: {
      *
      * It always takes the sign of the dividend.
      *
-     * @example
+     * **Example** (Calculating remainders)
+     *
      * ```ts
-     * import { remainder } from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(remainder(2, 2), 0)
-     * assert.deepStrictEqual(remainder(3, 2), 1)
-     * assert.deepStrictEqual(remainder(-4, 2), -0)
+     * assert.deepStrictEqual(Number.remainder(2, 2), 0)
+     * assert.deepStrictEqual(Number.remainder(3, 2), 1)
+     * assert.deepStrictEqual(Number.remainder(-4, 2), -0)
      * ```
      *
      * @category math
@@ -885,14 +932,15 @@ export declare const remainder: {
      *
      * It always takes the sign of the dividend.
      *
-     * @example
+     * **Example** (Calculating remainders)
+     *
      * ```ts
-     * import { remainder } from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(remainder(2, 2), 0)
-     * assert.deepStrictEqual(remainder(3, 2), 1)
-     * assert.deepStrictEqual(remainder(-4, 2), -0)
+     * assert.deepStrictEqual(Number.remainder(2, 2), 0)
+     * assert.deepStrictEqual(Number.remainder(3, 2), 1)
+     * assert.deepStrictEqual(Number.remainder(-4, 2), -0)
      * ```
      *
      * @category math
@@ -903,13 +951,14 @@ export declare const remainder: {
 /**
  * Returns the next power of 2 from the given number.
  *
- * @example
+ * **Example** (Finding the next power of two)
+ *
  * ```ts
- * import { nextPow2 } from "effect/Number"
+ * import { Number } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(nextPow2(5), 8)
- * assert.deepStrictEqual(nextPow2(17), 32)
+ * assert.deepStrictEqual(Number.nextPow2(5), 8)
+ * assert.deepStrictEqual(Number.nextPow2(17), 32)
  * ```
  *
  * @category math
@@ -920,7 +969,7 @@ export declare const nextPow2: (n: number) => number;
  * Tries to parse a `number` from a `string` using the `Number()` function.
  * The following special string values are supported: "NaN", "Infinity", "-Infinity".
  *
- * **Example**
+ * **Example** (Parsing numbers from strings)
  *
  * ```ts
  * import { Number } from "effect"
@@ -940,13 +989,14 @@ export declare const parse: (s: string) => Option.Option<number>;
 /**
  * Returns the number rounded with the given precision.
  *
- * @example
+ * **Example** (Rounding with precision)
+ *
  * ```ts
- * import { round } from "effect/Number"
+ * import { Number } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(round(1.1234, 2), 1.12)
- * assert.deepStrictEqual(round(1.567, 2), 1.57)
+ * assert.deepStrictEqual(Number.round(1.1234, 2), 1.12)
+ * assert.deepStrictEqual(Number.round(1.567, 2), 1.57)
  * ```
  *
  * @category math
@@ -956,13 +1006,14 @@ export declare const round: {
     /**
      * Returns the number rounded with the given precision.
      *
-     * @example
+     * **Example** (Rounding with precision)
+     *
      * ```ts
-     * import { round } from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(round(1.1234, 2), 1.12)
-     * assert.deepStrictEqual(round(1.567, 2), 1.57)
+     * assert.deepStrictEqual(Number.round(1.1234, 2), 1.12)
+     * assert.deepStrictEqual(Number.round(1.567, 2), 1.57)
      * ```
      *
      * @category math
@@ -972,13 +1023,14 @@ export declare const round: {
     /**
      * Returns the number rounded with the given precision.
      *
-     * @example
+     * **Example** (Rounding with precision)
+     *
      * ```ts
-     * import { round } from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(round(1.1234, 2), 1.12)
-     * assert.deepStrictEqual(round(1.567, 2), 1.57)
+     * assert.deepStrictEqual(Number.round(1.1234, 2), 1.12)
+     * assert.deepStrictEqual(Number.round(1.567, 2), 1.57)
      * ```
      *
      * @category math
@@ -989,24 +1041,28 @@ export declare const round: {
 /**
  * A `Reducer` for combining `number`s using addition.
  *
+ * @category math
  * @since 4.0.0
  */
 export declare const ReducerSum: Reducer.Reducer<number>;
 /**
  * A `Reducer` for combining `number`s using multiplication.
  *
+ * @category math
  * @since 4.0.0
  */
 export declare const ReducerMultiply: Reducer.Reducer<number>;
 /**
- * A `Combiner` that returns the maximum `number`.
+ * A `Reducer` for reducing `number`s by keeping the maximum value.
  *
+ * @category math
  * @since 4.0.0
  */
 export declare const ReducerMax: Reducer.Reducer<number>;
 /**
- * A `Combiner` that returns the minimum `number`.
+ * A `Reducer` for reducing `number`s by keeping the minimum value.
  *
+ * @category math
  * @since 4.0.0
  */
 export declare const ReducerMin: Reducer.Reducer<number>;