@typed/fx 1.18.4 → 1.20.0

package/dist/esm/Fx.js

@@ -1,1259 +1,760 @@
 /**
- * Fx<R, E, A> is a representation of an `Effect`-ful workflow that exists over
- * the time dimension. It operates within a context `R`, can fail with an `E`,
- * and succeed with an `A`.
- *
- * Any `Fx`, shorthand for "Effects", can emit 0 or more errors or events over an
- * indefinite period of time. This is in contrast to `Effect` which can only
- * produce exactly 1 error or event.
- *
- * It is defined as a super-type of `Effect`, `Stream`, and `Cause`. This
- * allows for all operators that accept an `Fx` to also capable of
- * accepting an `Effect`, `Stream`, or `Cause`. An Effect or Cause represents a single
- * event or error, while a Stream represents a series of events or errors that will
- * be pulled from the producer as soon as possible.
- *
- * @since 1.18.0
+ * Fx is a push-based reactive primitive built atop of Effect.
+ * @since 1.20.0
  */
 import * as Cause from "effect/Cause";
 import * as Effect from "effect/Effect";
 import * as Either from "effect/Either";
-import { constant, dual, identity } from "effect/Function";
+import { dual, identity } from "effect/Function";
+import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
+import { hasProperty } from "effect/Predicate";
+import * as Queue from "effect/Queue";
+import * as Schedule from "effect/Schedule";
+import * as Emitter from "./Emitter.js";
 import * as core from "./internal/core.js";
-import * as primitive from "./internal/fx-primitive.js";
-import * as internal from "./internal/fx.js";
-import * as internalKeyed from "./internal/keyed.js";
-import * as internalProtos from "./internal/protos.js";
-import * as internalRun from "./internal/run.js";
-import * as Share from "./internal/share.js";
+import * as coreKeyed from "./internal/keyed.js";
+import * as protos from "./internal/protos.js";
+import * as coreShare from "./internal/share.js";
 import * as strategies from "./internal/strategies.js";
-import * as internalWithKey from "./internal/withKey.js";
+import * as coreWithKey from "./internal/withKey.js";
 import { transform } from "./RefSubject.js";
+import * as Sink from "./Sink.js";
 import { TypeId } from "./TypeId.js";
+/**
+ * @since 1.20.0
+ */
+export function isFx(u) {
+    return u === null ? false : hasProperty(u, TypeId);
+}
 /**
  * Singleton instance of Unbounded
- * @since 1.18.0
+ * @since 1.20.0
  * @category FlattenStrategy
  */
 export const Unbounded = strategies.Unbounded;
 /**
  * Construct a Bounded strategy
- * @since 1.18.0
+ * @since 1.20.0
  * @category FlattenStrategy
  */
 export const Bounded = strategies.Bounded;
 /**
  * Singleton instance of Switch
- * @since 1.18.0
+ * @since 1.20.0
  * @category FlattenStrategy
  */
 export const Switch = strategies.Switch;
 /**
  * Singleton instance of Exhaust
- * @since 1.18.0
+ * @since 1.20.0
  * @category FlattenStrategy
  */
 export const Exhaust = strategies.Exhaust;
 /**
  * Singleton instance of ExhaustLatest
- * @since 1.18.0
+ * @since 1.20.0
  * @category FlattenStrategy
  */
 export const ExhaustLatest = strategies.ExhaustLatest;
 /**
  * Construct an Unordered strategy
- * @since 1.18.0
+ * @since 1.20.0
  * @category MergeStrategy
  */
 export const Unordered = strategies.Unordered;
 /**
  * Construct an Ordered strategy
- * @since 1.18.0
+ * @since 1.20.0
  * @category MergeStrategy
  */
 export const Ordered = strategies.Ordered;
-/* #endregion */
-/* #region Constructor */
-/* #region Core */
 /**
- * An Fx which will immediately end producing 0 events and 0 errors.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const empty = core.empty;
+export const make = core.make;
 /**
- * Construct an Fx<never, E, A> from a Cause<E>
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const failCause = core.failCause;
+export const succeed = core.succeed;
 /**
- * Construct an Fx<never, never, never> from a defect
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const die = (defect) => failCause(Cause.die(defect));
+export const sync = core.fromSync;
 /**
- * Interrupt the current Fx with the specified FiberId
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const interrupt = (id) => failCause(Cause.interrupt(id));
+export const fromArray = core.fromArray;
 /**
- * Construct an Fx which will fail with the specified error.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const fail = core.fail;
+export const fromIterable = core.fromIterable;
 /**
- * Construct an Fx<R, E, A> from an Effect<R, E, A>
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
 export const fromEffect = core.fromEffect;
 /**
- * Construct an Fx from an Iterable
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const fromIterable = core.fromIterable;
+export const fromScheduled = dual(2, core.fromScheduled);
 /**
- * Construct an Fx<R, E, A> from an Effect<R, E, A>
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const fromStream = core.fromStream;
+export const schedule = dual(2, core.schedule);
 /**
- * Construct an Fx<R, E, A> from an Effect<R, E, A>
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const from = core.from;
+export const periodic = dual(2, (iterator, period) => continueWith(fromEffect(iterator), () => schedule(iterator, Schedule.spaced(period))));
 /**
- * Construct an Fx by describing an Effectful workflow that has access to a Sink
- * to emit events and errors.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const fromSink = core.fromSink;
+export const failCause = core.failCause;
 /**
- * Construct an Fx by describing an Scoped Effect that has access to an Emitter
- * to emit events and errors.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const fromEmitter = core.fromEmitter;
+export const fail = core.fail;
 /**
- * An Fx which will never emit any errors or events, and will never end
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const never = core.never;
+export const die = core.die;
 /**
- * Construct an Fx which will emit the specified value and then end.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const succeed = core.succeed;
+export const map = dual(2, core.map);
 /**
- * Construct an Fx which will emit the return of a synchronous function and then end.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const sync = core.sync;
+export const filter = dual(2, core.filter);
 /**
- * Lazily construct an Fx.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const suspend = core.suspend;
+export const filterMap = dual(2, core.filterMap);
 /**
- * Helper for constructing your own custom subtypes of an Fx
- * @since 1.18.0
- * @category Subtyping
+ * @since 1.20.0
  */
