effect 2.4.19 → 3.0.1

package/dist/esm/internal/stream.js

@@ -75,7 +75,7 @@ export const accumulateChunks = self => {
       return core.flatMap(core.write(next), () => accumulator(next));
     },
     onFailure: core.fail,
-    onDone: () => core.unit
+    onDone: () => core.void
   });
   return new StreamImpl(core.pipeTo(toChannel(self), accumulator(Chunk.empty())));
 };
@@ -105,7 +105,7 @@ export const aggregateWithinEither = /*#__PURE__*/dual(3, (self, sink, schedule)
         switch (signal._tag) {
           case HandoffSignal.OP_EMIT:
             {
-              return pipe(core.fromEffect(Ref.set(consumed, true)), channel.zipRight(core.write(signal.elements)), channel.zipRight(core.fromEffect(Ref.get(endAfterEmit))), core.flatMap(bool => bool ? core.unit : handoffConsumer));
+              return pipe(core.fromEffect(Ref.set(consumed, true)), channel.zipRight(core.write(signal.elements)), channel.zipRight(core.fromEffect(Ref.get(endAfterEmit))), core.flatMap(bool => bool ? core.void : handoffConsumer));
             }
           case HandoffSignal.OP_HALT:
             {
@@ -141,7 +141,7 @@ export const aggregateWithinEither = /*#__PURE__*/dual(3, (self, sink, schedule)
             }
           case SinkEndReason.OP_UPSTREAM_END:
             {
-              return pipe(Ref.get(consumed), Effect.map(wasConsumed => wasConsumed ? core.write(Chunk.of(Either.right(b))) : core.unit), channel.unwrap);
+              return pipe(Ref.get(consumed), Effect.map(wasConsumed => wasConsumed ? core.write(Chunk.of(Either.right(b))) : core.void), channel.unwrap);
             }
         }
       })), channel.unwrap);
@@ -164,7 +164,7 @@ export const as = /*#__PURE__*/dual(2, (self, value) => map(self, () => value));
 /** @internal */
 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 => {
+  const canceler = register(emit.make(resume => InternalTake.fromPull(resume).pipe(Effect.flatMap(take => Queue.offer(output, take)), Effect.asVoid, runPromiseExit).then(exit => {
     if (Exit.isFailure(exit)) {
       if (!Cause.isInterrupted(exit.cause)) {
         throw Cause.squash(exit.cause);
@@ -175,15 +175,15 @@ export const _async = (register, outputBuffer = 16) => Effect.acquireRelease(Que
 })), 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,
+      onNone: () => core.void,
       onSome: error => core.fail(error)
     }))),
     onSuccess: chunk => core.write(chunk).pipe(core.flatMap(() => loop))
   }), channel.unwrap);
-  return fromChannel(loop).pipe(ensuring(value ?? Effect.unit));
+  return fromChannel(loop).pipe(ensuring(value ?? Effect.void));
 }))), 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(InternalTake.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.asVoid, Runtime.runPromiseExit(runtime)).then(exit => {
   if (Exit.isFailure(exit)) {
     if (!Cause.isInterrupted(exit.cause)) {
       throw Cause.squash(exit.cause);
@@ -192,7 +192,7 @@ export const asyncEffect = (register, outputBuffer = 16) => pipe(Effect.acquireR
 }))), Effect.map(() => {
   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,
+      onNone: () => core.void,
       onSome: core.fail
     }))),
     onSuccess: chunk => pipe(core.write(chunk), core.flatMap(() => loop))
