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

package/src/Fx.catch.test.ts

@@ -1,60 +0,0 @@
-import { assert, describe, it } from "vitest";
-import { Cause, Data, Effect, Exit } from "effect";
-import { Fx } from "./index.js";
-
-describe("Fx", () => {
-  describe("catch / catchCause / catchTag", () => {
-    class ErrorA extends Data.TaggedError("A") {}
-    class ErrorB extends Data.TaggedError("B") {}
-
-    it("catch recovers from typed failures", () =>
-      Effect.gen(function* () {
-        const fx = Fx.fail("boom").pipe(Fx.catch((e) => Fx.succeed(`recovered:${e}`)));
-
-        const result = yield* Fx.collectAll(fx);
-        assert.deepStrictEqual(result, ["recovered:boom"]);
-      }).pipe(Effect.scoped, Effect.runPromise));
-
-    it("catch does not recover from defects", () =>
-      Effect.gen(function* () {
-        const fx = Fx.die("boom").pipe(Fx.catch(() => Fx.succeed("nope")));
-
-        const exit = yield* Effect.exit(Fx.collectAll(fx));
-        assert(Exit.isFailure(exit));
-        assert(Cause.hasDies(exit.cause));
-      }).pipe(Effect.scoped, Effect.runPromise));
-
-    it("catchCause recovers from defects", () =>
-      Effect.gen(function* () {
-        const fx = Fx.die("boom").pipe(Fx.catchCause(() => Fx.succeed("ok")));
-
-        const result = yield* Fx.collectAll(fx);
-        assert.deepStrictEqual(result, ["ok"]);
-      }).pipe(Effect.scoped, Effect.runPromise));
-
-    it("catchTag recovers from tagged failures", () =>
-      Effect.gen(function* () {
-        const fx = Fx.fail(new ErrorA()).pipe(Fx.catchTag("A", () => Fx.succeed(1)));
-
-        const result = yield* Fx.collectAll(fx);
-        assert.deepStrictEqual(result, [1]);
-      }).pipe(Effect.scoped, Effect.runPromise));
-
-    it("catchTag does not catch other tags", () =>
-      Effect.gen(function* () {
-        const fx = Fx.fail(new ErrorB()).pipe(
-          // @ts-expect-error - invalid tag
-          Fx.catchTag("A", () => Fx.succeed(1)),
-        );
-
-        const exit = yield* Effect.exit(Fx.collectAll(fx));
-        assert(Exit.isFailure(exit));
-        assert.strictEqual(exit.cause.reasons.length, 1);
-
-        const failure = exit.cause.reasons[0];
-        assert(failure._tag === "Fail");
-        // @ts-expect-error - unexpected tag
-        assert.strictEqual(failure.error._tag, "B");
-      }).pipe(Effect.scoped, Effect.runPromise));
-  });
-});

package/src/Fx.dropUntil.test.ts

@@ -1,61 +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 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.fn.test.ts

@@ -1,51 +0,0 @@
-import { assert, describe, it } from "vitest";
-import { Effect } from "effect";
-import { Fx } from "./index.js";
-
-describe("Fx", () => {
-  describe("fn", () => {
-    it("generator returns an Fx", () =>
-      Effect.gen(function* () {
-        const makeFx = Fx.fn(function* (n: number) {
-          const next = yield* Effect.succeed(n + 1);
-          return Fx.succeed(next);
-        });
-
-        const result = yield* Fx.collectAll(makeFx(1));
-        assert.deepStrictEqual(result, [2]);
-      }).pipe(Effect.scoped, Effect.runPromise));
-
-    it("non-generator returns an Fx", () =>
-      Effect.gen(function* () {
-        const makeFx = Fx.fn((n: number) => Fx.succeed(n));
-
-        const result = yield* Fx.collectAll(makeFx(3));
-        assert.deepStrictEqual(result, [3]);
-      }).pipe(Effect.scoped, Effect.runPromise));
-
-    it("named variant supports generator bodies", () =>
-      Effect.gen(function* () {
-        // oxlint-disable-next-line require-yield
-        const makeFx = Fx.fn("Fx.fn (named)")(function* (input: string) {
-          return Fx.succeed(input);
-        });
-
-        const result = yield* Fx.collectAll(makeFx("ok"));
-        assert.deepStrictEqual(result, ["ok"]);
-      }).pipe(Effect.scoped, Effect.runPromise));
-
-    it("pipeables compose over the returned Fx", () =>
-      Effect.gen(function* () {
-        const makeFx = Fx.fn(
-          function* (n: number) {
-            const next = yield* Effect.succeed(n + 1);
-            return Fx.succeed(next);
-          },
-          Fx.map((n) => n * 2),
-        );
-
-        const result = yield* Fx.collectAll(makeFx(1));
-        assert.deepStrictEqual(result, [4]);
-      }).pipe(Effect.scoped, Effect.runPromise));
-  });
-});