-export class ToFx extends primitive.ToFx {
-}
+export const compact = (fx) => filterMap(fx, identity);
 /**
- * Create an Fx which will emit a value after waiting for a specified duration.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const at = internal.at;
+export const mapEffect = dual(2, core.mapEffect);
 /**
- * Construct an Fx which can fork effects into a Scope.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const withScopedFork = core.withScopedFork;
+export const filterMapEffect = dual(2, core.filterMapEffect);
 /**
- * Construct an Fx which can exit early from a Scope.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const withEarlyExit = core.withEarlyExit;
+export const filterEffect = dual(2, core.filterEffect);
 /**
- * Construct an Fx which can flatten nested Fx.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const withFlattenStrategy = core.withFlattenStrategy;
-/* #endregion */
-/* #region Additions */
+export const tapEffect = dual(2, core.tapEffect);
 /**
- * Acquire a resource, use it to construct an Fx, and then release the resource
- * after the Fx has exited.
- *
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const acquireUseRelease = core.acquireUseRelease;
+export const tap = dual(2, (fx, f) => tapEffect(fx, (a) => Effect.sync(() => f(a))));
 /**
- * Combine multiple Fx into a single Fx that will emit the results of all Fx
- * as a tuple of values.
- *
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const combine = core.combine;
+export const loop = dual(3, core.loop);
 /**
- * Combine a record of Fx into a single Fx that will emit the results of all Fx
- * as a record of values.
- *
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const struct = (fx) => map(combine(Object.entries(fx).map(([k, fx]) => map(fx, (v) => [k, v]))), Object.fromEntries);
+export const filterMapLoop = dual(3, core.filterMapLoop);
 /**
- * Combine multiple Fx into a single Fx that will emit the results of all Fx
- * as they occur.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const merge = core.merge;
+export const loopEffect = dual(3, core.loopEffect);
 /**
- * Combine multiple Fx into a single Fx that will emit the results of all Fx
- * as they occur, but only allowing `n` concurrent Fx to run at a time.
- *
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const mergeConcurrently = core.mergeConcurrently;
+export const filterMapLoopEffect = dual(3, core.filterMapLoopEffect);
 /**
- * Combine multiple Fx into a single Fx that will emit the results of all Fx
- * in the order the Fx were provided. All Fx will be executed concurrently,
- * and the results will be buffered if necessary to preserve ordering.
- *
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const mergeBuffer = core.mergeBuffer;
+export const observe = dual(2, core.observe);
 /**
- * Combine multiple Fx into a single Fx that will emit the results of all Fx
- * in the order the Fx were provided. All Fx will be executed concurrently, limited
- * by the provided concurrency, and the results will be buffered if necessary to preserve ordering.
- *
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const mergeBufferConcurrently = core.mergeBufferConcurrently;
+export const drain = core.drain;
 /**
- * Merge together multiple Fx into a single Fx that will emit the results of all Fx
- * allowing only 1 Fx to run at a time.
- *
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const mergeSwitch = (fxs) => core.mergeSwitch(fxs);
+export const reduce = dual(3, core.reduce);
 /**
- * Merge together multiple Fx into a single Fx that will emit the results of the
- * first Fx to emit a value.
- *
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const race = core.race;
+export const toReadonlyArray = core.toReadonlyArray;
 /**
- * Schedule an Effect to run using the provided Schedule, emitting its success of failure
- * at the intervals specified by the Schedule.
- *
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const fromScheduled = core.fromScheduled;
+export const slice = dual(3, core.slice);
 /**
- * Schedule an Effect to run at the specified duration.
- *
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const periodic = core.periodic;
+export const take = dual(2, core.take);
 /**
- * Consume a Dequeue as soon as values become available and emit them as a Fx.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const fromDequeue = internal.fromDequeue;
+export const drop = dual(2, core.drop);
 /**
- * Consume a PubSub as soon as values become available and emit them as a Fx.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const fromPubSub = internal.fromPubSub;
-/* #endregion */
-/* #region Running */
+export const skipRepeats = core.skipRepeats;
 /**
- * Run an Fx to completion with the provided Sink. The
- * Effect will resolve with the first Error of the Fx.
- * @since 1.18.0
- * @category running
+ * @since 1.20.0
  */
-export const run = dual(2, internalRun.run);
+export const skipRepeatsWith = dual(2, core.skipRepeatsWith);
 /**
- * Observe an Fx with the provided success value handler. The
- * Effect will resolve with the first Error of the Fx.
- *
- * @since 1.18.0
- * @category running
+ * @since 1.20.0
  */
-export const observe = dual(2, core.observe);
+export const empty = core.empty;
 /**
- * Run an Fx to completion. The Effect will resolve with the first Error of the Fx.
- *
- * @since 1.18.0
- * @category running
+ * @since 1.20.0
  */
-export const drain = core.drain;
+export const never = core.never;
 /**
- * Reduce an Fx to a single value.
- * @since 1.18.0
- * @category running
+ * @since 1.20.0
  */
-export const reduce = core.reduce;
+export const padWith = dual(3, core.padWith);
 /**
- * Run an Fx to completion, collecting all emitted values into an Array.
- * @since 1.18.0
- * @category running
+ * @since 1.20.0
  */
-export const toArray = core.toArray;
+export const prependAll = dual(2, core.prependAll);
 /**
- * Run an Fx to completion, collecting all emitted values into a ReadonlyArray.
- * @since 1.18.0
- * @category running
+ * @since 1.20.0
  */
-export const toReadonlyArray = core.toReadonlyArray;
+export const appendAll = dual(2, core.appendAll);
 /**
- * Run an Fx to completion, collecting all emitted values into a Chunk.
- * @since 1.18.0
- * @category running
+ * @since 1.20.0
  */