@@ -200,7 +200,7 @@ export const asyncEffect = (register, outputBuffer = 16) => pipe(Effect.acquireR
   return loop;
 }))))), channel.unwrapScoped, fromChannel);
 /** @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(InternalTake.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.asVoid, Runtime.runPromiseExit(runtime)).then(exit => {
   if (Exit.isFailure(exit)) {
     if (!Cause.isInterrupted(exit.cause)) {
       throw Cause.squash(exit.cause);
@@ -249,7 +249,7 @@ export const buffer = /*#__PURE__*/dual(2, (self, options) => {
   return new StreamImpl(channel.unwrapScoped(Effect.map(queue, queue => {
     const process = pipe(core.fromEffect(Queue.take(queue)), core.flatMap(Exit.match({
       onFailure: cause => pipe(Cause.flipCauseOption(cause), Option.match({
-        onNone: () => core.unit,
+        onNone: () => core.void,
         onSome: core.failCause
       })),
       onSuccess: value => core.flatMap(core.write(Chunk.of(value)), () => process)
@@ -267,7 +267,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(InternalTake.match({
-      onEnd: () => core.unit,
+      onEnd: () => core.void,
       onFailure: core.failCause,
       onSuccess: value => pipe(core.write(value), core.flatMap(() => process))
     })));
@@ -296,7 +296,7 @@ const bufferUnbounded = self => {
   });
   return new StreamImpl(channel.unwrapScoped(Effect.map(queue, queue => {
     const process = pipe(core.fromEffect(Queue.take(queue)), core.flatMap(InternalTake.match({
-      onEnd: () => core.unit,
+      onEnd: () => core.void,
       onFailure: core.failCause,
       onSuccess: value => core.flatMap(core.write(value), () => process)
     })));
@@ -305,16 +305,16 @@ const bufferUnbounded = self => {
 };
 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);
+    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.asVoid, core.fromEffect);
     return core.readWithCause({
-      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))),
+      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.asVoid, 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)), InternalTake.match(take, {
-      onEnd: () => core.unit,
+      onEnd: () => core.void,
       onFailure: core.failCause,
       onSuccess: value => pipe(core.write(value), core.flatMap(() => process))
     }))));
@@ -363,7 +363,7 @@ export const changesWith = /*#__PURE__*/dual(2, (self, f) => {
       return core.flatMap(core.write(newChunk), () => writer(newLast));
     },
     onFailure: core.failCause,
-    onDone: () => core.unit
+    onDone: () => core.void
   });
   return new StreamImpl(pipe(toChannel(self), core.pipeTo(writer(Option.none()))));
 });
@@ -377,7 +377,7 @@ export const changesWithEffect = /*#__PURE__*/dual(2, (self, f) => {
       return Effect.succeed([Option.some(output), pipe(outputs, Chunk.append(output))]);
     }), core.fromEffect, core.flatMap(([newLast, newChunk]) => pipe(core.write(newChunk), core.flatMap(() => writer(newLast))))),
     onFailure: core.failCause,
-    onDone: () => core.unit
+    onDone: () => core.void
   });
   return new StreamImpl(pipe(toChannel(self), core.pipeTo(writer(Option.none()))));
 });
@@ -461,7 +461,7 @@ export const debounce = /*#__PURE__*/dual(2, (self, duration) => pipe(singleProd
                 }
               case HandoffSignal.OP_END:
                 {
-                  return core.unit;
+                  return core.void;
                 }
             }
           }), channel.unwrap);
@@ -487,7 +487,7 @@ export const debounce = /*#__PURE__*/dual(2, (self, duration) => pipe(singleProd
                     }
                   case HandoffSignal.OP_END:
                     {
-                      return pipe(Fiber.join(previous), Effect.map(chunk => pipe(core.write(chunk), channel.zipRight(core.unit))));
+                      return pipe(Fiber.join(previous), Effect.map(chunk => pipe(core.write(chunk), channel.zipRight(core.void))));
                     }
                 }
               }
@@ -508,7 +508,7 @@ export const debounce = /*#__PURE__*/dual(2, (self, duration) => pipe(singleProd
                 }
               case HandoffSignal.OP_END:
                 {
-                  return core.unit;
+                  return core.void;
                 }
             }
           }), channel.unwrap);
@@ -542,7 +542,7 @@ const newDistributedWithDynamicId = () => {
   return current;
 };
 /** @internal */
