@typed/fx 2.0.0-beta.0 → 2.0.0-beta.10

package/src/Push/index.ts

@@ -1 +0,0 @@
-export * from "./Push.js";

package/src/Push.test.ts

@@ -1,26 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { Effect, Fiber, Layer } from "effect";
-import { Fx, Push, Sink, Subject } from "./index.js";
-
-describe("Push", () => {
-  describe("Service", () => {
-    it("should allow defining a Push as a Service", () =>
-      Effect.gen(function* () {
-        class MyPush extends Push.Service<MyPush, number, never, string, never>()("MyPush") {}
-
-        const layer = Layer.unwrap(
-          Effect.gen(function* () {
-            const subject = yield* Subject.make<string>();
-            const sink = Sink.map(subject, String.fromCharCode);
-            return MyPush.make(sink, subject);
-          }),
-        );
-
-        yield* Effect.gen(function* () {
-          const fiber = yield* Fx.collectUpToFork(MyPush, 3);
-          yield* Effect.forEach(["f", "o", "o"], (char) => MyPush.onSuccess(char.charCodeAt(0)));
-          expect(yield* Fiber.join(fiber)).toEqual(["f", "o", "o"]);
-        }).pipe(Effect.provide(layer));
-      }).pipe(Effect.scoped, Effect.runPromise));
-  });
-});

package/src/Push.ts

@@ -1 +0,0 @@
-export * from "./Push/index.js";

package/src/RefSubject/RefArray.ts