-export const toChunk = core.toChunk;
+export const prepend = dual(2, core.prepend);
 /**
- * Consume an Fx and place its values into an Enqueue.
- * @since 1.18.0
- * @category running
+ * @since 1.20.0
  */
-export const toEnqueue = internal.toEnqueue;
-/* #endregion */
-/* #region Combinators */
+export const append = dual(2, core.append);
 /**
- * Map over the success value of an Fx.
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const map = core.map;
+export const scan = dual(3, core.scan);
 /**
- * Map over both failure and success values of an Fx.
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const mapBoth = core.mapBoth;
+export const flatMapWithStrategy = dual(4, core.flatMapWithStrategy);
+const isDataFirstFx = (args) => isFx(args[0]);
 /**
- * Filter the success value of an Fx.
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const filter = core.filter;
+export const flatMap = dual(isDataFirstFx, core.flatMap);
 /**
- * Filter and map the success value of an Fx.
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const filterMap = core.filterMap;
+export const flatMapEffect = dual(isDataFirstFx, core.flatMapEffect);
 /**
- * Unwrap Options by filtering any None values.
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const compact = core.compact;
+export const switchMap = dual(isDataFirstFx, core.switchMap);
 /**
- * Map over the Cause  of an Fx.
- * @since 1.18.0
- * @category errors
+ * @since 1.20.0
  */
-export const mapErrorCause = core.mapErrorCause;
+export const switchMapEffect = dual(isDataFirstFx, core.switchMapEffect);
 /**
- * Map over the Error of an Fx.
- * @since 1.18.0
- * @category errors
+ * @since 1.20.0
  */
-export const mapError = core.mapError;
+export const exhaustMap = dual(isDataFirstFx, core.exhaustMap);
 /**
- * Filter the Cause of an Fx.
- * @since 1.18.0
- * @category errors
+ * @since 1.20.0
  */
-export const filterErrorCause = core.filterCause;
+export const exhaustMapEffect = dual(isDataFirstFx, core.exhaustMapEffect);
 /**
- * Filter and map the Cause of an Fx.
- * @since 1.18.0
- * @category errors
+ * @since 1.20.0
  */
-export const filterMapCause = core.filterMapCause;
+export const exhaustMapLatest = dual(isDataFirstFx, core.exhaustMapLatest);
 /**
- * Filter the Error of an Fx.
- * @since 1.18.0
- * @category errors
+ * @since 1.20.0
  */
-export const filterError = core.filterError;
+export const exhaustMapLatestEffect = dual(isDataFirstFx, core.exhaustMapLatestEffect);
 /**
- * Filter and map the error of an Fx.
- * @since 1.18.0
- * @category errors
+ * @since 1.20.0
  */
-export const filterMapError = core.filterMapError;
+export const flatMapConcurrently = dual(isDataFirstFx, core.flatMapConcurrently);
 /**
- * Filter and map the error of an Fx using an Effect.
- * @since 1.18.0
- * @category errors
+ * @since 1.20.0
  */
-export const filterMapErrorEffect = core.filterMapErrorEffect;
+export const flatMapConcurrentlyEffect = dual(isDataFirstFx, core.flatMapConcurrentlyEffect);
 /**
- * Map the success value of an Fx to another Fx, flattening the result
- * with the provided FlattenStrategy.
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const flatMapWithStrategy = dual(3, core.flatMapWithStrategy);
+export const concatMap = dual(isDataFirstFx, core.concatMap);
 /**
- * Map the success value of an Fx to another Fx, switching to the latest
- * Fx emitted and interrupting the previous.
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const switchMap = core.switchMap;
+export const fromFxEffect = core.fromFxEffect;
 /**
- * Map the success value of an Fx to another Fx, switching to the latest
- * Fx emitted and interrupting the previous.
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const switchLatest = core.switchMap((x) => x);
+export const continueWith = dual(2, core.continueWith);
 /**
- * Map the success value of an Fx to another Fx, prefering the first
- * Fx emitted and dropping any subsequent Fx until it has completed.
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const exhaustMap = core.exhaustMap;
+export const orElseCause = dual(2, core.orElseCause);
 /**
- * Flatten a nested Fx, prefering the first
- * Fx emitted and dropping any subsequent Fx until it has completed.
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const exhaust = core.exhaust;
+export const orElse = dual(2, core.orElse);
 /**
- * Map the success value of an Fx to another Fx, prefering the first
- * until completion, and then running the last emitted Fx if they are not
- * the same Fx.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const exhaustMapLatest = core.exhaustMapLatest;
+export const suspend = core.suspend;
 /**
- * Flatten a nested Fx, prefering the first until completion, and then running the last emitted Fx if they are not
- * the same Fx.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const exhaustLatest = core.exhaustLatest;
+export const mergeWithStrategy = dual(2, core.mergeWithStrategy);
 /**
- * Map the success value of an Fx to another Fx with unbounded concurrency.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const flatMap = core.flatMap;
+export const merge = dual(2, core.merge);
 /**
- * Map the success value of an Fx to another Fx with unbounded concurrency.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const flatten = core.flatten;
+export const mergeAll = core.mergeAll;
 /**
- * Map the success value of an Fx to another Fx with the specified concurrency.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const flatMapConcurrently = core.flatMapConcurrently;
+export const mergeOrdered = core.mergeOrdered;
 /**
- * Map the success value of an Fx to another Fx one at a time.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const concatMap = core.concatMap;
+export const mergeOrderedConcurrently = core.mergeOrderedConcurrently;
 /**
- * Skip and take a number of values from an Fx.
- *
- * @since 1.18.0
- * @category slicing
+ * @since 1.20.0
  */
-export const slice = core.slice;
+export const mergeSwitch = core.mergeSwitch;
 /**
- * Take a number of values from an Fx.
- *
- * @since 1.18.0
- * @category slicing
+ * @since 1.20.0
  */
-export const take = core.take;
+export const takeWhile = dual(2, core.takeWhile);
 /**
- * Drop a number of values from an Fx.
- *
- * @since 1.18.0
- * @category slicing
+ * @since 1.20.0
  */
