@effect/platform 0.48.28 → 0.49.0

package/src/internal/worker.ts

@@ -1,5 +1,6 @@
 import * as Schema from "@effect/schema/Schema"
 import * as Serializable from "@effect/schema/Serializable"
+import * as Array from "effect/Array"
 import * as Cause from "effect/Cause"
 import * as Channel from "effect/Channel"
 import * as Chunk from "effect/Chunk"
@@ -13,7 +14,6 @@ import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
 import * as Pool from "effect/Pool"
 import * as Queue from "effect/Queue"
-import * as ReadonlyArray from "effect/ReadonlyArray"
 import * as Schedule from "effect/Schedule"
 import type * as Scope from "effect/Scope"
 import * as Stream from "effect/Stream"
@@ -64,7 +64,7 @@ export const makeManager = Effect.gen(function*(_) {
   let idCounter = 0
   return WorkerManager.of({
     [WorkerManagerTypeId]: WorkerManagerTypeId,
-    spawn<I, E, O>({
+    spawn<I, O, E>({
       encode,
       initialMessage,
       permits = 1,
@@ -112,7 +112,7 @@ export const makeManager = Effect.gen(function*(_) {
               Queue.take(backing.queue),
               Effect.flatMap((msg) => {
                 if (msg[0] === 0) {
-                  return Deferred.complete(readyLatch, Effect.unit)
+                  return Deferred.complete(readyLatch, Effect.void)
                 }
                 return handleMessage(msg[1])
               }),
@@ -153,7 +153,7 @@ export const makeManager = Effect.gen(function*(_) {
         const handleMessage = (response: Worker.Worker.Response<E, O>) =>
           Effect.suspend(() => {
             const queue = requestMap.get(response[0])
-            if (!queue) return Effect.unit
+            if (!queue) return Effect.void
 
             switch (response[1]) {
               // data
@@ -210,7 +210,7 @@ export const makeManager = Effect.gen(function*(_) {
           exit: Exit.Exit<unknown, unknown>
         ) => {
           const release = Effect.zipRight(
-            Deferred.complete(deferred, Effect.unit),
+            Deferred.complete(deferred, Effect.void),
             Effect.sync(() => requestMap.delete(id))
           )
           return Exit.isFailure(exit) ?
@@ -229,7 +229,7 @@ export const makeManager = Effect.gen(function*(_) {
                 .flatMap(
                   Queue.take(queue),
                   Exit.match({
-                    onFailure: (cause) => Cause.isEmpty(cause) ? Channel.unit : Channel.failCause(cause),
+                    onFailure: (cause) => Cause.isEmpty(cause) ? Channel.void : Channel.failCause(cause),
                     onSuccess: (value) => Channel.flatMap(Channel.write(Chunk.unsafeFromArray(value)), () => loop)
                   })
                 )
@@ -240,7 +240,7 @@ export const makeManager = Effect.gen(function*(_) {
         const executeEffect = (request: I) =>
           Effect.acquireUseRelease(
             executeAcquire(request),
-            ([, queue]) => Effect.flatMap(Queue.take(queue), Exit.map(ReadonlyArray.unsafeGet(0))),
+            ([, queue]) => Effect.flatMap(Queue.take(queue), Exit.map(Array.unsafeGet(0))),
             executeRelease
           )
 
@@ -251,7 +251,7 @@ export const makeManager = Effect.gen(function*(_) {
             pipe(
               Effect.suspend(() => {
                 const result = requestMap.get(id)
-                if (!result) return Effect.unit
+                if (!result) return Effect.void
                 const transferables = transfers(request)
                 const spanTuple = Option.getOrUndefined(
                   Option.map(span, (span) => [span.traceId, span.spanId, span.sampled] as const)
@@ -296,14 +296,14 @@ export const makeManager = Effect.gen(function*(_) {
 export const layerManager = Layer.effect(WorkerManager, makeManager)
 
 /** @internal */
-export const makePool = <I, E, O>(
+export const makePool = <I, O, E>(
   options: Worker.WorkerPool.Options<I>
 ) =>
   Effect.gen(function*(_) {
     const manager = yield* _(WorkerManager)
-    const workers = new Set<Worker.Worker<I, E, O>>()
+    const workers = new Set<Worker.Worker<I, O, E>>()
     const acquire = pipe(
-      manager.spawn<I, E, O>(options),
+      manager.spawn<I, O, E>(options),
       Effect.tap((worker) => Effect.sync(() => workers.add(worker))),
       Effect.tap((worker) => Effect.addFinalizer(() => Effect.sync(() => workers.delete(worker)))),
       options.onCreate ? Effect.tap(options.onCreate) : identity
@@ -321,7 +321,7 @@ export const makePool = <I, E, O>(
           size: options.size
         })
     )
-    const pool: Worker.WorkerPool<I, E, O> = {
+    const pool: Worker.WorkerPool<I, O, E> = {
       backing,
       broadcast: (message: I) =>
         Effect.forEach(workers, (worker) => worker.executeEffect(message), {
@@ -346,8 +346,8 @@ export const makePool = <I, E, O>(
   })
 
 /** @internal */
-export const makePoolLayer = <Tag, I, E, O>(
-  tag: Context.Tag<Tag, Worker.WorkerPool<I, E, O>>,
+export const makePoolLayer = <Tag, I, O, E>(
+  tag: Context.Tag<Tag, Worker.WorkerPool<I, O, E>>,
   options: Worker.WorkerPool.Options<I>
 ) => Layer.scoped(tag, makePool(options))
 

package/src/internal/workerRunner.ts

@@ -32,13 +32,13 @@ export const PlatformRunner = Context.GenericTag<WorkerRunner.PlatformRunner>(
 /** @internal */
 export const make = <I, R, E, O>(
   process: (request: I) => Stream.Stream<O, E, R> | Effect.Effect<O, E, R>,
-  options?: WorkerRunner.Runner.Options<I, E, O>
+  options?: WorkerRunner.Runner.Options<I, O, E>
 ) =>
   Effect.gen(function*(_) {
     const scope = yield* _(Scope.fork(yield* _(Effect.scope), ExecutionStrategy.parallel))
     const fiber = Option.getOrThrow(Fiber.getCurrentFiber())
     const shutdown = Effect.zipRight(
-      Scope.close(scope, Exit.unit),
+      Scope.close(scope, Exit.void),
       Fiber.interruptFork(fiber)
     )
     const platform = yield* _(PlatformRunner)
@@ -51,19 +51,20 @@ export const make = <I, R, E, O>(
     yield* _(
       Queue.take(backing.queue),
       options?.decode ?
-        Effect.flatMap((req): Effect.Effect<Worker.Worker.Request<I>, WorkerError> => {
+        Effect.flatMap((msg): Effect.Effect<readonly [portId: number, Worker.Worker.Request<I>], WorkerError> => {
+          const req = msg[1]
           if (req[1] === 1) {
-            return Effect.succeed(req)
+            return Effect.succeed(msg)
           }
 
-          return Effect.map(options.decode!(req[2]), (data) => [req[0], req[1], data, req[3]])
+          return Effect.map(options.decode!(req[2]), (data) => [msg[0], [req[0], req[1], data, req[3]]])
         }) :
         identity,
-      Effect.tap((req) => {
+      Effect.tap(([portId, req]) => {
         const id = req[0]
         if (req[1] === 1) {
           const fiber = fiberMap.get(id)
-          if (!fiber) return Effect.unit
+          if (!fiber) return Effect.void
           return Fiber.interrupt(fiber)
         }
 
@@ -79,7 +80,7 @@ export const make = <I, R, E, O>(
                     ? Effect.provideService(options.encodeOutput(req[2], data), Transferable.Collector, collector)
                     : Effect.succeed(data),
                   Effect.flatMap((payload) =>
-                    backing.send([id, 0, [payload]], [
+                    backing.send(portId, [id, 0, [payload]], [
                       ...transfers,
                       ...collector.unsafeRead()
                     ])
@@ -93,7 +94,7 @@ export const make = <I, R, E, O>(
                   if (options?.encodeOutput === undefined) {
                     const payload = Chunk.toReadonlyArray(data)
                     const transfers = options?.transfers ? payload.flatMap(options.transfers) : undefined
-                    return backing.send([id, 0, payload], transfers)
+                    return backing.send(portId, [id, 0, payload], transfers)
                   }
 
                   const transfers: Array<unknown> = []
@@ -110,12 +111,12 @@ export const make = <I, R, E, O>(
                     Effect.provideService(Transferable.Collector, collector),
                     Effect.flatMap((payload) => {
                       collector.unsafeRead().forEach((transfer) => transfers.push(transfer))
-                      return backing.send([id, 0, payload], transfers)
+                      return backing.send(portId, [id, 0, payload], transfers)
                     })
                   )
                 }),
                 Stream.runDrain,
-                Effect.andThen(backing.send([id, 1]))
+                Effect.andThen(backing.send(portId, [id, 1]))
               )
 
             if (req[3]) {
@@ -131,7 +132,8 @@ export const make = <I, R, E, O>(
 
             return effect
           }),
-          Effect.catchIf(isWorkerError, (error) => backing.send([id, 3, WorkerError.encodeCause(Cause.fail(error))])),
+          Effect.catchIf(isWorkerError, (error) =>
+            backing.send(portId, [id, 3, WorkerError.encodeCause(Cause.fail(error))])),
           Effect.catchAllCause((cause) =>
             Either.match(Cause.failureOrCause(cause), {
               onLeft: (error) => {
@@ -146,15 +148,17 @@ export const make = <I, R, E, O>(
                     )
                     : Effect.succeed(error),
                   Effect.flatMap((payload) =>
-                    backing.send([id, 2, payload as any], [
+                    backing.send(portId, [id, 2, payload as any], [
                       ...transfers,
                       ...collector.unsafeRead()
                     ])
                   ),
-                  Effect.catchAllCause((cause) => backing.send([id, 3, WorkerError.encodeCause(cause)]))
+                  Effect.catchAllCause((cause) =>
+                    backing.send(portId, [id, 3, WorkerError.encodeCause(cause)])
+                  )
                 )
               },
-              onRight: (cause) => backing.send([id, 3, WorkerError.encodeCause(cause)])
+              onRight: (cause) => backing.send(portId, [id, 3, WorkerError.encodeCause(cause)])
             })
           ),
           Effect.ensuring(Effect.sync(() => fiberMap.delete(id))),
@@ -170,7 +174,7 @@ export const make = <I, R, E, O>(
 /** @internal */
 export const layer = <I, R, E, O>(
   process: (request: I) => Stream.Stream<O, E, R> | Effect.Effect<O, E, R>,
-  options?: WorkerRunner.Runner.Options<I, E, O>
+  options?: WorkerRunner.Runner.Options<I, O, E>
 ): Layer.Layer<never, WorkerError, WorkerRunner.PlatformRunner | R> => Layer.scopedDiscard(make(process, options))
 
 /** @internal */