@typed/fx 2.0.0-beta.3 → 2.0.0-beta.5

package/src/RefSubject/RefRecord.ts

@@ -1,621 +0,0 @@
-/**
- * Extensions to RefSubject for working with Record values
- * @since 1.18.0
- */
-
-import { Result } from "effect";
-import type * as Effect from "effect/Effect";
-import { equals } from "effect/Equal";
-import { dual } from "effect/Function";
-import * as Option from "effect/Option";
-import * as Record from "effect/Record";
-import type * as Scope from "effect/Scope";
-import type * as Fx from "../Fx/index.js";
-import * as RefSubject from "./RefSubject.js";
-
-/**
- * A RefRecord is a RefSubject specialized over a Record.
- * @since 1.18.0
- * @category models
- */
-export interface RefRecord<
-  in out K extends string,
-  in out V,
-  in out E = never,
-  out R = never,
-> extends RefSubject.RefSubject<Record.ReadonlyRecord<K, V>, E, R> {}
-
-/**
- * Creates a new `RefRecord` from a Record, `Effect`, or `Fx`.
- * @since 1.18.0
- * @category constructors
- */
-export function make<K extends string, V, E, R>(
-  initial:
-    | Record.ReadonlyRecord<K, V>
-    | Effect.Effect<Record.ReadonlyRecord<K, V>, E, R>
-    | Fx.Fx<Record.ReadonlyRecord<K, V>, E, R>,
-): Effect.Effect<RefRecord<K, V, E>, never, R | Scope.Scope> {
-  return RefSubject.make(initial, { eq: equals });
-}
-
-// ========================================
-// Combinators
-// ========================================
-
-/**
- * Set a key-value pair in the Record.
- * @since 1.18.0
- * @category combinators
- */
-export const set: {
-  <K extends string, V>(
-    key: K,
-    value: V,
-  ): <E, R>(ref: RefRecord<K, V, E, R>) => Effect.Effect<Record.ReadonlyRecord<K, V>, E, R>;
-  <K extends string, V, E, R>(
-    ref: RefRecord<K, V, E, R>,
-    key: K,
-    value: V,
-  ): Effect.Effect<Record.ReadonlyRecord<K, V>, E, R>;
-} = dual(3, function set<K extends string, V, E, R>(ref: RefRecord<K, V, E, R>, key: K, value: V) {
-  return RefSubject.update(ref, Record.set(key, value));
-});
-
-/**
- * Remove a key from the Record.
- * @since 1.18.0
- * @category combinators
- */
-export const remove: {
-  <K extends string>(
-    key: K,
-  ): <V, E, R>(ref: RefRecord<K, V, E, R>) => Effect.Effect<Record.ReadonlyRecord<K, V>, E, R>;
-  <K extends string, V, E, R>(
-    ref: RefRecord<K, V, E, R>,
-    key: K,
-  ): Effect.Effect<Record.ReadonlyRecord<K, V>, E, R>;
-} = dual(2, function remove<K extends string, V, E, R>(ref: RefRecord<K, V, E, R>, key: K) {
-  return RefSubject.update(ref, (r) => Record.remove(r, key) as Record.ReadonlyRecord<K, V>);
-});
-
-/**
- * Modify the value at a key if it exists.
- * @since 1.18.0
- * @category combinators
- */
-export const modify: {
-  <K extends string, V>(
-    key: K,
-    f: (v: V) => V,
-  ): <E, R>(ref: RefRecord<K, V, E, R>) => Effect.Effect<Record.ReadonlyRecord<K, V>, E, R>;
-  <K extends string, V, E, R>(
-    ref: RefRecord<K, V, E, R>,
-    key: K,
-    f: (v: V) => V,
-  ): Effect.Effect<Record.ReadonlyRecord<K, V>, E, R>;
-} = dual(3, function modify<
-  K extends string,
-  V,
-  E,
-  R,
->(ref: RefRecord<K, V, E, R>, key: K, f: (v: V) => V) {
-  return RefSubject.update(ref, (r) => Option.getOrElse(Record.modify(r, key, f), () => r));
-});
-
-/**
- * Replace the value at a key if it exists.
- * @since 1.18.0
- * @category combinators
- */
-export const replace: {
-  <K extends string, V>(
-    key: K,
-    value: V,
-  ): <E, R>(ref: RefRecord<K, V, E, R>) => Effect.Effect<Record.ReadonlyRecord<K, V>, E, R>;
-  <K extends string, V, E, R>(
-    ref: RefRecord<K, V, E, R>,
-    key: K,
-    value: V,
-  ): Effect.Effect<Record.ReadonlyRecord<K, V>, E, R>;
-} = dual(3, function replace<
-  K extends string,
-  V,
-  E,
-  R,
->(ref: RefRecord<K, V, E, R>, key: K, value: V) {
-  return RefSubject.update(ref, (r) => Option.getOrElse(Record.replace(r, key, value), () => r));
-});
-
-/**
- * Clear all entries from the Record.
- * @since 1.18.0
- * @category combinators
- */
-export const clear = <K extends string, V, E, R>(
-  ref: RefRecord<K, V, E, R>,
-): Effect.Effect<Record.ReadonlyRecord<K, V>, E, R> =>
-  RefSubject.update(ref, () => Record.empty() as Record.ReadonlyRecord<K, V>);
-
-/**
- * Union with another record.
- * @since 1.18.0
- * @category combinators
- */
-export const union: {
-  <K extends string, V>(
-    that: Record.ReadonlyRecord<K, V>,
-    combine?: (selfValue: V, thatValue: V) => V,
-  ): <E, R>(ref: RefRecord<K, V, E, R>) => Effect.Effect<Record.ReadonlyRecord<K, V>, E, R>;
-  <K extends string, V, E, R>(
-    ref: RefRecord<K, V, E, R>,
-    that: Record.ReadonlyRecord<K, V>,
-    combine?: (selfValue: V, thatValue: V) => V,
-  ): Effect.Effect<Record.ReadonlyRecord<K, V>, E, R>;
-} = dual(
-  (args) => RefSubject.isRefSubject(args[0]),
-  function union<K extends string, V, E, R>(
-    ref: RefRecord<K, V, E, R>,
-    that: Record.ReadonlyRecord<K, V>,
-    combine?: (selfValue: V, thatValue: V) => V,
-  ) {
-    return RefSubject.update(
-      ref,
-      (r) => Record.union(r, that, combine ?? ((_, b) => b)) as Record.ReadonlyRecord<K, V>,
-    );
-  },
-);
-
-/**
- * Intersection with another record.
- * @since 1.18.0
- * @category combinators
- */
-export const intersection: {
-  <K extends string, V>(
-    that: Record.ReadonlyRecord<K, V>,
-    combine?: (selfValue: V, thatValue: V) => V,
-  ): <E, R>(ref: RefRecord<K, V, E, R>) => Effect.Effect<Record.ReadonlyRecord<K, V>, E, R>;
-  <K extends string, V, E, R>(
-    ref: RefRecord<K, V, E, R>,
-    that: Record.ReadonlyRecord<K, V>,
-    combine?: (selfValue: V, thatValue: V) => V,
-  ): Effect.Effect<Record.ReadonlyRecord<K, V>, E, R>;
-} = dual(
-  (args) => RefSubject.isRefSubject(args[0]),
-  function intersection<K extends string, V, E, R>(
-    ref: RefRecord<K, V, E, R>,
-    that: Record.ReadonlyRecord<K, V>,
-    combine?: (selfValue: V, thatValue: V) => V,
-  ) {
-    return RefSubject.update(
-      ref,
-      (r) => Record.intersection(r, that, combine ?? ((_, b) => b)) as Record.ReadonlyRecord<K, V>,
-    );
-  },
-);
-
-/**
- * Difference with another record.
- * @since 1.18.0
- * @category combinators
- */
-export const difference: {
-  <K extends string, V>(
-    that: Record.ReadonlyRecord<K, V>,
-  ): <E, R>(ref: RefRecord<K, V, E, R>) => Effect.Effect<Record.ReadonlyRecord<K, V>, E, R>;
-  <K extends string, V, E, R>(
-    ref: RefRecord<K, V, E, R>,
-    that: Record.ReadonlyRecord<K, V>,
-  ): Effect.Effect<Record.ReadonlyRecord<K, V>, E, R>;
-} = dual(2, function difference<
-  K extends string,
-  V,
-  E,
-  R,
->(ref: RefRecord<K, V, E, R>, that: Record.ReadonlyRecord<K, V>) {
-  return RefSubject.update(ref, (r) => Record.difference(r, that) as Record.ReadonlyRecord<K, V>);
-});
-
-/**
- * Filter entries in place.
- * @since 1.18.0
- * @category combinators
- */
-export const filter: {
-  <K extends string, V>(
-    predicate: (value: V, key: K) => boolean,
-  ): <E, R>(ref: RefRecord<K, V, E, R>) => Effect.Effect<Record.ReadonlyRecord<K, V>, E, R>;
-  <K extends string, V, E, R>(
-    ref: RefRecord<K, V, E, R>,
-    predicate: (value: V, key: K) => boolean,
-  ): Effect.Effect<Record.ReadonlyRecord<K, V>, E, R>;
-} = dual(2, function filter<
-  K extends string,
-  V,
-  E,
-  R,
->(ref: RefRecord<K, V, E, R>, predicate: (value: V, key: K) => boolean) {
-  return RefSubject.update(ref, (r) => Record.filter(r, predicate) as Record.ReadonlyRecord<K, V>);
-});
-
-/**
- * Map values in place (endomorphic).
- * @since 1.18.0
- * @category combinators
- */
-export const map: {
-  <K extends string, V>(
-    f: (value: V, key: K) => V,
-  ): <E, R>(ref: RefRecord<K, V, E, R>) => Effect.Effect<Record.ReadonlyRecord<K, V>, E, R>;
-  <K extends string, V, E, R>(
-    ref: RefRecord<K, V, E, R>,
-    f: (value: V, key: K) => V,
-  ): Effect.Effect<Record.ReadonlyRecord<K, V>, E, R>;
-} = dual(2, function map<
-  K extends string,
-  V,
-  E,
-  R,
->(ref: RefRecord<K, V, E, R>, f: (value: V, key: K) => V) {
-  return RefSubject.update(ref, (r) => Record.map(r, f) as Record.ReadonlyRecord<K, V>);
-});
-
-// ========================================
-// Computed
-// ========================================
-
-/**
- * Get the current size of the Record.
- * @since 1.18.0
- * @category computed
- */
-export const size = <K extends string, V, E, R>(
-  ref: RefRecord<K, V, E, R>,
-): RefSubject.Computed<number, E, R> => RefSubject.map(ref, Record.size);
-
-/**
- * Check if the Record is empty.
- * @since 1.18.0
- * @category computed
- */
-export const isEmpty = <K extends string, V, E, R>(
-  ref: RefRecord<K, V, E, R>,
-): RefSubject.Computed<boolean, E, R> => RefSubject.map(ref, Record.isEmptyRecord);
-
-/**
- * Check if the Record is non-empty.
- * @since 1.18.0
- * @category computed
- */
-export const isNonEmpty = <K extends string, V, E, R>(
-  ref: RefRecord<K, V, E, R>,
-): RefSubject.Computed<boolean, E, R> => RefSubject.map(ref, (r) => !Record.isEmptyRecord(r));
-
-/**
- * Check if a key exists in the Record.
- * @since 1.18.0
- * @category computed
- */
-export const has: {
-  <K extends string>(
-    key: K,
-  ): <V, E, R>(ref: RefRecord<K, V, E, R>) => RefSubject.Computed<boolean, E, R>;
-  <K extends string, V, E, R>(
-    ref: RefRecord<K, V, E, R>,
-    key: K,
-  ): RefSubject.Computed<boolean, E, R>;
-} = dual(2, function has<K extends string, V, E, R>(ref: RefRecord<K, V, E, R>, key: K) {
-  return RefSubject.map(ref, Record.has(key));
-});
-
-/**
- * Get all keys from the Record.
- * @since 1.18.0
- * @category computed
- */
-export const keys = <K extends string, V, E, R>(
-  ref: RefRecord<K, V, E, R>,
-): RefSubject.Computed<Array<K>, E, R> =>
-  RefSubject.map(ref, Record.keys) as RefSubject.Computed<Array<K>, E, R>;
-
-/**
- * Get all values from the Record.
- * @since 1.18.0
- * @category computed
- */
-export const values = <K extends string, V, E, R>(
-  ref: RefRecord<K, V, E, R>,
-): RefSubject.Computed<Array<V>, E, R> => RefSubject.map(ref, Record.values);
-
-/**
- * Get all entries from the Record.
- * @since 1.18.0
- * @category computed
- */
-export const entries = <K extends string, V, E, R>(
-  ref: RefRecord<K, V, E, R>,
-): RefSubject.Computed<Array<[K, V]>, E, R> => RefSubject.map(ref, Record.toEntries);
-
-/**
- * Map values to a different type.
- * @since 1.18.0
- * @category computed
- */
-export const mapValues: {
-  <K extends string, V, B>(
-    f: (value: V, key: K) => B,
-  ): <E, R>(ref: RefRecord<K, V, E, R>) => RefSubject.Computed<Record.ReadonlyRecord<K, B>, E, R>;
-  <K extends string, V, E, R, B>(
-    ref: RefRecord<K, V, E, R>,
-    f: (value: V, key: K) => B,
-  ): RefSubject.Computed<Record.ReadonlyRecord<K, B>, E, R>;
-} = dual(2, function mapValues<
-  K extends string,
-  V,
-  E,
-  R,
-  B,
->(ref: RefRecord<K, V, E, R>, f: (value: V, key: K) => B) {
-  return RefSubject.map(ref, (r) => Record.map(r, f) as Record.ReadonlyRecord<K, B>);
-});
-
-/**
- * Map keys to different keys.
- * @since 1.18.0
- * @category computed
- */
-export const mapKeys: {
-  <K extends string, K2 extends string>(
-    f: (key: K) => K2,
-  ): <V, E, R>(
-    ref: RefRecord<K, V, E, R>,
-  ) => RefSubject.Computed<Record.ReadonlyRecord<K2, V>, E, R>;
-  <K extends string, V, E, R, K2 extends string>(
-    ref: RefRecord<K, V, E, R>,
-    f: (key: K) => K2,
-  ): RefSubject.Computed<Record.ReadonlyRecord<K2, V>, E, R>;
-} = dual(2, function mapKeys<
-  K extends string,
-  V,
-  E,
-  R,
-  K2 extends string,
->(ref: RefRecord<K, V, E, R>, f: (key: K) => K2) {
-  return RefSubject.map(ref, (r) => Record.mapKeys(r, f) as Record.ReadonlyRecord<K2, V>);
-});
-
-/**
- * Map entries to new key-value pairs.
- * @since 1.18.0
- * @category computed
- */
-export const mapEntries: {
-  <K extends string, V, K2 extends string, B>(
-    f: (value: V, key: K) => [K2, B],
-  ): <E, R>(ref: RefRecord<K, V, E, R>) => RefSubject.Computed<Record.ReadonlyRecord<K2, B>, E, R>;
-  <K extends string, V, E, R, K2 extends string, B>(
-    ref: RefRecord<K, V, E, R>,
-    f: (value: V, key: K) => [K2, B],
-  ): RefSubject.Computed<Record.ReadonlyRecord<K2, B>, E, R>;
-} = dual(2, function mapEntries<
-  K extends string,
-  V,
-  E,
-  R,
-  K2 extends string,
-  B,
->(ref: RefRecord<K, V, E, R>, f: (value: V, key: K) => [K2, B]) {
-  return RefSubject.map(ref, (r) => Record.mapEntries(r, f) as Record.ReadonlyRecord<K2, B>);
-});
-
-/**
- * Filter entries creating a Computed value.
- * @since 1.18.0
- * @category computed
- */
-export const filterValues: {
-  <K extends string, V>(
-    predicate: (value: V, key: K) => boolean,
-  ): <E, R>(ref: RefRecord<K, V, E, R>) => RefSubject.Computed<Record.ReadonlyRecord<K, V>, E, R>;
-  <K extends string, V, E, R>(
-    ref: RefRecord<K, V, E, R>,
-    predicate: (value: V, key: K) => boolean,
-  ): RefSubject.Computed<Record.ReadonlyRecord<K, V>, E, R>;
-} = dual(2, function filterValues<
-  K extends string,
-  V,
-  E,
-  R,
->(ref: RefRecord<K, V, E, R>, predicate: (value: V, key: K) => boolean) {
-  return RefSubject.map(ref, (r) => Record.filter(r, predicate) as Record.ReadonlyRecord<K, V>);
-});
-
-/**
- * Filter and map values.
- * @since 1.18.0
- * @category computed
- */
-export const filterMapValues: {
-  <K extends string, V, B>(
-    f: (value: V, key: K) => Option.Option<B>,
-  ): <E, R>(ref: RefRecord<K, V, E, R>) => RefSubject.Computed<Record.ReadonlyRecord<K, B>, E, R>;
-  <K extends string, V, E, R, B>(
-    ref: RefRecord<K, V, E, R>,
-    f: (value: V, key: K) => Option.Option<B>,
-  ): RefSubject.Computed<Record.ReadonlyRecord<K, B>, E, R>;
-} = dual(2, function filterMapValues<
-  K extends string,
-  V,
-  E,
-  R,
-  B,
->(ref: RefRecord<K, V, E, R>, f: (value: V, key: K) => Option.Option<B>) {
-  return RefSubject.map(ref, (r) =>
-    Record.filterMap(r, (value, key) =>
-      f(value, key) ? Result.succeed(value) : Result.fail(value),
-    ),
-  );
-});
-
-/**
- * Partition entries.
- * @since 1.18.0
- * @category computed
- */
-export const partition: {
-  <K extends string, V>(
-    predicate: (value: V, key: K) => boolean,
-  ): <E, R>(
-    ref: RefRecord<K, V, E, R>,
-  ) => RefSubject.Computed<[Record.ReadonlyRecord<K, V>, Record.ReadonlyRecord<K, V>], E, R>;
-  <K extends string, V, E, R>(
-    ref: RefRecord<K, V, E, R>,
-    predicate: (value: V, key: K) => boolean,
-  ): RefSubject.Computed<[Record.ReadonlyRecord<K, V>, Record.ReadonlyRecord<K, V>], E, R>;
-} = dual(2, function partition<
-  K extends string,
-  V,
-  E,
-  R,
->(ref: RefRecord<K, V, E, R>, predicate: (value: V, key: K) => boolean) {
-  return RefSubject.map(
-    ref,
-    (r) =>
-      Record.partition(r, (value, key) =>
-        predicate(value, key) ? Result.succeed(value) : Result.fail(value),
-      ) as [Record.ReadonlyRecord<K, V>, Record.ReadonlyRecord<K, V>],
-  );
-});
-
-/**
- * Check if any entry satisfies a predicate.
- * @since 1.18.0
- * @category computed
- */
-export const some: {
-  <K extends string, V>(
-    predicate: (value: V, key: K) => boolean,
-  ): <E, R>(ref: RefRecord<K, V, E, R>) => RefSubject.Computed<boolean, E, R>;
-  <K extends string, V, E, R>(
-    ref: RefRecord<K, V, E, R>,
-    predicate: (value: V, key: K) => boolean,
-  ): RefSubject.Computed<boolean, E, R>;
-} = dual(2, function some<
-  K extends string,
-  V,
-  E,
-  R,
->(ref: RefRecord<K, V, E, R>, predicate: (value: V, key: K) => boolean) {
-  return RefSubject.map(ref, Record.some(predicate));
-});
-
-/**
- * Check if all entries satisfy a predicate.
- * @since 1.18.0
- * @category computed
- */
-export const every: {
-  <K extends string, V>(
-    predicate: (value: V, key: K) => boolean,
-  ): <E, R>(ref: RefRecord<K, V, E, R>) => RefSubject.Computed<boolean, E, R>;
-  <K extends string, V, E, R>(
-    ref: RefRecord<K, V, E, R>,
-    predicate: (value: V, key: K) => boolean,
-  ): RefSubject.Computed<boolean, E, R>;
-} = dual(2, function every<
-  K extends string,
-  V,
-  E,
-  R,
->(ref: RefRecord<K, V, E, R>, predicate: (value: V, key: K) => boolean) {
-  return RefSubject.map(ref, Record.every(predicate));
-});
-
-/**
- * Reduce the entries to a single value.
- * @since 1.18.0
- * @category computed
- */
-export const reduce: {
-  <K extends string, V, B>(
-    b: B,
-    f: (b: B, value: V, key: K) => B,
-  ): <E, R>(ref: RefRecord<K, V, E, R>) => RefSubject.Computed<B, E, R>;
-  <K extends string, V, E, R, B>(
-    ref: RefRecord<K, V, E, R>,
-    b: B,
-    f: (b: B, value: V, key: K) => B,
-  ): RefSubject.Computed<B, E, R>;
-} = dual(3, function reduce<
-  K extends string,
-  V,
-  E,
-  R,
-  B,
->(ref: RefRecord<K, V, E, R>, b: B, f: (b: B, value: V, key: K) => B) {
-  return RefSubject.map(ref, Record.reduce(b, f));
-});
-
-// ========================================
-// Filtered
-// ========================================
-
-/**
- * Get the value at a key as a Filtered.
- * @since 1.18.0
- * @category filtered
- */
-export const get: {
-  <K extends string>(key: K): <V, E, R>(ref: RefRecord<K, V, E, R>) => RefSubject.Filtered<V, E, R>;
-  <K extends string, V, E, R>(ref: RefRecord<K, V, E, R>, key: K): RefSubject.Filtered<V, E, R>;
-} = dual(2, function get<K extends string, V, E, R>(ref: RefRecord<K, V, E, R>, key: K) {
-  return RefSubject.filterMap(ref, Record.get(key));
-});
-
-/**
- * Find the first entry satisfying a predicate.
- * @since 1.18.0
- * @category filtered
- */
-export const findFirst: {
-  <K extends string, V>(
-    predicate: (value: V, key: K) => boolean,
-  ): <E, R>(ref: RefRecord<K, V, E, R>) => RefSubject.Filtered<[K, V], E, R>;
-  <K extends string, V, E, R>(
-    ref: RefRecord<K, V, E, R>,
-    predicate: (value: V, key: K) => boolean,
-  ): RefSubject.Filtered<[K, V], E, R>;
-} = dual(2, function findFirst<
-  K extends string,
-  V,
-  E,
-  R,
->(ref: RefRecord<K, V, E, R>, predicate: (value: V, key: K) => boolean) {
-  return RefSubject.filterMap(ref, (r) => Record.findFirst(r, predicate));
-});
-
-/**
- * Pop a value at a key as a Filtered.
- * @since 1.18.0
- * @category filtered
- */
-export const pop: {
-  <K extends string>(
-    key: K,
-  ): <V, E, R>(
-    ref: RefRecord<K, V, E, R>,
-  ) => RefSubject.Filtered<[V, Record.ReadonlyRecord<K, V>], E, R>;
-  <K extends string, V, E, R>(
-    ref: RefRecord<K, V, E, R>,
-    key: K,
-  ): RefSubject.Filtered<[V, Record.ReadonlyRecord<K, V>], E, R>;
-} = dual(2, function pop<K extends string, V, E, R>(ref: RefRecord<K, V, E, R>, key: K) {
-  return RefSubject.filterMap(ref, (r) => {
-    return Option.map(
-      Record.pop(r, key),
-      ([value, next]) =>
-        [value, next as Record.ReadonlyRecord<K, V>] as [V, Record.ReadonlyRecord<K, V>],
-    );
-  });
-});

