effect 2.2.5 → 2.3.0

package/src/internal/channel/channelState.ts

@@ -65,9 +65,9 @@ export interface FromEffect extends
 export interface Read extends
   Op<OpCodes.OP_READ, {
     readonly upstream: ErasedExecutor<unknown>
-    onEffect(effect: Effect.Effect<unknown, never, void>): Effect.Effect<unknown, never, void>
-    onEmit(value: unknown): Effect.Effect<unknown, never, void>
-    onDone(exit: Exit.Exit<unknown, unknown>): Effect.Effect<unknown, never, void>
+    onEffect(effect: Effect.Effect<void, never, unknown>): Effect.Effect<void, never, unknown>
+    onEmit(value: unknown): Effect.Effect<void, never, unknown>
+    onDone(exit: Exit.Exit<unknown, unknown>): Effect.Effect<void, never, unknown>
   }>
 {}
 
@@ -86,7 +86,7 @@ export const Emit = (): ChannelState<never, never> => {
 }
 
 /** @internal */
-export const FromEffect = <R, E, _>(effect: Effect.Effect<R, E, _>): ChannelState<R, E> => {
+export const FromEffect = <R, E, _>(effect: Effect.Effect<_, E, R>): ChannelState<R, E> => {
   const op = Object.create(proto)
   op._tag = OpCodes.OP_FROM_EFFECT
   op.effect = effect
@@ -96,9 +96,9 @@ export const FromEffect = <R, E, _>(effect: Effect.Effect<R, E, _>): ChannelStat
 /** @internal */
 export const Read = <R>(
   upstream: ErasedExecutor<R>,
-  onEffect: (effect: Effect.Effect<R, never, void>) => Effect.Effect<R, never, void>,
-  onEmit: (value: unknown) => Effect.Effect<R, never, void> | undefined,
-  onDone: (exit: Exit.Exit<unknown, unknown>) => Effect.Effect<R, never, void> | undefined
+  onEffect: (effect: Effect.Effect<void, never, R>) => Effect.Effect<void, never, R>,
+  onEmit: (value: unknown) => Effect.Effect<void, never, R> | undefined,
+  onDone: (exit: Exit.Exit<unknown, unknown>) => Effect.Effect<void, never, R> | undefined
 ): ChannelState<R, never> => {
   const op = Object.create(proto)
   op._tag = OpCodes.OP_READ
@@ -126,9 +126,9 @@ export const isFromEffect = <R, E>(self: ChannelState<R, E>): self is FromEffect
 export const isRead = <R, E>(self: ChannelState<R, E>): self is Read => (self as Primitive)._tag === OpCodes.OP_READ
 
 /** @internal */
-export const effect = <R, E>(self: ChannelState<R, E>): Effect.Effect<R, E, void> =>
-  isFromEffect(self) ? self.effect as Effect.Effect<R, E, void> : Effect.unit
+export const effect = <R, E>(self: ChannelState<R, E>): Effect.Effect<void, E, R> =>
+  isFromEffect(self) ? self.effect as Effect.Effect<void, E, R> : Effect.unit
 
 /** @internal */
-export const effectOrUndefinedIgnored = <R, E>(self: ChannelState<R, E>): Effect.Effect<R, E, void> | undefined =>
-  isFromEffect(self) ? Effect.ignore(self.effect as Effect.Effect<R, E, void>) : undefined
+export const effectOrUndefinedIgnored = <R, E>(self: ChannelState<R, E>): Effect.Effect<void, E, R> | undefined =>
+  isFromEffect(self) ? Effect.ignore(self.effect as Effect.Effect<void, E, R>) : undefined

package/src/internal/channel/continuation.ts

@@ -98,13 +98,13 @@ export interface ContinuationK<
   readonly _tag: OpCodes.OP_CONTINUATION_K
   onSuccess(
     o: OutDone
-  ): Channel.Channel<Env, InErr, InElem, InDone, OutErr2, OutElem, OutDone2>
+  ): Channel.Channel<OutElem, InElem, OutErr2, InErr, OutDone2, InDone, Env>
   onHalt(
     c: Cause.Cause<OutErr>
-  ): Channel.Channel<Env, InErr, InElem, InDone, OutErr2, OutElem, OutDone2>
+  ): Channel.Channel<OutElem, InElem, OutErr2, InErr, OutDone2, InDone, Env>
   onExit(
-    exit: Exit.Exit<OutErr, OutDone>
-  ): Channel.Channel<Env, InErr, InElem, InDone, OutErr2, OutElem, OutDone2>
+    exit: Exit.Exit<OutDone, OutErr>
+  ): Channel.Channel<OutElem, InElem, OutErr2, InErr, OutDone2, InDone, Env>
 }
 
 /** @internal */