-export const distributedWithDynamic = /*#__PURE__*/dual(2, (self, options) => distributedWithDynamicCallback(self, options.maximumLag, options.decide, () => Effect.unit));
+export const distributedWithDynamic = /*#__PURE__*/dual(2, (self, options) => distributedWithDynamicCallback(self, options.maximumLag, options.decide, () => Effect.void));
 /** @internal */
 export const distributedWithDynamicCallback = /*#__PURE__*/dual(4, (self, maximumLag, decide, done) => pipe(Effect.acquireRelease(Ref.make(new Map()), (ref, _) => pipe(Ref.get(ref), Effect.flatMap(queues => pipe(queues.values(), Effect.forEach(Queue.shutdown))))), Effect.flatMap(queuesRef => Effect.gen(function* ($) {
   const offer = a => pipe(decide(a), Effect.flatMap(shouldProcess => pipe(Ref.get(queuesRef), Effect.flatMap(queues => pipe(queues.entries(), Effect.reduce(Chunk.empty(), (acc, [id, queue]) => {
@@ -565,8 +565,8 @@ export const distributedWithDynamicCallback = /*#__PURE__*/dual(4, (self, maximu
         return map;
       }));
     }
-    return Effect.unit;
-  }))))), Effect.asUnit);
+    return Effect.void;
+  }))))), Effect.asVoid);
   const queuesLock = yield* $(Effect.makeSemaphore(1));
   const newQueue = yield* $(Ref.make(pipe(Queue.bounded(maximumLag), Effect.flatMap(queue => {
     const id = newDistributedWithDynamicId();
@@ -579,7 +579,7 @@ export const distributedWithDynamicCallback = /*#__PURE__*/dual(4, (self, maximu
   Queue.bounded(1), Effect.tap(queue => Queue.offer(queue, endTake)), Effect.flatMap(queue => {
     const id = newDistributedWithDynamicId();
     return pipe(Ref.update(queuesRef, map => map.set(id, queue)), Effect.as(Tuple.make(id, queue)));
-  }))), Effect.zipRight(pipe(Ref.get(queuesRef), Effect.flatMap(map => pipe(Chunk.fromIterable(map.values()), Effect.forEach(queue => pipe(Queue.offer(queue, endTake), Effect.catchSomeCause(cause => Cause.isInterrupted(cause) ? Option.some(Effect.unit) : Option.none()))))))), Effect.zipRight(done(endTake)), Effect.asUnit));
+  }))), Effect.zipRight(pipe(Ref.get(queuesRef), Effect.flatMap(map => pipe(Chunk.fromIterable(map.values()), Effect.forEach(queue => pipe(Queue.offer(queue, endTake), Effect.catchSomeCause(cause => Cause.isInterrupted(cause) ? Option.some(Effect.void) : Option.none()))))))), Effect.zipRight(done(endTake)), Effect.asVoid));
   yield* $(self, runForEachScoped(offer), Effect.matchCauseEffect({
     onFailure: cause => finalize(Exit.failCause(pipe(cause, Cause.map(Option.some)))),
     onSuccess: () => finalize(Exit.fail(Option.none()))
@@ -589,7 +589,7 @@ export const distributedWithDynamicCallback = /*#__PURE__*/dual(4, (self, maximu
 /** @internal */
 export const drain = self => new StreamImpl(channel.drain(toChannel(self)));
 /** @internal */
-export const drainFork = /*#__PURE__*/dual(2, (self, that) => pipe(fromEffect(Deferred.make()), flatMap(backgroundDied => pipe(scoped(pipe(that, runForEachScoped(() => Effect.unit), Effect.catchAllCause(cause => Deferred.failCause(backgroundDied, cause)), Effect.forkScoped)), crossRight(pipe(self, interruptWhenDeferred(backgroundDied)))))));
+export const drainFork = /*#__PURE__*/dual(2, (self, that) => pipe(fromEffect(Deferred.make()), flatMap(backgroundDied => pipe(scoped(pipe(that, runForEachScoped(() => Effect.void), Effect.catchAllCause(cause => Deferred.failCause(backgroundDied, cause)), Effect.forkScoped)), crossRight(pipe(self, interruptWhenDeferred(backgroundDied)))))));
 /** @internal */
 export const drop = /*#__PURE__*/dual(2, (self, n) => {
   const loop = r => core.readWith({
@@ -603,7 +603,7 @@ export const drop = /*#__PURE__*/dual(2, (self, n) => {
       return pipe(core.write(dropped), channel.zipRight(channel.identityChannel()));
     },
     onFailure: core.fail,
-    onDone: () => core.unit
+    onDone: () => core.void
   });
   return new StreamImpl(pipe(toChannel(self), channel.pipeToOrFail(loop(n))));
 });
@@ -624,7 +624,7 @@ export const dropRight = /*#__PURE__*/dual(2, (self, n) => {
         return pipe(core.write(outputs), core.flatMap(() => reader));
       },
       onFailure: core.fail,
-      onDone: () => core.unit
+      onDone: () => core.void
     });
     return new StreamImpl(pipe(toChannel(self), channel.pipeToOrFail(reader)));
   });
@@ -642,7 +642,7 @@ export const dropUntilEffect = /*#__PURE__*/dual(2, (self, predicate) => {
       return pipe(core.write(leftover), channel.zipRight(channel.identityChannel()));
     }), channel.unwrap),
     onFailure: core.fail,
-    onDone: () => core.unit
+    onDone: () => core.void
   });
   return new StreamImpl(pipe(toChannel(self), channel.pipeToOrFail(loop)));
 });
@@ -672,7 +672,7 @@ export const dropWhileEffect = /*#__PURE__*/dual(2, (self, predicate) => {
       return channel.zipRight(core.write(leftover), channel.identityChannel());
     }), channel.unwrap),
     onFailure: core.fail,
-    onDone: () => core.unit
+    onDone: () => core.void
   });
   return new StreamImpl(channel.pipeToOrFail(toChannel(self), loop));
 });
@@ -768,7 +768,7 @@ export const filterMapWhileEffect = /*#__PURE__*/dual(2, (self, pf) => suspend((
       });
     } else {
       return channel.unwrap(Option.match(pf(next.value), {
-        onNone: () => Effect.succeed(core.unit),
+        onNone: () => Effect.succeed(core.void),
         onSome: Effect.map(a2 => core.flatMap(core.write(Chunk.of(a2)), () => loop(iterator)))
       }));
     }
@@ -776,7 +776,7 @@ export const filterMapWhileEffect = /*#__PURE__*/dual(2, (self, pf) => suspend((
   return new StreamImpl(pipe(toChannel(self), channel.pipeToOrFail(loop(Chunk.empty()[Symbol.iterator]()))));
 }));
 /** @internal */
