effect 4.0.0-beta.4 → 4.0.0-beta.40

package/src/BigDecimal.ts

@@ -19,6 +19,7 @@ import * as Equ from "./Equivalence.ts"
 import { dual } from "./Function.ts"
 import * as Hash from "./Hash.ts"
 import { type Inspectable, NodeInspectSymbol } from "./Inspectable.ts"
+import * as Option from "./Option.ts"
 import * as order from "./Order.ts"
 import type { Ordering } from "./Ordering.ts"
 import { type Pipeable, pipeArguments } from "./Pipeable.ts"
@@ -565,11 +566,11 @@ export const roundTerminal = (n: bigint): bigint => {
  * If the dividend is not a multiple of the divisor the result will be a `BigDecimal` value
  * which represents the integer division rounded down to the nearest integer.
  *
- * If the divisor is `0`, the result will be `undefined`.
+ * If the divisor is `0`, the result will be `Option.none()`.
  *
  * @example
  * ```ts
- * import { BigDecimal } from "effect"
+ * import { BigDecimal, Option } from "effect"
  * import * as assert from "node:assert"
  *
  * assert.deepStrictEqual(
@@ -577,21 +578,21 @@ export const roundTerminal = (n: bigint): bigint => {
  *     BigDecimal.fromStringUnsafe("6"),
  *     BigDecimal.fromStringUnsafe("3")
  *   ),
- *   BigDecimal.fromStringUnsafe("2")
+ *   Option.some(BigDecimal.fromStringUnsafe("2"))
  * )
  * assert.deepStrictEqual(
  *   BigDecimal.divide(
  *     BigDecimal.fromStringUnsafe("6"),
  *     BigDecimal.fromStringUnsafe("4")
  *   ),
- *   BigDecimal.fromStringUnsafe("1.5")
+ *   Option.some(BigDecimal.fromStringUnsafe("1.5"))
  * )
  * assert.deepStrictEqual(
  *   BigDecimal.divide(
  *     BigDecimal.fromStringUnsafe("6"),
  *     BigDecimal.fromStringUnsafe("0")
  *   ),
- *   undefined
+ *   Option.none()
  * )
  * ```
  *
@@ -605,11 +606,11 @@ export const divide: {
    * If the dividend is not a multiple of the divisor the result will be a `BigDecimal` value
    * which represents the integer division rounded down to the nearest integer.
    *
-   * If the divisor is `0`, the result will be `undefined`.
+   * If the divisor is `0`, the result will be `Option.none()`.
    *
    * @example
    * ```ts
-   * import { BigDecimal } from "effect"
+   * import { BigDecimal, Option } from "effect"
    * import * as assert from "node:assert"
    *
    * assert.deepStrictEqual(
@@ -617,39 +618,39 @@ export const divide: {
    *     BigDecimal.fromStringUnsafe("6"),
    *     BigDecimal.fromStringUnsafe("3")
    *   ),
-   *   BigDecimal.fromStringUnsafe("2")
+   *   Option.some(BigDecimal.fromStringUnsafe("2"))
    * )
    * assert.deepStrictEqual(
    *   BigDecimal.divide(
    *     BigDecimal.fromStringUnsafe("6"),
    *     BigDecimal.fromStringUnsafe("4")
    *   ),
-   *   BigDecimal.fromStringUnsafe("1.5")
+   *   Option.some(BigDecimal.fromStringUnsafe("1.5"))
    * )
    * assert.deepStrictEqual(
    *   BigDecimal.divide(
    *     BigDecimal.fromStringUnsafe("6"),
    *     BigDecimal.fromStringUnsafe("0")
    *   ),
-   *   undefined
+   *   Option.none()
    * )
    * ```
    *
    * @since 2.0.0
    * @category math
    */
-  (that: BigDecimal): (self: BigDecimal) => BigDecimal | undefined
+  (that: BigDecimal): (self: BigDecimal) => Option.Option<BigDecimal>
   /**
    * Provides a division operation on `BigDecimal`s.
    *
    * If the dividend is not a multiple of the divisor the result will be a `BigDecimal` value
    * which represents the integer division rounded down to the nearest integer.
    *
-   * If the divisor is `0`, the result will be `undefined`.
+   * If the divisor is `0`, the result will be `Option.none()`.
    *
    * @example
    * ```ts
-   * import { BigDecimal } from "effect"
+   * import { BigDecimal, Option } from "effect"
    * import * as assert from "node:assert"
    *
    * assert.deepStrictEqual(
@@ -657,43 +658,43 @@ export const divide: {
    *     BigDecimal.fromStringUnsafe("6"),
    *     BigDecimal.fromStringUnsafe("3")
    *   ),
-   *   BigDecimal.fromStringUnsafe("2")
+   *   Option.some(BigDecimal.fromStringUnsafe("2"))
    * )
    * assert.deepStrictEqual(
    *   BigDecimal.divide(
    *     BigDecimal.fromStringUnsafe("6"),
    *     BigDecimal.fromStringUnsafe("4")
    *   ),
-   *   BigDecimal.fromStringUnsafe("1.5")
+   *   Option.some(BigDecimal.fromStringUnsafe("1.5"))
    * )
    * assert.deepStrictEqual(
    *   BigDecimal.divide(
    *     BigDecimal.fromStringUnsafe("6"),
    *     BigDecimal.fromStringUnsafe("0")
    *   ),
-   *   undefined
+   *   Option.none()
    * )
    * ```
    *
    * @since 2.0.0
    * @category math
    */
-  (self: BigDecimal, that: BigDecimal): BigDecimal | undefined
-} = dual(2, (self: BigDecimal, that: BigDecimal): BigDecimal | undefined => {
+  (self: BigDecimal, that: BigDecimal): Option.Option<BigDecimal>
+} = dual(2, (self: BigDecimal, that: BigDecimal): Option.Option<BigDecimal> => {
   if (that.value === bigint0) {
-    return undefined
+    return Option.none()
   }
 
   if (self.value === bigint0) {
-    return zero
+    return Option.some(zero)
   }
 
   const scale = self.scale - that.scale
   if (self.value === that.value) {
-    return make(bigint1, scale)
+    return Option.some(make(bigint1, scale))
   }
 
-  return divideWithPrecision(self.value, that.value, scale, DEFAULT_PRECISION)
+  return Option.some(divideWithPrecision(self.value, that.value, scale, DEFAULT_PRECISION))
 })
 
 /**
@@ -1514,11 +1515,11 @@ export const negate = (n: BigDecimal): BigDecimal => make(-n.value, n.scale)
 /**
  * Returns the remainder left over when one operand is divided by a second operand.
  *
- * If the divisor is `0`, the result will be `undefined`.
+ * If the divisor is `0`, the result will be `Option.none()`.
  *
  * @example
  * ```ts
- * import { BigDecimal } from "effect"
+ * import { BigDecimal, Option } from "effect"
  * import * as assert from "node:assert"
  *
  * assert.deepStrictEqual(
@@ -1526,21 +1527,21 @@ export const negate = (n: BigDecimal): BigDecimal => make(-n.value, n.scale)
  *     BigDecimal.fromStringUnsafe("2"),
  *     BigDecimal.fromStringUnsafe("2")
  *   ),
- *   BigDecimal.fromStringUnsafe("0")
+ *   Option.some(BigDecimal.fromStringUnsafe("0"))
  * )
  * assert.deepStrictEqual(
  *   BigDecimal.remainder(
  *     BigDecimal.fromStringUnsafe("3"),
  *     BigDecimal.fromStringUnsafe("2")
  *   ),
- *   BigDecimal.fromStringUnsafe("1")
+ *   Option.some(BigDecimal.fromStringUnsafe("1"))
  * )
  * assert.deepStrictEqual(
  *   BigDecimal.remainder(
  *     BigDecimal.fromStringUnsafe("-4"),
  *     BigDecimal.fromStringUnsafe("2")
  *   ),
- *   BigDecimal.fromStringUnsafe("0")
+ *   Option.some(BigDecimal.fromStringUnsafe("0"))
  * )
  * ```
  *
@@ -1551,11 +1552,11 @@ export const remainder: {
   /**
    * Returns the remainder left over when one operand is divided by a second operand.
    *
-   * If the divisor is `0`, the result will be `undefined`.
+   * If the divisor is `0`, the result will be `Option.none()`.
    *
    * @example
    * ```ts
-   * import { BigDecimal } from "effect"
+   * import { BigDecimal, Option } from "effect"
    * import * as assert from "node:assert"
    *
    * assert.deepStrictEqual(
@@ -1563,36 +1564,36 @@ export const remainder: {
    *     BigDecimal.fromStringUnsafe("2"),
    *     BigDecimal.fromStringUnsafe("2")
    *   ),
-   *   BigDecimal.fromStringUnsafe("0")
+   *   Option.some(BigDecimal.fromStringUnsafe("0"))
    * )
    * assert.deepStrictEqual(
    *   BigDecimal.remainder(
    *     BigDecimal.fromStringUnsafe("3"),
    *     BigDecimal.fromStringUnsafe("2")
    *   ),
-   *   BigDecimal.fromStringUnsafe("1")
+   *   Option.some(BigDecimal.fromStringUnsafe("1"))
    * )
    * assert.deepStrictEqual(
    *   BigDecimal.remainder(
    *     BigDecimal.fromStringUnsafe("-4"),
    *     BigDecimal.fromStringUnsafe("2")
    *   ),
-   *   BigDecimal.fromStringUnsafe("0")
+   *   Option.some(BigDecimal.fromStringUnsafe("0"))
    * )
    * ```
    *
    * @since 2.0.0
    * @category math
    */
-  (divisor: BigDecimal): (self: BigDecimal) => BigDecimal | undefined
+  (divisor: BigDecimal): (self: BigDecimal) => Option.Option<BigDecimal>
   /**
    * Returns the remainder left over when one operand is divided by a second operand.
    *
-   * If the divisor is `0`, the result will be `undefined`.
+   * If the divisor is `0`, the result will be `Option.none()`.
    *
    * @example
    * ```ts
-   * import { BigDecimal } from "effect"
+   * import { BigDecimal, Option } from "effect"
    * import * as assert from "node:assert"
    *
    * assert.deepStrictEqual(
@@ -1600,35 +1601,35 @@ export const remainder: {
    *     BigDecimal.fromStringUnsafe("2"),
    *     BigDecimal.fromStringUnsafe("2")
    *   ),
-   *   BigDecimal.fromStringUnsafe("0")
+   *   Option.some(BigDecimal.fromStringUnsafe("0"))
    * )
    * assert.deepStrictEqual(
    *   BigDecimal.remainder(
    *     BigDecimal.fromStringUnsafe("3"),
    *     BigDecimal.fromStringUnsafe("2")
    *   ),
-   *   BigDecimal.fromStringUnsafe("1")
+   *   Option.some(BigDecimal.fromStringUnsafe("1"))
    * )
    * assert.deepStrictEqual(
    *   BigDecimal.remainder(
    *     BigDecimal.fromStringUnsafe("-4"),
    *     BigDecimal.fromStringUnsafe("2")
    *   ),
-   *   BigDecimal.fromStringUnsafe("0")
+   *   Option.some(BigDecimal.fromStringUnsafe("0"))
    * )
    * ```
    *
    * @since 2.0.0
    * @category math
    */
-  (self: BigDecimal, divisor: BigDecimal): BigDecimal | undefined
-} = dual(2, (self: BigDecimal, divisor: BigDecimal): BigDecimal | undefined => {
+  (self: BigDecimal, divisor: BigDecimal): Option.Option<BigDecimal>
+} = dual(2, (self: BigDecimal, divisor: BigDecimal): Option.Option<BigDecimal> => {
   if (divisor.value === bigint0) {
-    return undefined
+    return Option.none()
   }
 
   const max = Math.max(self.scale, divisor.scale)
-  return make(scale(self, max).value % scale(divisor, max).value, max)
+  return Option.some(make(scale(self, max).value % scale(divisor, max).value, max))
 })
 
 /**
@@ -1853,9 +1854,7 @@ export const fromBigInt = (n: bigint): BigDecimal => make(n, 0)
  * @category constructors
  */
 export const fromNumberUnsafe = (n: number): BigDecimal => {
-  const out = fromNumber(n)
-  if (out) return out
-  throw new RangeError(`Number must be finite, got ${n}`)
+  return Option.getOrThrowWith(fromNumber(n), () => new RangeError(`Number must be finite, got ${n}`))
 }
 
 /**
@@ -1864,27 +1863,27 @@ export const fromNumberUnsafe = (n: number): BigDecimal => {
  * It is not recommended to convert a floating point number to a decimal directly,
  * as the floating point representation may be unexpected.
  *
- * Returns `undefined` for `NaN`, `+Infinity` or `-Infinity`.
+ * Returns `Option.none()` for `NaN`, `+Infinity` or `-Infinity`.
  *
  * @example
  * ```ts
- * import { BigDecimal } from "effect"
+ * import { BigDecimal, Option } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(BigDecimal.fromNumber(123), BigDecimal.make(123n, 0))
+ * assert.deepStrictEqual(BigDecimal.fromNumber(123), Option.some(BigDecimal.make(123n, 0)))
  * assert.deepStrictEqual(
  *   BigDecimal.fromNumber(123.456),
- *   BigDecimal.make(123456n, 3)
+ *   Option.some(BigDecimal.make(123456n, 3))
  * )
- * assert.deepStrictEqual(BigDecimal.fromNumber(Infinity), undefined)
+ * assert.deepStrictEqual(BigDecimal.fromNumber(Infinity), Option.none())
  * ```
  *
  * @since 4.0.0
  * @category constructors
  */
-export const fromNumber = (n: number): BigDecimal | undefined => {
+export const fromNumber = (n: number): Option.Option<BigDecimal> => {
   if (!Number.isFinite(n)) {
-    return undefined
+    return Option.none()
   }
 
   const string = `${n}`
@@ -1893,7 +1892,7 @@ export const fromNumber = (n: number): BigDecimal | undefined => {
   }
 
   const [lead, trail = ""] = string.split(".")
-  return make(BigInt(`${lead}${trail}`), trail.length)
+  return Option.some(make(BigInt(`${lead}${trail}`), trail.length))
 }
 
 /**
@@ -1901,23 +1900,23 @@ export const fromNumber = (n: number): BigDecimal | undefined => {
  *
  * @example
  * ```ts
- * import { BigDecimal } from "effect"
+ * import { BigDecimal, Option } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(BigDecimal.fromString("123"), BigDecimal.make(123n, 0))
+ * assert.deepStrictEqual(BigDecimal.fromString("123"), Option.some(BigDecimal.make(123n, 0)))
  * assert.deepStrictEqual(
  *   BigDecimal.fromString("123.456"),
- *   BigDecimal.make(123456n, 3)
+ *   Option.some(BigDecimal.make(123456n, 3))
  * )
- * assert.deepStrictEqual(BigDecimal.fromString("123.abc"), undefined)
+ * assert.deepStrictEqual(BigDecimal.fromString("123.abc"), Option.none())
  * ```
  *
  * @since 2.0.0
  * @category constructors
  */
-export const fromString = (s: string): BigDecimal | undefined => {
+export const fromString = (s: string): Option.Option<BigDecimal> => {
   if (s === "") {
-    return zero
+    return Option.some(zero)
   }
 
   let base: string
@@ -1928,7 +1927,7 @@ export const fromString = (s: string): BigDecimal | undefined => {
     base = s.slice(0, seperator)
     exp = Number(trail)
     if (base === "" || !Number.isSafeInteger(exp) || !FINITE_INT_REGEXP.test(trail)) {
-      return undefined
+      return Option.none()
     }
   } else {
     base = s
@@ -1949,15 +1948,15 @@ export const fromString = (s: string): BigDecimal | undefined => {
   }
 
   if (!FINITE_INT_REGEXP.test(digits)) {
-    return undefined
+    return Option.none()
   }
 
   const scale = offset - exp
   if (!Number.isSafeInteger(scale)) {
-    return undefined
+    return Option.none()
   }
 
-  return make(BigInt(digits), scale)
+  return Option.some(make(BigInt(digits), scale))
 }
 
 /**
@@ -1977,9 +1976,7 @@ export const fromString = (s: string): BigDecimal | undefined => {
  * @category constructors
  */
 export const fromStringUnsafe = (s: string): BigDecimal => {
-  const out = fromString(s)
-  if (out) return out
-  throw new Error(`Invalid numerical string: ${s}`)
+  return Option.getOrThrowWith(fromString(s), () => new Error(`Invalid numerical string: ${s}`))
 }
 
 /**

package/src/BigInt.ts

@@ -8,6 +8,7 @@
 import * as Combiner from "./Combiner.ts"
 import * as Equ from "./Equivalence.ts"
 import { dual } from "./Function.ts"
+import * as Option from "./Option.ts"
 import * as order from "./Order.ts"
 import type { Ordering } from "./Ordering.ts"
 import * as predicate from "./Predicate.ts"
@@ -200,15 +201,17 @@ export const subtract: {
  * If the dividend is not a multiple of the divisor the result will be a `bigint` value
  * which represents the integer division rounded down to the nearest integer.
  *
- * Returns `undefined` if the divisor is `0n`.
+ * Returns `Option.none()` if the divisor is `0n`.
  *
  * @example
  * ```ts
  * import { divide } from "effect/BigInt"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(divide(6n, 3n), 2n)
- * assert.deepStrictEqual(divide(6n, 0n), undefined)
+ * import { Option } from "effect"
+ *
+ * assert.deepStrictEqual(divide(6n, 3n), Option.some(2n))
+ * assert.deepStrictEqual(divide(6n, 0n), Option.none())
  * ```
  *
  * @category math
@@ -221,45 +224,49 @@ export const divide: {
    * If the dividend is not a multiple of the divisor the result will be a `bigint` value
    * which represents the integer division rounded down to the nearest integer.
    *
-   * Returns `undefined` if the divisor is `0n`.
+   * Returns `Option.none()` if the divisor is `0n`.
    *
    * @example
    * ```ts
    * import { divide } from "effect/BigInt"
    * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(divide(6n, 3n), 2n)
-   * assert.deepStrictEqual(divide(6n, 0n), undefined)
+   * import { Option } from "effect"
+   *
+   * assert.deepStrictEqual(divide(6n, 3n), Option.some(2n))
+   * assert.deepStrictEqual(divide(6n, 0n), Option.none())
    * ```
    *
    * @category math
    * @since 2.0.0
    */
-  (that: bigint): (self: bigint) => bigint | undefined
+  (that: bigint): (self: bigint) => Option.Option<bigint>
   /**
    * Provides a division operation on `bigint`s.
    *
    * If the dividend is not a multiple of the divisor the result will be a `bigint` value
    * which represents the integer division rounded down to the nearest integer.
    *
-   * Returns `undefined` if the divisor is `0n`.
+   * Returns `Option.none()` if the divisor is `0n`.
    *
    * @example
    * ```ts
    * import { divide } from "effect/BigInt"
    * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(divide(6n, 3n), 2n)
-   * assert.deepStrictEqual(divide(6n, 0n), undefined)
+   * import { Option } from "effect"
+   *
+   * assert.deepStrictEqual(divide(6n, 3n), Option.some(2n))
+   * assert.deepStrictEqual(divide(6n, 0n), Option.none())
    * ```
    *
    * @category math
    * @since 2.0.0
    */
-  (self: bigint, that: bigint): bigint | undefined
+  (self: bigint, that: bigint): Option.Option<bigint>
 } = dual(
   2,
-  (self: bigint, that: bigint): bigint | undefined => that === bigint0 ? undefined : self / that
+  (self: bigint, that: bigint): Option.Option<bigint> => that === bigint0 ? Option.none() : Option.some(self / that)
 )
 
 /**
@@ -1034,7 +1041,7 @@ export const sqrtUnsafe = (n: bigint): bigint => {
 }
 
 /**
- * Determines the square root of a given `bigint` safely. Returns `undefined` if
+ * Determines the square root of a given `bigint` safely. Returns `Option.none()` if
  * the given `bigint` is negative.
  *
  * **Example**
@@ -1042,16 +1049,17 @@ export const sqrtUnsafe = (n: bigint): bigint => {
  * ```ts
  * import { BigInt } from "effect"
  *
- * BigInt.sqrt(4n) // 2n
- * BigInt.sqrt(9n) // 3n
- * BigInt.sqrt(16n) // 4n
- * BigInt.sqrt(-1n) // undefined
+ * BigInt.sqrt(4n) // Option.some(2n)
+ * BigInt.sqrt(9n) // Option.some(3n)
+ * BigInt.sqrt(16n) // Option.some(4n)
+ * BigInt.sqrt(-1n) // Option.none()
  * ```
  *
  * @category math
  * @since 2.0.0
  */
-export const sqrt = (n: bigint): bigint | undefined => isGreaterThanOrEqualTo(n, bigint0) ? sqrtUnsafe(n) : undefined
+export const sqrt = (n: bigint): Option.Option<bigint> =>
+  isGreaterThanOrEqualTo(n, bigint0) ? Option.some(sqrtUnsafe(n)) : Option.none()
 
 /**
  * Takes an `Iterable` of `bigint`s and returns their sum as a single `bigint
@@ -1104,52 +1112,52 @@ export const multiplyAll = (collection: Iterable<bigint>): bigint => {
  * Converts a `bigint` to a `number`.
  *
  * If the `bigint` is outside the safe integer range for JavaScript (`Number.MAX_SAFE_INTEGER`
- * and `Number.MIN_SAFE_INTEGER`), it returns `undefined`
+ * and `Number.MIN_SAFE_INTEGER`), it returns `Option.none()`.
  *
  * @example
  * ```ts
  * import { BigInt as BI } from "effect"
  *
- * BI.toNumber(42n) // 42
- * BI.toNumber(BigInt(Number.MAX_SAFE_INTEGER) + 1n) // undefined
- * BI.toNumber(BigInt(Number.MIN_SAFE_INTEGER) - 1n) // undefined
+ * BI.toNumber(42n) // Option.some(42)
+ * BI.toNumber(BigInt(Number.MAX_SAFE_INTEGER) + 1n) // Option.none()
+ * BI.toNumber(BigInt(Number.MIN_SAFE_INTEGER) - 1n) // Option.none()
  * ```
  *
  * @category conversions
  * @since 2.0.0
  */
-export const toNumber = (b: bigint): number | undefined => {
+export const toNumber = (b: bigint): Option.Option<number> => {
   if (b > BigInt(Number.MAX_SAFE_INTEGER) || b < BigInt(Number.MIN_SAFE_INTEGER)) {
-    return undefined
+    return Option.none()
   }
-  return Number(b)
+  return Option.some(Number(b))
 }
 
 /**
  * Converts a string to a `bigint`.
  *
  * If the string is empty or contains characters that cannot be converted into a
- * `bigint`, it returns `undefined`.
+ * `bigint`, it returns `Option.none()`.
  *
  * @example
  * ```ts
  * import { BigInt } from "effect"
  *
- * BigInt.fromString("42") // 42n
- * BigInt.fromString(" ") // undefined
- * BigInt.fromString("a") // undefined
+ * BigInt.fromString("42") // Option.some(42n)
+ * BigInt.fromString(" ") // Option.none()
+ * BigInt.fromString("a") // Option.none()
  * ```
  *
  * @category conversions
  * @since 2.4.12
  */
-export const fromString = (s: string): bigint | undefined => {
+export const fromString = (s: string): Option.Option<bigint> => {
   try {
     return s.trim() === ""
-      ? undefined
-      : BigInt(s)
+      ? Option.none()
+      : Option.some(BigInt(s))
   } catch {
-    return undefined
+    return Option.none()
   }
 }
 
@@ -1158,30 +1166,30 @@ export const fromString = (s: string): bigint | undefined => {
  *
  * If the number is outside the safe integer range for JavaScript
  * (`Number.MAX_SAFE_INTEGER` and `Number.MIN_SAFE_INTEGER`) or if the number is
- * not a valid `bigint`, it returns `undefined`.
+ * not a valid `bigint`, it returns `Option.none()`.
  *
  * @example
  * ```ts
  * import { BigInt } from "effect"
  *
- * BigInt.fromNumber(42) // 42n
+ * BigInt.fromNumber(42) // Option.some(42n)
  *
- * BigInt.fromNumber(Number.MAX_SAFE_INTEGER + 1) // undefined
- * BigInt.fromNumber(Number.MIN_SAFE_INTEGER - 1) // undefined
+ * BigInt.fromNumber(Number.MAX_SAFE_INTEGER + 1) // Option.none()
+ * BigInt.fromNumber(Number.MIN_SAFE_INTEGER - 1) // Option.none()
  * ```
  *
  * @category conversions
  * @since 2.4.12
  */
-export function fromNumber(n: number): bigint | undefined {
+export function fromNumber(n: number): Option.Option<bigint> {
   if (n > Number.MAX_SAFE_INTEGER || n < Number.MIN_SAFE_INTEGER) {
-    return undefined
+    return Option.none()
   }
 
   try {
-    return BigInt(n)
+    return Option.some(BigInt(n))
   } catch {
-    return undefined
+    return Option.none()
   }
 }
 

package/src/Brand.ts

@@ -12,7 +12,7 @@ import * as AST from "./SchemaAST.ts"
 import type * as Issue from "./SchemaIssue.ts"
 import type * as Types from "./Types.ts"
 
-const TypeId = "~effect/data/Brand"
+const TypeId = "~effect/Brand"
 
 /**
  * A generic interface that defines a branded type.