-export const drop = core.drop;
+export const takeUntil = dual(2, core.takeUntil);
 /**
- * Take values from an Fx while the predicate returns true.
- *
- * @since 1.18.0
- * @category slicing
+ * @since 1.20.0
  */
-export const takeWhile = core.takeWhile;
+export const dropWhile = dual(2, core.dropWhile);
 /**
- * Take values from an Fx until the predicate returns true.
- *
- * @since 1.18.0
- * @category slicing
+ * @since 1.20.0
  */
-export const takeUntil = core.takeUntil;
+export const dropUntil = dual(2, core.dropUntil);
 /**
- * Drop values from an Fx while the predicate returns true.
- *
- * @since 1.18.0
- * @category slicing
+ * @since 1.20.0
  */
-export const dropWhile = core.dropWhile;
+export const dropAfter = dual(2, core.dropAfter);
 /**
- * Drop values from an Fx until the predicate returns true.
- *
- * @since 1.18.0
- * @category slicing
+ * @since 1.20.0
  */
-export const dropUntil = core.dropUntil;
+export const takeWhileEffect = dual(2, core.takeWhileEffect);
 /**
- * Drop values from an Fx after the predicate returns true.
- *
- * @since 1.18.0
- * @category slicing
+ * @since 1.20.0
  */
-export const dropAfter = core.dropAfter;
+export const takeUntiEffect = dual(2, core.takeUntilEffect);
 /**
- * Concatenate an Fx after the successful completion of another Fx
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const continueWith = core.continueWith;
+export const dropWhileEffect = dual(2, core.dropWhileEffect);
 /**
- * Concatenate an Fx after the failure of another Fx
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const orElse = core.recoverWith;
+export const dropUntilEffect = dual(2, core.dropUntilEffect);
 /**
- * Map the success value of an Fx to an Effect, doesn't fork any fibers like flatMap* etc.
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const mapEffect = core.mapEffect;
+export const dropAfterEffect = dual(2, core.dropAfterEffect);
 /**
- * Perform an Effect for each value emitted by an Fx, not affecting the output of the Fx.
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const tap = core.tap;
+export const during = dual(2, core.during);
 /**
- * Filter the success value of an Fx with an Effect.
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const filterEffect = core.filterEffect;
+export const since = dual(2, core.since);
 /**
- * Filter and map the success value of an Fx with an Effect.
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const filterMapEffect = core.filterMapEffect;
+export const until = dual(2, core.until);
 /**
- * Apply a function to the constructed Effect that represents the running Fx.
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const middleware = core.middleware;
+export const middleware = dual(isDataFirstFx, core.middleware);
 /**
- * Accumulate a value over the success values of an Fx and atomically produce derived value.
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const loop = core.loop;
+export const onExit = dual(2, core.onExit);
 /**
- * Emit values with their previously emitted values when possible.
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const withPrevious = (fx) => loop(fx, Option.none(), (previous, current) => [[previous, current], Option.some(current)]);
+export const onInterrupt = dual(2, core.onInterrupt);
 /**
- * Accumulate a value over the success values of an Fx and atomically produce derived value
- * useing an Effect. A SynchronizedRef is utilized to ensure ordering of events.
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const loopEffect = core.loopEffect;
+export const onError = dual(2, core.onError);
 /**
- * Prepends a value to the beginning of an Fx.
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const startWith = core.startWith;
+export const scoped = core.scoped;
 /**
- * Appends a value to the end of an Fx.
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const endWith = core.endWith;
+export const annotateLogs = dual(isDataFirstFx, core.annotateLogs);
 /**
- * Run a reducer over the success values of an Fx.
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const scan = core.scan;
+export const annotateSpans = dual(isDataFirstFx, core.annotateSpans);
 /**
- * Run an Effect-ful reducer over the success values of an Fx.
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const scanEffect = core.scanEffect;
+export const interruptible = core.interruptible;
 /**
- * Map the failures of an Fx to another Fx, flattening the result
- * with the provided FlattenStrategy.
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const flatMapCauseWithStrategy = core.flatMapCauseWithStrategy;
+export const uninterruptible = core.uninterruptible;
 /**
- * Map the failures of an Fx to another Fx, flattening the result
- * with the provided FlattenStrategy.
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const flatMapErrorWithStrategy = core.flatMapErrorWithStrategy;
+export const locally = dual(3, core.locally);
 /**
- * Map the failures of an Fx to another Fx, flattening the result with unbounded concurrency.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const flatMapCause = core.flatMapCause;
+export const locallyWith = dual(3, core.locallyWith);
 /**
- * Map the failures of an Fx to another Fx, flattening the result with unbounded concurrency.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const flatMapError = core.flatMapError;
+export const withTracerTiming = dual(2, core.withTracerTiming);
 /**
- * Map the failures of an Fx to another Fx with the specified concurrency.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const flatMapCauseConcurrently = core.flatMapCauseConcurrently;
+export const withConcurrency = dual(2, core.withConcurrency);
 /**
- * Map the failures of an Fx to another Fx with the specified concurrency.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const flatMapErrorConcurrently = core.flatMapErrorConcurrently;
+export const withConfigProvider = dual(2, core.withConfigProvider);
 /**
- * Map the failures of an Fx to another Fx, switching to the latest
- * Fx emitted and interrupting the previous.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const switchMapCause = core.switchMapCause;
+export const withLogSpan = dual(2, core.withLogSpan);
 /**
- * Map the failures of an Fx to another Fx, switching to the latest
- * Fx emitted and interrupting the previous.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const switchMapError = core.switchMapError;
+export const withMaxOpsBeforeYield = dual(2, core.withMaxOpsBeforeYield);
 /**
- * Map the failures of an Fx to another Fx, prefering the first
- * Fx emitted and dropping any subsequent Fx until it has completed.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const exhaustMapCause = core.exhaustMapCause;
+export const withParentSpan = dual(2, core.withParentSpan);
 /**
- * Map the failures of an Fx to another Fx, prefering the first
- * Fx emitted and dropping any subsequent Fx until it has completed.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const exhaustMapError = core.exhaustMapError;
+export const withRequestBatching = dual(2, core.withRequestBatching);
 /**
- * Map the failures of an Fx to another Fx, prefering the first
- * until completion, and then running the last emitted Fx if they are not
- * the same Fx.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const exhaustMapLatestCause = core.exhaustMapLatestCause;
+export const withRequestCache = dual(2, core.withRequestCache);
 /**
- * Map the failures of an Fx to another Fx,  prefering the first
- * until completion, and then running the last emitted Fx if they are not
- * the same Fx.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const exhaustMapLatestError = core.exhaustMapLatestError;
+export const withRequestCaching = dual(2, core.withRequestCaching);
 /**
- * Map over the failures and successes of an Fx, flattening both using the same strategy.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const matchCauseWithStrategy = core.matchCauseWithStrategy;
+export const withTracer = dual(2, core.withTracer);
 /**
- * Map over the failures and successes of an Fx, flattening both using the same strategy.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const matchErrorWithStrategy = core.matchErrorWithStrategy;
+export const acquireUseRelease = dual(3, core.acquireUseRelease);
 /**
- * Map over the failures and successes of an Fx, flattening both with unbounded concurrency.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const matchCause = core.matchCause;
+export const withSpan = dual(3, core.withSpan);
 /**
- * Map over the failures and successes of an Fx, flattening both with unbounded concurrency.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const match = core.match;
+export const provideContext = dual(2, core.provideContext);
 /**
- * Map over the failures and successes of an Fx, flattening both with the specified concurrency.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const matchCauseConcurrently = core.matchCauseConcurrently;
+export const provideLayer = dual(2, core.provideLayer);
 /**
- * Map over the failures and successes of an Fx, flattening both with the specified concurrency.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const matchErrorConcurrently = core.matchErrorConcurrently;
+export const provideRuntime = dual(2, core.provideRuntime);
 /**
- * Map over the failures and successes of an Fx, switching to the latest
- * Fx emitted and interrupting the previous.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const switchMatchCause = core.switchMatchCause;
+export const provideService = dual(3, core.provideService);
 /**
- * Map over the failures and successes of an Fx, switching to the latest
- * Fx emitted and interrupting the previous.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const switchMatch = core.switchMatch;
+export const provideServiceEffect = dual(3, core.provideServiceEffect);
 /**
- * Map over the failures and successes of an Fx, prefering the first
- * Fx emitted and dropping any subsequent Fx until it has completed.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const exhaustMatchCause = core.exhaustMatchCause;
+export const provide = dual(2, core.provide);
 /**
- * Map over the failures and successes of an Fx, prefering the first
- * Fx emitted and dropping any subsequent Fx until it has completed.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const exhaustMatch = core.exhaustMatch;
+export const share = dual(2, coreShare.share);
 /**
- * Map over the failures and successes of an Fx, prefering the first
- * Fx emitted and starting the latest Fx when the first completes
- * if they are not the same Fx.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const exhaustLatestMatchCause = core.exhaustLatestMatchCause;
+export const multicast = coreShare.multicast;
 /**
- * Map over the failures and successes of an Fx, prefering the first
- * Fx emitted and starting the latest Fx when the first completes
- * if they are not the same Fx.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export const exhaustLatestMatch = core.exhaustLatestMatch;
+export const hold = coreShare.hold;
 /**
- * Listen to the events of an Fx within the provided window. When the window Fx
- * emits the inner stream, the fx will begin allowing events to pass through,
- * and when the inner stream emits, the fx will be interrupted.
- *
- * @since 1.18.0
- * @category time slicing
+ * @since 1.20.0
  */