package/src/RefSubject/RefResult.test.ts

@@ -1,63 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { Effect } from "effect";
-import * as Result from "effect/Result";
-import * as RefResult from "./RefResult.js";
-
-describe("RefResult", () => {
-  it("creates and gets value", () =>
-    Effect.gen(function* () {
-      const value = Result.succeed(42);
-      const ref = yield* RefResult.make(value);
-      const current = yield* ref;
-      expect(Result.isSuccess(current)).toBe(true);
-      if (Result.isSuccess(current)) {
-        expect(current.success).toBe(42);
-      }
-    }).pipe(Effect.scoped, Effect.runPromise));
-
-  it("sets Success value", () =>
-    Effect.gen(function* () {
-      const ref = yield* RefResult.make<number, string>(Result.fail("error"));
-      yield* RefResult.setSuccess(ref, 10);
-      const result = yield* ref;
-      expect(Result.isSuccess(result)).toBe(true);
-      if (Result.isSuccess(result)) {
-        expect(result.success).toBe(10);
-      }
-    }).pipe(Effect.scoped, Effect.runPromise));
-
-  it("sets Failure value", () =>
-    Effect.gen(function* () {
-      const ref = yield* RefResult.make<number, string>(Result.succeed(42));
-      yield* RefResult.setFailure(ref, "error");
-      const result = yield* ref;
-      expect(Result.isFailure(result)).toBe(true);
-      if (Result.isFailure(result)) {
-        expect(result.failure).toBe("error");
-      }
-    }).pipe(Effect.scoped, Effect.runPromise));
-
-  it("maps Success value", () =>
-    Effect.gen(function* () {
-      const ref = yield* RefResult.make(Result.succeed(5));
-      const result = yield* RefResult.map(ref, (n) => n * 2);
-      expect(Result.isSuccess(result)).toBe(true);
-      if (Result.isSuccess(result)) {
-        expect(result.success).toBe(10);
-      }
-    }).pipe(Effect.scoped, Effect.runPromise));
-
-  it("checks if Success", () =>
-    Effect.gen(function* () {
-      const ref = yield* RefResult.make(Result.succeed(42));
-      const isSuccess = yield* RefResult.isSuccess(ref);
-      expect(isSuccess).toBe(true);
-    }).pipe(Effect.scoped, Effect.runPromise));
-
-  it("checks if Failure", () =>
-    Effect.gen(function* () {
-      const ref = yield* RefResult.make(Result.fail("error"));
-      const isFailure = yield* RefResult.isFailure(ref);
-      expect(isFailure).toBe(true);
-    }).pipe(Effect.scoped, Effect.runPromise));
-});