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

package/src/BigInt.ts

@@ -20,7 +20,7 @@ import * as Reducer from "./Reducer.ts"
  * **Example** (Constructing bigints)
  *
  * ```ts
- * import * as BigInt from "effect/BigInt"
+ * import { BigInt } from "effect"
  *
  * const bigInt = BigInt.BigInt(123)
  * console.log(bigInt) // 123n
@@ -44,11 +44,11 @@ const bigint2 = BigInt(2)
  * **Example** (Checking for bigints)
  *
  * ```ts
- * import { isBigInt } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(isBigInt(1n), true)
- * assert.deepStrictEqual(isBigInt(1), false)
+ * assert.deepStrictEqual(BigInt.isBigInt(1n), true)
+ * assert.deepStrictEqual(BigInt.isBigInt(1), false)
  * ```
  *
  * @category guards
@@ -62,10 +62,10 @@ export const isBigInt: (u: unknown) => u is bigint = predicate.isBigInt
  * **Example** (Adding bigints)
  *
  * ```ts
- * import { sum } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(sum(2n, 3n), 5n)
+ * assert.deepStrictEqual(BigInt.sum(2n, 3n), 5n)
  * ```
  *
  * @category math
@@ -78,10 +78,10 @@ export const sum: {
    * **Example** (Adding bigints)
    *
    * ```ts
-   * import { sum } from "effect/BigInt"
+   * import { BigInt } from "effect"
    * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(sum(2n, 3n), 5n)
+   * assert.deepStrictEqual(BigInt.sum(2n, 3n), 5n)
    * ```
    *
    * @category math
@@ -94,10 +94,10 @@ export const sum: {
    * **Example** (Adding bigints)
    *
    * ```ts
-   * import { sum } from "effect/BigInt"
+   * import { BigInt } from "effect"
    * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(sum(2n, 3n), 5n)
+   * assert.deepStrictEqual(BigInt.sum(2n, 3n), 5n)
    * ```
    *
    * @category math
@@ -112,10 +112,10 @@ export const sum: {
  * **Example** (Multiplying bigints)
  *
  * ```ts
- * import { multiply } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(multiply(2n, 3n), 6n)
+ * assert.deepStrictEqual(BigInt.multiply(2n, 3n), 6n)
  * ```
  *
  * @category math
@@ -128,10 +128,10 @@ export const multiply: {
    * **Example** (Multiplying bigints)
    *
    * ```ts
-   * import { multiply } from "effect/BigInt"
+   * import { BigInt } from "effect"
    * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(multiply(2n, 3n), 6n)
+   * assert.deepStrictEqual(BigInt.multiply(2n, 3n), 6n)
    * ```
    *
    * @category math
@@ -144,10 +144,10 @@ export const multiply: {
    * **Example** (Multiplying bigints)
    *
    * ```ts
-   * import { multiply } from "effect/BigInt"
+   * import { BigInt } from "effect"
    * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(multiply(2n, 3n), 6n)
+   * assert.deepStrictEqual(BigInt.multiply(2n, 3n), 6n)
    * ```
    *
    * @category math
@@ -162,10 +162,10 @@ export const multiply: {
  * **Example** (Subtracting bigints)
  *
  * ```ts
- * import { subtract } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(subtract(2n, 3n), -1n)
+ * assert.deepStrictEqual(BigInt.subtract(2n, 3n), -1n)
  * ```
  *
  * @category math
@@ -178,10 +178,10 @@ export const subtract: {
    * **Example** (Subtracting bigints)
    *
    * ```ts
-   * import { subtract } from "effect/BigInt"
+   * import { BigInt } from "effect"
    * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(subtract(2n, 3n), -1n)
+   * assert.deepStrictEqual(BigInt.subtract(2n, 3n), -1n)
    * ```
    *
    * @category math
@@ -194,10 +194,10 @@ export const subtract: {
    * **Example** (Subtracting bigints)
    *
    * ```ts
-   * import { subtract } from "effect/BigInt"
+   * import { BigInt } from "effect"
    * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(subtract(2n, 3n), -1n)
+   * assert.deepStrictEqual(BigInt.subtract(2n, 3n), -1n)
    * ```
    *
    * @category math
@@ -215,13 +215,11 @@ export const subtract: {
  * **Example** (Dividing bigints safely)
  *
  * ```ts
- * import { divide } from "effect/BigInt"
+ * import { BigInt, Option } from "effect"
  * import * as assert from "node:assert"
  *
