@typed/fx 1.31.0 → 2.0.0-beta.0

package/dist/{esm/Sink.js → Sink/combinators.js}

@@ -1,92 +1,64 @@
-/**
- * Sink is a data structure which can be used to consume values from a stream.
- * @since 1.20.0
- */
-import * as C from "@typed/context";
 import * as Cause from "effect/Cause";
-import * as Clock from "effect/Clock";
 import * as Effect from "effect/Effect";
-import { dual } from "effect/Function";
-import * as Layer from "effect/Layer";
+import * as Exit from "effect/Exit";
+import { dual, flow, identity } from "effect/Function";
+import * as MutableRef from "effect/MutableRef";
 import * as Option from "effect/Option";
-/**
- * @since 1.20.0
- */
-export function make(onFailure, onSuccess) {
-    return {
-        onFailure,
-        onSuccess
-    };
-}
-/**
- * @since 1.20.0
- */
-export function withEarlyExit(sink, f) {
-    return Effect.asyncEffect((resume) => {
-        const earlyExit = {
-            ...sink,
-            earlyExit: Effect.sync(() => resume(Effect.void))
-        };
-        return Effect.matchCauseEffect(f(earlyExit), {
-            onFailure: (cause) => Effect.asVoid(sink.onFailure(cause)),
-            onSuccess: () => earlyExit.earlyExit
-        });
-    });
-}
-/**
- * Transform the input value of a Sink.
- * @since 1.18.0
- * @category combinators
- */
-export const map = dual(2, function map(sink, f) {
-    return new MapSink(sink, f);
-});
+import * as Ref from "effect/Ref";
 class MapSink {
     sink;
     f;
     constructor(sink, f) {
         this.sink = sink;
         this.f = f;
-        this.onFailure = this.onFailure.bind(this);
         this.onSuccess = this.onSuccess.bind(this);
-    }
-    onFailure(cause) {
-        return this.sink.onFailure(cause);
+        this.onFailure = this.onFailure.bind(this);
     }
     onSuccess(value) {
         return this.sink.onSuccess(this.f(value));
     }
-}
-/**
- * @since 1.20.0
- */
-export function filter(sink, predicate) {
-    return new FilterSink(sink, predicate);
-}
-class FilterSink {
-    sink;
-    predicate;
-    constructor(sink, predicate) {
-        this.sink = sink;
-        this.predicate = predicate;
-        this.onFailure = this.onFailure.bind(this);
-        this.onSuccess = this.onSuccess.bind(this);
-    }
     onFailure(cause) {
         return this.sink.onFailure(cause);
     }
-    onSuccess(value) {
-        if (this.predicate(value))
-            return this.sink.onSuccess(value);
-        else
-            return Effect.void;
+    static make(sink, f) {
+        if (sink instanceof MapSink) {
+            return new MapSink(sink.sink, flow(f, sink.f));
+        }
+        if (sink instanceof FilterMapSink) {
+            return new FilterMapSink(sink.sink, flow(f, sink.f));
+        }
+        return new MapSink(sink, f);
     }
 }
 /**
- * @since 1.20.0
+ * Transforms values before they reach the sink using a pure function.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as Sink from "@typed/fx/Sink"
+ * import { Fx } from "@typed/fx"
+ *
+ * const program = Effect.gen(function* () {
+ *   const sink = Sink.make(
+ *     (cause) => Effect.void,
+ *     (value: number) => Effect.sync(() => console.log("Received:", value))
+ *   )
+ *
+ *   // Map string inputs to numbers
+ *   const mapped = Sink.map(sink, (str: string) => parseInt(str))
+ *
+ *   // Run an Fx with the mapped sink
+ *   yield* Fx.fromIterable(["1", "2", "3"]).run(mapped)
+ *   // Output: "Received: 1", "Received: 2", "Received: 3"
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category combinators
  */
-export function filterMap(sink, f) {
-    return new FilterMapSink(sink, f);
+export function map(sink, f) {
+    return MapSink.make(sink, f);
 }
 class FilterMapSink {
     sink;
@@ -94,130 +66,134 @@ class FilterMapSink {
     constructor(sink, f) {
         this.sink = sink;
         this.f = f;
-        this.onFailure = this.onFailure.bind(this);
         this.onSuccess = this.onSuccess.bind(this);
-    }
-    onFailure(cause) {
-        return this.sink.onFailure(cause);
-    }
-    onSuccess(value) {
-        const option = this.f(value);
-        if (Option.isSome(option))
-            return this.sink.onSuccess(option.value);
-        else
-            return Effect.void;
-    }
-}
-/**
- * @since 1.20.0
- */
-export const mapEffect = dual(2, function mapEffect(sink, f) {
-    return new MapEffectSink(sink, f);
-});
-class MapEffectSink {
-    sink;
-    f;
-    constructor(sink, f) {
-        this.sink = sink;
-        this.f = f;
         this.onFailure = this.onFailure.bind(this);
-        this.onSuccess = this.onSuccess.bind(this);
-    }
-    onFailure(cause) {
-        return this.sink.onFailure(cause);
     }
     onSuccess(value) {
-        return Effect.matchCauseEffect(this.f(value), this.sink);
-    }
-}
-/**
- * @since 1.20.0
- */
-export const filterMapEffect = dual(2, function filterMapEffect(sink, f) {
-    return new FilterMapEffectSink(sink, f);
-});
-class FilterMapEffectSink {
-    sink;
-    f;
-    constructor(sink, f) {
-        this.sink = sink;
-        this.f = f;
-        this.onFailure = this.onFailure.bind(this);
-        this.onSuccess = this.onSuccess.bind(this);
+        const a = this.f(value);
+        return Option.match(a, {
+            onSome: (a) => this.sink.onSuccess(a),
+            onNone: () => Effect.void,
+        });
     }
     onFailure(cause) {
         return this.sink.onFailure(cause);
     }
-    onSuccess(value) {
-        return Effect.matchCauseEffect(this.f(value), {
-            onFailure: (cause) => this.sink.onFailure(cause),
-            onSuccess: (option) => {
-                if (Option.isSome(option))
-                    return this.sink.onSuccess(option.value);
-                else
-                    return Effect.void;
-            }
-        });
+    static make(sink, f) {
+        if (sink instanceof FilterMapSink) {
+            return new FilterMapSink(sink.sink, flow(f, Option.flatMap(sink.f)));
+        }
+        if (sink instanceof MapSink) {
+            return new FilterMapSink(sink.sink, flow(f, Option.map(sink.f)));
+        }
+        return new FilterMapSink(sink, f);
     }
 }
 /**
- * @since 1.20.0
+ * Filters and transforms values before they reach the sink using a function that returns an `Option`.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Option } from "effect"
+ * import * as Sink from "@typed/fx/Sink"
+ * import { Fx } from "@typed/fx"
+ *
+ * const program = Effect.gen(function* () {
+ *   const sink = Sink.make(
+ *     (cause) => Effect.void,
+ *     (value: number) => Effect.sync(() => console.log("Even:", value))
+ *   )
+ *
+ *   // Only pass through even numbers
+ *   const filtered = Sink.filterMap(sink, (n: number) =>
+ *     n % 2 === 0 ? Option.some(n) : Option.none()
+ *   )
+ *
+ *   yield* Fx.fromIterable([1, 2, 3, 4, 5]).run(filtered)
+ *   // Output: "Even: 2", "Even: 4"
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category combinators
  */
-export const filterEffect = dual(2, function filterEffect(sink, f) {
-    return new FilterEffectSink(sink, f);
-});
-class FilterEffectSink {
-    sink;
-    f;
-    constructor(sink, f) {
-        this.sink = sink;
-        this.f = f;
-        this.onFailure = this.onFailure.bind(this);
-        this.onSuccess = this.onSuccess.bind(this);
-    }
-    onFailure(cause) {
-        return this.sink.onFailure(cause);
-    }
-    onSuccess(value) {
-        return Effect.matchCauseEffect(this.f(value), {
-            onFailure: (cause) => this.sink.onFailure(cause),
-            onSuccess: (b) => {
-                if (b)
-                    return this.sink.onSuccess(value);
-                else
-                    return Effect.void;
-            }
-        });
-    }
+export function filterMap(sink, f) {
+    return FilterMapSink.make(sink, f);
+}
+export function compact(sink) {
+    return filterMap(sink, identity);
 }
 /**
- * @since 1.20.0
+ * Filters values before they reach the sink using a predicate function.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as Sink from "@typed/fx/Sink"
+ * import { Fx } from "@typed/fx"
+ *
+ * const program = Effect.gen(function* () {
+ *   const sink = Sink.make(
+ *     (cause) => Effect.void,
+ *     (value: number) => Effect.sync(() => console.log("Positive:", value))
+ *   )
+ *
+ *   // Only pass through positive numbers
+ *   const filtered = Sink.filter(sink, (n) => n > 0)
+ *
+ *   yield* Fx.fromIterable([-2, -1, 0, 1, 2]).run(filtered)
+ *   // Output: "Positive: 1", "Positive: 2"
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category combinators
  */
-export const tapEffect = dual(2, function tapEffect(sink, f) {
-    return new TapEffectSink(sink, f);
-});
-class TapEffectSink {
-    sink;
-    f;
-    constructor(sink, f) {
-        this.sink = sink;
-        this.f = f;
-        this.onFailure = this.onFailure.bind(this);
-        this.onSuccess = this.onSuccess.bind(this);
-    }
-    onFailure(cause) {
-        return this.sink.onFailure(cause);
-    }
-    onSuccess(value) {
-        return Effect.matchCauseEffect(this.f(value), {
-            onFailure: (cause) => this.sink.onFailure(cause),
-            onSuccess: () => this.sink.onSuccess(value)
+export function filter(sink, f) {
+    return filterMap(sink, Option.liftPredicate(f));
+}
+export function withEarlyExit(sink, f) {
+    return Effect.servicesWith((services) => Effect.callback(function (resume, signal) {
+        let exited = false;
+        const earlyExit = Effect.sync(() => {
+            exited = true;
+            resume(Effect.void);
         });
-    }
+        const onSuccess = (a) => {
+            if (exited)
+                return Effect.void;
+            return sink.onSuccess(a);
+        };
+        const onFailure = (cause) => {
+            if (exited)
+                return Effect.void;
+            return sink.onFailure(cause);
+        };
+        const sinkWithEarlyExit = {
+            onSuccess,
+            onFailure,
+            earlyExit,
+        };
+        f(sinkWithEarlyExit, { signal, scheduler: this }).pipe(Effect.flatMap(() => earlyExit), (_) => Effect.runForkWith(services)(_, { scheduler: this, signal }));
+    }));
+}
+export function withState(sink, state, f) {
+    return withEarlyExit(sink, (sink, params) => f({ ...sink, state: Ref.makeUnsafe(state) }, params));
+}
+export function withStateSemaphore(sink, state, f) {
+    return withEarlyExit(sink, (sink, params) => {
+        const stateRef = MutableRef.make(state);
+        const semaphore = Effect.makeSemaphoreUnsafe(1);
+        const lock = semaphore.withPermits(1);
+        const modifyEffect = (f) => Effect.suspend(() => f(MutableRef.get(stateRef))).pipe(Effect.flatMap(([c, b]) => {
+            MutableRef.set(stateRef, b);
+            return Effect.succeed(c);
+        }), lock);
+        const updateEffect = (f) => modifyEffect((state) => f(state).pipe(Effect.map((b) => [b, b])));
+        const get = modifyEffect((state) => Effect.succeed([state, state]));
+        return f({ ...sink, modifyEffect, updateEffect, get }, params);
+    });
 }
-/**
- * @since 1.20.0
- */
 export const loop = dual(3, function loop(sink, seed, f) {
     return new LoopSink(sink, seed, f);
 });
@@ -241,9 +217,6 @@ class LoopSink {
         return this.sink.onSuccess(c);
     }
 }
-/**
- * @since 1.20.0
- */
 export const loopCause = dual(3, function loopCause(sink, seed, f) {
     return new LoopCauseSink(sink, seed, f);
 });
@@ -267,9 +240,6 @@ class LoopCauseSink {
         return this.sink.onSuccess(value);
     }
 }
-/**
- * @since 1.20.0
- */
 export const filterMapLoop = dual(3, function filterMapLoop(sink, seed, f) {
     return new FilterMapLoopSink(sink, seed, f);
 });
@@ -292,13 +262,9 @@ class FilterMapLoopSink {
         this.seed = acc;
         if (Option.isSome(option))
             return this.sink.onSuccess(option.value);
-        else
-            return Effect.void;
+        return Effect.void;
     }
 }
-/**
- * @since 1.20.0
- */
 export const filterMapLoopCause = dual(3, function filterMapLoopCause(sink, seed, f) {
     return new FilterMapLoopCauseSink(sink, seed, f);
 });
@@ -318,16 +284,12 @@ class FilterMapLoopCauseSink {
         this.seed = acc;
         if (Option.isSome(option))
             return this.sink.onFailure(option.value);
-        else
-            return Effect.void;
+        return Effect.void;
     }
     onSuccess(value) {
         return this.sink.onSuccess(value);
     }
 }
-/**
- * @since 1.20.0
- */
 export const loopEffect = dual(3, function loopEffect(sink, seed, f) {
     return new LoopEffectSink(sink, seed, f);
 });
@@ -351,13 +313,10 @@ class LoopEffectSink {
             onSuccess: ([c, acc]) => {
                 this.seed = acc;
                 return this.sink.onSuccess(c);
-            }
+            },
         });
     }
 }
