@typed/fx 1.19.0 → 1.20.0

package/dist/esm/Sink.js

@@ -1,42 +1,37 @@
 /**
- * Sink is a data structure that represents a place to send failures and successes
- * over time in an effectful manner.
- * @since 1.18.0
+ * 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 * as Either from "effect/Either";
 import { dual } from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
 /**
- * Construct a Sink that can be used to handle failures and successes.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export function Sink(onFailure, onSuccess) {
+export function make(onFailure, onSuccess) {
     return {
         onFailure,
         onSuccess
     };
 }
 /**
- * Construct a Sink that can be used to handle failures and successes with a Context.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export function WithContext(onFailure, onSuccess) {
-    return {
-        onFailure,
-        onSuccess
-    };
-}
-/**
- * Provide a Context to a Sink
- * @since 1.18.0
- * @category context
- */
-export function provide(sink, ctx) {
-    return Sink((cause) => Effect.provide(sink.onFailure(cause), ctx), (a) => Effect.provide(sink.onSuccess(a), ctx));
+export function withEarlyExit(sink, f) {
+    return Effect.asyncEffect((resume) => {
+        const earlyExit = {
+            ...sink,
+            earlyExit: Effect.sync(() => resume(Effect.unit))
+        };
+        return Effect.matchCauseEffect(f(earlyExit), {
+            onFailure: (cause) => sink.onFailure(cause),
+            onSuccess: () => earlyExit.earlyExit
+        });
+    });
 }
 /**
  * Transform the input value of a Sink.
@@ -44,58 +39,567 @@ export function provide(sink, ctx) {
  * @category combinators
  */
 export const map = dual(2, function map(sink, f) {
-    return WithContext(sink.onFailure, (a) => sink.onSuccess(f(a)));
+    return new MapSink(sink, f);
 });
+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);
+    }
+    onSuccess(value) {
+        return this.sink.onSuccess(this.f(value));
+    }
+}
 /**
- * Transform the input value of a Sink using an Effect.
- * @since 1.18.0
- * @category combinators
+ * @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.unit;
+    }
+}
+/**
+ * @since 1.20.0
+ */
+export function filterMap(sink, f) {
+    return new FilterMapSink(sink, f);
+}
+class FilterMapSink {
+    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) {
+        const option = this.f(value);
+        if (Option.isSome(option))
+            return this.sink.onSuccess(option.value);
+        else
+            return Effect.unit;
+    }
+}
+/**
+ * @since 1.20.0
  */
 export const mapEffect = dual(2, function mapEffect(sink, f) {
-    return WithContext(sink.onFailure, (b) => Effect.matchCauseEffect(f(b), sink));
+    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);
+    }
+}
 /**
- * Transform the input Cause of a Sink.
- * @since 1.18.0
- * @category combinators
+ * @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);
+    }
+    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.unit;
+            }
+        });
+    }
+}
+/**
+ * @since 1.20.0
  */
-export const mapErrorCause = dual(2, function mapErrorCause(sink, f) {
-    return Sink((cause) => sink.onFailure(f(cause)), sink.onSuccess);
+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.unit;
+            }
+        });
+    }
+}
 /**
- * Transform the input Cause of a Sink using an Effect.
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const mapErrorCauseEffect = dual(2, function mapErrorCauseEffect(sink, f) {
-    return WithContext((cause) => Effect.matchCauseEffect(f(cause), WithContext(sink.onFailure, sink.onFailure)), sink.onSuccess);
+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)
+        });
+    }
+}
 /**
- * Transform the input Error of a Sink.
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const mapError = dual(2, function mapError(sink, f) {
-    return WithContext((cause) => sink.onFailure(Cause.map(cause, f)), sink.onSuccess);
+export const loop = dual(3, function loop(sink, seed, f) {
+    return new LoopSink(sink, seed, f);
 });
+class LoopSink {
+    sink;
+    seed;
+    f;
+    constructor(sink, seed, f) {
+        this.sink = sink;
+        this.seed = seed;
+        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 [c, acc] = this.f(this.seed, value);
+        this.seed = acc;
+        return this.sink.onSuccess(c);
+    }
+}
 /**
- * Transform the input Error of a Sink using an Effect.
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const mapErrorEffect = dual(2, function mapErrorEffect(sink, f) {
-    return mapErrorCauseEffect(sink, (cause) => Either.match(Cause.failureOrCause(cause), {
-        onLeft: (e2) => Effect.map(f(e2), Cause.fail),
-        onRight: (cause) => Effect.succeed(cause)
-    }));
+export const loopCause = dual(3, function loopCause(sink, seed, f) {
+    return new LoopCauseSink(sink, seed, f);
 });
+class LoopCauseSink {
+    sink;
+    seed;
+    f;
+    constructor(sink, seed, f) {
+        this.sink = sink;
+        this.seed = seed;
+        this.f = f;
+        this.onFailure = this.onFailure.bind(this);
+        this.onSuccess = this.onSuccess.bind(this);
+    }
+    onFailure(cause) {
+        const [c, acc] = this.f(this.seed, cause);
+        this.seed = acc;
+        return this.sink.onFailure(c);
+    }
+    onSuccess(value) {
+        return this.sink.onSuccess(value);
+    }
+}
 /**
- * Set the span a Sink will use to append events to.
- * @since 1.18.0
- * @category tracing
+ * @since 1.20.0
  */