@@ -1,512 +0,0 @@
-/**
- * Extensions to RefSubject for working with arrays of values
- * @since 1.18.0
- */
-
-import * as ReadonlyArray from "effect/Array";
-import type * as Effect from "effect/Effect";
-import { equals } from "effect/Equal";
-import * as Equivalence_ from "effect/Equivalence";
-import type { Equivalence } from "effect/Equivalence";
-import { dual } from "effect/Function";
-import * as Option from "effect/Option";
-import type * as Order from "effect/Order";
-import type * as Scope from "effect/Scope";
-import type * as Fx from "../Fx/index.js";
-import * as RefSubject from "./RefSubject.js";
-
-/**
- * A RefArray is a RefSubject that is specialized over an array of values.
- * @since 1.18.0
- * @category models
- */
-export interface RefArray<in out A, in out E = never, out R = never> extends RefSubject.RefSubject<
-  ReadonlyArray<A>,
-  E,
-  R
-> {}
-
-/**
- * Creates a new `RefArray` from an array, `Effect`, or `Fx`.
- *
- * @example
- * ```ts
- * import { Effect } from "effect"
- * import * as RefArray from "@typed/fx/RefSubject/RefArray"
- *
- * // From a plain array
- * const program1 = Effect.gen(function* () {
- *   const items = yield* RefArray.make([1, 2, 3])
- *   const values = yield* items
- *   console.log(values) // [1, 2, 3]
- * })
- *
- * // From an Effect
- * const program2 = Effect.gen(function* () {
- *   const items = yield* RefArray.make(
- *     Effect.succeed(["a", "b", "c"])
- *   )
- *   const values = yield* items
- *   console.log(values) // ["a", "b", "c"]
- * })
- * ```
- *
- * @since 1.18.0
- * @category constructors
- */
-export function make<A, E, R>(
-  initial: ReadonlyArray<A> | Effect.Effect<ReadonlyArray<A>, E, R> | Fx.Fx<ReadonlyArray<A>, E, R>,
-  eq: Equivalence<A> = equals,
-): Effect.Effect<RefArray<A, E>, never, R | Scope.Scope> {
-  return RefSubject.make(initial, { eq: Equivalence_.Array(eq) });
-}
-
-/**
- * Prepend a value to the current state of a RefArray.
- * @since 1.18.0
- * @category combinators
- */
-export const prepend: {
-  <A>(value: A): <E, R>(ref: RefArray<A, E, R>) => Effect.Effect<ReadonlyArray<A>, E, R>;
-  <A, E, R>(ref: RefArray<A, E, R>, value: A): Effect.Effect<ReadonlyArray<A>, E, R>;
-} = dual(2, function prepend<A, E, R>(ref: RefArray<A, E, R>, value: A) {
-  return RefSubject.update(ref, ReadonlyArray.prepend(value));
-});
-
-/**
- * Prepend an iterable of values to the current state of a RefArray.
- * @since 1.18.0
- * @category combinators
- */
-export const prependAll: {
-  <A>(value: Iterable<A>): <E, R>(ref: RefArray<A, E, R>) => Effect.Effect<ReadonlyArray<A>, E, R>;
-  <A, E, R>(ref: RefArray<A, E, R>, value: Iterable<A>): Effect.Effect<ReadonlyArray<A>, E, R>;
-} = dual(2, function prependAll<A, E, R>(ref: RefArray<A, E, R>, value: Iterable<A>) {
-  return RefSubject.update(ref, ReadonlyArray.prependAll(value));
-});
-
-/**
- * Append a value to the current state of a RefArray.
- * @since 1.18.0
- * @category combinators
- */
-export const append: {
-  <A>(value: A): <E, R>(ref: RefArray<A, E, R>) => Effect.Effect<ReadonlyArray<A>, E, R>;
-  <A, E, R>(ref: RefArray<A, E, R>, value: A): Effect.Effect<ReadonlyArray<A>, E, R>;
-} = dual(2, function append<A, E, R>(ref: RefArray<A, E, R>, value: A) {
-  return RefSubject.update(ref, ReadonlyArray.append(value));
-});
-
-/**
- * Append an iterable of values to the current state of a RefArray.
- * @since 1.18.0
- * @category combinators
- */
-export const appendAll: {
-  <A>(value: Iterable<A>): <E, R>(ref: RefArray<A, E, R>) => Effect.Effect<ReadonlyArray<A>, E, R>;
-  <A, E, R>(ref: RefArray<A, E, R>, value: Iterable<A>): Effect.Effect<ReadonlyArray<A>, E, R>;
-} = dual(2, function appendAll<A, E, R>(ref: RefArray<A, E, R>, value: Iterable<A>) {
-  return RefSubject.update(ref, ReadonlyArray.appendAll(value));
-});
-
-/**
- * Drop the first `n` values from a RefArray.
- * @since 1.18.0
- * @category combinators
- */
-export const drop: {
-  (n: number): <A, E, R>(ref: RefArray<A, E, R>) => Effect.Effect<ReadonlyArray<A>, E, R>;
-  <A, E, R>(ref: RefArray<A, E, R>, n: number): Effect.Effect<ReadonlyArray<A>, E, R>;
-} = dual(2, function drop<A, E, R>(ref: RefArray<A, E, R>, n: number) {
-  return RefSubject.update(ref, ReadonlyArray.drop(n));
-});
-
-/**
- * Drop the last `n` values from a RefArray.
- * @since 1.18.0
- * @category combinators
- */
-export const dropRight: {
-  (n: number): <A, E, R>(ref: RefArray<A, E, R>) => Effect.Effect<ReadonlyArray<A>, E, R>;
-  <A, E, R>(ref: RefArray<A, E, R>, n: number): Effect.Effect<ReadonlyArray<A>, E, R>;
-} = dual(2, function dropRight<A, E, R>(ref: RefArray<A, E, R>, n: number) {
-  return RefSubject.update(ref, ReadonlyArray.dropRight(n));
-});
-
-/**
- * Drop values from a RefArray while a predicate is true.
- * @since 1.18.0
- * @category combinators
- */
-export const dropWhile: {
-  <A>(
-    predicate: (a: A) => boolean,
-  ): <E, R>(ref: RefArray<A, E, R>) => Effect.Effect<ReadonlyArray<A>, E, R>;
-  <A, E, R>(
-    ref: RefArray<A, E, R>,
-    predicate: (a: unknown) => boolean,
-  ): Effect.Effect<ReadonlyArray<A>, E, R>;
-} = dual(2, function dropWhile<
-  A,
-  E,
-  R,
->(ref: RefArray<A, E, R>, predicate: (a: unknown) => boolean) {
-  return RefSubject.update(ref, ReadonlyArray.dropWhile(predicate));
-});
-
-/**
- * Filter the values of a RefArray using a predicate creating a Computed value.
- * @since 1.18.0
- * @category computed
- */
-export const filterValues: {
-  <A>(
-    predicate: (a: A) => boolean,
-  ): <E, R>(ref: RefArray<A, E, R>) => RefSubject.Computed<ReadonlyArray<A>, E, R>;
-  <A, E, R>(
-    ref: RefArray<A, E, R>,
-    predicate: (a: A) => boolean,
-  ): RefSubject.Computed<ReadonlyArray<A>, E, R>;
-} = dual(2, function filterValues<A, E, R>(ref: RefArray<A, E, R>, predicate: (a: A) => boolean) {
-  return RefSubject.map(ref, ReadonlyArray.filter(predicate));
-});
-
-/**
- * Get a value contained a particular index of a RefArray.
- * @since 1.18.0
- * @category filtered
- */
-export const getIndex: {
-  (index: number): <A, E, R>(ref: RefArray<A, E, R>) => RefSubject.Filtered<A, E, R>;
-  <A, E, R>(ref: RefArray<A, E, R>, index: number): RefSubject.Filtered<A, E, R>;
-} = dual(2, function getIndex<A, E, R>(ref: RefArray<A, E, R>, index: number) {
-  return RefSubject.filterMap(ref, ReadonlyArray.get(index));
-});
-
-/**
- * Group the values of a RefArray by a key.
- * @since 1.18.0
- * @category computed
- */
-export const groupBy: {
-  <A>(
-    f: (a: A) => string,
-  ): <E, R>(ref: RefArray<A, E, R>) => RefSubject.Computed<R, E, Record<string, ReadonlyArray<A>>>;
-  <A, E, R>(
-    ref: RefArray<A, E, R>,
-    f: (a: A) => string,
-  ): RefSubject.Computed<R, E, Record<string, ReadonlyArray<A>>>;
-} = dual(2, function groupBy<A, E, R>(ref: RefArray<A, E, R>, f: (a: A) => string) {
-  return RefSubject.map(ref, ReadonlyArray.groupBy(f));
-});
-
-/**
- * Insert a value at a particular index of a RefArray.
- * @since 1.18.0
- * @category combinators
- */
-export const insertAt: {
-  <A>(index: number, a: A): <E, R>(ref: RefArray<A, E, R>) => Effect.Effect<ReadonlyArray<A>, E, R>;
-  <A, E, R>(ref: RefArray<A, E, R>, index: number, a: A): Effect.Effect<ReadonlyArray<A>, E, R>;
-} = dual(3, function insertAt<A, E, R>(ref: RefArray<A, E, R>, index: number, a: A) {
-  return RefSubject.update(ref, (as) =>
-    Option.getOrElse(Option.fromUndefinedOr(ReadonlyArray.insertAt(as, index, a)), () => [
-      ...as,
-      a,
-    ]),
-  );
-});
-
-/**
- * Check to see if a RefArray is empty.
- * @since 1.18.0
- * @category computed
- */
-export const isEmpty = <A, E, R>(ref: RefArray<A, E, R>): RefSubject.Computed<boolean, E, R> =>
-  RefSubject.map(ref, ReadonlyArray.isReadonlyArrayEmpty);
-
-/**
- * Check to see if a RefArray is non-empty.
- * @since 1.18.0
- * @category computed
- */
-export const isNonEmpty = <A, E, R>(ref: RefArray<A, E, R>): RefSubject.Computed<boolean, E, R> =>
-  RefSubject.map(ref, ReadonlyArray.isReadonlyArrayNonEmpty);
-
-/**
- * Get the current length of a RefArray.
- * @since 1.18.0
- * @category computed
- */
-export const length = <A, E, R>(ref: RefArray<A, E, R>): RefSubject.Computed<number, E, R> =>
-  RefSubject.map(ref, ReadonlyArray.length);
-
-/**
- * Map (Endomorphic) the values of a RefArray.
- * @since 1.18.0
- * @category combinators
- */
-export const map: {
-  <A>(
-    f: (a: A, index: number) => A,
-  ): <E, R>(ref: RefArray<A, E, R>) => RefSubject.Computed<ReadonlyArray<A>, E, R>;
-  <A, E, R>(
-    ref: RefArray<A, E, R>,
-    f: (a: A, index: number) => A,
-  ): RefSubject.Computed<ReadonlyArray<A>, E, R>;
-} = dual(2, function mapValues<A, E, R>(ref: RefArray<A, E, R>, f: (a: A, index: number) => A) {
-  return RefSubject.update(ref, ReadonlyArray.map(f));
-});
-
-/**
- * Map the values with their indexes of a RefArray.
- * @since 1.18.0
- * @category computed
- */
-export const mapValues: {
-  <A, B>(
-    f: (a: A, index: number) => B,
-  ): <E, R>(ref: RefArray<A, E, R>) => RefSubject.Computed<ReadonlyArray<B>, E, R>;
-  <A, E, R, B>(
-    ref: RefArray<A, E, R>,
-    f: (a: A, index: number) => B,
-  ): RefSubject.Computed<ReadonlyArray<B>, E, R>;
-} = dual(2, function mapValues<A, E, R, B>(ref: RefArray<A, E, R>, f: (a: A, index: number) => B) {
-  return RefSubject.map(ref, ReadonlyArray.map(f));
-});
-
-/**
- * Modify the value at a particular index of a RefArray.
- * @since 1.18.0
- * @category combinators
- */
-export const modifyAt: {
-  <A>(
-    index: number,
-    f: (a: A) => A,
-  ): <E, R>(ref: RefArray<A, E, R>) => Effect.Effect<ReadonlyArray<A>, E, R>;
-  <A, E, R>(
-    ref: RefArray<A, E, R>,
-    index: number,
-    f: (a: A) => A,
-  ): Effect.Effect<ReadonlyArray<A>, E, R>;
-} = dual(3, function modifyAt<A, E, R>(ref: RefArray<A, E, R>, index: number, f: (a: A) => A) {
-  return RefSubject.update(ref, (values) => ReadonlyArray.modify(values, index, f) || values);
-});
-
-/**
- * Partition the values of a RefArray using a predicate.
- * @since 1.18.0
- * @category computed
- */
-export const partition: {
-  <A, B extends A>(
-    predicate: (a: A) => a is B,
-  ): <E, R>(
-    ref: RefArray<A, E, R>,
-  ) => RefSubject.Computed<R, E, readonly [ReadonlyArray<B>, ReadonlyArray<A>]>;
-  <A, E, R>(
-    ref: RefArray<A, E, R>,
-    predicate: (a: A) => boolean,
-  ): RefSubject.Computed<never, E, readonly [ReadonlyArray<A>, ReadonlyArray<A>]>;
-} = dual(2, function partition<A, E, R>(ref: RefArray<A, E, R>, predicate: (a: A) => boolean) {
-  return RefSubject.map(ref, ReadonlyArray.partition(predicate));
-});
-
-/**
- * Reduce the values of a RefArray to a single value.
- * @since 1.18.0
- * @category computed
- */
-export const reduce: {
-  <A, B>(
-    b: B,
-    f: (b: B, a: A, index: number) => B,
-  ): <E, R>(ref: RefArray<A, E, R>) => RefSubject.Computed<B, E, R>;
-  <A, E, R, B>(
-    ref: RefArray<A, E, R>,
-    b: B,
-    f: (b: B, a: A, index: number) => B,
-  ): RefSubject.Computed<B, E, R>;
-} = dual(3, function reduce<
-  A,
-  E,
-  R,
-  B,
->(ref: RefArray<A, E, R>, b: B, f: (b: B, a: A, index: number) => B) {
-  return RefSubject.map(ref, ReadonlyArray.reduce(b, f));
-});
-
-/**
- * Reduce the values of a RefArray to a single value in reverse order.
- * @since 1.18.0
- * @category computed
- */
-export const reduceRight: {
-  <A, B>(
-    b: B,
-    f: (b: B, a: A, index: number) => B,
-  ): <E, R>(ref: RefArray<A, E, R>) => RefSubject.Computed<B, E, R>;
-  <A, E, R, B>(
-    ref: RefArray<A, E, R>,
-    b: B,
-    f: (b: B, a: A, index: number) => B,
-  ): RefSubject.Computed<B, E, R>;
-} = dual(3, function reduceRight<
-  A,
-  E,
-  R,
-  B,
->(ref: RefArray<A, E, R>, b: B, f: (b: B, a: A, index: number) => B) {
-  return RefSubject.map(ref, ReadonlyArray.reduceRight(b, f));
-});
-
-/**
- * Replace a value at a particular index of a RefArray.
- * @since 1.18.0
- * @category combinators
- */
-export const replaceAt: {
-  <A>(index: number, a: A): <E, R>(ref: RefArray<A, E, R>) => Effect.Effect<ReadonlyArray<A>, E, R>;
-  <A, E, R>(ref: RefArray<A, E, R>, index: number, a: A): Effect.Effect<ReadonlyArray<A>, E, R>;
-} = dual(3, function replaceAt<A, E, R>(ref: RefArray<A, E, R>, index: number, a: A) {
-  return RefSubject.update(ref, (values) => ReadonlyArray.replace(values, index, a) || values);
-});
-
-/**
- * Rotate the values of a RefArray by `n` places. Helpful for things like carousels.
- * @since 1.18.0
- * @category combinators
- */
-export const rotate: {
-  (n: number): <A, E, R>(ref: RefArray<A, E, R>) => Effect.Effect<ReadonlyArray<A>, E, R>;
-  <A, E, R>(ref: RefArray<A, E, R>, n: number): Effect.Effect<ReadonlyArray<A>, E, R>;
-} = dual(2, function rotate<A, E, R>(ref: RefArray<A, E, R>, n: number) {
-  return RefSubject.update(ref, ReadonlyArray.rotate(n));
-});
-
-/**
- * Sort the values of a RefArray using a provided Order.
- * @since 1.18.0
- * @category combinators
- */
-export const sortBy: {
-  <A>(
-    orders: Iterable<Order.Order<A>>,
-  ): <E, R>(ref: RefArray<A, E, R>) => Effect.Effect<ReadonlyArray<A>, E, R>;
-  <A, E, R>(
-    ref: RefArray<A, E, R>,
-    orders: Iterable<Order.Order<A>>,
-  ): Effect.Effect<ReadonlyArray<A>, E, R>;
-} = dual(2, function sortBy<A, E, R>(ref: RefArray<A, E, R>, orders: Iterable<Order.Order<A>>) {
-  return RefSubject.update(ref, ReadonlyArray.sortBy(...orders));
-});
-
-/**
- * Take the first `n` values from a RefArray.
- * @since 1.18.0
- * @category combinators
- */
-export const take: {
-  (n: number): <A, E, R>(ref: RefArray<A, E, R>) => Effect.Effect<ReadonlyArray<A>, E, R>;
-  <A, E, R>(ref: RefArray<A, E, R>, n: number): Effect.Effect<ReadonlyArray<A>, E, R>;
-} = dual(2, function take<A, E, R>(ref: RefArray<A, E, R>, n: number) {
-  return RefSubject.update(ref, ReadonlyArray.take(n));
-});
-
-/**
- * Take the last `n` values from a RefArray.
- * @since 1.18.0
- * @category combinators
- */
-export const takeRight: {
-  (n: number): <A, E, R>(ref: RefArray<A, E, R>) => Effect.Effect<ReadonlyArray<A>, E, R>;
-  <A, E, R>(ref: RefArray<A, E, R>, n: number): Effect.Effect<ReadonlyArray<A>, E, R>;
-} = dual(2, function takeRight<A, E, R>(ref: RefArray<A, E, R>, n: number) {
-  return RefSubject.update(ref, ReadonlyArray.takeRight(n));
-});
-
-/**
- * Take values from a RefArray while a predicate is true.
- * @since 1.18.0
- * @category combinators
- */
-export const takeWhile: {
-  <A>(
-    predicate: (a: A) => boolean,
-  ): <E, R>(ref: RefArray<A, E, R>) => Effect.Effect<ReadonlyArray<A>, E, R>;
-  <A, E, R>(
-    ref: RefArray<A, E, R>,
-    predicate: (a: unknown) => boolean,
-  ): Effect.Effect<ReadonlyArray<A>, E, R>;
-} = dual(2, function takeWhile<
-  A,
-  E,
-  R,
->(ref: RefArray<A, E, R>, predicate: (a: unknown) => boolean) {
-  return RefSubject.update(ref, ReadonlyArray.takeWhile(predicate));
-});
-
-/**
- * Remove any duplicate values from a RefArray.
- * @since 1.18.0
- * @category combinators
- */
-export const dedupeWith =
-  <A>(valueEq: Equivalence<A>) =>
-  <E, R>(ref: RefArray<A, E, R>): Effect.Effect<ReadonlyArray<A>, E, R> =>
-    RefSubject.update(ref, ReadonlyArray.dedupeWith(valueEq));
-
-/**
- * Gets the last element of a `RefArray` as a `Filtered`.
- *
- * @example
- * ```ts
- * import { Effect } from "effect"
- * import * as RefArray from "@typed/fx/RefSubject/RefArray"
- *
- * const program = Effect.gen(function* () {
- *   const items = yield* RefArray.make([1, 2, 3, 4, 5])
- *
- *   const last = RefArray.last(items)
- *   const value = yield* last
- *   console.log(value) // 5
- *
- *   // If array becomes empty, Filtered will fail
- *   yield* RefArray.set(items, [])
- *   // yield* last would fail with NoSuchElementError
- * })
- * ```
- *
- * @since 1.18.0
- * @category filtered
- */
-export const last = <A, E, R>(ref: RefArray<A, E, R>): RefSubject.Filtered<A, E, R> =>
-  RefSubject.filterMap(ref, ReadonlyArray.last);
-
-/**
- * Gets the first element of a `RefArray` as a `Filtered`.
- *
- * @example
- * ```ts
- * import { Effect } from "effect"
- * import * as RefArray from "@typed/fx/RefSubject/RefArray"
- *
- * const program = Effect.gen(function* () {
- *   const items = yield* RefArray.make([1, 2, 3, 4, 5])
- *
- *   const head = RefArray.head(items)
- *   const value = yield* head
- *   console.log(value) // 1
- *
- *   // If array becomes empty, Filtered will fail
- *   yield* RefArray.set(items, [])
- *   // yield* head would fail with NoSuchElementError
- * })
- * ```
- *
- * @since 1.18.0
- * @category filtered
- */
-export const head = <A, E, R>(ref: RefArray<A, E, R>): RefSubject.Filtered<A, E, R> =>
-  RefSubject.filterMap(ref, ReadonlyArray.head);