-/**
- * @since 1.20.0
- */
 export const filterMapLoopEffect = dual(3, function filterMapLoopEffect(sink, seed, f) {
     return new FilterMapLoopEffectSink(sink, seed, f);
 });
@@ -382,15 +341,11 @@ class FilterMapLoopEffectSink {
                 this.seed = acc;
                 if (Option.isSome(option))
                     return this.sink.onSuccess(option.value);
-                else
-                    return Effect.void;
-            }
+                return Effect.void;
+            },
         });
     }
 }
-/**
- * @since 1.20.0
- */
 export const loopCauseEffect = dual(3, function loopCauseEffect(sink, seed, f) {
     return new LoopCauseEffectSink(sink, seed, f);
 });
@@ -407,20 +362,17 @@ class LoopCauseEffectSink {
     }
     onFailure(cause) {
         return Effect.matchCauseEffect(this.f(this.seed, cause), {
-            onFailure: (cause2) => this.sink.onFailure(Cause.sequential(cause, cause2)),
+            onFailure: (cause2) => this.sink.onFailure(Cause.fromReasons([...cause.reasons, ...cause2.reasons])),
             onSuccess: ([c, acc]) => {
                 this.seed = acc;
                 return this.sink.onFailure(c);
-            }
+            },
         });
     }
     onSuccess(value) {
         return this.sink.onSuccess(value);
     }
 }
