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

package/src/Sink.reduce-collect-head-last.test.ts

@@ -0,0 +1,107 @@
+import { assert, describe, it } from "vitest";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Ref from "effect/Ref";
+import { Fx, Sink } from "./index.js";
+
+describe("Sink.reduce", () => {
+  it("reduces values with pure function", () =>
+    Effect.gen(function* () {
+      const ref = yield* Ref.make(0);
+      const sink = Sink.reduce(ref, (acc: number, n: number) => acc + n);
+      yield* Fx.fromIterable([1, 2, 3]).run(sink);
+      const result = yield* Ref.get(ref);
+      assert.strictEqual(result, 6);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("uses initial value when no elements", () =>
+    Effect.gen(function* () {
+      const ref = yield* Ref.make(10);
+      const sink = Sink.reduce(ref, (acc: number, n: number) => acc + n);
+      yield* Fx.fromIterable<number>([]).run(sink);
+      const result = yield* Ref.get(ref);
+      assert.strictEqual(result, 10);
+    }).pipe(Effect.scoped, Effect.runPromise));
+});
+
+describe("Sink.reduceEffect", () => {
+  it("reduces values with effectful function", () =>
+    Effect.gen(function* () {
+      const ref = yield* Ref.make(0);
+      const sink = Sink.reduceEffect(ref, (acc: number, n: number) => Effect.succeed(acc + n));
+      yield* Fx.fromIterable([1, 2, 3]).run(sink);
+      const result = yield* Ref.get(ref);
+      assert.strictEqual(result, 6);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("skips step when reducer effect fails, continues with rest", () =>
+    Effect.gen(function* () {
+      const ref = yield* Ref.make(0);
+      const sink = Sink.reduceEffect(ref, (acc: number, n: number) =>
+        n === 2 ? Effect.fail("skip") : Effect.succeed(acc + n),
+      );
+      yield* Fx.fromIterable([1, 2, 3]).run(sink);
+      const result = yield* Ref.get(ref);
+      assert.strictEqual(result, 4);
+    }).pipe(Effect.scoped, Effect.runPromise));
+});
+
+describe("Sink.collect", () => {
+  it("collects all values into array", () =>
+    Effect.gen(function* () {
+      const ref = yield* Ref.make<ReadonlyArray<number>>([]);
+      const sink = Sink.collect(ref);
+      yield* Fx.fromIterable([1, 2, 3]).run(sink);
+      const result = yield* Ref.get(ref);
+      assert.deepStrictEqual(result, [1, 2, 3]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("returns empty array when no elements", () =>
+    Effect.gen(function* () {
+      const ref = yield* Ref.make<ReadonlyArray<number>>([]);
+      const sink = Sink.collect(ref);
+      yield* Fx.fromIterable<number>([]).run(sink);
+      const result = yield* Ref.get(ref);
+      assert.deepStrictEqual(result, []);
+    }).pipe(Effect.scoped, Effect.runPromise));
+});
+
+describe("Sink.head", () => {
+  it("keeps only first value", () =>
+    Effect.gen(function* () {
+      const ref = yield* Ref.make(Option.none<number>());
+      const sink = Sink.head(ref);
+      yield* Fx.fromIterable([1, 2, 3]).run(sink);
+      const result = yield* Ref.get(ref);
+      assert.deepStrictEqual(result, Option.some(1));
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("remains none when no elements", () =>
+    Effect.gen(function* () {
+      const ref = yield* Ref.make(Option.none<number>());
+      const sink = Sink.head(ref);
+      yield* Fx.fromIterable<number>([]).run(sink);
+      const result = yield* Ref.get(ref);
+      assert.deepStrictEqual(result, Option.none());
+    }).pipe(Effect.scoped, Effect.runPromise));
+});
+
+describe("Sink.last", () => {
+  it("keeps only last value", () =>
+    Effect.gen(function* () {
+      const ref = yield* Ref.make(Option.none<number>());
+      const sink = Sink.last(ref);
+      yield* Fx.fromIterable([1, 2, 3]).run(sink);
+      const result = yield* Ref.get(ref);
+      assert.deepStrictEqual(result, Option.some(3));
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("remains none when no elements", () =>
+    Effect.gen(function* () {
+      const ref = yield* Ref.make(Option.none<number>());
+      const sink = Sink.last(ref);
+      yield* Fx.fromIterable<number>([]).run(sink);
+      const result = yield* Ref.get(ref);
+      assert.deepStrictEqual(result, Option.none());
+    }).pipe(Effect.scoped, Effect.runPromise));
+});

package/src/Versioned/Versioned.ts

@@ -17,6 +17,8 @@ import * as Option from "effect/Option";
 import { pipeArguments } from "effect/Pipeable";
 import type * as Scope from "effect/Scope";
 import * as ServiceMap from "effect/ServiceMap";
+import { filterMap as fxFilterMap } from "../Fx/combinators/filterMap.js";
+import { filterMapEffect as fxFilterMapEffect } from "../Fx/combinators/filterMapEffect.js";
 import { map as fxMap } from "../Fx/combinators/map.js";
 import { mapEffect as fxMapEffect } from "../Fx/combinators/mapEffect.js";
 import {
@@ -332,6 +334,80 @@ export const mapEffect: {
   },
 );
 
+/**
+ * Filter-maps a Versioned's output as both an Fx and Effect; the Effect value becomes `Option` (Some when the predicate holds, None otherwise).
+ * @since 1.18.0
+ * @category combinators
+ */
+export const filterMap: {
+  <A, E, R, C, B, D>(options: {
+    onFx: (a: A) => Option.Option<C>;
+    onEffect: (b: B) => Option.Option<D>;
+  }): <R0, E0, R2, E2>(
+    versioned: Versioned<R0, E0, A, E, R, B, E2, R2>,
+  ) => Versioned<never, never, C, E, R, Option.Option<D>, E0 | E2, R0 | R2>;
+
+  <R0, E0, A, E, R, B, E2, R2, C, D>(
+    versioned: Versioned<R0, E0, A, E, R, B, E2, R2>,
+    options: {
+      onFx: (a: A) => Option.Option<C>;
+      onEffect: (b: B) => Option.Option<D>;
+    },
+  ): Versioned<never, never, C, E, R, Option.Option<D>, E0 | E2, R0 | R2>;
+} = dual(
+  2,
+  function filterMap<R0, E0, A, E, R, B, E2, R2, C, D>(
+    versioned: Versioned<R0, E0, A, E, R, B, E2, R2>,
+    options: {
+      onFx: (a: A) => Option.Option<C>;
+      onEffect: (b: B) => Option.Option<D>;
+    },
+  ): Versioned<never, never, C, E, R, Option.Option<D>, E0 | E2, R0 | R2> {
+    return transform(
+      versioned,
+      (fx) => fxFilterMap(fx, options.onFx),
+      (effect) => Effect.map(effect, options.onEffect),
+    );
+  },
+);
+
+/**
+ * Filter-maps a Versioned's output as both an Fx and Effect using an Effect; the Effect value becomes `Option`.
+ * @since 1.18.0
+ * @category combinators
+ */
+export const filterMapEffect: {
+  <A, C, E3, R3, B, D, E4, R4>(options: {
+    onFx: (a: A) => Effect.Effect<Option.Option<C>, E3, R3>;
+    onEffect: (b: B) => Effect.Effect<Option.Option<D>, E4, R4>;
+  }): <R0, E0, R, E, R2, E2>(
+    versioned: Versioned<R0, E0, A, E, R, B, E2, R2>,
+  ) => Versioned<never, never, C, E | E3, R | R3, Option.Option<D>, E0 | E2 | E4, R0 | R2 | R4>;
+
+  <R0, E0, A, E, R, B, E2, R2, C, E3, R3, D, E4, R4>(
+    versioned: Versioned<R0, E0, A, E, R, B, E2, R2>,
+    options: {
+      onFx: (a: A) => Effect.Effect<Option.Option<C>, E3, R3>;
+      onEffect: (b: B) => Effect.Effect<Option.Option<D>, E4, R4>;
+    },
+  ): Versioned<never, never, C, E | E3, R | R3, Option.Option<D>, E0 | E2 | E4, R0 | R2 | R4>;
+} = dual(
+  2,
+  function filterMapEffect<R0, E0, A, E, R, B, E2, R2, C, E3, R3, D, E4, R4>(
+    versioned: Versioned<R0, E0, A, E, R, B, E2, R2>,
+    options: {
+      onFx: (a: A) => Effect.Effect<Option.Option<C>, E3, R3>;
+      onEffect: (b: B) => Effect.Effect<Option.Option<D>, E4, R4>;
+    },
+  ): Versioned<never, never, C, E | E3, R | R3, Option.Option<D>, E0 | E2 | E4, R0 | R2 | R4> {
+    return transform(
+      versioned,
+      (fx) => fxFilterMapEffect(fx, options.onFx),
+      (effect) => Effect.flatMap(effect, options.onEffect),
+    );
+  },
+);
+
 /**
  * Combines multiple Versioned values into a single tuple.
  * @since 1.0.0

package/src/Versioned.filterMap.test.ts

@@ -0,0 +1,91 @@
+import { describe, expect, it } from "vitest";
+import { Effect, Option } from "effect";
+import * as Fx from "./Fx/index.js";
+import * as Versioned from "./Versioned.js";
+
+describe("Versioned filterMap / filterMapEffect", () => {
+  const evenOption = (n: number) => (n % 2 === 0 ? Option.some(n) : Option.none<number>());
+
+  describe("filterMap", () => {
+    it("filters Fx and maps Effect to Option (Some when matched)", () =>
+      Effect.gen(function* () {
+        const v = Versioned.of(8);
+        const filtered = Versioned.filterMap(v, {
+          onFx: evenOption,
+          onEffect: evenOption,
+        });
+        expect(yield* filtered.asEffect()).toEqual(Option.some(8));
+        expect(yield* Fx.collectAll(filtered)).toEqual([8]);
+      }).pipe(Effect.runPromise));
+
+    it("filters Fx and maps Effect to Option (None when not matched)", () =>
+      Effect.gen(function* () {
+        const v = Versioned.of(7);
+        const filtered = Versioned.filterMap(v, {
+          onFx: evenOption,
+          onEffect: evenOption,
+        });
+        expect(yield* filtered.asEffect()).toEqual(Option.none());
+        expect(yield* Fx.collectAll(filtered)).toEqual([]);
+      }).pipe(Effect.runPromise));
+
+    it("supports curried form", () =>
+      Effect.gen(function* () {
+        const filterEven = Versioned.filterMap({
+          onFx: evenOption,
+          onEffect: evenOption,
+        });
+        const v = Versioned.of(10);
+        const filtered = filterEven(v);
+        expect(yield* filtered.asEffect()).toEqual(Option.some(10));
+        expect(yield* Fx.collectAll(filtered)).toEqual([10]);
+      }).pipe(Effect.runPromise));
+
+    it("can map to different types on Fx vs Effect", () =>
+      Effect.gen(function* () {
+        const v = Versioned.of(3);
+        const filtered = Versioned.filterMap(v, {
+          onFx: (n) => (n > 0 ? Option.some(String(n)) : Option.none()),
+          onEffect: (n) => (n > 0 ? Option.some(n + 1) : Option.none()),
+        });
+        expect(yield* filtered.asEffect()).toEqual(Option.some(4));
+        expect(yield* Fx.collectAll(filtered)).toEqual(["3"]);
+      }).pipe(Effect.runPromise));
+  });
+
+  describe("filterMapEffect", () => {
+    it("effectful filterMap on Fx and Effect (Some when matched)", () =>
+      Effect.gen(function* () {
+        const v = Versioned.of(4);
+        const filtered = Versioned.filterMapEffect(v, {
+          onFx: (n) => Effect.succeed(evenOption(n)),
+          onEffect: (n) => Effect.succeed(evenOption(n)),
+        });
+        expect(yield* filtered.asEffect()).toEqual(Option.some(4));
+        expect(yield* Fx.collectAll(filtered)).toEqual([4]);
+      }).pipe(Effect.runPromise));
+
+    it("effectful filterMap (None when not matched)", () =>
+      Effect.gen(function* () {
+        const v = Versioned.of(5);
+        const filtered = Versioned.filterMapEffect(v, {
+          onFx: (n) => Effect.succeed(evenOption(n)),
+          onEffect: (n) => Effect.succeed(evenOption(n)),
+        });
+        expect(yield* filtered.asEffect()).toEqual(Option.none());
+        expect(yield* Fx.collectAll(filtered)).toEqual([]);
+      }).pipe(Effect.runPromise));
+
+    it("supports curried form", () =>
+      Effect.gen(function* () {
+        const filterEven = Versioned.filterMapEffect({
+          onFx: (n: number) => Effect.succeed(evenOption(n)),
+          onEffect: (n: number) => Effect.succeed(evenOption(n)),
+        });
+        const v = Versioned.of(6);
+        const filtered = filterEven(v);
+        expect(yield* filtered.asEffect()).toEqual(Option.some(6));
+        expect(yield* Fx.collectAll(filtered)).toEqual([6]);
+      }).pipe(Effect.runPromise));
+  });
+});

package/tsconfig.json

@@ -1,6 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": { "rootDir": "src", "outDir": "dist" },
-  "include": ["src"],
-  "exclude": ["**/*.test.ts"]
-}