- * import { Option } from "effect"
- *
- * assert.deepStrictEqual(divide(6n, 3n), Option.some(2n))
- * assert.deepStrictEqual(divide(6n, 0n), Option.none())
+ * assert.deepStrictEqual(BigInt.divide(6n, 3n), Option.some(2n))
+ * assert.deepStrictEqual(BigInt.divide(6n, 0n), Option.none())
  * ```
  *
  * @category math
@@ -237,13 +235,11 @@ export const divide: {
    * **Example** (Dividing bigints safely)
    *
    * ```ts
-   * import { divide } from "effect/BigInt"
+   * import { BigInt, Option } from "effect"
    * import * as assert from "node:assert"
    *
-   * import { Option } from "effect"
-   *
-   * assert.deepStrictEqual(divide(6n, 3n), Option.some(2n))
-   * assert.deepStrictEqual(divide(6n, 0n), Option.none())
+   * assert.deepStrictEqual(BigInt.divide(6n, 3n), Option.some(2n))
+   * assert.deepStrictEqual(BigInt.divide(6n, 0n), Option.none())
    * ```
    *
    * @category math
@@ -259,13 +255,11 @@ export const divide: {
    * **Example** (Dividing bigints safely)
    *
    * ```ts
-   * import { divide } from "effect/BigInt"
+   * import { BigInt, Option } from "effect"
    * import * as assert from "node:assert"
    *
-   * import { Option } from "effect"
-   *
-   * assert.deepStrictEqual(divide(6n, 3n), Option.some(2n))
-   * assert.deepStrictEqual(divide(6n, 0n), Option.none())
+   * assert.deepStrictEqual(BigInt.divide(6n, 3n), Option.some(2n))
+   * assert.deepStrictEqual(BigInt.divide(6n, 0n), Option.none())
    * ```
    *
    * @category math
@@ -286,15 +280,15 @@ export const divide: {
  * **Example** (Dividing bigints unsafely)
  *
  * ```ts
- * import { divideUnsafe } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(divideUnsafe(6n, 3n), 2n)
- * assert.deepStrictEqual(divideUnsafe(6n, 4n), 1n)
+ * assert.deepStrictEqual(BigInt.divideUnsafe(6n, 3n), 2n)
+ * assert.deepStrictEqual(BigInt.divideUnsafe(6n, 4n), 1n)
  * ```
  *
  * @category math
- * @since 2.0.0
+ * @since 4.0.0
  */
 export const divideUnsafe: {
   /**
@@ -306,15 +300,15 @@ export const divideUnsafe: {
    * **Example** (Dividing bigints unsafely)
    *
    * ```ts
-   * import { divideUnsafe } from "effect/BigInt"
+   * import { BigInt } from "effect"
    * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(divideUnsafe(6n, 3n), 2n)
-   * assert.deepStrictEqual(divideUnsafe(6n, 4n), 1n)
+   * assert.deepStrictEqual(BigInt.divideUnsafe(6n, 3n), 2n)
+   * assert.deepStrictEqual(BigInt.divideUnsafe(6n, 4n), 1n)
    * ```
    *
    * @category math
-   * @since 2.0.0
+   * @since 4.0.0
    */
   (that: bigint): (self: bigint) => bigint
   /**
@@ -326,15 +320,15 @@ export const divideUnsafe: {
    * **Example** (Dividing bigints unsafely)
    *
    * ```ts
-   * import { divideUnsafe } from "effect/BigInt"
+   * import { BigInt } from "effect"
    * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(divideUnsafe(6n, 3n), 2n)
-   * assert.deepStrictEqual(divideUnsafe(6n, 4n), 1n)
+   * assert.deepStrictEqual(BigInt.divideUnsafe(6n, 3n), 2n)
+   * assert.deepStrictEqual(BigInt.divideUnsafe(6n, 4n), 1n)
    * ```
    *
    * @category math
-   * @since 2.0.0
+   * @since 4.0.0
    */
   (self: bigint, that: bigint): bigint
 } = dual(2, (self: bigint, that: bigint): bigint => self / that)
@@ -345,10 +339,10 @@ export const divideUnsafe: {
  * **Example** (Incrementing a bigint)
  *
  * ```ts
