@typed/fx 1.31.0 → 2.0.0-beta.0

package/src/Fx/internal/yieldable.ts

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

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

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

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

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

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

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

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

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

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

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

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