-export const during = core.during;
+export const replay = dual(2, coreShare.replay);
 /**
- * Listen to the events of an Fx after the provided window emits.
- *
- * @since 1.18.0
- * @category time slicing
+ * @since 1.20.0
  */
-export const since = core.since;
+export const mapCause = dual(2, core.mapCause);
 /**
- * Listen to the events of an Fx until the provided window emits.
- *
- * @since 1.18.0
- * @category time slicing
+ * @since 1.20.0
  */
-export const until = core.until;
+export const mapError = dual(2, core.mapError);
 /**
- * Provide the environment to an Fx.
- *
- * @since 1.18.0
- * @category context
+ * @since 1.20.0
  */
-export const provide = core.provide;
+export const mapBoth = dual(3, core.mapBoth);
 /**
- * Provide a service to an Fx using a Tag.
- * @since 1.18.0
- * @category context
+ * @since 1.20.0
  */
-export const provideService = core.provideService;
+export const filterCause = dual(2, core.filterCause);
 /**
- * Provide a service using an Effect to an Fx using a Tag.
- *
- * @since 1.18.0
- * @category context
+ * @since 1.20.0
  */
-export const provideServiceEffect = core.provideServiceEffect;
+export const filterError = dual(2, core.filterError);
 /**
- * Skip repeated values, using the provided Equivalence to compare values.
- *
- * @since 1.18.0
- * @category slicing
+ * @since 1.20.0
  */
-export const skipRepeatsWith = core.skipRepeatsWith;
+export const filterMapCause = dual(2, core.filterMapCause);
 /**
- * Skip repeated values, using @effect/data/Equal for value comparison.
- *
- * @since 1.18.0
- * @category slicing
+ * @since 1.20.0
  */
-export const skipRepeats = core.skipRepeats;
+export const filterMapError = dual(2, core.filterMapError);
 /**
- * Sample the values of an Fx, or Effect, during the events of another Fx.
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const snapshot = core.snapshot;
+export const mapCauseEffect = dual(2, core.mapCauseEffect);
 /**
- * Share the output of an Fx, or Effect, with other Fx's using the behavior of the
- * provided Subject.
- *
- * @since 1.18.0
- * @category sharing
+ * @since 1.20.0
  */
