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

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

package/src/Fx.zip.test.ts

@@ -0,0 +1,133 @@
+import { assert, describe, it } from "vitest";
+import * as Effect from "effect/Effect";
+import { Fx } from "./index.js";
+import * as Sink from "./Sink/index.js";
+
+describe("Fx zip combinators", () => {
+  describe("zip", () => {
+    it("emits pairs when run directly with a sink (no observe)", () =>
+      Effect.gen(function* () {
+        const arr: Array<readonly [number, string]> = [];
+        const sink = Sink.make(
+          () => Effect.void,
+          (pair: readonly [number, string]) => Effect.sync(() => arr.push(pair)),
+        );
+        yield* Fx.zip(Fx.fromIterable([1, 2, 3]), Fx.fromIterable(["a", "b", "c", "d"])).run(sink);
+        assert.deepStrictEqual(arr, [
+          [1, "a"],
+          [2, "b"],
+          [3, "c"],
+        ]);
+      }).pipe(Effect.runPromise));
+
+    it("emits pairs in lockstep; completes when first stream completes", () =>
+      Effect.gen(function* () {
+        const left = Fx.fromIterable([1, 2, 3]);
+        const right = Fx.fromIterable(["a", "b", "c", "d"]);
+        const result = yield* Fx.collectAll(Fx.zip(left, right));
+        assert.deepStrictEqual(result, [
+          [1, "a"],
+          [2, "b"],
+          [3, "c"],
+        ]);
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("completes when right is shorter than left", () =>
+      Effect.gen(function* () {
+        const left = Fx.fromIterable([1, 2, 3, 4]);
+        const right = Fx.fromIterable(["a", "b"]);
+        const result = yield* Fx.collectAll(Fx.zip(left, right));
+        assert.deepStrictEqual(result, [
+          [1, "a"],
+          [2, "b"],
+        ]);
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("data-last form: pipe(self, Fx.zip(that))", () =>
+      Effect.gen(function* () {
+        const result = yield* Fx.fromIterable([1, 2])
+          .pipe(Fx.zip(Fx.fromIterable(["x", "y"])))
+          .pipe(Fx.collectAll);
+        assert.deepStrictEqual(result, [
+          [1, "x"],
+          [2, "y"],
+        ]);
+      }).pipe(Effect.scoped, Effect.runPromise));
+  });
+
+  describe("zipWith", () => {
+    it("emits f(a,b) in lockstep", () =>
+      Effect.gen(function* () {
+        const left = Fx.fromIterable([1, 2, 3]);
+        const right = Fx.fromIterable([10, 20, 30]);
+        const result = yield* Fx.collectAll(Fx.zipWith(left, right, (a, b) => a + b));
+        assert.deepStrictEqual(result, [11, 22, 33]);
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("completes when first stream completes", () =>
+      Effect.gen(function* () {
+        const result = yield* Fx.collectAll(
+          Fx.zipWith(Fx.fromIterable([1, 2, 3]), Fx.fromIterable([0, 0]), (a, b) => a + b),
+        );
+        assert.deepStrictEqual(result, [1, 2]);
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("data-last form: pipe(self, Fx.zipWith(that, f))", () =>
+      Effect.gen(function* () {
+        const result = yield* Fx.fromIterable(["a", "b"])
+          .pipe(Fx.zipWith(Fx.fromIterable([1, 2]), (s, n) => `${s}${n}`))
+          .pipe(Fx.collectAll);
+        assert.deepStrictEqual(result, ["a1", "b2"]);
+      }).pipe(Effect.scoped, Effect.runPromise));
+  });
+
+  describe("zipLatest", () => {
+    it("waits for both to emit once then emits on every update from either", () =>
+      Effect.gen(function* () {
+        const left = Fx.fromIterable([1, 2, 3]);
+        const right = Fx.fromIterable(["a", "b"]);
+        const result = yield* Fx.collectAll(Fx.zipLatest(left, right));
+        // tuple runs both streams; emission order depends on scheduling.
+        assert.ok(result.length >= 2, "at least two emissions");
+        assert.ok(
+          result.some((p) => p[0] === 3 && p[1] === "b"),
+          "should contain [3, 'b']",
+        );
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("data-last form: pipe(self, Fx.zipLatest(that))", () =>
+      Effect.gen(function* () {
+        const result = yield* Fx.fromIterable([1, 2])
+          .pipe(Fx.zipLatest(Fx.fromIterable(["a", "b"])))
+          .pipe(Fx.collectAll);
+        assert.ok(result.length >= 2);
+        assert.deepStrictEqual(result[result.length - 1], [2, "b"]);
+      }).pipe(Effect.scoped, Effect.runPromise));
+  });
+
+  describe("zipLatestWith", () => {
+    it("emits f(left, right) on every update from either stream", () =>
+      Effect.gen(function* () {
+        const result = yield* Fx.collectAll(
+          Fx.zipLatestWith(Fx.fromIterable([1, 2]), Fx.fromIterable([10, 20]), (a, b) => a + b),
+        );
+        assert.ok(result.length >= 2);
+        // First emission depends on which stream fills first (1+10=11 or 2+10=12 or 1+20=21)
+        assert.ok([11, 12, 21, 22].includes(result[0]));
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("data-last form: pipe(self, Fx.zipLatestWith(that, f))", () =>
+      Effect.gen(function* () {
+        const result = yield* Fx.fromIterable([1, 2])
+          .pipe(Fx.zipLatestWith(Fx.fromIterable(["a", "b"]), (n, s) => `${n}${s}`))
+          .pipe(Fx.collectAll);
+        assert.ok(result.length >= 2);
+        // First emission is combined first values; last includes latest from both
+        assert.ok(
+          result.includes("1a") || result.includes("2a") || result.includes("2b"),
+          "should contain a combined pair",
+        );
+        assert.ok(result.includes("2b"), "should contain final pair 2b");
+      }).pipe(Effect.scoped, Effect.runPromise));
+  });
+});