From 41e610a089658132781c3a66d6f453fc5b80e5e7 Mon Sep 17 00:00:00 2001
From: lkb <tmwlak@gmail.com>
Date: Fri, 22 Mar 2024 22:50:49 +0900
Subject: [PATCH 01/11] implemented : Number.fromString, Number.fromBigInt

---
 .changeset/sixty-news-begin.md      |   5 +
 packages/effect/src/Number.ts       |  20 +++-
 packages/effect/test/Number.test.ts | 151 ++++++++++++++++------------
 3 files changed, 109 insertions(+), 67 deletions(-)
 create mode 100644 .changeset/sixty-news-begin.md

diff --git a/.changeset/sixty-news-begin.md b/.changeset/sixty-news-begin.md
new file mode 100644
index 0000000000..b437be42e5
--- /dev/null
+++ b/.changeset/sixty-news-begin.md
@@ -0,0 +1,5 @@
+---
+"effect": major
+---
+
+add Number.fromString, Number.fromBigInt, BigInt.FromString, BigInt.fromNumber
diff --git a/packages/effect/src/Number.ts b/packages/effect/src/Number.ts
index ae76dae486..ca1f3db47c 100644
--- a/packages/effect/src/Number.ts
+++ b/packages/effect/src/Number.ts
@@ -5,7 +5,7 @@
  *
  * @since 2.0.0
  */
-import * as equivalence from "./Equivalence.js"
+import * as Number_ from "./Equivalence.js"
 import { dual } from "./Function.js"
 import * as option from "./internal/option.js"
 import type { Option } from "./Option.js"
@@ -165,7 +165,7 @@ export const decrement = (n: number): number => n - 1
  * @category instances
  * @since 2.0.0
  */
