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

package/src/Fx/internal/yieldable.ts

@@ -1,31 +0,0 @@
-import * as Effect from "effect/Effect";
-import { identity } from "effect/Function";
-import { pipeArguments } from "effect/Pipeable";
-import type { Sink } from "../../Sink/Sink.js";
-import type * as Fx from "../Fx.js";
-import { FxTypeId } from "../TypeId.js";
-
-const VARIANCE = {
-  _A: identity,
-  _E: identity,
-  _R: identity,
-};
-
-export abstract class YieldableFx<A, E, R, B, E2, R2>
-  extends Effect.YieldableClass<B, E2, R2>
-  implements Fx.Fx<A, E, R>
-{
-  readonly [FxTypeId] = VARIANCE;
-  abstract run<RSink>(sink: Sink<A, E, RSink>): Effect.Effect<unknown, never, R | RSink>;
-  abstract toEffect(): Effect.Effect<B, E2, R2>;
-
-  pipe() {
-    return pipeArguments(this, arguments);
-  }
-
-  // Memoize the effect
-  protected _effect: Effect.Effect<B, E2, R2> | null = null;
-  asEffect(): Effect.Effect<B, E2, R2> {
-    return (this._effect ??= this.toEffect());
-  }
-}

package/src/Fx/run/collect.ts

@@ -1,79 +0,0 @@
-import * as Effect from "effect/Effect";
-import type * as Fiber from "effect/Fiber";
-import { dual } from "effect/Function";
-import { take } from "../combinators/take.js";
-import type { Fx } from "../Fx.js";
-import { observe } from "./observe.js";
-
-/**
- * Collects all values emitted by an `Fx` into an array.
- *
- * @param fx - The `Fx` to collect values from.
- * @returns An `Effect` that produces an array of all values when the `Fx` completes.
- * @since 1.0.0
- * @category runners
- */
-export const collectAll = <A, E = never, R = never>(
-  fx: Fx<A, E, R>,
-): Effect.Effect<ReadonlyArray<A>, E, R> =>
-  Effect.suspend(() => {
-    const values: Array<A> = [];
-
-    return fx.pipe(
-      observe((value) => Effect.sync(() => values.push(value))),
-      (_) => Effect.map(_.asEffect(), () => values),
-    );
-  });
-
-/**
- * Forks the collection of all values from an `Fx`.
- *
- * @param fx - The `Fx` to collect values from.
- * @returns An `Effect` that produces a `Fiber` which computes the array of values.
- * @since 1.0.0
- * @category runners
- */
-export const collectAllFork = <A, E = never, R = never>(
-  fx: Fx<A, E, R>,
-): Effect.Effect<Fiber.Fiber<ReadonlyArray<A>, E>, never, R> =>
-  Effect.forkChild(collectAll(fx), {
-    startImmediately: true,
-    uninterruptible: false,
-  });
-
-/**
- * Collects the first `n` values emitted by an `Fx` into an array.
- *
- * @param fx - The `Fx` to collect values from.
- * @param upTo - The maximum number of values to collect.
- * @returns An `Effect` that produces an array of up to `n` values.
- * @since 1.0.0
- * @category runners
- */
-export const collectUpTo: {
-  (upTo: number): <A, E, R>(fx: Fx<A, E, R>) => Effect.Effect<ReadonlyArray<A>, E, R>;
-
-  <A, E, R>(fx: Fx<A, E, R>, upTo: number): Effect.Effect<ReadonlyArray<A>, E, R>;
-} = dual(
-  2,
-  <A, E, R>(fx: Fx<A, E, R>, upTo: number): Effect.Effect<ReadonlyArray<A>, E, R> =>
-    fx.pipe(take(upTo), collectAll),
-);
-
-/**
- * Forks the collection of up to `n` values from an `Fx`.
- *
- * @param fx - The `Fx` to collect values from.
- * @param upTo - The maximum number of values to collect.
- * @returns An `Effect` that produces a `Fiber` which computes the array of values.
- * @since 1.0.0
- * @category runners
- */
-export const collectUpToFork = <A, E = never, R = never>(
-  fx: Fx<A, E, R>,
-  upTo: number,
-): Effect.Effect<Fiber.Fiber<ReadonlyArray<A>, E>, never, R> =>
-  Effect.forkChild(collectUpTo(fx, upTo), {
-    startImmediately: true,
-    uninterruptible: false,
-  });

