effect 2.4.11 → 2.4.13

package/src/BigInt.ts

@@ -547,10 +547,24 @@ 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 { toNumber } from "effect/BigInt"
+ * import { Option } from "effect"
+ *
+ * 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())
  *
- * @since 2.0.0
  * @category conversions
+ * @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)) {
@@ -558,3 +572,64 @@ 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`.
+ *
+ * @example
+ * import { fromString } from "effect/BigInt"
+ * import { Option } from "effect"
+ *
+ * assert.deepStrictEqual(fromString("42"), Option.some(BigInt(42)))
+ * 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`.
+ *
+ * @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())
+ * 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()
+  }
+}

package/src/Duration.ts

@@ -15,7 +15,11 @@ import { hasProperty, isBigInt, isNumber } from "./Predicate.js"
 
 const TypeId: unique symbol = Symbol.for("effect/Duration")
 
+const bigint0 = BigInt(0)
+const bigint24 = BigInt(24)
+const bigint60 = BigInt(60)
 const bigint1e3 = BigInt(1_000)
+const bigint1e6 = BigInt(1_000_000)
 const bigint1e9 = BigInt(1_000_000_000)
 
 /**
@@ -162,7 +166,7 @@ const DurationProto: Omit<Duration, "value"> = {
 const make = (input: number | bigint): Duration => {
   const duration = Object.create(DurationProto)
   if (isNumber(input)) {
-    if (isNaN(input) || input < 0) {
+    if (isNaN(input) || input <= 0) {
       duration.value = zeroValue
     } else if (!Number.isFinite(input)) {
       duration.value = infinityValue
@@ -171,7 +175,7 @@ const make = (input: number | bigint): Duration => {
     } else {
       duration.value = { _tag: "Millis", millis: input }
     }
-  } else if (input < BigInt(0)) {
+  } else if (input <= bigint0) {
     duration.value = zeroValue
   } else {
     duration.value = { _tag: "Nanos", nanos: input }
@@ -522,6 +526,22 @@ export const times: {
     })
 )
 
+/**
+ * @since 2.0.0
+ * @category math
+ */
+export const subtract: {
+  (that: DurationInput): (self: DurationInput) => Duration
+  (self: DurationInput, that: DurationInput): Duration
+} = dual(
+  2,
+  (self: DurationInput, that: DurationInput): Duration =>
+    matchWith(self, that, {
+      onMillis: (self, that) => make(self - that),
+      onNanos: (self, that) => make(self - that)
+    })
+)
+
 /**
  * @since 2.0.0
  * @category math
@@ -631,32 +651,32 @@ export const format = (self: DurationInput): string => {
 
   const nanos = unsafeToNanos(duration)
 
-  if (nanos % 1000000n) {
-    parts.push(`${nanos % 1000000n}ns`)
+  if (nanos % bigint1e6) {
+    parts.push(`${nanos % bigint1e6}ns`)
   }
 
-  const ms = nanos / 1000000n
-  if (ms % 1000n !== 0n) {
-    parts.push(`${ms % 1000n}ms`)
+  const ms = nanos / bigint1e6
+  if (ms % bigint1e3 !== bigint0) {
+    parts.push(`${ms % bigint1e3}ms`)
   }
 
-  const sec = ms / 1000n
-  if (sec % 60n !== 0n) {
-    parts.push(`${sec % 60n}s`)
+  const sec = ms / bigint1e3
+  if (sec % bigint60 !== bigint0) {
+    parts.push(`${sec % bigint60}s`)
   }
 
-  const min = sec / 60n
-  if (min % 60n !== 0n) {
-    parts.push(`${min % 60n}m`)
+  const min = sec / bigint60
+  if (min % bigint60 !== bigint0) {
+    parts.push(`${min % bigint60}m`)
   }
 
-  const hr = min / 60n
-  if (hr % 24n !== 0n) {
-    parts.push(`${hr % 24n}h`)
+  const hr = min / bigint60
+  if (hr % bigint24 !== bigint0) {
+    parts.push(`${hr % bigint24}h`)
   }
 
-  const days = hr / 24n
-  if (days !== 0n) {
+  const days = hr / bigint24
+  if (days !== bigint0) {
     parts.push(`${days}d`)
   }
 

package/src/Number.ts

@@ -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)
  *

package/src/internal/version.ts

@@ -1,4 +1,4 @@
-let moduleVersion = "2.4.11"
+let moduleVersion = "2.4.13"
 
 export const getCurrentVersion = () => moduleVersion