@typed/fx 1.32.0 → 2.0.0-beta.0

package/src/RefSubject/RefBigDecimal.test.ts

@@ -0,0 +1,56 @@
+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));
+});

package/src/RefSubject/RefBigDecimal.ts

@@ -0,0 +1,295 @@
+/**
+ * Extensions to RefSubject for working with BigDecimal values
+ * @since 1.18.0
+ */
+
+import * as BigDecimal from "effect/BigDecimal";
+import type * as Effect from "effect/Effect";
+import { dual } from "effect/Function";
+import type * as Scope from "effect/Scope";
+import type * as Fx from "../Fx/index.js";
+import * as RefSubject from "./RefSubject.js";
+
+/**
+ * A RefBigDecimal is a RefSubject specialized over a BigDecimal value.
+ * @since 1.18.0
+ * @category models
+ */
+export interface RefBigDecimal<in out E = never, out R = never> extends RefSubject.RefSubject<
+  BigDecimal.BigDecimal,
+  E,
+  R
+> {}
+
+/**
+ * Creates a new `RefBigDecimal` from a BigDecimal, `Effect`, or `Fx`.
+ *
+ * @example
+ * ```ts
+ * import { Effect, BigDecimal } from "effect"
+ * import * as RefBigDecimal from "effect/typed/fx/RefSubject/RefBigDecimal"
+ *
+ * const program = Effect.gen(function* () {
+ *   const value = yield* RefBigDecimal.make(BigDecimal.fromStringUnsafe("123.45"))
+ *   const current = yield* value
+ *   console.log(current) // BigDecimal(123.45)
+ * })
+ * ```
+ *
+ * @since 1.18.0
+ * @category constructors
+ */
+export function make<E = never, R = never>(
+  initial:
+    | BigDecimal.BigDecimal
+    | Effect.Effect<BigDecimal.BigDecimal, E, R>
+    | Fx.Fx<BigDecimal.BigDecimal, E, R>,
+): Effect.Effect<RefBigDecimal<E>, never, R | Scope.Scope> {
+  return RefSubject.make(initial, { eq: BigDecimal.Equivalence });
+}
+
+// ========================================
+// Computed
+// ========================================
+
+/**
+ * Add a BigDecimal to the current state of a RefBigDecimal.
+ * @since 1.18.0
+ * @category computed
+ */
+export const add: {
+  (
+    that: BigDecimal.BigDecimal,
+  ): <E, R>(ref: RefBigDecimal<E, R>) => RefSubject.Computed<BigDecimal.BigDecimal, E, R>;
+  <E, R>(
+    ref: RefBigDecimal<E, R>,
+    that: BigDecimal.BigDecimal,
+  ): RefSubject.Computed<BigDecimal.BigDecimal, E, R>;
+} = dual(2, function add<E, R>(ref: RefBigDecimal<E, R>, that: BigDecimal.BigDecimal) {
+  return RefSubject.map(ref, (self) => BigDecimal.sum(self, that));
+});
+
+/**
+ * Subtract a BigDecimal from the current state of a RefBigDecimal.
+ * @since 1.18.0
+ * @category computed
+ */
+export const subtract: {
+  (
+    that: BigDecimal.BigDecimal,
+  ): <E, R>(ref: RefBigDecimal<E, R>) => RefSubject.Computed<BigDecimal.BigDecimal, E, R>;
+  <E, R>(
+    ref: RefBigDecimal<E, R>,
+    that: BigDecimal.BigDecimal,
+  ): RefSubject.Computed<BigDecimal.BigDecimal, E, R>;
+} = dual(2, function subtract<E, R>(ref: RefBigDecimal<E, R>, that: BigDecimal.BigDecimal) {
+  return RefSubject.map(ref, (self) => BigDecimal.subtract(self, that));
+});
+
+/**
+ * Multiply the current state of a RefBigDecimal by a BigDecimal.
+ * @since 1.18.0
+ * @category computed
+ */
+export const multiply: {
+  (
+    that: BigDecimal.BigDecimal,
+  ): <E, R>(ref: RefBigDecimal<E, R>) => RefSubject.Computed<BigDecimal.BigDecimal, E, R>;
+  <E, R>(
+    ref: RefBigDecimal<E, R>,
+    that: BigDecimal.BigDecimal,
+  ): RefSubject.Computed<BigDecimal.BigDecimal, E, R>;
+} = dual(2, function multiply<E, R>(ref: RefBigDecimal<E, R>, that: BigDecimal.BigDecimal) {
+  return RefSubject.map(ref, (self) => BigDecimal.multiply(self, that));
+});
+
+/**
+ * Divide the current state of a RefBigDecimal by a BigDecimal.
+ * @since 1.18.0
+ * @category computed
+ */
+export const divide: {
+  (
+    that: BigDecimal.BigDecimal,
+  ): <E, R>(
+    ref: RefBigDecimal<E, R>,
+  ) => RefSubject.Computed<BigDecimal.BigDecimal | undefined, E, R>;
+  <E, R>(
+    ref: RefBigDecimal<E, R>,
+    that: BigDecimal.BigDecimal,
+  ): RefSubject.Computed<BigDecimal.BigDecimal | undefined, E, R>;
+} = dual(2, function divide<E, R>(ref: RefBigDecimal<E, R>, that: BigDecimal.BigDecimal) {
+  return RefSubject.map(ref, (self) => BigDecimal.divide(self, that));
+});
+
+/**
+ * Get the absolute value of the current state of a RefBigDecimal.
+ * @since 1.18.0
+ * @category computed
+ */
+export const abs = <E, R>(
+  ref: RefBigDecimal<E, R>,
+): RefSubject.Computed<BigDecimal.BigDecimal, E, R> => RefSubject.map(ref, BigDecimal.abs);
+
+/**
+ * Negate the current state of a RefBigDecimal.
+ * @since 1.18.0
+ * @category computed
+ */
+export const negate = <E, R>(
+  ref: RefBigDecimal<E, R>,
+): RefSubject.Computed<BigDecimal.BigDecimal, E, R> => RefSubject.map(ref, BigDecimal.negate);
+
+/**
+ * Round the current state of a RefBigDecimal.
+ * @since 1.18.0
+ * @category computed
+ */
+export const round: {
+  (options?: {
+    scale?: number;
+    mode?: BigDecimal.RoundingMode;
+  }): <E, R>(ref: RefBigDecimal<E, R>) => RefSubject.Computed<BigDecimal.BigDecimal, E, R>;
+  <E, R>(
+    ref: RefBigDecimal<E, R>,
+    options?: { scale?: number; mode?: BigDecimal.RoundingMode },
+  ): RefSubject.Computed<BigDecimal.BigDecimal, E, R>;
+} = dual(2, function round<
+  E,
+  R,
+>(ref: RefBigDecimal<E, R>, options?: { scale?: number; mode?: BigDecimal.RoundingMode }) {
+  return RefSubject.map(ref, (self) => BigDecimal.round(self, options));
+});
+
+/**
+ * Truncate the current state of a RefBigDecimal.
+ * @since 1.18.0
+ * @category computed
+ */
+export const truncate: {
+  (
+    scale?: number,
+  ): <E, R>(ref: RefBigDecimal<E, R>) => RefSubject.Computed<BigDecimal.BigDecimal, E, R>;
+  <E, R>(
+    ref: RefBigDecimal<E, R>,
+    scale?: number,
+  ): RefSubject.Computed<BigDecimal.BigDecimal, E, R>;
+} = dual(2, function truncate<E, R>(ref: RefBigDecimal<E, R>, scale?: number) {
+  return RefSubject.map(ref, (self) => BigDecimal.truncate(self, scale));
+});
+
+/**
+ * Calculate the ceiling of the current state of a RefBigDecimal.
+ * @since 1.18.0
+ * @category computed
+ */
+export const ceil: {
+  (
+    scale?: number,
+  ): <E, R>(ref: RefBigDecimal<E, R>) => RefSubject.Computed<BigDecimal.BigDecimal, E, R>;
+  <E, R>(
+    ref: RefBigDecimal<E, R>,
+    scale?: number,
+  ): RefSubject.Computed<BigDecimal.BigDecimal, E, R>;
+} = dual(2, function ceil<E, R>(ref: RefBigDecimal<E, R>, scale?: number) {
+  return RefSubject.map(ref, (self) => BigDecimal.ceil(self, scale));
+});
+
+/**
+ * Calculate the floor of the current state of a RefBigDecimal.
+ * @since 1.18.0
+ * @category computed
+ */
+export const floor: {
+  (
+    scale?: number,
+  ): <E, R>(ref: RefBigDecimal<E, R>) => RefSubject.Computed<BigDecimal.BigDecimal, E, R>;
+  <E, R>(
+    ref: RefBigDecimal<E, R>,
+    scale?: number,
+  ): RefSubject.Computed<BigDecimal.BigDecimal, E, R>;
+} = dual(2, function floor<E, R>(ref: RefBigDecimal<E, R>, scale?: number) {
+  return RefSubject.map(ref, (self) => BigDecimal.floor(self, scale));
+});
+
+/**
+ * Check if the current state of a RefBigDecimal is zero.
+ * @since 1.18.0
+ * @category computed
+ */
+export const isZero = <E, R>(ref: RefBigDecimal<E, R>): RefSubject.Computed<boolean, E, R> =>
+  RefSubject.map(ref, BigDecimal.isZero);
+
+/**
+ * Check if the current state of a RefBigDecimal is negative.
+ * @since 1.18.0
+ * @category computed
+ */
+export const isNegative = <E, R>(ref: RefBigDecimal<E, R>): RefSubject.Computed<boolean, E, R> =>
+  RefSubject.map(ref, BigDecimal.isNegative);
+
+/**
+ * Check if the current state of a RefBigDecimal is positive.
+ * @since 1.18.0
+ * @category computed
+ */
+export const isPositive = <E, R>(ref: RefBigDecimal<E, R>): RefSubject.Computed<boolean, E, R> =>
+  RefSubject.map(ref, BigDecimal.isPositive);
+
+/**
+ * Check if the current state of a RefBigDecimal is an integer.
+ * @since 1.18.0
+ * @category computed
+ */
+export const isInteger = <E, R>(ref: RefBigDecimal<E, R>): RefSubject.Computed<boolean, E, R> =>
+  RefSubject.map(ref, BigDecimal.isInteger);
+
+/**
+ * Get the sign of the current state of a RefBigDecimal.
+ * @since 1.18.0
+ * @category computed
+ */
+export const sign = <E, R>(ref: RefBigDecimal<E, R>): RefSubject.Computed<number, E, R> =>
+  RefSubject.map(ref, BigDecimal.sign);
+
+/**
+ * Check if the current state of a RefBigDecimal is less than a BigDecimal.
+ * @since 1.18.0
+ * @category computed
+ */
+export const isLessThan: {
+  (
+    that: BigDecimal.BigDecimal,
+  ): <E, R>(ref: RefBigDecimal<E, R>) => RefSubject.Computed<boolean, E, R>;
+  <E, R>(ref: RefBigDecimal<E, R>, that: BigDecimal.BigDecimal): RefSubject.Computed<boolean, E, R>;
+} = dual(2, function isLessThan<E, R>(ref: RefBigDecimal<E, R>, that: BigDecimal.BigDecimal) {
+  return RefSubject.map(ref, (self) => BigDecimal.isLessThan(self, that));
+});
+
+/**
+ * Check if the current state of a RefBigDecimal is greater than a BigDecimal.
+ * @since 1.18.0
+ * @category computed
+ */
+export const isGreaterThan: {
+  (
+    that: BigDecimal.BigDecimal,
+  ): <E, R>(ref: RefBigDecimal<E, R>) => RefSubject.Computed<boolean, E, R>;
+  <E, R>(ref: RefBigDecimal<E, R>, that: BigDecimal.BigDecimal): RefSubject.Computed<boolean, E, R>;
+} = dual(2, function isGreaterThan<E, R>(ref: RefBigDecimal<E, R>, that: BigDecimal.BigDecimal) {
+  return RefSubject.map(ref, (self) => BigDecimal.isGreaterThan(self, that));
+});
+
+/**
+ * Check if the current state of a RefBigDecimal equals a BigDecimal.
+ * @since 1.18.0
+ * @category computed
+ */
+export const equals: {
+  (
+    that: BigDecimal.BigDecimal,
+  ): <E, R>(ref: RefBigDecimal<E, R>) => RefSubject.Computed<boolean, E, R>;
+  <E, R>(ref: RefBigDecimal<E, R>, that: BigDecimal.BigDecimal): RefSubject.Computed<boolean, E, R>;
+} = dual(2, function equals<E, R>(ref: RefBigDecimal<E, R>, that: BigDecimal.BigDecimal) {
+  return RefSubject.map(ref, (self) => BigDecimal.equals(self, that));
+});

