effect 2.0.0-next.37 → 2.0.0-next.38

package/dist/Cause-384e2165.cjs.prod.js

@@ -0,0 +1,791 @@
+'use strict';
+
+var core = require('./core-c2eb171a.cjs.prod.js');
+
+/**
+ * The `Effect<R, E, A>` type is polymorphic in values of type `E` and we can
+ * work with any error type that we want. However, there is a lot of information
+ * that is not inside an arbitrary `E` value. So as a result, an `Effect` needs
+ * somewhere to store things like unexpected errors or defects, stack and
+ * execution traces, causes of fiber interruptions, and so forth.
+ *
+ * Effect-TS is very strict about preserving the full information related to a
+ * failure. It captures all type of errors into the `Cause` data type. `Effect`
+ * uses the `Cause<E>` data type to store the full story of failure. So its
+ * error model is lossless. It doesn't throw information related to the failure
+ * result. So we can figure out exactly what happened during the operation of
+ * our effects.
+ *
+ * It is important to note that `Cause` is an underlying data type representing
+ * errors occuring within an `Effect` workflow. Thus, we don't usually deal with
+ * `Cause`s directly. Even though it is not a data type that we deal with very
+ * often, the `Cause` of a failing `Effect` workflow can be accessed at any
+ * time, which gives us total access to all parallel and sequential errors in
+ * occurring within our codebase.
+ *
+ * @since 2.0.0
+ */
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const CauseTypeId = core.CauseTypeId;
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const RuntimeExceptionTypeId = core.RuntimeExceptionTypeId;
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const InterruptedExceptionTypeId = core.InterruptedExceptionTypeId;
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const IllegalArgumentExceptionTypeId = core.IllegalArgumentExceptionTypeId;
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const NoSuchElementExceptionTypeId = core.NoSuchElementExceptionTypeId;
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const InvalidHubCapacityExceptionTypeId = core.InvalidHubCapacityExceptionTypeId;
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+
+/**
+ * A `Cause` represents the full history of a failure resulting from running an
+ * `Effect` workflow.
+ *
+ * Effect-TS uses a data structure from functional programming called a semiring
+ * to represent the `Cause` data type. This allows us to take a base type `E`
+ * (which represents the error type of an `Effect`) and capture the sequential
+ * and parallel composition of errors in a fully lossless fashion.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * @since 2.0.0
+ */
+
+/**
+ * Represents a set of methods that can be used to reduce a `Cause<E>` to a
+ * specified value of type `Z` with access to a context of type `C`.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * Represents a generic checked exception which occurs at runtime.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * Represents a checked exception which occurs when a `Fiber` is interrupted.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * Represents a checked exception which occurs when an invalid argument is
+ * provided to a method.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * Represents a checked exception which occurs when an expected element was
+ * unable to be found.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * Represents a checked exception which occurs when attempting to construct a
+ * `Hub` with an invalid capacity.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * The `Empty` cause represents a lack of errors.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * The `Fail` cause represents a `Cause` which failed with an expected error of
+ * type `E`.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * The `Die` cause represents a `Cause` which failed as a result of a defect, or
+ * in other words, an unexpected error.
+ *
+ * type `E`.
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * The `Interrupt` cause represents failure due to `Fiber` interruption, which
+ * contains the `FiberId` of the interrupted `Fiber`.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * The `Parallel` cause represents the composition of two causes which occurred
+ * in parallel.
+ *
+ * In Effect-TS programs, it is possible that two operations may be performed in
+ * parallel. In these cases, the `Effect` workflow can fail for more than one
+ * reason. If both computations fail, then there are actually two errors which
+ * occurred in parallel. In these cases, the errors can be represented by the
+ * `Parallel` cause.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * The `Sequential` cause represents the composition of two causes which occurred
+ * sequentially.
+ *
+ * For example, if we perform Effect-TS's analog of `try-finally` (i.e.
+ * `Effect.ensuring`), and both the `try` and `finally` blocks fail, we have two
+ * errors which occurred sequentially. In these cases, the errors can be
+ * represented by the `Sequential` cause.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * Constructs a new `Empty` cause.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const empty = core.empty;
+
+/**
+ * Constructs a new `Fail` cause from the specified `error`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fail = core.fail$1;
+
+/**
+ * Constructs a new `Die` cause from the specified `defect`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const die = core.die;
+
+/**
+ * Constructs a new `Interrupt` cause from the specified `fiberId`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const interrupt = core.interrupt$1;
+
+/**
+ * Constructs a new `Parallel` cause from the specified `left` and `right`
+ * causes.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const parallel = core.parallel;
+
+/**
+ * Constructs a new `Sequential` cause from the specified pecified `left` and
+ * `right` causes.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const sequential = core.sequential;
+
+/**
+ * Returns `true` if the specified value is a `Cause`, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isCause = core.isCause;
+
+/**
+ * Returns `true` if the specified `Cause` is an `Empty` type, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isEmptyType = core.isEmptyType;
+
+/**
+ * Returns `true` if the specified `Cause` is a `Fail` type, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isFailType = core.isFailType;
+
+/**
+ * Returns `true` if the specified `Cause` is a `Die` type, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isDieType = core.isDieType;
+
+/**
+ * Returns `true` if the specified `Cause` is an `Interrupt` type, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isInterruptType = core.isInterruptType;
+
+/**
+ * Returns `true` if the specified `Cause` is a `Sequential` type, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isSequentialType = core.isSequentialType;
+
+/**
+ * Returns `true` if the specified `Cause` is a `Parallel` type, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isParallelType = core.isParallelType;
+
+/**
+ * Returns the size of the cause, calculated as the number of individual `Cause`
+ * nodes found in the `Cause` semiring structure.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const size = core.size;
+
+/**
+ * Returns `true` if the specified cause is empty, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const isEmpty = core.isEmpty;
+
+/**
+ * Returns `true` if the specified cause contains a failure, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const isFailure = core.isFailure;
+
+/**
+ * Returns `true` if the specified cause contains a defect, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const isDie = core.isDie;
+
+/**
+ * Returns `true` if the specified cause contains an interruption, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const isInterrupted = core.isInterrupted;
+
+/**
+ * Returns `true` if the specified cause contains only interruptions (without
+ * any `Die` or `Fail` causes), `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const isInterruptedOnly = core.isInterruptedOnly;
+
+/**
+ * Returns a `List` of all recoverable errors of type `E` in the specified
+ * cause.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const failures = core.failures;
+
+/**
+ * Returns a `List` of all unrecoverable defects in the specified cause.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const defects = core.defects;
+
+/**
+ * Returns a `HashSet` of `FiberId`s for all fibers that interrupted the fiber
+ * described by the specified cause.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const interruptors = core.interruptors;
+
+/**
+ * Returns the `E` associated with the first `Fail` in this `Cause`, if one
+ * exists.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const failureOption = core.failureOption;
+
+/**
+ * Returns the first checked error on the `Left` if available, if there are
+ * no checked errors return the rest of the `Cause` that is known to contain
+ * only `Die` or `Interrupt` causes.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const failureOrCause = core.failureOrCause;
+
+/**
+ * Converts the specified `Cause<Option<E>>` to an `Option<Cause<E>>` by
+ * recursively stripping out any failures with the error `None`.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const flipCauseOption = core.flipCauseOption;
+
+/**
+ * Returns the defect associated with the first `Die` in this `Cause`, if one
+ * exists.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const dieOption = core.dieOption;
+
+/**
+ * Returns the `FiberId` associated with the first `Interrupt` in the specified
+ * cause, if one exists.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const interruptOption = core.interruptOption;
+
+/**
+ * Remove all `Fail` and `Interrupt` nodes from the specified cause, and return
+ * a cause containing only `Die` cause/finalizer defects.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const keepDefects = core.keepDefects;
+
+/**
+ * Linearizes the specified cause into a `HashSet` of parallel causes where each
+ * parallel cause contains a linear sequence of failures.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const linearize = core.linearize;
+
+/**
+ * Remove all `Fail` and `Interrupt` nodes from the specified cause, and return
+ * a cause containing only `Die` cause/finalizer defects.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const stripFailures = core.stripFailures;
+
+/**
+ * Remove all `Die` causes that the specified partial function is defined at,
+ * returning `Some` with the remaining causes or `None` if there are no
+ * remaining causes.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const stripSomeDefects = core.stripSomeDefects;
+
+/**
+ * @since 2.0.0
+ * @category mapping
+ */
+const as = core.as$1;
+
+/**
+ * @since 2.0.0
+ * @category mapping
+ */
+const map = core.map$1;
+
+/**
+ * @since 2.0.0
+ * @category sequencing
+ */
+const flatMap = core.flatMap$1;
+
+/**
+ * @since 2.0.0
+ * @category sequencing
+ */
+const flatten = core.flatten$2;
+
+/**
+ * Returns `true` if the `self` cause contains or is equal to `that` cause,
+ * `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const contains = core.contains;
+
+/**
+ * Squashes a `Cause` down to a single defect, chosen to be the "most important"
+ * defect.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const squash = core.squash;
+
+/**
+ * Squashes a `Cause` down to a single defect, chosen to be the "most important"
+ * defect. If a recoverable error is found, the provided function will be used
+ * to map the error a defect, and the resulting value will be returned.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const squashWith = core.squashWith;
+
+/**
+ * Uses the provided partial function to search the specified cause and attempt
+ * to extract information from it.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const find = core.find;
+
+/**
+ * Filters causes which match the provided predicate out of the specified cause.
+ *
+ * @since 2.0.0
+ * @category filtering
+ */
+const filter = core.filter;
+
+/**
+ * Folds the specified cause into a value of type `Z`.
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+const match = core.match;
+
+/**
+ * Reduces the specified cause into a value of type `Z`, beginning with the
+ * provided `zero` value.
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+const reduce = core.reduce;
+
+/**
+ * Reduces the specified cause into a value of type `Z` using a `Cause.Reducer`.
+ * Also allows for accessing the provided context during reduction.
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+const reduceWithContext = core.reduceWithContext;
+
+/**
+ * Represents a checked exception which occurs when a `Fiber` is interrupted.
+ *
+ * @since 2.0.0
+ * @category errors
+ */
+const InterruptedException = core.InterruptedException;
+
+/**
+ * Returns `true` if the specified value is an `InterruptedException`, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isInterruptedException = core.isInterruptedException;
+
+/**
+ * Represents a checked exception which occurs when an invalid argument is
+ * provided to a method.
+ *
+ * @since 2.0.0
+ * @category errors
+ */
+const IllegalArgumentException = core.IllegalArgumentException;
+
+/**
+ * Returns `true` if the specified value is an `IllegalArgumentException`, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isIllegalArgumentException = core.isIllegalArgumentException;
+
+/**
+ * Represents a checked exception which occurs when an expected element was
+ * unable to be found.
+ *
+ * @since 2.0.0
+ * @category errors
+ */
+const NoSuchElementException = core.NoSuchElementException;
+
+/**
+ * Returns `true` if the specified value is an `NoSuchElementException`, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isNoSuchElementException = core.isNoSuchElementException;
+
+/**
+ * Represents a generic checked exception which occurs at runtime.
+ *
+ * @since 2.0.0
+ * @category errors
+ */
+const RuntimeException = core.RuntimeException;
+
+/**
+ * Returns `true` if the specified value is an `RuntimeException`, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isRuntimeException = core.isRuntimeException;
+
+/**
+ * Returns the specified `Cause` as a pretty-printed string.
+ *
+ * @since 2.0.0
+ * @category rendering
+ */
+const pretty = core.pretty;
+
+/**
+ * Returns the original, unproxied, instance of a thrown error
+ *
+ * @since 2.0.0
+ * @category errors
+ */
+const originalError = core.originalInstance;
+
+var Cause = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  CauseTypeId: CauseTypeId,
+  RuntimeExceptionTypeId: RuntimeExceptionTypeId,
+  InterruptedExceptionTypeId: InterruptedExceptionTypeId,
+  IllegalArgumentExceptionTypeId: IllegalArgumentExceptionTypeId,
+  NoSuchElementExceptionTypeId: NoSuchElementExceptionTypeId,
+  InvalidHubCapacityExceptionTypeId: InvalidHubCapacityExceptionTypeId,
+  empty: empty,
+  fail: fail,
+  die: die,
+  interrupt: interrupt,
+  parallel: parallel,
+  sequential: sequential,
+  isCause: isCause,
+  isEmptyType: isEmptyType,
+  isFailType: isFailType,
+  isDieType: isDieType,
+  isInterruptType: isInterruptType,
+  isSequentialType: isSequentialType,
+  isParallelType: isParallelType,
+  size: size,
+  isEmpty: isEmpty,
+  isFailure: isFailure,
+  isDie: isDie,
+  isInterrupted: isInterrupted,
+  isInterruptedOnly: isInterruptedOnly,
+  failures: failures,
+  defects: defects,
+  interruptors: interruptors,
+  failureOption: failureOption,
+  failureOrCause: failureOrCause,
+  flipCauseOption: flipCauseOption,
+  dieOption: dieOption,
+  interruptOption: interruptOption,
+  keepDefects: keepDefects,
+  linearize: linearize,
+  stripFailures: stripFailures,
+  stripSomeDefects: stripSomeDefects,
+  as: as,
+  map: map,
+  flatMap: flatMap,
+  flatten: flatten,
+  contains: contains,
+  squash: squash,
+  squashWith: squashWith,
+  find: find,
+  filter: filter,
+  match: match,
+  reduce: reduce,
+  reduceWithContext: reduceWithContext,
+  InterruptedException: InterruptedException,
+  isInterruptedException: isInterruptedException,
+  IllegalArgumentException: IllegalArgumentException,
+  isIllegalArgumentException: isIllegalArgumentException,
+  NoSuchElementException: NoSuchElementException,
+  isNoSuchElementException: isNoSuchElementException,
+  RuntimeException: RuntimeException,
+  isRuntimeException: isRuntimeException,
+  pretty: pretty,
+  originalError: originalError
+});
+
+exports.Cause = Cause;
+exports.CauseTypeId = CauseTypeId;
+exports.IllegalArgumentException = IllegalArgumentException;
+exports.IllegalArgumentExceptionTypeId = IllegalArgumentExceptionTypeId;
+exports.InterruptedException = InterruptedException;
+exports.InterruptedExceptionTypeId = InterruptedExceptionTypeId;
+exports.InvalidHubCapacityExceptionTypeId = InvalidHubCapacityExceptionTypeId;
+exports.NoSuchElementException = NoSuchElementException;
+exports.NoSuchElementExceptionTypeId = NoSuchElementExceptionTypeId;
+exports.RuntimeException = RuntimeException;
+exports.RuntimeExceptionTypeId = RuntimeExceptionTypeId;
+exports.as = as;
+exports.contains = contains;
+exports.defects = defects;
+exports.die = die;
+exports.dieOption = dieOption;
+exports.empty = empty;
+exports.fail = fail;
+exports.failureOption = failureOption;
+exports.failureOrCause = failureOrCause;
+exports.failures = failures;
+exports.filter = filter;
+exports.find = find;
+exports.flatMap = flatMap;
+exports.flatten = flatten;
+exports.flipCauseOption = flipCauseOption;
+exports.interrupt = interrupt;
+exports.interruptOption = interruptOption;
+exports.interruptors = interruptors;
+exports.isCause = isCause;
+exports.isDie = isDie;
+exports.isDieType = isDieType;
+exports.isEmpty = isEmpty;
+exports.isEmptyType = isEmptyType;
+exports.isFailType = isFailType;
+exports.isFailure = isFailure;
+exports.isIllegalArgumentException = isIllegalArgumentException;
+exports.isInterruptType = isInterruptType;
+exports.isInterrupted = isInterrupted;
+exports.isInterruptedException = isInterruptedException;
+exports.isInterruptedOnly = isInterruptedOnly;
+exports.isNoSuchElementException = isNoSuchElementException;
+exports.isParallelType = isParallelType;
+exports.isRuntimeException = isRuntimeException;
+exports.isSequentialType = isSequentialType;
+exports.keepDefects = keepDefects;
+exports.linearize = linearize;
+exports.map = map;
+exports.match = match;
+exports.originalError = originalError;
+exports.parallel = parallel;
+exports.pretty = pretty;
+exports.reduce = reduce;
+exports.reduceWithContext = reduceWithContext;
+exports.sequential = sequential;
+exports.size = size;
+exports.squash = squash;
+exports.squashWith = squashWith;
+exports.stripFailures = stripFailures;
+exports.stripSomeDefects = stripSomeDefects;