- * import { increment } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(increment(2n), 3n)
+ * assert.deepStrictEqual(BigInt.increment(2n), 3n)
  * ```
  *
  * @category math
@@ -362,10 +356,10 @@ export const increment = (n: bigint): bigint => n + bigint1
  * **Example** (Decrementing a bigint)
  *
  * ```ts
- * import { decrement } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(decrement(3n), 2n)
+ * assert.deepStrictEqual(BigInt.decrement(3n), 2n)
  * ```
  *
  * @category math
@@ -379,7 +373,7 @@ export const decrement = (n: bigint): bigint => n - bigint1
  * **Example** (Comparing bigints with Order)
  *
  * ```ts
- * import * as BigInt from "effect/BigInt"
+ * import { BigInt } from "effect"
  *
  * const a = 123n
  * const b = 456n
@@ -408,7 +402,7 @@ export const Order: order.Order<bigint> = order.BigInt
  * ```
  *
  * @category instances
- * @since 4.0.0
+ * @since 2.0.0
  */
 export const Equivalence: Equ.Equivalence<bigint> = Equ.BigInt
 
@@ -418,16 +412,16 @@ export const Equivalence: Equ.Equivalence<bigint> = Equ.BigInt
  * **Example** (Checking less-than comparisons)
  *
  * ```ts
- * import { isLessThan } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(isLessThan(2n, 3n), true)
- * assert.deepStrictEqual(isLessThan(3n, 3n), false)
- * assert.deepStrictEqual(isLessThan(4n, 3n), false)
+ * assert.deepStrictEqual(BigInt.isLessThan(2n, 3n), true)
+ * assert.deepStrictEqual(BigInt.isLessThan(3n, 3n), false)
+ * assert.deepStrictEqual(BigInt.isLessThan(4n, 3n), false)
  * ```
  *
  * @category predicates
- * @since 2.0.0
+ * @since 4.0.0
  */
 export const isLessThan: {
   /**
@@ -436,16 +430,16 @@ export const isLessThan: {
    * **Example** (Checking less-than comparisons)
    *
    * ```ts
-   * import { isLessThan } from "effect/BigInt"
+   * import { BigInt } from "effect"
    * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(isLessThan(2n, 3n), true)
-   * assert.deepStrictEqual(isLessThan(3n, 3n), false)
-   * assert.deepStrictEqual(isLessThan(4n, 3n), false)
+   * assert.deepStrictEqual(BigInt.isLessThan(2n, 3n), true)
+   * assert.deepStrictEqual(BigInt.isLessThan(3n, 3n), false)
+   * assert.deepStrictEqual(BigInt.isLessThan(4n, 3n), false)
    * ```
    *
    * @category predicates
-   * @since 2.0.0
+   * @since 4.0.0
    */
   (that: bigint): (self: bigint) => boolean
   /**
@@ -454,16 +448,16 @@ export const isLessThan: {
    * **Example** (Checking less-than comparisons)
    *
    * ```ts
-   * import { isLessThan } from "effect/BigInt"
+   * import { BigInt } from "effect"
    * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(isLessThan(2n, 3n), true)
-   * assert.deepStrictEqual(isLessThan(3n, 3n), false)
-   * assert.deepStrictEqual(isLessThan(4n, 3n), false)
+   * assert.deepStrictEqual(BigInt.isLessThan(2n, 3n), true)
+   * assert.deepStrictEqual(BigInt.isLessThan(3n, 3n), false)
+   * assert.deepStrictEqual(BigInt.isLessThan(4n, 3n), false)
    * ```
    *
    * @category predicates
-   * @since 2.0.0
+   * @since 4.0.0
    */
   (self: bigint, that: bigint): boolean
 } = order.isLessThan(Order)
@@ -474,16 +468,16 @@ export const isLessThan: {
  * **Example** (Checking less-than-or-equal comparisons)
  *
  * ```ts
- * import { isLessThanOrEqualTo } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(isLessThanOrEqualTo(2n, 3n), true)
- * assert.deepStrictEqual(isLessThanOrEqualTo(3n, 3n), true)
- * assert.deepStrictEqual(isLessThanOrEqualTo(4n, 3n), false)
+ * assert.deepStrictEqual(BigInt.isLessThanOrEqualTo(2n, 3n), true)
+ * assert.deepStrictEqual(BigInt.isLessThanOrEqualTo(3n, 3n), true)
+ * assert.deepStrictEqual(BigInt.isLessThanOrEqualTo(4n, 3n), false)
  * ```
  *
  * @category predicates
- * @since 2.0.0
+ * @since 4.0.0
  */
 export const isLessThanOrEqualTo: {
   /**
@@ -492,16 +486,16 @@ export const isLessThanOrEqualTo: {
    * **Example** (Checking less-than-or-equal comparisons)
    *
    * ```ts
