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

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

@@ -1,84 +0,0 @@
-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.test.ts

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

package/src/Fx.ts

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

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

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

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