-export const share = Share.share;
+export const mapErrorEffect = dual(2, core.mapErrorEffect);
 /**
- * Effeciently share an underlying stream with multiple subscribers.
- *
- * @since 1.18.0
- * @category sharing
+ * @since 1.20.0
  */
-export const multicast = Share.multicast;
+export const filterCauseEffect = dual(2, core.filterCauseEffect);
 /**
- * Effeciently share an underlying stream with multiple subscribers, saving the most
- * recent event and emitting it to new subscribers.
- *
- * @since 1.18.0
- * @category sharing
+ * @since 1.20.0
  */
-export const hold = Share.hold;
+export const filterErrorEffect = dual(2, core.filterErrorEffect);
 /**
- * Effeciently share an underlying stream with multiple subscribers,
- * saving up to the most recent `n` events and emitting them to new subscribers.
- *
- * @since 1.18.0
- * @category sharing
+ * @since 1.20.0
  */
-export const replay = Share.replay;
+export const filterMapCauseEffect = dual(2, core.filterMapCauseEffect);
 /**
- * Create an Fx which will wait a specified duration of time where no
- * events have occurred before emitting a value.
- * @since 1.18.0
- * @category time slicing
+ * @since 1.20.0
  */
-export const debounce = internal.debounce;
+export const filterMapErrorEffect = dual(2, core.filterMapErrorEffect);
 /**
- * Create an Fx which will wait a specified duration of time before emitting
- * an event after the last event.
- * @since 1.18.0
- * @category time slicing
+ * @since 1.20.0
  */
-export const throttle = internal.throttle;
+export const loopCause = dual(3, core.loopCause);
 /**
- * Create an Fx which will wait a specified duration of time where no
- * events have occurred before emitting a value.
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const delay = internal.delay;
+export const loopError = dual(3, core.loopError);
 /**
- * Run an Effect to produce an Fx to run.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const fromFxEffect = internal.fromFxEffect;
+export const loopCauseEffect = dual(3, core.loopCauseEffect);
 /**
- * Utilize Effect.gen to construct an Fx
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export function gen(f) {
-    return fromFxEffect(Effect.gen(f));
-}
+export const loopErrorEffect = dual(3, core.loopErrorEffect);
 /**
- * Utilize Effect.gen to construct an Fx
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export function genScoped(f) {
-    return scoped(fromFxEffect(Effect.gen(f)));
-}
+export const filterMapLoopCause = dual(3, core.filterMapLoopCause);
 /**
- * Run an Effect when an Fx exits
- * @since 1.18.0
- * @category lifecycles
+ * @since 1.20.0
  */
-export const onExit = internal.onExit;
+export const filterMapLoopError = dual(3, core.filterMapLoopError);
 /**
- * Run an Effect when an Fx is interrupted
- * @since 1.18.0
- * @category lifecycles
+ * @since 1.20.0
  */
-export const onInterrupt = internal.onInterrupt;
+export const filterMapLoopCauseEffect = dual(3, core.filterMapLoopCauseEffect);
 /**
- * Run an Effect when an Fx ends with an error
- * @since 1.18.0
- * @category lifecycles
+ * @since 1.20.0
  */
-export const onError = internal.onError;
+export const filterMapLoopErrorEffect = dual(3, core.filterMapLoopErrorEffect);
 /**
- * Provide a Scope to an Fx
- * @since 1.18.0
- * @category context
+ * @since 1.20.0
  */
-export const scoped = internal.scoped;
+export const flatMapCauseWithStrategy = dual(isDataFirstFx, core.flatMapCauseWithStrategy);
 /**
- * Annotate the logs of an Fx
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const annotateLogs = internal.annotateLogs;
+export const flatMapErrorWithStrategy = dual(isDataFirstFx, core.flatMapErrorWithStrategy);
 /**
- * Annotate the spans of an Fx
- * @since 1.18.0
- * @category combinators
- */
-export const annotateSpans = internal.annotateSpans;
-/**
- * Create an Fx which will succeed with Option.None
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const succeedNone = internal.succeedNone;
+export const switchMapCause = dual(isDataFirstFx, core.switchMapCause);
 /**
- * Create an Fx which will succeed with Option.Some
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const succeedSome = internal.succeedSome;
+export const switchMapError = dual(isDataFirstFx, core.switchMapError);
 /**
- * Do simulation
- * @since 1.18.0
- * @category Do
+ * @since 1.20.0
  */
-export const Do = internal.Do;
+export const flatMapCause = dual(isDataFirstFx, core.flatMapCause);
 /**
- * Do simulation
- * @since 1.18.0
- * @category Do
+ * @since 1.20.0
  */
-export const bind = internal.bind;
+export const flatMapError = dual(isDataFirstFx, core.flatMapError);
 /**
- * Do simulation
- * @since 1.18.0
- * @category Do
+ * @since 1.20.0
  */
-export const bindTo = internal.bindTo;
-const let_ = internal.let;
-export { 
+export const flatMapCauseConcurrently = dual(isDataFirstFx, core.flatMapCauseConcurrently);
 /**
- * Do simulation
- * @since 1.18.0
- * @category Do
+ * @since 1.20.0
  */
-let_ as let };
+export const flatMapErrorConcurrently = dual(isDataFirstFx, core.flatMapErrorConcurrently);
 /**
- * Ensure a finalizer runs on Fx ext.
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const ensuring = internal.ensuring;
+export const exhaustMapCause = dual(isDataFirstFx, core.exhaustMapCause);
 /**
- * Capture the errors and success values as Exit
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const exit = internal.exit;
+export const exhaustMapError = dual(isDataFirstFx, core.exhaustMapError);
 /**
- * Capture the errors and success values as Either
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const either = internal.either;
+export const exhaustMapLatestCause = dual(isDataFirstFx, core.exhaustMapLatestCause);
 /**
- * Run an Fx until finding a value which satisfies the predicate.
- * @since 1.18.0
- * @category running
+ * @since 1.20.0
  */