package/src/Fx/run/first.ts

@@ -1,20 +0,0 @@
-import { head } from "effect/Array";
-import type { Effect } from "effect/Effect";
-import { map } from "effect/Effect";
-import { pipe } from "effect/Function";
-import type { Option } from "effect/Option";
-import type { Fx } from "../Fx.js";
-import { collectUpTo } from "./collect.js";
-
-/**
- * Returns the first value emitted by the `Fx` wrapped in an `Option`.
- * If the `Fx` is empty, returns `None`.
- *
- * @param fx - The `Fx` stream.
- * @returns An `Effect` that produces `Some(firstValue)` or `None`.
- * @since 1.0.0
- * @category runners
- */
-export function first<A, E, R>(fx: Fx<A, E, R>): Effect<Option<A>, E, R> {
-  return pipe(fx, collectUpTo(1), map(head));
-}

package/src/Fx/run/fork.ts

@@ -1,40 +0,0 @@
-import type { Effect, RunOptions } from "effect/Effect";
-import { forkChild as effectFork, runFork as effectRunFork } from "effect/Effect";
-import type { Fiber } from "effect/Fiber";
-import type { Fx } from "../Fx.js";
-import { drain } from "./observe.js";
-
-/**
- * Forks the execution of an `Fx` into a background fiber.
- * The stream will run until it completes or the fiber is interrupted.
- *
- * @param fx - The `Fx` stream to fork.
- * @param options - Configuration for the forked fiber.
- * @returns An `Effect` that produces a `Fiber`.
- * @since 1.0.0
- * @category runners
- */
-export const fork = <A, E, R>(
-  fx: Fx<A, E, R>,
-  options?: {
-    readonly startImmediately?: boolean;
-    readonly uninterruptible?: boolean;
-  },
-): Effect<Fiber<unknown, E>, never, R> =>
-  effectFork(drain(fx), {
-    startImmediately: options?.startImmediately ?? true,
-    uninterruptible: options?.uninterruptible ?? false,
-  });
-
-/**
- * Runs an `Fx` in a new fiber, using the standard `Effect.runFork`.
- * This is useful for integrating with the top-level Effect runtime.
- *
- * @param fx - The `Fx` stream to run.
- * @param options - `RunOptions` for the execution.
- * @returns The created `Fiber`.
- * @since 1.0.0
- * @category runners
- */
-export const runFork = <A, E>(fx: Fx<A, E>, options?: RunOptions): Fiber<void, E> =>
-  effectRunFork(drain(fx), options);

package/src/Fx/run/index.ts

@@ -1,5 +0,0 @@
-export * from "./collect.js";
-export * from "./first.js";
-export * from "./fork.js";
-export * from "./observe.js";
-export * from "./runPromise.js";

package/src/Fx/run/observe.ts

