@fncts/io 0.0.1

package/_mjs/Channel/api.mjs

@@ -0,0 +1,727 @@
+const fileName_1 = "(@fncts/io) src/Channel/api.ts";
+import * as tsplus_module_1 from "@fncts/io/Channel/core-api";
+import * as tsplus_module_2 from "@fncts/io/IO/api/environment";
+import * as tsplus_module_3 from "@fncts/io/Ref/api/get";
+import * as tsplus_module_4 from "@fncts/io/IO/api";
+import * as tsplus_module_5 from "@fncts/io/IO/api/interrupt";
+import * as tsplus_module_6 from "@fncts/io/Ref/api/set";
+import * as tsplus_module_7 from "@fncts/io/Ref/constructors";
+import * as tsplus_module_8 from "@fncts/io/Ref/api/modify";
+import * as tsplus_module_9 from "@fncts/base/collection/immutable/Conc/api/empty";
+import * as tsplus_module_10 from "@fncts/base/collection/immutable/Conc/api";
+import * as tsplus_module_11 from "@fncts/base/data/Cause/api";
+import * as tsplus_module_12 from "@fncts/base/data/Either/destructors";
+import * as tsplus_module_13 from "@fncts/base/data/Maybe/constructors";
+import * as tsplus_module_14 from "@fncts/io/Channel/UpstreamPullStrategy/definition";
+import * as tsplus_module_15 from "@fncts/io/Channel/ChildExecutorDecision/definition";
+import * as tsplus_module_16 from "@fncts/base/data/Maybe/destructors";
+import * as tsplus_module_17 from "@fncts/base/data/Exit/api";
+import * as tsplus_module_18 from "@fncts/io/Queue/api/operations";
+import * as tsplus_module_19 from "@fncts/base/data/Exit/constructors";
+import * as tsplus_module_20 from "@fncts/io/Scope/api";
+import * as tsplus_module_21 from "@fncts/base/util/predicates";
+import * as tsplus_module_22 from "@fncts/base/data/Either/constructors";
+import * as tsplus_module_23 from "@fncts/base/collection/immutable/Conc/constructors";
+export const as_ = as_1;
+export const ask = ask_1;
+export const acquireReleaseExitWith_ = acquireReleaseExitWith_1;
+export const acquireReleaseOutExit_ = acquireReleaseOutExit_1;
+export const buffer = buffer_1;
+export const catchAll_ = catchAll_1;
+export const catchAllCause_ = catchAllCause_1;
+export const concatMapWith_ = concatMapWith_1;
+export const concatAllWith_ = concatAllWith_1;
+export const defer = defer_1;
+export const doneCollect = doneCollect_1;
+export const ensuringWith_ = ensuringWith_1;
+export const failNow = failNow_1;
+export const flatten = flatten_1;
+export const fromInput = fromInput_1;
+export const fromIO = fromIO_1;
+export const fromQueue = fromQueue_1;
+export const provideEnvironment_ = provideEnvironment_1;
+export const haltNow = haltNow_1;
+export const id = id_1;
+export const scoped = scoped_1;
+export const mapErrorCause_ = mapErrorCause_1;
+export const mapIO_ = mapIO_1;
+export const mapOut_ = mapOut_1;
+export const orHaltWith_ = orHaltWith_1;
+export const pipeTo_ = pipeTo_1;
+export const readOrFail = readOrFail_1;
+export const readWithCause = readWithCause_1;
+export const readWith = readWith_1;
+export const repeated = repeated_1;
+export const toQueue = toQueue_1;
+export const write = write_1;
+export const writeChunk = writeChunk_1;
+export const writeNow = writeNow_1;
+export const unwrap = unwrap_1;
+import { identity, tuple } from "@fncts/base/data/function";
+import { BracketOut, Bridge, ConcatAll, ContinuationK, Defer, Emit, Ensuring, Fail, Fold, FromIO, PipeTo, Provide, Read } from "@fncts/io/Channel/definition";
+/**
+ * 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
+ */
+
+
+export function asUnit(self) {
+  return as_1(self, () => undefined);
+}
+/**
+ * @tsplus static fncts.io.ChannelOps acquireReleaseWith
+ */
+
+export 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
+ */
+
+
+export 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 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 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 tuple(tsplus_module_1.apSecond_(writeNow_1(v), buffer_1(empty, isEmpty, ref)), empty);
+    }
+  }));
+}
+/**
+ * @tsplus static fncts.io.ChannelOps bufferChunk
+ */
+
+
+export 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 Fold(self, new ContinuationK(_ => tsplus_module_1.endNow(_), f));
+}
+/**
+ * @tsplus getter fncts.io.Channel concatAll
+ */
+
+
+export 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 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
+ */
+
+
+export function concatMapWithCustom_(channel, f, g, h, onPull, onEmit) {
+  return new 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 ConcatAll(f, g, () => tsplus_module_14.PullAfterNext(tsplus_module_13.nothing()), () => tsplus_module_15.Continue, channels, 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
+ */
+
+
+export 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
+ */
+
+
+export 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
+ */
+
+
+export 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
+ */
+
+
+export 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
+ */
+
+
+export function contramapInIO_(self, f) {
+  return pipeTo_1(contramapInIOReader(f), self);
+}
+/**
+ * @tsplus static fncts.io.ChannelOps defer
+ */
+
+function defer_1(effect) {
+  return new 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(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
+ */
+
+
+export 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
+ */
+
+export function emitCollect(self) {
+  return tsplus_module_1.flatMap_(doneCollect_1(self), t => writeNow_1(t));
+}
+/**
+ * @tsplus fluent fncts.io.Channel ensuring
+ */
+
+export 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 Ensuring(channel, finalizer);
+}
+/**
+ * Embed inputs from continuos pulling of a producer
+ *
+ * @tsplus fluent fncts.io.Channel embedInput
+ */
+
+
+export function embedInput_(self, input) {
+  return new Bridge(input, self);
+}
+/**
+ * Halt a channel with the specified error
+ *
+ * @tsplus static fncts.io.ChannelOps fail
+ */
+
+export function fail(error) {
+  return new 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 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, identity);
+}
+/**
+ * @tsplus static fncts.io.ChannelOps fromEither
+ */
+
+
+export 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 FromIO(io);
+}
+/**
+ * @tsplus static fncts.io.ChannelOps fromOption
+ */
+
+
+export 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 Provide(env, self);
+}
+/**
+ * @tsplus fluent fncts.io.Channel contramapEnvironment
+ */
+
+
+export 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 Fail(() => tsplus_module_11.halt(defect));
+}
+/**
+ * Halt a channel with the specified exception
+ *
+ * @tsplus static fncts.io.ChannelOps halt
+ */
+
+
+export function halt(defect) {
+  return new 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
+ */
+
+
+export 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(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
+ */
+
+
+export 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
+ */
+
+
+export 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
+ */
+
+export function matchCauseChannel_(channel, onError, onSuccess) {
+  return new Fold(channel, new ContinuationK(onSuccess, onError));
+}
+export 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
+ */
+
+export function orElse_(self, that) {
+  return catchAll_1(self, _ => that);
+}
+/**
+ * @tsplus fluent fncts.io.Channel orHalt
+ */
+
+export 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 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
+ */
+
+
+export 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
+ */
+
+export function read() {
+  return readOrFail_1(tsplus_module_13.nothing());
+}
+/**
+ * @tsplus static fncts.io.ChannelOps readOrFail
+ */
+
+function readOrFail_1(e) {
+  return new Read(tsplus_module_1.endNow, new 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 Read(inp, new 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 Emit(out);
+}
+/**
+ * @tsplus static fncts.io.ChannelOps writeAll
+ */
+
+
+export 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 Emit(() => out);
+}
+/**
+ * @tsplus static fncts.io.ChannelOps unit
+ */
+
+
+const unit_1 = /*#__PURE__*/tsplus_module_1.endNow(undefined);
+export const unit = unit_1;
+/**
+ * Makes a channel from an effect that returns a channel in case of success
+ *
+ * @tsplus static fncts.io.ChannelOps unwrap
+ */
+
+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
+ */
+
+
+export function unwrapScoped(self) {
+  return concatAllWith_1(scoped_1(() => self), (d, _) => d, (d, _) => d);
+}
+//# sourceMappingURL=api.mjs.map