-export const Equivalence: equivalence.Equivalence<number> = equivalence.number
+export const Equivalence: Number_.Equivalence<number> = Number_.number
 
 /**
  * @category instances
@@ -493,3 +493,19 @@ export const parse = (s: string): Option<number> => {
     ? option.none
     : option.some(n)
 }
+
+export const fromString = (s: string): Option<number> => {
+  const n = Number(s)
+  return s === ""
+    ? option.none
+    : Number.isNaN(n)
+    ? option.none
+    : option.some(n)
+}
+
+export const fromBigInt = (b: bigint): Option<number> => {
+  if (b > BigInt(Number.MAX_SAFE_INTEGER) || b < BigInt(Number.MIN_SAFE_INTEGER)) {
+    return option.none
+  }
+  return option.some(Number(b))
+}
diff --git a/packages/effect/test/Number.test.ts b/packages/effect/test/Number.test.ts
index db347364ff..52d63055e7 100644
--- a/packages/effect/test/Number.test.ts
+++ b/packages/effect/test/Number.test.ts
@@ -1,138 +1,159 @@
 import { deepStrictEqual } from "effect-test/util"
 import { pipe } from "effect/Function"
-import * as Number from "effect/Number"
+import * as Number_ from "effect/Number"
 import * as Option from "effect/Option"
 import { assert, describe, expect, it } from "vitest"
 
 describe("Number", () => {
   it("isNumber", () => {
-    expect(Number.isNumber(1)).toEqual(true)
-    expect(Number.isNumber("a")).toEqual(false)
-    expect(Number.isNumber(true)).toEqual(false)
+    expect(Number_.isNumber(1)).toEqual(true)
+    expect(Number_.isNumber("a")).toEqual(false)
+    expect(Number_.isNumber(true)).toEqual(false)
   })
 
   it("sum", () => {
-    deepStrictEqual(pipe(1, Number.sum(2)), 3)
+    deepStrictEqual(pipe(1, Number_.sum(2)), 3)
   })
 
   it("multiply", () => {
-    deepStrictEqual(pipe(2, Number.multiply(3)), 6)
+    deepStrictEqual(pipe(2, Number_.multiply(3)), 6)
   })
 
   it("subtract", () => {
-    deepStrictEqual(pipe(3, Number.subtract(1)), 2)
+    deepStrictEqual(pipe(3, Number_.subtract(1)), 2)
   })
 
   it("divide", () => {
-    deepStrictEqual(pipe(6, Number.divide(2)), Option.some(3))
-    deepStrictEqual(pipe(6, Number.divide(0)), Option.none())
+    deepStrictEqual(pipe(6, Number_.divide(2)), Option.some(3))
+    deepStrictEqual(pipe(6, Number_.divide(0)), Option.none())
   })
 
   it("unsafeDivide", () => {
-    deepStrictEqual(pipe(6, Number.unsafeDivide(2)), 3)
+    deepStrictEqual(pipe(6, Number_.unsafeDivide(2)), 3)
   })
 
   it("decrement", () => {
-    deepStrictEqual(Number.decrement(2), 1)
+    deepStrictEqual(Number_.decrement(2), 1)
   })
 
   it("Equivalence", () => {
-    expect(Number.Equivalence(1, 1)).toBe(true)
-    expect(Number.Equivalence(1, 2)).toBe(false)
+    expect(Number_.Equivalence(1, 1)).toBe(true)
+    expect(Number_.Equivalence(1, 2)).toBe(false)
   })
 
   it("Order", () => {
-    deepStrictEqual(Number.Order(1, 2), -1)
-    deepStrictEqual(Number.Order(2, 1), 1)
-    deepStrictEqual(Number.Order(2, 2), 0)
+    deepStrictEqual(Number_.Order(1, 2), -1)
+    deepStrictEqual(Number_.Order(2, 1), 1)
+    deepStrictEqual(Number_.Order(2, 2), 0)
   })
 
   it("sign", () => {
-    deepStrictEqual(Number.sign(0), 0)
-    deepStrictEqual(Number.sign(0.0), 0)
-    deepStrictEqual(Number.sign(-0.1), -1)
-    deepStrictEqual(Number.sign(-10), -1)
-    deepStrictEqual(Number.sign(10), 1)
-    deepStrictEqual(Number.sign(0.1), 1)
+    deepStrictEqual(Number_.sign(0), 0)
+    deepStrictEqual(Number_.sign(0.0), 0)
+    deepStrictEqual(Number_.sign(-0.1), -1)
+    deepStrictEqual(Number_.sign(-10), -1)
+    deepStrictEqual(Number_.sign(10), 1)
+    deepStrictEqual(Number_.sign(0.1), 1)
   })
 
   it("remainder", () => {
-    assert.deepStrictEqual(Number.remainder(2, 2), 0)
-    assert.deepStrictEqual(Number.remainder(3, 2), 1)
-    assert.deepStrictEqual(Number.remainder(4, 2), 0)
-    assert.deepStrictEqual(Number.remainder(2.5, 2), 0.5)
-    assert.deepStrictEqual(Number.remainder(-2, 2), -0)
-    assert.deepStrictEqual(Number.remainder(-3, 2), -1)
-    assert.deepStrictEqual(Number.remainder(-4, 2), -0)
-    assert.deepStrictEqual(Number.remainder(-2.8, -.2), -0)
-    assert.deepStrictEqual(Number.remainder(-2, -.2), -0)
-    assert.deepStrictEqual(Number.remainder(-1.5, -.2), -0.1)
-    assert.deepStrictEqual(Number.remainder(0, -.2), 0)
-    assert.deepStrictEqual(Number.remainder(1, -.2), 0)
-    assert.deepStrictEqual(Number.remainder(2.6, -.2), 0)
-    assert.deepStrictEqual(Number.remainder(3.1, -.2), 0.1)
+    assert.deepStrictEqual(Number_.remainder(2, 2), 0)
+    assert.deepStrictEqual(Number_.remainder(3, 2), 1)
+    assert.deepStrictEqual(Number_.remainder(4, 2), 0)
+    assert.deepStrictEqual(Number_.remainder(2.5, 2), 0.5)
+    assert.deepStrictEqual(Number_.remainder(-2, 2), -0)
+    assert.deepStrictEqual(Number_.remainder(-3, 2), -1)
+    assert.deepStrictEqual(Number_.remainder(-4, 2), -0)
+    assert.deepStrictEqual(Number_.remainder(-2.8, -.2), -0)
+    assert.deepStrictEqual(Number_.remainder(-2, -.2), -0)
+    assert.deepStrictEqual(Number_.remainder(-1.5, -.2), -0.1)
+    assert.deepStrictEqual(Number_.remainder(0, -.2), 0)
+    assert.deepStrictEqual(Number_.remainder(1, -.2), 0)
+    assert.deepStrictEqual(Number_.remainder(2.6, -.2), 0)
+    assert.deepStrictEqual(Number_.remainder(3.1, -.2), 0.1)
   })
 
   it("lessThan", () => {
-    assert.deepStrictEqual(Number.lessThan(2, 3), true)
-    assert.deepStrictEqual(Number.lessThan(3, 3), false)
-    assert.deepStrictEqual(Number.lessThan(4, 3), false)
+    assert.deepStrictEqual(Number_.lessThan(2, 3), true)
+    assert.deepStrictEqual(Number_.lessThan(3, 3), false)
+    assert.deepStrictEqual(Number_.lessThan(4, 3), false)
   })
 
   it("lessThanOrEqualTo", () => {
-    assert.deepStrictEqual(Number.lessThanOrEqualTo(2, 3), true)
-    assert.deepStrictEqual(Number.lessThanOrEqualTo(3, 3), true)
-    assert.deepStrictEqual(Number.lessThanOrEqualTo(4, 3), false)
+    assert.deepStrictEqual(Number_.lessThanOrEqualTo(2, 3), true)
+    assert.deepStrictEqual(Number_.lessThanOrEqualTo(3, 3), true)
+    assert.deepStrictEqual(Number_.lessThanOrEqualTo(4, 3), false)
   })
 
   it("greaterThan", () => {
-    assert.deepStrictEqual(Number.greaterThan(2, 3), false)
-    assert.deepStrictEqual(Number.greaterThan(3, 3), false)
-    assert.deepStrictEqual(Number.greaterThan(4, 3), true)
+    assert.deepStrictEqual(Number_.greaterThan(2, 3), false)
+    assert.deepStrictEqual(Number_.greaterThan(3, 3), false)
+    assert.deepStrictEqual(Number_.greaterThan(4, 3), true)
   })
 
   it("greaterThanOrEqualTo", () => {
-    assert.deepStrictEqual(Number.greaterThanOrEqualTo(2, 3), false)
-    assert.deepStrictEqual(Number.greaterThanOrEqualTo(3, 3), true)
-    assert.deepStrictEqual(Number.greaterThanOrEqualTo(4, 3), true)
+    assert.deepStrictEqual(Number_.greaterThanOrEqualTo(2, 3), false)
+    assert.deepStrictEqual(Number_.greaterThanOrEqualTo(3, 3), true)
+    assert.deepStrictEqual(Number_.greaterThanOrEqualTo(4, 3), true)
   })
 
   it("between", () => {
-    assert.deepStrictEqual(Number.between({ minimum: 0, maximum: 5 })(3), true)
-    assert.deepStrictEqual(Number.between({ minimum: 0, maximum: 5 })(-1), false)
-    assert.deepStrictEqual(Number.between({ minimum: 0, maximum: 5 })(6), false)
+    assert.deepStrictEqual(Number_.between({ minimum: 0, maximum: 5 })(3), true)
+    assert.deepStrictEqual(Number_.between({ minimum: 0, maximum: 5 })(-1), false)
+    assert.deepStrictEqual(Number_.between({ minimum: 0, maximum: 5 })(6), false)
 
-    assert.deepStrictEqual(Number.between(3, { minimum: 0, maximum: 5 }), true)
+    assert.deepStrictEqual(Number_.between(3, { minimum: 0, maximum: 5 }), true)
   })
 
   it("clamp", () => {
-    assert.deepStrictEqual(Number.clamp({ minimum: 0, maximum: 5 })(3), 3)
-    assert.deepStrictEqual(Number.clamp({ minimum: 0, maximum: 5 })(-1), 0)
-    assert.deepStrictEqual(Number.clamp({ minimum: 0, maximum: 5 })(6), 5)
+    assert.deepStrictEqual(Number_.clamp({ minimum: 0, maximum: 5 })(3), 3)
+    assert.deepStrictEqual(Number_.clamp({ minimum: 0, maximum: 5 })(-1), 0)
+    assert.deepStrictEqual(Number_.clamp({ minimum: 0, maximum: 5 })(6), 5)
   })
 
   it("min", () => {
-    assert.deepStrictEqual(Number.min(2, 3), 2)
+    assert.deepStrictEqual(Number_.min(2, 3), 2)
   })
 
   it("max", () => {
-    assert.deepStrictEqual(Number.max(2, 3), 3)
+    assert.deepStrictEqual(Number_.max(2, 3), 3)
   })
 
   it("sumAll", () => {
-    assert.deepStrictEqual(Number.sumAll([2, 3, 4]), 9)
+    assert.deepStrictEqual(Number_.sumAll([2, 3, 4]), 9)
   })
 
   it("multiplyAll", () => {
-    assert.deepStrictEqual(Number.multiplyAll([2, 0, 4]), 0)
-    assert.deepStrictEqual(Number.multiplyAll([2, 3, 4]), 24)
+    assert.deepStrictEqual(Number_.multiplyAll([2, 0, 4]), 0)
+    assert.deepStrictEqual(Number_.multiplyAll([2, 3, 4]), 24)
   })
 
   it("parse", () => {
-    assert.deepStrictEqual(Number.parse("NaN"), Option.some(NaN))
-    assert.deepStrictEqual(Number.parse("Infinity"), Option.some(Infinity))
-    assert.deepStrictEqual(Number.parse("-Infinity"), Option.some(-Infinity))
-    assert.deepStrictEqual(Number.parse("42"), Option.some(42))
-    assert.deepStrictEqual(Number.parse("a"), Option.none())
+    assert.deepStrictEqual(Number_.parse("NaN"), Option.some(NaN))
+    assert.deepStrictEqual(Number_.parse("Infinity"), Option.some(Infinity))
+    assert.deepStrictEqual(Number_.parse("-Infinity"), Option.some(-Infinity))
+    assert.deepStrictEqual(Number_.parse("42"), Option.some(42))
+    assert.deepStrictEqual(Number_.parse("a"), Option.none())
+  })
+
+  it("fromString", () => {
+    assert.deepStrictEqual(Number_.fromString("NaN"), Option.none())
+    assert.deepStrictEqual(Number_.parse("Infinity"), Option.some(Infinity))
+    assert.deepStrictEqual(Number_.parse("-Infinity"), Option.some(-Infinity))
+    assert.deepStrictEqual(Number_.parse("42"), Option.some(42))
+    assert.deepStrictEqual(Number_.parse(" 42 \n\r\t"), Option.some(42))
+    assert.deepStrictEqual(Number_.fromString("3.14"), Option.some(3.14))
+    assert.deepStrictEqual(Number_.fromString(""), Option.none())
+    assert.deepStrictEqual(Number_.parse("a"), Option.none())
+  })
+
+  it("fromBigInt", () => {
+    assert.deepStrictEqual(Number_.fromBigInt(BigInt(Number.MAX_SAFE_INTEGER)), Option.some(Number.MAX_SAFE_INTEGER))
+    assert.deepStrictEqual(Number_.fromBigInt(BigInt(Number.MAX_SAFE_INTEGER) + BigInt(1)), Option.none())
+    assert.deepStrictEqual(Number_.fromBigInt(BigInt(Number.MIN_SAFE_INTEGER)), Option.some(Number.MIN_SAFE_INTEGER))
+    assert.deepStrictEqual(Number_.fromBigInt(BigInt(Number.MIN_SAFE_INTEGER) - BigInt(1)), Option.none())
+    assert.deepStrictEqual(Number_.fromBigInt(BigInt(0)), Option.some(0))
+    assert.deepStrictEqual(Number_.fromBigInt(BigInt(42)), Option.some(42))
+    assert.deepStrictEqual(Number_.fromBigInt(BigInt(-42)), Option.some(-42))
   })
 })

From ad8afe80ffce0a3ba508bfde0fd69270181d1d3e Mon Sep 17 00:00:00 2001
From: lkb <tmwlak@gmail.com>
Date: Sun, 24 Mar 2024 19:05:54 +0900
Subject: [PATCH 02/11] implemented : BigInt.fromString, BigInt.fromNumber

---
 packages/effect/src/BigInt.ts       | 65 +++++++++++++++++++++++++++++
 packages/effect/src/Number.ts       | 47 ++++++++++++++++++++-
 packages/effect/test/BigInt.test.ts | 31 ++++++++++++++
 packages/effect/test/Number.test.ts | 12 +++---
 4 files changed, 149 insertions(+), 6 deletions(-)

diff --git a/packages/effect/src/BigInt.ts b/packages/effect/src/BigInt.ts
index 5a0305807e..66e55a489e 100644
--- a/packages/effect/src/BigInt.ts
+++ b/packages/effect/src/BigInt.ts
@@ -558,3 +558,68 @@ export const toNumber = (b: bigint): Option.Option<number> => {
   }
   return Option.some(Number(b))
 }
+
+/**
+ * Takes a string and returns an `Option` of `bigint`.
+ *
+ * If the string is empty or contains characters that cannot be converted into a `bigint`,
+ * it returns `Option.none()`, otherwise, it returns `Option.some(bigint)`.
+ *
+ * @param s - The string to be converted to a `bigint`.
+ * @returns An `Option` type that is either `some(bigint)` if the string can be converted,
+ *          or `none()` if it cannot.
+ *
+ * @example
+ * import { fromString } from 'effect/BigInt'
+ *
+ * assert.deepStrictEqual(fromString("1234"), Option.some(BigInt(1234)))
+ * assert.deepStrictEqual(fromString(" "), Option.none())
+ * assert.deepStrictEqual(fromString("a"), Option.none())
+ *
+ * @category conversions
+ * @since 2.4.12
+ */
+
+export const fromString = (s: string): Option.Option<bigint> => {
+  try {
+    return s.trim() === ""
+      ? Option.none()
+      : Option.some(BigInt(s))
+  } catch (_) {
+    return Option.none()
+  }
+}
+
+/**
+ * Takes a number and returns an `Option` of `bigint`.
+ *
+ * If the number is outside the safe integer range for JavaScript (`Number.MAX_SAFE_INTEGER`
+ * and `Number.MIN_SAFE_INTEGER`), it returns `Option.none()`. Otherwise, it attempts to
+ * convert the number to a `bigint` and returns `Option.some(bigint)`.
+ *
+ * @param n - The number to be converted to a `bigint`.
+ * @returns An `Option` type that is either `some(bigint)` if the number is within the safe
+ *          integer range and can be converted, or `none()` if it is out of the safe range
+ *          or if the conversion fails.
+ *
+ * @example
+ * import { fromNumber } from 'effect/BigInt'
+ *
+ * assert.deepStrictEqual(fromNumber(42), Option.some(BigInt(42)))
+ * assert.deepStrictEqual(fromNumber(Number.MAX_SAFE_INTEGER + 1), Option.none())
+ * assert.deepStrictEqual(fromNumber(Number.MIN_SAFE_INTEGER - 1), Option.none())
+ *
+ * @category conversions
+ * @since 2.4.12
+ */
+export const fromNumber = (n: number): Option.Option<bigint> => {
+  if (n > Number.MAX_SAFE_INTEGER || n < Number.MIN_SAFE_INTEGER) {
+    return Option.none()
+  }
+
+  try {
+    return Option.some(BigInt(n))
+  } catch (_) {
+    return Option.none()
+  }
+}
diff --git a/packages/effect/src/Number.ts b/packages/effect/src/Number.ts
index ca1f3db47c..c7111fc4a5 100644
--- a/packages/effect/src/Number.ts
+++ b/packages/effect/src/Number.ts
@@ -494,15 +494,60 @@ export const parse = (s: string): Option<number> => {
     : option.some(n)
 }
 
