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

package/src/Push/Push.ts

@@ -8,7 +8,7 @@ import type * as Cause from "effect/Cause";
 import * as Effect from "effect/Effect";
 import { dual, identity } from "effect/Function";
 import * as Layer from "effect/Layer";
-import type * as Option from "effect/Option";
+import * as Option from "effect/Option";
 import { pipeArguments } from "effect/Pipeable";
 import type * as Scope from "effect/Scope";
 import * as ServiceMap from "effect/ServiceMap";
@@ -432,6 +432,68 @@ export const mapEffect: {
   return make(push, Fx.mapEffect(push, f));
 });
 
+/**
+ * Transforms the output (Fx) error channel of a `Push` using the provided function.
+ *
+ * Failures (Cause) are mapped via `Cause.map`, so only the typed failure (`Fail`)
+ * is transformed; defects and interrupts are preserved unchanged.
+ *
+ * Mirrors `Effect.mapError` on the Fx side.
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export const mapError: {
+  <E2, E3>(
+    f: (e: E2) => E3,
+  ): <A, E, R, B, R2>(push: Push<A, E, R, B, E2, R2>) => Push<A, E, R, B, E3, R2>;
+  <A, E, R, B, E2, R2, E3>(
+    push: Push<A, E, R, B, E2, R2>,
+    f: (e: E2) => E3,
+  ): Push<A, E, R, B, E3, R2>;
+} = dual(2, function mapError<
+  A,
+  E,
+  R,
+  B,
+  E2,
+  R2,
+  E3,
+>(push: Push<A, E, R, B, E2, R2>, f: (e: E2) => E3): Push<A, E, R, B, E3, R2> {
+  return make(push, Fx.mapError(push, f));
+});
+
+/**
+ * Transforms both the output (Fx) success and error channels of a `Push` using the provided options.
+ *
+ * Mirrors `Effect.mapBoth` on the Fx side: `onSuccess` maps emitted values,
+ * `onFailure` maps the typed failure (via `Cause.map`); defects and interrupts are preserved.
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export const mapBoth: {
+  <B, C, E2, E3>(options: {
+    readonly onFailure: (e: E2) => E3;
+    readonly onSuccess: (b: B) => C;
+  }): <A, E, R, R2>(push: Push<A, E, R, B, E2, R2>) => Push<A, E, R, C, E3, R2>;
+  <A, E, R, B, E2, R2, C, E3>(
+    push: Push<A, E, R, B, E2, R2>,
+    options: { readonly onFailure: (e: E2) => E3; readonly onSuccess: (b: B) => C },
+  ): Push<A, E, R, C, E3, R2>;
+} = dual(
+  2,
+  function mapBoth<A, E, R, B, E2, R2, C, E3>(
+    push: Push<A, E, R, B, E2, R2>,
+    options: {
+      readonly onFailure: (e: E2) => E3;
+      readonly onSuccess: (b: B) => C;
+    },
+  ): Push<A, E, R, C, E3, R2> {
+    return make(push, Fx.mapBoth(push, options));
+  },
+);
+
 export const filter: {
   <B>(
     f: (b: B) => boolean,
@@ -844,6 +906,113 @@ export const exhaustLatestMapEffect: {
   return make(push, Fx.exhaustLatestMapEffect(push, f));
 });
 
+/**
+ * Maps over the output (Fx) side of a `Push` with an accumulator: for each emitted value `b`,
+ * applies `f(state, b)` to get `[nextState, emitted]` and emits the second element.
+ * The first element is the initial state; subsequent states are updated by each step.
+ *
+ * @param initial - Initial accumulator state.
+ * @param f - Reducer `(state, value) => [nextState, emitted]`.
+ * @returns A `Push` whose Fx side emits the accumulated/mapped values.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const mapAccum: {
+  <S, B, C>(
+    initial: S,
+    f: (s: S, b: B) => readonly [S, C],
+  ): <A, E, R, E2, R2>(push: Push<A, E, R, B, E2, R2>) => Push<A, E, R, C, E2, R2>;
+  <A, E, R, B, E2, R2, S, C>(
+    push: Push<A, E, R, B, E2, R2>,
+    initial: S,
+    f: (s: S, b: B) => readonly [S, C],
+  ): Push<A, E, R, C, E2, R2>;
+} = dual(3, function mapAccum<
+  A,
+  E,
+  R,
+  B,
+  E2,
+  R2,
+  S,
+  C,
+>(push: Push<A, E, R, B, E2, R2>, initial: S, f: (s: S, b: B) => readonly [S, C]): Push<
+  A,
+  E,
+  R,
+  C,
+  E2,
+  R2
+> {
+  return make(
+    push,
+    Fx.make((sink) =>
+      push.run(
+        Sink.loop(sink, initial, (s, b) => {
+          const [sNext, c] = f(s, b);
+          return [c, sNext];
+        }),
+      ),
+    ),
+  );
+});
+
+/**
+ * Maps over the output (Fx) side of a `Push` with an effectful accumulator: for each emitted value `b`,
+ * runs `f(state, b)` to get `[nextState, emitted]` and emits the second element.
+ *
+ * @param initial - Initial accumulator state.
+ * @param f - Effectful reducer `(state, value) => Effect<[nextState, emitted]>`.
+ * @returns A `Push` whose Fx side emits the accumulated/mapped values.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const mapAccumEffect: {
+  <S, B, C, E3, R3>(
+    initial: S,
+    f: (s: S, b: B) => Effect.Effect<readonly [S, C], E3, R3>,
+  ): <A, E, R, E2, R2>(push: Push<A, E, R, B, E2, R2>) => Push<A, E, R, C, E2 | E3, R2 | R3>;
+  <A, E, R, B, E2, R2, S, C, E3, R3>(
+    push: Push<A, E, R, B, E2, R2>,
+    initial: S,
+    f: (s: S, b: B) => Effect.Effect<readonly [S, C], E3, R3>,
+  ): Push<A, E, R, C, E2 | E3, R2 | R3>;
+} = dual(3, function mapAccumEffect<
+  A,
+  E,
+  R,
+  B,
+  E2,
+  R2,
+  S,
+  C,
+  E3,
+  R3,
+>(push: Push<A, E, R, B, E2, R2>, initial: S, f: (s: S, b: B) => Effect.Effect<readonly [S, C], E3, R3>): Push<
+  A,
+  E,
+  R,
+  C,
+  E2 | E3,
+  R2 | R3
+> {
+  return make(
+    push,
+    Fx.make(<RSink>(sink: Sink.Sink<C, E2 | E3, RSink>) =>
+      push.run(
+        Sink.filterMapLoopEffect(sink, initial, (s, b) =>
+          f(s, b).pipe(
+            Effect.map(([sNext, c]) => [Option.some(c), sNext] as const),
+            Effect.catchCause((cause) =>
+              sink.onFailure(cause).pipe(Effect.as([Option.none(), s] as const)),
+            ),
+          ),
+        ),
+      ),
+    ),
+  );
+});
+
 export function Service<Self, A, E = never, B = never, E2 = never>() {
   return <const Id extends string>(id: Id): Push.Class<Self, Id, A, E, B, E2> => {
     const service = ServiceMap.Service<Self, Push<A, E, never, B, E2, never>>(id);

package/src/Push.additive.test.ts

@@ -0,0 +1,256 @@
+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, Push, Sink } from "./index.js";
+
+describe("Push.mapError", () => {
+  it("maps Fx output error channel to new type", () =>
+    Effect.gen(function* () {
+      const push = Push.make(
+        Sink.make(
+          () => Effect.void,
+          () => Effect.void,
+        ),
+        Fx.fail("err"),
+      );
+      const mapped = Push.mapError(push, (s) => ({ msg: s }));
+      const exit = yield* Effect.exit(Fx.collectAll(mapped));
+      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 push = Push.make(
+        Sink.make(
+          () => Effect.void,
+          () => Effect.void,
+        ),
+        Fx.fail(42),
+      );
+      const mapped = Push.mapError(push, (n) => `n=${n}`);
+      const exit = yield* Effect.exit(Fx.collectAll(mapped));
+      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("preserves success values on Fx side", () =>
+    Effect.gen(function* () {
+      const push = Push.make(
+        Sink.make(
+          () => Effect.void,
+          () => Effect.void,
+        ),
+        Fx.fromIterable([1, 2, 3]),
+      );
+      const mapped = push.pipe(Push.mapError((e: string) => e));
+      const result = yield* Fx.collectAll(mapped);
+      assert.deepStrictEqual(result, [1, 2, 3]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("does not map defects (Cause.map only maps Fail)", () =>
+    Effect.gen(function* () {
+      const push = Push.make(
+        Sink.make(
+          () => Effect.void,
+          () => Effect.void,
+        ),
+        Fx.die("defect"),
+      );
+      const mapped = Push.mapError(push, (_e: string) => "mapped");
+      const exit = yield* Effect.exit(Fx.collectAll(mapped));
+      assert(Exit.isFailure(exit));
+      assert(Cause.hasDies(exit.cause));
+    }).pipe(Effect.scoped, Effect.runPromise));
+});
+
+describe("Push.mapBoth", () => {
+  it("maps both Fx success and error channels", () =>
+    Effect.gen(function* () {
+      const push = Push.make(
+        Sink.make(
+          () => Effect.void,
+          () => Effect.void,
+        ),
+        Fx.fromIterable([1, 2, 3]),
+      );
+      const mapped = Push.mapBoth(push, {
+        onSuccess: (n) => n * 10,
+        onFailure: (e: string) => e.length,
+      });
+      const result = yield* Fx.collectAll(mapped);
+      assert.deepStrictEqual(result, [10, 20, 30]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("maps Fx failure when stream fails", () =>
+    Effect.gen(function* () {
+      const push = Push.make(
+        Sink.make(
+          () => Effect.void,
+          () => Effect.void,
+        ),
+        Fx.fail("boom"),
+      );
+      const mapped = Push.mapBoth(push, {
+        onSuccess: (a: number) => a,
+        onFailure: (s: string) => ({ message: s }),
+      });
+      const exit = yield* Effect.exit(Fx.collectAll(mapped));
+      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 push = Push.make(
+        Sink.make(
+          () => Effect.void,
+          () => Effect.void,
+        ),
+        Fx.fromIterable(["a", "b"]),
+      );
+      const mapped = Push.mapBoth(push, {
+        onSuccess: (s) => s.toUpperCase(),
+        onFailure: (e: number) => String(e),
+      });
+      const result = yield* Fx.collectAll(mapped);
+      assert.deepStrictEqual(result, ["A", "B"]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("preserves defects (onFailure only maps Fail)", () =>
+    Effect.gen(function* () {
+      const push = Push.make(
+        Sink.make(
+          () => Effect.void,
+          () => Effect.void,
+        ),
+        Fx.die("oops"),
+      );
+      const mapped = Push.mapBoth(push, {
+        onSuccess: (a: number) => a,
+        onFailure: (_e: string) => "mapped",
+      });
+      const exit = yield* Effect.exit(Fx.collectAll(mapped));
+      assert(Exit.isFailure(exit));
+      assert(Cause.hasDies(exit.cause));
+    }).pipe(Effect.scoped, Effect.runPromise));
+});
+
+describe("Push.mapAccum", () => {
+  it("emits accumulated values from (state, value) => [nextState, emitted]", () =>
+    Effect.gen(function* () {
+      const push = Push.make(
+        Sink.make(
+          () => Effect.void,
+          () => Effect.void,
+        ),
+        Fx.fromIterable([1, 2, 3, 4]),
+      );
+      const accumulated = Push.mapAccum(push, 0, (sum, n) => [sum + n, sum + n] as const);
+      const result = yield* Fx.collectAll(accumulated);
+      assert.deepStrictEqual(result, [1, 3, 6, 10]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("data-last form: pipe(push, mapAccum(initial, f))", () =>
+    Effect.gen(function* () {
+      const push = Push.make(
+        Sink.make(
+          () => Effect.void,
+          () => Effect.void,
+        ),
+        Fx.fromIterable(["a", "b", "c"]),
+      );
+      const accumulated = push.pipe(
+        Push.mapAccum("", (acc, s) => [`${acc}${s}`, `${acc}${s}`] as const),
+      );
+      const result = yield* Fx.collectAll(accumulated);
+      assert.deepStrictEqual(result, ["a", "ab", "abc"]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("data-first form: mapAccum(push, initial, f)", () =>
+    Effect.gen(function* () {
+      const push = Push.make(
+        Sink.make(
+          () => Effect.void,
+          () => Effect.void,
+        ),
+        Fx.fromIterable([2, 3, 4]),
+      );
+      const accumulated = Push.mapAccum(push, 1, (prod, n) => [prod * n, prod * n] as const);
+      const result = yield* Fx.collectAll(accumulated);
+      assert.deepStrictEqual(result, [2, 6, 24]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("single value emits one accumulated result", () =>
+    Effect.gen(function* () {
+      const push = Push.make(
+        Sink.make(
+          () => Effect.void,
+          () => Effect.void,
+        ),
+        Fx.succeed(42),
+      );
+      const accumulated = Push.mapAccum(push, 0, (s, n) => [s + n, n] as const);
+      const result = yield* Fx.collectAll(accumulated);
+      assert.deepStrictEqual(result, [42]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+});
+
+describe("Push.mapAccumEffect", () => {
+  it("emits accumulated values from effectful reducer", () =>
+    Effect.gen(function* () {
+      const push = Push.make(
+        Sink.make(
+          () => Effect.void,
+          () => Effect.void,
+        ),
+        Fx.fromIterable([1, 2, 3]),
+      );
+      const accumulated = Push.mapAccumEffect(push, 0, (sum, n) =>
+        Effect.succeed([sum + n, sum + n] as const),
+      );
+      const result = yield* Fx.collectAll(accumulated);
+      assert.deepStrictEqual(result, [1, 3, 6]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("data-first form: mapAccumEffect(push, initial, f)", () =>
+    Effect.gen(function* () {
+      const push = Push.make(
+        Sink.make(
+          () => Effect.void,
+          () => Effect.void,
+        ),
+        Fx.fromIterable([10, 20]),
+      );
+      const accumulated = Push.mapAccumEffect(push, 1, (acc, n) =>
+        Effect.succeed([acc * n, acc * n] as const),
+      );
+      const result = yield* Fx.collectAll(accumulated);
+      assert.deepStrictEqual(result, [10, 200]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("propagates effect failure", () =>
+    Effect.gen(function* () {
+      const push = Push.make(
+        Sink.make(
+          () => Effect.void,
+          () => Effect.void,
+        ),
+        Fx.fromIterable([1, 2, 3]),
+      );
+      const accumulated = Push.mapAccumEffect(push, 0, (sum, n) =>
+        n === 2 ? Effect.fail("stop" as const) : Effect.succeed([sum + n, sum + n] as const),
+      );
+      const exit = yield* Effect.exit(Fx.collectAll(accumulated));
+      assert(Exit.isFailure(exit));
+      const fail = Cause.findFail(exit.cause);
+      assert(fail._tag === "Success" && fail.success.error === "stop");
+    }).pipe(Effect.scoped, Effect.runPromise));
+});

package/src/RefSubject/RefArray.ts

@@ -14,6 +14,7 @@ import type * as Order from "effect/Order";
 import type * as Scope from "effect/Scope";
 import type * as Fx from "../Fx/index.js";
 import * as RefSubject from "./RefSubject.js";
+import { Filter, Result } from "effect";
 
 /**
  * A RefArray is a RefSubject that is specialized over an array of values.
@@ -310,7 +311,9 @@ export const partition: {
     predicate: (a: A) => boolean,
   ): RefSubject.Computed<never, E, readonly [ReadonlyArray<A>, ReadonlyArray<A>]>;
 } = dual(2, function partition<A, E, R>(ref: RefArray<A, E, R>, predicate: (a: A) => boolean) {
-  return RefSubject.map(ref, ReadonlyArray.partition(predicate));
+  return RefSubject.map(ref, (array) =>
+    ReadonlyArray.partition(array, Result.liftPredicate(predicate, Result.fail)),
+  );
 });
 
 /**

package/src/RefSubject/RefChunk.ts

@@ -12,6 +12,7 @@ import type * as Order from "effect/Order";
 import type * as Scope from "effect/Scope";
 import type * as Fx from "../Fx/index.js";
 import * as RefSubject from "./RefSubject.js";
+import { Result } from "effect";
 
 /**
  * A RefChunk is a RefSubject specialized over a Chunk of values.
@@ -356,7 +357,7 @@ export const partition: {
     predicate: (a: A) => boolean,
   ): RefSubject.Computed<[Chunk.Chunk<A>, Chunk.Chunk<A>], E, R>;
 } = dual(2, function partition<A, E, R>(ref: RefChunk<A, E, R>, predicate: (a: A) => boolean) {
-  return RefSubject.map(ref, Chunk.partition(predicate));
+  return RefSubject.map(ref, Chunk.partition(Result.liftPredicate(predicate, Result.fail)));
 });
 
 /**

package/src/RefSubject/RefDateTime.ts

@@ -110,13 +110,13 @@ export const add: {
  */
 export const addDuration: {
   (
-    duration: Duration.DurationInput,
+    duration: Duration.Input,
   ): <E, R>(ref: RefDateTime<E, R>) => RefSubject.Computed<DateTime.DateTime, E, R>;
   <E, R>(
     ref: RefDateTime<E, R>,
-    duration: Duration.DurationInput,
+    duration: Duration.Input,
   ): RefSubject.Computed<DateTime.DateTime, E, R>;
-} = dual(2, function addDuration<E, R>(ref: RefDateTime<E, R>, duration: Duration.DurationInput) {
+} = dual(2, function addDuration<E, R>(ref: RefDateTime<E, R>, duration: Duration.Input) {
   return RefSubject.map(ref, (self) => DateTime.addDuration(self, duration));
 });
 
@@ -177,16 +177,16 @@ export const subtract: {
  */
 export const subtractDuration: {
   (
-    duration: Duration.DurationInput,
+    duration: Duration.Input,
   ): <E, R>(ref: RefDateTime<E, R>) => RefSubject.Computed<DateTime.DateTime, E, R>;
   <E, R>(
     ref: RefDateTime<E, R>,
-    duration: Duration.DurationInput,
+    duration: Duration.Input,
   ): RefSubject.Computed<DateTime.DateTime, E, R>;
 } = dual(2, function subtractDuration<
   E,
   R,
->(ref: RefDateTime<E, R>, duration: Duration.DurationInput) {
+>(ref: RefDateTime<E, R>, duration: Duration.Input) {
   return RefSubject.map(ref, (self) => DateTime.subtractDuration(self, duration));
 });
 

package/src/RefSubject/RefHashMap.ts

@@ -11,6 +11,7 @@ import * as Option from "effect/Option";
 import type * as Scope from "effect/Scope";
 import type * as Fx from "../Fx/index.js";
 import * as RefSubject from "./RefSubject.js";
+import { Result } from "effect";
 
 /**
  * A RefHashMap is a RefSubject specialized over a HashMap.
@@ -354,7 +355,15 @@ export const filterMapValues: {
   R,
   B,
 >(ref: RefHashMap<K, V, E, R>, f: (value: V, key: K) => Option.Option<B>) {
-  return RefSubject.map(ref, HashMap.filterMap(f));
+  return RefSubject.map(
+    ref,
+    HashMap.filterMap((value, key) =>
+      Option.match(f(value, key), {
+        onNone: () => Result.failVoid,
+        onSome: (b) => Result.succeed(b),
+      }),
+    ),
+  );
 });
 
 /**

package/src/RefSubject/RefIterable.ts

@@ -3,11 +3,12 @@
  * @since 1.18.0
  */
 
+import { Result } from "effect";
 import type * as Effect from "effect/Effect";
 import { equals } from "effect/Equal";
 import { dual } from "effect/Function";
 import * as Iterable from "effect/Iterable";
-import type * as Option from "effect/Option";
+import * as Option from "effect/Option";
 import type * as Scope from "effect/Scope";
 import type * as Fx from "../Fx/index.js";
 import * as RefSubject from "./RefSubject.js";
@@ -233,7 +234,15 @@ export const filterMap: {
   E,
   R,
 >(ref: RefIterable<A, E, R>, f: (a: A, index: number) => Option.Option<A>) {
-  return RefSubject.update(ref, Iterable.filterMap(f));
+  return RefSubject.update(
+    ref,
+    Iterable.filterMap((a, index) =>
+      Option.match(f(a, index), {
+        onNone: () => Result.failVoid,
+        onSome: (b) => Result.succeed(b),
+      }),
+    ),
+  );
 });
 
 /**

package/src/RefSubject/RefRecord.ts

@@ -3,6 +3,7 @@
  * @since 1.18.0
  */
 
+import { Result } from "effect";
 import type * as Effect from "effect/Effect";
 import { equals } from "effect/Equal";
 import { dual } from "effect/Function";
@@ -450,7 +451,11 @@ export const filterMapValues: {
   R,
   B,
 >(ref: RefRecord<K, V, E, R>, f: (value: V, key: K) => Option.Option<B>) {
-  return RefSubject.map(ref, (r) => Record.filterMap(r, f) as Record.ReadonlyRecord<K, B>);
+  return RefSubject.map(ref, (r) =>
+    Record.filterMap(r, (value, key) =>
+      f(value, key) ? Result.succeed(value) : Result.fail(value),
+    ),
+  );
 });
 
 /**
@@ -477,7 +482,9 @@ export const partition: {
   return RefSubject.map(
     ref,
     (r) =>
-      Record.partition(r, predicate) as [Record.ReadonlyRecord<K, V>, Record.ReadonlyRecord<K, V>],
+      Record.partition(r, (value, key) =>
+        predicate(value, key) ? Result.succeed(value) : Result.fail(value),
+      ) as [Record.ReadonlyRecord<K, V>, Record.ReadonlyRecord<K, V>],
   );
 });