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

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));
+});

package/src/Fx.result-changesWithEffect.test.ts

@@ -0,0 +1,112 @@
+import { assert, describe, it } from "vitest";
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as Result from "effect/Result";
+import { changesWithEffect } from "./Fx/combinators/changesWithEffect.js";
+import { result } from "./Fx/combinators/result.js";
+import { Fx } from "./index.js";
+
+describe("Fx.result", () => {
+  it("materializes success values as Result.succeed", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fromIterable([1, 2, 3]).pipe(result);
+      const collected = yield* Fx.collectAll(fx);
+      assert.strictEqual(collected.length, 3);
+      assert(Result.isSuccess(collected[0]!) && collected[0].success === 1);
+      assert(Result.isSuccess(collected[1]!) && collected[1].success === 2);
+      assert(Result.isSuccess(collected[2]!) && collected[2].success === 3);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("materializes typed failure as Result.fail(Cause)", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fail("err").pipe(result);
+      const collected = yield* Fx.collectAll(fx);
+      assert.strictEqual(collected.length, 1);
+      assert(Result.isFailure(collected[0]!));
+      const cause = collected[0].failure;
+      const failResult = Cause.findFail(cause);
+      assert(failResult._tag === "Success");
+      assert.strictEqual(failResult.success.error, "err");
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("materializes defect as Result.fail(Cause) with die", () =>
+    Effect.gen(function* () {
+      const fx = Fx.die("defect").pipe(result);
+      const collected = yield* Fx.collectAll(fx);
+      assert.strictEqual(collected.length, 1);
+      assert(Result.isFailure(collected[0]!));
+      assert(Cause.hasDies(collected[0].failure));
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("materializes interrupt as Result.fail(Cause) with interrupt", () =>
+    Effect.gen(function* () {
+      const fx = result(Fx.interrupt());
+      const collected = yield* Fx.collectAll(fx);
+      assert.strictEqual(collected.length, 1);
+      assert(Result.isFailure(collected[0]!));
+      assert(Cause.hasInterrupts(collected[0].failure));
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("emits both successes and failures in order", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fromIterable([1, 2])
+        .pipe(Fx.continueWith(() => Fx.fail("e")))
+        .pipe(Fx.continueWith(() => Fx.fromIterable([3])))
+        .pipe(result);
+      const collected = yield* Fx.collectAll(fx);
+      assert.strictEqual(collected.length, 4);
+      assert(Result.isSuccess(collected[0]!) && collected[0].success === 1);
+      assert(Result.isSuccess(collected[1]!) && collected[1].success === 2);
+      assert(Result.isFailure(collected[2]!));
+      assert(Result.isSuccess(collected[3]!) && collected[3].success === 3);
+    }).pipe(Effect.scoped, Effect.runPromise));
+});
+
+describe("Fx.changesWithEffect", () => {
+  it("emits first value and then only when effect returns false (changed)", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fromIterable([1, 2, 2, 3, 3, 3]).pipe(
+        changesWithEffect((prev, next) => Effect.succeed(prev === next)),
+      );
+      const out = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(out, [1, 2, 3]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("emits all when effect always returns false", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fromIterable([1, 2, 3]).pipe(changesWithEffect(() => Effect.succeed(false)));
+      const out = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(out, [1, 2, 3]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("emits only first when effect always returns true after first", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fromIterable([1, 2, 3]).pipe(
+        changesWithEffect((_prev, next) => Effect.succeed(next > 1)),
+      );
+      const out = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(out, [1]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("propagates failure when effect fails", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fromIterable([1, 2]).pipe(
+        changesWithEffect((_prev, next) =>
+          next === 2 ? Effect.fail("err" as const) : Effect.succeed(false),
+        ),
+      );
+      const exit = yield* Effect.exit(Fx.collectAll(fx));
+      assert(exit._tag === "Failure");
+      const fail = Cause.findFail(exit.cause);
+      assert(fail._tag === "Success" && fail.success.error === "err");
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("dual call style: data-first", () =>
+    Effect.gen(function* () {
+      const fx = changesWithEffect(Fx.fromIterable([1, 1, 2, 2]), (a, b) =>
+        Effect.succeed(a === b),
+      );
+      const out = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(out, [1, 2]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+});

package/src/Fx.scan.test.ts

@@ -0,0 +1,73 @@
+import { assert, describe, it } from "vitest";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import { Fx } from "./index.js";
+import { scan, scanEffect } from "./Fx/combinators/scan.js";
+
+describe("Fx scan / scanEffect combinators", () => {
+  describe("scan", () => {
+    it("emits initial then accumulated state (sum)", () =>
+      Effect.gen(function* () {
+        const fx = Fx.fromIterable([1, 2, 3, 4]).pipe(scan(0, (s, a) => s + a));
+        const result = yield* Fx.collectAll(fx);
+        assert.deepStrictEqual(result, [0, 1, 3, 6, 10]);
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("emits initial only when source is empty", () =>
+      Effect.gen(function* () {
+        const fx = Fx.fromIterable<number>([]).pipe(scan(42, (s, a) => s + a));
+        const result = yield* Fx.collectAll(fx);
+        assert.deepStrictEqual(result, [42]);
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("data-last form: pipe(fx, scan(initial, f))", () =>
+      Effect.gen(function* () {
+        const fx = Fx.fromIterable(["a", "b", "c"]).pipe(scan("", (acc, s) => acc + s));
+        const result = yield* Fx.collectAll(fx);
+        assert.deepStrictEqual(result, ["", "a", "ab", "abc"]);
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("data-first form: scan(fx, initial, f)", () =>
+      Effect.gen(function* () {
+        const fx = scan(Fx.fromIterable([2, 3, 4]), 1, (s, a) => s * a);
+        const result = yield* Fx.collectAll(fx);
+        assert.deepStrictEqual(result, [1, 2, 6, 24]);
+      }).pipe(Effect.scoped, Effect.runPromise));
+  });
+
+  describe("scanEffect", () => {
+    it("emits initial then effectfully accumulated state", () =>
+      Effect.gen(function* () {
+        const fx = Fx.fromIterable([1, 2, 3]).pipe(scanEffect(0, (s, a) => Effect.succeed(s + a)));
+        const result = yield* Fx.collectAll(fx);
+        assert.deepStrictEqual(result, [0, 1, 3, 6]);
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("emits initial only when source is empty", () =>
+      Effect.gen(function* () {
+        const fx = Fx.fromIterable<number>([]).pipe(
+          scanEffect(10, (s, a) => Effect.succeed(s + a)),
+        );
+        const result = yield* Fx.collectAll(fx);
+        assert.deepStrictEqual(result, [10]);
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("fails when reducer effect fails", () =>
+      Effect.gen(function* () {
+        const fx = Fx.fromIterable([1, 2, 3]).pipe(
+          scanEffect(0, (s, a) => (a === 2 ? Effect.fail("boom") : Effect.succeed(s + a))),
+        );
+        const exit = yield* Effect.exit(Fx.collectAll(fx));
+        assert(Exit.isFailure(exit));
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("data-first form: scanEffect(fx, initial, f)", () =>
+      Effect.gen(function* () {
+        const fx = scanEffect(Fx.fromIterable([1, 2, 3]), [] as number[], (acc, n) =>
+          Effect.succeed([...acc, n]),
+        );
+        const result = yield* Fx.collectAll(fx);
+        assert.deepStrictEqual(result, [[], [1], [1, 2], [1, 2, 3]]);
+      }).pipe(Effect.scoped, Effect.runPromise));
+  });
+});

package/src/Fx.takeWhile-skipWhile.test.ts

@@ -0,0 +1,84 @@
+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 takeWhile / skipWhile combinators", () => {
+  it("takeWhile emits while predicate is true and excludes first false", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fromIterable([1, 2, 3, 4, 5]).pipe(Fx.takeWhile((n) => n < 4));
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, [1, 2, 3]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("takeWhile emits all when predicate always true", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fromIterable([1, 2, 3]).pipe(Fx.takeWhile(() => true));
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, [1, 2, 3]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("takeWhile emits none when predicate false on first", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fromIterable([1, 2, 3]).pipe(Fx.takeWhile((n) => n > 1));
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, []);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("takeWhileEffect emits while effectful predicate is true", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fromIterable([1, 2, 3, 4]).pipe(
+        Fx.takeWhileEffect((n) => Effect.succeed(n < 3)),
+      );
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, [1, 2]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("takeWhileEffect fails when predicate effect fails", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fromIterable([1, 2, 3]).pipe(
+        Fx.takeWhileEffect((n) => (n === 2 ? Effect.fail("err") : Effect.succeed(true))),
+      );
+      const exit = yield* Effect.exit(Fx.collectAll(fx));
+      assert(Exit.isFailure(exit));
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("skipWhile skips while predicate true and emits from first false", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fromIterable([1, 2, 3, 4, 5]).pipe(Fx.skipWhile((n) => n < 3));
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, [3, 4, 5]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("skipWhile emits all when predicate always false", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fromIterable([1, 2, 3]).pipe(Fx.skipWhile(() => false));
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, [1, 2, 3]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("skipWhile emits none when predicate always true", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fromIterable([1, 2, 3]).pipe(Fx.skipWhile(() => true));
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, []);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("skipWhileEffect skips while effectful predicate is true", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fromIterable([1, 2, 3, 4]).pipe(
+        Fx.skipWhileEffect((n) => Effect.succeed(n < 3)),
+      );
+      const result = yield* Fx.collectAll(fx);
+      assert.deepStrictEqual(result, [3, 4]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("skipWhileEffect fails when predicate effect fails", () =>
+    Effect.gen(function* () {
+      const fx = Fx.fromIterable([1, 2, 3]).pipe(
+        Fx.skipWhileEffect((n) => (n === 1 ? Effect.fail("err") : Effect.succeed(true))),
+      );
+      const exit = yield* Effect.exit(Fx.collectAll(fx));
+      assert(Exit.isFailure(exit));
+    }).pipe(Effect.scoped, Effect.runPromise));
+});

package/src/Fx.zip-merge-additive.test.ts

@@ -0,0 +1,171 @@
+import { assert, describe, it } from "vitest";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import { mergeLeft, mergeRight, zipLeft, zipRight } from "./Fx/combinators/additive.js";
+import { Fx } from "./index.js";
+
+describe("Fx zip/merge additive combinators", () => {
+  describe("zipLeft", () => {
+    it("emits only left values in lockstep; completes when first completes", () =>
+      Effect.gen(function* () {
+        const left = Fx.fromIterable([1, 2, 3]);
+        const right = Fx.fromIterable(["a", "b", "c", "d"]);
+        const result = yield* Fx.collectAll(zipLeft(left, right));
+        assert.deepStrictEqual(result, [1, 2, 3]);
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("completes when right is shorter (lockstep)", () =>
+      Effect.gen(function* () {
+        const left = Fx.fromIterable([1, 2, 3, 4]);
+        const right = Fx.fromIterable(["a", "b"]);
+        const result = yield* Fx.collectAll(zipLeft(left, right));
+        assert.deepStrictEqual(result, [1, 2]);
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("data-last form: pipe(self, zipLeft(that))", () =>
+      Effect.gen(function* () {
+        const result = yield* Fx.fromIterable([10, 20])
+          .pipe(zipLeft(Fx.fromIterable(["x", "y", "z"])))
+          .pipe(Fx.collectAll);
+        assert.deepStrictEqual(result, [10, 20]);
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("fails when left fails", () =>
+      Effect.gen(function* () {
+        const exit = yield* Effect.exit(
+          Fx.collectAll(zipLeft(Fx.fail("err" as const), Fx.fromIterable([1]))),
+        );
+        assert(Exit.isFailure(exit));
+      }).pipe(Effect.scoped, Effect.runPromise));
+  });
+
+  describe("zipRight", () => {
+    it("emits only right values in lockstep; completes when first completes", () =>
+      Effect.gen(function* () {
+        const left = Fx.fromIterable([1, 2, 3, 4]);
+        const right = Fx.fromIterable(["a", "b", "c"]);
+        const result = yield* Fx.collectAll(zipRight(left, right));
+        assert.deepStrictEqual(result, ["a", "b", "c"]);
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("completes when left is shorter (lockstep)", () =>
+      Effect.gen(function* () {
+        const left = Fx.fromIterable([1, 2]);
+        const right = Fx.fromIterable([10, 20, 30]);
+        const result = yield* Fx.collectAll(zipRight(left, right));
+        assert.deepStrictEqual(result, [10, 20]);
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("data-last form: pipe(self, zipRight(that))", () =>
+      Effect.gen(function* () {
+        const result = yield* Fx.fromIterable([1, 2, 3])
+          .pipe(zipRight(Fx.fromIterable(["a", "b"])))
+          .pipe(Fx.collectAll);
+        assert.deepStrictEqual(result, ["a", "b"]);
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("fails when right fails", () =>
+      Effect.gen(function* () {
+        const exit = yield* Effect.exit(
+          Fx.collectAll(zipRight(Fx.fromIterable([1]), Fx.fail("err" as const))),
+        );
+        assert(Exit.isFailure(exit));
+      }).pipe(Effect.scoped, Effect.runPromise));
+  });
+
+  describe("mergeLeft", () => {
+    it("emits only values from the left stream; both run concurrently", () =>
+      Effect.gen(function* () {
+        const left = Fx.fromIterable([1, 2, 3]);
+        const right = Fx.fromIterable(["a", "b"]);
+        const result = yield* Fx.collectAll(mergeLeft(left, right));
+        assert.strictEqual(result.length, 3);
+        assert.deepStrictEqual(
+          [...result].sort((a, b) => a - b),
+          [1, 2, 3],
+        );
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("completes when both streams complete", () =>
+      Effect.gen(function* () {
+        const left = Fx.fromIterable([1]);
+        const right = Fx.fromIterable([2, 3]);
+        const result = yield* Fx.collectAll(mergeLeft(left, right));
+        assert.deepStrictEqual(result, [1]);
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("emits left values only (order non-deterministic)", () =>
+      Effect.gen(function* () {
+        const left = Fx.fromIterable([10, 20]);
+        const right = Fx.fromIterable([30, 40]);
+        const result = yield* Fx.collectAll(mergeLeft(left, right));
+        assert.strictEqual(result.length, 2);
+        assert.ok(result.every((n) => n === 10 || n === 20));
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("fails when left fails", () =>
+      Effect.gen(function* () {
+        const exit = yield* Effect.exit(
+          Fx.collectAll(mergeLeft(Fx.fail("err" as const), Fx.fromIterable([1]))),
+        );
+        assert(Exit.isFailure(exit));
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("data-last form: pipe(self, mergeLeft(that))", () =>
+      Effect.gen(function* () {
+        const result = yield* Fx.fromIterable([1, 2])
+          .pipe(mergeLeft(Fx.fromIterable(["a", "b", "c"])))
+          .pipe(Fx.collectAll);
+        assert.strictEqual(result.length, 2);
+        assert.deepStrictEqual(
+          [...result].sort((a, b) => a - b),
+          [1, 2],
+        );
+      }).pipe(Effect.scoped, Effect.runPromise));
+  });
+
+  describe("mergeRight", () => {
+    it("emits only values from the right stream; both run concurrently", () =>
+      Effect.gen(function* () {
+        const left = Fx.fromIterable([1, 2]);
+        const right = Fx.fromIterable(["a", "b", "c"]);
+        const result = yield* Fx.collectAll(mergeRight(left, right));
+        assert.strictEqual(result.length, 3);
+        assert.deepStrictEqual([...result].sort(), ["a", "b", "c"]);
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("completes when both streams complete", () =>
+      Effect.gen(function* () {
+        const left = Fx.fromIterable([1, 2]);
+        const right = Fx.fromIterable([3]);
+        const result = yield* Fx.collectAll(mergeRight(left, right));
+        assert.deepStrictEqual(result, [3]);
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("emits right values only (order non-deterministic)", () =>
+      Effect.gen(function* () {
+        const left = Fx.fromIterable([1, 2]);
+        const right = Fx.fromIterable([10, 20]);
+        const result = yield* Fx.collectAll(mergeRight(left, right));
+        assert.strictEqual(result.length, 2);
+        assert.ok(result.every((n) => n === 10 || n === 20));
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("fails when right fails", () =>
+      Effect.gen(function* () {
+        const exit = yield* Effect.exit(
+          Fx.collectAll(mergeRight(Fx.fromIterable([1]), Fx.fail("err" as const))),
+        );
+        assert(Exit.isFailure(exit));
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("data-last form: pipe(self, mergeRight(that))", () =>
+      Effect.gen(function* () {
+        const result = yield* Fx.fromIterable([1, 2, 3])
+          .pipe(mergeRight(Fx.fromIterable(["x", "y"])))
+          .pipe(Fx.collectAll);
+        assert.strictEqual(result.length, 2);
+        assert.deepStrictEqual([...result].sort(), ["x", "y"]);
+      }).pipe(Effect.scoped, Effect.runPromise));
+  });
+});