-/**
- * @since 1.20.0
- */
 export function filterMapLoopCauseEffect(sink, seed, f) {
     return new FilterMapLoopCauseEffectSink(sink, seed, f);
 }
@@ -442,31 +394,27 @@ class FilterMapLoopCauseEffectSink {
                 this.seed = acc;
                 if (Option.isSome(option))
                     return this.sink.onFailure(option.value);
-                else
-                    return Effect.void;
-            }
+                return Effect.void;
+            },
         });
     }
     onSuccess(value) {
         return this.sink.onSuccess(value);
     }
 }
-/**
- * @since 1.20.0
- */
 export const slice = dual(3, function slice(sink, bounds, f) {
     return withEarlyExit(sink, (s) => f(new SliceSink(s, bounds)));
 });
 class SliceSink {
-    sink;
-    bounds;
     drop;
     take;
+    sink;
+    bounds;
     constructor(sink, bounds) {
         this.sink = sink;
         this.bounds = bounds;
-        this.drop = this.bounds.min;
-        this.take = this.bounds.max;
+        this.drop = this.bounds.skip;
+        this.take = this.bounds.take;
         this.onFailure = this.onFailure.bind(this);
         this.onSuccess = this.onSuccess.bind(this);
     }
@@ -484,20 +432,15 @@ class SliceSink {
         return this.sink.earlyExit;
     }
 }