-export const findFirst = internal.findFirst;
+export const exhaustMapLatestError = dual(isDataFirstFx, core.exhaustMapLatestError);
 /**
- * Grab the first value emitted by an Fx
- * @since 1.18.0
- * @category running
+ * @since 1.20.0
  */
-export const first = findFirst(constant(Effect.succeed(true)));
+export const matchCauseWithStrategy = dual(3, core.matchCauseWithStrategy);
 /**
- * Transform success values into failures and failures into successes.
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const flip = internal.flip;
+export const matchErrorWithStrategy = dual(3, core.matchErrorWithStrategy);
 /**
- * Lift a nullable value into an Fx
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export const fromNullable = internal.fromNullable;
-const if_ = internal.if;
-export { 
+export const matchCause = dual(2, core.matchCause);
 /**
- * Logical if/else using Fx.
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-if_ as if };
+export const matchError = dual(2, core.matchError);
 /**
- * Logical if/else using static values.
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const when = internal.when;
+export const matchCauseConcurrently = dual(3, core.matchCauseConcurrently);
 /**
- * Mark an Fx as interruptible
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const interruptible = internal.interruptible;
+export const matchErrorConcurrently = dual(3, core.matchErrorConcurrently);
 /**
- * Mark an Fx as uninterruptible
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const uninterruptible = internal.uninterruptible;
+export const switchMatchCause = dual(2, core.switchMatchCause);
 /**
- * Locally set the value of a FiberRef
- * @since 1.18.0
- * @category FiberRef
+ * @since 1.20.0
  */
-export const locally = internal.locally;
+export const switchMatchError = dual(2, core.switchMatchError);
 /**
- * Locally set the value of a FiberRef by updating the current value
- * @since 1.18.0
- * @category FiberRef
+ * @since 1.20.0
  */
-export const locallyWith = internal.locallyWith;
+export const exhaustMatchCause = dual(2, core.exhaustMatchCause);
 /**
- * Enable/disable tracer timing for an Fx
- * @since 1.18.0
- * @category tracing
+ * @since 1.20.0
  */
-export const withTracerTiming = internal.withTracerTiming;
+export const exhaustMatchError = dual(2, core.exhaustMatchError);
 /**
- * Configure the concurreny limit of Fibers running within an Fx
- * @since 1.18.0
- * @category concurrency
+ * @since 1.20.0
  */
-export const withConcurrency = internal.withConcurrency;
+export const exhaustMatchLatestCause = dual(2, core.exhaustMatchLatestCause);
 /**
- * Add a span to your log messages
- * @since 1.18.0
- * @category logging
+ * @since 1.20.0
  */
-export const withLogSpan = internal.withLogSpan;
+export const exhaustMatchLatestError = dual(2, core.exhaustMatchLatestError);
 /**
- * Configure the maximum number of operations to run before yielding to the runtime
- * @since 1.18.0
- * @category concurrency
+ * @since 1.20.0
  */
-export const withMaxOpsBeforeYield = internal.withMaxOpsBeforeYield;
+export const exit = core.exit;
 /**
- * Set the parent Span of an Fx
- * @since 1.18.0
- * @category tracing
+ * @since 1.20.0
  */
-export const withParentSpan = internal.withParentSpan;
+export const either = core.either;
 /**
- * Enable/disable request batching within an Fx
- * @since 1.18.0
- * @category batching
+ * @since 1.20.0
  */
-export const withRequestBatching = internal.withRequestBatching;
+export const tuple = core.tuple;
 /**
- * Set the request cache Effects running within an Fx
- * @since 1.18.0
- * @category batching
+ * @since 1.20.0
  */
-export const withRequestCache = internal.withRequestCache;
+export const struct = core.struct;
 /**
- * Enable/disable request caching within an Fx
- * @since 1.18.0
- * @category batching
+ * @since 1.20.0
  */
-export const withRequestCaching = internal.withRequestCaching;
+export const all = core.all;
 /**
- * Configure the scheduler to use within an Fx
- * @since 1.18.0
- * @category concurrency
+ * @since 1.20.0
  */
-export const withScheduler = internal.withScheduler;
+export const toEnqueue = dual(2, core.toEnqueue);
 /**
- * Set the span of an Fx
- * @since 1.18.0
- * @category tracing
+ * @since 1.20.0
  */
-export const withSpan = internal.withSpan;
+export const debounce = dual(2, core.debounce);
 /**
- * Set the tracer used within an Fx
- * @since 1.18.0
- * @category tracing
+ * @since 1.20.0
  */