package/src/Fx.lifecycle.test.ts

@@ -1,79 +0,0 @@
-import { assert, describe, it } from "vitest";
-import * as Effect from "effect/Effect";
-import * as Exit from "effect/Exit";
-import * as Fiber from "effect/Fiber";
-import * as Ref from "effect/Ref";
-import { Fx } from "./index.js";
-
-describe("Fx", () => {
-  describe("lifecycle hooks", () => {
-    it("onExit runs on success", () =>
-      Effect.gen(function* () {
-        const tag = yield* Ref.make("unset");
-
-        const fx = Fx.fromIterable([1]).pipe(
-          Fx.onExit((exit) => Ref.set(tag, Exit.isSuccess(exit) ? "success" : "failure")),
-        );
-
-        const result = yield* Fx.collectAll(fx);
-        assert.deepStrictEqual(result, [1]);
-        assert.strictEqual(yield* Ref.get(tag), "success");
-      }).pipe(Effect.scoped, Effect.runPromise));
-
-    it("onExit runs on failure", () =>
-      Effect.gen(function* () {
-        const tag = yield* Ref.make("unset");
-
-        const fx = Fx.fail("boom").pipe(
-          Fx.onExit((exit) => Ref.set(tag, Exit.isFailure(exit) ? "failure" : "success")),
-        );
-
-        const exit = yield* Effect.exit(Fx.collectAll(fx));
-        assert(Exit.isFailure(exit));
-        assert.strictEqual(yield* Ref.get(tag), "failure");
-      }).pipe(Effect.scoped, Effect.runPromise));
-
-    it("onInterrupt runs when interrupted", () =>
-      Effect.gen(function* () {
-        const interrupted = yield* Ref.make(false);
-
-        const fiber = yield* Fx.never.pipe(
-          Fx.onInterrupt(() => Ref.set(interrupted, true)),
-          Fx.collectAllFork,
-        );
-
-        yield* Fiber.interrupt(fiber);
-        assert.strictEqual(yield* Ref.get(interrupted), true);
-      }).pipe(Effect.scoped, Effect.runPromise));
-
-    it("onError runs only on failure", () =>
-      Effect.gen(function* () {
-        const count = yield* Ref.make(0);
-
-        yield* Fx.fromIterable([1]).pipe(
-          Fx.onError(() => Ref.update(count, (n) => n + 1)),
-          Fx.collectAll,
-        );
-        assert.strictEqual(yield* Ref.get(count), 0);
-
-        const exit = yield* Effect.exit(
-          Fx.fail("boom").pipe(
-            Fx.onError(() => Ref.update(count, (n) => n + 1)),
-            Fx.collectAll,
-          ),
-        );
-        assert(Exit.isFailure(exit));
-        assert.strictEqual(yield* Ref.get(count), 1);
-      }).pipe(Effect.scoped, Effect.runPromise));
-
-    it("ensuring runs when interrupted", () =>
-      Effect.gen(function* () {
-        const ensured = yield* Ref.make(false);
-
-        const fiber = yield* Fx.never.pipe(Fx.ensuring(Ref.set(ensured, true)), Fx.collectAllFork);
-
-        yield* Fiber.interrupt(fiber);
-        assert.strictEqual(yield* Ref.get(ensured), true);
-      }).pipe(Effect.scoped, Effect.runPromise));
-  });
-});

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

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

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

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

@@ -1,73 +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";
-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));
-  });
-});