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

package/src/RefSubject/RefSubject.ts

@@ -4,6 +4,7 @@
 import * as Array from "effect/Array";
 import type * as Cause from "effect/Cause";
 import * as Effect from "effect/Effect";
+import * as Semaphore from "effect/Semaphore";
 import { equals } from "effect/Equal";
 import type { Equivalence } from "effect/Equivalence";
 import * as Exit from "effect/Exit";
@@ -459,14 +460,14 @@ class RefSubjectCore<A, E, R, R2> {
   readonly services: ServiceMap.ServiceMap<R2>;
   readonly scope: Scope.Closeable;
   readonly deferredRef: DeferredRef.DeferredRef<E, A>;
-  readonly semaphore: Effect.Semaphore;
+  readonly semaphore: Semaphore.Semaphore;
   constructor(
     initial: Effect.Effect<A, E, R>,
     subject: Subject.HoldSubjectImpl<A, E>,
     services: ServiceMap.ServiceMap<R2>,
     scope: Scope.Closeable,
     deferredRef: DeferredRef.DeferredRef<E, A>,
-    semaphore: Effect.Semaphore,
+    semaphore: Semaphore.Semaphore,
   ) {
     this.initial = initial;
     this.subject = subject;
@@ -693,6 +694,66 @@ export function fromStream<A, E, R>(
   });
 }
 