+/**
+ * Takes a string and returns an `Option` of `number`.
+ *
+ * If the string is empty or cannot be converted to a number due to invalid characters,
+ * it returns `option.none`. Otherwise, it attempts to convert the string to a number
+ * and returns `option.some(number)`.
+ *
+ * @param s - The string to be converted to a `number`.
+ * @returns An `Option` type that is either `some(number)` if the string can be converted
+ *          to a valid number, or `none` if the string is empty or contains invalid characters
+ *          for number conversion.
+ *
+ * @example
+ * import { fromString } from 'effect/Number'
+ *
+ * assert.deepStrictEqual(fromString("42"), option.some(42))
+ * assert.deepStrictEqual(fromString(""), option.none)
+ * assert.deepStrictEqual(fromString("not a number"), option.none)
+ *
+ * @category conversions
+ * @since 2.4.12
+ */
+
 export const fromString = (s: string): Option<number> => {
   const n = Number(s)
-  return s === ""
+  return s.trim() === ""
     ? option.none
     : Number.isNaN(n)
     ? option.none
     : option.some(n)
 }
 
+/**
+ * Takes a `bigint` and returns an `Option` of `number`.
+ *
+ * If the `bigint` is outside the safe integer range for JavaScript (`Number.MAX_SAFE_INTEGER`
+ * and `Number.MIN_SAFE_INTEGER`), it returns `option.none`. Otherwise, it converts the `bigint`
+ * to a number and returns `option.some(number)`.
+ *
+ * @param b - The `bigint` to be converted to a `number`.
+ * @returns An `Option` type that is either `some(number)` if the `bigint` is within the safe
+ *          integer range and can be converted, or `none` if it is out of the safe range.
+ *
+ * @example
+ * import { fromBigInt } from 'effect/Number'
+ *
+ * assert.deepStrictEqual(fromBigInt(BigInt(42)), option.some(42))
+ * assert.deepStrictEqual(fromBigInt(BigInt(Number.MAX_SAFE_INTEGER) + BigInt(1)), option.none)
+ * assert.deepStrictEqual(fromBigInt(BigInt(Number.MIN_SAFE_INTEGER) - BigInt(1)), option.none)
+ *
+ * @category conversions
+ * @since 2.4.12
+ */
+
 export const fromBigInt = (b: bigint): Option<number> => {
   if (b > BigInt(Number.MAX_SAFE_INTEGER) || b < BigInt(Number.MIN_SAFE_INTEGER)) {
     return option.none
diff --git a/packages/effect/test/BigInt.test.ts b/packages/effect/test/BigInt.test.ts
index 3a3017b042..acf1842d20 100644
--- a/packages/effect/test/BigInt.test.ts
+++ b/packages/effect/test/BigInt.test.ts
@@ -145,4 +145,35 @@ describe("BigInt", () => {
     assert.deepStrictEqual(BigInt_.toNumber(1n), Option.some(1))
     assert.deepStrictEqual(BigInt_.toNumber(BigInt(Number.MAX_SAFE_INTEGER) + 1n), Option.none())
   })
+
+  it("fromString", () => {
+    assert.deepStrictEqual(BigInt_.fromString("NaN"), Option.none())
+    assert.deepStrictEqual(BigInt_.fromString("Infinity"), Option.none())
+    assert.deepStrictEqual(BigInt_.fromString("-Infinity"), Option.none())
+    assert.deepStrictEqual(BigInt_.fromString("3.14"), Option.none())
+    assert.deepStrictEqual(BigInt_.fromString("-3.14"), Option.none())
+    assert.deepStrictEqual(BigInt_.fromString("1e3"), Option.none())
+    assert.deepStrictEqual(BigInt_.fromString("1e-3"), Option.none())
+    assert.deepStrictEqual(BigInt_.fromString(""), Option.none())
+    assert.deepStrictEqual(BigInt_.fromString("a"), Option.none())
+    assert.deepStrictEqual(BigInt_.fromString("42"), Option.some(BigInt(42)))
+    assert.deepStrictEqual(BigInt_.fromString("\n\r\t 42 \n\r\t"), Option.some(BigInt(42)))
+  })
+
+  it("fromNumber", () => {
+    assert.deepStrictEqual(BigInt_.fromNumber(Number.MAX_SAFE_INTEGER), Option.some(BigInt(Number.MAX_SAFE_INTEGER)))
+    assert.deepStrictEqual(BigInt_.fromNumber(Number.MAX_SAFE_INTEGER + 1), Option.none())
+    assert.deepStrictEqual(BigInt_.fromNumber(Number.MIN_SAFE_INTEGER), Option.some(BigInt(Number.MIN_SAFE_INTEGER)))
+    assert.deepStrictEqual(BigInt_.fromNumber(Number.MIN_SAFE_INTEGER - 1), Option.none())
+    assert.deepStrictEqual(BigInt_.fromNumber(Infinity), Option.none())
+    assert.deepStrictEqual(BigInt_.fromNumber(-Infinity), Option.none())
+    assert.deepStrictEqual(BigInt_.fromNumber(NaN), Option.none())
+    assert.deepStrictEqual(BigInt_.fromNumber(1e100), Option.none())
+    assert.deepStrictEqual(BigInt_.fromNumber(-1e100), Option.none())
+    assert.deepStrictEqual(BigInt_.fromNumber(3.14), Option.none())
+    assert.deepStrictEqual(BigInt_.fromNumber(-3.14), Option.none())
+    assert.deepStrictEqual(BigInt_.fromNumber(0), Option.some(BigInt(0)))
+    assert.deepStrictEqual(BigInt_.fromNumber(42), Option.some(BigInt(42)))
+    assert.deepStrictEqual(BigInt_.fromNumber(-42), Option.some(BigInt(-42)))
+  })
 })