@@ -1,114 +0,0 @@
-import type { Cause } from "effect/Cause";
-import type { Effect } from "effect/Effect";
-import {
-  callback,
-  catchCause,
-  failCause,
-  forkChild,
-  isEffect,
-  matchCauseEffect,
-  runForkWith,
-  servicesWith,
-  sync,
-  void as void_,
-} from "effect/Effect";
-import { interrupt } from "effect/Fiber";
-import { dual } from "effect/Function";
-import type { Layer } from "effect/Layer";
-import { effectDiscard } from "effect/Layer";
-import type { Scope } from "effect/Scope";
-import { make } from "../../Sink/Sink.js";
-import type { Fx } from "../Fx.js";
-
-/**
- * Observes the values of an `Fx` stream using a callback function.
- * The callback can return `void` or an `Effect` which will be executed for each value.
- *
- * @param fx - The `Fx` stream to observe.
- * @param f - The function to call for each emitted value.
- * @returns An `Effect` that completes when the stream ends.
- * @since 1.0.0
- * @category runners
- */
-export const observe: {
-  <A, E2 = never, R2 = never>(
-    f: (value: A) => void | Effect<unknown, E2, R2>,
-  ): <E, R>(fx: Fx<A, E, R>) => Effect<unknown, E | E2, R | R2>;
-
-  <A, E, R, E2 = never, R2 = never>(
-    fx: Fx<A, E, R>,
-    f: (value: A) => void | Effect<unknown, E2, R2>,
-  ): Effect<unknown, E | E2, R | R2>;
-} = dual(
-  2,
-  <A, E, R, E2 = never, R2 = never>(
-    fx: Fx<A, E, R>,
-    f: (value: A) => void | Effect<unknown, E2, R2>,
-  ): Effect<unknown, E | E2, R | R2> =>
-    servicesWith((services) =>
-      callback<void, E | E2, R | R2>((resume) => {
-        const onFailure = (cause: Cause<E | E2>) => sync(() => resume(failCause(cause)));
-        const onSuccess = (value: A) => {
-          const result = f(value);
-          return isEffect(result) ? catchCause(result, onFailure) : void_;
-        };
-        const onDone = () => sync(() => resume(void_));
-
-        return fx.run(make(onFailure, onSuccess)).pipe(
-          matchCauseEffect(make(onFailure, onDone)),
-          runForkWith(services),
-          interrupt, // Interrupt fiber when callback is interrupted
-        );
-      }),
-    ),
-);
-
-/**
- * Runs an `Fx` stream to completion, discarding all values.
- * Useful when the side effects of the stream are all that matter.
- *
- * @param fx - The `Fx` stream to drain.
- * @returns An `Effect` that completes when the stream ends.
- * @since 1.0.0
- * @category runners
- */
-export const drain = <A, E, R>(fx: Fx<A, E, R>): Effect<void, E, R> => observe(fx, () => void_);
-
-/**
- * Runs an `Fx` stream as a Layer.
- * The stream is forked in the background when the layer is acquired.
- *
- * @param fx - The `Fx` stream to run.
- * @returns A `Layer` that manages the background execution of the stream.
- * @since 1.0.0
- * @category runners
- */
-export const drainLayer = <A, E, R>(fx: Fx<A, E, R>): Layer<never, E, Exclude<R, Scope>> =>
-  effectDiscard(forkChild(drain(fx)));
-
-/**
- * Observes the values of an `Fx` stream using a callback function and returns a `Layer`.
- * The callback can return `void` or an `Effect` which will be executed for each value.
- *
- * @param fx - The `Fx` stream to observe.
- * @param f - The function to call for each emitted value.
- * @returns A `Layer` that manages the background execution of the stream.
- * @since 1.0.0
- * @category runners
- */
-export const observeLayer: {
-  <A, E2 = never, R2 = never>(
-    f: (value: A) => void | Effect<unknown, E2, R2>,
-  ): <E, R>(fx: Fx<A, E, R>) => Layer<never, E | E2, Exclude<R | R2, Scope>>;
-
-  <A, E, R, E2 = never, R2 = never>(
-    fx: Fx<A, E, R>,
-    f: (value: A) => void | Effect<unknown, E2, R2>,
-  ): Layer<never, E | E2, Exclude<R | R2, Scope>>;
-} = dual(
-  2,
-  <A, E, R, E2 = never, R2 = never>(
-    fx: Fx<A, E, R>,
-    f: (value: A) => void | Effect<unknown, E2, R2>,
-  ): Layer<never, E | E2, Exclude<R | R2, Scope>> => effectDiscard(observe(fx, f)),
-);

package/src/Fx/run/runPromise.ts

@@ -1,32 +0,0 @@
-import type { RunOptions } from "effect/Effect";
-import * as Effect from "effect/Effect";
-import type * as Exit from "effect/Exit";
-import type { Fx } from "../Fx.js";
-import { drain } from "./observe.js";
-
-/**
- * Runs an `Fx` stream to completion and returns a Promise of the Exit.
- *
- * @param fx - The `Fx` stream to run.
- * @param options - `RunOptions` for execution.
- * @returns A Promise resolving to the `Exit` of the execution.
- * @since 1.0.0
- * @category runners
- */
-export const runPromiseExit = <A, E>(
-  fx: Fx<A, E>,
-  options?: RunOptions,
-): Promise<Exit.Exit<void, E>> => Effect.runPromiseExit(drain(fx), options);
-
-/**
- * Runs an `Fx` stream to completion and returns a Promise.
- * Rejects if the stream fails.
- *
- * @param fx - The `Fx` stream to run.
- * @param options - `RunOptions` for execution.
- * @returns A Promise that resolves when the stream completes.
- * @since 1.0.0
- * @category runners
- */
-export const runPromise = <A, E>(fx: Fx<A, E>, options?: RunOptions): Promise<unknown> =>
-  Effect.runPromise(drain(fx), options);

package/src/Fx/stream.ts