package/src/RefSubject/RefBigInt.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, it } from "vitest";
+import { Effect } from "effect";
+import * as BigInt_ from "effect/BigInt";
+import * as RefBigInt from "./RefBigInt.js";
+
+describe("RefBigInt", () => {
+  it("creates and gets value", () =>
+    Effect.gen(function* () {
+      const value = BigInt_.BigInt(123);
+      const ref = yield* RefBigInt.make(value);
+      const current = yield* ref;
+      expect(current).toBe(value);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("adds two BigInt values", () =>
+    Effect.gen(function* () {
+      const ref = yield* RefBigInt.make(BigInt_.BigInt(10));
+      const result = yield* RefBigInt.add(ref, BigInt_.BigInt(5));
+      expect(result).toBe(BigInt_.BigInt(15));
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("subtracts two BigInt values", () =>
+    Effect.gen(function* () {
+      const ref = yield* RefBigInt.make(BigInt_.BigInt(10));
+      const result = yield* RefBigInt.subtract(ref, BigInt_.BigInt(3));
+      expect(result).toBe(BigInt_.BigInt(7));
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("multiplies two BigInt values", () =>
+    Effect.gen(function* () {
+      const ref = yield* RefBigInt.make(BigInt_.BigInt(5));
+      const result = yield* RefBigInt.multiply(ref, BigInt_.BigInt(4));
+      expect(result).toBe(BigInt_.BigInt(20));
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("gets absolute value", () =>
+    Effect.gen(function* () {
+      const ref = yield* RefBigInt.make(BigInt_.BigInt(-5));
+      const result = yield* RefBigInt.abs(ref);
+      expect(result).toBe(BigInt_.BigInt(5));
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("checks if zero", () =>
+    Effect.gen(function* () {
+      const ref = yield* RefBigInt.make(BigInt_.BigInt(0));
+      const isZero = yield* RefBigInt.isZero(ref);
+      expect(isZero).toBe(true);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("checks if less than", () =>
+    Effect.gen(function* () {
+      const ref = yield* RefBigInt.make(BigInt_.BigInt(5));
+      const isLess = yield* RefBigInt.isLessThan(ref, BigInt_.BigInt(10));
+      expect(isLess).toBe(true);
+    }).pipe(Effect.scoped, Effect.runPromise));
+});

package/src/RefSubject/RefBigInt.ts

@@ -0,0 +1,189 @@
+/**
+ * Extensions to RefSubject for working with BigInt values
+ * @since 1.18.0
+ */
+
+import * as BigInt_ from "effect/BigInt";
+import type * as Effect from "effect/Effect";
+import * as Equivalence_ from "effect/Equivalence";
+import type { Equivalence } from "effect/Equivalence";
+import { dual } from "effect/Function";
+import type * as Scope from "effect/Scope";
+import type * as Fx from "../Fx/index.js";
+import * as RefSubject from "./RefSubject.js";
+
+/**
+ * A RefBigInt is a RefSubject specialized over a BigInt value.
+ * @since 1.18.0
+ * @category models
+ */
+export interface RefBigInt<in out E = never, out R = never> extends RefSubject.RefSubject<
+  bigint,
+  E,
+  R
+> {}
+
+/**
+ * Creates a new `RefBigInt` from a BigInt, `Effect`, or `Fx`.
+ *
+ * @example
+ * ```ts
+ * import { Effect, BigInt } from "effect"
+ * import * as RefBigInt from "effect/typed/fx/RefSubject/RefBigInt"
+ *
+ * const program = Effect.gen(function* () {
+ *   const value = yield* RefBigInt.make(BigInt.BigInt(123))
+ *   const current = yield* value
+ *   console.log(current) // 123n
+ * })
+ * ```
+ *
+ * @since 1.18.0
+ * @category constructors
+ */
+export function make<E = never, R = never>(
+  initial: bigint | Effect.Effect<bigint, E, R> | Fx.Fx<bigint, E, R>,
+  eq: Equivalence<bigint> = Equivalence_.strictEqual(),
+): Effect.Effect<RefBigInt<E>, never, R | Scope.Scope> {
+  return RefSubject.make(initial, { eq });
+}
+
+// ========================================
+// Computed
+// ========================================
+
+/**
+ * Add a BigInt to the current state of a RefBigInt.
+ * @since 1.18.0
+ * @category computed
+ */
+export const add: {
+  (that: bigint): <E, R>(ref: RefBigInt<E, R>) => RefSubject.Computed<bigint, E, R>;
+  <E, R>(ref: RefBigInt<E, R>, that: bigint): RefSubject.Computed<bigint, E, R>;
+} = dual(2, function add<E, R>(ref: RefBigInt<E, R>, that: bigint) {
+  return RefSubject.map(ref, (self) => BigInt_.sum(self, that));
+});
+
+/**
+ * Subtract a BigInt from the current state of a RefBigInt.
+ * @since 1.18.0
+ * @category computed
+ */
+export const subtract: {
+  (that: bigint): <E, R>(ref: RefBigInt<E, R>) => RefSubject.Computed<bigint, E, R>;
+  <E, R>(ref: RefBigInt<E, R>, that: bigint): RefSubject.Computed<bigint, E, R>;
+} = dual(2, function subtract<E, R>(ref: RefBigInt<E, R>, that: bigint) {
+  return RefSubject.map(ref, (self) => BigInt_.subtract(self, that));
+});
+
+/**
+ * Multiply the current state of a RefBigInt by a BigInt.
+ * @since 1.18.0
+ * @category computed
+ */
+export const multiply: {
+  (that: bigint): <E, R>(ref: RefBigInt<E, R>) => RefSubject.Computed<bigint, E, R>;
+  <E, R>(ref: RefBigInt<E, R>, that: bigint): RefSubject.Computed<bigint, E, R>;
+} = dual(2, function multiply<E, R>(ref: RefBigInt<E, R>, that: bigint) {
+  return RefSubject.map(ref, (self) => BigInt_.multiply(self, that));
+});
+
+/**
+ * Divide the current state of a RefBigInt by a BigInt.
+ * @since 1.18.0
+ * @category computed
+ */
+export const divide: {
+  (that: bigint): <E, R>(ref: RefBigInt<E, R>) => RefSubject.Computed<bigint | undefined, E, R>;
+  <E, R>(ref: RefBigInt<E, R>, that: bigint): RefSubject.Computed<bigint | undefined, E, R>;
+} = dual(2, function divide<E, R>(ref: RefBigInt<E, R>, that: bigint) {
+  return RefSubject.map(ref, (self) => BigInt_.divide(self, that));
+});
+
+/**
+ * Get the remainder of dividing the current state of a RefBigInt by a BigInt.
+ * @since 1.18.0
+ * @category computed
+ */
+export const mod: {
+  (that: bigint): <E, R>(ref: RefBigInt<E, R>) => RefSubject.Computed<bigint, E, R>;
+  <E, R>(ref: RefBigInt<E, R>, that: bigint): RefSubject.Computed<bigint, E, R>;
+} = dual(2, function mod<E, R>(ref: RefBigInt<E, R>, that: bigint) {
+  return RefSubject.map(ref, (self) => BigInt_.remainder(self, that));
+});
+
+/**
+ * Get the absolute value of the current state of a RefBigInt.
+ * @since 1.18.0
+ * @category computed
+ */
+export const abs = <E, R>(ref: RefBigInt<E, R>): RefSubject.Computed<bigint, E, R> =>
+  RefSubject.map(ref, BigInt_.abs);
+
+/**
+ * Negate the current state of a RefBigInt.
+ * @since 1.18.0
+ * @category computed
+ */
+export const negate = <E, R>(ref: RefBigInt<E, R>): RefSubject.Computed<bigint, E, R> =>
+  RefSubject.map(ref, (self) => -self);
+
+/**
+ * Check if the current state of a RefBigInt is zero.
+ * @since 1.18.0
+ * @category computed
+ */
+export const isZero = <E, R>(ref: RefBigInt<E, R>): RefSubject.Computed<boolean, E, R> =>
+  RefSubject.map(ref, (self) => self === BigInt_.BigInt(0));
+
+/**
+ * Check if the current state of a RefBigInt is negative.
+ * @since 1.18.0
+ * @category computed
+ */
+export const isNegative = <E, R>(ref: RefBigInt<E, R>): RefSubject.Computed<boolean, E, R> =>
+  RefSubject.map(ref, (self) => self < BigInt_.BigInt(0));
+
+/**
+ * Check if the current state of a RefBigInt is positive.
+ * @since 1.18.0
+ * @category computed
+ */
+export const isPositive = <E, R>(ref: RefBigInt<E, R>): RefSubject.Computed<boolean, E, R> =>
+  RefSubject.map(ref, (self) => self > BigInt_.BigInt(0));
+
+/**
+ * Check if the current state of a RefBigInt is less than a BigInt.
+ * @since 1.18.0
+ * @category computed
+ */
+export const isLessThan: {
+  (that: bigint): <E, R>(ref: RefBigInt<E, R>) => RefSubject.Computed<boolean, E, R>;
+  <E, R>(ref: RefBigInt<E, R>, that: bigint): RefSubject.Computed<boolean, E, R>;
+} = dual(2, function isLessThan<E, R>(ref: RefBigInt<E, R>, that: bigint) {
+  return RefSubject.map(ref, (self) => BigInt_.isLessThan(self, that));
+});
+
+/**
+ * Check if the current state of a RefBigInt is greater than a BigInt.
+ * @since 1.18.0
+ * @category computed
+ */
+export const isGreaterThan: {
+  (that: bigint): <E, R>(ref: RefBigInt<E, R>) => RefSubject.Computed<boolean, E, R>;
+  <E, R>(ref: RefBigInt<E, R>, that: bigint): RefSubject.Computed<boolean, E, R>;
+} = dual(2, function isGreaterThan<E, R>(ref: RefBigInt<E, R>, that: bigint) {
+  return RefSubject.map(ref, (self) => BigInt_.isGreaterThan(self, that));
+});
+
+/**
+ * Check if the current state of a RefBigInt equals a BigInt.
+ * @since 1.18.0
+ * @category computed
+ */
+export const equals: {
+  (that: bigint): <E, R>(ref: RefBigInt<E, R>) => RefSubject.Computed<boolean, E, R>;
+  <E, R>(ref: RefBigInt<E, R>, that: bigint): RefSubject.Computed<boolean, E, R>;
+} = dual(2, function equals<E, R>(ref: RefBigInt<E, R>, that: bigint) {
+  return RefSubject.map(ref, (self) => self === that);
+});

package/src/RefSubject/RefBoolean.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, it } from "vitest";
+import { Effect } from "effect";
+import * as RefBoolean from "./RefBoolean.js";
+
+describe("RefBoolean", () => {
+  it("creates and gets value", () =>
+    Effect.gen(function* () {
+      const ref = yield* RefBoolean.make(true);
+      const current = yield* ref;
+      expect(current).toBe(true);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("toggles boolean value", () =>
+    Effect.gen(function* () {
+      const ref = yield* RefBoolean.make(true);
+      yield* RefBoolean.toggle(ref);
+      const result = yield* ref;
+      expect(result).toBe(false);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("sets to true", () =>
+    Effect.gen(function* () {
+      const ref = yield* RefBoolean.make(false);
+      yield* RefBoolean.setTrue(ref);
+      const result = yield* ref;
+      expect(result).toBe(true);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("sets to false", () =>
+    Effect.gen(function* () {
+      const ref = yield* RefBoolean.make(true);
+      yield* RefBoolean.setFalse(ref);
+      const result = yield* ref;
+      expect(result).toBe(false);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("applies AND operation", () =>
+    Effect.gen(function* () {
+      const ref = yield* RefBoolean.make(true);
+      const result = yield* RefBoolean.and(ref, false);
+      expect(result).toBe(false);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("applies OR operation", () =>
+    Effect.gen(function* () {
+      const ref = yield* RefBoolean.make(false);
+      const result = yield* RefBoolean.or(ref, true);
+      expect(result).toBe(true);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("checks if true", () =>
+    Effect.gen(function* () {
+      const ref = yield* RefBoolean.make(true);
+      const isTrue = yield* RefBoolean.isTrue(ref);
+      expect(isTrue).toBe(true);
+    }).pipe(Effect.scoped, Effect.runPromise));
+});