-/**
- * @since 1.20.0
- */
-export const takeWhile = dual(3, function takeWhile(sink, predicate, f) {
-    return withEarlyExit(sink, (s) => f(new TakeWhileSink(s, predicate)));
+export const mapEffect = dual(2, function mapEffect(sink, f) {
+    return new MapEffectSink(sink, f);
 });
-class TakeWhileSink {
+class MapEffectSink {
     sink;
-    predicate;
-    take;
-    constructor(sink, predicate) {
+    f;
+    constructor(sink, f) {
         this.sink = sink;
-        this.predicate = predicate;
-        this.take = true;
+        this.f = f;
         this.onFailure = this.onFailure.bind(this);
         this.onSuccess = this.onSuccess.bind(this);
     }
@@ -505,35 +448,18 @@ class TakeWhileSink {
         return this.sink.onFailure(cause);
     }
     onSuccess(value) {
-        if (this.take === true && (this.take = this.predicate(value)))
-            return this.sink.onSuccess(value);
-        else {
-            this.take = false;
-            return this.sink.earlyExit;
-        }
+        return Effect.matchCauseEffect(this.f(value), this.sink);
     }
 }
-/**
- * @since 1.20.0
- */
-export const dropWhile = dual(2, function dropWhile(sink, predicate) {
-    return filterMapLoop(sink, true, (drop, a) => {
-        const drop2 = drop && predicate(a);
-        return [drop2 ? Option.none() : Option.some(a), drop2];
-    });
-});
-/**
- * @since 2.0.0
- */
-export const dropAfter = dual(3, function dropAfter(sink, predicate, f) {
-    return withEarlyExit(sink, (s) => f(new DropAfterSink(s, predicate)));
+export const filterMapEffect = dual(2, function filterMapEffect(sink, f) {
+    return new FilterMapEffectSink(sink, f);
 });
-class DropAfterSink {
+class FilterMapEffectSink {
     sink;
-    predicate;
-    constructor(sink, predicate) {
+    f;
+    constructor(sink, f) {
         this.sink = sink;
-        this.predicate = predicate;
+        this.f = f;
         this.onFailure = this.onFailure.bind(this);
         this.onSuccess = this.onSuccess.bind(this);
     }
@@ -541,26 +467,26 @@ class DropAfterSink {
         return this.sink.onFailure(cause);
     }
     onSuccess(value) {
-        if (this.predicate(value)) {
-            return Effect.zipRight(this.sink.onSuccess(value), this.sink.earlyExit);
-        }
-        return this.sink.onSuccess(value);
+        return Effect.matchCauseEffect(this.f(value), {
+            onFailure: (cause) => this.sink.onFailure(cause),
+            onSuccess: (option) => {
+                if (Option.isSome(option))
+                    return this.sink.onSuccess(option.value);
+                else
+                    return Effect.void;
+            },
+        });
     }
 }
-/**
- * @since 1.20.0
- */
-export const takeWhileEffect = dual(3, function takeWhileEffect(sink, predicate, f) {
-    return withEarlyExit(sink, (s) => f(new TakeWhileEffectSink(s, predicate)));
+export const filterEffect = dual(2, function filterEffect(sink, f) {
+    return new FilterEffectSink(sink, f);
 });
-class TakeWhileEffectSink {
+class FilterEffectSink {
     sink;
-    predicate;
-    take;
-    constructor(sink, predicate) {
+    f;
+    constructor(sink, f) {
         this.sink = sink;
-        this.predicate = predicate;
-        this.take = true;
+        this.f = f;
         this.onFailure = this.onFailure.bind(this);
         this.onSuccess = this.onSuccess.bind(this);
     }
@@ -568,106 +494,93 @@ class TakeWhileEffectSink {
         return this.sink.onFailure(cause);
     }
     onSuccess(value) {
-        if (this.take === true) {
-            return Effect.matchCauseEffect(this.predicate(value), {
-                onFailure: (cause) => this.sink.onFailure(cause),
-                onSuccess: (b) => {
-                    if ((this.take = b))
-                        return this.sink.onSuccess(value);
-                    else
-                        return this.sink.earlyExit;
-                }
-            });
-        }
-        else
-            return this.sink.earlyExit;
+        return Effect.matchCauseEffect(this.f(value), {
+            onFailure: (cause) => this.sink.onFailure(cause),
+            onSuccess: (b) => {
+                if (b)
+                    return this.sink.onSuccess(value);
+                else
+                    return Effect.void;
+            },
+        });
     }
 }
-/**
- * @since 1.20.0
- */
-export const dropWhileEffect = dual(2, function dropWhileEffect(sink, predicate) {
-    return filterMapLoopEffect(sink, true, (drop, a) => {
-        if (drop === false)
-            return Effect.succeed([Option.some(a), drop]);
-        return Effect.map(predicate(a), (b) => [b ? Option.none() : Option.some(a), b]);
-    });
-});
-/**
- * @since 1.20.0
- */
-export const dropAfterEffect = dual(2, function dropAfterEffect(sink, predicate) {
-    return filterMapLoopEffect(sink, false, (drop, a) => {
-        if (drop === true)
-            return Effect.succeed([Option.none(), drop]);
-        return Effect.map(predicate(a), (b) => [Option.some(a), b]);
-    });
-});
-/**
- * @since 1.20.0
- */
-export const provide = dual(2, function provide(sink, ctx) {
-    return make((cause) => Effect.provide(sink.onFailure(cause), ctx), (a) => Effect.provide(sink.onSuccess(a), ctx));
-});
-/**
- * @since 1.20.0
- */
-export const setSpan = dual(2, function setSpan(self, span) {
-    return make((cause) => addEvent(self.onFailure(cause), "fx.failure", span, {
-        "cause": Cause.pretty(cause)
-    }), (a) => addEvent(self.onSuccess(a), "fx.success", span, {
-        "value": JSON.stringify(a)
-    }));
+export const tapEffect = dual(2, function tapEffect(sink, f) {
+    return new TapEffectSink(sink, f);
 });
-const addEvent = (effect, name, span, attributes) => Effect.flatMap(Clock.currentTimeNanos, (time) => Effect.suspend(() => {
-    span.event(name, time, attributes);
-    return effect;
-}));
-/**
- * @since 1.20.0
- */
-export function tagged() {
-    return (identifier) => new TaggedImpl(C.Tagged(identifier));
+class TapEffectSink {
+    sink;
+    f;
+    constructor(sink, f) {
+        this.sink = sink;
+        this.f = f;
+        this.onFailure = this.onFailure.bind(this);
+        this.onSuccess = this.onSuccess.bind(this);
+    }
+    onFailure(cause) {
+        return this.sink.onFailure(cause);
+    }
+    onSuccess(value) {
+        return Effect.matchCauseEffect(this.f(value), {
+            onFailure: (cause) => this.sink.onFailure(cause),
+            onSuccess: () => this.sink.onSuccess(value),
+        });
+    }
 }
-class TaggedImpl {
-    tag;
-    constructor(tag) {
-        this.tag = tag;
+export const flip = (sink) => new FlipSink(sink);
+class FlipSink {
+    sink;
+    constructor(sink) {
+        this.sink = sink;
     }
     onSuccess(value) {
-        return this.tag.withEffect((sink) => sink.onSuccess(value));
+        return this.sink.onFailure(Cause.fail(value));
     }
     onFailure(cause) {
-        return this.tag.withEffect((sink) => sink.onFailure(cause));
+        const fail = cause.reasons.find((failure) => failure._tag === "Fail");
+        if (!fail)
+            return this.sink.onFailure(cause);
+        return this.sink.onSuccess(fail.error);
     }
-    make = (sink) => Layer.flatMap(Layer.context(), (ctx) => this.tag.layer(provide(sink, ctx)));
 }
-/**
- * @since 1.20.0
- */
-export const fromTag = dual(2, function fromTag(tag, f) {
-    return new FromTag(tag, f);
-});
-class FromTag {
-    tag;
-    f;
-    get;
-    constructor(tag, f) {
-        this.tag = tag;
-        this.f = f;
-        this.get = Effect.map(tag, f);
+export const exit = (sink) => new ExitSink(sink);
+class ExitSink {
+    sink;
+    constructor(sink) {
+        this.sink = sink;
     }
     onSuccess(value) {
-        return Effect.flatMap(this.get, (sink) => sink.onSuccess(value));
+        return this.sink.onSuccess(Exit.succeed(value));
     }
     onFailure(cause) {
-        return Effect.flatMap(this.get, (sink) => sink.onFailure(cause));
+        return this.sink.onSuccess(Exit.failCause(cause));
     }
 }
-/**
- * @since 1.20.0
- */
-export function ignoreInterrupt(sink) {
-    return make((cause) => Cause.isInterruptedOnly(cause) ? Effect.void : sink.onFailure(cause), sink.onSuccess);
+export const dropAfter = dual(3, function dropAfter(sink, predicate, f) {
+    return withEarlyExit(sink, (s) => f(new DropAfterSink(s, predicate)).pipe(Effect.catchCause(sink.onFailure)));
+});
+class DropAfterSink {
+    sink;
+    predicate;
+    constructor(sink, predicate) {
+        this.sink = sink;
+        this.predicate = predicate;
+        this.onFailure = this.onFailure.bind(this);
+        this.onSuccess = this.onSuccess.bind(this);
+    }
+    onFailure(cause) {
+        return this.sink.onFailure(cause);
+    }
+    onSuccess(value) {
+        if (this.predicate(value)) {
+            return Effect.flatMap(this.sink.onSuccess(value), () => this.sink.earlyExit);
+        }
+        return this.sink.onSuccess(value);
+    }
 }
-//# sourceMappingURL=Sink.js.map
+export const skipInterrupt = (sink) => {
+    return {
+        onSuccess: (value) => sink.onSuccess(value),
+        onFailure: (cause) => cause.reasons.every(Cause.isInterruptReason) ? Effect.void : sink.onFailure(cause),
+    };
+};