@typed/fx 1.18.4 → 1.20.0

package/dist/cjs/Sink.js

@@ -3,53 +3,57 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.Sink = Sink;
-exports.WithContext = WithContext;
-exports.mapErrorEffect = exports.mapErrorCauseEffect = exports.mapErrorCause = exports.mapError = exports.mapEffect = exports.map = void 0;
-exports.provide = provide;
-exports.setSpan = void 0;
+exports.dropWhileEffect = exports.dropWhile = exports.dropAfterEffect = exports.dropAfter = void 0;
+exports.filter = filter;
+exports.filterEffect = void 0;
+exports.filterMap = filterMap;
+exports.filterMapLoopCause = exports.filterMapLoop = exports.filterMapEffect = void 0;
+exports.filterMapLoopCauseEffect = filterMapLoopCauseEffect;
+exports.fromTag = exports.filterMapLoopEffect = void 0;
+exports.ignoreInterrupt = ignoreInterrupt;
+exports.loopEffect = exports.loopCauseEffect = exports.loopCause = exports.loop = void 0;
+exports.make = make;
+exports.slice = exports.setSpan = exports.provide = exports.mapEffect = exports.map = void 0;
+exports.tagged = tagged;
+exports.tapEffect = exports.takeWhileEffect = exports.takeWhile = void 0;
+exports.withEarlyExit = withEarlyExit;
+var C = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@typed/context"));
 var Cause = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Cause"));
 var Clock = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Clock"));
 var Effect = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Effect"));
-var Either = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Either"));
 var _Function = /*#__PURE__*/require("effect/Function");
+var Layer = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Layer"));
+var Option = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Option"));
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 /**
- * 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
  */
 
 /**
- * Construct a Sink that can be used to handle failures and successes.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-function Sink(onFailure, onSuccess) {
+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
  */
-function WithContext(onFailure, onSuccess) {
-  return {
-    onFailure,
-    onSuccess
-  };
-}
-/**
- * Provide a Context to a Sink
- * @since 1.18.0
- * @category context
- */
-function provide(sink, ctx) {
-  return Sink(cause => Effect.provide(sink.onFailure(cause), ctx), a => Effect.provide(sink.onSuccess(a), ctx));
+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.
@@ -57,58 +61,533 @@ function provide(sink, ctx) {
  * @category combinators
  */
 const map = exports.map = /*#__PURE__*/(0, _Function.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
+ */
+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
+ */
+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
  */
 const mapEffect = exports.mapEffect = /*#__PURE__*/(0, _Function.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
+ */
+const filterMapEffect = exports.filterMapEffect = /*#__PURE__*/(0, _Function.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
  */
-const mapErrorCause = exports.mapErrorCause = /*#__PURE__*/(0, _Function.dual)(2, function mapErrorCause(sink, f) {
-  return Sink(cause => sink.onFailure(f(cause)), sink.onSuccess);
+const filterEffect = exports.filterEffect = /*#__PURE__*/(0, _Function.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
  */
-const mapErrorCauseEffect = exports.mapErrorCauseEffect = /*#__PURE__*/(0, _Function.dual)(2, function mapErrorCauseEffect(sink, f) {
-  return WithContext(cause => Effect.matchCauseEffect(f(cause), WithContext(sink.onFailure, sink.onFailure)), sink.onSuccess);
+const tapEffect = exports.tapEffect = /*#__PURE__*/(0, _Function.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
  */
-const mapError = exports.mapError = /*#__PURE__*/(0, _Function.dual)(2, function mapError(sink, f) {
-  return WithContext(cause => sink.onFailure(Cause.map(cause, f)), sink.onSuccess);
+const loop = exports.loop = /*#__PURE__*/(0, _Function.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
  */
-const mapErrorEffect = exports.mapErrorEffect = /*#__PURE__*/(0, _Function.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)
-  }));
+const loopCause = exports.loopCause = /*#__PURE__*/(0, _Function.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
  */
-const setSpan = exports.setSpan = /*#__PURE__*/(0, _Function.dual)(2, function withSpan(self, span) {
-  return WithContext(cause => addEvent(self.onFailure(cause), "fx.failure", span, {
+const filterMapLoop = exports.filterMapLoop = /*#__PURE__*/(0, _Function.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
+ */
+const filterMapLoopCause = exports.filterMapLoopCause = /*#__PURE__*/(0, _Function.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
+ */
+const loopEffect = exports.loopEffect = /*#__PURE__*/(0, _Function.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
+ */
+const filterMapLoopEffect = exports.filterMapLoopEffect = /*#__PURE__*/(0, _Function.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
+ */
+const loopCauseEffect = exports.loopCauseEffect = /*#__PURE__*/(0, _Function.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
+ */
+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
+ */
+const slice = exports.slice = /*#__PURE__*/(0, _Function.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
+ */
+const takeWhile = exports.takeWhile = /*#__PURE__*/(0, _Function.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
+ */
+const dropWhile = exports.dropWhile = /*#__PURE__*/(0, _Function.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
+ */
+const dropAfter = exports.dropAfter = /*#__PURE__*/(0, _Function.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
+ */
+const takeWhileEffect = exports.takeWhileEffect = /*#__PURE__*/(0, _Function.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
+ */
+const dropWhileEffect = exports.dropWhileEffect = /*#__PURE__*/(0, _Function.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
+ */
+const dropAfterEffect = exports.dropAfterEffect = /*#__PURE__*/(0, _Function.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
+ */
+const provide = exports.provide = /*#__PURE__*/(0, _Function.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
+ */
+const setSpan = exports.setSpan = /*#__PURE__*/(0, _Function.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)
@@ -118,4 +597,51 @@ const addEvent = (effect, name, span, attributes) => Effect.flatMap(Clock.curren
   span.event(name, time, attributes);
   return effect;
 }));
+/**
+ * @since 1.20.0
+ */
+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
+ */
+const fromTag = exports.fromTag = /*#__PURE__*/(0, _Function.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
+ */
+function ignoreInterrupt(sink) {
+  return make(cause => Cause.isInterruptedOnly(cause) ? Effect.unit : sink.onFailure(cause), sink.onSuccess);
+}
 //# sourceMappingURL=Sink.js.map