-export const finalizer = finalizer => acquireRelease(Effect.unit, () => finalizer);
+export const finalizer = finalizer => acquireRelease(Effect.void, () => finalizer);
 /** @internal */
 export const find = /*#__PURE__*/dual(2, (self, predicate) => {
   const loop = core.readWith({
@@ -785,7 +785,7 @@ export const find = /*#__PURE__*/dual(2, (self, predicate) => {
       onSome: n => core.write(Chunk.of(n))
     }),
     onFailure: core.fail,
-    onDone: () => core.unit
+    onDone: () => core.void
   });
   return new StreamImpl(pipe(toChannel(self), core.pipeTo(loop)));
 });
@@ -797,7 +797,7 @@ export const findEffect = /*#__PURE__*/dual(2, (self, predicate) => {
       onSome: n => core.write(Chunk.of(n))
     })), channel.unwrap),
     onFailure: core.fail,
-    onDone: () => core.unit
+    onDone: () => core.void
   });
   return new StreamImpl(pipe(toChannel(self), core.pipeTo(loop)));
 });
@@ -807,7 +807,7 @@ export const flatMap = /*#__PURE__*/dual(args => isStream(args[0]), (self, f, op
   if (options?.switch) {
     return matchConcurrency(options?.concurrency, () => flatMapParSwitchBuffer(self, 1, bufferSize, f), n => flatMapParSwitchBuffer(self, n, bufferSize, f));
   }
-  return matchConcurrency(options?.concurrency, () => new StreamImpl(channel.concatMap(toChannel(self), as => pipe(as, Chunk.map(a => toChannel(f(a))), Chunk.reduce(core.unit, (left, right) => pipe(left, channel.zipRight(right)))))), _ => new StreamImpl(pipe(toChannel(self), channel.concatMap(channel.writeChunk), channel.mergeMap(out => toChannel(f(out)), options))));
+  return matchConcurrency(options?.concurrency, () => new StreamImpl(channel.concatMap(toChannel(self), as => pipe(as, Chunk.map(a => toChannel(f(a))), Chunk.reduce(core.void, (left, right) => pipe(left, channel.zipRight(right)))))), _ => new StreamImpl(pipe(toChannel(self), channel.concatMap(channel.writeChunk), channel.mergeMap(out => toChannel(f(out)), options))));
 });
 /** @internal */
 export const matchConcurrency = (concurrency, sequential, bounded) => {
@@ -832,7 +832,7 @@ export const flattenChunks = self => {
   const flatten = core.readWithCause({
     onInput: chunks => core.flatMap(channel.writeChunk(chunks), () => flatten),
     onFailure: core.failCause,
-    onDone: () => core.unit
+    onDone: () => core.void
   });
   return new StreamImpl(pipe(toChannel(self), core.pipeTo(flatten)));
 };
@@ -848,10 +848,10 @@ export const flattenExitOption = self => {
       onNone: () => cont,
       onSome: Exit.match({
         onFailure: cause => Option.match(Cause.flipCauseOption(cause), {
-          onNone: () => core.unit,
+          onNone: () => core.void,
           onSome: core.failCause
         }),
-        onSuccess: () => core.unit
+        onSuccess: () => core.void
       })
     }));
     return pipe(core.write(pipe(toEmit, Chunk.filterMap(exit => Exit.isSuccess(exit) ? Option.some(exit.value) : Option.none()))), core.flatMap(() => next));
@@ -859,7 +859,7 @@ export const flattenExitOption = self => {
   const process = core.readWithCause({
     onInput: chunk => processChunk(chunk, process),
     onFailure: cause => core.failCause(cause),
-    onDone: () => core.unit
+    onDone: () => core.void
   });
   return new StreamImpl(pipe(toChannel(self), core.pipeTo(process)));
 };