-export const withTracer = internal.withTracer;
+export const throttle = dual(2, core.throttle);
 /**
- * Partition an Fx into two Fx's based on a either-returning function.
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const partitionMap = internal.partitionMap;
+export const throttleLatest = dual(2, core.throttleLatest);
 /**
- * Convert a list of keyed values into persistent workflows for given each key of the list
- * even when the list has been re-ordered.
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const keyed = dual(3, internalKeyed.keyed);
+export const keyed = dual(2, coreKeyed.keyed);
 /**
- * Map an Fx of values into workflows similar to Fx.switchMap, but
- * instead of providing the value directly, it is exposed as a RefSubject to
- * allow creating a persistent workflows similar to Fx.keyed but for a single value.
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export const withKey = dual(3, internalWithKey.withKey);
+export const withKey = dual(2, coreWithKey.withKey);
 const getTag = (a) => a._tag;
 /**
  * Match over a tagged union of values into a set of persistent workflows
  * that allow listening to changes of values with the same tag using the same
  * Fx.
  *
- * @since 1.18.0
+ * @since 1.20.0
  * @category combinators
  */
 export const matchTags = dual(2, function matchTags(fx, matchers) {
-    return withKey(fx, getTag, (ref, tag) => matchers[tag](ref));
+    return withKey(fx, {
+        getKey: getTag,
+        onValue: (ref, tag) => matchers[tag](ref)
+    });
 });
 /**
- * @since 1.18.0
- */
-export const drainLayer = internal.drainLayer;
-/* #endregion */
-/**
- * @since 1.18.0
- */
-export function isFx(u) {
-    return typeof u === "object" && u !== null && TypeId in u;
-}
-/**
- * @since 1.18.0
+ * @since 1.20.0
  */
 export const matchOption = dual(3, function matchOption(fx, onNone, onSome) {
     return matchTags(fx, {
@@ -1262,13 +763,13 @@ export const matchOption = dual(3, function matchOption(fx, onNone, onSome) {
     });
 });
 /**
- * @since 1.18.0
+ * @since 1.20.0
  */
 export const getOrElse = dual(2, function getOrElse(fx, orElse) {
     return matchOption(fx, orElse, identity);
 });
 /**
- * @since 1.18.0
+ * @since 1.20.0
  */
 export const matchEither = dual(3, function matchEither(fx, onLeft, onRight) {
     return matchTags(fx, {
@@ -1277,28 +778,162 @@ export const matchEither = dual(3, function matchEither(fx, onLeft, onRight) {
     });
 });
 /**
- * @since 1.18.0
+ * @since 1.20.0
+ */
+export const at = dual(2, (value, duration) => fromEffect(Effect.delay(Effect.succeed(value), duration)));
+/**
+ * @since 1.20.0
+ */
+export function drainLayer(...fxs) {
+    return Layer.scopedDiscard(Effect.forkWithErrorHandler(core.drain(core.mergeAll(fxs)), Effect.logError));
+}
+/**
+ * @since 1.20.0
  */
 export const fork = (fx) => Effect.fork(drain(fx));
 /**
- * @since 1.18.0
+ * @since 1.20.0
  */
 export const forkScoped = (fx) => Effect.forkScoped(drain(fx));
 /**
- * @since 1.18.0
+ * @since 1.20.0
  */
 export const forkDaemon = (fx) => Effect.forkDaemon(drain(fx));
 /**
- * @since 1.18.0
+ * @since 1.20.0
  */
 export const forkIn = dual(2, (fx, scope) => Effect.forkIn(drain(fx), scope));
 /**
- * @since 1.18.0
+ * @since 1.20.0
+ */
+export const fromAsyncIterable = core.fromAsyncIterable;
+/**
+ * @since 1.20.0
+ */
+export const partitionMap = dual(2, function partitionMap(fx, f) {
+    const source = coreShare.multicast(core.map(fx, f));
+    return [
+        core.filterMap(source, Either.getLeft),
+        core.filterMap(source, Either.getRight)
+    ];
+});
+/**
+ * @since 1.20.0
+ */
+export const gen = core.gen;
+/**
+ * @since 1.20.0
+ */
+export const genScoped = core.genScoped;
+/**
+ * @since 1.20.0
+ */
+export const findFirst = dual(2, core.findFirst);
+/**
+ * @since 1.20.0
+ */
+export const first = core.first;
+/**
+ * @since 1.20.0
+ */
+export const mergeFirst = dual(2, core.mergeFirst);
+/**
+ * @since 1.20.0
+ */
+export const mergeRace = dual(2, core.mergeRace);
+/**
+ * @since 1.20.0
+ */
+export const raceAll = core.raceAll;
+/**
+ * @since 1.20.0
+ */
+export const race = dual(2, core.race);
+/**
+ * @since 1.20.0
+ */
+export const snapshot = dual(3, core.snapshot);
+/**
+ * @since 1.20.0
  */
-export const mergeRace = internal.mergeRace;
+export const sample = dual(2, core.sample);
 /**
+ * @since 1.20.0
+ */
+export const snapshotEffect = dual(3, core.snapshotEffect);
+const if_ = dual(2, core.if);
+export { 
+/**
+ * @since 1.20.0
+ */
+if_ as if };
+/**
+ * @since 1.20.0
+ */
+export const when = dual(2, core.when);
+/**
+ * @since 1.20.0
+ */
+export const withEmitter = (f) => core.make((sink) => Emitter.withEmitter(sink, f));
+/**
+ * Create an Fx which will wait a specified duration of time where no
+ * events have occurred before emitting a value.
  * @since 1.18.0
  */
-export class FxEffectBase extends internalProtos.FxEffectBase {
+export const delay = dual(2, function (fx, delay) {
+    return core.flatMap(fx, (a) => core.fromEffect(Effect.delay(Effect.succeed(a), delay)));
+});
+/**
+ * @since 1.20.0
+ */
+export const ensuring = dual(2, function (self, finalizer) {
+    return core.middleware(self, (effect) => Effect.ensuring(effect, finalizer));
+});
+/**
+ * @since 1.20.0
+ */
+export const flip = (fx) => core.make((sink) => fx.run(Sink.make((cause) => Either.match(Cause.failureOrCause(cause), {
+    onLeft: (e) => sink.onSuccess(e),
+    onRight: (c) => sink.onFailure(c)
+}), (a) => sink.onFailure(Cause.fail(a)))));
+/**
+ * @since 1.20.0
+ */
+export const fromNullable = (value) => {
+    if (value === null || value === undefined) {
+        return core.empty;
+    }
+    else {
+        return core.succeed(value);
+    }
+};
+export function fromDequeue(dequeue) {
+    return core.make((sink) => Effect.repeatWhileEffect(Effect.matchCauseEffect(dequeue.take, sink), () => dequeueIsActive(dequeue)));
+}
+/**
+ * @internal
+ */
+export function dequeueIsActive(dequeue) {
+    if (Queue.DequeueTypeId in dequeue) {
+        return Effect.sync(() => dequeue.isActive());
+    }
+    else {
+        return dequeue.isActive;
+    }
+}
+export function fromPubSub(pubSub) {
+    return core.acquireUseRelease(pubSub.subscribe, (q) => fromDequeue(q), (d) => d.shutdown);
+}
+/**
+ * @since 1.20.0
+ */
+export class FxEffectBase extends protos.FxEffectBase {
+    _fx;
+    /**
+     * @since 1.20.0
+     */
+    run(sink) {
+        return (this._fx ||= this.toFx()).run(sink);
+    }
 }
 //# sourceMappingURL=Fx.js.map