@typed/fx 1.17.4 → 1.18.0

package/dist/esm/Fx.js

@@ -0,0 +1,1298 @@
+/**
+ * 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
+ */
+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 * as Option from "effect/Option";
+import * as core from "./internal/core";
+import * as internal from "./internal/fx";
+import * as primitive from "./internal/fx-primitive";
+import * as internalKeyed from "./internal/keyed";
+import * as internalRun from "./internal/run";
+import * as Share from "./internal/share";
+import * as strategies from "./internal/strategies";
+import * as internalWithKey from "./internal/withKey";
+import { transform } from "./RefSubject";
+import { TypeId } from "./TypeId";
+/**
+ * Singleton instance of Unbounded
+ * @since 1.18.0
+ * @category FlattenStrategy
+ */
+export const Unbounded = strategies.Unbounded;
+/**
+ * Construct a Bounded strategy
+ * @since 1.18.0
+ * @category FlattenStrategy
+ */
+export const Bounded = strategies.Bounded;
+/**
+ * Singleton instance of Switch
+ * @since 1.18.0
+ * @category FlattenStrategy
+ */
+export const Switch = strategies.Switch;
+/**
+ * Singleton instance of Exhaust
+ * @since 1.18.0
+ * @category FlattenStrategy
+ */
+export const Exhaust = strategies.Exhaust;
+/**
+ * Singleton instance of ExhaustLatest
+ * @since 1.18.0
+ * @category FlattenStrategy
+ */
+export const ExhaustLatest = strategies.ExhaustLatest;
+/**
+ * Construct an Unordered strategy
+ * @since 1.18.0
+ * @category MergeStrategy
+ */
+export const Unordered = strategies.Unordered;
+/**
+ * Construct an Ordered strategy
+ * @since 1.18.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
+ */
+export const empty = core.empty;
+/**
+ * Construct an Fx<never, E, A> from a Cause<E>
+ * @since 1.18.0
+ * @category constructors
+ */
+export const failCause = core.failCause;
+/**
+ * Construct an Fx<never, never, never> from a defect
+ * @since 1.18.0
+ * @category constructors
+ */
+export const die = (defect) => failCause(Cause.die(defect));
+/**
+ * Interrupt the current Fx with the specified FiberId
+ * @since 1.18.0
+ * @category constructors
+ */
+export const interrupt = (id) => failCause(Cause.interrupt(id));
+/**
+ * Construct an Fx which will fail with the specified error.
+ * @since 1.18.0
+ * @category constructors
+ */
+export const fail = core.fail;
+/**
+ * Construct an Fx<R, E, A> from an Effect<R, E, A>
+ * @since 1.18.0
+ * @category constructors
+ */
+export const fromEffect = core.fromEffect;
+/**
+ * Construct an Fx from an Iterable
+ * @since 1.18.0
+ * @category constructors
+ */
+export const fromIterable = core.fromIterable;
+/**
+ * Construct an Fx<R, E, A> from an Effect<R, E, A>
+ * @since 1.18.0
+ * @category constructors
+ */
+export const fromStream = core.fromStream;
+/**
+ * Construct an Fx<R, E, A> from an Effect<R, E, A>
+ * @since 1.18.0
+ * @category constructors
+ */
+export const from = core.from;
+/**
+ * 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
+ */
+export const fromSink = core.fromSink;
+/**
+ * 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
+ */
+export const fromEmitter = core.fromEmitter;
+/**
+ * An Fx which will never emit any errors or events, and will never end
+ * @since 1.18.0
+ * @category constructors
+ */
+export const never = core.never;
+/**
+ * Construct an Fx which will emit the specified value and then end.
+ * @since 1.18.0
+ * @category constructors
+ */
+export const succeed = core.succeed;
+/**
+ * Construct an Fx which will emit the return of a synchronous function and then end.
+ * @since 1.18.0
+ * @category constructors
+ */
+export const sync = core.sync;
+/**
+ * Lazily construct an Fx.
+ * @since 1.18.0
+ * @category constructors
+ */
+export const suspend = core.suspend;
+/**
+ * Helper for constructing your own custom subtypes of an Fx
+ * @since 1.18.0
+ * @category Subtyping
+ */
+export class ToFx extends primitive.ToFx {
+}
+/**
+ * Create an Fx which will emit a value after waiting for a specified duration.
+ * @since 1.18.0
+ * @category constructors
+ */
+export const at = internal.at;
+/**
+ * Construct an Fx which can fork effects into a Scope.
+ * @since 1.18.0
+ * @category constructors
+ */
+export const withScopedFork = core.withScopedFork;
+/**
+ * Construct an Fx which can exit early from a Scope.
+ * @since 1.18.0
+ * @category constructors
+ */
+export const withEarlyExit = core.withEarlyExit;
+/**
+ * Construct an Fx which can flatten nested Fx.
+ * @since 1.18.0
+ * @category constructors
+ */
+export const withFlattenStrategy = core.withFlattenStrategy;
+/* #endregion */
+/* #region Additions */
+/**
+ * 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
+ */
+export const acquireUseRelease = core.acquireUseRelease;
+/**
+ * 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
+ */
+export const combine = core.combine;
+/**
+ * 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
+ */
+export const struct = (fx) => map(combine(Object.entries(fx).map(([k, fx]) => map(fx, (v) => [k, v]))), Object.fromEntries);
+/**
+ * Combine multiple Fx into a single Fx that will emit the results of all Fx
+ * as they occur.
+ * @since 1.18.0
+ * @category constructors
+ */
+export const merge = core.merge;
+/**
+ * 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
+ */
+export const mergeConcurrently = core.mergeConcurrently;
+/**
+ * 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
+ */
+export const mergeBuffer = core.mergeBuffer;
+/**
+ * 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
+ */
+export const mergeBufferConcurrently = core.mergeBufferConcurrently;
+/**
+ * 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
+ */
+export const mergeSwitch = (fxs) => core.mergeSwitch(fxs);
+/**
+ * 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
+ */
+export const race = core.race;
+/**
+ * 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
+ */
+export const fromScheduled = core.fromScheduled;
+/**
+ * Schedule an Effect to run at the specified duration.
+ *
+ * @since 1.18.0
+ * @category constructors
+ */
+export const periodic = core.periodic;
+/**
+ * Consume a Dequeue as soon as values become available and emit them as a Fx.
+ * @since 1.18.0
+ * @category constructors
+ */
+export const fromDequeue = internal.fromDequeue;
+/**
+ * Consume a PubSub as soon as values become available and emit them as a Fx.
+ * @since 1.18.0
+ * @category constructors
+ */
+export const fromPubSub = internal.fromPubSub;
+/* #endregion */
+/* #region Running */
+/**
+ * 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
+ */
+export const run = dual(2, internalRun.run);
+/**
+ * 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
+ */
+export const observe = dual(2, core.observe);
+/**
+ * Run an Fx to completion. The Effect will resolve with the first Error of the Fx.
+ *
+ * @since 1.18.0
+ * @category running
+ */
+export const drain = core.drain;
+/**
+ * Reduce an Fx to a single value.
+ * @since 1.18.0
+ * @category running
+ */
+export const reduce = core.reduce;
+/**
+ * Run an Fx to completion, collecting all emitted values into an Array.
+ * @since 1.18.0
+ * @category running
+ */
+export const toArray = core.toArray;
+/**
+ * Run an Fx to completion, collecting all emitted values into a ReadonlyArray.
+ * @since 1.18.0
+ * @category running
+ */
+export const toReadonlyArray = core.toReadonlyArray;
+/**
+ * Run an Fx to completion, collecting all emitted values into a Chunk.
+ * @since 1.18.0
+ * @category running
+ */
+export const toChunk = core.toChunk;
+/**
+ * Consume an Fx and place its values into an Enqueue.
+ * @since 1.18.0
+ * @category running
+ */
+export const toEnqueue = internal.toEnqueue;
+/* #endregion */
+/* #region Combinators */
+/**
+ * Map over the success value of an Fx.
+ * @since 1.18.0
+ * @category combinators
+ */
+export const map = core.map;
+/**
+ * Map over both failure and success values of an Fx.
+ * @since 1.18.0
+ * @category combinators
+ */
+export const mapBoth = core.mapBoth;
+/**
+ * Filter the success value of an Fx.
+ * @since 1.18.0
+ * @category combinators
+ */
+export const filter = core.filter;
+/**
+ * Filter and map the success value of an Fx.
+ * @since 1.18.0
+ * @category combinators
+ */
+export const filterMap = core.filterMap;
+/**
+ * Unwrap Options by filtering any None values.
+ * @since 1.18.0
+ * @category combinators
+ */
+export const compact = core.compact;
+/**
+ * Map over the Cause  of an Fx.
+ * @since 1.18.0
+ * @category errors
+ */
+export const mapErrorCause = core.mapErrorCause;
+/**
+ * Map over the Error of an Fx.
+ * @since 1.18.0
+ * @category errors
+ */
+export const mapError = core.mapError;
+/**
+ * Filter the Cause of an Fx.
+ * @since 1.18.0
+ * @category errors
+ */
+export const filterErrorCause = core.filterCause;
+/**
+ * Filter and map the Cause of an Fx.
+ * @since 1.18.0
+ * @category errors
+ */
+export const filterMapCause = core.filterMapCause;
+/**
+ * Filter the Error of an Fx.
+ * @since 1.18.0
+ * @category errors
+ */
+export const filterError = core.filterError;
+/**
+ * Filter and map the error of an Fx.
+ * @since 1.18.0
+ * @category errors
+ */
+export const filterMapError = core.filterMapError;
+/**
+ * Filter and map the error of an Fx using an Effect.
+ * @since 1.18.0
+ * @category errors
+ */
+export const filterMapErrorEffect = core.filterMapErrorEffect;
+/**
+ * Map the success value of an Fx to another Fx, flattening the result
+ * with the provided FlattenStrategy.
+ * @since 1.18.0
+ * @category flattening
+ */
+export const flatMapWithStrategy = dual(3, core.flatMapWithStrategy);
+/**
+ * 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
+ */
+export const switchMap = core.switchMap;
+/**
+ * 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
+ */
+export const switchLatest = core.switchMap((x) => x);
+/**
+ * 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
+ */
+export const exhaustMap = core.exhaustMap;
+/**
+ * Flatten a nested Fx, prefering the first
+ * Fx emitted and dropping any subsequent Fx until it has completed.
+ * @since 1.18.0
+ * @category flattening
+ */
+export const exhaust = core.exhaust;
+/**
+ * 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
+ */
+export const exhaustMapLatest = core.exhaustMapLatest;
+/**
+ * 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
+ */
+export const exhaustLatest = core.exhaustLatest;
+/**
+ * Map the success value of an Fx to another Fx with unbounded concurrency.
+ *
+ * @since 1.18.0
+ * @category flattening
+ */
+export const flatMap = core.flatMap;
+/**
+ * Map the success value of an Fx to another Fx with unbounded concurrency.
+ *
+ * @since 1.18.0
+ * @category flattening
+ */
+export const flatten = core.flatten;
+/**
+ * Map the success value of an Fx to another Fx with the specified concurrency.
+ *
+ * @since 1.18.0
+ * @category flattening
+ */
+export const flatMapConcurrently = core.flatMapConcurrently;
+/**
+ * Map the success value of an Fx to another Fx one at a time.
+ *
+ * @since 1.18.0
+ * @category flattening
+ */
+export const concatMap = core.concatMap;
+/**
+ * Skip and take a number of values from an Fx.
+ *
+ * @since 1.18.0
+ * @category slicing
+ */
+export const slice = core.slice;
+/**
+ * Take a number of values from an Fx.
+ *
+ * @since 1.18.0
+ * @category slicing
+ */
+export const take = core.take;
+/**
+ * Drop a number of values from an Fx.
+ *
+ * @since 1.18.0
+ * @category slicing
+ */
+export const drop = core.drop;
+/**
+ * Take values from an Fx while the predicate returns true.
+ *
+ * @since 1.18.0
+ * @category slicing
+ */
+export const takeWhile = core.takeWhile;
+/**
+ * Take values from an Fx until the predicate returns true.
+ *
+ * @since 1.18.0
+ * @category slicing
+ */
+export const takeUntil = core.takeUntil;
+/**
+ * Drop values from an Fx while the predicate returns true.
+ *
+ * @since 1.18.0
+ * @category slicing
+ */
+export const dropWhile = core.dropWhile;
+/**
+ * Drop values from an Fx until the predicate returns true.
+ *
+ * @since 1.18.0
+ * @category slicing
+ */
+export const dropUntil = core.dropUntil;
+/**
+ * Drop values from an Fx after the predicate returns true.
+ *
+ * @since 1.18.0
+ * @category slicing
+ */
+export const dropAfter = core.dropAfter;
+/**
+ * Concatenate an Fx after the successful completion of another Fx
+ *
+ * @since 1.18.0
+ * @category combinators
+ */
+export const continueWith = core.continueWith;
+/**
+ * Concatenate an Fx after the failure of another Fx
+ *
+ * @since 1.18.0
+ * @category combinators
+ */
+export const orElse = core.recoverWith;
+/**
+ * Map the success value of an Fx to an Effect, doesn't fork any fibers like flatMap* etc.
+ *
+ * @since 1.18.0
+ * @category combinators
+ */
+export const mapEffect = core.mapEffect;
+/**
+ * Perform an Effect for each value emitted by an Fx, not affecting the output of the Fx.
+ *
+ * @since 1.18.0
+ * @category combinators
+ */
+export const tap = core.tap;
+/**
+ * Filter the success value of an Fx with an Effect.
+ *
+ * @since 1.18.0
+ * @category combinators
+ */
+export const filterEffect = core.filterEffect;
+/**
+ * Filter and map the success value of an Fx with an Effect.
+ *
+ * @since 1.18.0
+ * @category combinators
+ */
+export const filterMapEffect = core.filterMapEffect;
+/**
+ * Apply a function to the constructed Effect that represents the running Fx.
+ *
+ * @since 1.18.0
+ * @category combinators
+ */
+export const middleware = core.middleware;
+/**
+ * Accumulate a value over the success values of an Fx and atomically produce derived value.
+ *
+ * @since 1.18.0
+ * @category combinators
+ */
+export const loop = core.loop;
+/**
+ * Emit values with their previously emitted values when possible.
+ *
+ * @since 1.18.0
+ * @category combinators
+ */
+export const withPrevious = (fx) => loop(fx, Option.none(), (previous, current) => [[previous, current], Option.some(current)]);
+/**
+ * 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
+ */
+export const loopEffect = core.loopEffect;
+/**
+ * Prepends a value to the beginning of an Fx.
+ *
+ * @since 1.18.0
+ * @category combinators
+ */
+export const startWith = core.startWith;
+/**
+ * Appends a value to the end of an Fx.
+ *
+ * @since 1.18.0
+ * @category combinators
+ */
+export const endWith = core.endWith;
+/**
+ * Run a reducer over the success values of an Fx.
+ *
+ * @since 1.18.0
+ * @category combinators
+ */
+export const scan = core.scan;
+/**
+ * Run an Effect-ful reducer over the success values of an Fx.
+ *
+ * @since 1.18.0
+ * @category combinators
+ */
+export const scanEffect = core.scanEffect;
+/**
+ * Map the failures of an Fx to another Fx, flattening the result
+ * with the provided FlattenStrategy.
+ * @since 1.18.0
+ * @category flattening
+ */
+export const flatMapCauseWithStrategy = core.flatMapCauseWithStrategy;
+/**
+ * Map the failures of an Fx to another Fx, flattening the result
+ * with the provided FlattenStrategy.
+ * @since 1.18.0
+ * @category flattening
+ */
+export const flatMapErrorWithStrategy = core.flatMapErrorWithStrategy;
+/**
+ * Map the failures of an Fx to another Fx, flattening the result with unbounded concurrency.
+ *
+ * @since 1.18.0
+ * @category flattening
+ */
+export const flatMapCause = core.flatMapCause;
+/**
+ * Map the failures of an Fx to another Fx, flattening the result with unbounded concurrency.
+ *
+ * @since 1.18.0
+ * @category flattening
+ */
+export const flatMapError = core.flatMapError;
+/**
+ * Map the failures of an Fx to another Fx with the specified concurrency.
+ *
+ * @since 1.18.0
+ * @category flattening
+ */
+export const flatMapCauseConcurrently = core.flatMapCauseConcurrently;
+/**
+ * Map the failures of an Fx to another Fx with the specified concurrency.
+ *
+ * @since 1.18.0
+ * @category flattening
+ */
+export const flatMapErrorConcurrently = core.flatMapErrorConcurrently;
+/**
+ * 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
+ */
+export const switchMapCause = core.switchMapCause;
+/**
+ * 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
+ */
+export const switchMapError = core.switchMapError;
+/**
+ * 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
+ */
+export const exhaustMapCause = core.exhaustMapCause;
+/**
+ * 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
+ */
+export const exhaustMapError = core.exhaustMapError;
+/**
+ * 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
+ */
+export const exhaustMapLatestCause = core.exhaustMapLatestCause;
+/**
+ * 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
+ */
+export const exhaustMapLatestError = core.exhaustMapLatestError;
+/**
+ * Map over the failures and successes of an Fx, flattening both using the same strategy.
+ *
+ * @since 1.18.0
+ * @category flattening
+ */
+export const matchCauseWithStrategy = core.matchCauseWithStrategy;
+/**
+ * Map over the failures and successes of an Fx, flattening both using the same strategy.
+ *
+ * @since 1.18.0
+ * @category flattening
+ */
+export const matchErrorWithStrategy = core.matchErrorWithStrategy;
+/**
+ * Map over the failures and successes of an Fx, flattening both with unbounded concurrency.
+ *
+ * @since 1.18.0
+ * @category flattening
+ */
+export const matchCause = core.matchCause;
+/**
+ * Map over the failures and successes of an Fx, flattening both with unbounded concurrency.
+ *
+ * @since 1.18.0
+ * @category flattening
+ */
+export const match = core.match;
+/**
+ * Map over the failures and successes of an Fx, flattening both with the specified concurrency.
+ *
+ * @since 1.18.0
+ * @category flattening
+ */
+export const matchCauseConcurrently = core.matchCauseConcurrently;
+/**
+ * Map over the failures and successes of an Fx, flattening both with the specified concurrency.
+ *
+ * @since 1.18.0
+ * @category flattening
+ */
+export const matchErrorConcurrently = core.matchErrorConcurrently;
+/**
+ * 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
+ */
+export const switchMatchCause = core.switchMatchCause;
+/**
+ * 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
+ */
+export const switchMatch = core.switchMatch;
+/**
+ * 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
+ */
+export const exhaustMatchCause = core.exhaustMatchCause;
+/**
+ * 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
+ */
+export const exhaustMatch = core.exhaustMatch;
+/**
+ * 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
+ */
+export const exhaustLatestMatchCause = core.exhaustLatestMatchCause;
+/**
+ * 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
+ */
+export const exhaustLatestMatch = core.exhaustLatestMatch;
+/**
+ * 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
+ */
+export const during = core.during;
+/**
+ * Listen to the events of an Fx after the provided window emits.
+ *
+ * @since 1.18.0
+ * @category time slicing
+ */
+export const since = core.since;
+/**
+ * Listen to the events of an Fx until the provided window emits.
+ *
+ * @since 1.18.0
+ * @category time slicing
+ */
+export const until = core.until;
+/**
+ * Provide the environment to an Fx.
+ *
+ * @since 1.18.0
+ * @category context
+ */
+export const provide = core.provide;
+/**
+ * Provide a service to an Fx using a Tag.
+ * @since 1.18.0
+ * @category context
+ */
+export const provideService = core.provideService;
+/**
+ * Provide a service using an Effect to an Fx using a Tag.
+ *
+ * @since 1.18.0
+ * @category context
+ */
+export const provideServiceEffect = core.provideServiceEffect;
+/**
+ * Skip repeated values, using the provided Equivalence to compare values.
+ *
+ * @since 1.18.0
+ * @category slicing
+ */
+export const skipRepeatsWith = core.skipRepeatsWith;
+/**
+ * Skip repeated values, using @effect/data/Equal for value comparison.
+ *
+ * @since 1.18.0
+ * @category slicing
+ */
+export const skipRepeats = core.skipRepeats;
+/**
+ * Sample the values of an Fx, or Effect, during the events of another Fx.
+ *
+ * @since 1.18.0
+ * @category combinators
+ */
+export const snapshot = core.snapshot;
+/**
+ * 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
+ */
+export const share = Share.share;
+/**
+ * Effeciently share an underlying stream with multiple subscribers.
+ *
+ * @since 1.18.0
+ * @category sharing
+ */
+export const multicast = Share.multicast;
+/**
+ * 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
+ */
+export const hold = Share.hold;
+/**
+ * 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
+ */
+export const replay = Share.replay;
+/**
+ * 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
+ */
+export const debounce = internal.debounce;
+/**
+ * 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
+ */
+export const throttle = internal.throttle;
+/**
+ * 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
+ */
+export const delay = internal.delay;
+/**
+ * Run an Effect to produce an Fx to run.
+ * @since 1.18.0
+ * @category constructors
+ */
+export const fromFxEffect = internal.fromFxEffect;
+/**
+ * Utilize Effect.gen to construct an Fx
+ * @since 1.18.0
+ * @category constructors
+ */
+export function gen(f) {
+    return fromFxEffect(Effect.gen(f));
+}
+/**
+ * Utilize Effect.gen to construct an Fx
+ * @since 1.18.0
+ * @category constructors
+ */
+export function genScoped(f) {
+    return scoped(fromFxEffect(Effect.gen(f)));
+}
+/**
+ * Run an Effect when an Fx exits
+ * @since 1.18.0
+ * @category lifecycles
+ */
+export const onExit = internal.onExit;
+/**
+ * Run an Effect when an Fx is interrupted
+ * @since 1.18.0
+ * @category lifecycles
+ */
+export const onInterrupt = internal.onInterrupt;
+/**
+ * Run an Effect when an Fx ends with an error
+ * @since 1.18.0
+ * @category lifecycles
+ */
+export const onError = internal.onError;
+/**
+ * Provide a Scope to an Fx
+ * @since 1.18.0
+ * @category context
+ */
+export const scoped = internal.scoped;
+/**
+ * Annotate the logs of an Fx
+ * @since 1.18.0
+ * @category combinators
+ */
+export const annotateLogs = internal.annotateLogs;
+/**
+ * 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
+ */
+export const succeedNone = internal.succeedNone;
+/**
+ * Create an Fx which will succeed with Option.Some
+ * @since 1.18.0
+ * @category constructors
+ */
+export const succeedSome = internal.succeedSome;
+/**
+ * Do simulation
+ * @since 1.18.0
+ * @category Do
+ */
+export const Do = internal.Do;
+/**
+ * Do simulation
+ * @since 1.18.0
+ * @category Do
+ */
+export const bind = internal.bind;
+/**
+ * Do simulation
+ * @since 1.18.0
+ * @category Do
+ */
+export const bindTo = internal.bindTo;
+const let_ = internal.let;
+export { 
+/**
+ * Do simulation
+ * @since 1.18.0
+ * @category Do
+ */
+let_ as let };
+/**
+ * Ensure a finalizer runs on Fx ext.
+ * @since 1.18.0
+ * @category combinators
+ */
+export const ensuring = internal.ensuring;
+/**
+ * Capture the errors and success values as Exit
+ * @since 1.18.0
+ * @category combinators
+ */
+export const exit = internal.exit;
+/**
+ * Capture the errors and success values as Either
+ * @since 1.18.0
+ * @category combinators
+ */
+export const either = internal.either;
+/**
+ * Run an Fx until finding a value which satisfies the predicate.
+ * @since 1.18.0
+ * @category running
+ */
+export const findFirst = internal.findFirst;
+/**
+ * Grab the first value emitted by an Fx
+ * @since 1.18.0
+ * @category running
+ */
+export const first = findFirst(constant(Effect.succeed(true)));
+/**
+ * Transform success values into failures and failures into successes.
+ * @since 1.18.0
+ * @category combinators
+ */
+export const flip = internal.flip;
+/**
+ * Lift a nullable value into an Fx
+ * @since 1.18.0
+ * @category constructors
+ */
+export const fromNullable = internal.fromNullable;
+const if_ = internal.if;
+export { 
+/**
+ * Logical if/else using Fx.
+ * @since 1.18.0
+ * @category combinators
+ */
+if_ as if };
+/**
+ * Logical if/else using static values.
+ * @since 1.18.0
+ * @category combinators
+ */
+export const when = internal.when;
+/**
+ * Mark an Fx as interruptible
+ * @since 1.18.0
+ * @category combinators
+ */
+export const interruptible = internal.interruptible;
+/**
+ * Mark an Fx as uninterruptible
+ * @since 1.18.0
+ * @category combinators
+ */
+export const uninterruptible = internal.uninterruptible;
+/**
+ * Locally set the value of a FiberRef
+ * @since 1.18.0
+ * @category FiberRef
+ */
+export const locally = internal.locally;
+/**
+ * Locally set the value of a FiberRef by updating the current value
+ * @since 1.18.0
+ * @category FiberRef
+ */
+export const locallyWith = internal.locallyWith;
+/**
+ * Enable/disable tracer timing for an Fx
+ * @since 1.18.0
+ * @category tracing
+ */
+export const withTracerTiming = internal.withTracerTiming;
+/**
+ * Configure the concurreny limit of Fibers running within an Fx
+ * @since 1.18.0
+ * @category concurrency
+ */
+export const withConcurrency = internal.withConcurrency;
+/**
+ * Add a span to your log messages
+ * @since 1.18.0
+ * @category logging
+ */
+export const withLogSpan = internal.withLogSpan;
+/**
+ * Configure the maximum number of operations to run before yielding to the runtime
+ * @since 1.18.0
+ * @category concurrency
+ */
+export const withMaxOpsBeforeYield = internal.withMaxOpsBeforeYield;
+/**
+ * Set the parent Span of an Fx
+ * @since 1.18.0
+ * @category tracing
+ */
+export const withParentSpan = internal.withParentSpan;
+/**
+ * Enable/disable request batching within an Fx
+ * @since 1.18.0
+ * @category batching
+ */
+export const withRequestBatching = internal.withRequestBatching;
+/**
+ * Set the request cache Effects running within an Fx
+ * @since 1.18.0
+ * @category batching
+ */
+export const withRequestCache = internal.withRequestCache;
+/**
+ * Enable/disable request caching within an Fx
+ * @since 1.18.0
+ * @category batching
+ */
+export const withRequestCaching = internal.withRequestCaching;
+/**
+ * Configure the scheduler to use within an Fx
+ * @since 1.18.0
+ * @category concurrency
+ */
+export const withScheduler = internal.withScheduler;
+/**
+ * Set the span of an Fx
+ * @since 1.18.0
+ * @category tracing
+ */
+export const withSpan = internal.withSpan;
+/**
+ * Set the tracer used within an Fx
+ * @since 1.18.0
+ * @category tracing
+ */
+export const withTracer = internal.withTracer;
+/**
+ * Partition an Fx into two Fx's based on a either-returning function.
+ * @since 1.18.0
+ * @category combinators
+ */
+export const partitionMap = internal.partitionMap;
+/**
+ * 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
+ */
+export const keyed = dual(3, internalKeyed.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
+ */
+export const withKey = dual(3, internalWithKey.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
+ * @category combinators
+ */
+export const matchTags = dual(2, function matchTags(fx, matchers) {
+    return withKey(fx, getTag, (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
+ */
+export const matchOption = dual(3, function matchOption(fx, onNone, onSome) {
+    return matchTags(fx, {
+        None: onNone,
+        Some: (some) => onSome(transform(some, (s) => s.value, (value) => Option.some(value)))
+    });
+});
+/**
+ * @since 1.18.0
+ */
+export const getOrElse = dual(2, function getOrElse(fx, orElse) {
+    return matchOption(fx, orElse, identity);
+});
+/**
+ * @since 1.18.0
+ */
+export const matchEither = dual(3, function matchEither(fx, onLeft, onRight) {
+    return matchTags(fx, {
+        Left: (left) => onLeft(transform(left, (a) => a.left, (a) => Either.left(a))),
+        Right: (right) => onRight(transform(right, (s) => s.right, (value) => Either.right(value)))
+    });
+});
+/**
+ * @since 1.18.0
+ */
+export const fork = (fx) => Effect.fork(drain(fx));
+/**
+ * @since 1.18.0
+ */
+export const forkScoped = (fx) => Effect.forkScoped(drain(fx));
+/**
+ * @since 1.18.0
+ */
+export const forkDaemon = (fx) => Effect.forkDaemon(drain(fx));
+/**
+ * @since 1.18.0
+ */
+export const forkIn = dual(2, (fx, scope) => Effect.forkIn(drain(fx), scope));
+/**
+ * @since 1.18.0
+ */
+export const mergeRace = internal.mergeRace;
+//# sourceMappingURL=Fx.js.map