@@ -870,7 +870,7 @@ export const flattenTake = self => flattenChunks(flattenExitOption(pipe(self, ma
 /** @internal */
 export const forever = self => new StreamImpl(channel.repeated(toChannel(self)));
 /** @internal */
-export const fromAsyncIterable = (iterable, onError) => pipe(Effect.acquireRelease(Effect.sync(() => iterable[Symbol.asyncIterator]()), iterator => iterator.return ? Effect.promise(async () => iterator.return()) : Effect.unit), Effect.map(iterator => repeatEffectOption(pipe(Effect.tryPromise({
+export const fromAsyncIterable = (iterable, onError) => pipe(Effect.acquireRelease(Effect.sync(() => iterable[Symbol.asyncIterator]()), iterator => iterator.return ? Effect.promise(async () => iterator.return()) : Effect.void), Effect.map(iterator => repeatEffectOption(pipe(Effect.tryPromise({
   try: async () => iterator.next(),
   catch: reason => Option.some(onError(reason))
 }), Effect.flatMap(result => result.done ? Effect.fail(Option.none()) : Effect.succeed(result.value))))), unwrapScoped);
@@ -887,7 +887,7 @@ export const toChannel = stream => {
   }
 };
 /** @internal */
-export const fromChunk = chunk => new StreamImpl(Chunk.isEmpty(chunk) ? core.unit : core.write(chunk));
+export const fromChunk = chunk => new StreamImpl(Chunk.isEmpty(chunk) ? core.void : core.write(chunk));
 /** @internal */
 export const fromChunkPubSub = (pubsub, options) => {
   if (options?.scoped) {
@@ -906,7 +906,7 @@ export const fromEffect = effect => pipe(effect, Effect.mapError(Option.some), f
 /** @internal */
 export const fromEffectOption = effect => new StreamImpl(channel.unwrap(Effect.match(effect, {
   onFailure: Option.match({
-    onNone: () => core.unit,
+    onNone: () => core.void,
     onSome: core.fail
   }),
   onSuccess: a => core.write(Chunk.of(a))
@@ -938,7 +938,7 @@ export const fromIteratorSucceed = (iterator, maxChunkSize = DefaultChunkSize) =
       let next = iterator.next();
       if (maxChunkSize === 1) {
         if (next.done) {
-          return core.unit;
+          return core.void;
         }
         return pipe(core.write(Chunk.of(next.value)), core.flatMap(() => loop(iterator)));
       }
@@ -955,7 +955,7 @@ export const fromIteratorSucceed = (iterator, maxChunkSize = DefaultChunkSize) =
       if (count > 0) {
         return pipe(core.write(Chunk.unsafeFromArray(builder)), core.flatMap(() => loop(iterator)));
       }
-      return core.unit;
+      return core.void;
     }), channel.unwrap);
     return new StreamImpl(loop(iterator));
   }), unwrap);
@@ -1079,11 +1079,11 @@ export const haltWhen = /*#__PURE__*/dual(2, (self, effect) => {
     onNone: () => core.readWith({
       onInput: input => core.flatMap(core.write(input), () => writer(fiber)),
       onFailure: core.fail,
-      onDone: () => core.unit
+      onDone: () => core.void
     }),
     onSome: Exit.match({
       onFailure: core.failCause,
-      onSuccess: () => core.unit
+      onSuccess: () => core.void
     })
   })), channel.unwrap);
   return new StreamImpl(pipe(Effect.forkScoped(effect), Effect.map(fiber => pipe(toChannel(self), core.pipeTo(writer(fiber)))), channel.unwrapScoped));
@@ -1096,11 +1096,11 @@ export const haltWhenDeferred = /*#__PURE__*/dual(2, (self, deferred) => {
     onNone: () => core.readWith({
       onInput: input => pipe(core.write(input), core.flatMap(() => writer)),
       onFailure: core.fail,
-      onDone: () => core.unit
+      onDone: () => core.void
     }),
     onSome: effect => channel.unwrap(Effect.match(effect, {
       onFailure: core.fail,
-      onSuccess: () => core.unit
+      onSuccess: () => core.void
     }))
   })), channel.unwrap);
   return new StreamImpl(pipe(toChannel(self), core.pipeTo(writer)));
@@ -1121,14 +1121,14 @@ export const interleaveWith = /*#__PURE__*/dual(3, (self, that, decider) => {
       onInput: bool => {
         if (bool && !leftDone) {
           return pipe(core.fromEffect(Handoff.take(left)), core.flatMap(InternalTake.match({
-            onEnd: () => rightDone ? core.unit : process(true, rightDone),
+            onEnd: () => rightDone ? core.void : 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(InternalTake.match({
-            onEnd: () => leftDone ? core.unit : process(leftDone, true),
+            onEnd: () => leftDone ? core.void : process(leftDone, true),
             onFailure: core.failCause,
             onSuccess: chunk => pipe(core.write(chunk), core.flatMap(() => process(leftDone, rightDone)))
           })));
@@ -1136,7 +1136,7 @@ export const interleaveWith = /*#__PURE__*/dual(3, (self, that, decider) => {
         return process(leftDone, rightDone);
       },
       onFailure: core.failCause,
-      onDone: () => core.unit
+      onDone: () => core.void
     });
     return pipe(toChannel(decider), channel.concatMap(channel.writeChunk), core.pipeTo(process(false, false)));
   }))));
@@ -1159,7 +1159,7 @@ export const intersperse = /*#__PURE__*/dual(2, (self, element) => new StreamImp
       return pipe(core.write(Chunk.unsafeFromArray(builder)), core.flatMap(() => writer(flagResult)));
     },
     onFailure: core.failCause,
-    onDone: () => core.unit
+    onDone: () => core.void
   });
   return writer(true);
 })))));