-   * import { isLessThanOrEqualTo } from "effect/BigInt"
+   * import { BigInt } from "effect"
    * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(isLessThanOrEqualTo(2n, 3n), true)
-   * assert.deepStrictEqual(isLessThanOrEqualTo(3n, 3n), true)
-   * assert.deepStrictEqual(isLessThanOrEqualTo(4n, 3n), false)
+   * assert.deepStrictEqual(BigInt.isLessThanOrEqualTo(2n, 3n), true)
+   * assert.deepStrictEqual(BigInt.isLessThanOrEqualTo(3n, 3n), true)
+   * assert.deepStrictEqual(BigInt.isLessThanOrEqualTo(4n, 3n), false)
    * ```
    *
    * @category predicates
-   * @since 2.0.0
+   * @since 4.0.0
    */
   (that: bigint): (self: bigint) => boolean
   /**
@@ -510,16 +504,16 @@ export const isLessThanOrEqualTo: {
    * **Example** (Checking less-than-or-equal comparisons)
    *
    * ```ts
-   * import { isLessThanOrEqualTo } from "effect/BigInt"
+   * import { BigInt } from "effect"
    * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(isLessThanOrEqualTo(2n, 3n), true)
-   * assert.deepStrictEqual(isLessThanOrEqualTo(3n, 3n), true)
-   * assert.deepStrictEqual(isLessThanOrEqualTo(4n, 3n), false)
+   * assert.deepStrictEqual(BigInt.isLessThanOrEqualTo(2n, 3n), true)
+   * assert.deepStrictEqual(BigInt.isLessThanOrEqualTo(3n, 3n), true)
+   * assert.deepStrictEqual(BigInt.isLessThanOrEqualTo(4n, 3n), false)
    * ```
    *
    * @category predicates
-   * @since 2.0.0
+   * @since 4.0.0
    */
   (self: bigint, that: bigint): boolean
 } = order.isLessThanOrEqualTo(Order)
@@ -530,16 +524,16 @@ export const isLessThanOrEqualTo: {
  * **Example** (Checking greater-than comparisons)
  *
  * ```ts
- * import { isGreaterThan } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(isGreaterThan(2n, 3n), false)
- * assert.deepStrictEqual(isGreaterThan(3n, 3n), false)
- * assert.deepStrictEqual(isGreaterThan(4n, 3n), true)
+ * assert.deepStrictEqual(BigInt.isGreaterThan(2n, 3n), false)
+ * assert.deepStrictEqual(BigInt.isGreaterThan(3n, 3n), false)
+ * assert.deepStrictEqual(BigInt.isGreaterThan(4n, 3n), true)
  * ```
  *
  * @category predicates
- * @since 2.0.0
+ * @since 4.0.0
  */
 export const isGreaterThan: {
   /**
@@ -548,16 +542,16 @@ export const isGreaterThan: {
    * **Example** (Checking greater-than comparisons)
    *
    * ```ts
-   * import { isGreaterThan } from "effect/BigInt"
+   * import { BigInt } from "effect"
    * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(isGreaterThan(2n, 3n), false)
-   * assert.deepStrictEqual(isGreaterThan(3n, 3n), false)
-   * assert.deepStrictEqual(isGreaterThan(4n, 3n), true)
+   * assert.deepStrictEqual(BigInt.isGreaterThan(2n, 3n), false)
+   * assert.deepStrictEqual(BigInt.isGreaterThan(3n, 3n), false)
+   * assert.deepStrictEqual(BigInt.isGreaterThan(4n, 3n), true)
    * ```
    *
    * @category predicates
-   * @since 2.0.0
+   * @since 4.0.0
    */
   (that: bigint): (self: bigint) => boolean
   /**
@@ -566,16 +560,16 @@ export const isGreaterThan: {
    * **Example** (Checking greater-than comparisons)
    *
    * ```ts
-   * import { isGreaterThan } from "effect/BigInt"
+   * import { BigInt } from "effect"
    * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(isGreaterThan(2n, 3n), false)
