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

package/src/RefSubject/RefBigDecimal.ts

@@ -1,295 +0,0 @@
-/**
- * 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

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

@@ -1,189 +0,0 @@
-/**
- * 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

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