@@ -1189,7 +1189,7 @@ export const mapAccum = /*#__PURE__*/dual(3, (self, s, f) => {
       return core.flatMap(core.write(chunk), () => accumulator(nextS));
     },
     onFailure: core.fail,
-    onDone: () => core.unit
+    onDone: () => core.void
   });
   return new StreamImpl(pipe(toChannel(self), core.pipeTo(accumulator(s))));
 });
@@ -1212,7 +1212,7 @@ export const mapAccumEffect = /*#__PURE__*/dual(3, (self, s, f) => suspend(() =>
       }));
     }), channel.unwrap),
     onFailure: core.fail,
-    onDone: () => core.unit
+    onDone: () => core.void
   });
   return new StreamImpl(pipe(toChannel(self), channel.pipeToOrFail(accumulator(s))));
 }));
@@ -1289,7 +1289,7 @@ export const never = /*#__PURE__*/fromEffect(Effect.never);
 /** @internal */
 export const onError = /*#__PURE__*/dual(2, (self, cleanup) => pipe(self, catchAllCause(cause => fromEffect(pipe(cleanup(cause), Effect.zipRight(Effect.failCause(cause)))))));
 /** @internal */
-export const onDone = /*#__PURE__*/dual(2, (self, cleanup) => new StreamImpl(pipe(toChannel(self), core.ensuringWith(exit => Exit.isSuccess(exit) ? cleanup() : Effect.unit))));
+export const onDone = /*#__PURE__*/dual(2, (self, cleanup) => new StreamImpl(pipe(toChannel(self), core.ensuringWith(exit => Exit.isSuccess(exit) ? cleanup() : Effect.void))));
 /** @internal */
 export const orDie = self => pipe(self, orDieWith(identity));
 /** @internal */
@@ -1330,7 +1330,7 @@ export const paginateChunk = (s, f) => {
   const loop = s => {
     const page = f(s);
     return Option.match(page[1], {
-      onNone: () => channel.zipRight(core.write(page[0]), core.unit),
+      onNone: () => channel.zipRight(core.write(page[0]), core.void),
       onSome: s => core.flatMap(core.write(page[0]), () => loop(s))
     });
   };
@@ -1339,7 +1339,7 @@ export const paginateChunk = (s, f) => {
 /** @internal */
 export const paginateChunkEffect = (s, f) => {
   const loop = s => channel.unwrap(Effect.map(f(s), ([chunk, option]) => Option.match(option, {
-    onNone: () => channel.zipRight(core.write(chunk), core.unit),
+    onNone: () => channel.zipRight(core.write(chunk), core.void),
     onSome: s => core.flatMap(core.write(chunk), () => loop(s))
   })));
   return new StreamImpl(core.suspend(() => loop(s)));
@@ -1366,7 +1366,7 @@ export const peel = /*#__PURE__*/dual(2, (self, sink) => {
           })), core.failCause(cause)),
           onDone: _ => channel.zipRight(core.fromEffect(Handoff.offer(handoff, {
             _tag: OP_END
-          })), core.unit)
+          })), core.void)
         });
         return _sink.fromChannel(pipe(core.fromEffect(Deferred.succeed(deferred, z)), channel.zipRight(core.fromEffect(pipe(handoff, Handoff.offer({
           _tag: OP_EMIT,
@@ -1386,7 +1386,7 @@ export const peel = /*#__PURE__*/dual(2, (self, sink) => {
           }
         case OP_END:
           {
-            return core.unit;
+            return core.void;
           }
       }
     }), channel.unwrap);
@@ -1510,7 +1510,7 @@ class StreamRechunker {
     if (this.pos !== 0) {
       return core.write(Chunk.unsafeFromArray(this.builder));
     }
-    return core.unit;
+    return core.void;
   }
 }
 /** @internal */
@@ -1561,7 +1561,7 @@ export const repeatElementsWith = /*#__PURE__*/dual(3, (self, schedule, options)
     const loop = core.readWith({
       onInput: feed,
       onFailure: core.fail,
-      onDone: () => core.unit
+      onDone: () => core.void
     });
     return loop;
   }), channel.unwrap);
@@ -1575,7 +1575,7 @@ export const repeatWith = /*#__PURE__*/dual(3, (self, schedule, options) => {
     const scheduleOutput = pipe(driver.last, Effect.orDie, Effect.map(options.onSchedule));
     const process = pipe(self, map(options.onElement), toChannel);
     const loop = channel.unwrap(Effect.match(driver.next(void 0), {
-      onFailure: () => core.unit,
+      onFailure: () => core.void,
       onSuccess: () => pipe(process, channel.zipRight(pipe(scheduleOutput, Effect.map(c => pipe(core.write(Chunk.of(c)), core.flatMap(() => loop))), channel.unwrap)))
     }));
     return new StreamImpl(pipe(process, channel.zipRight(loop)));
@@ -1646,7 +1646,7 @@ export const runIntoQueueElementsScoped = /*#__PURE__*/dual(2, (self, queue) =>
     onFailure: cause => core.fromEffect(Queue.offer(queue, Exit.failCause(Cause.map(cause, Option.some)))),
     onDone: () => core.fromEffect(Queue.offer(queue, Exit.fail(Option.none())))
   });
-  return pipe(core.pipeTo(toChannel(self), writer), channel.drain, channelExecutor.runScoped, Effect.asUnit);
+  return pipe(core.pipeTo(toChannel(self), writer), channel.drain, channelExecutor.runScoped, Effect.asVoid);
 });
 /** @internal */
 export const runIntoQueueScoped = /*#__PURE__*/dual(2, (self, queue) => {
@@ -1655,7 +1655,7 @@ export const runIntoQueueScoped = /*#__PURE__*/dual(2, (self, queue) => {
     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);
+  return pipe(core.pipeTo(toChannel(self), writer), channel.mapOutEffect(take => Queue.offer(queue, take)), channel.drain, channelExecutor.runScoped, Effect.asVoid);
 });
 /** @internal */
 export const runLast = self => pipe(self, run(_sink.last()));
@@ -1706,7 +1706,7 @@ export const scheduleWith = /*#__PURE__*/dual(3, (self, schedule, options) => {
 /** @internal */
 export const scanEffect = /*#__PURE__*/dual(3, (self, s, f) => new StreamImpl(pipe(core.write(Chunk.of(s)), core.flatMap(() => toChannel(pipe(self, mapAccumEffect(s, (s, a) => pipe(f(s, a), Effect.map(s => [s, s])))))))));
 /** @internal */
-export const scoped = effect => new StreamImpl(channel.ensuring(channel.scoped(pipe(effect, Effect.map(Chunk.of))), Effect.unit));
+export const scoped = effect => new StreamImpl(channel.ensuring(channel.scoped(pipe(effect, Effect.map(Chunk.of))), Effect.void));
 /** @internal */
 export const some = self => pipe(self, mapError(Option.some), someOrFail(() => Option.none()));
 /** @internal */
@@ -1750,7 +1750,7 @@ export const slidingSize = /*#__PURE__*/dual(3, (self, chunkSize, stepSize) => {
         return Option.some(queue.toChunk());
       })), () => reader(queueSize + input.length)),
       onFailure: cause => emitOnStreamEnd(queueSize, core.failCause(cause)),
-      onDone: () => emitOnStreamEnd(queueSize, core.unit)
+      onDone: () => emitOnStreamEnd(queueSize, core.void)
     });
     return pipe(toChannel(self), core.pipeTo(reader(0)));
   }));
