@fncts/base 0.0.1

package/_cjs/data/Cause/api.cjs

@@ -0,0 +1,1406 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  both: true,
+  flatMap_: true,
+  empty: true,
+  fail: true,
+  failed: true,
+  failureTraceMaybe: true,
+  failureMaybe: true,
+  find_: true,
+  foldLeft_: true,
+  halt: true,
+  halted: true,
+  haltMaybe: true,
+  interrupt: true,
+  isFail: true,
+  isHalt: true,
+  interruptOption: true,
+  map_: true,
+  mapTrace_: true,
+  stackless: true,
+  then: true,
+  traced: true,
+  as_: true,
+  contains_: true,
+  defects: true,
+  failures: true,
+  failureOrCause: true,
+  failureTraceOrCause: true,
+  filterDefects_: true,
+  flatten: true,
+  flipCauseEither: true,
+  flipCauseOption: true,
+  isBoth: true,
+  isThen: true,
+  isTraced: true,
+  interrupted: true,
+  interruptors: true,
+  interruptedOnly: true,
+  keepDefects: true,
+  stripFailures: true,
+  sequenceCauseEither: true,
+  sequenceCauseMaybe: true,
+  untraced: true
+};
+exports.as_ = as_;
+exports.both = void 0;
+exports.contains_ = contains_;
+exports.defects = defects;
+exports.failureMaybe = exports.failed = exports.fail = exports.empty = void 0;
+exports.failureOrCause = failureOrCause;
+exports.failureTraceMaybe = void 0;
+exports.failureTraceOrCause = failureTraceOrCause;
+exports.failures = failures;
+exports.filterDefects_ = filterDefects_;
+exports.flatMap_ = exports.find_ = void 0;
+exports.flatten = flatten;
+exports.flipCauseEither = flipCauseEither;
+exports.flipCauseOption = flipCauseOption;
+exports.interruptOption = exports.interrupt = exports.halted = exports.haltMaybe = exports.halt = exports.foldLeft_ = void 0;
+exports.interrupted = interrupted;
+exports.interruptedOnly = interruptedOnly;
+exports.interruptors = interruptors;
+exports.isBoth = isBoth;
+exports.isHalt = exports.isFail = void 0;
+exports.isThen = isThen;
+exports.isTraced = isTraced;
+exports.keepDefects = keepDefects;
+exports.map_ = exports.mapTrace_ = void 0;
+exports.sequenceCauseEither = sequenceCauseEither;
+exports.sequenceCauseMaybe = sequenceCauseMaybe;
+exports.stackless = void 0;
+exports.stripFailures = stripFailures;
+exports.traced = exports.then = void 0;
+exports.untraced = untraced;
+
+var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/control/Eval/constructors"));
+
+var tsplus_module_2 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/control/Eval/api"));
+
+var tsplus_module_3 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Cause/api/isEmpty"));
+
+var tsplus_module_4 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/control/Eval/run"));
+
+var tsplus_module_5 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/constructors"));
+
+var tsplus_module_6 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/List/api"));
+
+var tsplus_module_7 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/List/constructors"));
+
+var tsplus_module_8 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Trace/constructors"));
+
+var tsplus_module_9 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/destructors"));
+
+var tsplus_module_10 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Either/constructors"));
+
+var tsplus_module_11 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/definition"));
+
+var tsplus_module_12 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/api"));
+
+var tsplus_module_13 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Cause/api/fold"));
+
+var tsplus_module_14 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/List/definition"));
+
+var tsplus_module_15 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/List/api/unsafeTail"));
+
+var tsplus_module_16 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/internal/Stack"));
+
+var tsplus_module_17 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Either/destructors"));
+
+var tsplus_module_18 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Either/api"));
+
+var tsplus_module_19 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Trace/api"));
+
+var _function = /*#__PURE__*/require("../function.js");
+
+var _definition3 = /*#__PURE__*/require("./definition.js");
+
+var _fold2 = /*#__PURE__*/require("./api/fold.js");
+
+Object.keys(_fold2).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _fold2[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _fold2[key];
+    }
+  });
+});
+
+var _isEmpty2 = /*#__PURE__*/require("./api/isEmpty.js");
+
+Object.keys(_isEmpty2).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _isEmpty2[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _isEmpty2[key];
+    }
+  });
+});
+
+var _linearize = /*#__PURE__*/require("./api/linearize.js");
+
+Object.keys(_linearize).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _linearize[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _linearize[key];
+    }
+  });
+});
+
+var _prettyPrint = /*#__PURE__*/require("./api/prettyPrint.js");
+
+Object.keys(_prettyPrint).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _prettyPrint[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _prettyPrint[key];
+    }
+  });
+});
+
+var _unified = /*#__PURE__*/require("./api/unified.js");
+
+Object.keys(_unified).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _unified[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _unified[key];
+    }
+  });
+});
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const both = both_1;
+exports.both = both;
+const flatMap_ = flatMap_1;
+exports.flatMap_ = flatMap_;
+const empty = empty_1;
+exports.empty = empty;
+const fail = fail_1;
+exports.fail = fail;
+const failed = failed_1;
+exports.failed = failed;
+const failureTraceMaybe = failureTraceMaybe_1;
+exports.failureTraceMaybe = failureTraceMaybe;
+const failureMaybe = failureMaybe_1;
+exports.failureMaybe = failureMaybe;
+const find_ = find_1;
+exports.find_ = find_;
+const foldLeft_ = foldLeft_1;
+exports.foldLeft_ = foldLeft_;
+const halt = halt_1;
+exports.halt = halt;
+const halted = halted_1;
+exports.halted = halted;
+const haltMaybe = haltMaybe_1;
+exports.haltMaybe = haltMaybe;
+const interrupt = interrupt_1;
+exports.interrupt = interrupt;
+const isFail = isFail_1;
+exports.isFail = isFail;
+const isHalt = isHalt_1;
+exports.isHalt = isHalt;
+const interruptOption = interruptOption_1;
+exports.interruptOption = interruptOption;
+const map_ = map_1;
+exports.map_ = map_;
+const mapTrace_ = mapTrace_1;
+exports.mapTrace_ = mapTrace_;
+const stackless = stackless_1;
+exports.stackless = stackless;
+const then = then_1;
+exports.then = then;
+const traced = traced_1;
+exports.traced = traced;
+
+/**
+ * @tsplus fluent fncts.Cause as
+ */
+function as_(self, b) {
+  return map_1(self, () => b());
+}
+/**
+ * @internal
+ */
+
+
+function chainEval(self, f) {
+  switch (self._tag) {
+    case "Empty"
+    /* CauseTag.Empty */
+    :
+      return tsplus_module_1.now(empty_1());
+
+    case "Fail"
+    /* CauseTag.Fail */
+    :
+      return tsplus_module_1.now(traced_1(f(self.value), self.trace));
+
+    case "Halt"
+    /* CauseTag.Halt */
+    :
+      return tsplus_module_1.now(self);
+
+    case "Interrupt"
+    /* CauseTag.Interrupt */
+    :
+      return tsplus_module_1.now(self);
+
+    case "Then"
+    /* CauseTag.Then */
+    :
+      return tsplus_module_2.zipWith_(tsplus_module_1.defer(() => chainEval(self.left, f)), tsplus_module_1.defer(() => chainEval(self.right, f)), then_1);
+
+    case "Both"
+    /* CauseTag.Both */
+    :
+      return tsplus_module_2.zipWith_(tsplus_module_1.defer(() => chainEval(self.left, f)), tsplus_module_1.defer(() => chainEval(self.right, f)), both_1);
+
+    case "Stackless"
+    /* CauseTag.Stackless */
+    :
+      return tsplus_module_1.defer(() => chainEval(self.cause, f));
+  }
+}
+/**
+ * Constructs a `Cause` from two `Cause`s, representing parallel failures.
+ *
+ * @note If one of the `Cause`s is `Empty`, the non-empty `Cause` is returned
+ *
+ * @tsplus static fncts.CauseOps both
+ * @tsplus static fncts.Cause.BothOps __call
+ */
+
+
+function both_1(left, right) {
+  return tsplus_module_3.isEmpty(left) ? right : tsplus_module_3.isEmpty(right) ? left : new _definition3.Both(left, right);
+}
+/**
+ * Composes computations in sequence, using the return value of one computation as input for the next
+ *
+ * @tsplus fluent fncts.Cause flatMap
+ */
+
+
+function flatMap_1(self, f) {
+  return tsplus_module_4.run(chainEval(self, f));
+}
+/**
+ * Determines whether a `Cause` contains or is equal to the specified cause.
+ *
+ * @tsplus fluent fncts.Cause contains
+ */
+
+
+function contains_(self, that) {
+  return tsplus_module_4.run(containsEval(self, that));
+}
+/**
+ * @internal
+ */
+
+
+function containsEval(self, that) {
+  return tsplus_module_2.gen(function* (_) {
+    if (yield* _(self.equalsEval(that))) {
+      return true;
+    }
+
+    return yield* _(foldLeft_1(self, tsplus_module_1.now(false), (computation, c) => tsplus_module_5.just(tsplus_module_2.flatMap_(computation, b => b ? tsplus_module_1.now(b) : c.equalsEval(that)))));
+  });
+}
+/**
+ * Extracts a list of non-recoverable errors from the `Cause`.
+ *
+ * @tsplus getter fncts.Cause defects
+ */
+
+
+function defects(self) {
+  return tsplus_module_6.reverse(foldLeft_1(self, tsplus_module_7.empty(), (z, c) => isHalt_1(c) ? tsplus_module_5.just(tsplus_module_6.prependOperator(c.value, z)) : tsplus_module_5.nothing()));
+}
+/**
+ * The empty `Cause`
+ *
+ * @tsplus static fncts.CauseOps empty
+ * @tsplus static fncts.Cause.EmptyOps __call
+ */
+
+
+function empty_1() {
+  return _definition3._Empty;
+}
+/**
+ * Constructs a `Cause` from a single value, representing a typed failure
+ *
+ * @tsplus static fncts.CauseOps fail
+ * @tsplus static fncts.Cause.FailOps __call
+ */
+
+
+function fail_1(value, trace = tsplus_module_8.none) {
+  return new _definition3.Fail(value, trace);
+}
+/**
+ * Determines whether a `Cause` contains a failure
+ *
+ * @tsplus getter Cause failed
+ */
+
+
+function failed_1(self) {
+  return tsplus_module_9.match_(failureMaybe_1(self), () => false, () => true);
+}
+/**
+ * Produces a list of all recoverable errors `E` in the `Cause`.
+ *
+ * @tsplus getter fncts.Cause failures
+ */
+
+
+function failures(self) {
+  return tsplus_module_6.reverse(foldLeft_1(self, tsplus_module_7.empty(), (z, c) => isFail_1(c) ? tsplus_module_5.just(tsplus_module_6.prependOperator(c.value, z)) : tsplus_module_5.nothing()));
+}
+/**
+ * Retrieve 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 `Halt` or `Interrupt` causes.
+ *
+ * @tsplus getter fncts.Cause failureOrCause
+ */
+
+
+function failureOrCause(self) {
+  return tsplus_module_9.match_(failureMaybe_1(self), () => tsplus_module_10.right(self), tsplus_module_10.left);
+}
+/**
+ * Returns the `E` associated with the first `Fail` in this `Cause` if one
+ * exists, along with its (optional) trace.
+ *
+ * @tsplus getter fncts.Cause failureTraceMaybe
+ */
+
+
+function failureTraceMaybe_1(self) {
+  return find_1(self, c => isFail_1(c) ? tsplus_module_5.just([c.value, c.trace]) : tsplus_module_5.nothing());
+}
+/**
+ * Retrieve the first checked error and its trace on the `Left` if available,
+ * if there are no checked errors return the rest of the `Cause`
+ * that is known to contain only `Halt` or `Interrupt` causes.
+ *
+ * @tsplus getter fncts.Cause failureTraceOrCause
+ */
+
+
+function failureTraceOrCause(self) {
+  return tsplus_module_9.match_(failureTraceMaybe_1(self), () => tsplus_module_10.right(self), tsplus_module_10.left);
+}
+/**
+ * Returns the `E` associated with the first `Fail` in this `Cause` if one exists.
+ *
+ * @tsplus getter fncts.Cause failureMaybe
+ */
+
+
+function failureMaybe_1(self) {
+  return find_1(self, c => c._tag === "Fail"
+  /* CauseTag.Fail */
+  ? tsplus_module_5.just(c.value) : tsplus_module_5.nothing());
+}
+/**
+ * Remove all `Halt` causes that the specified partial function is defined at,
+ * returning `Just` with the remaining causes or `Nothing` if there are no
+ * remaining causes.
+ *
+ * @tsplus fluent fncts.Cause filterDefects
+ */
+
+
+function filterDefects_(self, p) {
+  return tsplus_module_13.fold_(self, {
+    Empty: () => tsplus_module_5.just(empty_1()),
+    Fail: (e, trace) => tsplus_module_5.just(fail_1(e, trace)),
+    Halt: (u, trace) => p(u) ? tsplus_module_5.nothing() : tsplus_module_5.just(halt_1(u, trace)),
+    Interrupt: (fiberId, trace) => tsplus_module_5.just(interrupt_1(fiberId, trace)),
+    Then: (l, r) => {
+      if (tsplus_module_11.isJust(l) && tsplus_module_11.isJust(r)) {
+        return tsplus_module_5.just(then_1(l.value, r.value));
+      } else if (tsplus_module_11.isJust(l) && tsplus_module_11.isNothing(r)) {
+        return tsplus_module_5.just(l.value);
+      } else if (tsplus_module_11.isNothing(l) && tsplus_module_11.isJust(r)) {
+        return tsplus_module_5.just(r.value);
+      } else {
+        return tsplus_module_5.nothing();
+      }
+    },
+    Both: (l, r) => {
+      if (tsplus_module_11.isJust(l) && tsplus_module_11.isJust(r)) {
+        return tsplus_module_5.just(both_1(l.value, r.value));
+      } else if (tsplus_module_11.isJust(l) && tsplus_module_11.isNothing(r)) {
+        return tsplus_module_5.just(l.value);
+      } else if (tsplus_module_11.isNothing(l) && tsplus_module_11.isJust(r)) {
+        return tsplus_module_5.just(r.value);
+      } else {
+        return tsplus_module_5.nothing();
+      }
+    },
+    Stackless: (causeOption, stackless) => tsplus_module_12.map_(causeOption, cause => stackless_1(cause, stackless))
+  });
+}
+/**
+ * @tsplus tailRec
+ */
+
+
+function findLoop(self, f, stack) {
+  var self_1 = self,
+      f_1 = f,
+      stack_1 = stack;
+  var self_2 = self,
+      f_2 = f,
+      stack_2 = stack;
+
+  while (1) {
+    const r = f_1(self_1);
+
+    switch (r._tag) {
+      case "Nothing"
+      /* MaybeTag.Nothing */
+      :
+        {
+          switch (self_1._tag) {
+            case "Both"
+            /* CauseTag.Both */
+            :
+            case "Then"
+            /* CauseTag.Then */
+            :
+              {
+                self_2 = self_1.left;
+                f_2 = f_1;
+                stack_2 = tsplus_module_6.prepend_(stack_1, self_1.right);
+                self_1 = self_2;
+                f_1 = f_2;
+                stack_1 = stack_2;
+                continue;
+              }
+
+            default:
+              {
+                if (tsplus_module_14.isNonEmpty(stack_1)) {
+                  self_2 = tsplus_module_6.unsafeHead(stack_1);
+                  f_2 = f_1;
+                  stack_2 = tsplus_module_15.unsafeTail(stack_1);
+                  self_1 = self_2;
+                  f_1 = f_2;
+                  stack_1 = stack_2;
+                  continue;
+                }
+
+                return tsplus_module_5.nothing();
+              }
+          }
+        }
+
+      case "Just"
+      /* MaybeTag.Just */
+      :
+        {
+          return r;
+        }
+    }
+  }
+}
+/**
+ * Finds the first result matching `f`
+ *
+ * @tsplus fluent fncts.Cause find
+ */
+
+
+function find_1(self, f) {
+  return findLoop(self, f, tsplus_module_7.nil());
+}
+/**
+ * @tsplus getter fncts.Cause flatten
+ */
+
+
+function flatten(self) {
+  return flatMap_1(self, _function.identity);
+}
+
+class FCEStackFrameDone {
+  constructor() {
+    this._tag = "FCEStackFrameDone";
+  }
+
+}
+
+class FCEStackFrameThenLeft {
+  constructor(cause) {
+    this.cause = cause;
+    this._tag = "FCEStackFrameThenLeft";
+  }
+
+}
+
+class FCEStackFrameThenRight {
+  constructor(cause, leftResult) {
+    this.cause = cause;
+    this.leftResult = leftResult;
+    this._tag = "FCEStackFrameThenRight";
+  }
+
+}
+
+class FCEStackFrameBothLeft {
+  constructor(cause) {
+    this.cause = cause;
+    this._tag = "FCEStackFrameBothLeft";
+  }
+
+}
+
+class FCEStackFrameBothRight {
+  constructor(cause, leftResult) {
+    this.cause = cause;
+    this.leftResult = leftResult;
+    this._tag = "FCEStackFrameBothRight";
+  }
+
+}
+/**
+ * Converts the specified `Cause<Either<E, A>>` to an `Either<Cause<E>, A>` by
+ * recursively stripping out any failures with the error `Nothing`.
+ *
+ * @tsplus getter fncts.Cause flipCauseEither
+ */
+
+
+function flipCauseEither(self) {
+  const stack = tsplus_module_16.mkStack();
+  stack.push(new FCEStackFrameDone());
+  let result;
+  let c = self;
+
+  recursion: while (stack.hasNext) {
+    // eslint-disable-next-line no-constant-condition
+    pushing: while (true) {
+      switch (c._tag) {
+        case "Empty"
+        /* CauseTag.Empty */
+        :
+          result = tsplus_module_10.left(empty_1());
+          break pushing;
+
+        case "Interrupt"
+        /* CauseTag.Interrupt */
+        :
+          result = tsplus_module_10.left(interrupt_1(c.id, c.trace));
+          break pushing;
+
+        case "Halt"
+        /* CauseTag.Halt */
+        :
+          result = tsplus_module_10.left(c);
+          break pushing;
+
+        case "Fail"
+        /* CauseTag.Fail */
+        :
+          result = tsplus_module_17.match_(c.value, l => tsplus_module_10.left(fail_1(l, tsplus_module_8.none)), r => tsplus_module_10.right(r));
+          break pushing;
+
+        case "Then"
+        /* CauseTag.Then */
+        :
+          stack.push(new FCEStackFrameThenLeft(c));
+          c = c.left;
+          continue pushing;
+
+        case "Both"
+        /* CauseTag.Both */
+        :
+          stack.push(new FCEStackFrameBothLeft(c));
+          c = c.left;
+          continue pushing;
+      }
+    } // eslint-disable-next-line no-constant-condition
+
+
+    popping: while (true) {
+      const top = stack.pop();
+
+      switch (top._tag) {
+        case "FCEStackFrameDone":
+          return result;
+
+        case "FCEStackFrameThenLeft":
+          c = top.cause.right;
+          stack.push(new FCEStackFrameThenRight(top.cause, result));
+          continue recursion;
+
+        case "FCEStackFrameThenRight":
+          {
+            const l = top.leftResult;
+
+            if (tsplus_module_18.isLeft(l) && tsplus_module_18.isLeft(result)) {
+              result = tsplus_module_10.left(then_1(l.left, result.left));
+            }
+
+            if (tsplus_module_18.isRight(l)) {
+              result = tsplus_module_10.right(l.right);
+            }
+
+            if (tsplus_module_18.isRight(result)) {
+              result = tsplus_module_10.right(result.right);
+            }
+
+            continue popping;
+          }
+
+        case "FCEStackFrameBothLeft":
+          c = top.cause.right;
+          stack.push(new FCEStackFrameBothRight(top.cause, result));
+          continue recursion;
+
+        case "FCEStackFrameBothRight":
+          {
+            const l = top.leftResult;
+
+            if (tsplus_module_18.isLeft(l) && tsplus_module_18.isLeft(result)) {
+              result = tsplus_module_10.left(both_1(l.left, result.left));
+            }
+
+            if (tsplus_module_18.isRight(l)) {
+              result = tsplus_module_10.right(l.right);
+            }
+
+            if (tsplus_module_18.isRight(result)) {
+              result = tsplus_module_10.right(result.right);
+            }
+
+            continue popping;
+          }
+      }
+    }
+  }
+
+  throw new Error("Bug");
+}
+
+class FCOStackFrameDone {
+  constructor() {
+    this._tag = "FCOStackFrameDone";
+  }
+
+}
+
+class FCOStackFrameThenLeft {
+  constructor(cause) {
+    this.cause = cause;
+    this._tag = "FCOStackFrameThenLeft";
+  }
+
+}
+
+class FCOStackFrameThenRight {
+  constructor(cause, leftResult) {
+    this.cause = cause;
+    this.leftResult = leftResult;
+    this._tag = "FCOStackFrameThenRight";
+  }
+
+}
+
+class FCOStackFrameBothLeft {
+  constructor(cause) {
+    this.cause = cause;
+    this._tag = "FCOStackFrameBothLeft";
+  }
+
+}
+
+class FCOStackFrameBothRight {
+  constructor(cause, leftResult) {
+    this.cause = cause;
+    this.leftResult = leftResult;
+    this._tag = "FCOStackFrameBothRight";
+  }
+
+}
+/**
+ * Converts the specified `Cause<Maybe<A>>` to an `Maybe<Cause<A>>` by
+ * recursively stripping out any failures with the error `Nothing`.
+ *
+ * @tsplus getter fncts.Cause flipCauseMaybe
+ */
+
+
+function flipCauseOption(self) {
+  const stack = tsplus_module_16.mkStack();
+  stack.push(new FCOStackFrameDone());
+  let result;
+  let c = self;
+
+  recursion: while (stack.hasNext) {
+    // eslint-disable-next-line no-constant-condition
+    pushing: while (true) {
+      switch (c._tag) {
+        case "Empty"
+        /* CauseTag.Empty */
+        :
+          result = tsplus_module_5.just(empty_1());
+          break pushing;
+
+        case "Interrupt"
+        /* CauseTag.Interrupt */
+        :
+          result = tsplus_module_5.just(interrupt_1(c.id, tsplus_module_8.none));
+          break pushing;
+
+        case "Halt"
+        /* CauseTag.Halt */
+        :
+          result = tsplus_module_5.just(c);
+          break pushing;
+
+        case "Fail"
+        /* CauseTag.Fail */
+        :
+          result = tsplus_module_9.match_(c.value, () => tsplus_module_5.nothing(), r => tsplus_module_5.just(fail_1(r, tsplus_module_8.none)));
+          break pushing;
+
+        case "Then"
+        /* CauseTag.Then */
+        :
+          stack.push(new FCOStackFrameThenLeft(c));
+          c = c.left;
+          continue pushing;
+
+        case "Both"
+        /* CauseTag.Both */
+        :
+          stack.push(new FCOStackFrameBothLeft(c));
+          c = c.left;
+          continue pushing;
+      }
+    } // eslint-disable-next-line no-constant-condition
+
+
+    popping: while (true) {
+      const top = stack.pop();
+
+      switch (top._tag) {
+        case "FCOStackFrameDone":
+          return result;
+
+        case "FCOStackFrameThenLeft":
+          c = top.cause.right;
+          stack.push(new FCOStackFrameThenRight(top.cause, result));
+          continue recursion;
+
+        case "FCOStackFrameThenRight":
+          {
+            const l = top.leftResult;
+
+            if (tsplus_module_11.isJust(l) && tsplus_module_11.isJust(result)) {
+              result = tsplus_module_5.just(then_1(l.value, result.value));
+            }
+
+            if (tsplus_module_11.isNothing(l) && tsplus_module_11.isJust(result)) {
+              result = tsplus_module_5.just(result.value);
+            }
+
+            if (tsplus_module_11.isJust(l) && tsplus_module_11.isNothing(result)) {
+              result = tsplus_module_5.just(l.value);
+            }
+
+            result = tsplus_module_5.nothing();
+            continue popping;
+          }
+
+        case "FCOStackFrameBothLeft":
+          c = top.cause.right;
+          stack.push(new FCOStackFrameBothRight(top.cause, result));
+          continue recursion;
+
+        case "FCOStackFrameBothRight":
+          {
+            const l = top.leftResult;
+
+            if (tsplus_module_11.isJust(l) && tsplus_module_11.isJust(result)) {
+              result = tsplus_module_5.just(both_1(l.value, result.value));
+            }
+
+            if (tsplus_module_11.isNothing(l) && tsplus_module_11.isJust(result)) {
+              result = tsplus_module_5.just(result.value);
+            }
+
+            if (tsplus_module_11.isJust(l) && tsplus_module_11.isNothing(result)) {
+              result = tsplus_module_5.just(l.value);
+            }
+
+            result = tsplus_module_5.nothing();
+            continue popping;
+          }
+      }
+    }
+  }
+
+  throw new Error("Bug");
+}
+/**
+ * Accumulates a state over a `Cause`
+ *
+ * @tsplus fluent fncts.Cause foldLeft
+ */
+
+
+function foldLeft_1(self, b, f) {
+  return foldLeftLoop(self, b, f, tsplus_module_7.nil());
+}
+/**
+ * @internal
+ * @tsplus tailRec
+ */
+
+
+function foldLeftLoop(self, b, f, stack) {
+  var self_3 = self,
+      b_1 = b,
+      f_3 = f,
+      stack_3 = stack;
+  var self_4 = self,
+      b_2 = b,
+      f_4 = f,
+      stack_4 = stack;
+
+  while (1) {
+    const z = tsplus_module_12.getOrElse_(f_3(b_1, self_3), () => b_1);
+
+    switch (self_3._tag) {
+      case "Both"
+      /* CauseTag.Both */
+      :
+      case "Then"
+      /* CauseTag.Then */
+      :
+        {
+          self_4 = self_3.left;
+          b_2 = z;
+          f_4 = f_3;
+          stack_4 = tsplus_module_6.prepend_(stack_3, self_3.right);
+          self_3 = self_4;
+          b_1 = b_2;
+          f_3 = f_4;
+          stack_3 = stack_4;
+          continue;
+        }
+
+      default:
+        {
+          if (tsplus_module_14.isNonEmpty(stack_3)) {
+            self_4 = tsplus_module_6.unsafeHead(stack_3);
+            b_2 = z;
+            f_4 = f_3;
+            stack_4 = tsplus_module_15.unsafeTail(stack_3);
+            self_3 = self_4;
+            b_1 = b_2;
+            f_3 = f_4;
+            stack_3 = stack_4;
+            continue;
+          }
+
+          return z;
+        }
+    }
+  }
+}
+/**
+ * Constructs a `Cause` from a single `unknown`, representing an untyped failure
+ *
+ * @tsplus static fncts.CauseOps halt
+ * @tsplus static fncts.Cause.HaltOps __call
+ */
+
+
+function halt_1(value, trace = tsplus_module_8.none) {
+  return new _definition3.Halt(value, trace);
+}
+/**
+ * Determines whether a `Cause` contains a defect
+ *
+ * @tsplus getter fncts.Cause halted
+ */
+
+
+function halted_1(self) {
+  return tsplus_module_9.match_(haltMaybe_1(self), () => false, () => true);
+}
+/**
+ * Returns the `unknown` associated with the first `Halt` in this `Cause` if one exists.
+ *
+ * @tsplus getter fncts.Cause haltMaybe
+ */
+
+
+function haltMaybe_1(self) {
+  return find_1(self, c => c._tag === "Halt"
+  /* CauseTag.Halt */
+  ? tsplus_module_5.just(c.value) : tsplus_module_5.nothing());
+}
+/**
+ * Constructs a `Cause` from an `Id`, representing an interruption of asynchronous computation
+ *
+ * @tsplus static fncts.CauseOps interrupt
+ * @tsplus static fncts.Cause.InterruptOps __call
+ */
+
+
+function interrupt_1(id, trace = tsplus_module_8.none) {
+  return new _definition3.Interrupt(id, trace);
+}
+/**
+ * A type-guard matching `Both`
+ *
+ * @tsplus fluent fncts.Cause isBoth
+ */
+
+
+function isBoth(self) {
+  return self._tag === "Both"
+  /* CauseTag.Both */
+  ;
+}
+/**
+ * A type-guard matching `Fail`
+ *
+ * @tsplus fluent fncts.Cause isFail
+ */
+
+
+function isFail_1(self) {
+  return self._tag === "Fail"
+  /* CauseTag.Fail */
+  ;
+}
+/**
+ * @tsplus fluent fncts.Cause isHalt
+ */
+
+
+function isHalt_1(self) {
+  return self._tag === "Halt"
+  /* CauseTag.Halt */
+  ;
+}
+/**
+ * A type-guard matching `Then`
+ *
+ * @tsplus fluent fncts.Cause isThen
+ */
+
+
+function isThen(self) {
+  return self._tag === "Then"
+  /* CauseTag.Then */
+  ;
+}
+/**
+ * A type-guard matching `Traced`
+ *
+ * @tsplus getter fncts.Cause isTraced
+ */
+
+
+function isTraced(self) {
+  return tsplus_module_11.isJust(find_1(self, cause => {
+    switch (cause._tag) {
+      case "Halt":
+      case "Fail":
+      case "Interrupt":
+        return cause.trace !== tsplus_module_8.none ? tsplus_module_5.just(undefined) : tsplus_module_5.nothing();
+
+      default:
+        return tsplus_module_5.nothing();
+    }
+  }));
+}
+/**
+ * Determines whether the `Cause` contains an interruption
+ *
+ * @tsplus getter fncts.Cause interrupted
+ */
+
+
+function interrupted(self) {
+  return tsplus_module_9.match_(interruptOption_1(self), () => false, () => true);
+}
+/**
+ * Returns the `FiberId` associated with the first `Interrupt` in this `Cause` if one exists.
+ *
+ * @tsplus getter fncts.Cause interruptOption
+ */
+
+
+function interruptOption_1(self) {
+  return find_1(self, c => c._tag === "Interrupt"
+  /* CauseTag.Interrupt */
+  ? tsplus_module_5.just(c.id) : tsplus_module_5.nothing());
+}
+/**
+ * Returns a set of interruptors, fibers that interrupted the fiber described
+ * by this `Cause`.
+ *
+ * @tsplus getter fncts.Cause interruptors
+ */
+
+
+function interruptors(self) {
+  return foldLeft_1(self, new Set(), (s, c) => c._tag === "Interrupt"
+  /* CauseTag.Interrupt */
+  ? tsplus_module_5.just(s.add(c.id)) : tsplus_module_5.nothing());
+}
+/**
+ * Determines if the `Cause` contains only interruptions and not any `Halt` or
+ * `Fail` causes.
+ *
+ * @tsplus getter fncts.Cause interruptedOnly
+ */
+
+
+function interruptedOnly(self) {
+  return tsplus_module_12.getOrElse_(find_1(self, c => halted_1(c) || failed_1(c) ? tsplus_module_5.just(false) : tsplus_module_5.nothing()), () => true);
+}
+/**
+ * Remove all `Fail` and `Interrupt` nodes from this `Cause`,
+ * return only `Halt` cause/finalizer defects.
+ *
+ * @tsplus getter fncts.Cause keepDefects
+ */
+
+
+function keepDefects(self) {
+  return tsplus_module_13.fold_(self, {
+    Empty: () => tsplus_module_5.nothing(),
+    Fail: () => tsplus_module_5.nothing(),
+    Halt: (t, trace) => tsplus_module_5.just(halt_1(t, trace)),
+    Interrupt: () => tsplus_module_5.nothing(),
+    Then: (l, r) => {
+      if (tsplus_module_11.isJust(l) && tsplus_module_11.isJust(r)) {
+        return tsplus_module_5.just(then_1(l.value, r.value));
+      } else if (tsplus_module_11.isJust(l) && tsplus_module_11.isNothing(r)) {
+        return tsplus_module_5.just(l.value);
+      } else if (tsplus_module_11.isNothing(l) && tsplus_module_11.isJust(r)) {
+        return tsplus_module_5.just(r.value);
+      } else {
+        return tsplus_module_5.nothing();
+      }
+    },
+    Both: (l, r) => {
+      if (tsplus_module_11.isJust(l) && tsplus_module_11.isJust(r)) {
+        return tsplus_module_5.just(both_1(l.value, r.value));
+      } else if (tsplus_module_11.isJust(l) && tsplus_module_11.isNothing(r)) {
+        return tsplus_module_5.just(l.value);
+      } else if (tsplus_module_11.isNothing(l) && tsplus_module_11.isJust(r)) {
+        return tsplus_module_5.just(r.value);
+      } else {
+        return tsplus_module_5.nothing();
+      }
+    },
+    Stackless: (maybeCause, stackless) => tsplus_module_12.map_(maybeCause, cause => stackless_1(cause, stackless))
+  });
+}
+/**
+ * @tsplus fluent fncts.Cause map
+ */
+
+
+function map_1(self, f) {
+  return flatMap_1(self, e => fail_1(f(e), tsplus_module_8.none));
+}
+/**
+ * @tsplus fluent fncts.Cause mapTrace
+ */
+
+
+function mapTrace_1(self, f) {
+  return tsplus_module_13.fold_(self, {
+    Empty: () => empty_1(),
+    Fail: (e, trace) => fail_1(e, f(trace)),
+    Halt: (u, trace) => halt_1(u, f(trace)),
+    Interrupt: (id, trace) => interrupt_1(id, f(trace)),
+    Then: then_1,
+    Both: both_1,
+    Stackless: stackless_1
+  });
+}
+/**
+ * @tsplus static fncts.CauseOps stackless
+ * @tsplus static fncts.Cause.StacklessOps __call
+ */
+
+
+function stackless_1(cause, stackless) {
+  return new _definition3.Stackless(cause, stackless);
+}
+/**
+ * Discards all typed failures kept on this `Cause`.
+ *
+ * @tsplus getter fncts.Cause stripFailures
+ */
+
+
+function stripFailures(self) {
+  return tsplus_module_13.fold_(self, {
+    Empty: () => empty_1(),
+    Fail: () => empty_1(),
+    Halt: (u, trace) => halt_1(u, trace),
+    Interrupt: (fiberId, trace) => interrupt_1(fiberId, trace),
+    Then: (l, r) => then_1(l, r),
+    Both: (l, r) => both_1(l, r),
+    Stackless: (c, stackless) => stackless_1(c, stackless)
+  });
+}
+
+function sequenceCauseEitherEval(self) {
+  switch (self._tag) {
+    case "Empty"
+    /* CauseTag.Empty */
+    :
+      {
+        return tsplus_module_1.now(tsplus_module_10.left(empty_1()));
+      }
+
+    case "Interrupt"
+    /* CauseTag.Interrupt */
+    :
+      {
+        return tsplus_module_1.now(tsplus_module_10.left(self));
+      }
+
+    case "Fail"
+    /* CauseTag.Fail */
+    :
+      {
+        return tsplus_module_1.now(tsplus_module_17.match_(self.value, e => tsplus_module_10.left(fail_1(e, tsplus_module_8.none)), a => tsplus_module_10.right(a)));
+      }
+
+    case "Halt"
+    /* CauseTag.Halt */
+    :
+      {
+        return tsplus_module_1.now(tsplus_module_10.left(self));
+      }
+
+    case "Then"
+    /* CauseTag.Then */
+    :
+      {
+        return tsplus_module_2.zipWith_(tsplus_module_1.defer(() => sequenceCauseEitherEval(self.left)), tsplus_module_1.defer(() => sequenceCauseEitherEval(self.right)), (lefts, rights) => {
+          return lefts._tag === "Left" ? rights._tag === "Right" ? tsplus_module_10.right(rights.right) : tsplus_module_10.left(then_1(lefts.left, rights.left)) : tsplus_module_10.right(lefts.right);
+        });
+      }
+
+    case "Both"
+    /* CauseTag.Both */
+    :
+      {
+        return tsplus_module_2.zipWith_(tsplus_module_1.defer(() => sequenceCauseEitherEval(self.left)), tsplus_module_1.defer(() => sequenceCauseEitherEval(self.right)), (lefts, rights) => {
+          return lefts._tag === "Left" ? rights._tag === "Right" ? tsplus_module_10.right(rights.right) : tsplus_module_10.left(both_1(lefts.left, rights.left)) : tsplus_module_10.right(lefts.right);
+        });
+      }
+
+    case "Stackless"
+    /* CauseTag.Stackless */
+    :
+      {
+        return tsplus_module_2.map_(tsplus_module_1.defer(() => sequenceCauseEitherEval(self.cause)), _ => tsplus_module_18.mapLeft_(_, cause => stackless_1(cause, self.stackless)));
+      }
+  }
+}
+/**
+ * Converts the specified `Cause<Either<E, A>>` to an `Either<Cause<E>, A>`.
+ *
+ * @tsplus getter fncts.Cause sequenceCauseEither
+ */
+
+
+function sequenceCauseEither(self) {
+  return tsplus_module_4.run(sequenceCauseEitherEval(self));
+}
+
+function sequenceCauseMaybeEval(self) {
+  switch (self._tag) {
+    case "Empty"
+    /* CauseTag.Empty */
+    :
+      {
+        return tsplus_module_1.now(tsplus_module_5.just(empty_1()));
+      }
+
+    case "Interrupt"
+    /* CauseTag.Interrupt */
+    :
+      {
+        return tsplus_module_1.now(tsplus_module_5.just(self));
+      }
+
+    case "Fail"
+    /* CauseTag.Fail */
+    :
+      {
+        return tsplus_module_1.now(tsplus_module_12.map_(self.value, e => fail_1(e, tsplus_module_8.none)));
+      }
+
+    case "Halt"
+    /* CauseTag.Halt */
+    :
+      {
+        return tsplus_module_1.now(tsplus_module_5.just(self));
+      }
+
+    case "Then"
+    /* CauseTag.Then */
+    :
+      {
+        return tsplus_module_2.zipWith_(tsplus_module_1.defer(() => sequenceCauseMaybeEval(self.left)), tsplus_module_1.defer(() => sequenceCauseMaybeEval(self.right)), (lefts, rights) => {
+          return lefts._tag === "Just" ? rights._tag === "Just" ? tsplus_module_5.just(then_1(lefts.value, rights.value)) : lefts : rights._tag === "Just" ? rights : tsplus_module_5.nothing();
+        });
+      }
+
+    case "Both"
+    /* CauseTag.Both */
+    :
+      {
+        return tsplus_module_2.zipWith_(tsplus_module_1.defer(() => sequenceCauseMaybeEval(self.left)), tsplus_module_1.defer(() => sequenceCauseMaybeEval(self.right)), (lefts, rights) => {
+          return lefts._tag === "Just" ? rights._tag === "Just" ? tsplus_module_5.just(both_1(lefts.value, rights.value)) : lefts : rights._tag === "Just" ? rights : tsplus_module_5.nothing();
+        });
+      }
+
+    case "Stackless"
+    /* CauseTag.Stackless */
+    :
+      {
+        return tsplus_module_2.map_(tsplus_module_1.defer(() => sequenceCauseMaybeEval(self.cause)), _ => tsplus_module_12.map_(_, cause => stackless_1(cause, self.stackless)));
+      }
+  }
+}
+/**
+ * Converts the specified `Cause<Maybe<E>>` to an `Option<Cause<E>>`.
+ *
+ * @tsplus getter fncts.Cause sequenceCauseMaybe
+ */
+
+
+function sequenceCauseMaybe(self) {
+  return tsplus_module_4.run(sequenceCauseMaybeEval(self));
+} // /**
+//  * Squashes a `Cause` down to a single `Error`, chosen to be the
+//  * "most important" `Error`.
+//  */
+// export function squash_<Id>(
+//   S: P.Show<Id>
+// ): <E>(cause: Cause<E>, f: (e: E) => unknown) => unknown {
+//   return (cause, f) =>
+//     cause.failureOption
+//       .map(f)
+//       .orElse(
+//         interrupted(cause)
+//           ? Maybe.just<unknown>(
+//               new InterruptedException(
+//                 "Interrupted by fibers: " +
+//                   Array.from(interruptors(cause))
+//                     .map((id) => S.show(id))
+//                     .join(", ")
+//               )
+//             )
+//           : Maybe.nothing()
+//       )
+//       .orElse(defects(cause).head)
+//       .getOrElse(new InterruptedException("Interrupted"));
+// }
+// /**
+//  * @tsplus getter PCause squash
+//  */
+// export function squash0<Id, E>(self: Cause<E>) {
+//   return (S: P.Show<Id>) =>
+//     (f: (e: E) => unknown): unknown =>
+//       squash_(S)(self, f);
+// }
+// /**
+//  * Squashes a `Cause` down to a single `Error`, chosen to be the
+//  * "most important" `Error`.
+//  *
+//  * @dataFirst squash_
+//  */
+// export function squash<Id>(
+//   S: P.Show<Id>
+// ): <E>(f: (e: E) => unknown) => (cause: Cause<E>) => unknown {
+//   return (f) => (cause) => squash_(S)(cause, f);
+// }
+
+/**
+ * Constructs a `Cause` from two `Cause`s, representing sequential failures.
+ *
+ * @note If one of the `Cause`s is `Empty`, the non-empty `Cause` is returned
+ *
+ * @tsplus static fncts.CauseOps then
+ * @tsplus static fncts.Cause.ThenOps __call
+ */
+
+
+function then_1(left, right) {
+  return tsplus_module_3.isEmpty(left) ? right : tsplus_module_3.isEmpty(right) ? left : new _definition3.Then(left, right);
+}
+/**
+ * Constructs a `Cause` from a `Cause` and a stack trace.
+ *
+ * @note If the stack trace is empty, the original `Cause` is returned.
+ *
+ * @tsplus static fncts.CauseOps traced
+ * @tsplus static fncts.Cause.TracedOps __call
+ */
+
+
+function traced_1(cause, trace) {
+  return mapTrace_1(cause, t => tsplus_module_19.combine_(t, trace));
+}
+/**
+ * Returns a `Cause` that has been stripped of all tracing information.
+ *
+ * @tsplus getter fncts.Cause untraced
+ */
+
+
+function untraced(self) {
+  return mapTrace_1(self, () => tsplus_module_8.none);
+} // codegen:start { preset: barrel, include: api/*.ts }
+//# sourceMappingURL=api.cjs.map