-   * assert.deepStrictEqual(isGreaterThan(3n, 3n), false)
-   * assert.deepStrictEqual(isGreaterThan(4n, 3n), true)
+   * assert.deepStrictEqual(BigInt.isGreaterThan(2n, 3n), false)
+   * assert.deepStrictEqual(BigInt.isGreaterThan(3n, 3n), false)
+   * assert.deepStrictEqual(BigInt.isGreaterThan(4n, 3n), true)
    * ```
    *
    * @category predicates
-   * @since 2.0.0
+   * @since 4.0.0
    */
   (self: bigint, that: bigint): boolean
 } = order.isGreaterThan(Order)
@@ -586,16 +580,16 @@ export const isGreaterThan: {
  * **Example** (Checking greater-than-or-equal comparisons)
  *
  * ```ts
- * import { isGreaterThanOrEqualTo } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(isGreaterThanOrEqualTo(2n, 3n), false)
- * assert.deepStrictEqual(isGreaterThanOrEqualTo(3n, 3n), true)
- * assert.deepStrictEqual(isGreaterThanOrEqualTo(4n, 3n), true)
+ * assert.deepStrictEqual(BigInt.isGreaterThanOrEqualTo(2n, 3n), false)
+ * assert.deepStrictEqual(BigInt.isGreaterThanOrEqualTo(3n, 3n), true)
+ * assert.deepStrictEqual(BigInt.isGreaterThanOrEqualTo(4n, 3n), true)
  * ```
  *
  * @category predicates
- * @since 2.0.0
+ * @since 4.0.0
  */
 export const isGreaterThanOrEqualTo: {
   /**
@@ -604,16 +598,16 @@ export const isGreaterThanOrEqualTo: {
    * **Example** (Checking greater-than-or-equal comparisons)
    *
    * ```ts
-   * import { isGreaterThanOrEqualTo } from "effect/BigInt"
+   * import { BigInt } from "effect"
    * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(isGreaterThanOrEqualTo(2n, 3n), false)
-   * assert.deepStrictEqual(isGreaterThanOrEqualTo(3n, 3n), true)
-   * assert.deepStrictEqual(isGreaterThanOrEqualTo(4n, 3n), true)
+   * assert.deepStrictEqual(BigInt.isGreaterThanOrEqualTo(2n, 3n), false)
+   * assert.deepStrictEqual(BigInt.isGreaterThanOrEqualTo(3n, 3n), true)
+   * assert.deepStrictEqual(BigInt.isGreaterThanOrEqualTo(4n, 3n), true)
    * ```
    *
    * @category predicates
-   * @since 2.0.0
+   * @since 4.0.0
    */
   (that: bigint): (self: bigint) => boolean
   /**
@@ -622,16 +616,16 @@ export const isGreaterThanOrEqualTo: {
    * **Example** (Checking greater-than-or-equal comparisons)
    *
    * ```ts
-   * import { isGreaterThanOrEqualTo } from "effect/BigInt"
+   * import { BigInt } from "effect"
    * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(isGreaterThanOrEqualTo(2n, 3n), false)
-   * assert.deepStrictEqual(isGreaterThanOrEqualTo(3n, 3n), true)
-   * assert.deepStrictEqual(isGreaterThanOrEqualTo(4n, 3n), true)
+   * assert.deepStrictEqual(BigInt.isGreaterThanOrEqualTo(2n, 3n), false)
+   * assert.deepStrictEqual(BigInt.isGreaterThanOrEqualTo(3n, 3n), true)
+   * assert.deepStrictEqual(BigInt.isGreaterThanOrEqualTo(4n, 3n), true)
    * ```
    *
    * @category predicates
-   * @since 2.0.0
+   * @since 4.0.0
    */
   (self: bigint, that: bigint): boolean
 } = order.isGreaterThanOrEqualTo(Order)
@@ -642,7 +636,7 @@ export const isGreaterThanOrEqualTo: {
  * **Example** (Checking whether a bigint is within bounds)
  *
  * ```ts
- * import * as BigInt from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
  * const between = BigInt.between({ minimum: 0n, maximum: 5n })