@@ -1769,12 +1769,12 @@ export const split = /*#__PURE__*/dual(2, (self, predicate) => {
     onFailure: core.fail,
     onDone: () => {
       if (Chunk.isEmpty(leftovers)) {
-        return core.unit;
+        return core.void;
       }
       if (Option.isNone(pipe(leftovers, Chunk.findFirst(predicate)))) {
-        return channel.zipRight(core.write(Chunk.of(leftovers)), core.unit);
+        return channel.zipRight(core.write(Chunk.of(leftovers)), core.void);
       }
-      return channel.zipRight(split(Chunk.empty(), leftovers), core.unit);
+      return channel.zipRight(split(Chunk.empty(), leftovers), core.void);
     }
   });
   return new StreamImpl(pipe(toChannel(self), core.pipeTo(loop(Chunk.empty()))));
@@ -1838,7 +1838,7 @@ export const take = /*#__PURE__*/dual(2, (self, n) => {
     onFailure: core.fail,
     onDone: core.succeed
   });
-  return new StreamImpl(pipe(toChannel(self), channel.pipeToOrFail(0 < n ? loop(n) : core.unit)));
+  return new StreamImpl(pipe(toChannel(self), channel.pipeToOrFail(0 < n ? loop(n) : core.void)));
 });
 /** @internal */
 export const takeRight = /*#__PURE__*/dual(2, (self, n) => {
@@ -1854,7 +1854,7 @@ export const takeRight = /*#__PURE__*/dual(2, (self, n) => {
         return reader;
       },
       onFailure: core.fail,
-      onDone: () => pipe(core.write(queue.toChunk()), channel.zipRight(core.unit))
+      onDone: () => pipe(core.write(queue.toChunk()), channel.zipRight(core.void))
     });
     return pipe(toChannel(self), core.pipeTo(reader));
   }), channel.unwrap));
@@ -1936,8 +1936,8 @@ export const tapSink = /*#__PURE__*/dual(2, (self, sink) => pipe(fromEffect(Effe
       onSuccess: () => core.failCause(cause)
     })),
     onDone: () => pipe(core.fromEffect(Queue.offer(queue, InternalTake.end)), core.foldCauseChannel({
-      onFailure: () => core.unit,
-      onSuccess: () => core.unit
+      onFailure: () => core.void,
+      onSuccess: () => core.void
     }))
   });
   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)))))));