@@ -1,42 +0,0 @@
-import type * as Effect from "effect/Effect";
-import { pipe } from "effect/Function";
-import * as Queue from "effect/Queue";
-import * as Stream from "effect/Stream";
-import * as Sink from "../Sink/Sink.js";
-import { make } from "./constructors/make.js";
-import type * as Fx from "./Fx.js";
-
-export type ToStreamOptions = Parameters<typeof Stream.callback<unknown, unknown, unknown>>[1];
-
-export const toStream = <A, E, R>(
-  fx: Fx.Fx<A, E, R>,
-  options?: ToStreamOptions,
-): Stream.Stream<A, E, R> =>
-  Stream.callback<A, E, R>(
-    (queue) =>
-      fx.run(
-        Sink.make(
-          (cause) => Queue.failCause(queue, cause),
-          (value) => Queue.offer(queue, value),
-        ),
-      ),
-    options,
-  );
-
-export type FromStreamOptions = Parameters<
-  typeof Stream.mapEffect<unknown, unknown, unknown, unknown>
->[1];
-
-export const fromStream = <A, E, R>(
-  stream: Stream.Stream<A, E, R>,
-  options?: FromStreamOptions,
-): Fx.Fx<A, E, R> =>
-  make<A, E, R>(
-    <RSink = never>(sink: Sink.Sink<A, E, RSink>): Effect.Effect<unknown, never, R | RSink> =>
-      pipe(
-        stream,
-        Stream.mapEffect(sink.onSuccess, options),
-        Stream.catchCause((cause) => Stream.fromEffect(sink.onFailure(cause))),
-        Stream.runDrain,
-      ),
-  );

package/src/Fx.catch.test.ts

@@ -1,61 +0,0 @@
-import assert from "node:assert";
-import { describe, it } from "vitest";
-import { Cause, Data, Effect, Exit } from "effect";
-import { Fx } from "./index.js";
-
-describe("Fx", () => {
-  describe("catch / catchCause / catchTag", () => {
-    class ErrorA extends Data.TaggedError("A") {}
-    class ErrorB extends Data.TaggedError("B") {}
-
-    it("catch recovers from typed failures", () =>
-      Effect.gen(function* () {
-        const fx = Fx.fail("boom").pipe(Fx.catch((e) => Fx.succeed(`recovered:${e}`)));
-
-        const result = yield* Fx.collectAll(fx);
-        assert.deepStrictEqual(result, ["recovered:boom"]);
-      }).pipe(Effect.scoped, Effect.runPromise));
-
-    it("catch does not recover from defects", () =>
-      Effect.gen(function* () {
-        const fx = Fx.die("boom").pipe(Fx.catch(() => Fx.succeed("nope")));
-
-        const exit = yield* Effect.exit(Fx.collectAll(fx));
-        assert(Exit.isFailure(exit));
-        assert(Cause.hasDies(exit.cause));
-      }).pipe(Effect.scoped, Effect.runPromise));
-
-    it("catchCause recovers from defects", () =>
-      Effect.gen(function* () {
-        const fx = Fx.die("boom").pipe(Fx.catchCause(() => Fx.succeed("ok")));
-
-        const result = yield* Fx.collectAll(fx);
-        assert.deepStrictEqual(result, ["ok"]);
-      }).pipe(Effect.scoped, Effect.runPromise));
-
-    it("catchTag recovers from tagged failures", () =>
-      Effect.gen(function* () {
-        const fx = Fx.fail(new ErrorA()).pipe(Fx.catchTag("A", () => Fx.succeed(1)));
-
-        const result = yield* Fx.collectAll(fx);
-        assert.deepStrictEqual(result, [1]);
-      }).pipe(Effect.scoped, Effect.runPromise));
-
-    it("catchTag does not catch other tags", () =>
-      Effect.gen(function* () {
-        const fx = Fx.fail(new ErrorB()).pipe(
-          // @ts-expect-error - invalid tag
-          Fx.catchTag("A", () => Fx.succeed(1)),
-        );
-
-        const exit = yield* Effect.exit(Fx.collectAll(fx));
-        assert(Exit.isFailure(exit));
-        assert.strictEqual(exit.cause.reasons.length, 1);
-
-        const failure = exit.cause.reasons[0];
-        assert(failure._tag === "Fail");
-        // @ts-expect-error - unexpected tag
-        assert.strictEqual(failure.error._tag, "B");
-      }).pipe(Effect.scoped, Effect.runPromise));
-  });
-});

