effect 2.0.0-next.37 → 2.0.0-next.39

package/dist/STM-23270be2.cjs.prod.js

@@ -0,0 +1,1447 @@
+'use strict';
+
+var Cause_dist_effectCause = require('./Cause-384e2165.cjs.prod.js');
+var Chunk_dist_effectChunk = require('./Chunk-6cf5a8e6.cjs.prod.js');
+var core = require('./core-4ced6e17.cjs.prod.js');
+var stm = require('./stm-59af7e62.cjs.prod.js');
+
+/**
+ * @since 2.0.0
+ */
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const STMTypeId = core.STMTypeId;
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+
+/**
+ * `STM<R, E, A>` represents an effect that can be performed transactionally,
+ *  resulting in a failure `E` or a value `A` that may require an environment
+ *  `R` to execute.
+ *
+ * Software Transactional Memory is a technique which allows composition of
+ * arbitrary atomic operations.  It is the software analog of transactions in
+ * database systems.
+ *
+ * The API is lifted directly from the Haskell package Control.Concurrent.STM
+ * although the implementation does not resemble the Haskell one at all.
+ *
+ * See http://hackage.haskell.org/package/stm-2.5.0.0/docs/Control-Concurrent-STM.html
+ *
+ * STM in Haskell was introduced in:
+ *
+ * Composable memory transactions, by Tim Harris, Simon Marlow, Simon Peyton
+ * Jones, and Maurice Herlihy, in ACM Conference on Principles and Practice of
+ * Parallel Programming 2005.
+ *
+ * See https://www.microsoft.com/en-us/research/publication/composable-memory-transactions/
+ *
+ * See also:
+ *  Lock Free Data Structures using STMs in Haskell, by Anthony Discolo, Tim
+ *  Harris, Simon Marlow, Simon Peyton Jones, Satnam Singh) FLOPS 2006: Eighth
+ *  International Symposium on Functional and Logic Programming, Fuji Susono,
+ *  JAPAN, April 2006
+ *
+ *  https://www.microsoft.com/en-us/research/publication/lock-free-data-structures-using-stms-in-haskell/
+ *
+ * The implemtation is based on the ZIO STM module, while JS environments have
+ * no race conditions from multiple threads STM provides greater benefits for
+ * synchronization of Fibers and transactional data-types can be quite useful.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * @category models
+ * @since 2.0.0
+ */
+
+/**
+ * @category type lambdas
+ * @since 2.0.0
+ */
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * @since 2.0.0
+ */
+
+/**
+ * @category models
+ * @since 2.0.0
+ */
+
+/**
+ * Returns `true` if the provided value is an `STM`, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isSTM = core.isSTM;
+
+/**
+ * Treats the specified `acquire` transaction as the acquisition of a
+ * resource. The `acquire` transaction will be executed interruptibly. If it
+ * is a success and is committed the specified `release` workflow will be
+ * executed uninterruptibly as soon as the `use` workflow completes execution.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const acquireUseRelease = stm.acquireUseRelease;
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+
+/**
+ * Runs all the provided transactional effects in sequence respecting the
+ * structure provided in input.
+ *
+ * Supports multiple arguments, a single argument tuple / array or record /
+ * struct.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const all = stm.all;
+
+/**
+ * Maps the success value of this effect to the specified constant value.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const as = stm.as;
+
+/**
+ * Maps the success value of this effect to an optional value.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const asSome = stm.asSome;
+
+/**
+ * Maps the error value of this effect to an optional value.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const asSomeError = stm.asSomeError;
+
+/**
+ * This function maps the success value of an `STM` to `void`. If the original
+ * `STM` succeeds, the returned `STM` will also succeed. If the original `STM`
+ * fails, the returned `STM` will fail with the same error.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const asUnit = stm.asUnit;
+
+/**
+ * Creates an `STM` value from a partial (but pure) function.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const attempt = stm.attempt;
+
+/**
+ * Recovers from all errors.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const catchAll = core.catchAll;
+
+/**
+ * Recovers from some or all of the error cases.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const catchSome = stm.catchSome;
+
+/**
+ * Recovers from the specified tagged error.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const catchTag = stm.catchTag;
+
+/**
+ * Recovers from multiple tagged errors.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const catchTags = stm.catchTags;
+
+/**
+ * Checks the condition, and if it's true, returns unit, otherwise, retries.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const check = stm.check;
+
+/**
+ * Simultaneously filters and maps the value produced by this effect.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const collect = stm.collect;
+
+/**
+ * Simultaneously filters and maps the value produced by this effect.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const collectSTM = stm.collectSTM;
+
+/**
+ * Commits this transaction atomically.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const commit = core.commit;
+
+/**
+ * Commits this transaction atomically, regardless of whether the transaction
+ * is a success or a failure.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const commitEither = stm.commitEither;
+
+/**
+ * Similar to Either.cond, evaluate the predicate, return the given A as
+ * success if predicate returns true, and the given E as error otherwise
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const cond = stm.cond;
+
+/**
+ * Retrieves the environment inside an stm.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const context = core.context;
+
+/**
+ * Accesses the environment of the transaction to perform a transaction.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const contextWith = core.contextWith;
+
+/**
+ * Accesses the environment of the transaction to perform a transaction.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const contextWithSTM = core.contextWithSTM;
+
+/**
+ * Transforms the environment being provided to this effect with the specified
+ * function.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const mapInputContext = core.mapInputContext;
+
+/**
+ * Fails the transactional effect with the specified defect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const die = core.die;
+
+/**
+ * Kills the fiber running the effect with a `Cause.RuntimeException` that
+ * contains the specified message.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const dieMessage = core.dieMessage;
+
+/**
+ * Fails the transactional effect with the specified lazily evaluated defect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const dieSync = core.dieSync;
+
+/**
+ * Converts the failure channel into an `Either`.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const either = stm.either;
+
+/**
+ * Executes the specified finalization transaction whether or not this effect
+ * succeeds. Note that as with all STM transactions, if the full transaction
+ * fails, everything will be rolled back.
+ *
+ * @since 2.0.0
+ * @category finalization
+ */
+const ensuring = core.ensuring;
+
+/**
+ * Returns an effect that ignores errors and runs repeatedly until it
+ * eventually succeeds.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const eventually = stm.eventually;
+
+/**
+ * Determines whether all elements of the `Iterable<A>` satisfy the effectual
+ * predicate.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const every = stm.every;
+
+/**
+ * Determines whether any element of the `Iterable[A]` satisfies the effectual
+ * predicate `f`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const exists = stm.exists;
+
+/**
+ * Fails the transactional effect with the specified error.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fail = core.fail;
+
+/**
+ * Fails the transactional effect with the specified lazily evaluated error.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const failSync = core.failSync;
+
+/**
+ * Returns the fiber id of the fiber committing the transaction.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fiberId = stm.fiberId;
+
+/**
+ * Filters the collection using the specified effectual predicate.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const filter = stm.filter;
+
+/**
+ * Filters the collection using the specified effectual predicate, removing
+ * all elements that satisfy the predicate.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const filterNot = stm.filterNot;
+
+/**
+ * Dies with specified defect if the predicate fails.
+ *
+ * @since 2.0.0
+ * @category filtering
+ */
+const filterOrDie = stm.filterOrDie;
+
+/**
+ * Dies with a `Cause.RuntimeException` having the specified  message if the
+ * predicate fails.
+ *
+ * @since 2.0.0
+ * @category filtering
+ */
+const filterOrDieMessage = stm.filterOrDieMessage;
+
+/**
+ * Supplies `orElse` if the predicate fails.
+ *
+ * @since 2.0.0
+ * @category filtering
+ */
+const filterOrElse = stm.filterOrElse;
+
+/**
+ * Fails with the specified error if the predicate fails.
+ *
+ * @since 2.0.0
+ * @category filtering
+ */
+const filterOrFail = stm.filterOrFail;
+
+/**
+ * Feeds the value produced by this effect to the specified function, and then
+ * runs the returned effect as well to produce its results.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const flatMap = core.flatMap;
+
+/**
+ * Flattens out a nested `STM` effect.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const flatten = stm.flatten;
+
+/**
+ * Flips the success and failure channels of this transactional effect. This
+ * allows you to use all methods on the error channel, possibly before
+ * flipping back.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const flip = stm.flip;
+
+/**
+ * Swaps the error/value parameters, applies the function `f` and flips the
+ * parameters back
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const flipWith = stm.flipWith;
+
+/**
+ * Folds over the `STM` effect, handling both failure and success, but not
+ * retry.
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+const match = stm.match;
+
+/**
+ * Effectfully folds over the `STM` effect, handling both failure and success.
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+const matchSTM = core.matchSTM;
+
+/**
+ * Applies the function `f` to each element of the `Iterable<A>` and returns
+ * a transactional effect that produces a new `Chunk<A2>`.
+ *
+ * @since 2.0.0
+ * @category traversing
+ */
+const forEach = stm.forEach;
+
+/**
+ * Lifts an `Either` into a `STM`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromEither = stm.fromEither;
+
+/**
+ * Lifts an `Option` into a `STM`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromOption = stm.fromOption;
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const gen = stm.gen;
+
+/**
+ * Returns a successful effect with the head of the list if the list is
+ * non-empty or fails with the error `None` if the list is empty.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const head = stm.head;
+const if_ = stm.if_;
+
+/**
+ * Returns a new effect that ignores the success or failure of this effect.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const ignore = stm.ignore;
+
+/**
+ * Interrupts the fiber running the effect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const interrupt = core.interrupt;
+
+/**
+ * Interrupts the fiber running the effect with the specified `FiberId`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const interruptAs = core.interruptAs;
+
+/**
+ * Returns whether this transactional effect is a failure.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const isFailure = stm.isFailure;
+
+/**
+ * Returns whether this transactional effect is a success.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const isSuccess = stm.isSuccess;
+
+/**
+ * Iterates with the specified transactional function. The moral equivalent
+ * of:
+ *
+ * ```ts
+ * const s = initial
+ *
+ * while (cont(s)) {
+ *   s = body(s)
+ * }
+ *
+ * return s
+ * ```
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const iterate = stm.iterate;
+
+/**
+ * Loops with the specified transactional function, collecting the results
+ * into a list. The moral equivalent of:
+ *
+ * ```ts
+ * const as = []
+ * let s  = initial
+ *
+ * while (cont(s)) {
+ *   as.push(body(s))
+ *   s  = inc(s)
+ * }
+ *
+ * return as
+ * ```
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const loop = stm.loop;
+
+/**
+ * Maps the value produced by the effect.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const map = core.map;
+
+/**
+ * Maps the value produced by the effect with the specified function that may
+ * throw exceptions but is otherwise pure, translating any thrown exceptions
+ * into typed failed effects.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapAttempt = stm.mapAttempt;
+
+/**
+ * Returns an `STM` effect whose failure and success channels have been mapped
+ * by the specified pair of functions, `f` and `g`.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapBoth = stm.mapBoth;
+
+/**
+ * Maps from one error type to another.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapError = stm.mapError;
+
+/**
+ * Returns a new effect where the error channel has been merged into the
+ * success channel to their common combined type.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const merge = stm.merge;
+
+/**
+ * Merges an `Iterable<STM>` to a single `STM`, working sequentially.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const mergeAll = stm.mergeAll;
+
+/**
+ * Returns a new effect where boolean value of this effect is negated.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const negate = stm.negate;
+
+/**
+ * Requires the option produced by this value to be `None`.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const none = stm.none;
+
+/**
+ * Converts the failure channel into an `Option`.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const option = stm.option;
+
+/**
+ * Translates `STM` effect failure into death of the fiber, making all
+ * failures unchecked and not a part of the type of the effect.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const orDie = stm.orDie;
+
+/**
+ * Keeps none of the errors, and terminates the fiber running the `STM` effect
+ * with them, using the specified function to convert the `E` into a defect.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const orDieWith = stm.orDieWith;
+
+/**
+ * Tries this effect first, and if it fails or retries, tries the other
+ * effect.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const orElse = stm.orElse;
+
+/**
+ * Returns a transactional effect that will produce the value of this effect
+ * in left side, unless it fails or retries, in which case, it will produce
+ * the value of the specified effect in right side.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const orElseEither = stm.orElseEither;
+
+/**
+ * Tries this effect first, and if it fails or retries, fails with the
+ * specified error.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const orElseFail = stm.orElseFail;
+
+/**
+ * Returns an effect that will produce the value of this effect, unless it
+ * fails with the `None` value, in which case it will produce the value of the
+ * specified effect.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const orElseOptional = stm.orElseOptional;
+
+/**
+ * Tries this effect first, and if it fails or retries, succeeds with the
+ * specified value.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const orElseSucceed = stm.orElseSucceed;
+
+/**
+ * Tries this effect first, and if it enters retry, then it tries the other
+ * effect. This is an equivalent of Haskell's orElse.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const orTry = core.orTry;
+
+/**
+ * Feeds elements of type `A` to a function `f` that returns an effect.
+ * Collects all successes and failures in a tupled fashion.
+ *
+ * @since 2.0.0
+ * @category traversing
+ */
+const partition = stm.partition;
+
+/**
+ * Provides the transaction its required environment, which eliminates its
+ * dependency on `R`.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const provideContext = stm.provideContext;
+
+/**
+ * Splits the context into two parts, providing one part using the
+ * specified layer and leaving the remainder `R0`.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const provideSomeContext = stm.provideSomeContext;
+
+/**
+ * Provides the effect with the single service it requires. If the transactional
+ * effect requires more than one service use `provideEnvironment` instead.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const provideService = stm.provideService;
+
+/**
+ * Provides the effect with the single service it requires. If the transactional
+ * effect requires more than one service use `provideEnvironment` instead.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const provideServiceSTM = stm.provideServiceSTM;
+
+/**
+ * Folds an `Iterable<A>` using an effectual function f, working sequentially
+ * from left to right.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const reduce = stm.reduce;
+
+/**
+ * Reduces an `Iterable<STM>` to a single `STM`, working sequentially.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const reduceAll = stm.reduceAll;
+
+/**
+ * Folds an `Iterable<A>` using an effectual function f, working sequentially
+ * from right to left.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const reduceRight = stm.reduceRight;
+
+/**
+ * Keeps some of the errors, and terminates the fiber with the rest.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const refineOrDie = stm.refineOrDie;
+
+/**
+ * Keeps some of the errors, and terminates the fiber with the rest, using the
+ * specified function to convert the `E` into a `Throwable`.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const refineOrDieWith = stm.refineOrDieWith;
+
+/**
+ * Fail with the returned value if the `PartialFunction` matches, otherwise
+ * continue with our held value.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const reject = stm.reject;
+
+/**
+ * Continue with the returned computation if the specified partial function
+ * matches, translating the successful match into a failure, otherwise continue
+ * with our held value.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const rejectSTM = stm.rejectSTM;
+
+/**
+ * Repeats this `STM` effect until its result satisfies the specified
+ * predicate.
+ *
+ * **WARNING**: `repeatUntil` uses a busy loop to repeat the effect and will
+ * consume a thread until it completes (it cannot yield). This is because STM
+ * describes a single atomic transaction which must either complete, retry or
+ * fail a transaction before yielding back to the Effect runtime.
+ *   - Use `retryUntil` instead if you don't need to maintain transaction
+ *     state for repeats.
+ *   - Ensure repeating the STM effect will eventually satisfy the predicate.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const repeatUntil = stm.repeatUntil;
+
+/**
+ * Repeats this `STM` effect while its result satisfies the specified
+ * predicate.
+ *
+ * **WARNING**: `repeatWhile` uses a busy loop to repeat the effect and will
+ * consume a thread until it completes (it cannot yield). This is because STM
+ * describes a single atomic transaction which must either complete, retry or
+ * fail a transaction before yielding back to the Effect runtime.
+ *   - Use `retryWhile` instead if you don't need to maintain transaction
+ *     state for repeats.
+ *   - Ensure repeating the STM effect will eventually not satisfy the
+ *     predicate.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const repeatWhile = stm.repeatWhile;
+
+/**
+ * Replicates the given effect n times. If 0 or negative numbers are given, an
+ * empty `Chunk` will be returned.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const replicate = stm.replicate;
+
+/**
+ * Performs this transaction the specified number of times and collects the
+ * results.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const replicateSTM = stm.replicateSTM;
+
+/**
+ * Performs this transaction the specified number of times, discarding the
+ * results.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const replicateSTMDiscard = stm.replicateSTMDiscard;
+
+/**
+ * Abort and retry the whole transaction when any of the underlying
+ * transactional variables have changed.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const retry = core.retry;
+
+/**
+ * Filters the value produced by this effect, retrying the transaction until
+ * the predicate returns `true` for the value.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const retryUntil = stm.retryUntil;
+
+/**
+ * Filters the value produced by this effect, retrying the transaction while
+ * the predicate returns `true` for the value.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const retryWhile = stm.retryWhile;
+
+/**
+ * Converts an option on values into an option on errors.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const some = stm.some;
+
+/**
+ * Returns an `STM` effect that succeeds with the specified value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const succeed = core.succeed;
+
+/**
+ * Returns an effect with the empty value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const succeedNone = stm.succeedNone;
+
+/**
+ * Returns an effect with the optional value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const succeedSome = stm.succeedSome;
+
+/**
+ * Summarizes a `STM` effect by computing a provided value before and after
+ * execution, and then combining the values to produce a summary, together
+ * with the result of execution.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const summarized = stm.summarized;
+
+/**
+ * Suspends creation of the specified transaction lazily.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const suspend = stm.suspend;
+
+/**
+ * Returns an `STM` effect that succeeds with the specified lazily evaluated
+ * value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const sync = core.sync;
+
+/**
+ * "Peeks" at the success of transactional effect.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const tap = stm.tap;
+
+/**
+ * "Peeks" at both sides of an transactional effect.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const tapBoth = stm.tapBoth;
+
+/**
+ * "Peeks" at the error of the transactional effect.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const tapError = stm.tapError;
+const try_ = stm.try_;
+
+/**
+ * The moral equivalent of `if (!p) exp`
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const unless = stm.unless;
+
+/**
+ * The moral equivalent of `if (!p) exp` when `p` has side-effects
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const unlessSTM = stm.unlessSTM;
+
+/**
+ * Converts an option on errors into an option on values.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const unsome = stm.unsome;
+
+/**
+ * Returns an `STM` effect that succeeds with `Unit`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const unit = stm.unit;
+
+/**
+ * Feeds elements of type `A` to `f` and accumulates all errors in error
+ * channel or successes in success channel.
+ *
+ * This combinator is lossy meaning that if there are errors all successes
+ * will be lost. To retain all information please use `STM.partition`.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const validateAll = stm.validateAll;
+
+/**
+ * Feeds elements of type `A` to `f` until it succeeds. Returns first success
+ * or the accumulation of all errors.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const validateFirst = stm.validateFirst;
+
+/**
+ * The moral equivalent of `if (p) exp`.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const when = stm.when;
+
+/**
+ * The moral equivalent of `if (p) exp` when `p` has side-effects.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const whenSTM = stm.whenSTM;
+
+/**
+ * Sequentially zips this value with the specified one.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zip = core.zip;
+
+/**
+ * Sequentially zips this value with the specified one, discarding the second
+ * element of the tuple.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipLeft = core.zipLeft;
+
+/**
+ * Sequentially zips this value with the specified one, discarding the first
+ * element of the tuple.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipRight = core.zipRight;
+
+/**
+ * Sequentially zips this value with the specified one, combining the values
+ * using the specified combiner function.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipWith = core.zipWith;
+
+/**
+ * This function takes an iterable of `STM` values and returns a new
+ * `STM` value that represents the first `STM` value in the iterable
+ * that succeeds. If all of the `Effect` values in the iterable fail, then
+ * the resulting `STM` value will fail as well.
+ *
+ * This function is sequential, meaning that the `STM` values in the
+ * iterable will be executed in sequence, and the first one that succeeds
+ * will determine the outcome of the resulting `STM` value.
+ *
+ * @param effects - The iterable of `STM` values to evaluate.
+ *
+ * @returns A new `STM` value that represents the first successful
+ * `STM` value in the iterable, or a failed `STM` value if all of the
+ * `STM` values in the iterable fail.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const firstSuccessOf = effects => suspend(() => {
+  const list = Chunk_dist_effectChunk.fromIterable(effects);
+  if (!Chunk_dist_effectChunk.isNonEmpty(list)) {
+    return dieSync(() => Cause_dist_effectCause.IllegalArgumentException(`Received an empty collection of effects`));
+  }
+  return Chunk_dist_effectChunk.reduce(Chunk_dist_effectChunk.tailNonEmpty(list), Chunk_dist_effectChunk.headNonEmpty(list), (left, right) => orElse(left, () => right));
+});
+
+/**
+ * @category do notation
+ * @since 2.0.0
+ */
+const Do = /*#__PURE__*/succeed({});
+
+/**
+ * @category do notation
+ * @since 2.0.0
+ */
+const bind = stm.bind;
+const let_ = stm.let_;
+
+/**
+ * @category do notation
+ * @since 2.0.0
+ */
+const bindTo = stm.bindTo;
+
+var STM = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  STMTypeId: STMTypeId,
+  isSTM: isSTM,
+  acquireUseRelease: acquireUseRelease,
+  all: all,
+  as: as,
+  asSome: asSome,
+  asSomeError: asSomeError,
+  asUnit: asUnit,
+  attempt: attempt,
+  catchAll: catchAll,
+  catchSome: catchSome,
+  catchTag: catchTag,
+  catchTags: catchTags,
+  check: check,
+  collect: collect,
+  collectSTM: collectSTM,
+  commit: commit,
+  commitEither: commitEither,
+  cond: cond,
+  context: context,
+  contextWith: contextWith,
+  contextWithSTM: contextWithSTM,
+  mapInputContext: mapInputContext,
+  die: die,
+  dieMessage: dieMessage,
+  dieSync: dieSync,
+  either: either,
+  ensuring: ensuring,
+  eventually: eventually,
+  every: every,
+  exists: exists,
+  fail: fail,
+  failSync: failSync,
+  fiberId: fiberId,
+  filter: filter,
+  filterNot: filterNot,
+  filterOrDie: filterOrDie,
+  filterOrDieMessage: filterOrDieMessage,
+  filterOrElse: filterOrElse,
+  filterOrFail: filterOrFail,
+  flatMap: flatMap,
+  flatten: flatten,
+  flip: flip,
+  flipWith: flipWith,
+  match: match,
+  matchSTM: matchSTM,
+  forEach: forEach,
+  fromEither: fromEither,
+  fromOption: fromOption,
+  gen: gen,
+  head: head,
+  'if': if_,
+  ignore: ignore,
+  interrupt: interrupt,
+  interruptAs: interruptAs,
+  isFailure: isFailure,
+  isSuccess: isSuccess,
+  iterate: iterate,
+  loop: loop,
+  map: map,
+  mapAttempt: mapAttempt,
+  mapBoth: mapBoth,
+  mapError: mapError,
+  merge: merge,
+  mergeAll: mergeAll,
+  negate: negate,
+  none: none,
+  option: option,
+  orDie: orDie,
+  orDieWith: orDieWith,
+  orElse: orElse,
+  orElseEither: orElseEither,
+  orElseFail: orElseFail,
+  orElseOptional: orElseOptional,
+  orElseSucceed: orElseSucceed,
+  orTry: orTry,
+  partition: partition,
+  provideContext: provideContext,
+  provideSomeContext: provideSomeContext,
+  provideService: provideService,
+  provideServiceSTM: provideServiceSTM,
+  reduce: reduce,
+  reduceAll: reduceAll,
+  reduceRight: reduceRight,
+  refineOrDie: refineOrDie,
+  refineOrDieWith: refineOrDieWith,
+  reject: reject,
+  rejectSTM: rejectSTM,
+  repeatUntil: repeatUntil,
+  repeatWhile: repeatWhile,
+  replicate: replicate,
+  replicateSTM: replicateSTM,
+  replicateSTMDiscard: replicateSTMDiscard,
+  retry: retry,
+  retryUntil: retryUntil,
+  retryWhile: retryWhile,
+  some: some,
+  succeed: succeed,
+  succeedNone: succeedNone,
+  succeedSome: succeedSome,
+  summarized: summarized,
+  suspend: suspend,
+  sync: sync,
+  tap: tap,
+  tapBoth: tapBoth,
+  tapError: tapError,
+  'try': try_,
+  unless: unless,
+  unlessSTM: unlessSTM,
+  unsome: unsome,
+  unit: unit,
+  validateAll: validateAll,
+  validateFirst: validateFirst,
+  when: when,
+  whenSTM: whenSTM,
+  zip: zip,
+  zipLeft: zipLeft,
+  zipRight: zipRight,
+  zipWith: zipWith,
+  firstSuccessOf: firstSuccessOf,
+  Do: Do,
+  bind: bind,
+  'let': let_,
+  bindTo: bindTo
+});
+
+exports.Do = Do;
+exports.STM = STM;
+exports.STMTypeId = STMTypeId;
+exports.acquireUseRelease = acquireUseRelease;
+exports.all = all;
+exports.as = as;
+exports.asSome = asSome;
+exports.asSomeError = asSomeError;
+exports.asUnit = asUnit;
+exports.attempt = attempt;
+exports.bind = bind;
+exports.bindTo = bindTo;
+exports.catchAll = catchAll;
+exports.catchSome = catchSome;
+exports.catchTag = catchTag;
+exports.catchTags = catchTags;
+exports.check = check;
+exports.collect = collect;
+exports.collectSTM = collectSTM;
+exports.commit = commit;
+exports.commitEither = commitEither;
+exports.cond = cond;
+exports.context = context;
+exports.contextWith = contextWith;
+exports.contextWithSTM = contextWithSTM;
+exports.die = die;
+exports.dieMessage = dieMessage;
+exports.dieSync = dieSync;
+exports.either = either;
+exports.ensuring = ensuring;
+exports.eventually = eventually;
+exports.every = every;
+exports.exists = exists;
+exports.fail = fail;
+exports.failSync = failSync;
+exports.fiberId = fiberId;
+exports.filter = filter;
+exports.filterNot = filterNot;
+exports.filterOrDie = filterOrDie;
+exports.filterOrDieMessage = filterOrDieMessage;
+exports.filterOrElse = filterOrElse;
+exports.filterOrFail = filterOrFail;
+exports.firstSuccessOf = firstSuccessOf;
+exports.flatMap = flatMap;
+exports.flatten = flatten;
+exports.flip = flip;
+exports.flipWith = flipWith;
+exports.forEach = forEach;
+exports.fromEither = fromEither;
+exports.fromOption = fromOption;
+exports.gen = gen;
+exports.head = head;
+exports.if_ = if_;
+exports.ignore = ignore;
+exports.interrupt = interrupt;
+exports.interruptAs = interruptAs;
+exports.isFailure = isFailure;
+exports.isSTM = isSTM;
+exports.isSuccess = isSuccess;
+exports.iterate = iterate;
+exports.let_ = let_;
+exports.loop = loop;
+exports.map = map;
+exports.mapAttempt = mapAttempt;
+exports.mapBoth = mapBoth;
+exports.mapError = mapError;
+exports.mapInputContext = mapInputContext;
+exports.match = match;
+exports.matchSTM = matchSTM;
+exports.merge = merge;
+exports.mergeAll = mergeAll;
+exports.negate = negate;
+exports.none = none;
+exports.option = option;
+exports.orDie = orDie;
+exports.orDieWith = orDieWith;
+exports.orElse = orElse;
+exports.orElseEither = orElseEither;
+exports.orElseFail = orElseFail;
+exports.orElseOptional = orElseOptional;
+exports.orElseSucceed = orElseSucceed;
+exports.orTry = orTry;
+exports.partition = partition;
+exports.provideContext = provideContext;
+exports.provideService = provideService;
+exports.provideServiceSTM = provideServiceSTM;
+exports.provideSomeContext = provideSomeContext;
+exports.reduce = reduce;
+exports.reduceAll = reduceAll;
+exports.reduceRight = reduceRight;
+exports.refineOrDie = refineOrDie;
+exports.refineOrDieWith = refineOrDieWith;
+exports.reject = reject;
+exports.rejectSTM = rejectSTM;
+exports.repeatUntil = repeatUntil;
+exports.repeatWhile = repeatWhile;
+exports.replicate = replicate;
+exports.replicateSTM = replicateSTM;
+exports.replicateSTMDiscard = replicateSTMDiscard;
+exports.retry = retry;
+exports.retryUntil = retryUntil;
+exports.retryWhile = retryWhile;
+exports.some = some;
+exports.succeed = succeed;
+exports.succeedNone = succeedNone;
+exports.succeedSome = succeedSome;
+exports.summarized = summarized;
+exports.suspend = suspend;
+exports.sync = sync;
+exports.tap = tap;
+exports.tapBoth = tapBoth;
+exports.tapError = tapError;
+exports.try_ = try_;
+exports.unit = unit;
+exports.unless = unless;
+exports.unlessSTM = unlessSTM;
+exports.unsome = unsome;
+exports.validateAll = validateAll;
+exports.validateFirst = validateFirst;
+exports.when = when;
+exports.whenSTM = whenSTM;
+exports.zip = zip;
+exports.zipLeft = zipLeft;
+exports.zipRight = zipRight;
+exports.zipWith = zipWith;