@@ -122,7 +122,7 @@ export interface ContinuationFinalizer<out Env, out OutErr, out OutDone> extends
   >
 {
   readonly _tag: OpCodes.OP_CONTINUATION_FINALIZER
-  finalizer(exit: Exit.Exit<OutErr, OutDone>): Effect.Effect<Env, never, unknown>
+  finalizer(exit: Exit.Exit<OutErr, OutDone>): Effect.Effect<unknown, never, Env>
 }
 
 const continuationVariance = {
@@ -176,15 +176,15 @@ export class ContinuationKImpl<
   constructor(
     readonly onSuccess: (
       o: OutDone
-    ) => Channel.Channel<Env, InErr, InElem, InDone, OutErr2, OutElem, OutDone2>,
+    ) => Channel.Channel<OutElem, InElem, OutErr2, InErr, OutDone2, InDone, Env>,
     readonly onHalt: (
       c: Cause.Cause<OutErr>
-    ) => Channel.Channel<Env2, InErr, InElem, InDone, OutErr2, OutElem, OutDone2>
+    ) => Channel.Channel<OutElem, InElem, OutErr2, InErr, OutDone2, InDone, Env2>
   ) {
   }
   onExit(
-    exit: Exit.Exit<OutErr, OutDone>
-  ): Channel.Channel<Env | Env2, InErr, InElem, InDone, OutErr2, OutElem, OutDone2> {
+    exit: Exit.Exit<OutDone, OutErr>
+  ): Channel.Channel<OutElem, InElem, OutErr2, InErr, OutDone2, InDone, Env | Env2> {
     return Exit.isFailure(exit) ? this.onHalt(exit.cause) : this.onSuccess(exit.value)
   }
 }