package/src/Fx.fn.test.ts

@@ -1,51 +0,0 @@
-import { assert, describe, it } from "vitest";
-import { Effect } from "effect";
-import { Fx } from "./index.js";
-
-describe("Fx", () => {
-  describe("fn", () => {
-    it("generator returns an Fx", () =>
-      Effect.gen(function* () {
-        const makeFx = Fx.fn(function* (n: number) {
-          const next = yield* Effect.succeed(n + 1);
-          return Fx.succeed(next);
-        });
-
-        const result = yield* Fx.collectAll(makeFx(1));
-        assert.deepStrictEqual(result, [2]);
-      }).pipe(Effect.scoped, Effect.runPromise));
-
-    it("non-generator returns an Fx", () =>
-      Effect.gen(function* () {
-        const makeFx = Fx.fn((n: number) => Fx.succeed(n));
-
-        const result = yield* Fx.collectAll(makeFx(3));
-        assert.deepStrictEqual(result, [3]);
-      }).pipe(Effect.scoped, Effect.runPromise));
-
-    it("named variant supports generator bodies", () =>
-      Effect.gen(function* () {
-        // oxlint-disable-next-line require-yield
-        const makeFx = Fx.fn("Fx.fn (named)")(function* (input: string) {
-          return Fx.succeed(input);
-        });
-
-        const result = yield* Fx.collectAll(makeFx("ok"));
-        assert.deepStrictEqual(result, ["ok"]);
-      }).pipe(Effect.scoped, Effect.runPromise));
-
-    it("pipeables compose over the returned Fx", () =>
-      Effect.gen(function* () {
-        const makeFx = Fx.fn(
-          function* (n: number) {
-            const next = yield* Effect.succeed(n + 1);
-            return Fx.succeed(next);
-          },
-          Fx.map((n) => n * 2),
-        );
-
-        const result = yield* Fx.collectAll(makeFx(1));
-        assert.deepStrictEqual(result, [4]);
-      }).pipe(Effect.scoped, Effect.runPromise));
-  });
-});

package/src/Fx.lifecycle.test.ts

@@ -1,80 +0,0 @@
-import assert from "node:assert";
-import { describe, it } from "vitest";
-import * as Effect from "effect/Effect";
-import * as Exit from "effect/Exit";
-import * as Fiber from "effect/Fiber";
-import * as Ref from "effect/Ref";
-import { Fx } from "./index.js";
-
-describe("Fx", () => {
-  describe("lifecycle hooks", () => {
-    it("onExit runs on success", () =>
-      Effect.gen(function* () {
-        const tag = yield* Ref.make("unset");
-
-        const fx = Fx.fromIterable([1]).pipe(
-          Fx.onExit((exit) => Ref.set(tag, Exit.isSuccess(exit) ? "success" : "failure")),
-        );
-
-        const result = yield* Fx.collectAll(fx);
-        assert.deepStrictEqual(result, [1]);
-        assert.strictEqual(yield* Ref.get(tag), "success");
-      }).pipe(Effect.scoped, Effect.runPromise));
-
-    it("onExit runs on failure", () =>
-      Effect.gen(function* () {
-        const tag = yield* Ref.make("unset");
-
-        const fx = Fx.fail("boom").pipe(
-          Fx.onExit((exit) => Ref.set(tag, Exit.isFailure(exit) ? "failure" : "success")),
-        );
-
-        const exit = yield* Effect.exit(Fx.collectAll(fx));
-        assert(Exit.isFailure(exit));
-        assert.strictEqual(yield* Ref.get(tag), "failure");
-      }).pipe(Effect.scoped, Effect.runPromise));
-
-    it("onInterrupt runs when interrupted", () =>
-      Effect.gen(function* () {
-        const interrupted = yield* Ref.make(false);
-
-        const fiber = yield* Fx.never.pipe(
-          Fx.onInterrupt(() => Ref.set(interrupted, true)),
-          Fx.collectAllFork,
-        );
-
-        yield* Fiber.interrupt(fiber);
-        assert.strictEqual(yield* Ref.get(interrupted), true);
-      }).pipe(Effect.scoped, Effect.runPromise));
-
-    it("onError runs only on failure", () =>
-      Effect.gen(function* () {
-        const count = yield* Ref.make(0);
-
-        yield* Fx.fromIterable([1]).pipe(
-          Fx.onError(() => Ref.update(count, (n) => n + 1)),
-          Fx.collectAll,
-        );
-        assert.strictEqual(yield* Ref.get(count), 0);
-
-        const exit = yield* Effect.exit(
-          Fx.fail("boom").pipe(
-            Fx.onError(() => Ref.update(count, (n) => n + 1)),
-            Fx.collectAll,
-          ),
-        );
-        assert(Exit.isFailure(exit));
-        assert.strictEqual(yield* Ref.get(count), 1);
-      }).pipe(Effect.scoped, Effect.runPromise));
-
-    it("ensuring runs when interrupted", () =>
-      Effect.gen(function* () {
-        const ensured = yield* Ref.make(false);
-
-        const fiber = yield* Fx.never.pipe(Fx.ensuring(Ref.set(ensured, true)), Fx.collectAllFork);
-
-        yield* Fiber.interrupt(fiber);
-        assert.strictEqual(yield* Ref.get(ensured), true);
-      }).pipe(Effect.scoped, Effect.runPromise));
-  });
-});