@@ -1968,7 +1968,7 @@ const throttleEnforceEffect = (self, cost, units, duration, burst) => {
       return loop(tokens, timestampMillis);
     }), channel.unwrap),
     onFailure: core.failCause,
-    onDone: () => core.unit
+    onDone: () => core.void
   });
   const throttled = pipe(Clock.currentTimeMillis, Effect.map(currentTimeMillis => loop(units, currentTimeMillis)), channel.unwrap);
   return new StreamImpl(pipe(toChannel(self), channel.pipeToOrFail(throttled)));
@@ -1990,7 +1990,7 @@ const throttleShapeEffect = (self, costFn, units, duration, burst) => {
       return core.flatMap(core.write(input), () => loop(remaining, currentTimeMillis));
     }), channel.unwrap),
     onFailure: core.failCause,
-    onDone: () => core.unit
+    onDone: () => core.void
   });
   const throttled = pipe(Clock.currentTimeMillis, Effect.map(currentTimeMillis => loop(units, currentTimeMillis)), channel.unwrap);
   return new StreamImpl(pipe(toChannel(self), channel.pipeToOrFail(throttled)));
@@ -2036,20 +2036,20 @@ export const toReadableStream = source => {
         Chunk.map(chunk, a => {
           controller.enqueue(a);
         });
-      })), Effect.tapErrorCause(() => Scope.close(scope, Exit.unit)), Effect.catchTags({
+      })), Effect.tapErrorCause(() => Scope.close(scope, Exit.void)), Effect.catchTags({
         "None": () => Effect.sync(() => {
           controller.close();
         }),
         "Some": error => Effect.sync(() => {
           controller.error(error.value);
         })
-      }), Effect.asUnit);
+      }), Effect.asVoid);
     },
     pull() {
       return Effect.runPromise(pull);
     },
     cancel() {
-      return Effect.runPromise(Scope.close(scope, Exit.unit));
+      return Effect.runPromise(Scope.close(scope, Exit.void));
     }
   });
 };
@@ -2088,7 +2088,7 @@ export const transduce = /*#__PURE__*/dual(2, (self, sink) => {
       }), core.succeedNow(done))
     });
     const transducer = pipe(sink, _sink.toChannel, core.collectElements, core.flatMap(([leftover, z]) => pipe(core.succeed([upstreamDone.ref, concatAndGet(leftover)]), core.flatMap(([done, newLeftovers]) => {
-      const nextChannel = done && Chunk.isEmpty(newLeftovers) ? core.unit : transducer;
+      const nextChannel = done && Chunk.isEmpty(newLeftovers) ? core.void : transducer;
       return pipe(core.write(Chunk.of(z)), core.flatMap(() => nextChannel));
     }))));
     return pipe(toChannel(self), core.pipeTo(upstreamMarker), core.pipeTo(buffer), channel.pipeToOrFail(transducer));
@@ -2100,7 +2100,7 @@ export const unfold = (s, f) => unfoldChunk(s, s => pipe(f(s), Option.map(([a, s
 /** @internal */
 export const unfoldChunk = (s, f) => {
   const loop = s => Option.match(f(s), {
-    onNone: () => core.unit,
+    onNone: () => core.void,
     onSome: ([chunk, s]) => core.flatMap(core.write(chunk), () => loop(s))
   });
   return new StreamImpl(core.suspend(() => loop(s)));
@@ -2108,15 +2108,16 @@ export const unfoldChunk = (s, f) => {
 /** @internal */
 export const unfoldChunkEffect = (s, f) => suspend(() => {
   const loop = s => channel.unwrap(Effect.map(f(s), Option.match({
-    onNone: () => core.unit,
+    onNone: () => core.void,
     onSome: ([chunk, s]) => core.flatMap(core.write(chunk), () => loop(s))
   })));
   return new StreamImpl(loop(s));
 });
 /** @internal */
 export const unfoldEffect = (s, f) => unfoldChunkEffect(s, s => pipe(f(s), Effect.map(Option.map(([a, s]) => [Chunk.of(a), s]))));
-/** @internal */
-export const unit = /*#__PURE__*/succeed(void 0);
+const void_ = /*#__PURE__*/succeed(void 0);
+export { /** @internal */
+void_ as void };
 /** @internal */
 export const unwrap = effect => flatten(fromEffect(effect));
 /** @internal */
@@ -2562,8 +2563,8 @@ export const zipWithNext = self => {
     },
     onFailure: core.failCause,
     onDone: () => Option.match(last, {
-      onNone: () => core.unit,
-      onSome: value => channel.zipRight(core.write(Chunk.of([value, Option.none()])), core.unit)
+      onNone: () => core.void,
+      onSome: value => channel.zipRight(core.write(Chunk.of([value, Option.none()])), core.void)
     })
   });
   return new StreamImpl(pipe(toChannel(self), channel.pipeToOrFail(process(Option.none()))));