@@ -662,7 +656,7 @@ export const between: {
    * **Example** (Checking whether a bigint is within bounds)
    *
    * ```ts
-   * import * as BigInt from "effect/BigInt"
+   * import { BigInt } from "effect"
    * import * as assert from "node:assert"
    *
    * const between = BigInt.between({ minimum: 0n, maximum: 5n })
@@ -687,7 +681,7 @@ export const between: {
    * **Example** (Checking whether a bigint is within bounds)
    *
    * ```ts
-   * import * as BigInt from "effect/BigInt"
+   * import { BigInt } from "effect"
    * import * as assert from "node:assert"
    *
    * const between = BigInt.between({ minimum: 0n, maximum: 5n })
@@ -719,7 +713,7 @@ export const between: {
  * **Example** (Clamping a bigint to bounds)
  *
  * ```ts
- * import * as BigInt from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
  * const clamp = BigInt.clamp({ minimum: 1n, maximum: 5n })
@@ -743,7 +737,7 @@ export const clamp: {
    * **Example** (Clamping a bigint to bounds)
    *
    * ```ts
-   * import * as BigInt from "effect/BigInt"
+   * import { BigInt } from "effect"
    * import * as assert from "node:assert"
    *
    * const clamp = BigInt.clamp({ minimum: 1n, maximum: 5n })
@@ -772,7 +766,7 @@ export const clamp: {
    * **Example** (Clamping a bigint to bounds)
    *
    * ```ts
-   * import * as BigInt from "effect/BigInt"
+   * import { BigInt } from "effect"
    * import * as assert from "node:assert"
    *
    * const clamp = BigInt.clamp({ minimum: 1n, maximum: 5n })
@@ -800,10 +794,10 @@ export const clamp: {
  * **Example** (Finding the minimum bigint)
  *
  * ```ts
- * import { min } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(min(2n, 3n), 2n)
+ * assert.deepStrictEqual(BigInt.min(2n, 3n), 2n)
  * ```
  *
  * @category math
@@ -816,10 +810,10 @@ export const min: {
    * **Example** (Finding the minimum bigint)
    *
    * ```ts
-   * import { min } from "effect/BigInt"
+   * import { BigInt } from "effect"
    * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(min(2n, 3n), 2n)
+   * assert.deepStrictEqual(BigInt.min(2n, 3n), 2n)
    * ```
    *
    * @category math
@@ -832,10 +826,10 @@ export const min: {
    * **Example** (Finding the minimum bigint)
    *
    * ```ts
-   * import { min } from "effect/BigInt"
+   * import { BigInt } from "effect"
    * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(min(2n, 3n), 2n)
+   * assert.deepStrictEqual(BigInt.min(2n, 3n), 2n)
    * ```
    *
    * @category math
@@ -850,10 +844,10 @@ export const min: {
  * **Example** (Finding the maximum bigint)
  *
  * ```ts
- * import { max } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(max(2n, 3n), 3n)
+ * assert.deepStrictEqual(BigInt.max(2n, 3n), 3n)
  * ```
  *
  * @category math
@@ -866,10 +860,10 @@ export const max: {
    * **Example** (Finding the maximum bigint)
    *
    * ```ts
-   * import { max } from "effect/BigInt"
+   * import { BigInt } from "effect"
    * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(max(2n, 3n), 3n)
+   * assert.deepStrictEqual(BigInt.max(2n, 3n), 3n)
    * ```
    *
    * @category math
@@ -882,10 +876,10 @@ export const max: {
    * **Example** (Finding the maximum bigint)
    *
    * ```ts
-   * import { max } from "effect/BigInt"
+   * import { BigInt } from "effect"
    * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(max(2n, 3n), 3n)
+   * assert.deepStrictEqual(BigInt.max(2n, 3n), 3n)
    * ```
    *
    * @category math
@@ -900,12 +894,12 @@ export const max: {
  * **Example** (Determining bigint signs)
  *
  * ```ts
- * import { sign } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(sign(-5n), -1)
- * assert.deepStrictEqual(sign(0n), 0)
- * assert.deepStrictEqual(sign(5n), 1)
+ * assert.deepStrictEqual(BigInt.sign(-5n), -1)
+ * assert.deepStrictEqual(BigInt.sign(0n), 0)
+ * assert.deepStrictEqual(BigInt.sign(5n), 1)
  * ```
  *
  * @category math
@@ -919,12 +913,12 @@ export const sign = (n: bigint): Ordering => order.BigInt(n, bigint0)
  * **Example** (Calculating absolute values)
  *
  * ```ts
- * import { abs } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(abs(-5n), 5n)
- * assert.deepStrictEqual(abs(0n), 0n)
- * assert.deepStrictEqual(abs(5n), 5n)
+ * assert.deepStrictEqual(BigInt.abs(-5n), 5n)
+ * assert.deepStrictEqual(BigInt.abs(0n), 0n)
+ * assert.deepStrictEqual(BigInt.abs(5n), 5n)
  * ```
  *
  * @category math
@@ -938,12 +932,12 @@ export const abs = (n: bigint): bigint => (n < bigint0 ? -n : n)
  * **Example** (Calculating greatest common divisors)
  *
  * ```ts
- * import { gcd } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(gcd(2n, 3n), 1n)
- * assert.deepStrictEqual(gcd(2n, 4n), 2n)
- * assert.deepStrictEqual(gcd(16n, 24n), 8n)
+ * assert.deepStrictEqual(BigInt.gcd(2n, 3n), 1n)
+ * assert.deepStrictEqual(BigInt.gcd(2n, 4n), 2n)
+ * assert.deepStrictEqual(BigInt.gcd(16n, 24n), 8n)
  * ```
  *
  * @category math
@@ -956,12 +950,12 @@ export const gcd: {
    * **Example** (Calculating greatest common divisors)
    *
    * ```ts
-   * import { gcd } from "effect/BigInt"
+   * import { BigInt } from "effect"
    * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(gcd(2n, 3n), 1n)
-   * assert.deepStrictEqual(gcd(2n, 4n), 2n)
-   * assert.deepStrictEqual(gcd(16n, 24n), 8n)
+   * assert.deepStrictEqual(BigInt.gcd(2n, 3n), 1n)
+   * assert.deepStrictEqual(BigInt.gcd(2n, 4n), 2n)
+   * assert.deepStrictEqual(BigInt.gcd(16n, 24n), 8n)
    * ```
    *
    * @category math
@@ -974,12 +968,12 @@ export const gcd: {
    * **Example** (Calculating greatest common divisors)
    *
    * ```ts
-   * import { gcd } from "effect/BigInt"
+   * import { BigInt } from "effect"
    * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(gcd(2n, 3n), 1n)
-   * assert.deepStrictEqual(gcd(2n, 4n), 2n)
-   * assert.deepStrictEqual(gcd(16n, 24n), 8n)
+   * assert.deepStrictEqual(BigInt.gcd(2n, 3n), 1n)
+   * assert.deepStrictEqual(BigInt.gcd(2n, 4n), 2n)
+   * assert.deepStrictEqual(BigInt.gcd(16n, 24n), 8n)
    * ```
    *
    * @category math
@@ -1001,12 +995,12 @@ export const gcd: {
  * **Example** (Calculating least common multiples)
  *
  * ```ts
- * import { lcm } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(lcm(2n, 3n), 6n)
- * assert.deepStrictEqual(lcm(2n, 4n), 4n)
- * assert.deepStrictEqual(lcm(16n, 24n), 48n)
+ * assert.deepStrictEqual(BigInt.lcm(2n, 3n), 6n)
+ * assert.deepStrictEqual(BigInt.lcm(2n, 4n), 4n)
+ * assert.deepStrictEqual(BigInt.lcm(16n, 24n), 48n)
  * ```
  *
  * @category math
@@ -1019,12 +1013,12 @@ export const lcm: {
    * **Example** (Calculating least common multiples)
    *
    * ```ts
-   * import { lcm } from "effect/BigInt"
+   * import { BigInt } from "effect"
    * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(lcm(2n, 3n), 6n)
-   * assert.deepStrictEqual(lcm(2n, 4n), 4n)
-   * assert.deepStrictEqual(lcm(16n, 24n), 48n)
+   * assert.deepStrictEqual(BigInt.lcm(2n, 3n), 6n)
+   * assert.deepStrictEqual(BigInt.lcm(2n, 4n), 4n)
+   * assert.deepStrictEqual(BigInt.lcm(16n, 24n), 48n)
    * ```
    *
    * @category math
@@ -1037,12 +1031,12 @@ export const lcm: {
    * **Example** (Calculating least common multiples)
    *
    * ```ts
-   * import { lcm } from "effect/BigInt"
+   * import { BigInt } from "effect"
    * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(lcm(2n, 3n), 6n)
-   * assert.deepStrictEqual(lcm(2n, 4n), 4n)
-   * assert.deepStrictEqual(lcm(16n, 24n), 48n)
+   * assert.deepStrictEqual(BigInt.lcm(2n, 3n), 6n)
+   * assert.deepStrictEqual(BigInt.lcm(2n, 4n), 4n)
+   * assert.deepStrictEqual(BigInt.lcm(16n, 24n), 48n)
    * ```
    *
    * @category math
@@ -1060,16 +1054,16 @@ export const lcm: {
  * **Example** (Calculating square roots unsafely)
  *
  * ```ts
- * import { sqrtUnsafe } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(sqrtUnsafe(4n), 2n)
- * assert.deepStrictEqual(sqrtUnsafe(9n), 3n)
- * assert.deepStrictEqual(sqrtUnsafe(16n), 4n)
+ * assert.deepStrictEqual(BigInt.sqrtUnsafe(4n), 2n)
+ * assert.deepStrictEqual(BigInt.sqrtUnsafe(9n), 3n)
+ * assert.deepStrictEqual(BigInt.sqrtUnsafe(16n), 4n)
  * ```
  *
  * @category math
- * @since 2.0.0
+ * @since 4.0.0
  */
 export const sqrtUnsafe = (n: bigint): bigint => {
   if (n < bigint0) {
@@ -1117,10 +1111,10 @@ export const sqrt = (n: bigint): Option.Option<bigint> =>
  * **Example** (Summing iterable bigints)
  *
  * ```ts
- * import { sumAll } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(sumAll([2n, 3n, 4n]), 9n)
+ * assert.deepStrictEqual(BigInt.sumAll([2n, 3n, 4n]), 9n)
  * ```
  *
  * @category math
@@ -1143,10 +1137,10 @@ export const sumAll = (collection: Iterable<bigint>): bigint => {
  * **Example** (Multiplying iterable bigints)
  *
  * ```ts
- * import { multiplyAll } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(multiplyAll([2n, 3n, 4n]), 24n)
+ * assert.deepStrictEqual(BigInt.multiplyAll([2n, 3n, 4n]), 24n)
  * ```
  *
  * @category math
@@ -1179,7 +1173,7 @@ export const multiplyAll = (collection: Iterable<bigint>): bigint => {
  * BI.toNumber(BigInt(Number.MIN_SAFE_INTEGER) - 1n) // Option.none()
  * ```
  *
- * @category conversions
+ * @category converting
  * @since 2.0.0
  */
 export const toNumber = (b: bigint): Option.Option<number> => {
@@ -1205,7 +1199,7 @@ export const toNumber = (b: bigint): Option.Option<number> => {
  * BigInt.fromString("a") // Option.none()
  * ```
  *
- * @category conversions
+ * @category converting
  * @since 2.4.12
  */
 export const fromString = (s: string): Option.Option<bigint> => {
@@ -1236,7 +1230,7 @@ export const fromString = (s: string): Option.Option<bigint> => {
  * BigInt.fromNumber(Number.MIN_SAFE_INTEGER - 1) // Option.none()
  * ```
  *
- * @category conversions
+ * @category converting
  * @since 2.4.12
  */
 export function fromNumber(n: number): Option.Option<bigint> {
@@ -1316,6 +1310,7 @@ export const remainder: {
 /**
  * A `Reducer` for combining `bigint`s using addition.
  *
+ * @category math
  * @since 4.0.0
  */
 export const ReducerSum: Reducer.Reducer<bigint> = Reducer.make((a, b) => a + b, bigint0)
@@ -1323,6 +1318,7 @@ export const ReducerSum: Reducer.Reducer<bigint> = Reducer.make((a, b) => a + b,
 /**
  * A `Reducer` for combining `bigint`s using multiplication.
  *
+ * @category math
  * @since 4.0.0
  */
 export const ReducerMultiply: Reducer.Reducer<bigint> = Reducer.make((a, b) => a * b, bigint1, (collection) => {
@@ -1337,6 +1333,7 @@ export const ReducerMultiply: Reducer.Reducer<bigint> = Reducer.make((a, b) => a
 /**
  * A `Combiner` that returns the maximum `bigint`.
  *
+ * @category math
  * @since 4.0.0
  */
 export const CombinerMax: Combiner.Combiner<bigint> = Combiner.max(Order)
@@ -1344,6 +1341,7 @@ export const CombinerMax: Combiner.Combiner<bigint> = Combiner.max(Order)
 /**
  * A `Combiner` that returns the minimum `bigint`.
  *
+ * @category math
  * @since 4.0.0
  */
 export const CombinerMin: Combiner.Combiner<bigint> = Combiner.min(Order)