effect 2.0.0-next.50 → 2.0.0-next.51

package/dist/{core-effect-6666f2dc.cjs.prod.js → core-effect-460f968a.cjs.prod.js}

@@ -5,23 +5,23 @@ var Clock_dist_effectClock = require('../Clock/dist/effect-Clock.cjs.prod.js');
 var Context_dist_effectContext = require('../Context/dist/effect-Context.cjs.prod.js');
 var Duration_dist_effectDuration = require('../Duration/dist/effect-Duration.cjs.prod.js');
 var Either_dist_effectEither = require('../Either/dist/effect-Either.cjs.prod.js');
-var FiberId_dist_effectFiberId = require('./FiberId-0f0b7779.cjs.prod.js');
+var FiberId_dist_effectFiberId = require('./FiberId-88cc0067.cjs.prod.js');
 var FiberRefs_dist_effectFiberRefs = require('../FiberRefs/dist/effect-FiberRefs.cjs.prod.js');
 var Function_dist_effectFunction = require('../Function/dist/effect-Function.cjs.prod.js');
 var HashMap_dist_effectHashMap = require('../HashMap/dist/effect-HashMap.cjs.prod.js');
 var HashSet_dist_effectHashSet = require('../HashSet/dist/effect-HashSet.cjs.prod.js');
-var core = require('./core-473934ce.cjs.prod.js');
-var defaultServices = require('./defaultServices-8ea5e664.cjs.prod.js');
-var patch = require('./patch-256bc574.cjs.prod.js');
+var core = require('./core-35439f06.cjs.prod.js');
+var defaultServices = require('./defaultServices-61911fd4.cjs.prod.js');
+var patch = require('./patch-b7689042.cjs.prod.js');
 var label = require('./label-a588e6cd.cjs.prod.js');
-var RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch = require('./RuntimeFlagsPatch-3890e860.cjs.prod.js');
+var RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch = require('./RuntimeFlagsPatch-233ac7d7.cjs.prod.js');
 var List_dist_effectList = require('../List/dist/effect-List.cjs.prod.js');
 var LogLevel_dist_effectLogLevel = require('../LogLevel/dist/effect-LogLevel.cjs.prod.js');
 var LogSpan_dist_effectLogSpan = require('../LogSpan/dist/effect-LogSpan.cjs.prod.js');
 var Option_dist_effectOption = require('../Option/dist/effect-Option.cjs.prod.js');
 var Predicate_dist_effectPredicate = require('../Predicate/dist/effect-Predicate.cjs.prod.js');
 var ReadonlyArray_dist_effectReadonlyArray = require('../ReadonlyArray/dist/effect-ReadonlyArray.cjs.prod.js');
-var Ref_dist_effectRef = require('./Ref-00103de4.cjs.prod.js');
+var Ref_dist_effectRef = require('./Ref-50f14c13.cjs.prod.js');
 var Tracer_dist_effectTracer = require('../Tracer/dist/effect-Tracer.cjs.prod.js');
 
 /** @internal */

package/dist/{dataSource-d5d7f338.cjs.prod.js → dataSource-94fb44f9.cjs.prod.js}

@@ -4,8 +4,8 @@ var Cause_dist_effectCause = require('../Cause/dist/effect-Cause.cjs.prod.js');
 var Chunk_dist_effectChunk = require('../Chunk/dist/effect-Chunk.cjs.prod.js');
 var Effect_dist_effectEffect = require('../Effect/dist/effect-Effect.cjs.prod.js');
 var Function_dist_effectFunction = require('../Function/dist/effect-Function.cjs.prod.js');
-var core = require('./core-473934ce.cjs.prod.js');
-var fiberRuntime = require('./fiberRuntime-f1e80ca7.cjs.prod.js');
+var core = require('./core-35439f06.cjs.prod.js');
+var fiberRuntime = require('./fiberRuntime-26f406c3.cjs.prod.js');
 var ReadonlyArray_dist_effectReadonlyArray = require('../ReadonlyArray/dist/effect-ReadonlyArray.cjs.prod.js');
 
 /** @internal */