diff --git a/packages/effect/test/Number.test.ts b/packages/effect/test/Number.test.ts
index 52d63055e7..4df1d84129 100644
--- a/packages/effect/test/Number.test.ts
+++ b/packages/effect/test/Number.test.ts
@@ -138,13 +138,15 @@ describe("Number", () => {
 
   it("fromString", () => {
     assert.deepStrictEqual(Number_.fromString("NaN"), Option.none())
-    assert.deepStrictEqual(Number_.parse("Infinity"), Option.some(Infinity))
-    assert.deepStrictEqual(Number_.parse("-Infinity"), Option.some(-Infinity))
-    assert.deepStrictEqual(Number_.parse("42"), Option.some(42))
-    assert.deepStrictEqual(Number_.parse(" 42 \n\r\t"), Option.some(42))
+    assert.deepStrictEqual(Number_.fromString("Infinity"), Option.some(Infinity))
+    assert.deepStrictEqual(Number_.fromString("-Infinity"), Option.some(-Infinity))
+    assert.deepStrictEqual(Number_.fromString("42"), Option.some(42))
+    assert.deepStrictEqual(Number_.fromString(" 42 \n\r\t"), Option.some(42))
     assert.deepStrictEqual(Number_.fromString("3.14"), Option.some(3.14))
+    assert.deepStrictEqual(Number_.fromString("1e3"), Option.some(1000))
+    assert.deepStrictEqual(Number_.fromString("1e-3"), Option.some(0.001))
     assert.deepStrictEqual(Number_.fromString(""), Option.none())
-    assert.deepStrictEqual(Number_.parse("a"), Option.none())
+    assert.deepStrictEqual(Number_.fromString("a"), Option.none())
   })
 
   it("fromBigInt", () => {

From c498d903f3416c7af4c87e9f661ed0c34a0db91b Mon Sep 17 00:00:00 2001
From: lkb <tmwlak@gmail.com>
Date: Sun, 24 Mar 2024 19:29:12 +0900
Subject: [PATCH 03/11] fix typos

---
 packages/effect/src/BigInt.ts | 2 +-
 packages/effect/src/Number.ts | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/effect/src/BigInt.ts b/packages/effect/src/BigInt.ts
index 66e55a489e..37a6e538b7 100644
--- a/packages/effect/src/BigInt.ts
+++ b/packages/effect/src/BigInt.ts
@@ -572,7 +572,7 @@ export const toNumber = (b: bigint): Option.Option<number> => {
  * @example
  * import { fromString } from 'effect/BigInt'
  *
- * assert.deepStrictEqual(fromString("1234"), Option.some(BigInt(1234)))
+ * assert.deepStrictEqual(fromString("42"), Option.some(BigInt(42)))
  * assert.deepStrictEqual(fromString(" "), Option.none())
  * assert.deepStrictEqual(fromString("a"), Option.none())
  *
diff --git a/packages/effect/src/Number.ts b/packages/effect/src/Number.ts
index c7111fc4a5..17fc803867 100644
--- a/packages/effect/src/Number.ts
+++ b/packages/effect/src/Number.ts
@@ -497,7 +497,7 @@ export const parse = (s: string): Option<number> => {
 /**
  * Takes a string and returns an `Option` of `number`.
  *
- * If the string is empty or cannot be converted to a number due to invalid characters,
+ * If the string is empty or invalid characters,
  * it returns `option.none`. Otherwise, it attempts to convert the string to a number
  * and returns `option.some(number)`.
  *

From d303124e8865a780daef5c0b4d62e706de6091b8 Mon Sep 17 00:00:00 2001
From: lkb <tmwlak@gmail.com>
Date: Sun, 24 Mar 2024 22:14:32 +0900
Subject: [PATCH 04/11] fixed by PR comment

---
 packages/effect/src/BigInt.ts | 10 ++--------
 packages/effect/src/Number.ts | 25 +++++++++----------------
 2 files changed, 11 insertions(+), 24 deletions(-)

diff --git a/packages/effect/src/BigInt.ts b/packages/effect/src/BigInt.ts
index 37a6e538b7..8b06fcbc0e 100644
--- a/packages/effect/src/BigInt.ts
+++ b/packages/effect/src/BigInt.ts
@@ -566,11 +566,9 @@ export const toNumber = (b: bigint): Option.Option<number> => {
  * it returns `Option.none()`, otherwise, it returns `Option.some(bigint)`.
  *
  * @param s - The string to be converted to a `bigint`.
- * @returns An `Option` type that is either `some(bigint)` if the string can be converted,
- *          or `none()` if it cannot.
  *
  * @example
- * import { fromString } from 'effect/BigInt'
+ * import { fromString } from "effect/BigInt"
  *
  * assert.deepStrictEqual(fromString("42"), Option.some(BigInt(42)))
  * assert.deepStrictEqual(fromString(" "), Option.none())
@@ -579,7 +577,6 @@ export const toNumber = (b: bigint): Option.Option<number> => {
  * @category conversions
  * @since 2.4.12
  */
-
 export const fromString = (s: string): Option.Option<bigint> => {
   try {
     return s.trim() === ""
@@ -598,12 +595,9 @@ export const fromString = (s: string): Option.Option<bigint> => {
  * convert the number to a `bigint` and returns `Option.some(bigint)`.
  *
  * @param n - The number to be converted to a `bigint`.
- * @returns An `Option` type that is either `some(bigint)` if the number is within the safe
- *          integer range and can be converted, or `none()` if it is out of the safe range
- *          or if the conversion fails.
  *
  * @example
- * import { fromNumber } from 'effect/BigInt'
+ * import { fromNumber } from "effect/BigInt"
  *
  * assert.deepStrictEqual(fromNumber(42), Option.some(BigInt(42)))
  * assert.deepStrictEqual(fromNumber(Number.MAX_SAFE_INTEGER + 1), Option.none())
diff --git a/packages/effect/src/Number.ts b/packages/effect/src/Number.ts
index 17fc803867..6b961f5edb 100644
--- a/packages/effect/src/Number.ts
+++ b/packages/effect/src/Number.ts
@@ -5,7 +5,7 @@
  *
  * @since 2.0.0
  */
-import * as Number_ from "./Equivalence.js"
+import * as equivalence from "./Equivalence.js"
 import { dual } from "./Function.js"
 import * as option from "./internal/option.js"
 import type { Option } from "./Option.js"
@@ -165,7 +165,7 @@ export const decrement = (n: number): number => n - 1
  * @category instances
  * @since 2.0.0
  */
-export const Equivalence: Number_.Equivalence<number> = Number_.number
+export const Equivalence: equivalence.Equivalence<number> = equivalence.number
 
 /**
  * @category instances
@@ -400,7 +400,7 @@ export const sumAll = (collection: Iterable<number>): number => {
  * @param collection - The collection of `number`s to multiply.
  *
  * @example
- * import { multiplyAll } from 'effect/Number'
+ * import { multiplyAll } from "effect/Number"
  *
  * assert.deepStrictEqual(multiplyAll([2, 3, 4]), 24)
  *
@@ -498,16 +498,13 @@ export const parse = (s: string): Option<number> => {
  * Takes a string and returns an `Option` of `number`.
  *
  * If the string is empty or invalid characters,
- * it returns `option.none`. Otherwise, it attempts to convert the string to a number
- * and returns `option.some(number)`.
+ * it returns `Option.none`. Otherwise, it attempts to convert the string to a number
+ * and returns `Option.some(number)`.
  *
  * @param s - The string to be converted to a `number`.
- * @returns An `Option` type that is either `some(number)` if the string can be converted
- *          to a valid number, or `none` if the string is empty or contains invalid characters
- *          for number conversion.
  *
  * @example
- * import { fromString } from 'effect/Number'
+ * import { fromString } from "effect/Number"
  *
  * assert.deepStrictEqual(fromString("42"), option.some(42))
  * assert.deepStrictEqual(fromString(""), option.none)
@@ -516,7 +513,6 @@ export const parse = (s: string): Option<number> => {
  * @category conversions
  * @since 2.4.12
  */
-
 export const fromString = (s: string): Option<number> => {
   const n = Number(s)
   return s.trim() === ""
@@ -530,15 +526,13 @@ export const fromString = (s: string): Option<number> => {
  * Takes a `bigint` and returns an `Option` of `number`.
  *
  * If the `bigint` is outside the safe integer range for JavaScript (`Number.MAX_SAFE_INTEGER`
- * and `Number.MIN_SAFE_INTEGER`), it returns `option.none`. Otherwise, it converts the `bigint`
- * to a number and returns `option.some(number)`.
+ * and `Number.MIN_SAFE_INTEGER`), it returns `Option.none`. Otherwise, it converts the `bigint`
+ * to a number and returns `Option.some(number)`.
  *
  * @param b - The `bigint` to be converted to a `number`.
- * @returns An `Option` type that is either `some(number)` if the `bigint` is within the safe
- *          integer range and can be converted, or `none` if it is out of the safe range.
  *
  * @example
- * import { fromBigInt } from 'effect/Number'
+ * import { fromBigInt } from "effect/Number"
  *
  * assert.deepStrictEqual(fromBigInt(BigInt(42)), option.some(42))
  * assert.deepStrictEqual(fromBigInt(BigInt(Number.MAX_SAFE_INTEGER) + BigInt(1)), option.none)
@@ -547,7 +541,6 @@ export const fromString = (s: string): Option<number> => {
  * @category conversions
  * @since 2.4.12
  */
-
 export const fromBigInt = (b: bigint): Option<number> => {
   if (b > BigInt(Number.MAX_SAFE_INTEGER) || b < BigInt(Number.MIN_SAFE_INTEGER)) {
     return option.none

From 42ed90556efa9b6ca8a9dd2182f2c6f97ce081be Mon Sep 17 00:00:00 2001
From: lkb <tmwlak@gmail.com>
Date: Mon, 25 Mar 2024 08:24:48 +0900
Subject: [PATCH 05/11] remove Number.fromBigInt

---
 .changeset/sixty-news-begin.md      |  2 +-
 packages/effect/src/BigInt.ts       | 17 +++++++++++++++--
 packages/effect/src/Number.ts       | 26 --------------------------
 packages/effect/test/BigInt.test.ts |  9 +++++++--
 packages/effect/test/Number.test.ts | 10 ----------
 5 files changed, 23 insertions(+), 41 deletions(-)

diff --git a/.changeset/sixty-news-begin.md b/.changeset/sixty-news-begin.md
index b437be42e5..210c328011 100644
--- a/.changeset/sixty-news-begin.md
+++ b/.changeset/sixty-news-begin.md
@@ -1,5 +1,5 @@
 ---
-"effect": major
+"effect": patch
 ---
 
 add Number.fromString, Number.fromBigInt, BigInt.FromString, BigInt.fromNumber
diff --git a/packages/effect/src/BigInt.ts b/packages/effect/src/BigInt.ts
index 8b06fcbc0e..4155318472 100644
--- a/packages/effect/src/BigInt.ts
+++ b/packages/effect/src/BigInt.ts
@@ -547,10 +547,23 @@ export const multiplyAll = (collection: Iterable<bigint>): bigint => {
 }
 
 /**
- * Convers a bigint into a number
+ * Takes a `bigint` and returns an `Option` of `number`.
+ *
+ * If the `bigint` is outside the safe integer range for JavaScript (`Number.MAX_SAFE_INTEGER`
+ * and `Number.MIN_SAFE_INTEGER`), it returns `Option.none`. Otherwise, it converts the `bigint`
+ * to a number and returns `Option.some(number)`.
+ *
+ * @param b - The `bigint` to be converted to a `number`.
+ *
+ * @example
+ * import { fromBigInt } from "effect/Number"
+ *
+ * assert.deepStrictEqual(fromBigInt(BigInt(42)), option.some(42))
+ * assert.deepStrictEqual(fromBigInt(BigInt(Number.MAX_SAFE_INTEGER) + BigInt(1)), option.none)
+ * assert.deepStrictEqual(fromBigInt(BigInt(Number.MIN_SAFE_INTEGER) - BigInt(1)), option.none)
  *
- * @since 2.0.0
  * @category conversions
+ * @since 2.4.12
  */
 export const toNumber = (b: bigint): Option.Option<number> => {
   if (b > BigInt(Number.MAX_SAFE_INTEGER) || b < BigInt(Number.MIN_SAFE_INTEGER)) {
diff --git a/packages/effect/src/Number.ts b/packages/effect/src/Number.ts
index 6b961f5edb..62d5cbbb68 100644
--- a/packages/effect/src/Number.ts
+++ b/packages/effect/src/Number.ts
@@ -521,29 +521,3 @@ export const fromString = (s: string): Option<number> => {
     ? option.none
     : option.some(n)
 }
-
-/**
- * Takes a `bigint` and returns an `Option` of `number`.
- *
- * If the `bigint` is outside the safe integer range for JavaScript (`Number.MAX_SAFE_INTEGER`
- * and `Number.MIN_SAFE_INTEGER`), it returns `Option.none`. Otherwise, it converts the `bigint`
- * to a number and returns `Option.some(number)`.
- *
- * @param b - The `bigint` to be converted to a `number`.
- *
- * @example
- * import { fromBigInt } from "effect/Number"
- *
- * assert.deepStrictEqual(fromBigInt(BigInt(42)), option.some(42))
- * assert.deepStrictEqual(fromBigInt(BigInt(Number.MAX_SAFE_INTEGER) + BigInt(1)), option.none)
- * assert.deepStrictEqual(fromBigInt(BigInt(Number.MIN_SAFE_INTEGER) - BigInt(1)), option.none)
- *
- * @category conversions
- * @since 2.4.12
- */
-export const fromBigInt = (b: bigint): Option<number> => {
-  if (b > BigInt(Number.MAX_SAFE_INTEGER) || b < BigInt(Number.MIN_SAFE_INTEGER)) {
-    return option.none
-  }
-  return option.some(Number(b))
-}
diff --git a/packages/effect/test/BigInt.test.ts b/packages/effect/test/BigInt.test.ts
index acf1842d20..4c70c04867 100644
--- a/packages/effect/test/BigInt.test.ts
+++ b/packages/effect/test/BigInt.test.ts
@@ -142,8 +142,13 @@ describe("BigInt", () => {
   })
 
   it("toNumber", () => {
-    assert.deepStrictEqual(BigInt_.toNumber(1n), Option.some(1))
-    assert.deepStrictEqual(BigInt_.toNumber(BigInt(Number.MAX_SAFE_INTEGER) + 1n), Option.none())
+    assert.deepStrictEqual(BigInt_.toNumber(BigInt(Number.MAX_SAFE_INTEGER)), Option.some(Number.MAX_SAFE_INTEGER))
+    assert.deepStrictEqual(BigInt_.toNumber(BigInt(Number.MAX_SAFE_INTEGER) + BigInt(1)), Option.none())
+    assert.deepStrictEqual(BigInt_.toNumber(BigInt(Number.MIN_SAFE_INTEGER)), Option.some(Number.MIN_SAFE_INTEGER))
+    assert.deepStrictEqual(BigInt_.toNumber(BigInt(Number.MIN_SAFE_INTEGER) - BigInt(1)), Option.none())
+    assert.deepStrictEqual(BigInt_.toNumber(BigInt(0)), Option.some(0))
+    assert.deepStrictEqual(BigInt_.toNumber(BigInt(42)), Option.some(42))
+    assert.deepStrictEqual(BigInt_.toNumber(BigInt(-42)), Option.some(-42))
   })
 
   it("fromString", () => {
diff --git a/packages/effect/test/Number.test.ts b/packages/effect/test/Number.test.ts
index 4df1d84129..f7bd0f1fd4 100644
--- a/packages/effect/test/Number.test.ts
+++ b/packages/effect/test/Number.test.ts
@@ -148,14 +148,4 @@ describe("Number", () => {
     assert.deepStrictEqual(Number_.fromString(""), Option.none())
     assert.deepStrictEqual(Number_.fromString("a"), Option.none())
   })
-
-  it("fromBigInt", () => {
-    assert.deepStrictEqual(Number_.fromBigInt(BigInt(Number.MAX_SAFE_INTEGER)), Option.some(Number.MAX_SAFE_INTEGER))
-    assert.deepStrictEqual(Number_.fromBigInt(BigInt(Number.MAX_SAFE_INTEGER) + BigInt(1)), Option.none())
-    assert.deepStrictEqual(Number_.fromBigInt(BigInt(Number.MIN_SAFE_INTEGER)), Option.some(Number.MIN_SAFE_INTEGER))
-    assert.deepStrictEqual(Number_.fromBigInt(BigInt(Number.MIN_SAFE_INTEGER) - BigInt(1)), Option.none())
-    assert.deepStrictEqual(Number_.fromBigInt(BigInt(0)), Option.some(0))
-    assert.deepStrictEqual(Number_.fromBigInt(BigInt(42)), Option.some(42))
-    assert.deepStrictEqual(Number_.fromBigInt(BigInt(-42)), Option.some(-42))
-  })
 })

From 18226b59ee136de14d8cdadb929b6bffe5a5854c Mon Sep 17 00:00:00 2001
From: lkb <tmwlak@gmail.com>
Date: Mon, 25 Mar 2024 08:28:48 +0900
Subject: [PATCH 06/11] fix type issue

---
 packages/effect/src/BigInt.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/effect/src/BigInt.ts b/packages/effect/src/BigInt.ts
index 4155318472..920f89168b 100644
--- a/packages/effect/src/BigInt.ts
+++ b/packages/effect/src/BigInt.ts
@@ -563,7 +563,7 @@ export const multiplyAll = (collection: Iterable<bigint>): bigint => {
  * assert.deepStrictEqual(fromBigInt(BigInt(Number.MIN_SAFE_INTEGER) - BigInt(1)), option.none)
  *
  * @category conversions
- * @since 2.4.12
+ * @since 2.0.0
  */
 export const toNumber = (b: bigint): Option.Option<number> => {
   if (b > BigInt(Number.MAX_SAFE_INTEGER) || b < BigInt(Number.MIN_SAFE_INTEGER)) {

From a4cb6a168def695308ba4ea76c645f3cd2355651 Mon Sep 17 00:00:00 2001
From: lkb <tmwlak@gmail.com>
Date: Mon, 25 Mar 2024 09:32:00 +0900
Subject: [PATCH 07/11] fix comment for docs, and import variable name (Number_
 -> Number)

---
 .changeset/sixty-news-begin.md      |   2 +-
 packages/effect/src/BigInt.ts       |   9 +-
 packages/effect/src/Number.ts       |   7 +-
 packages/effect/test/Number.test.ts | 150 ++++++++++++++--------------
 4 files changed, 86 insertions(+), 82 deletions(-)

diff --git a/.changeset/sixty-news-begin.md b/.changeset/sixty-news-begin.md
index 210c328011..fa666baa87 100644
--- a/.changeset/sixty-news-begin.md
+++ b/.changeset/sixty-news-begin.md
@@ -2,4 +2,4 @@
 "effect": patch
 ---
 
-add Number.fromString, Number.fromBigInt, BigInt.FromString, BigInt.fromNumber
+add BigInt.fromString and BigInt.fromNumber
diff --git a/packages/effect/src/BigInt.ts b/packages/effect/src/BigInt.ts
index 920f89168b..036e5cd484 100644
--- a/packages/effect/src/BigInt.ts
+++ b/packages/effect/src/BigInt.ts
@@ -557,10 +557,11 @@ export const multiplyAll = (collection: Iterable<bigint>): bigint => {
  *
  * @example
  * import { fromBigInt } from "effect/Number"
+ * import { Option } from "effect"
  *
- * assert.deepStrictEqual(fromBigInt(BigInt(42)), option.some(42))
- * assert.deepStrictEqual(fromBigInt(BigInt(Number.MAX_SAFE_INTEGER) + BigInt(1)), option.none)
- * assert.deepStrictEqual(fromBigInt(BigInt(Number.MIN_SAFE_INTEGER) - BigInt(1)), option.none)
+ * assert.deepStrictEqual(fromBigInt(BigInt(42)), Option.some(42))
+ * assert.deepStrictEqual(fromBigInt(BigInt(Number.MAX_SAFE_INTEGER) + BigInt(1)), Option.none())
+ * assert.deepStrictEqual(fromBigInt(BigInt(Number.MIN_SAFE_INTEGER) - BigInt(1)), Option.none())
  *
  * @category conversions
  * @since 2.0.0
@@ -582,6 +583,7 @@ export const toNumber = (b: bigint): Option.Option<number> => {
  *
  * @example
  * import { fromString } from "effect/BigInt"
+ * import { Option } from "effect"
  *
  * assert.deepStrictEqual(fromString("42"), Option.some(BigInt(42)))
  * assert.deepStrictEqual(fromString(" "), Option.none())
@@ -611,6 +613,7 @@ export const fromString = (s: string): Option.Option<bigint> => {
  *
  * @example
  * import { fromNumber } from "effect/BigInt"
+ * import { Option } from "effect"
  *
  * assert.deepStrictEqual(fromNumber(42), Option.some(BigInt(42)))
  * assert.deepStrictEqual(fromNumber(Number.MAX_SAFE_INTEGER + 1), Option.none())
diff --git a/packages/effect/src/Number.ts b/packages/effect/src/Number.ts
index 62d5cbbb68..ed32fb0b84 100644
--- a/packages/effect/src/Number.ts
+++ b/packages/effect/src/Number.ts
@@ -505,10 +505,11 @@ export const parse = (s: string): Option<number> => {
  *
  * @example
  * import { fromString } from "effect/Number"
+ * import { Option } from "effect"
  *
- * assert.deepStrictEqual(fromString("42"), option.some(42))
- * assert.deepStrictEqual(fromString(""), option.none)
- * assert.deepStrictEqual(fromString("not a number"), option.none)
+ * assert.deepStrictEqual(fromString("42"), Option.some(42))
+ * assert.deepStrictEqual(fromString(""), Option.none())
+ * assert.deepStrictEqual(fromString("not a number"), Option.none())
  *
  * @category conversions
  * @since 2.4.12
diff --git a/packages/effect/test/Number.test.ts b/packages/effect/test/Number.test.ts
index f7bd0f1fd4..5d4882b490 100644
--- a/packages/effect/test/Number.test.ts
+++ b/packages/effect/test/Number.test.ts
@@ -1,151 +1,151 @@
 import { deepStrictEqual } from "effect-test/util"
 import { pipe } from "effect/Function"
-import * as Number_ from "effect/Number"
+import * as Number from "effect/Number"
 import * as Option from "effect/Option"
 import { assert, describe, expect, it } from "vitest"
 
 describe("Number", () => {
   it("isNumber", () => {
-    expect(Number_.isNumber(1)).toEqual(true)
-    expect(Number_.isNumber("a")).toEqual(false)
-    expect(Number_.isNumber(true)).toEqual(false)
+    expect(Number.isNumber(1)).toEqual(true)
+    expect(Number.isNumber("a")).toEqual(false)
+    expect(Number.isNumber(true)).toEqual(false)
   })
 
   it("sum", () => {
-    deepStrictEqual(pipe(1, Number_.sum(2)), 3)
+    deepStrictEqual(pipe(1, Number.sum(2)), 3)
   })
 
   it("multiply", () => {
-    deepStrictEqual(pipe(2, Number_.multiply(3)), 6)
+    deepStrictEqual(pipe(2, Number.multiply(3)), 6)
   })
 
   it("subtract", () => {
-    deepStrictEqual(pipe(3, Number_.subtract(1)), 2)
+    deepStrictEqual(pipe(3, Number.subtract(1)), 2)
   })
 
   it("divide", () => {
-    deepStrictEqual(pipe(6, Number_.divide(2)), Option.some(3))
-    deepStrictEqual(pipe(6, Number_.divide(0)), Option.none())
+    deepStrictEqual(pipe(6, Number.divide(2)), Option.some(3))
+    deepStrictEqual(pipe(6, Number.divide(0)), Option.none())
   })
 
   it("unsafeDivide", () => {
-    deepStrictEqual(pipe(6, Number_.unsafeDivide(2)), 3)
+    deepStrictEqual(pipe(6, Number.unsafeDivide(2)), 3)
   })
 
   it("decrement", () => {
-    deepStrictEqual(Number_.decrement(2), 1)
+    deepStrictEqual(Number.decrement(2), 1)
   })
 
   it("Equivalence", () => {
-    expect(Number_.Equivalence(1, 1)).toBe(true)
-    expect(Number_.Equivalence(1, 2)).toBe(false)
+    expect(Number.Equivalence(1, 1)).toBe(true)
+    expect(Number.Equivalence(1, 2)).toBe(false)
   })
 
   it("Order", () => {
-    deepStrictEqual(Number_.Order(1, 2), -1)
-    deepStrictEqual(Number_.Order(2, 1), 1)
-    deepStrictEqual(Number_.Order(2, 2), 0)
+    deepStrictEqual(Number.Order(1, 2), -1)
+    deepStrictEqual(Number.Order(2, 1), 1)
+    deepStrictEqual(Number.Order(2, 2), 0)
   })
 
   it("sign", () => {
-    deepStrictEqual(Number_.sign(0), 0)
-    deepStrictEqual(Number_.sign(0.0), 0)
-    deepStrictEqual(Number_.sign(-0.1), -1)
-    deepStrictEqual(Number_.sign(-10), -1)
-    deepStrictEqual(Number_.sign(10), 1)
-    deepStrictEqual(Number_.sign(0.1), 1)
+    deepStrictEqual(Number.sign(0), 0)
+    deepStrictEqual(Number.sign(0.0), 0)
+    deepStrictEqual(Number.sign(-0.1), -1)
+    deepStrictEqual(Number.sign(-10), -1)
+    deepStrictEqual(Number.sign(10), 1)
+    deepStrictEqual(Number.sign(0.1), 1)
   })
 
   it("remainder", () => {
-    assert.deepStrictEqual(Number_.remainder(2, 2), 0)
-    assert.deepStrictEqual(Number_.remainder(3, 2), 1)
-    assert.deepStrictEqual(Number_.remainder(4, 2), 0)
-    assert.deepStrictEqual(Number_.remainder(2.5, 2), 0.5)
-    assert.deepStrictEqual(Number_.remainder(-2, 2), -0)
-    assert.deepStrictEqual(Number_.remainder(-3, 2), -1)
-    assert.deepStrictEqual(Number_.remainder(-4, 2), -0)
-    assert.deepStrictEqual(Number_.remainder(-2.8, -.2), -0)
-    assert.deepStrictEqual(Number_.remainder(-2, -.2), -0)
-    assert.deepStrictEqual(Number_.remainder(-1.5, -.2), -0.1)
-    assert.deepStrictEqual(Number_.remainder(0, -.2), 0)
-    assert.deepStrictEqual(Number_.remainder(1, -.2), 0)
-    assert.deepStrictEqual(Number_.remainder(2.6, -.2), 0)
-    assert.deepStrictEqual(Number_.remainder(3.1, -.2), 0.1)
+    assert.deepStrictEqual(Number.remainder(2, 2), 0)
+    assert.deepStrictEqual(Number.remainder(3, 2), 1)
+    assert.deepStrictEqual(Number.remainder(4, 2), 0)
+    assert.deepStrictEqual(Number.remainder(2.5, 2), 0.5)
+    assert.deepStrictEqual(Number.remainder(-2, 2), -0)
+    assert.deepStrictEqual(Number.remainder(-3, 2), -1)
+    assert.deepStrictEqual(Number.remainder(-4, 2), -0)
+    assert.deepStrictEqual(Number.remainder(-2.8, -.2), -0)
+    assert.deepStrictEqual(Number.remainder(-2, -.2), -0)
+    assert.deepStrictEqual(Number.remainder(-1.5, -.2), -0.1)
+    assert.deepStrictEqual(Number.remainder(0, -.2), 0)
+    assert.deepStrictEqual(Number.remainder(1, -.2), 0)
+    assert.deepStrictEqual(Number.remainder(2.6, -.2), 0)
+    assert.deepStrictEqual(Number.remainder(3.1, -.2), 0.1)
   })
 
   it("lessThan", () => {
-    assert.deepStrictEqual(Number_.lessThan(2, 3), true)
-    assert.deepStrictEqual(Number_.lessThan(3, 3), false)
-    assert.deepStrictEqual(Number_.lessThan(4, 3), false)
+    assert.deepStrictEqual(Number.lessThan(2, 3), true)
+    assert.deepStrictEqual(Number.lessThan(3, 3), false)
+    assert.deepStrictEqual(Number.lessThan(4, 3), false)
   })
 
   it("lessThanOrEqualTo", () => {
-    assert.deepStrictEqual(Number_.lessThanOrEqualTo(2, 3), true)
-    assert.deepStrictEqual(Number_.lessThanOrEqualTo(3, 3), true)
-    assert.deepStrictEqual(Number_.lessThanOrEqualTo(4, 3), false)
+    assert.deepStrictEqual(Number.lessThanOrEqualTo(2, 3), true)
+    assert.deepStrictEqual(Number.lessThanOrEqualTo(3, 3), true)
+    assert.deepStrictEqual(Number.lessThanOrEqualTo(4, 3), false)
   })
 
   it("greaterThan", () => {
-    assert.deepStrictEqual(Number_.greaterThan(2, 3), false)
-    assert.deepStrictEqual(Number_.greaterThan(3, 3), false)
-    assert.deepStrictEqual(Number_.greaterThan(4, 3), true)
+    assert.deepStrictEqual(Number.greaterThan(2, 3), false)
+    assert.deepStrictEqual(Number.greaterThan(3, 3), false)
+    assert.deepStrictEqual(Number.greaterThan(4, 3), true)
   })
 
   it("greaterThanOrEqualTo", () => {
-    assert.deepStrictEqual(Number_.greaterThanOrEqualTo(2, 3), false)
-    assert.deepStrictEqual(Number_.greaterThanOrEqualTo(3, 3), true)
-    assert.deepStrictEqual(Number_.greaterThanOrEqualTo(4, 3), true)
+    assert.deepStrictEqual(Number.greaterThanOrEqualTo(2, 3), false)
+    assert.deepStrictEqual(Number.greaterThanOrEqualTo(3, 3), true)
+    assert.deepStrictEqual(Number.greaterThanOrEqualTo(4, 3), true)
   })
 
   it("between", () => {
-    assert.deepStrictEqual(Number_.between({ minimum: 0, maximum: 5 })(3), true)
-    assert.deepStrictEqual(Number_.between({ minimum: 0, maximum: 5 })(-1), false)
-    assert.deepStrictEqual(Number_.between({ minimum: 0, maximum: 5 })(6), false)
+    assert.deepStrictEqual(Number.between({ minimum: 0, maximum: 5 })(3), true)
+    assert.deepStrictEqual(Number.between({ minimum: 0, maximum: 5 })(-1), false)
+    assert.deepStrictEqual(Number.between({ minimum: 0, maximum: 5 })(6), false)
 
-    assert.deepStrictEqual(Number_.between(3, { minimum: 0, maximum: 5 }), true)
+    assert.deepStrictEqual(Number.between(3, { minimum: 0, maximum: 5 }), true)
   })
 
   it("clamp", () => {
-    assert.deepStrictEqual(Number_.clamp({ minimum: 0, maximum: 5 })(3), 3)
-    assert.deepStrictEqual(Number_.clamp({ minimum: 0, maximum: 5 })(-1), 0)
-    assert.deepStrictEqual(Number_.clamp({ minimum: 0, maximum: 5 })(6), 5)
+    assert.deepStrictEqual(Number.clamp({ minimum: 0, maximum: 5 })(3), 3)
+    assert.deepStrictEqual(Number.clamp({ minimum: 0, maximum: 5 })(-1), 0)
+    assert.deepStrictEqual(Number.clamp({ minimum: 0, maximum: 5 })(6), 5)
   })
 
   it("min", () => {
-    assert.deepStrictEqual(Number_.min(2, 3), 2)
+    assert.deepStrictEqual(Number.min(2, 3), 2)
   })
 
   it("max", () => {
-    assert.deepStrictEqual(Number_.max(2, 3), 3)
+    assert.deepStrictEqual(Number.max(2, 3), 3)
   })
 
   it("sumAll", () => {
-    assert.deepStrictEqual(Number_.sumAll([2, 3, 4]), 9)
+    assert.deepStrictEqual(Number.sumAll([2, 3, 4]), 9)
   })
 
   it("multiplyAll", () => {
-    assert.deepStrictEqual(Number_.multiplyAll([2, 0, 4]), 0)
-    assert.deepStrictEqual(Number_.multiplyAll([2, 3, 4]), 24)
+    assert.deepStrictEqual(Number.multiplyAll([2, 0, 4]), 0)
+    assert.deepStrictEqual(Number.multiplyAll([2, 3, 4]), 24)
   })
 
   it("parse", () => {
-    assert.deepStrictEqual(Number_.parse("NaN"), Option.some(NaN))
-    assert.deepStrictEqual(Number_.parse("Infinity"), Option.some(Infinity))
-    assert.deepStrictEqual(Number_.parse("-Infinity"), Option.some(-Infinity))
-    assert.deepStrictEqual(Number_.parse("42"), Option.some(42))
-    assert.deepStrictEqual(Number_.parse("a"), Option.none())
+    assert.deepStrictEqual(Number.parse("NaN"), Option.some(NaN))
+    assert.deepStrictEqual(Number.parse("Infinity"), Option.some(Infinity))
+    assert.deepStrictEqual(Number.parse("-Infinity"), Option.some(-Infinity))
+    assert.deepStrictEqual(Number.parse("42"), Option.some(42))
+    assert.deepStrictEqual(Number.parse("a"), Option.none())
   })
 
   it("fromString", () => {
-    assert.deepStrictEqual(Number_.fromString("NaN"), Option.none())
-    assert.deepStrictEqual(Number_.fromString("Infinity"), Option.some(Infinity))
-    assert.deepStrictEqual(Number_.fromString("-Infinity"), Option.some(-Infinity))
-    assert.deepStrictEqual(Number_.fromString("42"), Option.some(42))
-    assert.deepStrictEqual(Number_.fromString(" 42 \n\r\t"), Option.some(42))
-    assert.deepStrictEqual(Number_.fromString("3.14"), Option.some(3.14))
-    assert.deepStrictEqual(Number_.fromString("1e3"), Option.some(1000))
-    assert.deepStrictEqual(Number_.fromString("1e-3"), Option.some(0.001))
-    assert.deepStrictEqual(Number_.fromString(""), Option.none())
-    assert.deepStrictEqual(Number_.fromString("a"), Option.none())
+    assert.deepStrictEqual(Number.fromString("NaN"), Option.none())
+    assert.deepStrictEqual(Number.fromString("Infinity"), Option.some(Infinity))
+    assert.deepStrictEqual(Number.fromString("-Infinity"), Option.some(-Infinity))
+    assert.deepStrictEqual(Number.fromString("42"), Option.some(42))
+    assert.deepStrictEqual(Number.fromString(" 42 \n\r\t"), Option.some(42))
+    assert.deepStrictEqual(Number.fromString("3.14"), Option.some(3.14))
+    assert.deepStrictEqual(Number.fromString("1e3"), Option.some(1000))
+    assert.deepStrictEqual(Number.fromString("1e-3"), Option.some(0.001))
+    assert.deepStrictEqual(Number.fromString(""), Option.none())
+    assert.deepStrictEqual(Number.fromString("a"), Option.none())
   })
 })

From b0c30a135ab52d601b0a42cac7e8d766d7b4f22a Mon Sep 17 00:00:00 2001
From: lkb <tmwlak@gmail.com>
Date: Mon, 25 Mar 2024 09:39:23 +0900
Subject: [PATCH 08/11] fix typo

---
 packages/effect/src/BigInt.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/effect/src/BigInt.ts b/packages/effect/src/BigInt.ts
index 036e5cd484..4269252fea 100644
--- a/packages/effect/src/BigInt.ts
+++ b/packages/effect/src/BigInt.ts
@@ -550,7 +550,7 @@ export const multiplyAll = (collection: Iterable<bigint>): bigint => {
  * Takes a `bigint` and returns an `Option` of `number`.
  *
  * If the `bigint` is outside the safe integer range for JavaScript (`Number.MAX_SAFE_INTEGER`
- * and `Number.MIN_SAFE_INTEGER`), it returns `Option.none`. Otherwise, it converts the `bigint`
+ * and `Number.MIN_SAFE_INTEGER`), it returns `Option.none()`. Otherwise, it converts the `bigint`
  * to a number and returns `Option.some(number)`.
  *
  * @param b - The `bigint` to be converted to a `number`.

From 9bf1659201d18a904d33a41270f3bed086ad6b01 Mon Sep 17 00:00:00 2001
From: lkb <tmwlak@gmail.com>
Date: Mon, 25 Mar 2024 09:40:51 +0900
Subject: [PATCH 09/11] fix typo

---
 packages/effect/src/Number.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/effect/src/Number.ts b/packages/effect/src/Number.ts
index ed32fb0b84..467e76970e 100644
--- a/packages/effect/src/Number.ts
+++ b/packages/effect/src/Number.ts
@@ -498,7 +498,7 @@ export const parse = (s: string): Option<number> => {
  * Takes a string and returns an `Option` of `number`.
  *
  * If the string is empty or invalid characters,
- * it returns `Option.none`. Otherwise, it attempts to convert the string to a number
+ * it returns `Option.none()`. Otherwise, it attempts to convert the string to a number
  * and returns `Option.some(number)`.
  *
  * @param s - The string to be converted to a `number`.

From 3383f2fec6f9655152dadfd459a040deb37a3d26 Mon Sep 17 00:00:00 2001
From: lkb <tmwlak@gmail.com>
Date: Mon, 25 Mar 2024 10:00:14 +0900
Subject: [PATCH 10/11] remove Number.fromString

---
 packages/effect/src/Number.ts       | 29 -----------------------------
 packages/effect/test/Number.test.ts | 13 -------------
 2 files changed, 42 deletions(-)

diff --git a/packages/effect/src/Number.ts b/packages/effect/src/Number.ts
index 467e76970e..eec227b6ea 100644
--- a/packages/effect/src/Number.ts
+++ b/packages/effect/src/Number.ts
@@ -493,32 +493,3 @@ export const parse = (s: string): Option<number> => {
     ? option.none
     : option.some(n)
 }
-
-/**
- * Takes a string and returns an `Option` of `number`.
- *
- * If the string is empty or invalid characters,
- * it returns `Option.none()`. Otherwise, it attempts to convert the string to a number
- * and returns `Option.some(number)`.
- *
- * @param s - The string to be converted to a `number`.
- *
- * @example
- * import { fromString } from "effect/Number"
- * import { Option } from "effect"
- *
- * assert.deepStrictEqual(fromString("42"), Option.some(42))
- * assert.deepStrictEqual(fromString(""), Option.none())
- * assert.deepStrictEqual(fromString("not a number"), Option.none())
- *
- * @category conversions
- * @since 2.4.12
- */
-export const fromString = (s: string): Option<number> => {
-  const n = Number(s)
-  return s.trim() === ""
-    ? option.none
-    : Number.isNaN(n)
-    ? option.none
-    : option.some(n)
-}
diff --git a/packages/effect/test/Number.test.ts b/packages/effect/test/Number.test.ts
index 5d4882b490..db347364ff 100644
--- a/packages/effect/test/Number.test.ts
+++ b/packages/effect/test/Number.test.ts
@@ -135,17 +135,4 @@ describe("Number", () => {
     assert.deepStrictEqual(Number.parse("42"), Option.some(42))
     assert.deepStrictEqual(Number.parse("a"), Option.none())
   })
-
-  it("fromString", () => {
-    assert.deepStrictEqual(Number.fromString("NaN"), Option.none())
-    assert.deepStrictEqual(Number.fromString("Infinity"), Option.some(Infinity))
-    assert.deepStrictEqual(Number.fromString("-Infinity"), Option.some(-Infinity))
-    assert.deepStrictEqual(Number.fromString("42"), Option.some(42))
-    assert.deepStrictEqual(Number.fromString(" 42 \n\r\t"), Option.some(42))
-    assert.deepStrictEqual(Number.fromString("3.14"), Option.some(3.14))
-    assert.deepStrictEqual(Number.fromString("1e3"), Option.some(1000))
-    assert.deepStrictEqual(Number.fromString("1e-3"), Option.some(0.001))
-    assert.deepStrictEqual(Number.fromString(""), Option.none())
-    assert.deepStrictEqual(Number.fromString("a"), Option.none())
-  })
 })

From e9460108f9cf6ce5a9b6d107401a6184bb46d095 Mon Sep 17 00:00:00 2001
From: lkb <tmwlak@gmail.com>
Date: Mon, 25 Mar 2024 10:27:09 +0900
Subject: [PATCH 11/11] fix. example of BigInt.toNumber

---
 packages/effect/src/BigInt.ts | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/packages/effect/src/BigInt.ts b/packages/effect/src/BigInt.ts
index 4269252fea..ee7deccf31 100644
--- a/packages/effect/src/BigInt.ts
+++ b/packages/effect/src/BigInt.ts
@@ -556,12 +556,12 @@ export const multiplyAll = (collection: Iterable<bigint>): bigint => {
  * @param b - The `bigint` to be converted to a `number`.
  *
  * @example
- * import { fromBigInt } from "effect/Number"
+ * import { toNumber } from "effect/BigInt"
  * import { Option } from "effect"
  *
- * assert.deepStrictEqual(fromBigInt(BigInt(42)), Option.some(42))
- * assert.deepStrictEqual(fromBigInt(BigInt(Number.MAX_SAFE_INTEGER) + BigInt(1)), Option.none())
- * assert.deepStrictEqual(fromBigInt(BigInt(Number.MIN_SAFE_INTEGER) - BigInt(1)), Option.none())
+ * assert.deepStrictEqual(toNumber(BigInt(42)), Option.some(42))
+ * assert.deepStrictEqual(toNumber(BigInt(Number.MAX_SAFE_INTEGER) + BigInt(1)), Option.none())
+ * assert.deepStrictEqual(toNumber(BigInt(Number.MIN_SAFE_INTEGER) - BigInt(1)), Option.none())
  *
  * @category conversions
  * @since 2.0.0