-export const setSpan = dual(2, function withSpan(self, span) {
-    return WithContext((cause) => addEvent(self.onFailure(cause), "fx.failure", span, {
+export const filterMapLoop = dual(3, function filterMapLoop(sink, seed, f) {
+    return new FilterMapLoopSink(sink, seed, f);
+});
+class FilterMapLoopSink {
+    sink;
+    seed;
+    f;
+    constructor(sink, seed, f) {
+        this.sink = sink;
+        this.seed = seed;
+        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, acc] = this.f(this.seed, value);
+        this.seed = acc;
+        if (Option.isSome(option))
+            return this.sink.onSuccess(option.value);
+        else
+            return Effect.unit;
+    }
+}
+/**
+ * @since 1.20.0
+ */
+export const filterMapLoopCause = dual(3, function filterMapLoopCause(sink, seed, f) {
+    return new FilterMapLoopCauseSink(sink, seed, f);
+});
+class FilterMapLoopCauseSink {
+    sink;
+    seed;
+    f;
+    constructor(sink, seed, f) {
+        this.sink = sink;
+        this.seed = seed;
+        this.f = f;
+        this.onFailure = this.onFailure.bind(this);
+        this.onSuccess = this.onSuccess.bind(this);
+    }
+    onFailure(cause) {
+        const [option, acc] = this.f(this.seed, cause);
+        this.seed = acc;
+        if (Option.isSome(option))
+            return this.sink.onFailure(option.value);
+        else
+            return Effect.unit;
+    }
+    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);
+});
+class LoopEffectSink {
+    sink;
+    seed;
+    f;
+    constructor(sink, seed, f) {
+        this.sink = sink;
+        this.seed = seed;
+        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(this.seed, value), {
+            onFailure: (cause) => this.sink.onFailure(cause),
+            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);
+});
+class FilterMapLoopEffectSink {
+    sink;
+    seed;
+    f;
+    constructor(sink, seed, f) {
+        this.sink = sink;
+        this.seed = seed;
+        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(this.seed, value), {
+            onFailure: (cause) => this.sink.onFailure(cause),
+            onSuccess: ([option, acc]) => {
+                this.seed = acc;
+                if (Option.isSome(option))
+                    return this.sink.onSuccess(option.value);
+                else
+                    return Effect.unit;
+            }
+        });
+    }
+}
+/**
+ * @since 1.20.0
+ */
+export const loopCauseEffect = dual(3, function loopCauseEffect(sink, seed, f) {
+    return new LoopCauseEffectSink(sink, seed, f);
+});
+class LoopCauseEffectSink {
+    sink;
+    seed;
+    f;
+    constructor(sink, seed, f) {
+        this.sink = sink;
+        this.seed = seed;
+        this.f = f;
+        this.onFailure = this.onFailure.bind(this);
+        this.onSuccess = this.onSuccess.bind(this);
+    }
+    onFailure(cause) {
+        return Effect.matchCauseEffect(this.f(this.seed, cause), {
+            onFailure: (cause2) => this.sink.onFailure(Cause.sequential(cause, cause2)),
+            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);
+}
+class FilterMapLoopCauseEffectSink {
+    sink;
+    seed;
+    f;
+    constructor(sink, seed, f) {
+        this.sink = sink;
+        this.seed = seed;
+        this.f = f;
+        this.onFailure = this.onFailure.bind(this);
+        this.onSuccess = this.onSuccess.bind(this);
+    }
+    onFailure(cause) {
+        return Effect.matchCauseEffect(this.f(this.seed, cause), {
+            onFailure: (cause2) => this.sink.onFailure(cause2),
+            onSuccess: ([option, acc]) => {
+                this.seed = acc;
+                if (Option.isSome(option))
+                    return this.sink.onFailure(option.value);
+                else
+                    return Effect.unit;
+            }
+        });
+    }
+    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;
+    constructor(sink, bounds) {
+        this.sink = sink;
+        this.bounds = bounds;
+        this.drop = this.bounds.min;
+        this.take = this.bounds.max;
+        this.onFailure = this.onFailure.bind(this);
+        this.onSuccess = this.onSuccess.bind(this);
+    }
+    onFailure(cause) {
+        return this.sink.onFailure(cause);
+    }
+    onSuccess(value) {
+        if (this.drop > 0) {
+            this.drop--;
+            return Effect.unit;
+        }
+        if (this.take-- > 0) {
+            return Effect.tap(this.sink.onSuccess(value), () => this.take === 0 ? this.sink.earlyExit : Effect.unit);
+        }
+        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)));
+});
+class TakeWhileSink {
+    sink;
+    predicate;
+    take;
+    constructor(sink, predicate) {
+        this.sink = sink;
+        this.predicate = predicate;
+        this.take = true;
+        this.onFailure = this.onFailure.bind(this);
+        this.onSuccess = this.onSuccess.bind(this);
+    }
+    onFailure(cause) {
+        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;
+        }
+    }
+}
+/**
+ * @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 1.20.0
+ */
+export const dropAfter = dual(2, function dropAfter(sink, predicate) {
+    return filterMapLoop(sink, false, (drop, a) => {
+        if (drop === true)
+            return [Option.none(), drop];
+        const drop2 = predicate(a);
+        return [Option.some(a), drop2];
+    });
+});
+/**
+ * @since 1.20.0
+ */
+export const takeWhileEffect = dual(3, function takeWhileEffect(sink, predicate, f) {
+    return withEarlyExit(sink, (s) => f(new TakeWhileEffectSink(s, predicate)));
+});
+class TakeWhileEffectSink {
+    sink;
+    predicate;
+    take;
+    constructor(sink, predicate) {
+        this.sink = sink;
+        this.predicate = predicate;
+        this.take = true;
+        this.onFailure = this.onFailure.bind(this);
+        this.onSuccess = this.onSuccess.bind(this);
+    }
+    onFailure(cause) {
+        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;
+    }
+}
+/**
+ * @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)
@@ -105,4 +609,51 @@ const addEvent = (effect, name, span, attributes) => Effect.flatMap(Clock.curren
     span.event(name, time, attributes);
     return effect;
 }));
+/**
+ * @since 1.20.0
+ */
+export function tagged() {
+    return (identifier) => new TaggedImpl(C.Tagged(identifier));
+}
+class TaggedImpl {
+    tag;
+    constructor(tag) {
+        this.tag = tag;
+    }
+    onSuccess(value) {
+        return this.tag.withEffect((sink) => sink.onSuccess(value));
+    }
+    onFailure(cause) {
+        return this.tag.withEffect((sink) => sink.onFailure(cause));
+    }
+    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);
+    }
+    onSuccess(value) {
+        return Effect.flatMap(this.get, (sink) => sink.onSuccess(value));
+    }
+    onFailure(cause) {
+        return Effect.flatMap(this.get, (sink) => sink.onFailure(cause));
+    }
+}
+/**
+ * @since 1.20.0
+ */
+export function ignoreInterrupt(sink) {
+    return make((cause) => Cause.isInterruptedOnly(cause) ? Effect.unit : sink.onFailure(cause), sink.onSuccess);
+}
 //# sourceMappingURL=Sink.js.map