package/dist/{dataSource-9f78e828.cjs.dev.js → dataSource-da4a602c.cjs.dev.js}

@@ -4,8 +4,8 @@ var Cause_dist_effectCause = require('../Cause/dist/effect-Cause.cjs.dev.js');
 var Chunk_dist_effectChunk = require('../Chunk/dist/effect-Chunk.cjs.dev.js');
 var Effect_dist_effectEffect = require('../Effect/dist/effect-Effect.cjs.dev.js');
 var Function_dist_effectFunction = require('../Function/dist/effect-Function.cjs.dev.js');
-var core = require('./core-b4bf44d3.cjs.dev.js');
-var fiberRuntime = require('./fiberRuntime-0c1e7478.cjs.dev.js');
+var core = require('./core-a0828fef.cjs.dev.js');
+var fiberRuntime = require('./fiberRuntime-976a3e6f.cjs.dev.js');
 var ReadonlyArray_dist_effectReadonlyArray = require('../ReadonlyArray/dist/effect-ReadonlyArray.cjs.dev.js');
 
 /** @internal */

package/dist/declarations/src/BigDecimal.d.ts

@@ -0,0 +1,622 @@
+/**
+ * This module provides utility functions and type class instances for working with the `BigDecimal` type in TypeScript.
+ * It includes functions for basic arithmetic operations, as well as type class instances for `Equivalence` and `Order`.
+ *
+ * A `BigDecimal` allows storing any real number to arbitrary precision; which avoids common floating point errors
+ * (such as 0.1 + 0.2 ≠ 0.3) at the cost of complexity.
+ *
+ * Internally, `BigDecimal` uses a `BigInt` object, paired with a 64-bit integer which determines the position of the
+ * decimal point. Therefore, the precision *is not* actually arbitrary, but limited to 2<sup>63</sup> decimal places.
+ *
+ * It is not recommended to convert a floating point number to a decimal directly, as the floating point representation
+ * may be unexpected.
+ *
+ * @since 2.0.0
+ */
+import * as Equal from "./Equal.js";
+import * as equivalence from "./Equivalence.js";
+import { type Inspectable } from "./Inspectable.js";
+import * as Option from "./Option.js";
+import * as order from "./Order.js";
+import type { Ordering } from "./Ordering.js";
+import { type Pipeable } from "./Pipeable.js";
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export declare const TypeId: unique symbol;
+/**
+ * @since 2.0.0
+ * @category symbol
+ */
+export type TypeId = typeof TypeId;
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface BigDecimal extends Equal.Equal, Pipeable, Inspectable {
+    readonly [TypeId]: TypeId;
+    readonly value: bigint;
+    readonly scale: number;
+}
+/**
+ * Checks if a given value is a `BigDecimal`.
+ *
+ * @param u - The value to check.
+ *
+ * @since 2.0.0
+ * @category guards
+ */
+export declare const isBigDecimal: (u: unknown) => u is BigDecimal;
+/**
+ * Creates a `BigDecimal` from a `bigint` value and a scale.
+ *
+ * @param value - The `bigint` value to create a `BigDecimal` from.
+ * @param scale - The scale of the `BigDecimal`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export declare const make: (value: bigint, scale: number) => BigDecimal;
+/**
+ * Normalizes a given `BigDecimal` by removing trailing zeros.
+ *
+ * @param self - The `BigDecimal` to normalize.
+ *
+ * @example
+ * import { normalize, make, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(normalize(unsafeFromString("123.00000")), make(123n, 0))
+ * assert.deepStrictEqual(normalize(unsafeFromString("12300000")), make(123n, -5))
+ *
+ * @since 2.0.0
+ * @category scaling
+ */
+export declare const normalize: (self: BigDecimal) => BigDecimal;
+/**
+ * Scales a given `BigDecimal` to the specified scale.
+ *
+ * If the given scale is smaller than the current scale, the value will be rounded down to
+ * the nearest integer.
+ *
+ * @param self - The `BigDecimal` to scale.
+ * @param scale - The scale to scale to.
+ *
+ * @since 2.0.0
+ * @category scaling
+ */
+export declare const scale: (self: BigDecimal, scale: number) => BigDecimal;
+/**
+ * Provides an addition operation on `BigDecimal`s.
+ *
+ * @param self - The first operand.
+ * @param that - The second operand.
+ *
+ * @example
+ * import { sum, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(sum(unsafeFromString("2"), unsafeFromString("3")), unsafeFromString("5"))
+ *
+ * @since 2.0.0
+ * @category math
+ */
+export declare const sum: {
+    (that: BigDecimal): (self: BigDecimal) => BigDecimal;
+    (self: BigDecimal, that: BigDecimal): BigDecimal;
+};
+/**
+ * Provides a multiplication operation on `BigDecimal`s.
+ *
+ * @param self - The first operand.
+ * @param that - The second operand.
+ *
+ * @example
+ * import { multiply, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(multiply(unsafeFromString("2"), unsafeFromString("3")), unsafeFromString("6"))
+ *
+ * @since 2.0.0
+ * @category math
+ */
+export declare const multiply: {
+    (that: BigDecimal): (self: BigDecimal) => BigDecimal;
+    (self: BigDecimal, that: BigDecimal): BigDecimal;
+};
+/**
+ * Provides a subtraction operation on `BigDecimal`s.
+ *
+ * @param self - The first operand.
+ * @param that - The second operand.
+ *
+ * @example
+ * import { subtract, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(subtract(unsafeFromString("2"), unsafeFromString("3")), unsafeFromString("-1"))
+ *
+ * @since 2.0.0
+ * @category math
+ */
+export declare const subtract: {
+    (that: BigDecimal): (self: BigDecimal) => BigDecimal;
+    (self: BigDecimal, that: BigDecimal): 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 `None`.
+ *
+ * @param self - The dividend operand.
+ * @param that - The divisor operand.
+ *
+ * @example
+ * import { divide, unsafeFromString } from "effect/BigDecimal"
+ * import { some, none } from "effect/Option"
+ *
+ * assert.deepStrictEqual(divide(unsafeFromString("6"), unsafeFromString("3")), some(unsafeFromString("2")))
+ * assert.deepStrictEqual(divide(unsafeFromString("6"), unsafeFromString("4")), some(unsafeFromString("1.5")))
+ * assert.deepStrictEqual(divide(unsafeFromString("6"), unsafeFromString("0")), none())
+ *
+ * @since 2.0.0
+ * @category math
+ */
+export declare const divide: {
+    (that: BigDecimal): (self: BigDecimal) => Option.Option<BigDecimal>;
+    (self: BigDecimal, that: BigDecimal): Option.Option<BigDecimal>;
+};
+/**
+ * Provides an unsafe 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.
+ *
+ * Throws a `RangeError` if the divisor is `0`.
+ *
+ * @param self - The dividend operand.
+ * @param that - The divisor operand.as
+ *
+ * @example
+ * import { unsafeDivide, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(unsafeDivide(unsafeFromString("6"), unsafeFromString("3")), unsafeFromString("2"))
+ * assert.deepStrictEqual(unsafeDivide(unsafeFromString("6"), unsafeFromString("4")), unsafeFromString("1.5"))
+ *
+ * @since 2.0.0
+ * @category math
+ */
+export declare const unsafeDivide: {
+    (that: BigDecimal): (self: BigDecimal) => BigDecimal;
+    (self: BigDecimal, that: BigDecimal): BigDecimal;
+};
+/**
+ * @since 2.0.0
+ * @category instances
+ */
+export declare const Order: order.Order<BigDecimal>;
+/**
+ * Returns `true` if the first argument is less than the second, otherwise `false`.
+ *
+ * @param self - The first argument.
+ * @param that - The second argument.
+ *
+ * @example
+ * import { lessThan, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(lessThan(unsafeFromString("2"), unsafeFromString("3")), true)
+ * assert.deepStrictEqual(lessThan(unsafeFromString("3"), unsafeFromString("3")), false)
+ * assert.deepStrictEqual(lessThan(unsafeFromString("4"), unsafeFromString("3")), false)
+ *
+ * @since 2.0.0
+ * @category predicates
+ */
+export declare const lessThan: {
+    (that: BigDecimal): (self: BigDecimal) => boolean;
+    (self: BigDecimal, that: BigDecimal): boolean;
+};
+/**
+ * Checks if a given `BigDecimal` is less than or equal to the provided one.
+ *
+ * @param self - The first `BigDecimal` to compare with.
+ * @param that - The second `BigDecimal` to compare with.
+ *
+ * @example
+ * import { lessThanOrEqualTo, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(lessThanOrEqualTo(unsafeFromString("2"), unsafeFromString("3")), true)
+ * assert.deepStrictEqual(lessThanOrEqualTo(unsafeFromString("3"), unsafeFromString("3")), true)
+ * assert.deepStrictEqual(lessThanOrEqualTo(unsafeFromString("4"), unsafeFromString("3")), false)
+ *
+ * @since 2.0.0
+ * @category predicates
+ */
+export declare const lessThanOrEqualTo: {
+    (that: BigDecimal): (self: BigDecimal) => boolean;
+    (self: BigDecimal, that: BigDecimal): boolean;
+};
+/**
+ * Returns `true` if the first argument is greater than the second, otherwise `false`.
+ *
+ * @param self - The first argument.
+ * @param that - The second argument.
+ *
+ * @example
+ * import { greaterThan, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(greaterThan(unsafeFromString("2"), unsafeFromString("3")), false)
+ * assert.deepStrictEqual(greaterThan(unsafeFromString("3"), unsafeFromString("3")), false)
+ * assert.deepStrictEqual(greaterThan(unsafeFromString("4"), unsafeFromString("3")), true)
+ *
+ * @since 2.0.0
+ * @category predicates
+ */
+export declare const greaterThan: {
+    (that: BigDecimal): (self: BigDecimal) => boolean;
+    (self: BigDecimal, that: BigDecimal): boolean;
+};
+/**
+ * Checks if a given `BigDecimal` is greater than or equal to the provided one.
+ *
+ * @param self - The first `BigDecimal` to compare with.
+ * @param that - The second `BigDecimal` to compare with.
+ *
+ * @example
+ * import { greaterThanOrEqualTo, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(greaterThanOrEqualTo(unsafeFromString("2"), unsafeFromString("3")), false)
+ * assert.deepStrictEqual(greaterThanOrEqualTo(unsafeFromString("3"), unsafeFromString("3")), true)
+ * assert.deepStrictEqual(greaterThanOrEqualTo(unsafeFromString("4"), unsafeFromString("3")), true)
+ *
+ * @since 2.0.0
+ * @category predicates
+ */
+export declare const greaterThanOrEqualTo: {
+    (that: BigDecimal): (self: BigDecimal) => boolean;
+    (self: BigDecimal, that: BigDecimal): boolean;
+};
+/**
+ * Checks if a `BigDecimal` is between a `minimum` and `maximum` value (inclusive).
+ *
+ * @param self - The `number` to check.
+ * @param minimum - The `minimum` value to check.
+ * @param maximum - The `maximum` value to check.
+ *
+ * @example
+ * import { between, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(between(unsafeFromString("0"), unsafeFromString("5"))(unsafeFromString("3")), true)
+ * assert.deepStrictEqual(between(unsafeFromString("0"), unsafeFromString("5"))(unsafeFromString("-1")), false)
+ * assert.deepStrictEqual(between(unsafeFromString("0"), unsafeFromString("5"))(unsafeFromString("6")), false)
+ *
+ * @since 2.0.0
+ * @category predicates
+ */
+export declare const between: {
+    (minimum: BigDecimal, maximum: BigDecimal): (self: BigDecimal) => boolean;
+    (self: BigDecimal, minimum: BigDecimal, maximum: BigDecimal): boolean;
+};
+/**
+ * Restricts the given `BigDecimal` to be within the range specified by the `minimum` and `maximum` values.
+ *
+ * - If the `BigDecimal` is less than the `minimum` value, the function returns the `minimum` value.
+ * - If the `BigDecimal` is greater than the `maximum` value, the function returns the `maximum` value.
+ * - Otherwise, it returns the original `BigDecimal`.
+ *
+ * @param self - The `BigDecimal` to be clamped.
+ * @param minimum - The lower end of the range.
+ * @param maximum - The upper end of the range.
+ *
+ * @example
+ * import { clamp, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(clamp(unsafeFromString("0"), unsafeFromString("5"))(unsafeFromString("3")), unsafeFromString("3"))
+ * assert.deepStrictEqual(clamp(unsafeFromString("0"), unsafeFromString("5"))(unsafeFromString("-1")), unsafeFromString("0"))
+ * assert.deepStrictEqual(clamp(unsafeFromString("0"), unsafeFromString("5"))(unsafeFromString("6")), unsafeFromString("5"))
+ *
+ * @since 2.0.0
+ * @category math
+ */
+export declare const clamp: {
+    (minimum: BigDecimal, maximum: BigDecimal): (self: BigDecimal) => BigDecimal;
+    (self: BigDecimal, minimum: BigDecimal, maximum: BigDecimal): BigDecimal;
+};
+/**
+ * Returns the minimum between two `BigDecimal`s.
+ *
+ * @param self - The first `BigDecimal`.
+ * @param that - The second `BigDecimal`.
+ *
+ * @example
+ * import { min, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(min(unsafeFromString("2"), unsafeFromString("3")), unsafeFromString("2"))
+ *
+ * @since 2.0.0
+ * @category math
+ */
+export declare const min: {
+    (that: BigDecimal): (self: BigDecimal) => BigDecimal;
+    (self: BigDecimal, that: BigDecimal): BigDecimal;
+};
+/**
+ * Returns the maximum between two `BigDecimal`s.
+ *
+ * @param self - The first `BigDecimal`.
+ * @param that - The second `BigDecimal`.
+ *
+ * @example
+ * import { max, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(max(unsafeFromString("2"), unsafeFromString("3")), unsafeFromString("3"))
+ *
+ * @since 2.0.0
+ * @category math
+ */
+export declare const max: {
+    (that: BigDecimal): (self: BigDecimal) => BigDecimal;
+    (self: BigDecimal, that: BigDecimal): BigDecimal;
+};
+/**
+ * Determines the sign of a given `BigDecimal`.
+ *
+ * @param n - The `BigDecimal` to determine the sign of.
+ *
+ * @example
+ * import { sign, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(sign(unsafeFromString("-5")), -1)
+ * assert.deepStrictEqual(sign(unsafeFromString("0")), 0)
+ * assert.deepStrictEqual(sign(unsafeFromString("5")), 1)
+ *
+ * @since 2.0.0
+ * @category math
+ */
+export declare const sign: (n: BigDecimal) => Ordering;
+/**
+ * Determines the absolute value of a given `BigDecimal`.
+ *
+ * @param n - The `BigDecimal` to determine the absolute value of.
+ *
+ * @example
+ * import { abs, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(abs(unsafeFromString("-5")), unsafeFromString("5"))
+ * assert.deepStrictEqual(abs(unsafeFromString("0")), unsafeFromString("0"))
+ * assert.deepStrictEqual(abs(unsafeFromString("5")), unsafeFromString("5"))
+ *
+ * @since 2.0.0
+ * @category math
+ */
+export declare const abs: (n: BigDecimal) => BigDecimal;
+/**
+ * Provides a negate operation on `BigDecimal`s.
+ *
+ * @param n - The `BigDecimal` to negate.
+ *
+ * @example
+ * import { negate, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(negate(unsafeFromString("3")), unsafeFromString("-3"))
+ * assert.deepStrictEqual(negate(unsafeFromString("-6")), unsafeFromString("6"))
+ *
+ * @since 2.0.0
+ * @category math
+ */
+export declare const negate: (n: BigDecimal) => BigDecimal;
+/**
+ * Returns the remainder left over when one operand is divided by a second operand.
+ *
+ * If the divisor is `0`, the result will be `None`.
+ *
+ * @param self - The dividend.
+ * @param divisor - The divisor.
+ *
+ * @example
+ * import { remainder, unsafeFromString } from "effect/BigDecimal"
+ * import { some, none } from "effect/Option"
+ *
+ * assert.deepStrictEqual(remainder(unsafeFromString("2"), unsafeFromString("2")), some(unsafeFromString("0")))
+ * assert.deepStrictEqual(remainder(unsafeFromString("3"), unsafeFromString("2")), some(unsafeFromString("1")))
+ * assert.deepStrictEqual(remainder(unsafeFromString("-4"), unsafeFromString("2")), some(unsafeFromString("0")))
+ *
+ * @since 2.0.0
+ * @category math
+ */
+export declare const remainder: {
+    (divisor: BigDecimal): (self: BigDecimal) => Option.Option<BigDecimal>;
+    (self: BigDecimal, divisor: BigDecimal): Option.Option<BigDecimal>;
+};
+/**
+ * Returns the remainder left over when one operand is divided by a second operand.
+ *
+ * Throws a `RangeError` if the divisor is `0`.
+ *
+ * @param self - The dividend.
+ * @param divisor - The divisor.
+ *
+ * @example
+ * import { unsafeRemainder, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(unsafeRemainder(unsafeFromString("2"), unsafeFromString("2")), unsafeFromString("0"))
+ * assert.deepStrictEqual(unsafeRemainder(unsafeFromString("3"), unsafeFromString("2")), unsafeFromString("1"))
+ * assert.deepStrictEqual(unsafeRemainder(unsafeFromString("-4"), unsafeFromString("2")), unsafeFromString("0"))
+ *
+ * @since 2.0.0
+ * @category math
+ */
+export declare const unsafeRemainder: {
+    (divisor: BigDecimal): (self: BigDecimal) => BigDecimal;
+    (self: BigDecimal, divisor: BigDecimal): BigDecimal;
+};
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+export declare const Equivalence: equivalence.Equivalence<BigDecimal>;
+/**
+ * Checks if two `BigDecimal`s are equal.
+ *
+ * @since 2.0.0
+ * @category predicates
+ */
+export declare const equals: {
+    (that: BigDecimal): (self: BigDecimal) => boolean;
+    (self: BigDecimal, that: BigDecimal): boolean;
+};
+/**
+ * Creates a `BigDecimal` from a `bigint` value.
+ *
+ * @param value - The `bigint` value to create a `BigDecimal` from.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export declare const fromBigInt: (n: bigint) => BigDecimal;
+/**
+ * Creates a `BigDecimal` from a `number` value.
+ *
+ * It is not recommended to convert a floating point number to a decimal directly,
+ * as the floating point representation may be unexpected.
+ *
+ * @param value - The `number` value to create a `BigDecimal` from.
+ *
+ * @example
+ * import { fromNumber, make } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(fromNumber(123), make(123n, 0))
+ * assert.deepStrictEqual(fromNumber(123.456), make(123456n, 3))
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export declare const fromNumber: (n: number) => BigDecimal;
+/**
+ * Parses a numerical `string` into a `BigDecimal`.
+ *
+ * @param s - The `string` to parse.
+ *
+ * @example
+ * import { fromString, make } from "effect/BigDecimal"
+ * import { some, none } from "effect/Option"
+ *
+ * assert.deepStrictEqual(fromString("123"), some(make(123n, 0)))
+ * assert.deepStrictEqual(fromString("123.456"), some(make(123456n, 3)))
+ * assert.deepStrictEqual(fromString("123.abc"), none())
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export declare const fromString: (s: string) => Option.Option<BigDecimal>;
+/**
+ * Parses a numerical `string` into a `BigDecimal`.
+ *
+ * @param s - The `string` to parse.
+ *
+ * @example
+ * import { unsafeFromString, make } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(unsafeFromString("123"), make(123n, 0))
+ * assert.deepStrictEqual(unsafeFromString("123.456"), make(123456n, 3))
+ * assert.throws(() => unsafeFromString("123.abc"))
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export declare const unsafeFromString: (s: string) => BigDecimal;
+/**
+ * Formats a given `BigDecimal` as a `string`.
+ *
+ * @param normalized - The `BigDecimal` to format.
+ *
+ * @example
+ * import { toString, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(toString(unsafeFromString("-5")), "-5")
+ * assert.deepStrictEqual(toString(unsafeFromString("123.456")), "123.456")
+ * assert.deepStrictEqual(toString(unsafeFromString("-0.00000123")), "-0.00000123")
+ *
+ * @since 2.0.0
+ * @category conversions
+ */
+export declare const toString: (n: BigDecimal) => string;
+/**
+ * Converts a `BigDecimal` to a `number`.
+ *
+ * This function will produce incorrect results if the `BigDecimal` exceeds the 64-bit range of a `number`.
+ *
+ * @param n - The `BigDecimal` to convert.
+ *
+ * @example
+ * import { unsafeToNumber, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(unsafeToNumber(unsafeFromString("123.456")), 123.456)
+ *
+ * @since 2.0.0
+ * @category conversions
+ */
+export declare const unsafeToNumber: (n: BigDecimal) => number;
+/**
+ * Checks if a given `BigDecimal` is an integer.
+ *
+ * @param n - The `BigDecimal` to check.
+ *
+ * @example
+ * import { isInteger, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(isInteger(unsafeFromString("0")), true)
+ * assert.deepStrictEqual(isInteger(unsafeFromString("1")), true)
+ * assert.deepStrictEqual(isInteger(unsafeFromString("1.1")), false)
+ *
+ * @since 2.0.0
+ * @category predicates
+ */
+export declare const isInteger: (n: BigDecimal) => boolean;
+/**
+ * Checks if a given `BigDecimal` is `0`.
+ *
+ * @param n - The `BigDecimal` to check.
+ *
+ * @example
+ * import { isZero, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(isZero(unsafeFromString("0")), true)
+ * assert.deepStrictEqual(isZero(unsafeFromString("1")), false)
+ *
+ * @since 2.0.0
+ * @category predicates
+ */
+export declare const isZero: (n: BigDecimal) => boolean;
+/**
+ * Checks if a given `BigDecimal` is negative.
+ *
+ * @param n - The `BigDecimal` to check.
+ *
+ * @example
+ * import { isNegative, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(isNegative(unsafeFromString("-1")), true)
+ * assert.deepStrictEqual(isNegative(unsafeFromString("0")), false)
+ * assert.deepStrictEqual(isNegative(unsafeFromString("1")), false)
+ *
+ * @since 2.0.0
+ * @category predicates
+ */
+export declare const isNegative: (n: BigDecimal) => boolean;
+/**
+ * Checks if a given `BigDecimal` is positive.
+ *
+ * @param n - The `BigDecimal` to check.
+ *
+ * @example
+ * import { isPositive, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(isPositive(unsafeFromString("-1")), false)
+ * assert.deepStrictEqual(isPositive(unsafeFromString("0")), false)
+ * assert.deepStrictEqual(isPositive(unsafeFromString("1")), true)
+ *
+ * @since 2.0.0
+ * @category predicates
+ */
+export declare const isPositive: (n: BigDecimal) => boolean;
+//# sourceMappingURL=BigDecimal.d.ts.map

package/dist/declarations/src/BigDecimal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BigDecimal.d.ts","sourceRoot":"../../../src","sources":["BigDecimal.ts"],"names":[],"mappings":"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"}