effect 2.0.0-next.5 → 2.0.0-next.50

package/STM/dist/effect-STM.esm.js

@@ -0,0 +1,1193 @@
+import { IllegalArgumentException } from '../../Cause/dist/effect-Cause.esm.js';
+import { fromIterable, isNonEmpty, reduce as reduce$2, tailNonEmpty, headNonEmpty } from '../../Chunk/dist/effect-Chunk.esm.js';
+import { STMTypeId as STMTypeId$1, isSTM as isSTM$1, catchAll as catchAll$1, commit as commit$1, context as context$1, contextWith as contextWith$1, contextWithSTM as contextWithSTM$1, mapInputContext as mapInputContext$1, die as die$1, dieMessage as dieMessage$1, dieSync as dieSync$1, ensuring as ensuring$1, fail as fail$1, failSync as failSync$1, flatMap as flatMap$1, matchSTM as matchSTM$1, interrupt as interrupt$1, interruptAs as interruptAs$1, map as map$1, orTry as orTry$1, retry as retry$1, succeed as succeed$1, sync as sync$1, zip as zip$1, zipLeft as zipLeft$1, zipRight as zipRight$1, zipWith as zipWith$1 } from '../../internal/stm/core.esm.js';
+import { acquireUseRelease as acquireUseRelease$1, all as all$1, as as as$1, asSome as asSome$1, asSomeError as asSomeError$1, asUnit as asUnit$1, attempt as attempt$1, catchSome as catchSome$1, catchTag as catchTag$1, catchTags as catchTags$1, check as check$1, collect as collect$1, collectSTM as collectSTM$1, commitEither as commitEither$1, cond as cond$1, either as either$1, eventually as eventually$1, every as every$1, exists as exists$1, fiberId as fiberId$1, filter as filter$1, filterNot as filterNot$1, filterOrDie as filterOrDie$1, filterOrDieMessage as filterOrDieMessage$1, filterOrElse as filterOrElse$1, filterOrFail as filterOrFail$1, flatten as flatten$1, flip as flip$1, flipWith as flipWith$1, match as match$1, forEach as forEach$1, fromEither as fromEither$1, fromOption as fromOption$1, gen as gen$1, head as head$1, if_ as if_$1, ignore as ignore$1, isFailure as isFailure$1, isSuccess as isSuccess$1, iterate as iterate$1, loop as loop$1, mapAttempt as mapAttempt$1, mapBoth as mapBoth$1, mapError as mapError$1, merge as merge$1, mergeAll as mergeAll$1, negate as negate$1, none as none$1, option as option$1, orDie as orDie$1, orDieWith as orDieWith$1, orElse as orElse$1, orElseEither as orElseEither$1, orElseFail as orElseFail$1, orElseOptional as orElseOptional$1, orElseSucceed as orElseSucceed$1, partition as partition$1, provideContext as provideContext$1, provideSomeContext as provideSomeContext$1, provideService as provideService$1, provideServiceSTM as provideServiceSTM$1, reduce as reduce$1, reduceAll as reduceAll$1, reduceRight as reduceRight$1, refineOrDie as refineOrDie$1, refineOrDieWith as refineOrDieWith$1, reject as reject$1, rejectSTM as rejectSTM$1, repeatUntil as repeatUntil$1, repeatWhile as repeatWhile$1, replicate as replicate$1, replicateSTM as replicateSTM$1, replicateSTMDiscard as replicateSTMDiscard$1, retryUntil as retryUntil$1, retryWhile as retryWhile$1, some as some$1, succeedNone as succeedNone$1, succeedSome as succeedSome$1, summarized as summarized$1, suspend as suspend$1, tap as tap$1, tapBoth as tapBoth$1, tapError as tapError$1, try_ as try_$1, unless as unless$1, unlessSTM as unlessSTM$1, unsome as unsome$1, unit as unit$1, validateAll as validateAll$1, validateFirst as validateFirst$1, when as when$1, whenSTM as whenSTM$1, bind as bind$1, let_ as let_$1, bindTo as bindTo$1 } from '../../internal/stm/stm.esm.js';
+
+/**
+ * @since 2.0.0
+ */
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const STMTypeId = STMTypeId$1;
+
+/**
+ * @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 = isSTM$1;
+
+/**
+ * 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 = acquireUseRelease$1;
+
+/**
+ * @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 = all$1;
+
+/**
+ * Maps the success value of this effect to the specified constant value.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const as = as$1;
+
+/**
+ * Maps the success value of this effect to an optional value.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const asSome = asSome$1;
+
+/**
+ * Maps the error value of this effect to an optional value.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const asSomeError = asSomeError$1;
+
+/**
+ * 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 = asUnit$1;
+
+/**
+ * Creates an `STM` value from a partial (but pure) function.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const attempt = attempt$1;
+
+/**
+ * Recovers from all errors.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const catchAll = catchAll$1;
+
+/**
+ * Recovers from some or all of the error cases.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const catchSome = catchSome$1;
+
+/**
+ * Recovers from the specified tagged error.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const catchTag = catchTag$1;
+
+/**
+ * Recovers from multiple tagged errors.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const catchTags = catchTags$1;
+
+/**
+ * Checks the condition, and if it's true, returns unit, otherwise, retries.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const check = check$1;
+
+/**
+ * Simultaneously filters and maps the value produced by this effect.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const collect = collect$1;
+
+/**
+ * Simultaneously filters and maps the value produced by this effect.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const collectSTM = collectSTM$1;
+
+/**
+ * Commits this transaction atomically.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const commit = commit$1;
+
+/**
+ * Commits this transaction atomically, regardless of whether the transaction
+ * is a success or a failure.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const commitEither = commitEither$1;
+
+/**
+ * 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 = cond$1;
+
+/**
+ * Retrieves the environment inside an stm.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const context = context$1;
+
+/**
+ * Accesses the environment of the transaction to perform a transaction.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const contextWith = contextWith$1;
+
+/**
+ * Accesses the environment of the transaction to perform a transaction.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const contextWithSTM = contextWithSTM$1;
+
+/**
+ * Transforms the environment being provided to this effect with the specified
+ * function.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const mapInputContext = mapInputContext$1;
+
+/**
+ * Fails the transactional effect with the specified defect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const die = die$1;
+
+/**
+ * Kills the fiber running the effect with a `Cause.RuntimeException` that
+ * contains the specified message.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const dieMessage = dieMessage$1;
+
+/**
+ * Fails the transactional effect with the specified lazily evaluated defect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const dieSync = dieSync$1;
+
+/**
+ * Converts the failure channel into an `Either`.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const either = either$1;
+
+/**
+ * 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 = ensuring$1;
+
+/**
+ * Returns an effect that ignores errors and runs repeatedly until it
+ * eventually succeeds.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const eventually = eventually$1;
+
+/**
+ * Determines whether all elements of the `Iterable<A>` satisfy the effectual
+ * predicate.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const every = every$1;
+
+/**
+ * Determines whether any element of the `Iterable[A]` satisfies the effectual
+ * predicate `f`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const exists = exists$1;
+
+/**
+ * Fails the transactional effect with the specified error.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fail = fail$1;
+
+/**
+ * Fails the transactional effect with the specified lazily evaluated error.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const failSync = failSync$1;
+
+/**
+ * Returns the fiber id of the fiber committing the transaction.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fiberId = fiberId$1;
+
+/**
+ * Filters the collection using the specified effectual predicate.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const filter = filter$1;
+
+/**
+ * Filters the collection using the specified effectual predicate, removing
+ * all elements that satisfy the predicate.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const filterNot = filterNot$1;
+
+/**
+ * Dies with specified defect if the predicate fails.
+ *
+ * @since 2.0.0
+ * @category filtering
+ */
+const filterOrDie = filterOrDie$1;
+
+/**
+ * Dies with a `Cause.RuntimeException` having the specified  message if the
+ * predicate fails.
+ *
+ * @since 2.0.0
+ * @category filtering
+ */
+const filterOrDieMessage = filterOrDieMessage$1;
+
+/**
+ * Supplies `orElse` if the predicate fails.
+ *
+ * @since 2.0.0
+ * @category filtering
+ */
+const filterOrElse = filterOrElse$1;
+
+/**
+ * Fails with the specified error if the predicate fails.
+ *
+ * @since 2.0.0
+ * @category filtering
+ */
+const filterOrFail = filterOrFail$1;
+
+/**
+ * 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 = flatMap$1;
+
+/**
+ * Flattens out a nested `STM` effect.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const flatten = flatten$1;
+
+/**
+ * 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 = flip$1;
+
+/**
+ * Swaps the error/value parameters, applies the function `f` and flips the
+ * parameters back
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const flipWith = flipWith$1;
+
+/**
+ * Folds over the `STM` effect, handling both failure and success, but not
+ * retry.
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+const match = match$1;
+
+/**
+ * Effectfully folds over the `STM` effect, handling both failure and success.
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+const matchSTM = matchSTM$1;
+
+/**
+ * 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 = forEach$1;
+
+/**
+ * Lifts an `Either` into a `STM`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromEither = fromEither$1;
+
+/**
+ * Lifts an `Option` into a `STM`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromOption = fromOption$1;
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const gen = gen$1;
+
+/**
+ * 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 = head$1;
+const if_ = if_$1;
+
+/**
+ * Returns a new effect that ignores the success or failure of this effect.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const ignore = ignore$1;
+
+/**
+ * Interrupts the fiber running the effect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const interrupt = interrupt$1;
+
+/**
+ * Interrupts the fiber running the effect with the specified `FiberId`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const interruptAs = interruptAs$1;
+
+/**
+ * Returns whether this transactional effect is a failure.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const isFailure = isFailure$1;
+
+/**
+ * Returns whether this transactional effect is a success.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const isSuccess = isSuccess$1;
+
+/**
+ * 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 = iterate$1;
+
+/**
+ * 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 = loop$1;
+
+/**
+ * Maps the value produced by the effect.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const map = map$1;
+
+/**
+ * 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 = mapAttempt$1;
+
+/**
+ * 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 = mapBoth$1;
+
+/**
+ * Maps from one error type to another.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapError = mapError$1;
+
+/**
+ * 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 = merge$1;
+
+/**
+ * Merges an `Iterable<STM>` to a single `STM`, working sequentially.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const mergeAll = mergeAll$1;
+
+/**
+ * Returns a new effect where boolean value of this effect is negated.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const negate = negate$1;
+
+/**
+ * Requires the option produced by this value to be `None`.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const none = none$1;
+
+/**
+ * Converts the failure channel into an `Option`.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const option = option$1;
+
+/**
+ * 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 = orDie$1;
+
+/**
+ * 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 = orDieWith$1;
+
+/**
+ * Tries this effect first, and if it fails or retries, tries the other
+ * effect.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const orElse = orElse$1;
+
+/**
+ * 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 = orElseEither$1;
+
+/**
+ * Tries this effect first, and if it fails or retries, fails with the
+ * specified error.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const orElseFail = orElseFail$1;
+
+/**
+ * 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 = orElseOptional$1;
+
+/**
+ * Tries this effect first, and if it fails or retries, succeeds with the
+ * specified value.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const orElseSucceed = orElseSucceed$1;
+
+/**
+ * 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 = orTry$1;
+
+/**
+ * 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 = partition$1;
+
+/**
+ * Provides the transaction its required environment, which eliminates its
+ * dependency on `R`.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const provideContext = provideContext$1;
+
+/**
+ * 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 = provideSomeContext$1;
+
+/**
+ * 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 = provideService$1;
+
+/**
+ * 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 = provideServiceSTM$1;
+
+/**
+ * Folds an `Iterable<A>` using an effectual function f, working sequentially
+ * from left to right.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const reduce = reduce$1;
+
+/**
+ * Reduces an `Iterable<STM>` to a single `STM`, working sequentially.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const reduceAll = reduceAll$1;
+
+/**
+ * Folds an `Iterable<A>` using an effectual function f, working sequentially
+ * from right to left.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const reduceRight = reduceRight$1;
+
+/**
+ * Keeps some of the errors, and terminates the fiber with the rest.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const refineOrDie = refineOrDie$1;
+
+/**
+ * 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 = refineOrDieWith$1;
+
+/**
+ * Fail with the returned value if the `PartialFunction` matches, otherwise
+ * continue with our held value.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const reject = reject$1;
+
+/**
+ * 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 = rejectSTM$1;
+
+/**
+ * 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 = repeatUntil$1;
+
+/**
+ * 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 = repeatWhile$1;
+
+/**
+ * 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 = replicate$1;
+
+/**
+ * Performs this transaction the specified number of times and collects the
+ * results.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const replicateSTM = replicateSTM$1;
+
+/**
+ * Performs this transaction the specified number of times, discarding the
+ * results.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const replicateSTMDiscard = replicateSTMDiscard$1;
+
+/**
+ * Abort and retry the whole transaction when any of the underlying
+ * transactional variables have changed.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const retry = retry$1;
+
+/**
+ * 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 = retryUntil$1;
+
+/**
+ * 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 = retryWhile$1;
+
+/**
+ * Converts an option on values into an option on errors.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const some = some$1;
+
+/**
+ * Returns an `STM` effect that succeeds with the specified value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const succeed = succeed$1;
+
+/**
+ * Returns an effect with the empty value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const succeedNone = succeedNone$1;
+
+/**
+ * Returns an effect with the optional value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const succeedSome = succeedSome$1;
+
+/**
+ * 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 = summarized$1;
+
+/**
+ * Suspends creation of the specified transaction lazily.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const suspend = suspend$1;
+
+/**
+ * Returns an `STM` effect that succeeds with the specified lazily evaluated
+ * value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const sync = sync$1;
+
+/**
+ * "Peeks" at the success of transactional effect.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const tap = tap$1;
+
+/**
+ * "Peeks" at both sides of an transactional effect.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const tapBoth = tapBoth$1;
+
+/**
+ * "Peeks" at the error of the transactional effect.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const tapError = tapError$1;
+const try_ = try_$1;
+
+/**
+ * The moral equivalent of `if (!p) exp`
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const unless = unless$1;
+
+/**
+ * The moral equivalent of `if (!p) exp` when `p` has side-effects
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const unlessSTM = unlessSTM$1;
+
+/**
+ * Converts an option on errors into an option on values.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const unsome = unsome$1;
+
+/**
+ * Returns an `STM` effect that succeeds with `Unit`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const unit = unit$1;
+
+/**
+ * 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 = validateAll$1;
+
+/**
+ * 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 = validateFirst$1;
+
+/**
+ * The moral equivalent of `if (p) exp`.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const when = when$1;
+
+/**
+ * The moral equivalent of `if (p) exp` when `p` has side-effects.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const whenSTM = whenSTM$1;
+
+/**
+ * Sequentially zips this value with the specified one.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zip = zip$1;
+
+/**
+ * Sequentially zips this value with the specified one, discarding the second
+ * element of the tuple.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipLeft = zipLeft$1;
+
+/**
+ * Sequentially zips this value with the specified one, discarding the first
+ * element of the tuple.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipRight = zipRight$1;
+
+/**
+ * Sequentially zips this value with the specified one, combining the values
+ * using the specified combiner function.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipWith = zipWith$1;
+
+/**
+ * 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 = fromIterable(effects);
+  if (!isNonEmpty(list)) {
+    return dieSync(() => IllegalArgumentException(`Received an empty collection of effects`));
+  }
+  return reduce$2(tailNonEmpty(list), 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 = bind$1;
+const let_ = let_$1;
+
+/**
+ * @category do notation
+ * @since 2.0.0
+ */
+const bindTo = bindTo$1;
+
+export { Do, STMTypeId, acquireUseRelease, all, as, asSome, asSomeError, asUnit, attempt, bind, bindTo, catchAll, catchSome, catchTag, catchTags, check, collect, collectSTM, commit, commitEither, cond, context, contextWith, contextWithSTM, die, dieMessage, dieSync, either, ensuring, eventually, every, exists, fail, failSync, fiberId, filter, filterNot, filterOrDie, filterOrDieMessage, filterOrElse, filterOrFail, firstSuccessOf, flatMap, flatten, flip, flipWith, forEach, fromEither, fromOption, gen, head, if_ as if, ignore, interrupt, interruptAs, isFailure, isSTM, isSuccess, iterate, let_ as let, loop, map, mapAttempt, mapBoth, mapError, mapInputContext, match, matchSTM, merge, mergeAll, negate, none, option, orDie, orDieWith, orElse, orElseEither, orElseFail, orElseOptional, orElseSucceed, orTry, partition, provideContext, provideService, provideServiceSTM, provideSomeContext, reduce, reduceAll, reduceRight, refineOrDie, refineOrDieWith, reject, rejectSTM, repeatUntil, repeatWhile, replicate, replicateSTM, replicateSTMDiscard, retry, retryUntil, retryWhile, some, succeed, succeedNone, succeedSome, summarized, suspend, sync, tap, tapBoth, tapError, try_ as try, unit, unless, unlessSTM, unsome, validateAll, validateFirst, when, whenSTM, zip, zipLeft, zipRight, zipWith };