package/src/Fx.test.ts

@@ -1,71 +0,0 @@
-import { describe, expect, it } from "vitest";
-import * as Effect from "effect/Effect";
-import { Fx, Sink } from "./index.js";
-
-describe("Fx", () => {
-  it("fromIterable", () =>
-    Effect.gen(function* () {
-      const fx = Fx.fromIterable([1, 2, 3]);
-      expect(yield* Fx.collectAll(fx)).toEqual([1, 2, 3]);
-    }).pipe(Effect.scoped, Effect.runPromise));
-
-  it("filter", () =>
-    Effect.gen(function* () {
-      const fx = Fx.fromIterable([1, 2, 3, 4]);
-      const filtered = Fx.filter(fx, (n) => n % 2 === 0);
-      expect(yield* Fx.collectAll(filtered)).toEqual([2, 4]);
-    }).pipe(Effect.scoped, Effect.runPromise));
-
-  it("map", () =>
-    Effect.gen(function* () {
-      const fx = Fx.fromIterable([1, 2, 3]);
-      const mapped = Fx.map(fx, (n) => n * 2);
-      expect(yield* Fx.collectAll(mapped)).toEqual([2, 4, 6]);
-    }).pipe(Effect.scoped, Effect.runPromise));
-
-  it("switchMap", () =>
-    Effect.gen(function* () {
-      const fx = Fx.fromIterable([1, 2, 3]);
-      const switched = Fx.switchMap(fx, (n) => Fx.fromIterable([n, n * 2]));
-      expect(yield* Fx.collectAll(switched)).toEqual([3, 6]);
-    }).pipe(Effect.scoped, Effect.runPromise));
-
-  it("mergeAll", () =>
-    Effect.gen(function* () {
-      const fx1 = Fx.fromIterable([1, 2]);
-      const fx2 = Fx.fromIterable([3, 4]);
-      const merged = Fx.mergeAll(fx1, fx2);
-      const result = yield* Fx.collectAll(merged);
-      expect(result).toEqual([1, 2, 3, 4]);
-    }).pipe(Effect.scoped, Effect.runPromise));
-
-  describe("Service", () => {
-    it("should allow defining an Fx as a Service", () =>
-      Effect.gen(function* () {
-        class MyFx extends Fx.Service<MyFx, number>()("MyFx") {}
-
-        const layer = MyFx.make(Fx.succeed(42));
-
-        const result = yield* Fx.collectAll(MyFx).pipe(Effect.provide(layer));
-        expect(result).toEqual([42]);
-      }).pipe(Effect.scoped, Effect.runPromise));
-  });
-});
-
-describe("Sink", () => {
-  describe("Service", () => {
-    it("should allow defining a Sink as a Service", () =>
-      Effect.gen(function* () {
-        class MySink extends Sink.Service<MySink, number>()("MySink") {}
-
-        let value = 0;
-        const layer = MySink.make(Effect.failCause, (n) => Effect.sync(() => (value += n)));
-
-        yield* MySink.onSuccess(1).pipe(Effect.provide(layer));
-        expect(value).toEqual(1);
-
-        yield* MySink.onSuccess(2).pipe(Effect.provide(layer));
-        expect(value).toEqual(3);
-      }).pipe(Effect.scoped, Effect.runPromise));
-  });
-});

package/src/Fx.ts

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