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

package/src/Fx.additive-combinators.test.ts

@@ -0,0 +1,126 @@
+import { assert, describe, it } from "vitest";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import { concat, merge } from "./Fx/combinators/additive.js";
+import { Fx } from "./index.js";
+
+describe("Fx additive combinators", () => {
+  describe("merge (binary)", () => {
+    it("emits values from both streams and completes when both complete", () =>
+      Effect.gen(function* () {
+        const fx1 = Fx.fromIterable([1, 2]);
+        const fx2 = Fx.fromIterable([3, 4]);
+        const merged = merge(fx1, fx2);
+        const result = yield* Fx.collectAll(merged);
+        assert.strictEqual(result.length, 4);
+        assert.deepStrictEqual(
+          [...result].sort((a, b) => a - b),
+          [1, 2, 3, 4],
+        );
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("completes when both streams are empty", () =>
+      Effect.gen(function* () {
+        const merged = merge(Fx.fromIterable([]), Fx.fromIterable([]));
+        const result = yield* Fx.collectAll(merged);
+        assert.deepStrictEqual(result, []);
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("fails when first stream fails", () =>
+      Effect.gen(function* () {
+        const failFx = Fx.fail("err" as const);
+        const goodFx = Fx.fromIterable([1, 2]);
+        const merged = merge(failFx, goodFx);
+        const exit = yield* Effect.exit(Fx.collectAll(merged));
+        assert(Exit.isFailure(exit));
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("fails when second stream fails", () =>
+      Effect.gen(function* () {
+        const goodFx = Fx.fromIterable([1, 2]);
+        const failFx = Fx.fail("err" as const);
+        const merged = merge(goodFx, failFx);
+        const exit = yield* Effect.exit(Fx.collectAll(merged));
+        assert(Exit.isFailure(exit));
+      }).pipe(Effect.scoped, Effect.runPromise));
+  });
+
+  describe("concat", () => {
+    it("emits first stream then second stream in order", () =>
+      Effect.gen(function* () {
+        const fx1 = Fx.fromIterable([1, 2]);
+        const fx2 = Fx.fromIterable([3, 4]);
+        const concatenated = concat(fx1, fx2);
+        const result = yield* Fx.collectAll(concatenated);
+        assert.deepStrictEqual(result, [1, 2, 3, 4]);
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("completes when second stream completes", () =>
+      Effect.gen(function* () {
+        const concatenated = concat(Fx.fromIterable([1]), Fx.fromIterable([2, 3]));
+        const result = yield* Fx.collectAll(concatenated);
+        assert.deepStrictEqual(result, [1, 2, 3]);
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("fails when first stream fails (second never runs)", () =>
+      Effect.gen(function* () {
+        const concatenated = concat(Fx.fail("err" as const), Fx.fromIterable([1, 2]));
+        const exit = yield* Effect.exit(Fx.collectAll(concatenated));
+        assert(Exit.isFailure(exit));
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("fails when second stream fails after first completed", () =>
+      Effect.gen(function* () {
+        const concatenated = concat(Fx.fromIterable([1, 2]), Fx.fail("err" as const));
+        const exit = yield* Effect.exit(Fx.collectAll(concatenated));
+        assert(Exit.isFailure(exit));
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("completes with first stream only when second is empty", () =>
+      Effect.gen(function* () {
+        const concatenated = concat(Fx.fromIterable([1, 2]), Fx.fromIterable([]));
+        const result = yield* Fx.collectAll(concatenated);
+        assert.deepStrictEqual(result, [1, 2]);
+      }).pipe(Effect.scoped, Effect.runPromise));
+  });
+  it("takeEffect uses count from Effect", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fromIterable([1, 2, 3, 4]).pipe(Fx.takeEffect(Effect.succeed(2)));
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, [1, 2]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("skipEffect uses count from Effect", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fromIterable([1, 2, 3, 4]).pipe(Fx.skipEffect(Effect.succeed(2)));
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, [3, 4]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("sliceEffect uses bounds from Effect", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fromIterable([1, 2, 3, 4]).pipe(
+        Fx.sliceEffect(Effect.succeed({ skip: 1, take: 2 })),
+      );
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, [2, 3]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("takeUntilEffect stops when predicate effect succeeds with true", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fromIterable([1, 2, 3, 4]).pipe(
+        Fx.takeUntilEffect((n) => Effect.succeed(n > 2)),
+      );
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, [1, 2]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("takeUntilEffect fails when predicate effect fails", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fromIterable([1, 2, 3]).pipe(
+        Fx.takeUntilEffect((n) => (n === 2 ? Effect.fail("boom") : Effect.succeed(false))),
+      );
+      const exit = yield* Effect.exit(Fx.collectAll(fx));
+      assert(Exit.isFailure(exit));
+    }).pipe(Effect.scoped, Effect.runPromise));
+});

package/src/Fx.catch-additive.test.ts

@@ -0,0 +1,206 @@
+import { assert, describe, it } from "vitest";
+import * as Cause from "effect/Cause";
+import { Data } from "effect";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Result from "effect/Result";
+import { catchCauseIf, catchIf, catchTags } from "./Fx/combinators/catch.js";
+import { Fx } from "./index.js";
+
+describe("Fx.catchIf", () => {
+  it("recovers when predicate is true (typed failure)", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fail(42).pipe(
+        catchIf(
+          (n: number) => n > 10,
+          (n) => Fx.succeed(`recovered:${n}`),
+        ),
+      );
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, ["recovered:42"]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("does not recover when predicate is false (re-fails)", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fail(3).pipe(
+        catchIf(
+          (n: number) => n > 10,
+          (n) => Fx.succeed(`recovered:${n}`),
+        ),
+      );
+      const exit = yield* Effect.exit(Fx.collectAll(fx));
+      assert(Exit.isFailure(exit));
+      const failResult = Cause.findFail(exit.cause);
+      assert(failResult._tag === "Success");
+      assert.strictEqual(failResult.success.error, 3);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("does not recover from defects (only Fail is considered)", () =>
+    Effect.gen(function* () {
+      const fx = Fx.die("defect").pipe(
+        catchIf(
+          () => true,
+          () => 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("success path is unchanged", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fromIterable([1, 2, 3]).pipe(
+        catchIf(
+          (_: string) => true,
+          () => Fx.succeed(-1),
+        ),
+      );
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, [1, 2, 3]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("dual call style (data-first)", () =>
+    Effect.gen(function* () {
+      const fx = catchIf(
+        Fx.fail("err"),
+        (e: string) => e.length > 0,
+        (e) => Fx.succeed(e.toUpperCase()),
+      );
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, ["ERR"]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+});
+
+describe("Fx.catchCauseIf", () => {
+  it("recovers when predicate is true (e.g. has fails)", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fail("boom").pipe(
+        catchCauseIf(Cause.hasFails, (cause) => {
+          const r = Cause.findFail(cause);
+          const msg = Result.isSuccess(r) ? r.success.error : "?";
+          return Fx.succeed(`recovered:${msg}`);
+        }),
+      );
+      const result = yield* Fx.collectAll(fx);
+      assert.strictEqual(result[0], "recovered:boom");
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("recovers from defects when predicate matches cause", () =>
+    Effect.gen(function* () {
+      const fx = Fx.die("defect").pipe(catchCauseIf(Cause.hasDies, () => Fx.succeed("ok")));
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, ["ok"]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("does not recover when predicate is false", () =>
+    Effect.gen(function* () {
+      const fx = Fx.die("oops").pipe(catchCauseIf(Cause.isEmpty, () => Fx.succeed("no")));
+      const exit = yield* Effect.exit(Fx.collectAll(fx));
+      assert(Exit.isFailure(exit));
+      assert(Cause.hasDies(exit.cause));
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("success path is unchanged", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fromIterable([1, 2]).pipe(
+        catchCauseIf(
+          () => true,
+          () => Fx.succeed(0),
+        ),
+      );
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, [1, 2]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("dual call style (data-first)", () =>
+    Effect.gen(function* () {
+      const fx = catchCauseIf(Fx.fail("x"), Cause.hasFails, (cause) =>
+        Fx.succeed(Result.isSuccess(Cause.findFail(cause)) ? "handled" : "unhandled"),
+      );
+      const result = yield* Fx.collectAll(fx);
+      assert.strictEqual(result[0], "handled");
+    }).pipe(Effect.scoped, Effect.runPromise));
+});
+
+describe("Fx.catchTags", () => {
+  class ErrorA extends Data.TaggedError("A")<{ readonly n: number }> {}
+  class ErrorB extends Data.TaggedError("B")<{ readonly msg: string }> {}
+
+  it("recovers from multiple tagged failures with one call", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fail(new ErrorA({ n: 1 })).pipe(
+        catchTags({
+          A: (e) => Fx.succeed(`A:${e.n}`),
+          B: (e) => Fx.succeed(`B:${e.msg}`),
+        }),
+      );
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, ["A:1"]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("matches second tag when first fails with B", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fail(new ErrorB({ msg: "hello" })).pipe(
+        catchTags({
+          A: (e) => Fx.succeed(`A:${e.n}`),
+          B: (e) => Fx.succeed(`B:${e.msg}`),
+        }),
+      );
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, ["B:hello"]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("does not catch untagged or other tags (re-fails)", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fail("plain").pipe(
+        catchTags({
+          A: () => Fx.succeed(1),
+          B: () => Fx.succeed(2),
+        } as {
+          A: (e: ErrorA) => Fx<number, never, never>;
+          B: (e: ErrorB) => Fx<number, never, never>;
+        }),
+      );
+      const exit = yield* Effect.exit(Fx.collectAll(fx));
+      assert(Exit.isFailure(exit));
+      const failResult = Cause.findFail(exit.cause);
+      assert(failResult._tag === "Success");
+      assert.strictEqual(failResult.success.error, "plain");
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("does not recover from defects (only Fail with _tag)", () =>
+    Effect.gen(function* () {
+      const fx = Fx.die("defect").pipe(
+        catchTags({
+          A: () => Fx.succeed(1),
+          B: () => Fx.succeed(2),
+        }),
+      );
+      const exit = yield* Effect.exit(Fx.collectAll(fx));
+      assert(Exit.isFailure(exit));
+      assert(Cause.hasDies(exit.cause));
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("success path is unchanged", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fromIterable([1, 2, 3]).pipe(
+        catchTags({
+          A: () => Fx.succeed(-1),
+          B: () => Fx.succeed(-2),
+        }),
+      );
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, [1, 2, 3]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("dual call style (data-first)", () =>
+    Effect.gen(function* () {
+      const fx = catchTags(Fx.fail(new ErrorA({ n: 42 })), {
+        A: (e) => Fx.succeed(e.n * 2),
+        B: () => Fx.succeed(0),
+      });
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, [84]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+});

package/src/Fx.catch.test.ts

@@ -1,5 +1,4 @@
-import assert from "node:assert";
-import { describe, it } from "vitest";
+import { assert, describe, it } from "vitest";
 import { Cause, Data, Effect, Exit } from "effect";
 import { Fx } from "./index.js";
 

package/src/Fx.dropUntil.test.ts

@@ -0,0 +1,61 @@
+import { assert, describe, it } from "vitest";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import { Fx } from "./index.js";
+
+describe("Fx dropUntil / dropUntilEffect combinators", () => {
+  it("dropUntil drops until predicate is true and includes first match", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fromIterable([1, 2, 3, 4, 5]).pipe(Fx.dropUntil((n) => n >= 4));
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, [4, 5]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("dropUntil emits all when predicate true on first element", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fromIterable([1, 2, 3]).pipe(Fx.dropUntil(() => true));
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, [1, 2, 3]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("dropUntil emits none when predicate never true", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fromIterable([1, 2, 3]).pipe(Fx.dropUntil(() => false));
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, []);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("dropUntil includes first matching element only once", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fromIterable([1, 2, 3, 4, 5]).pipe(Fx.dropUntil((n) => n === 3));
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, [3, 4, 5]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("dropUntilEffect drops until effectful predicate is true", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fromIterable([1, 2, 3, 4]).pipe(
+        Fx.dropUntilEffect((n) => Effect.succeed(n >= 3)),
+      );
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, [3, 4]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("dropUntilEffect fails when predicate effect fails", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fromIterable([1, 2, 3]).pipe(
+        Fx.dropUntilEffect((n) => (n === 2 ? Effect.fail("err") : Effect.succeed(false))),
+      );
+      const exit = yield* Effect.exit(Fx.collectAll(fx));
+      assert(Exit.isFailure(exit));
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("dropUntilEffect emits from first element when predicate effect succeeds true immediately", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fromIterable([10, 20, 30]).pipe(
+        Fx.dropUntilEffect((n) => Effect.succeed(n > 0)),
+      );
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, [10, 20, 30]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+});

package/src/Fx.lifecycle.test.ts

@@ -1,5 +1,4 @@
-import assert from "node:assert";
-import { describe, it } from "vitest";
+import { assert, describe, it } from "vitest";
 import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";
 import * as Fiber from "effect/Fiber";

package/src/Fx.mapError-mapBoth.test.ts

@@ -0,0 +1,101 @@
+import { assert, describe, it } from "vitest";
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import { Fx } from "./index.js";
+
+describe("Fx.mapError", () => {
+  it("maps typed failure to new error type", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fail("err").pipe(Fx.mapError((s) => ({ msg: s })));
+      const exit = yield* Effect.exit(Fx.collectAll(fx));
+      assert(Exit.isFailure(exit));
+      const result = Cause.findFail(exit.cause);
+      assert(result._tag === "Success");
+      assert.deepStrictEqual(result.success.error, { msg: "err" });
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("dual call style: data-last", () =>
+    Effect.gen(function* () {
+      const fx = Fx.mapError(Fx.fail(42), (n) => `n=${n}`);
+      const exit = yield* Effect.exit(Fx.collectAll(fx));
+      assert(Exit.isFailure(exit));
+      const result = Cause.findFail(exit.cause);
+      assert(result._tag === "Success");
+      assert.strictEqual(result.success.error, "n=42");
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("dual call style: data-first pipe", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fromIterable([1, 2]).pipe(Fx.mapError((e: string) => e.toUpperCase()));
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, [1, 2]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("preserves success values", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fromIterable([1, 2, 3]).pipe(Fx.mapError((e: string) => e));
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, [1, 2, 3]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("defects are not mapped (Cause.map only maps Fail)", () =>
+    Effect.gen(function* () {
+      const fx = Fx.die("defect").pipe(Fx.mapError((_e: string) => "mapped"));
+      const exit = yield* Effect.exit(Fx.collectAll(fx));
+      assert(Exit.isFailure(exit));
+      assert(Cause.hasDies(exit.cause));
+    }).pipe(Effect.scoped, Effect.runPromise));
+});
+
+describe("Fx.mapBoth", () => {
+  it("maps both success and failure channels", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fromIterable([1, 2, 3]).pipe(
+        Fx.mapBoth({
+          onSuccess: (n) => n * 10,
+          onFailure: (e: string) => e.length,
+        }),
+      );
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, [10, 20, 30]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("maps failure when stream fails", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fail("boom").pipe(
+        Fx.mapBoth({
+          onSuccess: (a: number) => a,
+          onFailure: (s: string) => ({ message: s }),
+        }),
+      );
+      const exit = yield* Effect.exit(Fx.collectAll(fx));
+      assert(Exit.isFailure(exit));
+      const result = Cause.findFail(exit.cause);
+      assert(result._tag === "Success");
+      assert.deepStrictEqual(result.success.error, { message: "boom" });
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("dual call style: data-last", () =>
+    Effect.gen(function* () {
+      const fx = Fx.mapBoth(Fx.fromIterable(["a", "b"]), {
+        onSuccess: (s) => s.toUpperCase(),
+        onFailure: (e: number) => String(e),
+      });
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, ["A", "B"]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("preserves defects (onFailure only maps Fail)", () =>
+    Effect.gen(function* () {
+      const fx = Fx.die("oops").pipe(
+        Fx.mapBoth({
+          onSuccess: (a: number) => a,
+          onFailure: (_e: string) => "mapped",
+        }),
+      );
+      const exit = yield* Effect.exit(Fx.collectAll(fx));
+      assert(Exit.isFailure(exit));
+      assert(Cause.hasDies(exit.cause));
+    }).pipe(Effect.scoped, Effect.runPromise));
+});

package/src/Fx.provide-combinators.test.ts

@@ -0,0 +1,94 @@
+import { assert, describe, it } from "vitest";
+import * as Effect from "effect/Effect";
+import { Fx } from "./index.js";
+import * as ServiceMap from "effect/ServiceMap";
+
+const Foo = ServiceMap.Service<{ readonly n: number }>("Test/Foo");
+
+describe("Fx provideService", () => {
+  it("provides a single service and Fx can use it", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fromIterable([1, 2, 3]).pipe(
+        Fx.mapEffect((x) =>
+          Effect.gen(function* () {
+            const foo = yield* Foo;
+            return x + foo.n;
+          }),
+        ),
+        Fx.provideService(Foo, { n: 10 }),
+      );
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, [11, 12, 13]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("provideService(tag, service) curried form", () =>
+    Effect.gen(function* () {
+      const withFoo = Fx.provideService(Foo, { n: 1 });
+      const fx = Fx.fromIterable([0]).pipe(
+        Fx.mapEffect((x) =>
+          Effect.gen(function* () {
+            const f = yield* Foo;
+            return x + f.n;
+          }),
+        ),
+        withFoo,
+      );
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, [1]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+});
+
+describe("Fx provideServiceEffect", () => {
+  it("provides a service from an effect and Fx can use it", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fromIterable([1, 2]).pipe(
+        Fx.mapEffect((x) =>
+          Effect.gen(function* () {
+            const foo = yield* Foo;
+            return x + foo.n;
+          }),
+        ),
+        Fx.provideServiceEffect(Foo, Effect.succeed({ n: 100 })),
+      );
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, [101, 102]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("provideServiceEffect runs the effect when the stream runs (service effect can have requirements)", () =>
+    Effect.gen(function* () {
+      let built = false;
+      const makeFoo = Effect.sync(() => {
+        built = true;
+        return { n: 7 };
+      });
+      const fx = Fx.fromIterable([0]).pipe(
+        Fx.mapEffect((x) =>
+          Effect.gen(function* () {
+            const f = yield* Foo;
+            return x + f.n;
+          }),
+        ),
+        Fx.provideServiceEffect(Foo, makeFoo),
+      );
+      assert.strictEqual(built, false);
+      const result = yield* Fx.collectAll(fx);
+      assert.strictEqual(built, true);
+      assert.deepStrictEqual(result, [7]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("provideServiceEffect(tag, effect) curried form", () =>
+    Effect.gen(function* () {
+      const withFooFromEffect = Fx.provideServiceEffect(Foo, Effect.succeed({ n: 5 }));
+      const fx = Fx.fromIterable([0]).pipe(
+        Fx.mapEffect((x) =>
+          Effect.gen(function* () {
+            const f = yield* Foo;
+            return x + f.n;
+          }),
+        ),
+        withFooFromEffect,
+      );
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, [5]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+});