+/**
+ * Creates a `RefSubject` from an `Option` value.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Option } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const ref = yield* RefSubject.fromOption(Option.some(42))
+ *   const value = yield* ref
+ *   console.log(Option.isSome(value)) // true
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export function fromOption<A>(
+  option: Option.Option<A>,
+  options?: RefSubjectOptions<Option.Option<A>>,
+): Effect.Effect<RefSubject<Option.Option<A>>, never, Scope.Scope> {
+  return make(option, options);
+}
+
+/**
+ * Creates a `RefSubject` from a nullable value (null/undefined become `Option.none()`).
+ *
+ * @example
+ * ```ts
+ * import { Effect, Option } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const ref = yield* RefSubject.fromNullable("hello")
+ *   const value = yield* ref
+ *   console.log(Option.isSome(value)) // true
+ *
+ *   const empty = yield* RefSubject.fromNullable(null)
+ *   const none = yield* empty
+ *   console.log(Option.isNone(none)) // true
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+function optionFromNullable<A>(value: A | null | undefined): Option.Option<NonNullable<A>> {
+  return value === null || value === undefined
+    ? Option.none()
+    : Option.some(value as NonNullable<A>);
+}
+
+export function fromNullable<A>(
+  value: A | null | undefined,
+  options?: RefSubjectOptions<Option.Option<NonNullable<A>>>,
+): Effect.Effect<RefSubject<Option.Option<NonNullable<A>>>, never, Scope.Scope> {
+  return make(optionFromNullable(value), options);
+}
+
 function redirectCause<A, E, R>(core: RefSubjectCore<A, E, R, R | Scope.Scope>) {
   return Stream.catchCause((cause: Cause.Cause<E>) =>
     Stream.unwrap(Effect.as(onFailureCore(core, cause), Stream.empty)),
@@ -716,7 +777,7 @@ function makeCore<A, E, R>(
       scope,
       deferredRef ??
         DeferredRef.unsafeMake(id, getExitEquivalence(options?.eq ?? equals), subject.lastValue),
-      Effect.makeSemaphoreUnsafe(1),
+      Semaphore.makeUnsafe(1),
     );
     yield* Scope.addFinalizer(scope, core.subject.interrupt);
     return core;
@@ -1179,12 +1240,10 @@ export const runUpdates: {
   <A, E, R, B, E2, R2, R3 = never, E3 = never, C = never>(
     ref: RefSubject<A, E, R>,
     f: (ref: GetSetDelete<A, E, R>) => Effect.Effect<B, E2, R2>,
-    options?:
-      | {
-          readonly onInterrupt: (value: A) => Effect.Effect<C, E3, R3>;
-          readonly value?: "initial" | "current";
-        }
-      | undefined,
+    options?: {
+      readonly onInterrupt: (value: A) => Effect.Effect<C, E3, R3>;
+      readonly value?: "initial" | "current";
+    },
   ): Effect.Effect<B, E | E2 | E3, R | R2 | R3>;
 } = dual(
   isRefSubjectDataFirst,
@@ -1741,6 +1800,46 @@ export const compact: {
   return new FilteredImpl(versioned, Effect.succeed);
 };
 
+/**
+ * Returns a `Computed` that yields the value inside the `Option`, or the fallback when `None`.
+ * Works with `Computed<Option<A>>` (e.g. from `fromOption` / `fromNullable`) and with `Filtered<A>`.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Option } from "effect"
+ * import * as RefSubject from "@typed/fx/RefSubject"
+ *
+ * const program = Effect.gen(function* () {
+ *   const ref = yield* RefSubject.fromOption(Option.some(42))
+ *   const withDefault = RefSubject.getOrElse(ref, () => 0)
+ *   expect(yield* withDefault).toBe(42)
+ *
+ *   const empty = yield* RefSubject.fromNullable(null)
+ *   const fallback = RefSubject.getOrElse(empty, () => 99)
+ *   expect(yield* fallback).toBe(99)
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export const getOrElse: {
+  <A>(
+    fallback: () => A,
+  ): <E, R>(ref: Computed<Option.Option<A>, E, R> | Filtered<A, E, R>) => Computed<A, E, R>;
+  <A, E, R>(
+    ref: Computed<Option.Option<A>, E, R> | Filtered<A, E, R>,
+    fallback: () => A,
+  ): Computed<A, E, R>;
+} = dual(2, function getOrElse<
+  A,
+  E,
+  R,
+>(ref: Computed<Option.Option<A>, E, R> | Filtered<A, E, R>, fallback: () => A): Computed<A, E, R> {
+  const computed = FilteredTypeId in ref ? (ref as Filtered<A, E, R>).asComputed() : ref;
+  return map(computed, (opt) => Option.getOrElse(opt, fallback));
+});
+
 class RefSubjectSimpleTransform<A, E, R, R2, R3>
   extends YieldableFx<A, E, R | R2 | Scope.Scope, A, E, R | R3>
   implements RefSubject<A, E, R | R2 | R3>

package/src/RefSubject/RefTrie.ts

@@ -6,11 +6,12 @@
 import type * as Effect from "effect/Effect";
 import { equals } from "effect/Equal";
 import { dual } from "effect/Function";
-import type * as Option from "effect/Option";
+import * as Option from "effect/Option";
 import type * as Scope from "effect/Scope";
 import * as Trie from "effect/Trie";
 import type * as Fx from "../Fx/index.js";
 import * as RefSubject from "./RefSubject.js";
+import { Result } from "effect";
 
 /**
  * A RefTrie is a RefSubject specialized over a Trie.
@@ -122,13 +123,13 @@ export const clear = <V, E, R>(ref: RefTrie<V, E, R>): Effect.Effect<Trie.Trie<V
 export const map: {
   <V>(
     f: (value: V, key: string) => V,
-  ): <E, R>(ref: RefTrie<V, E, R>) => Effect.Effect<Trie.Trie<V>, E, R>;
+  ): <E, R>(ref: RefTrie<V, E, R>) => RefSubject.Computed<Trie.Trie<V>, E, R>;
   <V, E, R>(
     ref: RefTrie<V, E, R>,
     f: (value: V, key: string) => V,
-  ): Effect.Effect<Trie.Trie<V>, E, R>;
+  ): RefSubject.Computed<Trie.Trie<V>, E, R>;
 } = dual(2, function map<V, E, R>(ref: RefTrie<V, E, R>, f: (value: V, key: string) => V) {
-  return RefSubject.update(ref, Trie.map(f));
+  return RefSubject.map(ref, Trie.map(f));
 });
 
 /**
@@ -139,17 +140,17 @@ export const map: {
 export const filter: {
   <V>(
     predicate: (value: V, key: string) => boolean,
-  ): <E, R>(ref: RefTrie<V, E, R>) => Effect.Effect<Trie.Trie<V>, E, R>;
+  ): <E, R>(ref: RefTrie<V, E, R>) => RefSubject.Computed<Trie.Trie<V>, E, R>;
   <V, E, R>(
     ref: RefTrie<V, E, R>,
     predicate: (value: V, key: string) => boolean,
-  ): Effect.Effect<Trie.Trie<V>, E, R>;
+  ): RefSubject.Computed<Trie.Trie<V>, E, R>;
 } = dual(2, function filter<
   V,
   E,
   R,
 >(ref: RefTrie<V, E, R>, predicate: (value: V, key: string) => boolean) {
-  return RefSubject.update(ref, Trie.filter(predicate));
+  return RefSubject.map(ref, Trie.filter(predicate));
 });
 
 /**
@@ -160,17 +161,25 @@ export const filter: {
 export const filterMap: {
   <V>(
     f: (value: V, key: string) => Option.Option<V>,
-  ): <E, R>(ref: RefTrie<V, E, R>) => Effect.Effect<Trie.Trie<V>, E, R>;
+  ): <E, R>(ref: RefTrie<V, E, R>) => RefSubject.Computed<Trie.Trie<V>, E, R>;
   <V, E, R>(
     ref: RefTrie<V, E, R>,
     f: (value: V, key: string) => Option.Option<V>,
-  ): Effect.Effect<Trie.Trie<V>, E, R>;
+  ): RefSubject.Computed<Trie.Trie<V>, E, R>;
 } = dual(2, function filterMap<
   V,
   E,
   R,
 >(ref: RefTrie<V, E, R>, f: (value: V, key: string) => Option.Option<V>) {
-  return RefSubject.update(ref, Trie.filterMap(f));
+  return RefSubject.map(
+    ref,
+    Trie.filterMap((value, key) =>
+      Option.match(f(value, key), {
+        onNone: () => Result.failVoid,
+        onSome: (b) => Result.succeed(b),
+      }),
+    ),
+  );
 });
 
 // ========================================

package/src/RefSubject.additive-parity.test.ts

@@ -0,0 +1,101 @@
+import { describe, expect, it } from "vitest";
+import { Effect } from "effect";
+import * as Option from "effect/Option";
+import { RefSubject } from "./index.js";
+
+const fromNullableOption = <A>(v: A | null | undefined): Option.Option<NonNullable<A>> =>
+  v === null || v === undefined ? Option.none() : Option.some(v as NonNullable<A>);
+
+describe("RefSubject additive parity (fromOption, fromNullable, getOrElse)", () => {
+  describe("fromOption", () => {
+    it("creates RefSubject from Option.some", () =>
+      Effect.gen(function* () {
+        const ref = yield* RefSubject.fromOption(Option.some(42));
+        const value = yield* ref;
+        expect(Option.isSome(value)).toBe(true);
+        if (Option.isSome(value)) {
+          expect(value.value).toBe(42);
+        }
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("creates RefSubject from Option.none", () =>
+      Effect.gen(function* () {
+        const ref = yield* RefSubject.fromOption(Option.none<number>());
+        const value = yield* ref;
+        expect(Option.isNone(value)).toBe(true);
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("is writable (set/update)", () =>
+      Effect.gen(function* () {
+        const ref = yield* RefSubject.fromOption(Option.some(1));
+        yield* RefSubject.set(ref, Option.some(2));
+        const value = yield* ref;
+        expect(Option.isSome(value)).toBe(true);
+        if (Option.isSome(value)) {
+          expect(value.value).toBe(2);
+        }
+      }).pipe(Effect.scoped, Effect.runPromise));
+  });
+
+  describe("fromNullable", () => {
+    it("creates RefSubject from non-null value", () =>
+      Effect.gen(function* () {
+        const ref = yield* RefSubject.fromNullable("hello");
+        const value = yield* ref;
+        expect(Option.isSome(value)).toBe(true);
+        if (Option.isSome(value)) {
+          expect(value.value).toBe("hello");
+        }
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("creates RefSubject from null", () =>
+      Effect.gen(function* () {
+        const ref = yield* RefSubject.fromNullable<string>(null);
+        const value = yield* ref;
+        expect(Option.isNone(value)).toBe(true);
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("creates RefSubject from undefined", () =>
+      Effect.gen(function* () {
+        const ref = yield* RefSubject.fromNullable<number>(undefined);
+        const value = yield* ref;
+        expect(Option.isNone(value)).toBe(true);
+      }).pipe(Effect.scoped, Effect.runPromise));
+  });
+
+  describe("getOrElse", () => {
+    it("returns value for Computed<Option<A>> when Some", () =>
+      Effect.gen(function* () {
+        const ref = yield* RefSubject.fromOption(Option.some(42));
+        const withDefault = RefSubject.getOrElse(ref, () => 0);
+        expect(yield* withDefault).toBe(42);
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("returns fallback for Computed<Option<A>> when None", () =>
+      Effect.gen(function* () {
+        const ref = yield* RefSubject.fromNullable<number>(null);
+        const withDefault = RefSubject.getOrElse(ref, () => 99);
+        expect(yield* withDefault).toBe(99);
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("getOrElse on Filtered uses fallback when no value", () =>
+      Effect.gen(function* () {
+        const numbers = yield* RefSubject.make([1, 3, 5]);
+        const firstEven = RefSubject.filterMap(numbers, (arr) =>
+          fromNullableOption(arr.find((n) => n % 2 === 0)),
+        );
+        const withDefault = RefSubject.getOrElse(firstEven, () => -1);
+        expect(yield* withDefault).toBe(-1);
+      }).pipe(Effect.scoped, Effect.runPromise));
+
+    it("getOrElse on Filtered returns value when present", () =>
+      Effect.gen(function* () {
+        const numbers = yield* RefSubject.make([1, 2, 3]);
+        const firstEven = RefSubject.filterMap(numbers, (arr) =>
+          fromNullableOption(arr.find((n) => n % 2 === 0)),
+        );
+        const withDefault = RefSubject.getOrElse(firstEven, () => -1);
+        expect(yield* withDefault).toBe(2);
+      }).pipe(Effect.scoped, Effect.runPromise));
+  });
+});

package/src/Sink/combinators.ts

@@ -1,5 +1,6 @@
 import * as Cause from "effect/Cause";
 import * as Effect from "effect/Effect";
+import * as Semaphore from "effect/Semaphore";
 import * as Exit from "effect/Exit";
 import { dual, flow, identity } from "effect/Function";
 import * as MutableRef from "effect/MutableRef";
@@ -72,6 +73,40 @@ export function map<A, E, R, B>(sink: Sink<A, E, R>, f: (b: B) => A): Sink<B, E,
   return MapSink.make(sink, f);
 }
 
+/** Alias for `map`: transforms input values before they reach the sink. @since 1.0.0 @category combinators */
+export const mapInput = map;
+
+/**
+ * Maps the error channel of a sink using the provided function.
+ * Failures are mapped via `Cause.map`; defects and interrupts are preserved.
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export function mapError<A, E, E2, R>(sink: Sink<A, E2, R>, f: (e: E) => E2): Sink<A, E, R> {
+  return new MapErrorSink(sink, f);
+}
+
+class MapErrorSink<A, E, E2, R> implements Sink<A, E, R> {
+  readonly sink: Sink<A, E2, R>;
+  readonly f: (e: E) => E2;
+
+  constructor(sink: Sink<A, E2, R>, f: (e: E) => E2) {
+    this.sink = sink;
+    this.f = f;
+    this.onSuccess = this.onSuccess.bind(this);
+    this.onFailure = this.onFailure.bind(this);
+  }
+
+  onSuccess(value: A): Effect.Effect<unknown, never, R> {
+    return this.sink.onSuccess(value);
+  }
+
+  onFailure(cause: Cause.Cause<E>): Effect.Effect<unknown, never, R> {
+    return this.sink.onFailure(Cause.map(cause, this.f));
+  }
+}
+
 class FilterMapSink<A, E, R, B> implements Sink<B, E, R> {
   readonly sink: Sink<A, E, R>;
   readonly f: (b: B) => Option.Option<A>;
@@ -236,7 +271,7 @@ export function withStateSemaphore<A, E, R, B, R2>(
 ) {
   return withEarlyExit(sink, (sink, params) => {
     const stateRef = MutableRef.make(state);
-    const semaphore = Effect.makeSemaphoreUnsafe(1);
+    const semaphore = Semaphore.makeUnsafe(1);
     const lock = semaphore.withPermits(1);
     const modifyEffect = <C, E2, R2>(f: (state: B) => Effect.Effect<readonly [C, B], E2, R2>) =>
       Effect.suspend(() => f(MutableRef.get(stateRef))).pipe(
@@ -776,6 +811,9 @@ class MapEffectSink<A, E, R, B, E2, R2> implements Sink<B, E | E2, R | R2> {
   }
 }
 
+/** Alias for `mapEffect`: transforms input with an effect before the sink. @since 1.0.0 @category combinators */
+export const mapInputEffect = mapEffect;
+
 export const filterMapEffect: {
   <B, A, E2, R2>(
     f: (b: B) => Effect.Effect<Option.Option<A>, E2, R2>,
@@ -991,3 +1029,87 @@ export const skipInterrupt = <A, E, R>(sink: Sink<A, E, R>): Sink<A, E, R> => {
       cause.reasons.every(Cause.isInterruptReason) ? Effect.void : sink.onFailure(cause),
   };
 };
+
+// -----------------------------------------------------------------------------
+// Reducing / collecting combinators (additive)
+// -----------------------------------------------------------------------------
+
+/**
+ * Reduces values into a single result using a pure function. Pass a `Ref<B>`
+ * (e.g. from `Ref.make(initial)`); after running, read the result with `Ref.get(ref)`.
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export function reduce<A, B, E>(ref: Ref.Ref<B>, f: (b: B, a: A) => B): Sink<A, E, never> {
+  return {
+    onSuccess: (value) => Ref.update(ref, (b) => f(b, value)),
+    onFailure: () => Effect.void,
+  };
+}
+
+/**
+ * Reduces values into a single result using an effectful function. Pass a `Ref<B>`;
+ * after running, read the result with `Ref.get(ref)`. If the reducer effect fails,
+ * the ref is left unchanged (Sink onSuccess is typed as never failing).
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export function reduceEffect<A, B, E, E2, R2>(
+  ref: Ref.Ref<B>,
+  f: (b: B, a: A) => Effect.Effect<B, E2, R2>,
+): Sink<A, E | E2, R2> {
+  return {
+    onSuccess: (value) =>
+      Effect.flatMap(Ref.get(ref), (b) =>
+        Effect.matchCauseEffect(f(b, value), {
+          onFailure: () => Effect.void,
+          onSuccess: (next) => Ref.set(ref, next),
+        }),
+      ),
+    onFailure: () => Effect.void,
+  };
+}
+
+/**
+ * Collects all values into an array. Pass a `Ref<ReadonlyArray<A>>` (e.g. `Ref.make([])`);
+ * after running, read the result with `Ref.get(ref)`.
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export function collect<A, E>(ref: Ref.Ref<ReadonlyArray<A>>): Sink<A, E, never> {
+  return {
+    onSuccess: (value) => Ref.update(ref, (arr) => [...arr, value]),
+    onFailure: () => Effect.void,
+  };
+}
+
+/**
+ * Keeps only the first value. Pass a `Ref<Option.Option<A>>` (e.g. `Ref.make(Option.none())`);
+ * after running, read the result with `Ref.get(ref)`.
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export function head<A, E>(ref: Ref.Ref<Option.Option<A>>): Sink<A, E, never> {
+  return {
+    onSuccess: (value) => Ref.update(ref, (opt) => (Option.isNone(opt) ? Option.some(value) : opt)),
+    onFailure: () => Effect.void,
+  };
+}
+
+/**
+ * Keeps only the last value. Pass a `Ref<Option.Option<A>>` (e.g. `Ref.make(Option.none())`);
+ * after running, read the result with `Ref.get(ref)`.
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export function last<A, E>(ref: Ref.Ref<Option.Option<A>>): Sink<A, E, never> {
+  return {
+    onSuccess: (value) => Ref.set(ref, Option.some(value)),
+    onFailure: () => Effect.void,
+  };
+}

package/src/Sink.combinators.test.ts

@@ -0,0 +1,88 @@
+import { assert, describe, it } from "vitest";
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as Ref from "effect/Ref";
+import { Fx, Sink } from "./index.js";
+
+describe("Sink.mapError", () => {
+  it("maps failure cause before passing to inner sink", () =>
+    Effect.gen(function* () {
+      const failures = yield* Ref.make<Array<number>>([]);
+      const sink = Sink.make<unknown, number, never>(
+        (cause) =>
+          Ref.update(failures, (list) => {
+            const f = Cause.findFail(cause);
+            if (f._tag === "Success") list.push(f.success.error as number);
+            return list;
+          }),
+        () => Effect.void,
+      );
+      const mapped = Sink.mapError(sink, (s: string) => s.length);
+      yield* Fx.fail("err").run(mapped);
+      const list = yield* Ref.get(failures);
+      assert.deepStrictEqual(list, [3]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("preserves success path", () =>
+    Effect.gen(function* () {
+      const out = yield* Ref.make<number[]>([]);
+      const sink = Sink.make<number, string, never>(
+        (_cause) => Effect.void,
+        (n: number) => Ref.update(out, (arr) => [...arr, n]),
+      );
+      const mapped = Sink.mapError(sink, (e: string) => e);
+      yield* Fx.fromIterable([1, 2, 3]).run(mapped);
+      const list = yield* Ref.get(out);
+      assert.deepStrictEqual(list, [1, 2, 3]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+});
+
+describe("Sink.mapInput", () => {
+  it("transforms input before sink (same as map)", () =>
+    Effect.gen(function* () {
+      const out = yield* Ref.make<number[]>([]);
+      const sink = Sink.make(
+        () => Effect.void,
+        (n: number) => Ref.update(out, (arr) => [...arr, n]),
+      );
+      const mapped = Sink.mapInput(sink, (s: string) => parseInt(s, 10));
+      yield* Fx.fromIterable(["1", "2", "3"]).run(mapped);
+      const list = yield* Ref.get(out);
+      assert.deepStrictEqual(list, [1, 2, 3]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+});
+
+describe("Sink.mapInputEffect", () => {
+  it("transforms input with effect before sink (same as mapEffect)", () =>
+    Effect.gen(function* () {
+      const out = yield* Ref.make<number[]>([]);
+      const sink = Sink.make(
+        () => Effect.void,
+        (n: number) => Ref.update(out, (arr) => [...arr, n]),
+      );
+      const mapped = Sink.mapInputEffect(sink, (s: string) => Effect.succeed(parseInt(s, 10)));
+      yield* Fx.fromIterable(["1", "2", "3"]).run(mapped);
+      const list = yield* Ref.get(out);
+      assert.deepStrictEqual(list, [1, 2, 3]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+
+  it("propagates effect failure to sink onFailure", () =>
+    Effect.gen(function* () {
+      const failures = yield* Ref.make<Array<string>>([]);
+      const sink = Sink.make<number, string, never>(
+        (cause) =>
+          Ref.update(failures, (list) => {
+            const f = Cause.findFail(cause);
+            if (f._tag === "Success") list.push(f.success.error as string);
+            return list;
+          }),
+        (_n: number) => Effect.void,
+      );
+      const mapped = Sink.mapInputEffect(sink, (s: string) =>
+        s === "bad" ? Effect.fail("parse failed") : Effect.succeed(parseInt(s, 10)),
+      );
+      yield* Fx.fromIterable(["1", "bad", "3"]).run(mapped);
+      const list = yield* Ref.get(failures);
+      assert.deepStrictEqual(list, ["parse failed"]);
+    }).pipe(Effect.scoped, Effect.runPromise));
+});