effect 2.3.7 → 2.4.0

package/dist/esm/internal/stream.js

@@ -39,7 +39,7 @@ import * as pull from "./stream/pull.js";
 import * as SinkEndReason from "./stream/sinkEndReason.js";
 import * as ZipAllState from "./stream/zipAllState.js";
 import * as ZipChunksState from "./stream/zipChunksState.js";
-import * as _take from "./take.js";
+import * as InternalTake from "./take.js";
 /** @internal */
 const StreamSymbolKey = "effect/Stream";
 /** @internal */
@@ -162,19 +162,35 @@ export const aggregateWithinEither = /*#__PURE__*/dual(3, (self, sink, schedule)
 /** @internal */
 export const as = /*#__PURE__*/dual(2, (self, value) => map(self, () => value));
 /** @internal */
-export const _async = (register, outputBuffer = 16) => asyncOption(cb => {
-  register(cb);
-  return Option.none();
-}, outputBuffer);
+export const _async = (register, outputBuffer = 16) => Effect.acquireRelease(Queue.bounded(outputBuffer), queue => Queue.shutdown(queue)).pipe(Effect.flatMap(output => Effect.runtime().pipe(Effect.flatMap(runtime => Effect.sync(() => {
+  const runPromiseExit = Runtime.runPromiseExit(runtime);
+  const canceler = register(emit.make(resume => InternalTake.fromPull(resume).pipe(Effect.flatMap(take => Queue.offer(output, take)), Effect.asUnit, runPromiseExit).then(exit => {
+    if (Exit.isFailure(exit)) {
+      if (!Cause.isInterrupted(exit.cause)) {
+        throw Cause.squash(exit.cause);
+      }
+    }
+  })));
+  return canceler;
+})), Effect.map(value => {
+  const loop = Queue.take(output).pipe(Effect.flatMap(take => InternalTake.done(take)), Effect.match({
+    onFailure: maybeError => core.fromEffect(Queue.shutdown(output)).pipe(channel.zipRight(Option.match(maybeError, {
+      onNone: () => core.unit,
+      onSome: error => core.fail(error)
+    }))),
+    onSuccess: chunk => core.write(chunk).pipe(core.flatMap(() => loop))
+  }), channel.unwrap);
+  return fromChannel(loop).pipe(ensuring(value ?? Effect.unit));
+}))), unwrapScoped);
 /** @internal */
-export const asyncEffect = (register, outputBuffer = 16) => pipe(Effect.acquireRelease(Queue.bounded(outputBuffer), queue => Queue.shutdown(queue)), Effect.flatMap(output => pipe(Effect.runtime(), Effect.flatMap(runtime => pipe(register(emit.make(k => pipe(_take.fromPull(k), Effect.flatMap(take => Queue.offer(output, take)), Effect.asUnit, Runtime.runPromiseExit(runtime)).then(exit => {
+export const asyncEffect = (register, outputBuffer = 16) => pipe(Effect.acquireRelease(Queue.bounded(outputBuffer), queue => Queue.shutdown(queue)), Effect.flatMap(output => pipe(Effect.runtime(), Effect.flatMap(runtime => pipe(register(emit.make(k => pipe(InternalTake.fromPull(k), Effect.flatMap(take => Queue.offer(output, take)), Effect.asUnit, Runtime.runPromiseExit(runtime)).then(exit => {
   if (Exit.isFailure(exit)) {
     if (!Cause.isInterrupted(exit.cause)) {
       throw Cause.squash(exit.cause);
     }
   }
 }))), Effect.map(() => {
-  const loop = pipe(Queue.take(output), Effect.flatMap(_take.done), Effect.match({
+  const loop = pipe(Queue.take(output), Effect.flatMap(InternalTake.done), Effect.match({
     onFailure: maybeError => pipe(core.fromEffect(Queue.shutdown(output)), channel.zipRight(Option.match(maybeError, {
       onNone: () => core.unit,
       onSome: core.fail
@@ -184,38 +200,13 @@ export const asyncEffect = (register, outputBuffer = 16) => pipe(Effect.acquireR
   return loop;
 }))))), channel.unwrapScoped, fromChannel);
 /** @internal */
-export const asyncInterrupt = (register, outputBuffer = 16) => pipe(Effect.acquireRelease(Queue.bounded(outputBuffer), queue => Queue.shutdown(queue)), Effect.flatMap(output => pipe(Effect.runtime(), Effect.flatMap(runtime => pipe(Effect.sync(() => register(emit.make(k => pipe(_take.fromPull(k), Effect.flatMap(take => Queue.offer(output, take)), Effect.asUnit, Runtime.runPromiseExit(runtime)).then(exit => {
-  if (Exit.isFailure(exit)) {
-    if (!Cause.isInterrupted(exit.cause)) {
-      throw Cause.squash(exit.cause);
-    }
-  }
-})))), Effect.map(Either.match({
-  onLeft: canceler => {
-    const loop = pipe(Queue.take(output), Effect.flatMap(_take.done), Effect.match({
-      onFailure: maybeError => channel.zipRight(core.fromEffect(Queue.shutdown(output)), Option.match(maybeError, {
-        onNone: () => core.unit,
-        onSome: core.fail
-      })),
-      onSuccess: chunk => pipe(core.write(chunk), core.flatMap(() => loop))
-    }), channel.unwrap);
-    return pipe(fromChannel(loop), ensuring(canceler));
-  },
-  onRight: stream => unwrap(pipe(Queue.shutdown(output), Effect.as(stream)))
-})))))), unwrapScoped);
-/** @internal */
-export const asyncOption = (register, outputBuffer = 16) => asyncInterrupt(emit => Option.match(register(emit), {
-  onNone: () => Either.left(Effect.unit),
-  onSome: Either.right
-}), outputBuffer);
-/** @internal */
-export const asyncScoped = (register, outputBuffer = 16) => pipe(Effect.acquireRelease(Queue.bounded(outputBuffer), queue => Queue.shutdown(queue)), Effect.flatMap(output => pipe(Effect.runtime(), Effect.flatMap(runtime => pipe(register(emit.make(k => pipe(_take.fromPull(k), Effect.flatMap(take => Queue.offer(output, take)), Effect.asUnit, Runtime.runPromiseExit(runtime)).then(exit => {
+export const asyncScoped = (register, outputBuffer = 16) => pipe(Effect.acquireRelease(Queue.bounded(outputBuffer), queue => Queue.shutdown(queue)), Effect.flatMap(output => pipe(Effect.runtime(), Effect.flatMap(runtime => pipe(register(emit.make(k => pipe(InternalTake.fromPull(k), Effect.flatMap(take => Queue.offer(output, take)), Effect.asUnit, Runtime.runPromiseExit(runtime)).then(exit => {
   if (Exit.isFailure(exit)) {
     if (!Cause.isInterrupted(exit.cause)) {
       throw Cause.squash(exit.cause);
     }
   }
-}))), Effect.zipRight(Ref.make(false)), Effect.flatMap(ref => pipe(Ref.get(ref), Effect.map(isDone => isDone ? pull.end() : pipe(Queue.take(output), Effect.flatMap(_take.done), Effect.onError(() => pipe(Ref.set(ref, true), Effect.zipRight(Queue.shutdown(output)))))))))))), scoped, flatMap(repeatEffectChunkOption));
+}))), Effect.zipRight(Ref.make(false)), Effect.flatMap(ref => pipe(Ref.get(ref), Effect.map(isDone => isDone ? pull.end() : pipe(Queue.take(output), Effect.flatMap(InternalTake.done), Effect.onError(() => pipe(Ref.set(ref, true), Effect.zipRight(Queue.shutdown(output)))))))))))), scoped, flatMap(repeatEffectChunkOption));
 /** @internal */
 export const branchAfter = /*#__PURE__*/dual(3, (self, n, f) => suspend(() => {
   const buffering = acc => core.readWith({
@@ -275,7 +266,7 @@ export const bufferChunks = /*#__PURE__*/dual(2, (self, options) => {
   }
   const queue = toQueue(self, options);
   return new StreamImpl(channel.unwrapScoped(Effect.map(queue, queue => {
-    const process = pipe(core.fromEffect(Queue.take(queue)), core.flatMap(_take.match({
+    const process = pipe(core.fromEffect(Queue.take(queue)), core.flatMap(InternalTake.match({
       onEnd: () => core.unit,
       onFailure: core.failCause,
       onSuccess: value => pipe(core.write(value), core.flatMap(() => process))
@@ -304,7 +295,7 @@ const bufferUnbounded = self => {
     strategy: "unbounded"
   });
   return new StreamImpl(channel.unwrapScoped(Effect.map(queue, queue => {
-    const process = pipe(core.fromEffect(Queue.take(queue)), core.flatMap(_take.match({
+    const process = pipe(core.fromEffect(Queue.take(queue)), core.flatMap(InternalTake.match({
       onEnd: () => core.unit,
       onFailure: core.failCause,
       onSuccess: value => core.flatMap(core.write(value), () => process)
@@ -316,13 +307,13 @@ const bufferSignal = (scoped, bufferChannel) => {
   const producer = (queue, ref) => {
     const terminate = take => pipe(Ref.get(ref), Effect.tap(Deferred.await), Effect.zipRight(Deferred.make()), Effect.flatMap(deferred => pipe(Queue.offer(queue, [take, deferred]), Effect.zipRight(Ref.set(ref, deferred)), Effect.zipRight(Deferred.await(deferred)))), Effect.asUnit, core.fromEffect);
     return core.readWithCause({
-      onInput: input => pipe(Deferred.make(), Effect.flatMap(deferred => pipe(Queue.offer(queue, [_take.chunk(input), deferred]), Effect.flatMap(added => pipe(Ref.set(ref, deferred), Effect.when(() => added))))), Effect.asUnit, core.fromEffect, core.flatMap(() => producer(queue, ref))),
-      onFailure: error => terminate(_take.failCause(error)),
-      onDone: () => terminate(_take.end)
+      onInput: input => pipe(Deferred.make(), Effect.flatMap(deferred => pipe(Queue.offer(queue, [InternalTake.chunk(input), deferred]), Effect.flatMap(added => pipe(Ref.set(ref, deferred), Effect.when(() => added))))), Effect.asUnit, core.fromEffect, core.flatMap(() => producer(queue, ref))),
+      onFailure: error => terminate(InternalTake.failCause(error)),
+      onDone: () => terminate(InternalTake.end)
     });
   };
   const consumer = queue => {
-    const process = pipe(core.fromEffect(Queue.take(queue)), core.flatMap(([take, deferred]) => channel.zipRight(core.fromEffect(Deferred.succeed(deferred, void 0)), _take.match(take, {
+    const process = pipe(core.fromEffect(Queue.take(queue)), core.flatMap(([take, deferred]) => channel.zipRight(core.fromEffect(Deferred.succeed(deferred, void 0)), InternalTake.match(take, {
       onEnd: () => core.unit,
       onFailure: core.failCause,
       onSuccess: value => pipe(core.write(value), core.flatMap(() => process))
@@ -421,13 +412,13 @@ export const combine = /*#__PURE__*/dual(4, (self, that, s, f) => {
 /** @internal */
 export const combineChunks = /*#__PURE__*/dual(4, (self, that, s, f) => {
   const producer = (handoff, latch) => channel.zipRight(core.fromEffect(Handoff.take(latch)), core.readWithCause({
-    onInput: input => core.flatMap(core.fromEffect(pipe(handoff, Handoff.offer(_take.chunk(input)))), () => producer(handoff, latch)),
-    onFailure: cause => core.fromEffect(Handoff.offer(handoff, _take.failCause(cause))),
-    onDone: () => core.fromEffect(Handoff.offer(handoff, _take.end))
+    onInput: input => core.flatMap(core.fromEffect(pipe(handoff, Handoff.offer(InternalTake.chunk(input)))), () => producer(handoff, latch)),
+    onFailure: cause => core.fromEffect(Handoff.offer(handoff, InternalTake.failCause(cause))),
+    onDone: () => core.fromEffect(Handoff.offer(handoff, InternalTake.end))
   }));
   return new StreamImpl(pipe(Effect.all([Handoff.make(), Handoff.make(), Handoff.make(), Handoff.make()]), Effect.tap(([left, _, latchL]) => pipe(toChannel(self), core.pipeTo(producer(left, latchL)), channelExecutor.runScoped, Effect.forkScoped)), Effect.tap(([_, right, __, latchR]) => pipe(toChannel(that), core.pipeTo(producer(right, latchR)), channelExecutor.runScoped, Effect.forkScoped)), Effect.map(([left, right, latchL, latchR]) => {
-    const pullLeft = pipe(latchL, Handoff.offer(void 0), Effect.zipRight(pipe(Handoff.take(left), Effect.flatMap(_take.done))));
-    const pullRight = pipe(latchR, Handoff.offer(void 0), Effect.zipRight(pipe(Handoff.take(right), Effect.flatMap(_take.done))));
+    const pullLeft = pipe(latchL, Handoff.offer(void 0), Effect.zipRight(pipe(Handoff.take(left), Effect.flatMap(InternalTake.done))));
+    const pullRight = pipe(latchR, Handoff.offer(void 0), Effect.zipRight(pipe(Handoff.take(right), Effect.flatMap(InternalTake.done))));
     return toChannel(unfoldChunkEffect(s, s => Effect.flatMap(f(s, pullLeft, pullRight), unsome)));
   }), channel.unwrapScoped));
 });
@@ -1121,22 +1112,22 @@ export const interleave = /*#__PURE__*/dual(2, (self, that) => pipe(self, interl
 /** @internal */
 export const interleaveWith = /*#__PURE__*/dual(3, (self, that, decider) => {
   const producer = handoff => core.readWithCause({
-    onInput: value => core.flatMap(core.fromEffect(Handoff.offer(handoff, _take.of(value))), () => producer(handoff)),
-    onFailure: cause => core.fromEffect(Handoff.offer(handoff, _take.failCause(cause))),
-    onDone: () => core.fromEffect(Handoff.offer(handoff, _take.end))
+    onInput: value => core.flatMap(core.fromEffect(Handoff.offer(handoff, InternalTake.of(value))), () => producer(handoff)),
+    onFailure: cause => core.fromEffect(Handoff.offer(handoff, InternalTake.failCause(cause))),
+    onDone: () => core.fromEffect(Handoff.offer(handoff, InternalTake.end))
   });
   return new StreamImpl(channel.unwrapScoped(pipe(Handoff.make(), Effect.zip(Handoff.make()), Effect.tap(([left]) => pipe(toChannel(self), channel.concatMap(channel.writeChunk), core.pipeTo(producer(left)), channelExecutor.runScoped, Effect.forkScoped)), Effect.tap(([_, right]) => pipe(toChannel(that), channel.concatMap(channel.writeChunk), core.pipeTo(producer(right)), channelExecutor.runScoped, Effect.forkScoped)), Effect.map(([left, right]) => {
     const process = (leftDone, rightDone) => core.readWithCause({
       onInput: bool => {
         if (bool && !leftDone) {
-          return pipe(core.fromEffect(Handoff.take(left)), core.flatMap(_take.match({
+          return pipe(core.fromEffect(Handoff.take(left)), core.flatMap(InternalTake.match({
             onEnd: () => rightDone ? core.unit : process(true, rightDone),
             onFailure: core.failCause,
             onSuccess: chunk => pipe(core.write(chunk), core.flatMap(() => process(leftDone, rightDone)))
           })));
         }
         if (!bool && !rightDone) {
-          return pipe(core.fromEffect(Handoff.take(right)), core.flatMap(_take.match({
+          return pipe(core.fromEffect(Handoff.take(right)), core.flatMap(InternalTake.match({
             onEnd: () => leftDone ? core.unit : process(leftDone, true),
             onFailure: core.failCause,
             onSuccess: chunk => pipe(core.write(chunk), core.flatMap(() => process(leftDone, rightDone)))
@@ -1590,8 +1581,7 @@ export const repeatWith = /*#__PURE__*/dual(3, (self, schedule, options) => {
     return new StreamImpl(pipe(process, channel.zipRight(loop)));
   }), unwrap);
 });
-/** @internal */
-export const repeatWithSchedule = (value, schedule) => repeatEffectWithSchedule(Effect.succeed(value), schedule);
+const repeatWithSchedule = (value, schedule) => repeatEffectWithSchedule(Effect.succeed(value), schedule);
 /** @internal */
 export const repeatEffectWithSchedule = (effect, schedule) => flatMap(fromEffect(Effect.zip(effect, Schedule.driver(schedule))), ([a, driver]) => concat(succeed(a), unfoldEffect(a, s => Effect.matchEffect(driver.next(s), {
   onFailure: Effect.succeed,
@@ -1661,9 +1651,9 @@ export const runIntoQueueElementsScoped = /*#__PURE__*/dual(2, (self, queue) =>
 /** @internal */
 export const runIntoQueueScoped = /*#__PURE__*/dual(2, (self, queue) => {
   const writer = core.readWithCause({
-    onInput: input => core.flatMap(core.write(_take.chunk(input)), () => writer),
-    onFailure: cause => core.write(_take.failCause(cause)),
-    onDone: () => core.write(_take.end)
+    onInput: input => core.flatMap(core.write(InternalTake.chunk(input)), () => writer),
+    onFailure: cause => core.write(InternalTake.failCause(cause)),
+    onDone: () => core.write(InternalTake.end)
   });
   return pipe(core.pipeTo(toChannel(self), writer), channel.mapOutEffect(take => Queue.offer(queue, take)), channel.drain, channelExecutor.runScoped, Effect.asUnit);
 });
@@ -2008,20 +1998,20 @@ export const tapSink = /*#__PURE__*/dual(2, (self, sink) => pipe(fromEffect(Effe
     maxChunkSize: 1
   }));
   const loop = core.readWithCause({
-    onInput: chunk => pipe(core.fromEffect(Queue.offer(queue, _take.chunk(chunk))), core.foldCauseChannel({
+    onInput: chunk => pipe(core.fromEffect(Queue.offer(queue, InternalTake.chunk(chunk))), core.foldCauseChannel({
       onFailure: () => core.flatMap(core.write(chunk), () => channel.identityChannel()),
       onSuccess: () => core.flatMap(core.write(chunk), () => loop)
     })),
-    onFailure: cause => pipe(core.fromEffect(Queue.offer(queue, _take.failCause(cause))), core.foldCauseChannel({
+    onFailure: cause => pipe(core.fromEffect(Queue.offer(queue, InternalTake.failCause(cause))), core.foldCauseChannel({
       onFailure: () => core.failCause(cause),
       onSuccess: () => core.failCause(cause)
     })),
-    onDone: () => pipe(core.fromEffect(Queue.offer(queue, _take.end)), core.foldCauseChannel({
+    onDone: () => pipe(core.fromEffect(Queue.offer(queue, InternalTake.end)), core.foldCauseChannel({
       onFailure: () => core.unit,
       onSuccess: () => core.unit
     }))
   });
-  return pipe(new StreamImpl(pipe(core.pipeTo(toChannel(self), loop), channel.ensuring(Effect.zipRight(Effect.forkDaemon(Queue.offer(queue, _take.end)), Deferred.await(deferred))))), merge(execute(pipe(run(right, sink), Effect.ensuring(Effect.zipRight(Queue.shutdown(queue), Deferred.succeed(deferred, void 0)))))));
+  return pipe(new StreamImpl(pipe(core.pipeTo(toChannel(self), loop), channel.ensuring(Effect.zipRight(Effect.forkDaemon(Queue.offer(queue, InternalTake.end)), Deferred.await(deferred))))), merge(execute(pipe(run(right, sink), Effect.ensuring(Effect.zipRight(Queue.shutdown(queue), Deferred.succeed(deferred, void 0)))))));
 })));
 /** @internal */
 export const throttle = /*#__PURE__*/dual(2, (self, options) => throttleEffect(self, {