effect 4.0.0-beta.67 → 4.0.0-beta.68

package/src/Number.ts

@@ -18,7 +18,7 @@ import * as Reducer from "./Reducer.ts"
  * **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
@@ -38,11 +38,11 @@ export const Number = globalThis.Number
  * **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
@@ -56,10 +56,10 @@ export const isNumber: (input: unknown) => input is number = predicate.isNumber
  * **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
@@ -72,10 +72,10 @@ export const sum: {
    * **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
@@ -88,10 +88,10 @@ export const sum: {
    * **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
@@ -106,10 +106,10 @@ export const sum: {
  * **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,10 +122,10 @@ export const multiply: {
    * **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,10 +138,10 @@ export const multiply: {
    * **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
@@ -156,10 +156,10 @@ export const multiply: {
  * **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
@@ -172,10 +172,10 @@ export const subtract: {
    * **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
@@ -188,10 +188,10 @@ export const subtract: {
    * **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
@@ -275,7 +275,7 @@ export const divide: {
  * ```
  *
  * @category math
- * @since 2.0.0
+ * @since 4.0.0
  */
 export const divideUnsafe: {
   /**
@@ -294,7 +294,7 @@ export const divideUnsafe: {
    * ```
    *
    * @category math
-   * @since 2.0.0
+   * @since 4.0.0
    */
   (that: number): (self: number) => number
   /**
@@ -313,7 +313,7 @@ export const divideUnsafe: {
    * ```
    *
    * @category math
-   * @since 2.0.0
+   * @since 4.0.0
    */
   (self: number, that: number): number
 } = dual(
@@ -328,10 +328,10 @@ export const divideUnsafe: {
  * **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
@@ -345,10 +345,10 @@ export const increment = (n: number): number => n + 1
  * **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
@@ -362,7 +362,7 @@ export const decrement = (n: number): number => n - 1
  * **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
@@ -390,7 +390,7 @@ export const Order: order.Order<number> = order.Number
  * ```
  *
  * @category instances
- * @since 4.0.0
+ * @since 2.0.0
  */
 export const Equivalence: Equ.Equivalence<number> = Equ.Number
 
@@ -400,16 +400,16 @@ export const Equivalence: Equ.Equivalence<number> = Equ.Number
  * **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 const isLessThan: {
   /**
@@ -418,16 +418,16 @@ export const isLessThan: {
    * **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
   /**
@@ -436,16 +436,16 @@ export const isLessThan: {
    * **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
 } = order.isLessThan(Order)
@@ -456,16 +456,16 @@ export const isLessThan: {
  * **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 const isLessThanOrEqualTo: {
   /**
@@ -474,16 +474,16 @@ export const isLessThanOrEqualTo: {
    * **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
   /**
@@ -492,16 +492,16 @@ export const isLessThanOrEqualTo: {
    * **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
 } = order.isLessThanOrEqualTo(Order)
@@ -512,16 +512,16 @@ export const isLessThanOrEqualTo: {
  * **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 const isGreaterThan: {
   /**
@@ -530,16 +530,16 @@ export const isGreaterThan: {
    * **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
   /**
@@ -548,16 +548,16 @@ export const isGreaterThan: {
    * **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
 } = order.isGreaterThan(Order)
@@ -568,16 +568,16 @@ export const isGreaterThan: {
  * **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 const isGreaterThanOrEqualTo: {
   /**
@@ -586,16 +586,16 @@ export const isGreaterThanOrEqualTo: {
    * **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
   /**
@@ -604,16 +604,16 @@ export const isGreaterThanOrEqualTo: {
    * **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
 } = order.isGreaterThanOrEqualTo(Order)
@@ -624,7 +624,7 @@ export const isGreaterThanOrEqualTo: {
  * **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 })
@@ -644,7 +644,7 @@ export const between: {
    * **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 })
@@ -669,7 +669,7 @@ export const between: {
    * **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 })
@@ -701,7 +701,7 @@ export const between: {
  * **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 })
@@ -725,7 +725,7 @@ export const clamp: {
    * **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 })
@@ -754,7 +754,7 @@ export const clamp: {
    * **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 })
@@ -782,10 +782,10 @@ export const clamp: {
  * **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
@@ -798,10 +798,10 @@ export const min: {
    * **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
@@ -814,10 +814,10 @@ export const min: {
    * **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
@@ -832,10 +832,10 @@ export const min: {
  * **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
@@ -848,10 +848,10 @@ export const max: {
    * **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
@@ -864,10 +864,10 @@ export const max: {
    * **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
@@ -882,12 +882,12 @@ export const max: {
  * **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
@@ -901,10 +901,10 @@ export const sign = (n: number): Ordering => Order(n, 0)
  * **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
@@ -924,10 +924,10 @@ export const sumAll = (collection: Iterable<number>): number => {
  * **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
@@ -952,12 +952,12 @@ export const multiplyAll = (collection: Iterable<number>): number => {
  * **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
@@ -972,12 +972,12 @@ export const remainder: {
    * **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
@@ -992,12 +992,12 @@ export const remainder: {
    * **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
@@ -1030,11 +1030,11 @@ function decimalCount(n: number): number {
  * **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
@@ -1088,11 +1088,11 @@ export const parse = (s: string): Option.Option<number> => {
  * **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
@@ -1105,11 +1105,11 @@ export const round: {
    * **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
@@ -1122,11 +1122,11 @@ export const round: {
    * **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
@@ -1141,6 +1141,7 @@ export const round: {
 /**
  * A `Reducer` for combining `number`s using addition.
  *
+ * @category math
  * @since 4.0.0
  */
 export const ReducerSum: Reducer.Reducer<number> = Reducer.make((a, b) => a + b, 0)
@@ -1148,6 +1149,7 @@ export const ReducerSum: Reducer.Reducer<number> = Reducer.make((a, b) => a + b,
 /**
  * A `Reducer` for combining `number`s using multiplication.
  *
+ * @category math
  * @since 4.0.0
  */
 export const ReducerMultiply: Reducer.Reducer<number> = Reducer.make((a, b) => a * b, 1, (collection) => {
@@ -1162,6 +1164,7 @@ export const ReducerMultiply: Reducer.Reducer<number> = Reducer.make((a, b) => a
 /**
  * A `Reducer` for reducing `number`s by keeping the maximum value.
  *
+ * @category math
  * @since 4.0.0
  */
 export const ReducerMax: Reducer.Reducer<number> = Reducer.make((a, b) => Math.max(a, b), -Infinity)
@@ -1169,6 +1172,7 @@ export const ReducerMax: Reducer.Reducer<number> = Reducer.make((a, b) => Math.m
 /**
  * A `Reducer` for reducing `number`s by keeping the minimum value.
  *
+ * @category math
  * @since 4.0.0
  */
 export const ReducerMin: Reducer.Reducer<number> = Reducer.make((a, b) => Math.min(a, b), Infinity)