@@ -195,6 +195,6 @@ export class ContinuationFinalizerImpl<out Env, in out OutErr, in out OutDone>
 {
   readonly _tag = OpCodes.OP_CONTINUATION_FINALIZER
   readonly [ContinuationTypeId] = continuationVariance
-  constructor(readonly finalizer: (exit: Exit.Exit<OutErr, OutDone>) => Effect.Effect<Env, never, unknown>) {
+  constructor(readonly finalizer: (exit: Exit.Exit<OutErr, OutDone>) => Effect.Effect<unknown, never, Env>) {
   }
 }

package/src/internal/channel/mergeDecision.ts

@@ -40,20 +40,20 @@ export type Op<Tag extends string, Body = {}> =
 /** @internal */
 export interface Done extends
   Op<OpCodes.OP_DONE, {
-    readonly effect: Effect.Effect<never, never, never>
+    readonly effect: Effect.Effect<never>
   }>
 {}
 
 /** @internal */
 export interface Await extends
   Op<OpCodes.OP_AWAIT, {
-    f(exit: Exit.Exit<unknown, unknown>): Effect.Effect<never, never, never>
+    f(exit: Exit.Exit<unknown, unknown>): Effect.Effect<never>
   }>
 {}
 
 /** @internal */
-export const Done = <R, E, Z>(
-  effect: Effect.Effect<R, E, Z>
+export const Done = <Z, E, R>(
+  effect: Effect.Effect<Z, E, R>
 ): MergeDecision.MergeDecision<R, unknown, unknown, E, Z> => {
   const op = Object.create(proto)
   op._tag = OpCodes.OP_DONE
@@ -63,7 +63,7 @@ export const Done = <R, E, Z>(
 
 /** @internal */
 export const Await = <R, E0, Z0, E, Z>(
-  f: (exit: Exit.Exit<E0, Z0>) => Effect.Effect<R, E, Z>
+  f: (exit: Exit.Exit<Z0, E0>) => Effect.Effect<Z, E, R>
 ): MergeDecision.MergeDecision<R, E0, Z0, E, Z> => {
   const op = Object.create(proto)
   op._tag = OpCodes.OP_AWAIT
@@ -73,7 +73,7 @@ export const Await = <R, E0, Z0, E, Z>(
 
 /** @internal */
 export const AwaitConst = <R, E, Z>(
-  effect: Effect.Effect<R, E, Z>
+  effect: Effect.Effect<Z, E, R>
 ): MergeDecision.MergeDecision<R, unknown, unknown, E, Z> => Await(() => effect)
 
 /** @internal */
@@ -85,31 +85,29 @@ export const isMergeDecision = (
 export const match = dual<
   <R, E0, Z0, E, Z, Z2>(
     options: {
-      readonly onDone: (effect: Effect.Effect<R, E, Z>) => Z2
-      readonly onAwait: (f: (exit: Exit.Exit<E0, Z0>) => Effect.Effect<R, E, Z>) => Z2
+      readonly onDone: (effect: Effect.Effect<Z, E, R>) => Z2
+      readonly onAwait: (f: (exit: Exit.Exit<Z0, E0>) => Effect.Effect<Z, E, R>) => Z2
     }
   ) => (self: MergeDecision.MergeDecision<R, E0, Z0, E, Z>) => Z2,
   <R, E0, Z0, E, Z, Z2>(
     self: MergeDecision.MergeDecision<R, E0, Z0, E, Z>,
     options: {
-      readonly onDone: (effect: Effect.Effect<R, E, Z>) => Z2
-      readonly onAwait: (f: (exit: Exit.Exit<E0, Z0>) => Effect.Effect<R, E, Z>) => Z2
+      readonly onDone: (effect: Effect.Effect<Z, E, R>) => Z2
+      readonly onAwait: (f: (exit: Exit.Exit<Z0, E0>) => Effect.Effect<Z, E, R>) => Z2
     }
   ) => Z2
 >(2, <R, E0, Z0, E, Z, Z2>(
   self: MergeDecision.MergeDecision<R, E0, Z0, E, Z>,
   { onAwait, onDone }: {
-    readonly onDone: (effect: Effect.Effect<R, E, Z>) => Z2
-    readonly onAwait: (f: (exit: Exit.Exit<E0, Z0>) => Effect.Effect<R, E, Z>) => Z2
+    readonly onDone: (effect: Effect.Effect<Z, E, R>) => Z2
+    readonly onAwait: (f: (exit: Exit.Exit<Z0, E0>) => Effect.Effect<Z, E, R>) => Z2
   }
 ): Z2 => {
   const op = self as Primitive
   switch (op._tag) {
-    case OpCodes.OP_DONE: {
+    case OpCodes.OP_DONE:
       return onDone(op.effect)
-    }
-    case OpCodes.OP_AWAIT: {
+    case OpCodes.OP_AWAIT:
       return onAwait(op.f)
-    }
   }
 })

package/src/internal/channel/mergeState.ts

@@ -22,8 +22,8 @@ const proto = {
 
 /** @internal */
 export const BothRunning = <Env, Err, Err1, Err2, Elem, Done, Done1, Done2>(
-  left: Fiber.Fiber<Err, Either.Either<Done, Elem>>,
-  right: Fiber.Fiber<Err1, Either.Either<Done1, Elem>>
+  left: Fiber.Fiber<Either.Either<Done, Elem>, Err>,
+  right: Fiber.Fiber<Either.Either<Done1, Elem>, Err1>
 ): MergeState.MergeState<Env, Err, Err1, Err2, Elem, Done, Done1, Done2> => {
   const op = Object.create(proto)
   op._tag = OpCodes.OP_BOTH_RUNNING
@@ -34,7 +34,7 @@ export const BothRunning = <Env, Err, Err1, Err2, Elem, Done, Done1, Done2>(
 
 /** @internal */
 export const LeftDone = <Env, Err, Err1, Err2, Elem, Done, Done1, Done2>(
-  f: (exit: Exit.Exit<Err1, Done1>) => Effect.Effect<Env, Err2, Done2>
+  f: (exit: Exit.Exit<Done1, Err1>) => Effect.Effect<Done2, Err2, Env>
 ): MergeState.MergeState<Env, Err, Err1, Err2, Elem, Done, Done1, Done2> => {
   const op = Object.create(proto)
   op._tag = OpCodes.OP_LEFT_DONE
@@ -44,7 +44,7 @@ export const LeftDone = <Env, Err, Err1, Err2, Elem, Done, Done1, Done2>(
 
 /** @internal */
 export const RightDone = <Env, Err, Err1, Err2, Elem, Done, Done1, Done2>(
-  f: (exit: Exit.Exit<Err, Done>) => Effect.Effect<Env, Err2, Done2>
+  f: (exit: Exit.Exit<Done, Err>) => Effect.Effect<Done2, Err2, Env>
 ): MergeState.MergeState<Env, Err, Err1, Err2, Elem, Done, Done1, Done2> => {
   const op = Object.create(proto)
   op._tag = OpCodes.OP_RIGHT_DONE
@@ -84,22 +84,22 @@ export const match = dual<
   <Env, Err, Err1, Err2, Elem, Done, Done1, Done2, Z>(
     options: {
       readonly onBothRunning: (
-        left: Fiber.Fiber<Err, Either.Either<Done, Elem>>,
-        right: Fiber.Fiber<Err1, Either.Either<Done1, Elem>>
+        left: Fiber.Fiber<Either.Either<Done, Elem>, Err>,
+        right: Fiber.Fiber<Either.Either<Done1, Elem>, Err1>
       ) => Z
-      readonly onLeftDone: (f: (exit: Exit.Exit<Err1, Done1>) => Effect.Effect<Env, Err2, Done2>) => Z
-      readonly onRightDone: (f: (exit: Exit.Exit<Err, Done>) => Effect.Effect<Env, Err2, Done2>) => Z
+      readonly onLeftDone: (f: (exit: Exit.Exit<Done1, Err1>) => Effect.Effect<Done2, Err2, Env>) => Z
+      readonly onRightDone: (f: (exit: Exit.Exit<Done, Err>) => Effect.Effect<Done2, Err2, Env>) => Z
     }
   ) => (self: MergeState.MergeState<Env, Err, Err1, Err2, Elem, Done, Done1, Done2>) => Z,
   <Env, Err, Err1, Err2, Elem, Done, Done1, Done2, Z>(
     self: MergeState.MergeState<Env, Err, Err1, Err2, Elem, Done, Done1, Done2>,
     options: {
       readonly onBothRunning: (
-        left: Fiber.Fiber<Err, Either.Either<Done, Elem>>,
-        right: Fiber.Fiber<Err1, Either.Either<Done1, Elem>>
+        left: Fiber.Fiber<Either.Either<Done, Elem>, Err>,
+        right: Fiber.Fiber<Either.Either<Done1, Elem>, Err1>
       ) => Z
-      readonly onLeftDone: (f: (exit: Exit.Exit<Err1, Done1>) => Effect.Effect<Env, Err2, Done2>) => Z
-      readonly onRightDone: (f: (exit: Exit.Exit<Err, Done>) => Effect.Effect<Env, Err2, Done2>) => Z
+      readonly onLeftDone: (f: (exit: Exit.Exit<Done1, Err1>) => Effect.Effect<Done2, Err2, Env>) => Z
+      readonly onRightDone: (f: (exit: Exit.Exit<Done, Err>) => Effect.Effect<Done2, Err2, Env>) => Z
     }
   ) => Z
 >(2, (

package/src/internal/channel/singleProducerAsyncInput.ts

@@ -41,13 +41,13 @@ type OP_STATE_DONE = typeof OP_STATE_DONE
 /** @internal */
 interface Empty {
   readonly _tag: OP_STATE_EMPTY
-  readonly notifyProducer: Deferred.Deferred<never, void>
+  readonly notifyProducer: Deferred.Deferred<void>
 }
 
 /** @internal */
 interface Emit<Err, Elem, Done> {
   readonly _tag: OP_STATE_EMIT
-  readonly notifyConsumers: ReadonlyArray<Deferred.Deferred<Err, Either.Either<Done, Elem>>>
+  readonly notifyConsumers: ReadonlyArray<Deferred.Deferred<Either.Either<Done, Elem>, Err>>
 }
 
 /** @internal */
@@ -63,14 +63,14 @@ interface Done<_Done> {
 }
 
 /** @internal */
-const stateEmpty = (notifyProducer: Deferred.Deferred<never, void>): State<never, never, never> => ({
+const stateEmpty = (notifyProducer: Deferred.Deferred<void>): State<never, never, never> => ({
   _tag: OP_STATE_EMPTY,
   notifyProducer
 })
 
 /** @internal */
 const stateEmit = <Err, Elem, Done>(
-  notifyConsumers: ReadonlyArray<Deferred.Deferred<Err, Either.Either<Done, Elem>>>
+  notifyConsumers: ReadonlyArray<Deferred.Deferred<Either.Either<Done, Elem>, Err>>
 ): State<Err, Elem, Done> => ({
   _tag: OP_STATE_EMIT,
   notifyConsumers
@@ -95,7 +95,7 @@ class SingleProducerAsyncInputImpl<in out Err, in out Elem, in out Done>
   constructor(readonly ref: Ref.Ref<State<Err, Elem, Done>>) {
   }
 
-  awaitRead(): Effect.Effect<never, never, unknown> {
+  awaitRead(): Effect.Effect<unknown> {
     return Effect.flatten(
       Ref.modify(this.ref, (state) =>
         state._tag === OP_STATE_EMPTY ?
@@ -104,11 +104,11 @@ class SingleProducerAsyncInputImpl<in out Err, in out Elem, in out Done>
     )
   }
 
-  get close(): Effect.Effect<never, never, unknown> {
+  get close(): Effect.Effect<unknown> {
     return Effect.fiberIdWith((fiberId) => this.error(Cause.interrupt(fiberId)))
   }
 
-  done(value: Done): Effect.Effect<never, never, unknown> {
+  done(value: Done): Effect.Effect<unknown> {
     return Effect.flatten(
       Ref.modify(this.ref, (state) => {
         switch (state._tag) {
@@ -136,8 +136,8 @@ class SingleProducerAsyncInputImpl<in out Err, in out Elem, in out Done>
     )
   }
 
-  emit(element: Elem): Effect.Effect<never, never, unknown> {
-    return Effect.flatMap(Deferred.make<never, void>(), (deferred) =>
+  emit(element: Elem): Effect.Effect<unknown> {
+    return Effect.flatMap(Deferred.make<void>(), (deferred) =>
       Effect.flatten(
         Ref.modify(this.ref, (state) => {
           switch (state._tag) {
@@ -170,7 +170,7 @@ class SingleProducerAsyncInputImpl<in out Err, in out Elem, in out Done>
       ))
   }
 
-  error(cause: Cause.Cause<Err>): Effect.Effect<never, never, unknown> {
+  error(cause: Cause.Cause<Err>): Effect.Effect<unknown> {
     return Effect.flatten(
       Ref.modify(this.ref, (state) => {
         switch (state._tag) {
@@ -198,10 +198,10 @@ class SingleProducerAsyncInputImpl<in out Err, in out Elem, in out Done>
     )
   }
 
-  get take(): Effect.Effect<never, never, Exit.Exit<Either.Either<Err, Done>, Elem>> {
+  get take(): Effect.Effect<Exit.Exit<Elem, Either.Either<Err, Done>>> {
     return this.takeWith(
       (cause) => Exit.failCause(Cause.map(cause, Either.left)),
-      (elem) => Exit.succeed(elem) as Exit.Exit<Either.Either<Err, Done>, Elem>,
+      (elem) => Exit.succeed(elem) as Exit.Exit<Elem, Either.Either<Err, Done>>,
       (done) => Exit.fail(Either.right(done))
     )
   }
@@ -210,8 +210,8 @@ class SingleProducerAsyncInputImpl<in out Err, in out Elem, in out Done>
     onError: (cause: Cause.Cause<Err>) => A,
     onElement: (element: Elem) => A,
     onDone: (value: Done) => A
-  ): Effect.Effect<never, never, A> {
-    return Effect.flatMap(Deferred.make<Err, Either.Either<Done, Elem>>(), (deferred) =>
+  ): Effect.Effect<A> {
+    return Effect.flatMap(Deferred.make<Either.Either<Done, Elem>, Err>(), (deferred) =>
       Effect.flatten(
         Ref.modify(this.ref, (state) => {
           switch (state._tag) {
@@ -250,12 +250,10 @@ class SingleProducerAsyncInputImpl<in out Err, in out Elem, in out Done>
 
 /** @internal */
 export const make = <Err, Elem, Done>(): Effect.Effect<
-  never,
-  never,
   SingleProducerAsyncInput.SingleProducerAsyncInput<Err, Elem, Done>
 > =>
   pipe(
-    Deferred.make<never, void>(),
+    Deferred.make<void>(),
     Effect.flatMap((deferred) => Ref.make(stateEmpty(deferred) as State<Err, Elem, Done>)),
     Effect.map((ref) => new SingleProducerAsyncInputImpl(ref))
   )

package/src/internal/channel/subexecutor.ts

@@ -8,7 +8,7 @@ import type { ErasedChannel, ErasedExecutor } from "./channelExecutor.js"
 
 /** @internal */
 export interface Subexecutor<in out R> {
-  close(exit: Exit.Exit<unknown, unknown>): Effect.Effect<R, never, unknown> | undefined
+  close(exit: Exit.Exit<unknown, unknown>): Effect.Effect<unknown, never, R> | undefined
   enqueuePullFromChild(child: PullFromChild<R>): Subexecutor<R>
 }
 
@@ -55,7 +55,7 @@ export class PullFromChild<in out R> implements Subexecutor<R> {
   ) {
   }
 
-  close(exit: Exit.Exit<unknown, unknown>): Effect.Effect<R, never, unknown> | undefined {
+  close(exit: Exit.Exit<unknown, unknown>): Effect.Effect<unknown, never, R> | undefined {
     const fin1 = this.childExecutor.close(exit)
     const fin2 = this.parentSubexecutor.close(exit)
     if (fin1 !== undefined && fin2 !== undefined) {
@@ -101,7 +101,7 @@ export class PullFromUpstream<in out R> implements Subexecutor<R> {
   ) {
   }
 
-  close(exit: Exit.Exit<unknown, unknown>): Effect.Effect<R, never, unknown> | undefined {
+  close(exit: Exit.Exit<unknown, unknown>): Effect.Effect<unknown, never, R> | undefined {
     const fin1 = this.upstreamExecutor.close(exit)
     const fins = [
       ...this.activeChildExecutors.map((child) =>
@@ -112,7 +112,7 @@ export class PullFromUpstream<in out R> implements Subexecutor<R> {
       fin1
     ]
     const result = fins.reduce(
-      (acc: Effect.Effect<R, never, Exit.Exit<unknown, unknown>> | undefined, next) => {
+      (acc: Effect.Effect<Exit.Exit<unknown, unknown>, never, R> | undefined, next) => {
         if (acc !== undefined && next !== undefined) {
           return Effect.zipWith(
             acc,
@@ -168,7 +168,7 @@ export class DrainChildExecutors<in out R> implements Subexecutor<R> {
   ) {
   }
 
-  close(exit: Exit.Exit<unknown, unknown>): Effect.Effect<R, never, unknown> | undefined {
+  close(exit: Exit.Exit<unknown, unknown>): Effect.Effect<unknown, never, R> | undefined {
     const fin1 = this.upstreamExecutor.close(exit)
     const fins = [
       ...this.activeChildExecutors.map((child) => (child !== undefined ?
@@ -178,7 +178,7 @@ export class DrainChildExecutors<in out R> implements Subexecutor<R> {
       fin1
     ]
     const result = fins.reduce(
-      (acc: Effect.Effect<R, never, Exit.Exit<unknown, unknown>> | undefined, next) => {
+      (acc: Effect.Effect<Exit.Exit<unknown, unknown>, never, R> | undefined, next) => {
         if (acc !== undefined && next !== undefined) {
           return Effect.zipWith(
             acc,
@@ -218,7 +218,7 @@ export class Emit<in out R> implements Subexecutor<R> {
   constructor(readonly value: unknown, readonly next: Subexecutor<R>) {
   }
 
-  close(exit: Exit.Exit<unknown, unknown>): Effect.Effect<R, never, unknown> | undefined {
+  close(exit: Exit.Exit<unknown, unknown>): Effect.Effect<unknown, never, R> | undefined {
     const result = this.next.close(exit)
     return result === undefined ? result : result
   }