package/src/RefSubject/RefBigDecimal.test.ts

@@ -1,56 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { Effect } from "effect";
-import * as BigDecimal from "effect/BigDecimal";
-import * as RefBigDecimal from "./RefBigDecimal.js";
-
-describe("RefBigDecimal", () => {
-  it("creates and gets value", () =>
-    Effect.gen(function* () {
-      const value = BigDecimal.fromStringUnsafe("123.45");
-      const ref = yield* RefBigDecimal.make(value);
-      const current = yield* ref;
-      expect(BigDecimal.equals(current, value)).toBe(true);
-    }).pipe(Effect.scoped, Effect.runPromise));
-
-  it("adds two BigDecimal values", () =>
-    Effect.gen(function* () {
-      const ref = yield* RefBigDecimal.make(BigDecimal.fromStringUnsafe("10.5"));
-      const result = yield* RefBigDecimal.add(ref, BigDecimal.fromStringUnsafe("5.25"));
-      expect(BigDecimal.format(result)).toBe("15.75");
-    }).pipe(Effect.scoped, Effect.runPromise));
-
-  it("subtracts two BigDecimal values", () =>
-    Effect.gen(function* () {
-      const ref = yield* RefBigDecimal.make(BigDecimal.fromStringUnsafe("10.5"));
-      const result = yield* RefBigDecimal.subtract(ref, BigDecimal.fromStringUnsafe("3.25"));
-      expect(BigDecimal.format(result)).toBe("7.25");
-    }).pipe(Effect.scoped, Effect.runPromise));
-
-  it("multiplies two BigDecimal values", () =>
-    Effect.gen(function* () {
-      const ref = yield* RefBigDecimal.make(BigDecimal.fromStringUnsafe("2.5"));
-      const result = yield* RefBigDecimal.multiply(ref, BigDecimal.fromStringUnsafe("4"));
-      expect(BigDecimal.format(result)).toBe("10");
-    }).pipe(Effect.scoped, Effect.runPromise));
-
-  it("gets absolute value", () =>
-    Effect.gen(function* () {
-      const ref = yield* RefBigDecimal.make(BigDecimal.fromStringUnsafe("-5.5"));
-      const result = yield* RefBigDecimal.abs(ref);
-      expect(BigDecimal.format(result)).toBe("5.5");
-    }).pipe(Effect.scoped, Effect.runPromise));
-
-  it("checks if zero", () =>
-    Effect.gen(function* () {
-      const ref = yield* RefBigDecimal.make(BigDecimal.fromStringUnsafe("0"));
-      const isZero = yield* RefBigDecimal.isZero(ref);
-      expect(isZero).toBe(true);
-    }).pipe(Effect.scoped, Effect.runPromise));
-
-  it("checks if less than", () =>
-    Effect.gen(function* () {
-      const ref = yield* RefBigDecimal.make(BigDecimal.fromStringUnsafe("5"));
-      const isLess = yield* RefBigDecimal.isLessThan(ref, BigDecimal.fromStringUnsafe("10"));
-      expect(isLess).toBe(true);
-    }).pipe(Effect.scoped, Effect.runPromise));
-});