@fncts/io 0.0.1

package/_cjs/IO/api.cjs

@@ -0,0 +1,2142 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.__adapter = exports.GenIO = void 0;
+exports.absolve = absolve;
+exports.apFirst_ = apFirst_;
+exports.apSecond_ = void 0;
+exports.asJust = asJust;
+exports.asJustError = asJustError;
+exports.asyncMaybe = exports.asyncInterrupt = exports.async = exports.as_ = exports.asUnit = void 0;
+exports.bimap_ = bimap_;
+exports.bitap_ = bitap_;
+exports.catchAll_ = exports.catchAllCause_ = void 0;
+exports.catchJustCause_ = catchJustCause_;
+exports.catchJustDefect_ = catchJustDefect_;
+exports.catchJust_ = catchJust_;
+exports.catchTag_ = catchTag_;
+exports.catch_ = void 0;
+exports.cause = cause;
+exports.causeAsError = causeAsError;
+exports.checkInterruptible = checkInterruptible;
+exports.collectIO_ = void 0;
+exports.collect_ = collect_;
+exports.condIO_ = condIO_;
+exports.defer = void 0;
+exports.deferTry = deferTry;
+exports.deferTryCatch = deferTryCatch;
+exports.deferTryCatchWith = deferTryCatchWith;
+exports.deferTryWith = deferTryWith;
+exports.either = exports.descriptorWith = exports.descriptor = exports.deferWith = void 0;
+exports.ensuring_ = ensuring_;
+exports.errorAsCause = errorAsCause;
+exports.eventually = void 0;
+exports.extend_ = extend_;
+exports.filterMapWithIndex_ = exports.fiberId = exports.failNow = exports.failCauseNow = exports.failCause = exports.fail = void 0;
+exports.filterMap_ = filterMap_;
+exports.filterNot_ = filterNot_;
+exports.filterOrElse_ = void 0;
+exports.filterOrFail_ = filterOrFail_;
+exports.filterOrHalt_ = filterOrHalt_;
+exports.filter_ = void 0;
+exports.firstSuccess = firstSuccess;
+exports.flatMapError_ = flatMapError_;
+exports.flatMap_ = void 0;
+exports.flatten = flatten;
+exports.foldLeft_ = void 0;
+exports.foldMap_ = foldMap_;
+exports.foldRight_ = foldRight_;
+exports.foreachWithIndexDiscard_ = exports.foreachDiscard_ = void 0;
+exports.foreachWithIndex_ = foreachWithIndex_;
+exports.forever = exports.foreach_ = void 0;
+exports.fork = fork;
+exports.fromEither = fromEither;
+exports.fromEitherNow = fromEitherNow;
+exports.fromEval = fromEval;
+exports.fromExit = fromExit;
+exports.fromExitNow = fromExitNow;
+exports.fromMaybe = fromMaybe;
+exports.fromMaybeNow = fromMaybeNow;
+exports.fromPromise = fromPromise;
+exports.fromPromiseCatch = void 0;
+exports.fromPromiseHalt = fromPromiseHalt;
+exports.gen = void 0;
+exports.get = get;
+exports.getOrElseIO_ = getOrElseIO_;
+exports.getOrElse_ = getOrElse_;
+exports.getOrFailUnit = getOrFailUnit;
+exports.getOrFailWith_ = void 0;
+exports.halt = halt;
+exports.ifIO_ = exports.haltNow = void 0;
+exports.if_ = if_;
+exports.ignore = ignore;
+exports.isFailure = isFailure;
+exports.isSuccess = isSuccess;
+exports.iterate_ = void 0;
+exports.left = left;
+exports.log = log;
+exports.loopUnit_ = loopUnit_;
+exports.mapError_ = exports.mapErrorCause_ = exports.loop_ = void 0;
+exports.mapTryCatch_ = mapTryCatch_;
+exports.matchCauseIO_ = exports.map_ = void 0;
+exports.matchCause_ = matchCause_;
+exports.matchIO_ = void 0;
+exports.matchTraceIO_ = matchTraceIO_;
+exports.match_ = void 0;
+exports.maybe = maybe;
+exports.merge = merge;
+exports.mergeAll_ = mergeAll_;
+exports.never = void 0;
+exports.optional = optional;
+exports.orElseEither_ = orElseEither_;
+exports.orElseFail_ = orElseFail_;
+exports.orElseMaybe_ = orElseMaybe_;
+exports.orElseSucceed_ = orElseSucceed_;
+exports.orElse_ = void 0;
+exports.orHalt = orHalt;
+exports.orHaltKeep = orHaltKeep;
+exports.orHaltWith_ = void 0;
+exports.or_ = or_;
+exports.parallelErrors = parallelErrors;
+exports.partition_ = partition_;
+exports.refineOrHaltWith_ = void 0;
+exports.refineOrHalt_ = refineOrHalt_;
+exports.rejectIO_ = void 0;
+exports.reject_ = reject_;
+exports.repeatUntilIO_ = exports.repeatN_ = void 0;
+exports.repeatUntil_ = repeatUntil_;
+exports.repeatWhileIO_ = void 0;
+exports.repeatWhile_ = repeatWhile_;
+exports.replicate_ = replicate_;
+exports.require_ = require_;
+exports.result = result;
+exports.resurrect = resurrect;
+exports.retryUntilIO_ = void 0;
+exports.retryUntil_ = retryUntil_;
+exports.retryWhileIO_ = void 0;
+exports.retryWhile_ = retryWhile_;
+exports.sandbox = exports.runtimeConfig = void 0;
+exports.sandboxWith_ = sandboxWith_;
+exports.sequenceIterable = sequenceIterable;
+exports.sequenceIterableDiscard = sequenceIterableDiscard;
+exports.setRuntimeConfig = setRuntimeConfig;
+exports.summarized_ = exports.succeedNow = exports.succeed = void 0;
+exports.supervised_ = supervised_;
+exports.swapWith_ = exports.swap = void 0;
+exports.tapCause_ = tapCause_;
+exports.tapErrorCause_ = tapErrorCause_;
+exports.tapError_ = tapError_;
+exports.tap_ = tap_;
+exports.timedWith_ = timedWith_;
+exports.unit = exports.tryOrElse_ = exports.tryCatch = void 0;
+exports.unjust = unjust;
+exports.unsandbox = exports.unrefineWith_ = void 0;
+exports.updateFiberRefs = updateFiberRefs;
+exports.whenIO_ = exports.via = void 0;
+exports.when_ = when_;
+exports.zipWith_ = exports.yieldNow = void 0;
+exports.zip_ = zip_;
+
+var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/FiberId/constructors"));
+
+var tsplus_module_2 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/constructors"));
+
+var tsplus_module_3 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Either/constructors"));
+
+var tsplus_module_4 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/destructors"));
+
+var tsplus_module_5 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Cause/api"));
+
+var tsplus_module_6 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Either/destructors"));
+
+var tsplus_module_7 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/api"));
+
+var tsplus_module_8 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Exit/constructors"));
+
+var tsplus_module_9 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/Conc/api"));
+
+var tsplus_module_10 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/Iterable/api"));
+
+var tsplus_module_11 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/Conc/constructors"));
+
+var tsplus_module_12 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/definition"));
+
+var tsplus_module_13 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/control/Eval/run"));
+
+var tsplus_module_14 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Exit/api"));
+
+var tsplus_module_15 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Trace/constructors"));
+
+var tsplus_module_16 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/Conc/api/empty"));
+
+var tsplus_module_17 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/List/api"));
+
+var tsplus_module_18 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/ImmutableArray/constructors"));
+
+var tsplus_module_19 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/ImmutableArray/api"));
+
+var _function = /*#__PURE__*/require("@fncts/base/data/function");
+
+var _definition2 = /*#__PURE__*/require("@fncts/io/IO/definition");
+
+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 fileName_1 = "(@fncts/io) src/IO/api.ts";
+const async = async_1;
+exports.async = async;
+const asyncMaybe = asyncMaybe_1;
+exports.asyncMaybe = asyncMaybe;
+const asyncInterrupt = asyncInterrupt_1;
+exports.asyncInterrupt = asyncInterrupt;
+const apSecond_ = apSecond_1;
+exports.apSecond_ = apSecond_;
+const as_ = as_1;
+exports.as_ = as_;
+const asUnit = asUnit_1;
+exports.asUnit = asUnit;
+const catch_ = catch_1;
+exports.catch_ = catch_;
+const catchAll_ = catchAll_1;
+exports.catchAll_ = catchAll_;
+const catchAllCause_ = catchAllCause_1;
+exports.catchAllCause_ = catchAllCause_;
+const flatMap_ = flatMap_1;
+exports.flatMap_ = flatMap_;
+const collectIO_ = collectIO_1;
+exports.collectIO_ = collectIO_;
+const defer = defer_1;
+exports.defer = defer;
+const deferWith = deferWith_1;
+exports.deferWith = deferWith;
+const descriptorWith = descriptorWith_1;
+exports.descriptorWith = descriptorWith;
+const either = either_1;
+exports.either = either;
+const eventually = eventually_1;
+exports.eventually = eventually;
+const fail = fail_1;
+exports.fail = fail;
+const failNow = failNow_1;
+exports.failNow = failNow;
+const failCauseNow = failCauseNow_1;
+exports.failCauseNow = failCauseNow;
+const failCause = failCause_1;
+exports.failCause = failCause;
+const filter_ = filter_1;
+exports.filter_ = filter_;
+const filterMapWithIndex_ = filterMapWithIndex_1;
+exports.filterMapWithIndex_ = filterMapWithIndex_;
+const filterOrElse_ = filterOrElse_1;
+exports.filterOrElse_ = filterOrElse_;
+const foldLeft_ = foldLeft_1;
+exports.foldLeft_ = foldLeft_;
+const foreach_ = foreach_1;
+exports.foreach_ = foreach_;
+const foreachWithIndexDiscard_ = foreachWithIndexDiscard_1;
+exports.foreachWithIndexDiscard_ = foreachWithIndexDiscard_;
+const foreachDiscard_ = foreachDiscard_1;
+exports.foreachDiscard_ = foreachDiscard_;
+const forever = forever_1;
+exports.forever = forever;
+const fromPromiseCatch = fromPromiseCatch_1;
+exports.fromPromiseCatch = fromPromiseCatch;
+const getOrFailWith_ = getOrFailWith_1;
+exports.getOrFailWith_ = getOrFailWith_;
+const haltNow = haltNow_1;
+exports.haltNow = haltNow;
+const ifIO_ = ifIO_1;
+exports.ifIO_ = ifIO_;
+const iterate_ = iterate_1;
+exports.iterate_ = iterate_;
+const loop_ = loop_1;
+exports.loop_ = loop_;
+const map_ = map_1;
+exports.map_ = map_;
+const mapError_ = mapError_1;
+exports.mapError_ = mapError_;
+const mapErrorCause_ = mapErrorCause_1;
+exports.mapErrorCause_ = mapErrorCause_;
+const matchCauseIO_ = matchCauseIO_1;
+exports.matchCauseIO_ = matchCauseIO_;
+const matchIO_ = matchIO_1;
+exports.matchIO_ = matchIO_;
+const match_ = match_1;
+exports.match_ = match_;
+const orElse_ = orElse_1;
+exports.orElse_ = orElse_;
+const orHaltWith_ = orHaltWith_1;
+exports.orHaltWith_ = orHaltWith_;
+const refineOrHaltWith_ = refineOrHaltWith_1;
+exports.refineOrHaltWith_ = refineOrHaltWith_;
+const rejectIO_ = rejectIO_1;
+exports.rejectIO_ = rejectIO_;
+const repeatN_ = repeatN_1;
+exports.repeatN_ = repeatN_;
+const repeatUntilIO_ = repeatUntilIO_1;
+exports.repeatUntilIO_ = repeatUntilIO_;
+const repeatWhileIO_ = repeatWhileIO_1;
+exports.repeatWhileIO_ = repeatWhileIO_;
+const retryUntilIO_ = retryUntilIO_1;
+exports.retryUntilIO_ = retryUntilIO_;
+const retryWhileIO_ = retryWhileIO_1;
+exports.retryWhileIO_ = retryWhileIO_;
+const sandbox = sandbox_1;
+exports.sandbox = sandbox;
+const succeedNow = succeedNow_1;
+exports.succeedNow = succeedNow;
+const succeed = succeed_1;
+exports.succeed = succeed;
+const summarized_ = summarized_1;
+exports.summarized_ = summarized_;
+const swap = swap_1;
+exports.swap = swap;
+const swapWith_ = swapWith_1;
+exports.swapWith_ = swapWith_;
+const tryCatch = tryCatch_1;
+exports.tryCatch = tryCatch;
+const tryOrElse_ = tryOrElse_1;
+exports.tryOrElse_ = tryOrElse_;
+const unrefineWith_ = unrefineWith_1;
+exports.unrefineWith_ = unrefineWith_;
+const unsandbox = unsandbox_1;
+exports.unsandbox = unsandbox;
+const whenIO_ = whenIO_1;
+exports.whenIO_ = whenIO_;
+const zipWith_ = zipWith_1;
+exports.zipWith_ = zipWith_;
+const gen = gen_1;
+exports.gen = gen;
+
+/**
+ * Imports an asynchronous side-effect into a `IO`
+ *
+ * @tsplus static fncts.io.IOOps async
+ */
+function async_1(register, blockingOn = tsplus_module_1.none, __tsplusTrace) {
+  return asyncMaybe_1(cb => {
+    register(cb);
+    return tsplus_module_2.nothing();
+  }, blockingOn, __tsplusTrace);
+}
+/**
+ * Imports an asynchronous effect into a pure `IO`, possibly returning the value synchronously.
+ *
+ * If the register function returns a value synchronously, then the callback
+ * function must not be called. Otherwise the callback function must be called at most once.
+ *
+ * @tsplus static fncts.io.IOOps asyncMaybe
+ */
+
+
+function asyncMaybe_1(register, blockingOn = tsplus_module_1.none, __tsplusTrace) {
+  return asyncInterrupt_1(cb => tsplus_module_4.match_(register(cb), () => tsplus_module_3.left(unit_1), tsplus_module_3.right), blockingOn, __tsplusTrace);
+}
+/**
+ * Imports an asynchronous side-effect into an IO. The side-effect
+ * has the option of returning the value synchronously, which is useful in
+ * cases where it cannot be determined if the effect is synchronous or
+ * asynchronous until the side-effect is actually executed. The effect also
+ * has the option of returning a canceler, which will be used by the runtime
+ * to cancel the asynchronous effect if the fiber executing the effect is
+ * interrupted.
+ *
+ * If the register function returns a value synchronously, then the callback
+ * function must not be called. Otherwise the callback function must be called
+ * at most once.
+ *
+ * The list of fibers, that may complete the async callback, is used to
+ * provide better diagnostics.
+ *
+ * @tsplus static fncts.io.IOOps asyncInterrupt
+ */
+
+
+function asyncInterrupt_1(register, blockingOn = tsplus_module_1.none, __tsplusTrace) {
+  return new _definition2.Async(register, blockingOn, __tsplusTrace);
+} // /**
+//  * Attempts to convert defects into a failure, throwing away all information
+//  * about the cause of the failure.
+//  *
+//  * @tsplus fluent fncts.io.IO absorbWith
+//  */
+// export function absorbWith_<R, E, A>(ma: IO<R, E, A>, f: (e: E) => unknown, __tsplusTrace?: string) {
+//   return ma.sandbox.matchIO((cause) => IO.failNow(cause.squash(f)), IO.succeedNow)
+// }
+
+/**
+ * @tsplus fluent fncts.io.IO apFirst
+ * @tsplus operator fncts.io.IO <
+ */
+
+
+function apFirst_(self, fb, __tsplusTrace) {
+  return flatMap_1(self, a => map_1(fb, () => a, __tsplusTrace), __tsplusTrace);
+}
+/**
+ * Combine two effectful actions, keeping only the result of the second
+ *
+ * @tsplus fluent fncts.io.IO apSecond
+ * @tsplus operator fncts.io.IO >
+ */
+
+
+function apSecond_1(self, fb, __tsplusTrace) {
+  return flatMap_1(self, () => fb, __tsplusTrace);
+}
+/**
+ * @tsplus fluent fncts.io.IO as
+ */
+
+
+function as_1(self, b) {
+  return map_1(self, () => b(), fileName_1 + ":135:18");
+}
+/**
+ * Maps the success value of this effect to an optional value.
+ *
+ * @tsplus getter fncts.io.IO asJust
+ */
+
+
+function asJust(ma, __tsplusTrace) {
+  return map_1(ma, tsplus_module_2.just, __tsplusTrace);
+}
+/**
+ * Maps the error value of this IO to an optional value.
+ *
+ * @tsplus getter fncts.io.IO asJustError
+ */
+
+
+function asJustError(ma, __tsplusTrace) {
+  return mapError_1(ma, tsplus_module_2.just, __tsplusTrace);
+}
+/**
+ * @tsplus getter fncts.io.IO asUnit
+ */
+
+
+function asUnit_1(self) {
+  return as_1(self, () => undefined);
+}
+/**
+ * Returns an IO whose failure and success channels have been mapped by
+ * the specified pair of functions, `f` and `g`.
+ *
+ * @tsplus fluent fncts.io.IO bimap
+ */
+
+
+function bimap_(self, f, g, __tsplusTrace) {
+  return matchIO_1(self, e => failNow_1(f(e), __tsplusTrace), a => succeedNow_1(g(a), __tsplusTrace), __tsplusTrace);
+}
+/**
+ * Returns an IO that effectfully "peeks" at the failure or success of
+ * this effect.
+ *
+ * @tsplus fluent fncts.io.IO bitap
+ */
+
+
+function bitap_(self, onFailure, onSuccess, __tsplusTrace) {
+  return matchCauseIO_1(self, cause => tsplus_module_6.match_(tsplus_module_5.failureOrCause(cause), e => flatMap_1(onFailure(e), () => failCauseNow_1(cause, __tsplusTrace), __tsplusTrace), () => failCauseNow_1(cause, __tsplusTrace)), a => apSecond_1(onSuccess(a), succeedNow_1(a, __tsplusTrace), __tsplusTrace), __tsplusTrace);
+}
+/**
+ * Recovers from the specified error
+ *
+ * @tsplus fluent fncts.io.IO catch
+ */
+
+
+function catch_1(ma, tag, k, f, __tsplusTrace) {
+  return catchAll_1(ma, e => {
+    if (tag in e && e[tag] === k) {
+      return f(e);
+    }
+
+    return failNow_1(e, __tsplusTrace);
+  }, __tsplusTrace);
+}
+/**
+ * Recovers from all errors
+ *
+ * @tsplus fluent fncts.io.IO catchAll
+ */
+
+
+function catchAll_1(ma, f, __tsplusTrace) {
+  return matchIO_1(ma, f, succeedNow_1, __tsplusTrace);
+}
+/**
+ *
+ * Recovers from all errors with provided cause.
+ *
+ * @tsplus fluent fncts.io.IO catchAllCause
+ */
+
+
+function catchAllCause_1(ma, f, __tsplusTrace) {
+  return matchCauseIO_1(ma, f, succeedNow_1, __tsplusTrace);
+}
+/**
+ * Recovers from some or all of the error cases.
+ *
+ * @tsplus fluent fncts.io.IO catchJust
+ */
+
+
+function catchJust_(ma, f, __tsplusTrace) {
+  return matchCauseIO_1(ma, cause => tsplus_module_6.match_(tsplus_module_5.failureOrCause(cause), e => tsplus_module_7.getOrElse_(f(e), () => failCauseNow_1(cause, __tsplusTrace)), failCauseNow_1), succeedNow_1, __tsplusTrace);
+}
+/**
+ * Recovers from some or all of the error cases with provided cause.
+ *
+ * @tsplus fluent fncts.io.IO catchJustCause
+ */
+
+
+function catchJustCause_(ma, f) {
+  return matchCauseIO_1(ma, cause => tsplus_module_7.getOrElse_(f(cause), () => failCauseNow_1(cause, fileName_1 + ":275:71")), succeedNow_1, fileName_1 + ":275:25");
+}
+/**
+ * Recovers from some or all of the defects with provided partial function.
+ *
+ * *WARNING*: There is no sensible way to recover from defects. This
+ * method should be used only at the boundary between IO and an external
+ * system, to transmit information on a defect for diagnostic or explanatory
+ * purposes.
+ *
+ * @tsplus fluent fncts.io.IO catchJustDefect
+ */
+
+
+function catchJustDefect_(ma, f, __tsplusTrace) {
+  return catchAll_1(unrefineWith_1(ma, f, failNow_1, __tsplusTrace), _function.identity, __tsplusTrace);
+}
+/**
+ * Recovers from the specified error
+ *
+ * @tsplus fluent IO catchTag
+ */
+
+
+function catchTag_(ma, k, f, __tsplusTrace) {
+  return catch_1(ma, "_tag", k, f, __tsplusTrace);
+}
+/**
+ * @tsplus getter fncts.io.IO cause
+ */
+
+
+function cause(ma, __tsplusTrace) {
+  return matchCauseIO_1(ma, succeedNow_1, () => succeedNow_1(tsplus_module_5.empty(), __tsplusTrace), __tsplusTrace);
+}
+/**
+ * @tsplus fluent fncts.io.IO causeAsError
+ */
+
+
+function causeAsError(ma, __tsplusTrace) {
+  return matchCauseIO_1(ma, failNow_1, succeedNow_1, __tsplusTrace);
+}
+/**
+ * Returns an IO that models the execution of this effect, followed by
+ * the passing of its value to the specified continuation function `f`,
+ * followed by the effect that it returns.
+ *
+ * @tsplus fluent fncts.io.IO flatMap
+ */
+
+
+function flatMap_1(ma, f, __tsplusTrace) {
+  return new _definition2.Chain(ma, f, __tsplusTrace);
+}
+/**
+ * @tsplus fluent fncts.io.IO flatMapError
+ */
+
+
+function flatMapError_(ma, f) {
+  return swapWith_1(ma, effect => flatMap_1(effect, f, fileName_1 + ":343:48"));
+}
+/**
+ * Checks the interrupt status, and produces the IO returned by the
+ * specified callback.
+ *
+ * @tsplus static fncts.io.IOOps checkInterruptible
+ */
+
+
+function checkInterruptible(f, __tsplusTrace) {
+  return new _definition2.GetInterrupt(f, __tsplusTrace);
+}
+/**
+ * @tsplus fluent fncts.io.IO collect
+ */
+
+
+function collect_(ma, f, pf, __tsplusTrace) {
+  return collectIO_1(ma, f, a => tsplus_module_7.map_(pf(a), succeedNow_1), __tsplusTrace);
+}
+/**
+ * @tsplus fluent fncts.io.IO collectIO
+ */
+
+
+function collectIO_1(ma, f, pf, __tsplusTrace) {
+  return flatMap_1(ma, a => tsplus_module_7.getOrElse_(pf(a), () => fail_1(f, __tsplusTrace)), __tsplusTrace);
+}
+/**
+ * @tsplus static fncts.io.IOOps condIO
+ */
+
+
+function condIO_(b, onTrue, onFalse) {
+  return b ? onTrue : flatMap_1(onFalse, failNow_1, fileName_1 + ":387:38");
+}
+/**
+ * Returns a lazily constructed effect, whose construction may itself require
+ * effects. The effect must not throw any exceptions. When no environment is required (i.e., when R == unknown)
+ * it is conceptually equivalent to `flatten(succeedWith(io))`. If you wonder if the effect throws exceptions,
+ * do not use this method, use `IO.deferTryCatch`.
+ *
+ * @tsplus static fncts.io.IOOps defer
+ */
+
+
+function defer_1(io, __tsplusTrace) {
+  return new _definition2.Defer(io, __tsplusTrace);
+}
+/**
+ * Returns a lazily constructed effect, whose construction may itself require
+ * effects. The effect must not throw any exceptions. When no environment is required (i.e., when R == unknown)
+ * it is conceptually equivalent to `flatten(effectTotal(io))`. If you wonder if the effect throws exceptions,
+ * do not use this method, use `IO.deferTryCatchWith`.
+ *
+ * @tsplus static fncts.io.IOOps deferWith
+ */
+
+
+function deferWith_1(io, __tsplusTrace) {
+  return new _definition2.DeferWith(io, __tsplusTrace);
+}
+/**
+ * Returns a lazily constructed effect, whose construction may itself require effects.
+ * When no environment is required (i.e., when R == unknown) it is conceptually equivalent to `flatten(try(io))`.
+ *
+ * @tsplus static fncts.io.IOOps deferTry
+ */
+
+
+function deferTry(io, __tsplusTrace) {
+  return defer_1(() => {
+    try {
+      return io();
+    } catch (u) {
+      throw new _definition2.IOError(tsplus_module_8.fail(u));
+    }
+  }, __tsplusTrace);
+}
+/**
+ * Returns a lazily constructed effect, whose construction may itself require effects.
+ * When no environment is required (i.e., when R == unknown) it is conceptually equivalent to `flatten(effect(io))`.
+ *
+ * @tsplus static IOOps deferTryWith
+ */
+
+
+function deferTryWith(io) {
+  return deferWith_1((runtimeConfig, id) => {
+    try {
+      return io(runtimeConfig, id);
+    } catch (u) {
+      throw new _definition2.IOError(tsplus_module_8.fail(u));
+    }
+  }, fileName_1 + ":442:22");
+}
+/**
+ * Returns a lazily constructed effect, whose construction may itself require effects,
+ * translating any thrown exceptions into typed failed effects and mapping the error.
+ *
+ * When no environment is required (i.e., when R == unknown) it is conceptually equivalent to `flatten(effect(io))`.
+ *
+ * @tsplus static IOOps deferTryCatch
+ */
+
+
+function deferTryCatch(io, onThrow) {
+  return defer_1(() => {
+    try {
+      return io();
+    } catch (u) {
+      throw new _definition2.IOError(tsplus_module_8.fail(onThrow(u)));
+    }
+  }, fileName_1 + ":460:18");
+}
+/**
+ * Returns a lazily constructed effect, whose construction may itself require effects,
+ * translating any thrown exceptions into typed failed effects and mapping the error.
+ *
+ * When no environment is required (i.e., when R == unknown) it is conceptually equivalent to `flatten(effect(io))`.
+ *
+ * @tsplus static IOOps deferTryCatchWith
+ */
+
+
+function deferTryCatchWith(io, onThrow) {
+  return deferWith_1((runtimeConfig, id) => {
+    try {
+      return io(runtimeConfig, id);
+    } catch (u) {
+      throw new _definition2.IOError(tsplus_module_8.fail(onThrow(u)));
+    }
+  }, fileName_1 + ":481:22");
+}
+/**
+ * @tsplus static fncts.io.IOOps descriptor
+ */
+
+
+const descriptor = /*#__PURE__*/descriptorWith_1(succeedNow_1, fileName_1 + ":493:41");
+/**
+ * Constructs an IO based on information about the current fiber, such as
+ * its identity.
+ *
+ * @tsplus static fncts.io.IOOps descriptorWith
+ */
+
+exports.descriptor = descriptor;
+
+function descriptorWith_1(f, __tsplusTrace) {
+  return new _definition2.GetDescriptor(f, __tsplusTrace);
+}
+/**
+ * Folds an `IO` that may fail with `E` or succeed with `A` into one that never fails but succeeds with `Either<E, A>`
+ *
+ * @tsplus getter fncts.io.IO either
+ */
+
+
+function either_1(ma, __tsplusTrace) {
+  return match_1(ma, tsplus_module_3.left, tsplus_module_3.right, __tsplusTrace);
+}
+/**
+ * @tsplus fluent fncts.io.IO ensuring
+ */
+
+
+function ensuring_(self, finalizer, __tsplusTrace) {
+  return new _definition2.Ensuring(self, finalizer, __tsplusTrace);
+}
+/**
+ * @tsplus fluent fncts.io.IO errorAsCause
+ */
+
+
+function errorAsCause(ma, __tsplusTrace) {
+  return matchIO_1(ma, failCauseNow_1, succeedNow_1, __tsplusTrace);
+}
+/**
+ * @tsplus getter fncts.io.IO eventually
+ */
+
+
+function eventually_1(ma, __tsplusTrace) {
+  return orElse_1(ma, () => eventually_1(ma), __tsplusTrace);
+}
+/**
+ * @tsplus fluent fncts.io.IO extend
+ */
+
+
+function extend_(wa, f, __tsplusTrace) {
+  return matchIO_1(wa, failNow_1, _ => succeed_1(() => f(wa), __tsplusTrace), __tsplusTrace);
+}
+/**
+ * @tsplus static fncts.io.IOOps fail
+ */
+
+
+function fail_1(e, __tsplusTrace) {
+  return new _definition2.Fail(() => tsplus_module_5.fail(e()), __tsplusTrace);
+}
+/**
+ * @tsplus static fncts.io.IOOps failNow
+ */
+
+
+function failNow_1(e, __tsplusTrace) {
+  return new _definition2.Fail(() => tsplus_module_5.fail(e), __tsplusTrace);
+}
+/**
+ * Creates a `IO` that has failed with the specified `Cause`
+ *
+ * @tsplus static fncts.io.IOOps failCauseNow
+ */
+
+
+function failCauseNow_1(cause, __tsplusTrace) {
+  return new _definition2.Fail(() => cause, __tsplusTrace);
+}
+/**
+ * Returns an effect that models failure with the specified lazily-evaluated `Cause`.
+ *
+ * @tsplus static fncts.io.IOOps failCause
+ */
+
+
+function failCause_1(cause, __tsplusTrace) {
+  return new _definition2.Fail(cause, __tsplusTrace);
+}
+/**
+ * Returns the `FiberId` of the `Fiber` on which this `IO` is running
+ *
+ * @tsplus static fncts.io.IOOps fiberId
+ */
+
+
+const fiberId = /*#__PURE__*/descriptorWith_1(d => succeedNow_1(d.id, fileName_1 + ":583:91"), fileName_1 + ":583:70");
+/**
+ * Filters the collection using the specified effectual predicate.
+ *
+ * @tsplus static fncts.io.IOOps filter
+ */
+
+exports.fiberId = fiberId;
+
+function filter_1(as, f, __tsplusTrace) {
+  return map_1(tsplus_module_10.foldLeft_(as, succeedNow_1(tsplus_module_9.builder(), __tsplusTrace), (eff, a) => zipWith_1(eff, f(a), (builder, p) => {
+    if (p) {
+      builder.append(a);
+    }
+
+    return builder;
+  })), b => b.result(), __tsplusTrace);
+}
+/**
+ * @tsplus static fncts.io.IOOps filterMap
+ */
+
+
+function filterMap_(as, f, __tsplusTrace) {
+  return filterMapWithIndex_1(as, (_, a) => f(a), __tsplusTrace);
+}
+/**
+ * @tsplus static fncts.io.IOOps filterMapWithIndex
+ */
+
+
+function filterMapWithIndex_1(as, f, __tsplusTrace) {
+  return defer_1(() => {
+    const bs = [];
+    return as_1(foreachWithIndexDiscard_1(as, (i, a) => map_1(f(i, a), b => {
+      if (tsplus_module_12.isJust(b)) {
+        bs.push(b.value);
+      }
+    }, __tsplusTrace)), () => tsplus_module_11.from(bs));
+  }, __tsplusTrace);
+}
+/**
+ * Filters the collection using the specified effectual predicate, removing
+ * all elements that satisfy the predicate.
+ *
+ * @tsplus static fncts.io.IOOps filterNot
+ */
+
+
+function filterNot_(as, f, __tsplusTrace) {
+  return filter_1(as, a => map_1(f(a), b => !b, __tsplusTrace), __tsplusTrace);
+}
+
+function filterOrElse_1(fa, predicate, or, __tsplusTrace) {
+  return flatMap_1(fa, a => predicate(a) ? succeedNow_1(a, __tsplusTrace) : defer_1(() => or(a), __tsplusTrace), __tsplusTrace);
+}
+
+function filterOrFail_(fa, predicate, failWith) {
+  return filterOrElse_1(fa, predicate, a => failNow_1(failWith(a), fileName_1 + ":701:56"), fileName_1 + ":701:23");
+}
+/**
+ * Returns an `IO` that yields the value of the first
+ * `IO` to succeed.
+ *
+ * @tsplus static fncts.io.IOOps firstSuccess
+ */
+
+
+function firstSuccess(mas) {
+  return mas.reduce((b, a) => orElse_1(b, () => a, fileName_1 + ":711:39"));
+}
+
+function filterOrHalt_(fa, predicate, haltWith, __tsplusTrace) {
+  return filterOrElse_1(fa, predicate, a => haltNow_1(haltWith(a), __tsplusTrace), __tsplusTrace);
+}
+/**
+ * @tsplus getter fncts.io.IO flatten
+ */
+
+
+function flatten(self) {
+  return flatMap_1(self, _function.identity, fileName_1 + ":744:22");
+}
+/**
+ * Folds an `Iterable<A>` using an effectful function f, working sequentially from left to right.
+ *
+ * @tsplus static fncts.io.IOOps foldLeft
+ */
+
+
+function foldLeft_1(as, b, f, __tsplusTrace) {
+  return tsplus_module_10.foldLeft_(as, succeedNow_1(b, __tsplusTrace), (acc, el) => flatMap_1(acc, a => f(a, el), __tsplusTrace));
+}
+/**
+ * Combines an array of `IO`s using a `Monoid`
+ *
+ * @constrained
+ * @tsplus static fncts.io.IOOps foldMap
+ */
+
+
+function foldMap_(M) {
+  return (as, f) => foldLeft_1(as, M.nat, (m, a) => map_1(a, a => M.combine_(m, f(a)), fileName_1 + ":769:43"), fileName_1 + ":769:16");
+}
+
+function foldRightLoop(iterator, b, f) {
+  const next = iterator.next();
+  return next.done ? b : f(next.value, foldRightLoop(iterator, b, f));
+}
+/**
+ * Performs a right-associative fold of an `Iterable<A>`
+ *
+ * @tsplus static fncts.io.IOOps foldRight
+ */
+
+
+function foldRight_(as, b, f) {
+  return foldRightLoop(as[Symbol.iterator](), b, f);
+}
+
+function foreachWithIndexDiscardLoop(iterator, f, i = 0) {
+  const next = iterator.next();
+  return next.done ? unit_1 : flatMap_1(f(i, next.value), () => foreachWithIndexDiscardLoop(iterator, f, i + 1), fileName_1 + ":800:56");
+}
+/**
+ * Applies the function `f` to each element of the `Iterable<A>` and
+ * returns the results in a new `Conc<B>`.
+ *
+ * For a parallel version of this method, see `foreachC`.
+ * If you do not need the results, see `foreachUnit` for a more efficient implementation.
+ *
+ * @tsplus static fncts.io.IOOps foreach
+ */
+
+
+function foreach_1(as, f, __tsplusTrace) {
+  return defer_1(() => {
+    const acc = [];
+    return as_1(foreachWithIndexDiscard_1(as, (_, a) => flatMap_1(f(a), b => {
+      acc.push(b);
+      return unit_1;
+    }, __tsplusTrace)), () => tsplus_module_11.from(acc));
+  }, __tsplusTrace);
+}
+/**
+ * Applies the function `f` to each element of the `Iterable<A>` and
+ * returns the results in a new `Conc<B>`.
+ *
+ * For a parallel version of this method, see `foreachC`.
+ * If you do not need the results, see `foreachUnit` for a more efficient implementation.
+ *
+ * @tsplus static fncts.io.IOOps foreachWithIndex
+ */
+
+
+function foreachWithIndex_(as, f) {
+  return defer_1(() => {
+    const acc = [];
+    return as_1(foreachWithIndexDiscard_1(as, (i, a) => flatMap_1(f(i, a), b => {
+      acc.push(b);
+      return unit_1;
+    }, fileName_1 + ":841:22")), () => tsplus_module_11.from(acc));
+  }, fileName_1 + ":838:18");
+}
+/**
+ * @tsplus static fncts.io.IOOps foreachWithIndexDiscard
+ */
+
+
+function foreachWithIndexDiscard_1(as, f) {
+  return defer_1(() => foreachWithIndexDiscardLoop(as[Symbol.iterator](), f), fileName_1 + ":856:18");
+}
+/**
+ * Applies the function `f` to each element of the `Iterable<A>` and runs
+ * produced IOs sequentially.
+ *
+ * @tsplus static fncts.io.IOOps foreachDiscard
+ */
+
+
+function foreachDiscard_1(as, f) {
+  return defer_1(() => foreachWithIndexDiscardLoop(as[Symbol.iterator](), (_, a) => f(a)), fileName_1 + ":866:18");
+}
+/**
+ * Repeats this effect forever (until the first failure).
+ *
+ * @tsplus getter fncts.io.IO forever
+ */
+
+
+function forever_1(ma) {
+  return flatMap_1(apSecond_1(ma, yieldNow_1, fileName_1 + ":875:21"), () => forever_1(ma), fileName_1 + ":875:42");
+}
+/**
+ * Returns an IO that forks this IO into its own separate fiber,
+ * returning the fiber immediately, without waiting for it to begin executing
+ * the IO.
+ *
+ * You can use the `fork` method whenever you want to execute an IO in a
+ * new fiber, concurrently and without "blocking" the fiber executing other
+ * IOs. Using fibers can be tricky, so instead of using this method
+ * directly, consider other higher-level methods, such as `raceWith`,
+ * `zipPar`, and so forth.
+ *
+ * The fiber returned by this method has methods interrupt the fiber and to
+ * wait for it to finish executing the IO. See `Fiber` for more
+ * information.
+ *
+ * Whenever you use this method to launch a new fiber, the new fiber is
+ * attached to the parent fiber's scope. This means when the parent fiber
+ * terminates, the child fiber will be terminated as well, ensuring that no
+ * fibers leak. This behavior is called "None supervision", and if this
+ * behavior is not desired, you may use the `forkDaemon` or `forkIn`
+ * methods.
+ *
+ * @tsplus getter fncts.io.IO fork
+ */
+
+
+function fork(ma, __tsplusTrace) {
+  return new _definition2.Fork(ma, tsplus_module_2.nothing(), __tsplusTrace);
+}
+/**
+ * Lifts an `Either` into an `IO`
+ *
+ * @tsplus static fncts.io.IOOps fromEither
+ */
+
+
+function fromEither(either, __tsplusTrace) {
+  return flatMap_1(succeed_1(either, __tsplusTrace), ea => tsplus_module_6.match_(ea, failNow_1, succeedNow_1), __tsplusTrace);
+}
+/**
+ * Lifts an `Either` into an `IO`
+ *
+ * @tsplus static fncts.io.IOOps fromEitherNow
+ */
+
+
+function fromEitherNow(either, __tsplusTrace) {
+  return tsplus_module_6.match_(either, failNow_1, succeedNow_1);
+}
+/**
+ * Lifts an `Eval` into an `IO`
+ *
+ * @tsplus static fncts.io.IOOps fromEval
+ */
+
+
+function fromEval(computation, __tsplusTrace) {
+  return succeed_1(() => tsplus_module_13.run(computation), __tsplusTrace);
+}
+/**
+ * Creates a `IO` from an exit value
+ *
+ * @tsplus static fncts.io.IOOps fromExit
+ */
+
+
+function fromExit(exit, __tsplusTrace) {
+  return defer_1(() => tsplus_module_14.match_(exit(), failCauseNow_1, succeedNow_1), __tsplusTrace);
+}
+/**
+ * Creates a `IO` from an exit value
+ *
+ * @tsplus static fncts.io.IOOps fromExitNow
+ */
+
+
+function fromExitNow(exit, __tsplusTrace) {
+  return tsplus_module_14.match_(exit, failCauseNow_1, succeedNow_1);
+}
+/**
+ * Lifts a `Maybe` into an `IO` but preserves the error as a `Maybe` in the error channel, making it easier to compose
+ * in some scenarios.
+ *
+ * @tsplus static fncts.io.IOOps fromMaybe
+ */
+
+
+function fromMaybe(maybe, __tsplusTrace) {
+  return flatMap_1(succeed_1(maybe, __tsplusTrace), m => tsplus_module_4.match_(m, () => failNow_1(tsplus_module_2.nothing(), __tsplusTrace), succeedNow_1), __tsplusTrace);
+}
+/**
+ * @tsplus static fncts.io.IOOps fromMaybeNow
+ */
+
+
+function fromMaybeNow(maybe, __tsplusTrace) {
+  return tsplus_module_4.match_(maybe, () => failNow_1(tsplus_module_2.nothing(), __tsplusTrace), succeedNow_1);
+}
+/**
+ * Create an IO that when executed will construct `promise` and wait for its result,
+ * errors will be handled using `onReject`
+ *
+ * @tsplus static fncts.io.IOOps fromPromiseCatch
+ */
+
+
+function fromPromiseCatch_1(promise, onReject, __tsplusTrace) {
+  return async_1(k => {
+    promise().then(a => k(succeedNow_1(a, __tsplusTrace))).catch(e => k(failNow_1(onReject(e), __tsplusTrace)));
+  });
+}
+/**
+ * Create an IO that when executed will construct `promise` and wait for its result,
+ * errors will produce failure as `unknown`
+ *
+ * @tsplus static fncts.io.IOOps fromPromise
+ */
+
+
+function fromPromise(promise, __tsplusTrace) {
+  return fromPromiseCatch_1(promise, _function.identity, __tsplusTrace);
+}
+/**
+ * Like fromPromise but produces a defect in case of errors
+ *
+ * @tsplus static fncts.io.IOOps fromPromiseHalt
+ */
+
+
+function fromPromiseHalt(promise, __tsplusTrace) {
+  return async_1(k => {
+    promise().then(a => k(succeedNow_1(a, __tsplusTrace))).catch(e => k(haltNow_1(e, __tsplusTrace)));
+  });
+}
+/**
+ * Unwraps the optional success of an `IO`, but can fail with a `Nothing` value.
+ *
+ * @tsplus getter fncts.io.IO get
+ */
+
+
+function get(ma) {
+  return matchCauseIO_1(ma, cause => failCauseNow_1(tsplus_module_5.map_(cause, tsplus_module_2.just), fileName_1 + ":1016:31"), ma => tsplus_module_4.match_(ma, () => failNow_1(tsplus_module_2.nothing(), fileName_1 + ":1017:38"), succeedNow_1), fileName_1 + ":1015:25");
+}
+/**
+ * Extracts the optional value, or returns the given 'orElse'.
+ *
+ * @tsplus fluent fncts.io.IO getOrElse
+ */
+
+
+function getOrElse_(ma, orElse) {
+  return map_1(ma, ma => tsplus_module_7.getOrElse_(ma, orElse), fileName_1 + ":1027:16");
+}
+/**
+ * Extracts the optional value, or executes the effect 'orElse'.
+ *
+ * @tsplus fluent fncts.io.IO getOrElseIO
+ */
+
+
+function getOrElseIO_(ma, orElse) {
+  return flatMap_1(ma, mab => tsplus_module_7.getOrElse_(tsplus_module_7.map_(mab, succeedNow_1), orElse), fileName_1 + ":1039:48");
+}
+/**
+ * Lifts a Maybe into an IO. If the option is `Nothing`, fail with `onNothing`.
+ *
+ * @tsplus static fncts.io.IOOps getOrFailWith
+ */
+
+
+function getOrFailWith_1(maybe, onNothing) {
+  return defer_1(() => tsplus_module_4.match_(maybe, () => fail_1(onNothing, fileName_1 + ":1048:44"), succeedNow_1), fileName_1 + ":1048:18");
+}
+/**
+ * Lifts a Maybe into a IO, if the Maybe is `Nothing` it fails with Unit.
+ *
+ * @tsplus static fncts.io.IOOps getOrFailUnit
+ */
+
+
+function getOrFailUnit(option) {
+  return getOrFailWith_1(option, () => undefined);
+}
+/**
+ * Creates an `IO` that halts with the specified lazily-evaluated defect.
+ * This method can be used for terminating a fiber because a defect has been
+ * detected in the code.
+ *
+ * @tsplus static fncts.io.IOOps halt
+ */
+
+
+function halt(e, __tsplusTrace) {
+  return failCause_1(() => tsplus_module_5.halt(e(), tsplus_module_15.none), __tsplusTrace);
+}
+/**
+ * Creates an `IO` that halts with the specified defect
+ * This method can be used for terminating a fiber because a defect has been
+ * detected in the code.
+ *
+ * @tsplus static fncts.io.IOOps haltNow
+ */
+
+
+function haltNow_1(e, __tsplusTrace) {
+  return failCauseNow_1(tsplus_module_5.halt(e, tsplus_module_15.none), __tsplusTrace);
+}
+/**
+ * @tsplus fluent fncts.io.IO ifIO
+ */
+
+
+function ifIO_1(self, onFalse, onTrue) {
+  return flatMap_1(self, b => b ? onTrue() : onFalse(), fileName_1 + ":1090:22");
+}
+/**
+ * @tsplus static fncts.io.IOOps if
+ */
+
+
+function if_(b, onTrue, onFalse, __tsplusTrace) {
+  return ifIO_1(succeedNow_1(b, __tsplusTrace), onTrue, onFalse);
+}
+/**
+ * @tsplus getter fncts.io.IO ignore
+ */
+
+
+function ignore(fa) {
+  return match_1(fa, () => undefined, () => undefined, fileName_1 + ":1109:18");
+}
+/**
+ * Folds a `IO` to a boolean describing whether or not it is a failure
+ *
+ * @tsplus getter fncts.io.IO isFailure
+ */
+
+
+function isFailure(ma) {
+  return match_1(ma, () => true, () => false, fileName_1 + ":1121:18");
+}
+/**
+ * Folds a `IO` to a boolean describing whether or not it is a success
+ *
+ * @tsplus getter fncts.io.IO isSuccess
+ */
+
+
+function isSuccess(ma) {
+  return match_1(ma, () => false, () => true, fileName_1 + ":1133:18");
+}
+/**
+ * Iterates with the specified effectual function. The moral equivalent of:
+ *
+ * ```typescript
+ * let s = initial;
+ *
+ * while (cont(s)) {
+ *   s = body(s);
+ * }
+ *
+ * return s;
+ * ```
+ *
+ * @tsplus static fncts.io.IOOps iterate
+ */
+
+
+function iterate_1(initial, cont, body, __tsplusTrace) {
+  return cont(initial) ? flatMap_1(body(initial), a => iterate_1(a, cont, body, __tsplusTrace), __tsplusTrace) : succeedNow_1(initial, __tsplusTrace);
+}
+/**
+ *  Returns an IO with the value on the left part.
+ *
+ * @tsplus static fncts.io.IOOps left
+ */
+
+
+function left(a) {
+  return flatMap_1(succeed_1(a, fileName_1 + ":1168:20"), a => succeedNow_1(tsplus_module_3.left(a), fileName_1 + ":1168:52"), fileName_1 + ":1168:31");
+}
+/**
+ * @tsplus static fncts.io.IOOps log
+ */
+
+
+function log(message, __tsplusTrace) {
+  return new _definition2.Logged(message, tsplus_module_5.empty(), tsplus_module_2.nothing(), __tsplusTrace);
+}
+/**
+ * Loops with the specified effectual function, collecting the results into a
+ * list. The moral equivalent of:
+ *
+ * ```typescript
+ * let s  = initial
+ * let as = [] as readonly A[]
+ *
+ * while (cont(s)) {
+ *   as = [body(s), ...as]
+ *   s  = inc(s)
+ * }
+ *
+ * A.reverse(as)
+ * ```
+ *
+ * @tsplus static fncts.io.IOOps loop
+ */
+
+
+function loop_1(initial, cont, inc, body, __tsplusTrace) {
+  if (cont(initial)) {
+    return flatMap_1(body(initial), a => map_1(loop_1(inc(initial), cont, inc, body, __tsplusTrace), as => tsplus_module_9.prepend_(as, a), __tsplusTrace), __tsplusTrace);
+  } else {
+    return succeedNow_1(tsplus_module_16.empty(), __tsplusTrace);
+  }
+}
+/**
+ * Loops with the specified effectual function purely for its effects. The
+ * moral equivalent of:
+ *
+ * ```
+ * var s = initial
+ *
+ * while (cont(s)) {
+ *   body(s)
+ *   s = inc(s)
+ * }
+ * ```
+ *
+ * @tsplus static fncts.io.IOOps loopUnit
+ */
+
+
+function loopUnit_(initial, cont, inc, body, __tsplusTrace) {
+  if (cont(initial)) {
+    return asUnit_1(flatMap_1(body(initial), () => loop_1(inc(initial), cont, inc, body, __tsplusTrace), __tsplusTrace));
+  } else {
+    return unit_1;
+  }
+}
+/**
+ * Returns an `IO` whose success is mapped by the specified function `f`.
+ *
+ * @tsplus fluent fncts.io.IO map
+ */
+
+
+function map_1(fa, f, __tsplusTrace) {
+  return flatMap_1(fa, a => succeedNow_1(f(a), __tsplusTrace), __tsplusTrace);
+}
+/**
+ * Map covariantly over the first argument.
+ *
+ * Returns an IO with its error channel mapped using the specified
+ * function. This can be used to lift a "smaller" error into a "larger"
+ * error.
+ *
+ * @tsplus fluent fncts.io.IO mapError
+ */
+
+
+function mapError_1(fea, f, __tsplusTrace) {
+  return matchCauseIO_1(fea, cause => failCauseNow_1(tsplus_module_5.map_(cause, f), __tsplusTrace), succeedNow_1, __tsplusTrace);
+}
+/**
+ * @tsplus static fncts.io.IOOps mapTryCatch
+ */
+
+
+function mapTryCatch_(io, f, onThrow, __tsplusTrace) {
+  return flatMap_1(io, a => tryCatch_1(() => f(a), onThrow, __tsplusTrace), __tsplusTrace);
+}
+/**
+ * Returns an IO with its full cause of failure mapped using
+ * the specified function. This can be used to transform errors
+ * while preserving the original structure of Cause.
+ *
+ * @tsplus fluent fncts.io.IO mapErrorCause
+ */
+
+
+function mapErrorCause_1(ma, f, __tsplusTrace) {
+  return matchCauseIO_1(ma, cause => failCauseNow_1(f(cause), __tsplusTrace), succeedNow_1, __tsplusTrace);
+}
+/**
+ * A more powerful version of `match_` that allows recovering from any kind of failure except interruptions.
+ *
+ * @tsplus fluent fncts.io.IO matchCause
+ */
+
+
+function matchCause_(self, onFailure, onSuccess, __tsplusTrace) {
+  return matchCauseIO_1(self, cause => succeedNow_1(onFailure(cause), __tsplusTrace), a => succeedNow_1(onSuccess(a), __tsplusTrace), __tsplusTrace);
+}
+/**
+ * A more powerful version of `matchIO` that allows recovering from any kind of failure except interruptions.
+ *
+ * @tsplus fluent fncts.io.IO matchCauseIO
+ */
+
+
+function matchCauseIO_1(self, onFailure, onSuccess, __tsplusTrace) {
+  return new _definition2.Match(self, onFailure, onSuccess, __tsplusTrace);
+}
+/**
+ * @tsplus fluent fncts.io.IO matchIO
+ */
+
+
+function matchIO_1(self, onFailure, onSuccess, __tsplusTrace) {
+  return matchCauseIO_1(self, cause => tsplus_module_6.match_(tsplus_module_5.failureOrCause(cause), onFailure, failCauseNow_1), onSuccess, __tsplusTrace);
+}
+/**
+ * Folds over the failure value or the success value to yield an IO that
+ * does not fail, but succeeds with the value returned by the left or right
+ * function passed to `match_`.
+ *
+ * @tsplus fluent fncts.io.IO match
+ */
+
+
+function match_1(self, onFailure, onSuccess, __tsplusTrace) {
+  return matchIO_1(self, e => succeedNow_1(onFailure(e), __tsplusTrace), a => succeedNow_1(onSuccess(a), __tsplusTrace), __tsplusTrace);
+}
+/**
+ * A version of `matchIO` that gives you the (optional) trace of the error.
+ *
+ * @tsplus fluent fncts.io.IO matchTraceIO
+ */
+
+
+function matchTraceIO_(ma, onFailure, onSuccess, __tsplusTrace) {
+  return matchCauseIO_1(ma, cause => tsplus_module_6.match_(tsplus_module_5.failureTraceOrCause(cause), ([e, trace]) => onFailure(e, trace), failCauseNow_1), onSuccess, __tsplusTrace);
+}
+/**
+ * @tsplus getter fncts.io.IO maybe
+ */
+
+
+function maybe(io, __tsplusTrace) {
+  return match_1(io, () => tsplus_module_2.nothing(), tsplus_module_2.just, __tsplusTrace);
+}
+/**
+ * @tsplus getter fncts.io.IO merge
+ */
+
+
+function merge(io, __tsplusTrace) {
+  return matchIO_1(io, succeedNow_1, succeedNow_1, __tsplusTrace);
+}
+/**
+ * Merges an `Iterable<IO>` to a single IO, working sequentially.
+ *
+ * @tsplus static fncts.io.IOOps mergeAll
+ */
+
+
+function mergeAll_(fas, b, f, __tsplusTrace) {
+  return tsplus_module_10.foldLeft_(fas, succeed_1(() => b, __tsplusTrace), (b, a) => zipWith_1(b, a, f));
+}
+/**
+ * Returns a `IO` that will never produce anything. The moral equivalent of
+ * `while(true) {}`, only without the wasted CPU cycles.
+ *
+ * @tsplus static fncts.io.IOOps never
+ */
+
+
+const never = /*#__PURE__*/defer_1(() => asyncInterrupt_1(() => {
+  const interval = setInterval(() => {//
+  }, 60000);
+  return tsplus_module_3.left(succeed_1(() => {
+    clearInterval(interval);
+  }, fileName_1 + ":1407:17"));
+}), fileName_1 + ":1401:39");
+/**
+ * Converts an option on errors into an option on values.
+ *
+ * @tsplus getter fncts.io.IO optional
+ */
+
+exports.never = never;
+
+function optional(ma) {
+  return matchIO_1(ma, me => tsplus_module_4.match_(me, () => succeedNow_1(tsplus_module_2.nothing(), fileName_1 + ":1421:41"), failNow_1), a => succeedNow_1(tsplus_module_2.just(a), fileName_1 + ":1422:25"), fileName_1 + ":1420:20");
+}
+/**
+ * Returns the logical disjunction of the `Boolean` value returned by this
+ * effect and the `Boolean` value returned by the specified effect. This
+ * operator has "short circuiting" behavior so if the value returned by this
+ * effect is true the specified effect will not be evaluated.
+ *
+ * @tsplus fluent fncts.io.IO or
+ */
+
+
+function or_(ma, mb, __tsplusTrace) {
+  return flatMap_1(ma, b => b ? succeedNow_1(true, __tsplusTrace) : mb, __tsplusTrace);
+}
+/**
+ * @tsplus fluent fncts.io.IO orElse
+ */
+
+
+function orElse_1(ma, that, __tsplusTrace) {
+  return tryOrElse_1(ma, that, succeedNow_1, __tsplusTrace);
+}
+/**
+ * @tsplus fluent fncts.io.IO orElseEither
+ */
+
+
+function orElseEither_(self, that, __tsplusTrace) {
+  return tryOrElse_1(self, () => map_1(that(), tsplus_module_3.right, __tsplusTrace), a => succeedNow_1(tsplus_module_3.left(a), __tsplusTrace), __tsplusTrace);
+}
+/**
+ * @tsplus fluent fncts.io.IO orElseFail
+ */
+
+
+function orElseFail_(ma, e) {
+  return orElse_1(ma, () => fail_1(e, fileName_1 + ":1468:27"), fileName_1 + ":1468:19");
+}
+/**
+ * @tsplus fluent fncts.io.IO orElseMaybe
+ */
+
+
+function orElseMaybe_(ma, that, __tsplusTrace) {
+  return catchAll_1(ma, me => tsplus_module_4.match_(me, that, e => fail_1(() => tsplus_module_2.just(e), __tsplusTrace)), __tsplusTrace);
+}
+/**
+ * @tsplus fluent fncts.io.IO orElseSucceed
+ */
+
+
+function orElseSucceed_(ma, a, __tsplusTrace) {
+  return orElse_1(ma, () => succeed_1(a, __tsplusTrace), __tsplusTrace);
+}
+/**
+ * @tsplus getter fncts.io.IO orHalt
+ */
+
+
+function orHalt(ma, __tsplusTrace) {
+  return orHaltWith_1(ma, _function.identity, __tsplusTrace);
+}
+/**
+ * @tsplus getter fncts.io.IO orHaltKeep
+ */
+
+
+function orHaltKeep(ma) {
+  return matchCauseIO_1(ma, cause => failCauseNow_1(tsplus_module_5.flatMap_(cause, tsplus_module_5.halt), fileName_1 + ":1500:52"), succeedNow_1, fileName_1 + ":1500:25");
+}
+/**
+ * @tsplus fluent fncts.io.IO orHaltWith
+ */
+
+
+function orHaltWith_1(ma, f, __tsplusTrace) {
+  return matchIO_1(ma, e => haltNow_1(f(e), __tsplusTrace), succeedNow_1, __tsplusTrace);
+}
+/**
+ * Exposes all parallel errors in a single call
+ *
+ * @tsplus fluent fncts.io.IO parallelErrors
+ */
+
+
+function parallelErrors(io) {
+  return matchCauseIO_1(io, cause => {
+    const f = tsplus_module_5.failures(cause);
+
+    if (tsplus_module_17.length(f) === 0) {
+      return failCauseNow_1(cause, fileName_1 + ":1519:29");
+    } else {
+      return failNow_1(f, fileName_1 + ":1521:24");
+    }
+  }, succeedNow_1, fileName_1 + ":1516:25");
+}
+/**
+ * Feeds elements of type `A` to a function `f` that returns an IO.
+ * Collects all successes and failures in a separated fashion.
+ *
+ * @tsplus static fncts.io.IOOps partition
+ */
+
+
+function partition_(as, f, __tsplusTrace) {
+  return map_1(foreach_1(as, a => either_1(f(a)), __tsplusTrace), c => tsplus_module_9.separate(c), __tsplusTrace);
+}
+/**
+ * Keeps some of the errors, and terminates the fiber with the rest
+ *
+ * @tsplus fluent fncts.io.IO refineOrHalt
+ */
+
+
+function refineOrHalt_(fa, pf, __tsplusTrace) {
+  return refineOrHaltWith_1(fa, pf, _function.identity);
+}
+/**
+ * Keeps some of the errors, and terminates the fiber with the rest, using
+ * the specified function to convert the `E` into a `Throwable`.
+ *
+ * @tsplus fluent fncts.io.IO refineOrHaltWith
+ */
+
+
+function refineOrHaltWith_1(fa, pf, f) {
+  return catchAll_1(fa, e => tsplus_module_4.match_(pf(e), () => haltNow_1(f(e), fileName_1 + ":1564:57"), failNow_1), fileName_1 + ":1564:21");
+}
+/**
+ * Fail with the returned value if the partial function `pf` matches, otherwise
+ * continue with the held value.
+ *
+ * @tsplus fluent fncts.io.IO reject
+ */
+
+
+function reject_(fa, pf, __tsplusTrace) {
+  return rejectIO_1(fa, a => tsplus_module_7.map_(pf(a), failNow_1), __tsplusTrace);
+}
+/**
+ * Continue with the returned computation if the partial function `pf` matches,
+ * translating the successful match into a failure, otherwise continue with
+ * the held value.
+ *
+ * @tsplus fluent fncts.io.IO rejectIO
+ */
+
+
+function rejectIO_1(fa, pf, __tsplusTrace) {
+  return flatMap_1(fa, a => tsplus_module_4.match_(pf(a), () => succeedNow_1(a, __tsplusTrace), io => flatMap_1(io, failNow_1, __tsplusTrace)), __tsplusTrace);
+}
+/**
+ * Repeats this effect the specified number of times.
+ *
+ * @tsplus fluent fncts.io.IO repeatN
+ */
+
+
+function repeatN_1(ma, n, __tsplusTrace) {
+  return flatMap_1(ma, a => n <= 0 ? succeed_1(() => a, __tsplusTrace) : repeatN_1(ma, n - 1, __tsplusTrace), __tsplusTrace);
+}
+/**
+ * Repeats this effect until its result satisfies the specified predicate.
+ *
+ * @tsplus fluent fncts.io.IO repeatUntil
+ */
+
+
+function repeatUntil_(ma, f, __tsplusTrace) {
+  return repeatUntilIO_1(ma, a => succeedNow_1(f(a), __tsplusTrace), __tsplusTrace);
+}
+/**
+ * Repeats this effect until its error satisfies the specified effectful predicate.
+ *
+ * @tsplus fluent fncts.io.IO repeatUntilIO
+ */
+
+
+function repeatUntilIO_1(ma, f, __tsplusTrace) {
+  return flatMap_1(ma, a => flatMap_1(f(a), b => b ? succeed_1(() => a, __tsplusTrace) : repeatUntilIO_1(ma, f, __tsplusTrace), __tsplusTrace), __tsplusTrace);
+}
+/**
+ * Repeats this effect while its error satisfies the specified predicate.
+ *
+ * @tsplus fluent fncts.io.IO repeatWhile
+ */
+
+
+function repeatWhile_(ma, f) {
+  return repeatWhileIO_1(ma, a => succeedNow_1(f(a), fileName_1 + ":1638:47"), fileName_1 + ":1638:26");
+}
+/**
+ * Repeats this effect while its error satisfies the specified effectful predicate.
+ *
+ * @tsplus fluent fncts.io.IO repeatWhileIO
+ */
+
+
+function repeatWhileIO_1(ma, f, __tsplusTrace) {
+  return flatMap_1(ma, a => flatMap_1(f(a), b => b ? repeatWhileIO_1(ma, f, __tsplusTrace) : succeed_1(() => a, __tsplusTrace), __tsplusTrace), __tsplusTrace);
+}
+/**
+ * @tsplus fluent fncts.io.IO replicate
+ */
+
+
+function replicate_(self, n, __tsplusTrace) {
+  return tsplus_module_19.map_(tsplus_module_18.range(0, n), () => self);
+}
+/**
+ * @tsplus fluent fncts.io.IO require
+ */
+
+
+function require_(ma, error, __tsplusTrace) {
+  return flatMap_1(ma, ma => tsplus_module_4.match_(ma, () => fail_1(error, __tsplusTrace), succeedNow_1), __tsplusTrace);
+}
+/**
+ * Returns an IO that semantically runs the IO on a fiber,
+ * producing an `Exit` for the completion value of the fiber.
+ *
+ * @tsplus getter fncts.io.IO result
+ */
+
+
+function result(ma, __tsplusTrace) {
+  return matchCauseIO_1(ma, cause => succeedNow_1(tsplus_module_8.failCause(cause), __tsplusTrace), a => succeedNow_1(tsplus_module_8.succeed(a), __tsplusTrace), __tsplusTrace);
+}
+/**
+ * Recover from the unchecked failure of the `IO`. (opposite of `orHalt`)
+ *
+ * @trace call
+ */
+
+
+function resurrect(io) {
+  return unrefineWith_1(io, tsplus_module_2.just, _function.identity, fileName_1 + ":1687:25");
+}
+/**
+ * Retries this effect until its error satisfies the specified predicate.
+ *
+ * @tsplus fluent fncts.io.IO retryUntil
+ */
+
+
+function retryUntil_(fa, f, __tsplusTrace) {
+  return retryUntilIO_1(fa, e => succeedNow_1(f(e), __tsplusTrace), __tsplusTrace);
+}
+/**
+ * Retries this effect until its error satisfies the specified effectful predicate.
+ *
+ * @tsplus fluent fncts.io.IO retryUntilIO
+ */
+
+
+function retryUntilIO_1(fa, f, __tsplusTrace) {
+  return catchAll_1(fa, e => flatMap_1(f(e), b => b ? failNow_1(e, __tsplusTrace) : retryUntilIO_1(fa, f, __tsplusTrace), __tsplusTrace), __tsplusTrace);
+}
+/**
+ * Retries this effect while its error satisfies the specified predicate.
+ *
+ * @tsplus fluent fncts.io.IO retryWhile
+ */
+
+
+function retryWhile_(fa, f, __tsplusTrace) {
+  return retryWhileIO_1(fa, e => succeedNow_1(f(e), __tsplusTrace), __tsplusTrace);
+}
+/**
+ * Retries this effect while its error satisfies the specified effectful predicate.
+ *
+ * @tsplus fluent fncts.io.IO retryWhileIO
+ */
+
+
+function retryWhileIO_1(fa, f, __tsplusTrace) {
+  return catchAll_1(fa, e => flatMap_1(f(e), b => b ? retryWhileIO_1(fa, f, __tsplusTrace) : fail_1(() => e, __tsplusTrace), __tsplusTrace), __tsplusTrace);
+}
+/**
+ * Retrieves the runtimeConfig that this effect is running on.
+ *
+ * @tsplus static fncts.io.IOOps runtimeConfig
+ */
+
+
+const runtimeConfig = /*#__PURE__*/deferWith_1(runtimeConfig => succeedNow_1(runtimeConfig, fileName_1 + ":1739:95"), fileName_1 + ":1739:62");
+/**
+ * Exposes the full cause of failure of this effect.
+ *
+ * @tsplus getter fncts.io.IO sandbox
+ */
+
+exports.runtimeConfig = runtimeConfig;
+
+function sandbox_1(fa, __tsplusTrace) {
+  return matchCauseIO_1(fa, failNow_1, succeedNow_1, __tsplusTrace);
+}
+/**
+ * @tsplus fluent fncts.io.IO sandboxWith
+ */
+
+
+function sandboxWith_(ma, f, __tsplusTrace) {
+  return unsandbox_1(f(sandbox_1(ma)));
+}
+/**
+ * Sets the runtime configuration to the specified value.
+ * @tsplus static fncts.io.IOOps setRuntimeConfig
+ */
+
+
+function setRuntimeConfig(runtimeConfig, __tsplusTrace) {
+  return defer_1(() => new _definition2.SetRuntimeConfig(runtimeConfig(), __tsplusTrace), __tsplusTrace);
+}
+/**
+ * @tsplus static fncts.io.IOOps sequenceIterable
+ */
+
+
+function sequenceIterable(as) {
+  return foreach_1(as, _function.identity, fileName_1 + ":1773:20");
+}
+/**
+ * @tsplus static fncts.io.IOOps sequenceIterableDiscard
+ */
+
+
+function sequenceIterableDiscard(as, __tsplusTrace) {
+  return foreachDiscard_1(as, _function.identity);
+}
+/**
+ * Creates a `IO` that has succeeded with a pure value
+ *
+ * @tsplus static fncts.io.IOOps succeedNow
+ */
+
+
+function succeedNow_1(value, __tsplusTrace) {
+  return new _definition2.SucceedNow(value, __tsplusTrace);
+}
+/**
+ * Imports a total synchronous effect into a pure `IO` value.
+ * The effect must not throw any exceptions. If you wonder if the effect
+ * throws exceptions, then do not use this method, use `IO.try`
+ *
+ * @tsplus static fncts.io.IOOps succeed
+ * @tsplus static fncts.io.IOOps __call
+ */
+
+
+function succeed_1(effect, __tsplusTrace) {
+  return new _definition2.Succeed(effect, __tsplusTrace);
+}
+/**
+ *
+ * Returns an IO with the behavior of this one, but where all child
+ * fibers forked in the effect are reported to the specified supervisor.
+ *
+ * @tsplus fluent fncts.io.IO supervised
+ */
+
+
+function supervised_(fa, supervisor, __tsplusTrace) {
+  return new _definition2.Supervise(fa, supervisor);
+}
+/**
+ * @tsplus fluent fncts.io.IO summarized
+ */
+
+
+function summarized_1(ma, summary, f, __tsplusTrace) {
+  return gen_1(function* (_) {
+    const start = yield* _(summary, __tsplusTrace);
+    const value = yield* _(ma, __tsplusTrace);
+    const end = yield* _(summary, __tsplusTrace);
+    return (0, _function.tuple)(f(start, end), value);
+  });
+}
+/**
+ * Swaps the positions of a Bifunctor's arguments
+ *
+ * @tsplus getter fncts.io.IO swap
+ */
+
+
+function swap_1(pab) {
+  return matchIO_1(pab, succeedNow_1, failNow_1, fileName_1 + ":1842:21");
+}
+/**
+ * Swaps the error/value parameters, applies the function `f` and flips the parameters back
+ *
+ * @tsplus fluent fncts.io.IO swapWith
+ */
+
+
+function swapWith_1(fa, f) {
+  return swap_1(f(swap_1(fa)));
+}
+/**
+ * A more powerful variation of `timed` that allows specifying the clock.
+ *
+ * @tsplus fluent fncts.io.IO timedWith
+ */
+
+
+function timedWith_(ma, msTime, __tsplusTrace) {
+  return summarized_1(ma, msTime, (start, end) => end - start, __tsplusTrace);
+}
+/**
+ * Creates a `IO` that has succeeded with a pure value
+ *
+ * @tsplus static fncts.io.IOOps tryCatch
+ */
+
+
+function tryCatch_1(effect, onThrow, __tsplusTrace) {
+  return succeed_1(() => {
+    try {
+      return effect();
+    } catch (u) {
+      throw new _definition2.IOError(tsplus_module_8.fail(onThrow(u)));
+    }
+  }, __tsplusTrace);
+}
+/**
+ * Returns an `IO` that submerges an `Either` into the `IO`.
+ *
+ * @tsplus getter fncts.io.IO absolve
+ */
+
+
+function absolve(ma, __tsplusTrace) {
+  return flatMap_1(ma, ea => tsplus_module_6.match_(ea, failNow_1, succeedNow_1), __tsplusTrace);
+}
+/**
+ * Composes computations in sequence, using the return value of one computation as input for the next
+ * and keeping only the result of the first
+ *
+ * Returns an IO that effectfully "peeks" at the success of this effect.
+ *
+ * @tsplus fluent fncts.io.IO tap
+ */
+
+
+function tap_(self, f, __tsplusTrace) {
+  return flatMap_1(self, a => map_1(f(a), () => a, __tsplusTrace), __tsplusTrace);
+}
+/**
+ * Returns an IO that effectually "peeks" at the cause of the failure of
+ * this IO.
+ *
+ * @tsplus fluent fncts.io.IO tapCause
+ */
+
+
+function tapCause_(ma, f, __tsplusTrace) {
+  return matchCauseIO_1(ma, c => flatMap_1(f(c), () => failCauseNow_1(c, __tsplusTrace), __tsplusTrace), succeedNow_1, __tsplusTrace);
+}
+/**
+ * Returns an IO that effectfully "peeks" at the failure of this effect.
+ *
+ * @tsplus fluent fncts.io.IO tapError
+ */
+
+
+function tapError_(self, f, __tsplusTrace) {
+  return matchCauseIO_1(self, cause => tsplus_module_6.match_(tsplus_module_5.failureOrCause(cause), e => flatMap_1(f(e), () => failCauseNow_1(cause, __tsplusTrace), __tsplusTrace), _ => failCauseNow_1(cause, __tsplusTrace)), succeedNow_1, __tsplusTrace);
+}
+/**
+ * Returns an effect that effectually "peeks" at the cause of the failure of
+ * this effect.
+ *
+ * @tsplus fluent fncts.io.IO tapErrorCause
+ */
+
+
+function tapErrorCause_(self, f, __tsplusTrace) {
+  return matchCauseIO_1(self, cause => apSecond_1(f(cause), failCauseNow_1(cause, __tsplusTrace), __tsplusTrace), succeedNow_1, __tsplusTrace);
+}
+/**
+ * @tsplus fluent fncts.io.IO tryOrElse
+ */
+
+
+function tryOrElse_1(ma, that, onSuccess, __tsplusTrace) {
+  return matchCauseIO_1(ma, cause => tsplus_module_4.match_(tsplus_module_5.keepDefects(cause), that, failCauseNow_1), onSuccess, __tsplusTrace);
+}
+/**
+ * @tsplus static fncts.io.IOOps unit
+ */
+
+
+const unit_1 = /*#__PURE__*/succeedNow_1(undefined, fileName_1 + ":1962:45");
+const unit = unit_1;
+/**
+ * Converts an option on errors into an option on values.
+ *
+ * @tsplus getter fncts.io.IO unjust
+ */
+
+exports.unit = unit;
+
+function unjust(self) {
+  return matchIO_1(self, e => tsplus_module_4.match_(e, () => succeedNow_1(tsplus_module_2.nothing(), fileName_1 + ":1971:39"), failNow_1), a => succeedNow_1(tsplus_module_2.just(a), fileName_1 + ":1972:25"), fileName_1 + ":1970:22");
+}
+/**
+ * Takes some fiber failures and converts them into errors, using the
+ * specified function to convert the `E` into an `E1 | E2`.
+ *
+ * @tsplus fluent fncts.io.IO unrefineWith
+ */
+
+
+function unrefineWith_1(fa, pf, f, __tsplusTrace) {
+  return catchAllCause_1(fa, cause => tsplus_module_4.match_(tsplus_module_5.find_(cause, c => tsplus_module_5.isHalt(c) ? pf(c.value) : tsplus_module_2.nothing()), () => failCauseNow_1(tsplus_module_5.map_(cause, f), __tsplusTrace), failNow_1), __tsplusTrace);
+}
+/**
+ * The inverse operation `sandbox`
+ *
+ * @tsplus getter fncts.io.IO unsandbox
+ */
+
+
+function unsandbox_1(ma) {
+  return mapErrorCause_1(ma, cause => tsplus_module_5.flatten(cause), fileName_1 + ":1999:26");
+}
+/**
+ * Updates the `FiberRef` values for the fiber running this effect using the
+ * specified function
+ *
+ * @tsplus static fncts.io.IOOps updateFiberRefs
+ */
+
+
+function updateFiberRefs(f, __tsplusTrace) {
+  return new _definition2.FiberRefModifyAll((fiberId, fiberRefs) => [undefined, f(fiberId, fiberRefs)], __tsplusTrace);
+}
+/**
+ * @tsplus fluent fncts.io.IO __call
+ */
+
+
+const via = _function.pipe;
+/**
+ * @tsplus fluent fncts.io.IO when
+ */
+
+exports.via = via;
+
+function when_(ma, b, __tsplusTrace) {
+  return whenIO_1(ma, succeed_1(b, __tsplusTrace));
+}
+/**
+ * The moral equivalent of `if (p) exp` when `p` has side-effects
+ *
+ * @tsplus fluent fncts.io.IO whenIO
+ */
+
+
+function whenIO_1(ma, mb) {
+  return flatMap_1(mb, b => b ? asUnit_1(ma) : unit_1, fileName_1 + ":2033:20");
+}
+/**
+ * Returns an effect that yields to the runtime system, starting on a fresh
+ * stack. Manual use of this method can improve fairness, at the cost of
+ * overhead.
+ *
+ * @tsplus static fncts.io.IOOps yieldNow
+ */
+
+
+const yieldNow_1 = /*#__PURE__*/new _definition2.Yield();
+const yieldNow = yieldNow_1;
+/**
+ * @tsplus fluent fncts.io.IO zip
+ */
+
+exports.yieldNow = yieldNow;
+
+function zip_(self, that) {
+  return zipWith_1(self, that, _function.tuple);
+}
+/**
+ * @tsplus fluent fncts.io.IO zipWith
+ */
+
+
+function zipWith_1(self, that, f) {
+  return flatMap_1(self, a => map_1(that, b => f(a, b), fileName_1 + ":2060:38"), fileName_1 + ":2060:22");
+}
+
+class GenIO {
+  constructor(effect, _trace) {
+    this.effect = effect;
+    this._trace = _trace;
+  }
+
+  *[Symbol.iterator]() {
+    return yield this;
+  }
+
+}
+/**
+ * @internal
+ */
+
+
+exports.GenIO = GenIO;
+
+const __adapter = _ => {
+  // if (Either.isEither(_)) {
+  //   return IO.fromEither(_);
+  // }
+  // if (Maybe.isMaybe(_)) {
+  //   return __
+  //     ? _._tag === "Nothing"
+  //       ? IO.failNow(__())
+  //       : IO.succeed(_.value)
+  //     : getOrFail(_);
+  // }
+  // if (isTag(_)) {
+  //   return service(_);
+  // }
+  // if (S.isSync(_)) {
+  //   return fromSync(_);
+  // }
+  return _;
+};
+
+exports.__adapter = __adapter;
+
+const adapter = (_, __tsplusTrace) => {
+  return new GenIO(__adapter(_), __tsplusTrace);
+};
+/**
+ * @tsplus static fncts.io.IOOps gen
+ * @gen
+ */
+
+
+function gen_1(f) {
+  return defer_1(() => {
+    const iterator = f(adapter);
+    const state = iterator.next();
+
+    const run = state => {
+      if (state.done) {
+        return succeed_1(() => state.value, fileName_1 + ":2115:26");
+      }
+
+      const f = val => {
+        const next = iterator.next(val);
+        return run(next);
+      };
+
+      return flatMap_1(state.value.effect, f, fileName_1 + ":2121:40");
+    };
+
+    return run(state);
+  }, fileName_1 + ":2109:18");
+}
+//# sourceMappingURL=api.cjs.map