@fncts/io 0.0.1

package/_cjs/Channel/api.cjs

@@ -0,0 +1,875 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.acquireReleaseOutExit_ = exports.acquireReleaseExitWith_ = void 0;
+exports.acquireReleaseOut_ = acquireReleaseOut_;
+exports.acquireReleaseWith_ = acquireReleaseWith_;
+exports.asUnit = asUnit;
+exports.buffer = exports.ask = exports.as_ = void 0;
+exports.bufferChunk = bufferChunk;
+exports.catchAll_ = exports.catchAllCause_ = void 0;
+exports.concatAll = concatAll;
+exports.concatAllWith_ = void 0;
+exports.concatMapWithCustom_ = concatMapWithCustom_;
+exports.concatMapWith_ = void 0;
+exports.concatMap_ = concatMap_;
+exports.contramapEnvironment_ = contramapEnvironment_;
+exports.contramapIO_ = contramapIO_;
+exports.contramapInIO_ = contramapInIO_;
+exports.contramapIn_ = contramapIn_;
+exports.contramap_ = contramap_;
+exports.doneCollect = exports.defer = void 0;
+exports.drain = drain;
+exports.embedInput_ = embedInput_;
+exports.emitCollect = emitCollect;
+exports.ensuringWith_ = void 0;
+exports.ensuring_ = ensuring_;
+exports.fail = fail;
+exports.flatten = exports.failNow = void 0;
+exports.fromEither = fromEither;
+exports.fromInput = exports.fromIO = void 0;
+exports.fromOption = fromOption;
+exports.fromQueue = void 0;
+exports.halt = halt;
+exports.id = exports.haltNow = void 0;
+exports.interrupt = interrupt;
+exports.mapErrorCause_ = void 0;
+exports.mapError_ = mapError_;
+exports.mapIO_ = void 0;
+exports.mapOutIO_ = mapOutIO_;
+exports.mapOut_ = void 0;
+exports.matchCauseChannel_ = matchCauseChannel_;
+exports.never = void 0;
+exports.orElse_ = orElse_;
+exports.orHaltWith_ = void 0;
+exports.orHalt_ = orHalt_;
+exports.pipeToOrFail_ = pipeToOrFail_;
+exports.provideEnvironment_ = exports.pipeTo_ = void 0;
+exports.read = read;
+exports.unwrap = exports.unit = exports.toQueue = exports.scoped = exports.repeated = exports.readWithCause = exports.readWith = exports.readOrFail = void 0;
+exports.unwrapScoped = unwrapScoped;
+exports.write = void 0;
+exports.writeAll = writeAll;
+exports.writeNow = exports.writeChunk = void 0;
+
+var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/Channel/core-api"));
+
+var tsplus_module_2 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/IO/api/environment"));
+
+var tsplus_module_3 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/Ref/api/get"));
+
+var tsplus_module_4 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/IO/api"));
+
+var tsplus_module_5 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/IO/api/interrupt"));
+
+var tsplus_module_6 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/Ref/api/set"));
+
+var tsplus_module_7 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/Ref/constructors"));
+
+var tsplus_module_8 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/Ref/api/modify"));
+
+var tsplus_module_9 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/Conc/api/empty"));
+
+var tsplus_module_10 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/Conc/api"));
+
+var tsplus_module_11 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Cause/api"));
+
+var tsplus_module_12 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Either/destructors"));
+
+var tsplus_module_13 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/constructors"));
+
+var tsplus_module_14 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/Channel/UpstreamPullStrategy/definition"));
+
+var tsplus_module_15 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/Channel/ChildExecutorDecision/definition"));
+
+var tsplus_module_16 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/destructors"));
+
+var tsplus_module_17 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Exit/api"));
+
+var tsplus_module_18 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/Queue/api/operations"));
+
+var tsplus_module_19 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Exit/constructors"));
+
+var tsplus_module_20 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/Scope/api"));
+
+var tsplus_module_21 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/util/predicates"));
+
+var tsplus_module_22 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Either/constructors"));
+
+var tsplus_module_23 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/Conc/constructors"));
+
+var _function = /*#__PURE__*/require("@fncts/base/data/function");
+
+var _definition3 = /*#__PURE__*/require("@fncts/io/Channel/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/Channel/api.ts";
+const as_ = as_1;
+exports.as_ = as_;
+const ask = ask_1;
+exports.ask = ask;
+const acquireReleaseExitWith_ = acquireReleaseExitWith_1;
+exports.acquireReleaseExitWith_ = acquireReleaseExitWith_;
+const acquireReleaseOutExit_ = acquireReleaseOutExit_1;
+exports.acquireReleaseOutExit_ = acquireReleaseOutExit_;
+const buffer = buffer_1;
+exports.buffer = buffer;
+const catchAll_ = catchAll_1;
+exports.catchAll_ = catchAll_;
+const catchAllCause_ = catchAllCause_1;
+exports.catchAllCause_ = catchAllCause_;
+const concatMapWith_ = concatMapWith_1;
+exports.concatMapWith_ = concatMapWith_;
+const concatAllWith_ = concatAllWith_1;
+exports.concatAllWith_ = concatAllWith_;
+const defer = defer_1;
+exports.defer = defer;
+const doneCollect = doneCollect_1;
+exports.doneCollect = doneCollect;
+const ensuringWith_ = ensuringWith_1;
+exports.ensuringWith_ = ensuringWith_;
+const failNow = failNow_1;
+exports.failNow = failNow;
+const flatten = flatten_1;
+exports.flatten = flatten;
+const fromInput = fromInput_1;
+exports.fromInput = fromInput;
+const fromIO = fromIO_1;
+exports.fromIO = fromIO;
+const fromQueue = fromQueue_1;
+exports.fromQueue = fromQueue;
+const provideEnvironment_ = provideEnvironment_1;
+exports.provideEnvironment_ = provideEnvironment_;
+const haltNow = haltNow_1;
+exports.haltNow = haltNow;
+const id = id_1;
+exports.id = id;
+const scoped = scoped_1;
+exports.scoped = scoped;
+const mapErrorCause_ = mapErrorCause_1;
+exports.mapErrorCause_ = mapErrorCause_;
+const mapIO_ = mapIO_1;
+exports.mapIO_ = mapIO_;
+const mapOut_ = mapOut_1;
+exports.mapOut_ = mapOut_;
+const orHaltWith_ = orHaltWith_1;
+exports.orHaltWith_ = orHaltWith_;
+const pipeTo_ = pipeTo_1;
+exports.pipeTo_ = pipeTo_;
+const readOrFail = readOrFail_1;
+exports.readOrFail = readOrFail;
+const readWithCause = readWithCause_1;
+exports.readWithCause = readWithCause;
+const readWith = readWith_1;
+exports.readWith = readWith;
+const repeated = repeated_1;
+exports.repeated = repeated;
+const toQueue = toQueue_1;
+exports.toQueue = toQueue;
+const write = write_1;
+exports.write = write;
+const writeChunk = writeChunk_1;
+exports.writeChunk = writeChunk;
+const writeNow = writeNow_1;
+exports.writeNow = writeNow;
+const unwrap = unwrap_1;
+exports.unwrap = unwrap;
+
+/**
+ * Returns a new channel that is the same as this one, except the terminal value of the channel
+ * is the specified constant value.
+ *
+ * This method produces the same result as mapping this channel to the specified constant value.
+ *
+ * @tsplus fluent fncts.io.Channel as
+ */
+function as_1(self, z2) {
+  return tsplus_module_1.map_(self, () => z2());
+}
+/**
+ * @tsplus static fncts.io.ChannelOps ask
+ */
+
+
+function ask_1() {
+  return fromIO_1(tsplus_module_2.environment(fileName_1 + ":44:39"));
+}
+/**
+ * @tsplus getter fncts.io.Channel asUnit
+ */
+
+
+function asUnit(self) {
+  return as_1(self, () => undefined);
+}
+/**
+ * @tsplus static fncts.io.ChannelOps acquireReleaseWith
+ */
+
+
+function acquireReleaseWith_(acquire, use, release) {
+  return acquireReleaseExitWith_1(acquire, use, (a, _) => release(a));
+}
+/**
+ * @tsplus static fncts.io.ChannelOps acquireReleaseExitWith
+ */
+
+
+function acquireReleaseExitWith_1(acquire, use, release) {
+  return tsplus_module_1.flatMap_(fromIO_1(tsplus_module_7.make(() => _ => tsplus_module_4.unit)), ref => ensuringWith_1(tsplus_module_1.flatMap_(fromIO_1(tsplus_module_5.uninterruptible(tsplus_module_4.tap_(acquire, a => tsplus_module_6.set_(ref, exit => release(a, exit)), fileName_1 + ":76:31"))), use), exit => tsplus_module_4.flatMap_(tsplus_module_3.get(ref), fin => fin(exit), fileName_1 + ":78:46")));
+}
+/**
+ * Construct a resource Channel with Acquire / Release
+ *
+ * @tsplus static fncts.io.ChannelOps acquireReleaseOut
+ */
+
+
+function acquireReleaseOut_(acquire, release) {
+  return acquireReleaseOutExit_1(acquire, (z, _) => release(z));
+}
+/**
+ * Construct a resource Channel with Acquire / Release
+ *
+ * @tsplus static fncts.io.ChannelOps acquireReleaseOutExit
+ */
+
+
+function acquireReleaseOutExit_1(self, release) {
+  return new _definition3.BracketOut(self, release);
+}
+/**
+ * Creates a channel backed by a buffer. When the buffer is empty, the channel will simply
+ * passthrough its input as output. However, when the buffer is non-empty, the value inside
+ * the buffer will be passed along as output.
+ *
+ * @tsplus static fncts.io.ChannelOps buffer
+ */
+
+
+function buffer_1(empty, isEmpty, ref) {
+  return unwrap_1(tsplus_module_8.modify_(ref, v => {
+    if (isEmpty(v)) {
+      return (0, _function.tuple)(readWith_1(_in => tsplus_module_1.apSecond_(writeNow_1(_in), buffer_1(empty, isEmpty, ref)), failNow_1, tsplus_module_1.endNow), v);
+    } else {
+      return (0, _function.tuple)(tsplus_module_1.apSecond_(writeNow_1(v), buffer_1(empty, isEmpty, ref)), empty);
+    }
+  }));
+}
+/**
+ * @tsplus static fncts.io.ChannelOps bufferChunk
+ */
+
+
+function bufferChunk(ref) {
+  return buffer_1(tsplus_module_9.empty(), conc => tsplus_module_10.isEmpty(conc), ref);
+}
+/**
+ * Returns a new channel that is the same as this one, except if this channel errors for any
+ * typed error, then the returned channel will switch over to using the fallback channel returned
+ * by the specified error handler.
+ *
+ * @tsplus fluent fncts.io.Channel catchAll
+ */
+
+
+function catchAll_1(self, f) {
+  return catchAllCause_1(self, cause => tsplus_module_12.match_(tsplus_module_11.failureOrCause(cause), l => f(l), r => tsplus_module_1.failCauseNow(r)));
+}
+/**
+ * Returns a new channel that is the same as this one, except if this channel errors for any
+ * typed error, then the returned channel will switch over to using the fallback channel returned
+ * by the specified error handler.
+ *
+ * @tsplus fluent fncts.io.Channel catchAllCause
+ */
+
+
+function catchAllCause_1(self, f) {
+  return new _definition3.Fold(self, new _definition3.ContinuationK(_ => tsplus_module_1.endNow(_), f));
+}
+/**
+ * @tsplus getter fncts.io.Channel concatAll
+ */
+
+
+function concatAll(channels) {
+  return concatAllWith_1(channels, () => void 0, () => void 0);
+}
+/**
+ * Returns a new channel whose outputs are fed to the specified factory function, which creates
+ * new channels in response. These new channels are sequentially concatenated together, and all
+ * their outputs appear as outputs of the newly returned channel. The provided merging function
+ * is used to merge the terminal values of all channels into the single terminal value of the
+ * returned channel.
+ *
+ * @tsplus fluent fncts.io.Channel concatMapWith
+ */
+
+
+function concatMapWith_1(channel, f, g, h) {
+  return new _definition3.ConcatAll(g, h, () => tsplus_module_14.PullAfterNext(tsplus_module_13.nothing()), () => tsplus_module_15.Continue, channel, f);
+}
+/**
+ * Returns a new channel whose outputs are fed to the specified factory function, which creates
+ * new channels in response. These new channels are sequentially concatenated together, and all
+ * their outputs appear as outputs of the newly returned channel. The provided merging function
+ * is used to merge the terminal values of all channels into the single terminal value of the
+ * returned channel.
+ *
+ * @tsplus fluent fncts.io.Channel concatMapWithCustom
+ */
+
+
+function concatMapWithCustom_(channel, f, g, h, onPull, onEmit) {
+  return new _definition3.ConcatAll(g, h, onPull, onEmit, channel, f);
+}
+/**
+ * Concat sequentially a channel of channels
+ *
+ * @tsplus fluent fncts.io.Channel concatAllWith
+ */
+
+
+function concatAllWith_1(channels, f, g) {
+  return new _definition3.ConcatAll(f, g, () => tsplus_module_14.PullAfterNext(tsplus_module_13.nothing()), () => tsplus_module_15.Continue, channels, _function.identity);
+}
+/**
+ * Returns a new channel whose outputs are fed to the specified factory function, which creates
+ * new channels in response. These new channels are sequentially concatenated together, and all
+ * their outputs appear as outputs of the newly returned channel.
+ *
+ * @tsplus fluent fncts.io.Channel concatMap
+ */
+
+
+function concatMap_(self, f) {
+  return concatMapWith_1(self, f, () => void 0, () => void 0);
+}
+
+function contramapReader(f) {
+  return readWith_1(_in => tsplus_module_1.apSecond_(writeNow_1(_in), contramapReader(f)), failNow_1, done => tsplus_module_1.endNow(f(done)));
+}
+/**
+ * @tsplus fluent fncts.io.Channel contramap
+ */
+
+
+function contramap_(self, f) {
+  return pipeTo_1(contramapReader(f), self);
+}
+
+function contramapInReader(f) {
+  return readWith_1(_in => tsplus_module_1.apSecond_(writeNow_1(f(_in)), contramapInReader(f)), failNow_1, done => tsplus_module_1.endNow(done));
+}
+/**
+ * @tsplus fluent fncts.io.Channel contramapIn
+ */
+
+
+function contramapIn_(self, f) {
+  return pipeTo_1(contramapInReader(f), self);
+}
+
+function contramapIOReader(f) {
+  return readWith_1(_in => tsplus_module_1.apSecond_(writeNow_1(_in), contramapIOReader(f)), failNow_1, done0 => fromIO_1(f(done0)));
+}
+/**
+ * @tsplus fluent fncts.io.Channel contramapIO
+ */
+
+
+function contramapIO_(self, f) {
+  return pipeTo_1(contramapIOReader(f), self);
+}
+
+function contramapInIOReader(f) {
+  return readWith_1(inp => tsplus_module_1.apSecond_(tsplus_module_1.flatMap_(fromIO_1(f(inp)), writeNow_1), contramapInIOReader(f)), failNow_1, tsplus_module_1.endNow);
+}
+/**
+ * @tsplus fluent fncts.io.Channel contramapInIO
+ */
+
+
+function contramapInIO_(self, f) {
+  return pipeTo_1(contramapInIOReader(f), self);
+}
+/**
+ * @tsplus static fncts.io.ChannelOps defer
+ */
+
+
+function defer_1(effect) {
+  return new _definition3.Defer(effect);
+}
+
+function doneCollectReader(builder) {
+  return readWith_1(out => tsplus_module_1.apSecond_(fromIO_1(tsplus_module_4.succeed(() => {
+    builder.append(out);
+  }, fileName_1 + ":527:19")), doneCollectReader(builder)), failNow_1, tsplus_module_1.endNow);
+}
+/**
+ * Returns a new channel, which is the same as this one, except that all the outputs are
+ * collected and bundled into a tuple together with the terminal value of this channel.
+ *
+ * As the channel returned from this channel collects all of this channels output into an in-
+ * memory chunk, it is not safe to call this method on channels that output a large or unbounded
+ * number of values.
+ *
+ * @tsplus getter fncts.io.Channel doneCollect
+ */
+
+
+function doneCollect_1(self) {
+  return unwrap_1(tsplus_module_4.succeed(() => {
+    const builder = tsplus_module_10.builder();
+    return mapIO_1(pipeTo_1(self, doneCollectReader(builder)), z => tsplus_module_4.succeedNow((0, _function.tuple)(builder.result(), z), fileName_1 + ":553:80"));
+  }, fileName_1 + ":550:15"));
+}
+/**
+ * Returns a new channel which reads all the elements from upstream's output channel
+ * and ignores them, then terminates with the upstream result value.
+ *
+ * @tsplus getter fncts.io.Channel drain
+ */
+
+
+function drain(channel) {
+  const drainer = readWithCause_1(_ => drainer, tsplus_module_1.failCauseNow, tsplus_module_1.endNow);
+  return pipeTo_1(channel, drainer);
+}
+/**
+ * Returns a new channel that collects the output and terminal value of this channel, which it
+ * then writes as output of the returned channel.
+ *
+ * @tsplus getter fncts.io.Channel emitCollect
+ */
+
+
+function emitCollect(self) {
+  return tsplus_module_1.flatMap_(doneCollect_1(self), t => writeNow_1(t));
+}
+/**
+ * @tsplus fluent fncts.io.Channel ensuring
+ */
+
+
+function ensuring_(self, finalizer) {
+  return ensuringWith_1(self, () => finalizer);
+}
+/**
+ * Returns a new channel with an attached finalizer. The finalizer is guaranteed to be executed
+ * so long as the channel begins execution (and regardless of whether or not it completes).
+ *
+ * @tsplus fluent fncts.io.Channel ensuringWith
+ */
+
+
+function ensuringWith_1(channel, finalizer) {
+  return new _definition3.Ensuring(channel, finalizer);
+}
+/**
+ * Embed inputs from continuos pulling of a producer
+ *
+ * @tsplus fluent fncts.io.Channel embedInput
+ */
+
+
+function embedInput_(self, input) {
+  return new _definition3.Bridge(input, self);
+}
+/**
+ * Halt a channel with the specified error
+ *
+ * @tsplus static fncts.io.ChannelOps fail
+ */
+
+
+function fail(error) {
+  return new _definition3.Fail(() => tsplus_module_11.fail(error()));
+}
+/**
+ * Halt a channel with the specified error
+ *
+ * @tsplus static fncts.io.ChannelOps failNow
+ */
+
+
+function failNow_1(error) {
+  return new _definition3.Fail(() => tsplus_module_11.fail(error));
+}
+/**
+ * Returns a new channel, which flattens the terminal value of this channel. This function may
+ * only be called if the terminal value of this channel is another channel of compatible types.
+ *
+ * @tsplus getter fncts.io.Channel flatten
+ */
+
+
+function flatten_1(self) {
+  return tsplus_module_1.flatMap_(self, _function.identity);
+}
+/**
+ * @tsplus static fncts.io.ChannelOps fromEither
+ */
+
+
+function fromEither(either) {
+  return defer_1(() => tsplus_module_12.match_(either(), failNow_1, tsplus_module_1.succeedNow));
+}
+/**
+ * @tsplus static fncts.io.ChannelOps fromInput
+ */
+
+
+function fromInput_1(input) {
+  return unwrap_1(input.takeWith(tsplus_module_1.failCauseNow, elem => tsplus_module_1.apSecond_(writeNow_1(elem), fromInput_1(input)), tsplus_module_1.endNow));
+}
+/**
+ * Use an effect to end a channel
+ *
+ * @tsplus static fncts.io.ChannelOps fromIO
+ */
+
+
+function fromIO_1(io) {
+  return new _definition3.FromIO(io);
+}
+/**
+ * @tsplus static fncts.io.ChannelOps fromOption
+ */
+
+
+function fromOption(option) {
+  return defer_1(() => tsplus_module_16.match_(option(), () => failNow_1(tsplus_module_13.nothing()), tsplus_module_1.succeedNow));
+}
+/**
+ * @tsplus static fncts.io.ChannelOps fromQueue
+ */
+
+
+function fromQueue_1(queue) {
+  return tsplus_module_1.flatMap_(fromIO_1(tsplus_module_18.take(queue)), _ => tsplus_module_12.match_(_, _ => tsplus_module_17.match_(_, tsplus_module_1.failCauseNow, tsplus_module_1.endNow), elem => tsplus_module_1.apSecond_(writeNow_1(elem), fromQueue_1(queue))));
+}
+/**
+ * Provides the channel with its required environment, which eliminates
+ * its dependency on `Env`.
+ *
+ * @tsplus fluent fncts.io.Channel provideEnvironment
+ */
+
+
+function provideEnvironment_1(self, env) {
+  return new _definition3.Provide(env, self);
+}
+/**
+ * @tsplus fluent fncts.io.Channel contramapEnvironment
+ */
+
+
+function contramapEnvironment_(self, f) {
+  return tsplus_module_1.flatMap_(ask_1(), env0 => provideEnvironment_1(self, f(env0)));
+}
+/**
+ * Halt a channel with the specified exception
+ *
+ * @tsplus static fncts.io.ChannelOps haltNow
+ */
+
+
+function haltNow_1(defect) {
+  return new _definition3.Fail(() => tsplus_module_11.halt(defect));
+}
+/**
+ * Halt a channel with the specified exception
+ *
+ * @tsplus static fncts.io.ChannelOps halt
+ */
+
+
+function halt(defect) {
+  return new _definition3.Fail(() => tsplus_module_11.halt(defect()));
+}
+/**
+ * @tsplus static fncts.io.ChannelOps id
+ */
+
+
+function id_1() {
+  return readWith_1(_in => tsplus_module_1.apSecond_(write_1(() => _in), id_1()), failNow_1, tsplus_module_1.endNow);
+}
+/**
+ * @tsplus static fncts.io.ChannelOps interrupt
+ */
+
+
+function interrupt(fiberId) {
+  return tsplus_module_1.failCauseNow(tsplus_module_11.interrupt(fiberId));
+}
+/**
+ * Use a managed to emit an output element
+ *
+ * @tsplus static fncts.io.ChannelOps scoped
+ */
+
+
+function scoped_1(io) {
+  return mapOut_1(acquireReleaseOutExit_1(tsplus_module_4.flatMap_(tsplus_module_20.make, scope => tsplus_module_5.uninterruptibleMask(({
+    restore
+  }) => tsplus_module_4.matchCauseIO_(restore(tsplus_module_20.extend_(scope, io)), cause => tsplus_module_4.apSecond_(scope.close(() => tsplus_module_19.failCause(cause)), tsplus_module_4.failCauseNow(cause, fileName_1 + ":797:74"), fileName_1 + ":797:58"), out => tsplus_module_4.succeedNow((0, _function.tuple)(out, scope), fileName_1 + ":798:33"), fileName_1 + ":796:47")), fileName_1 + ":794:23"), ([_, scope], exit) => scope.close(() => exit)), ([a]) => a);
+}
+/**
+ * Returns a new channel, which is the same as this one, except the failure value of the returned
+ * channel is created by applying the specified function to the failure value of this channel.
+ *
+ * @tsplus fluent fncts.io.Channel mapError
+ */
+
+
+function mapError_(self, f) {
+  return mapErrorCause_1(self, cause => tsplus_module_11.map_(cause, f));
+}
+/**
+ * A more powerful version of `mapError` which also surfaces the `Cause` of the channel failure
+ *
+ * @tsplus fluent fncts.io.Channel mapErrorCause
+ */
+
+
+function mapErrorCause_1(self, f) {
+  return catchAllCause_1(self, cause => tsplus_module_1.failCauseNow(f(cause)));
+}
+/**
+ * Returns a new channel, which is the same as this one, except the terminal value of the
+ * returned channel is created by applying the specified effectful function to the terminal value
+ * of this channel.
+ *
+ * @tsplus fluent fncts.io.Channel mapIO
+ */
+
+
+function mapIO_1(self, f) {
+  return tsplus_module_1.flatMap_(self, outDone => fromIO_1(f(outDone)));
+}
+/**
+ * Maps the output of this channel using f
+ *
+ * @tsplus fluent fncts.io.Channel mapOut
+ */
+
+
+function mapOut_1(self, f) {
+  const reader = readWith_1(out => tsplus_module_1.apSecond_(writeNow_1(f(out)), reader), failNow_1, tsplus_module_1.endNow);
+  return pipeTo_1(self, reader);
+}
+
+const mapOutIOReader = f => readWith_1(out => tsplus_module_1.apSecond_(tsplus_module_1.flatMap_(fromIO_1(f(out)), writeNow_1), mapOutIOReader(f)), failNow_1, tsplus_module_1.endNow);
+/**
+ * @tsplus fluent fncts.io.Channel mapOutIO
+ */
+
+
+function mapOutIO_(self, f) {
+  return pipeTo_1(self, mapOutIOReader(f));
+}
+/**
+ * Fold the channel exposing success and full error cause
+ *
+ * @tsplus fluent fncts.io.Channel matchCauseChannel
+ */
+
+
+function matchCauseChannel_(channel, onError, onSuccess) {
+  return new _definition3.Fold(channel, new _definition3.ContinuationK(onSuccess, onError));
+}
+
+const never = /*#__PURE__*/fromIO_1(tsplus_module_4.never);
+/**
+ * Returns a new channel that will perform the operations of this one, until failure, and then
+ * it will switch over to the operations of the specified fallback channel.
+ *
+ * @tsplus fluent fncts.io.Channel orElse
+ */
+
+exports.never = never;
+
+function orElse_(self, that) {
+  return catchAll_1(self, _ => that);
+}
+/**
+ * @tsplus fluent fncts.io.Channel orHalt
+ */
+
+
+function orHalt_(self, err) {
+  return orHaltWith_1(self, () => err);
+}
+/**
+ * @tsplus fluent fncts.io.Channel orHaltWith
+ */
+
+
+function orHaltWith_1(self, f) {
+  return catchAll_1(self, e => haltNow_1(f(e)));
+}
+/**
+ * Pipe the output of a channel into the input of another
+ *
+ * @tsplus fluent fncts.io.Channel pipeTo
+ */
+
+
+function pipeTo_1(left, right) {
+  return new _definition3.PipeTo(() => left, () => right);
+}
+
+const ChannelFailureTypeId = /*#__PURE__*/Symbol.for("@principia/base/Channel/ChannelFailure");
+
+class ChannelFailure {
+  constructor(error) {
+    this.error = error;
+    this._typeId = ChannelFailureTypeId;
+  }
+
+}
+
+function isChannelFailure(u) {
+  return tsplus_module_21.hasTypeId(u, ChannelFailureTypeId);
+}
+/**
+ * @tsplus fluent fncts.io.Channel pipeToOrFail
+ */
+
+
+function pipeToOrFail_(left, right) {
+  return catchAllCause_1(pipeTo_1(catchAll_1(left, err => tsplus_module_1.failCauseNow(tsplus_module_11.halt(new ChannelFailure(err)))), right), cause => tsplus_module_11.isHalt(cause) && isChannelFailure(cause.value) ? failNow_1(cause.value.error) : haltNow_1(cause));
+}
+/**
+ * @tsplus static fncts.io.ChannelOps read
+ */
+
+
+function read() {
+  return readOrFail_1(tsplus_module_13.nothing());
+}
+/**
+ * @tsplus static fncts.io.ChannelOps readOrFail
+ */
+
+
+function readOrFail_1(e) {
+  return new _definition3.Read(tsplus_module_1.endNow, new _definition3.ContinuationK(() => failNow_1(e), () => failNow_1(e)));
+}
+/**
+ * Reads an input and continue exposing both full error cause and completion
+ *
+ * @tsplus static fncts.io.ChannelOps readWithCause
+ */
+
+
+function readWithCause_1(inp, halt, done) {
+  return new _definition3.Read(inp, new _definition3.ContinuationK(done, halt));
+}
+/**
+ * Reads an input and continue exposing both error and completion
+ *
+ * @tsplus static fncts.io.ChannelOps readWith
+ */
+
+
+function readWith_1(inp, error, done) {
+  return readWithCause_1(inp, c => tsplus_module_12.match_(tsplus_module_11.failureOrCause(c), error, tsplus_module_1.failCauseNow), done);
+}
+/**
+ * Repeats this channel forever
+ *
+ * @tsplus getter fncts.io.Channel repeated
+ */
+
+
+function repeated_1(self) {
+  return tsplus_module_1.flatMap_(self, () => repeated_1(self));
+}
+/**
+ * @tsplus static fncts.io.Channel toQueue
+ */
+
+
+function toQueue_1(queue) {
+  return readWithCause_1(in_ => tsplus_module_1.apSecond_(fromIO_1(tsplus_module_18.offer_(queue, tsplus_module_22.right(in_))), toQueue_1(queue)), cause => fromIO_1(tsplus_module_18.offer_(queue, tsplus_module_22.left(tsplus_module_19.failCause(cause)))), done => fromIO_1(tsplus_module_18.offer_(queue, tsplus_module_22.left(tsplus_module_19.succeed(done)))));
+}
+/**
+ * Writes an output to the channel
+ *
+ * @tsplus static fncts.io.ChannelOps write
+ */
+
+
+function write_1(out) {
+  return new _definition3.Emit(out);
+}
+/**
+ * @tsplus static fncts.io.ChannelOps writeAll
+ */
+
+
+function writeAll(outs) {
+  return writeChunk_1(tsplus_module_23.from(outs));
+}
+
+function writeChunkWriter(outs, idx, len) {
+  if (idx === len) return unit_1;
+  return tsplus_module_1.apSecond_(writeNow_1(tsplus_module_10.unsafeGet_(outs, idx)), writeChunkWriter(outs, idx + 1, len));
+}
+/**
+ * @tsplus static fncts.io.ChannelOps writeChunk
+ */
+
+
+function writeChunk_1(outs) {
+  return writeChunkWriter(outs, 0, outs.length);
+}
+/**
+ * Writes an output to the channel
+ *
+ * @tsplus static fncts.io.ChannelOps writeNow
+ */
+
+
+function writeNow_1(out) {
+  return new _definition3.Emit(() => out);
+}
+/**
+ * @tsplus static fncts.io.ChannelOps unit
+ */
+
+
+const unit_1 = /*#__PURE__*/tsplus_module_1.endNow(undefined);
+const unit = unit_1;
+/**
+ * Makes a channel from an effect that returns a channel in case of success
+ *
+ * @tsplus static fncts.io.ChannelOps unwrap
+ */
+
+exports.unit = unit;
+
+function unwrap_1(self) {
+  return flatten_1(fromIO_1(self));
+}
+/**
+ * Makes a channel from a managed that returns a channel in case of success
+ *
+ * @tsplus static fncts.io.ChannelOps unwrapScoped
+ */
+
+
+function unwrapScoped(self) {
+  return concatAllWith_1(scoped_1(() => self), (d, _) => d, (d, _) => d);
+}
+//# sourceMappingURL=api.cjs.map