effect 3.21.5 → 3.22.1

package/src/internal/stream/emit.ts

@@ -3,9 +3,8 @@ import * as Chunk from "../../Chunk.js"
 import * as Effect from "../../Effect.js"
 import * as Exit from "../../Exit.js"
 import { pipe } from "../../Function.js"
+import type * as Mailbox from "../../Mailbox.js"
 import * as Option from "../../Option.js"
-import type * as Queue from "../../Queue.js"
-import type * as Scheduler from "../../Scheduler.js"
 import type * as Emit from "../../StreamEmit.js"
 
 /** @internal */
@@ -48,53 +47,23 @@ export const make = <R, E, A, B>(
 }
 
 /** @internal */
-export const makePush = <E, A>(
-  queue: Queue.Queue<Array<A> | Exit.Exit<void, E>>,
-  scheduler: Scheduler.Scheduler
-): Emit.EmitOpsPush<E, A> => {
+export const makePush = <E, A>(mailbox: Mailbox.Mailbox<A, E>): Emit.EmitOpsPush<E, A> => {
   let finished = false
-  let buffer: Array<A> = []
-  let running = false
   function array(items: ReadonlyArray<A>) {
     if (finished) return false
-    if (items.length <= 50_000) {
-      buffer.push.apply(buffer, items as Array<A>)
-    } else {
-      for (let i = 0; i < items.length; i++) {
-        buffer.push(items[0])
-      }
-    }
-    if (!running) {
-      running = true
-      scheduler.scheduleTask(flush, 0)
-    }
-    return true
-  }
-  function flush() {
-    running = false
-    if (buffer.length > 0) {
-      queue.unsafeOffer(buffer)
-      buffer = []
-    }
+    return Chunk.isEmpty(mailbox.unsafeOfferAll(items))
   }
   function done(exit: Exit.Exit<A, E>) {
     if (finished) return
     finished = true
     if (exit._tag === "Success") {
-      buffer.push(exit.value)
+      mailbox.unsafeOffer(exit.value)
     }
-    flush()
-    queue.unsafeOffer(exit._tag === "Success" ? Exit.void : exit)
+    mailbox.unsafeDone(exit._tag === "Success" ? Exit.void : exit)
   }
   return {
     single(value: A) {
-      if (finished) return false
-      buffer.push(value)
-      if (!running) {
-        running = true
-        scheduler.scheduleTask(flush, 0)
-      }
-      return true
+      return finished ? false : mailbox.unsafeOffer(value)
     },
     array,
     chunk(chunk) {
@@ -104,8 +73,7 @@ export const makePush = <E, A>(
     end() {
       if (finished) return
       finished = true
-      flush()
-      queue.unsafeOffer(Exit.void)
+      mailbox.unsafeDone(Exit.void)
     },
     halt(cause: Cause.Cause<E>) {
       return done(Exit.failCause(cause))

package/src/internal/stream.ts

@@ -11,11 +11,11 @@ import * as Equal from "../Equal.js"
 import type { ExecutionPlan } from "../ExecutionPlan.js"
 import * as Exit from "../Exit.js"
 import * as Fiber from "../Fiber.js"
-import * as FiberRef from "../FiberRef.js"
 import type { LazyArg } from "../Function.js"
 import { constTrue, dual, identity, pipe } from "../Function.js"
 import * as internalExecutionPlan from "../internal/executionPlan.js"
 import * as Layer from "../Layer.js"
+import type * as Mailbox from "../Mailbox.js"
 import * as MergeDecision from "../MergeDecision.js"
 import * as Option from "../Option.js"
 import type * as Order from "../Order.js"
@@ -42,7 +42,11 @@ import * as channel from "./channel.js"
 import * as channelExecutor from "./channel/channelExecutor.js"
 import * as MergeStrategy from "./channel/mergeStrategy.js"
 import * as core from "./core-stream.js"
+import * as effectCore from "./core.js"
 import * as doNotation from "./doNotation.js"
+import * as circular from "./effect/circular.js"
+import * as fiberRuntime from "./fiberRuntime.js"
+import * as mailbox from "./mailbox.js"
 import { RingBuffer } from "./ringBuffer.js"
 import * as InternalSchedule from "./schedule.js"
 import * as sink_ from "./sink.js"
@@ -592,21 +596,19 @@ export const asyncEffect = <A, E = never, R = never>(
     fromChannel
   )
 
-const queueFromBufferOptionsPush = <A, E>(
+const mailboxFromBufferOptionsPush = <A, E>(
   options?: { readonly bufferSize: "unbounded" } | {
     readonly bufferSize?: number | undefined
     readonly strategy?: "dropping" | "sliding" | undefined
   } | undefined
-): Effect.Effect<Queue.Queue<Array<A> | Exit.Exit<void, E>>> => {
+): Effect.Effect<Mailbox.Mailbox<A, E>> => {
   if (options?.bufferSize === "unbounded" || (options?.bufferSize === undefined && options?.strategy === undefined)) {
-    return Queue.unbounded()
-  }
-  switch (options?.strategy) {
-    case "sliding":
-      return Queue.sliding(options.bufferSize ?? 16)
-    default:
-      return Queue.dropping(options?.bufferSize ?? 16)
+    return mailbox.make()
   }
+  return mailbox.make({
+    capacity: options?.bufferSize ?? 16,
+    strategy: options?.strategy ?? "dropping"
+  })
 }
 
 /** @internal */
@@ -620,21 +622,12 @@ export const asyncPush = <A, E = never, R = never>(
   } | undefined
 ): Stream.Stream<A, E, Exclude<R, Scope.Scope>> =>
   Effect.acquireRelease(
-    queueFromBufferOptionsPush<A, E>(options),
-    Queue.shutdown
+    mailboxFromBufferOptionsPush<A, E>(options),
+    (mailbox) => mailbox.shutdown
   ).pipe(
-    Effect.tap((queue) =>
-      FiberRef.getWith(FiberRef.currentScheduler, (scheduler) => register(emit.makePush(queue, scheduler)))
-    ),
-    Effect.map((queue) => {
-      const loop: Channel.Channel<Chunk.Chunk<A>, unknown, E> = core.flatMap(Queue.take(queue), (item) =>
-        Exit.isExit(item)
-          ? Exit.isSuccess(item) ? core.void : core.failCause(item.cause)
-          : channel.zipRight(core.write(Chunk.unsafeFromArray(item)), loop))
-      return loop
-    }),
-    channel.unwrapScoped,
-    fromChannel
+    Effect.tap((mailbox) => register(emit.makePush(mailbox))),
+    Effect.map(mailboxToStream),
+    unwrapScoped
   )
 
 /** @internal */
@@ -3011,6 +3004,51 @@ export const toChannel = <A, E, R>(
   }
 }
 
+/** @internal */
+export const mailboxToStream = <A, E>(self: Mailbox.ReadonlyMailbox<A, E>): Stream.Stream<A, E> =>
+  fromChannel(mailbox.toChannel(self))
+
+/** @internal */
+export const mailboxFromStream: {
+  (options?: {
+    readonly capacity?: number | undefined
+    readonly strategy?: "suspend" | "dropping" | "sliding" | undefined
+  }): <A, E, R>(self: Stream.Stream<A, E, R>) => Effect.Effect<Mailbox.ReadonlyMailbox<A, E>, never, R | Scope.Scope>
+  <A, E, R>(
+    self: Stream.Stream<A, E, R>,
+    options?: {
+      readonly capacity?: number | undefined
+      readonly strategy?: "suspend" | "dropping" | "sliding" | undefined
+    }
+  ): Effect.Effect<Mailbox.ReadonlyMailbox<A, E>, never, R | Scope.Scope>
+} = dual((args) => isStream(args[0]), <A, E, R>(
+  self: Stream.Stream<A, E, R>,
+  options?: {
+    readonly capacity?: number | undefined
+    readonly strategy?: "suspend" | "dropping" | "sliding" | undefined
+  }
+): Effect.Effect<Mailbox.ReadonlyMailbox<A, E>, never, R | Scope.Scope> =>
+  effectCore.tap(
+    fiberRuntime.acquireRelease(
+      mailbox.make<A, E>(options),
+      (mailbox) => mailbox.shutdown
+    ),
+    (mailbox) => {
+      const writer: Channel.Channel<never, Chunk.Chunk<A>, never, E> = core.readWithCause({
+        onInput: (input: Chunk.Chunk<A>) => core.flatMap(mailbox.offerAll(input), () => writer),
+        onFailure: (cause: Cause.Cause<E>) => mailbox.failCause(cause),
+        onDone: () => mailbox.end
+      })
+      return fiberRuntime.scopeWith((scope) =>
+        toChannel(self).pipe(
+          core.pipeTo(writer),
+          channelExecutor.runIn(scope),
+          circular.forkIn(scope)
+        )
+      )
+    }
+  ))
+
 /** @internal */
 export const fromChunk = <A>(chunk: Chunk.Chunk<A>): Stream.Stream<A> =>
   new StreamImpl(Chunk.isEmpty(chunk) ? core.void : core.write(chunk))

package/src/internal/version.ts

@@ -1,4 +1,4 @@
-let moduleVersion = "3.21.5"
+let moduleVersion = "3.22.1"
 
 export const getCurrentVersion = () => moduleVersion