effect 2.2.5 → 2.3.1

package/src/internal/cache.ts

@@ -38,7 +38,7 @@ export type MapValue<Key, Error, Value> =
 export interface Complete<out Key, out Error, out Value> {
   readonly _tag: "Complete"
   readonly key: MapKey<Key>
-  readonly exit: Exit.Exit<Error, Value>
+  readonly exit: Exit.Exit<Value, Error>
   readonly entryStats: Cache.EntryStats
   readonly timeToLiveMillis: number
 }
@@ -47,25 +47,25 @@ export interface Complete<out Key, out Error, out Value> {
 export interface Pending<out Key, in out Error, in out Value> {
   readonly _tag: "Pending"
   readonly key: MapKey<Key>
-  readonly deferred: Deferred.Deferred<Error, Value>
+  readonly deferred: Deferred.Deferred<Value, Error>
 }
 
 /** @internal */
 export interface Refreshing<out Key, in out Error, in out Value> {
   readonly _tag: "Refreshing"
-  readonly deferred: Deferred.Deferred<Error, Value>
+  readonly deferred: Deferred.Deferred<Value, Error>
   readonly complete: Complete<Key, Error, Value>
 }
 
 /** @internal */
 export const complete = <Key, Error, Value>(
   key: MapKey<Key>,
-  exit: Exit.Exit<Error, Value>,
+  exit: Exit.Exit<Value, Error>,
   entryStats: Cache.EntryStats,
   timeToLiveMillis: number
 ): MapValue<Key, Error, Value> =>
   Data.struct({
-    _tag: "Complete",
+    _tag: "Complete" as const,
     key,
     exit,
     entryStats,
@@ -75,21 +75,21 @@ export const complete = <Key, Error, Value>(
 /** @internal */
 export const pending = <Key, Error, Value>(
   key: MapKey<Key>,
-  deferred: Deferred.Deferred<Error, Value>
+  deferred: Deferred.Deferred<Value, Error>
 ): MapValue<Key, Error, Value> =>
   Data.struct({
-    _tag: "Pending",
+    _tag: "Pending" as const,
     key,
     deferred
   })
 
 /** @internal */
 export const refreshing = <Key, Error, Value>(
-  deferred: Deferred.Deferred<Error, Value>,
+  deferred: Deferred.Deferred<Value, Error>,
   complete: Complete<Key, Error, Value>
 ): MapValue<Key, Error, Value> =>
   Data.struct({
-    _tag: "Refreshing",
+    _tag: "Refreshing" as const,
     deferred,
     complete
   })
@@ -299,16 +299,16 @@ class CacheImpl<in out Key, in out Error, in out Value> implements Cache.Cache<K
     readonly context: Context.Context<any>,
     readonly fiberId: FiberId.FiberId,
     readonly lookup: Cache.Lookup<Key, any, Error, Value>,
-    readonly timeToLive: (exit: Exit.Exit<Error, Value>) => Duration.DurationInput
+    readonly timeToLive: (exit: Exit.Exit<Value, Error>) => Duration.DurationInput
   ) {
     this.cacheState = initialCacheState()
   }
 
-  get(key: Key): Effect.Effect<never, Error, Value> {
+  get(key: Key): Effect.Effect<Value, Error> {
     return core.map(this.getEither(key), Either.merge)
   }
 
-  get cacheStats(): Effect.Effect<never, never, Cache.CacheStats> {
+  get cacheStats(): Effect.Effect<Cache.CacheStats> {
     return core.sync(() =>
       makeCacheStats({
         hits: this.cacheState.hits,
@@ -318,7 +318,7 @@ class CacheImpl<in out Key, in out Error, in out Value> implements Cache.Cache<K
     )
   }
 
-  getOption(key: Key): Effect.Effect<never, Error, Option.Option<Value>> {
+  getOption(key: Key): Effect.Effect<Option.Option<Value>, Error> {
     return core.suspend(() =>
       Option.match(MutableHashMap.get(this.cacheState.map, key), {
         onNone: () => {
@@ -332,7 +332,7 @@ class CacheImpl<in out Key, in out Error, in out Value> implements Cache.Cache<K
     )
   }
 
-  getOptionComplete(key: Key): Effect.Effect<never, never, Option.Option<Value>> {
+  getOptionComplete(key: Key): Effect.Effect<Option.Option<Value>> {
     return core.suspend(() =>
       Option.match(MutableHashMap.get(this.cacheState.map, key), {
         onNone: () => {
@@ -341,16 +341,16 @@ class CacheImpl<in out Key, in out Error, in out Value> implements Cache.Cache<K
           this.trackMiss()
           return core.succeed(Option.none<Value>())
         },
-        onSome: (value) => this.resolveMapValue(value, true) as Effect.Effect<never, never, Option.Option<Value>>
+        onSome: (value) => this.resolveMapValue(value, true) as Effect.Effect<Option.Option<Value>>
       })
     )
   }
 
-  contains(key: Key): Effect.Effect<never, never, boolean> {
+  contains(key: Key): Effect.Effect<boolean> {
     return core.sync(() => MutableHashMap.has(this.cacheState.map, key))
   }
 
-  entryStats(key: Key): Effect.Effect<never, never, Option.Option<Cache.EntryStats>> {
+  entryStats(key: Key): Effect.Effect<Option.Option<Cache.EntryStats>> {
     return core.sync(() => {
       const option = MutableHashMap.get(this.cacheState.map, key)
       if (Option.isSome(option)) {
@@ -372,14 +372,14 @@ class CacheImpl<in out Key, in out Error, in out Value> implements Cache.Cache<K
     })
   }
 
-  getEither(key: Key): Effect.Effect<never, Error, Either.Either<Value, Value>> {
-    return core.suspend((): Effect.Effect<never, Error, Either.Either<Value, Value>> => {
+  getEither(key: Key): Effect.Effect<Either.Either<Value, Value>, Error> {
+    return core.suspend((): Effect.Effect<Either.Either<Value, Value>, Error> => {
       const k = key
       let mapKey: MapKey<Key> | undefined = undefined
-      let deferred: Deferred.Deferred<Error, Value> | undefined = undefined
+      let deferred: Deferred.Deferred<Value, Error> | undefined = undefined
       let value = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, k))
       if (value === undefined) {
-        deferred = Deferred.unsafeMake<Error, Value>(this.fiberId)
+        deferred = Deferred.unsafeMake<Value, Error>(this.fiberId)
         mapKey = makeMapKey(k)
         if (MutableHashMap.has(this.cacheState.map, k)) {
           value = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, k))
@@ -403,13 +403,13 @@ class CacheImpl<in out Key, in out Error, in out Value> implements Cache.Cache<K
     })
   }
 
-  invalidate(key: Key): Effect.Effect<never, never, void> {
+  invalidate(key: Key): Effect.Effect<void> {
     return core.sync(() => {
       MutableHashMap.remove(this.cacheState.map, key)
     })
   }
 
-  invalidateWhen(key: Key, when: (value: Value) => boolean): Effect.Effect<never, never, void> {
+  invalidateWhen(key: Key, when: (value: Value) => boolean): Effect.Effect<void> {
     return core.sync(() => {
       const value = MutableHashMap.get(this.cacheState.map, key)
       if (Option.isSome(value) && value.value._tag === "Complete") {
@@ -422,17 +422,17 @@ class CacheImpl<in out Key, in out Error, in out Value> implements Cache.Cache<K
     })
   }
 
-  get invalidateAll(): Effect.Effect<never, never, void> {
+  get invalidateAll(): Effect.Effect<void> {
     return core.sync(() => {
       this.cacheState.map = MutableHashMap.empty()
     })
   }
 
-  refresh(key: Key): Effect.Effect<never, Error, void> {
+  refresh(key: Key): Effect.Effect<void, Error> {
     return effect.clockWith((clock) =>
       core.suspend(() => {
         const k = key
-        const deferred: Deferred.Deferred<Error, Value> = Deferred.unsafeMake(this.fiberId)
+        const deferred: Deferred.Deferred<Value, Error> = Deferred.unsafeMake(this.fiberId)
         let value = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, k))
         if (value === undefined) {
           if (MutableHashMap.has(this.cacheState.map, k)) {
@@ -480,7 +480,7 @@ class CacheImpl<in out Key, in out Error, in out Value> implements Cache.Cache<K
     )
   }
 
-  set(key: Key, value: Value): Effect.Effect<never, never, void> {
+  set(key: Key, value: Value): Effect.Effect<void> {
     return effect.clockWith((clock) =>
       core.sync(() => {
         const now = clock.unsafeCurrentTimeMillis()
@@ -501,13 +501,13 @@ class CacheImpl<in out Key, in out Error, in out Value> implements Cache.Cache<K
     )
   }
 
-  get size(): Effect.Effect<never, never, number> {
+  get size(): Effect.Effect<number> {
     return core.sync(() => {
       return MutableHashMap.size(this.cacheState.map)
     })
   }
 
-  get values(): Effect.Effect<never, never, Array<Value>> {
+  get values(): Effect.Effect<Array<Value>> {
     return core.sync(() => {
       const values: Array<Value> = []
       for (const entry of this.cacheState.map) {
@@ -519,7 +519,7 @@ class CacheImpl<in out Key, in out Error, in out Value> implements Cache.Cache<K
     })
   }
 
-  get entries(): Effect.Effect<never, never, Array<[Key, Value]>> {
+  get entries(): Effect.Effect<Array<[Key, Value]>> {
     return core.sync(() => {
       const values: Array<[Key, Value]> = []
       for (const entry of this.cacheState.map) {
@@ -531,7 +531,7 @@ class CacheImpl<in out Key, in out Error, in out Value> implements Cache.Cache<K
     })
   }
 
-  get keys(): Effect.Effect<never, never, Array<Key>> {
+  get keys(): Effect.Effect<Array<Key>> {
     return core.sync(() => {
       const keys: Array<Key> = []
       for (const entry of this.cacheState.map) {
@@ -546,7 +546,7 @@ class CacheImpl<in out Key, in out Error, in out Value> implements Cache.Cache<K
   resolveMapValue(
     value: MapValue<Key, Error, Value>,
     ignorePending = false
-  ): Effect.Effect<never, Error, Option.Option<Value>> {
+  ): Effect.Effect<Option.Option<Value>, Error> {
     return effect.clockWith((clock) => {
       switch (value._tag) {
         case "Complete": {
@@ -625,8 +625,8 @@ class CacheImpl<in out Key, in out Error, in out Value> implements Cache.Cache<K
 
   lookupValueOf(
     input: Key,
-    deferred: Deferred.Deferred<Error, Value>
-  ): Effect.Effect<never, Error, Value> {
+    deferred: Deferred.Deferred<Value, Error>
+  ): Effect.Effect<Value, Error> {
     return effect.clockWith((clock) =>
       core.suspend(() => {
         const key = input
@@ -670,7 +670,7 @@ export const make = <Key, Environment, Error, Value>(
     readonly timeToLive: Duration.DurationInput
     readonly lookup: Cache.Lookup<Key, Environment, Error, Value>
   }
-): Effect.Effect<Environment, never, Cache.Cache<Key, Error, Value>> => {
+): Effect.Effect<Cache.Cache<Key, Error, Value>, never, Environment> => {
   const timeToLive = Duration.decode(options.timeToLive)
   return makeWith({
     capacity: options.capacity,
@@ -684,9 +684,9 @@ export const makeWith = <Key, Environment, Error, Value>(
   options: {
     readonly capacity: number
     readonly lookup: Cache.Lookup<Key, Environment, Error, Value>
-    readonly timeToLive: (exit: Exit.Exit<Error, Value>) => Duration.DurationInput
+    readonly timeToLive: (exit: Exit.Exit<Value, Error>) => Duration.DurationInput
   }
-): Effect.Effect<Environment, never, Cache.Cache<Key, Error, Value>> =>
+): Effect.Effect<Cache.Cache<Key, Error, Value>, never, Environment> =>
   core.map(
     fiberRuntime.all([core.context<Environment>(), core.fiberId]),
     ([context, fiberId]) =>
@@ -703,7 +703,7 @@ export const makeWith = <Key, Environment, Error, Value>(
 export const unsafeMakeWith = <Key, Error, Value>(
   capacity: number,
   lookup: Cache.Lookup<Key, never, Error, Value>,
-  timeToLive: (exit: Exit.Exit<Error, Value>) => Duration.DurationInput
+  timeToLive: (exit: Exit.Exit<Value, Error>) => Duration.DurationInput
 ): Cache.Cache<Key, Error, Value> =>
   new CacheImpl<Key, Error, Value>(
     capacity,

package/src/internal/channel/channelExecutor.ts

@@ -22,26 +22,10 @@ import * as Continuation from "./continuation.js"
 import * as Subexecutor from "./subexecutor.js"
 import * as upstreamPullRequest from "./upstreamPullRequest.js"
 
-export type ErasedChannel<R> = Channel.Channel<
-  R,
-  unknown,
-  unknown,
-  unknown,
-  unknown,
-  unknown,
-  unknown
->
+export type ErasedChannel<R> = Channel.Channel<unknown, unknown, unknown, unknown, unknown, unknown, R>
 
 /** @internal */
-export type ErasedExecutor<R> = ChannelExecutor<
-  R,
-  unknown,
-  unknown,
-  unknown,
-  unknown,
-  unknown,
-  unknown
->
+export type ErasedExecutor<R> = ChannelExecutor<unknown, unknown, unknown, unknown, unknown, unknown, R>
 
 /** @internal */
 export type ErasedContinuation<R> = Continuation.Continuation<
@@ -57,15 +41,23 @@ export type ErasedContinuation<R> = Continuation.Continuation<
 >
 
 /** @internal */
-export type ErasedFinalizer<R> = (exit: Exit.Exit<unknown, unknown>) => Effect.Effect<R, never, unknown>
+export type ErasedFinalizer<R> = (exit: Exit.Exit<unknown, unknown>) => Effect.Effect<unknown, never, R>
 
 /** @internal */
-export class ChannelExecutor<in out Env, in InErr, in InElem, in InDone, out OutErr, out OutElem, out OutDone> {
+export class ChannelExecutor<
+  out OutElem,
+  in InElem = unknown,
+  out OutErr = never,
+  in InErr = unknown,
+  out OutDone = void,
+  in InDone = unknown,
+  in out Env = never
+> {
   private _activeSubexecutor: Subexecutor.Subexecutor<Env> | undefined = undefined
 
   private _cancelled: Exit.Exit<OutErr, OutDone> | undefined = undefined
 
-  private _closeLastSubstream: Effect.Effect<Env, never, unknown> | undefined = undefined
+  private _closeLastSubstream: Effect.Effect<unknown, never, Env> | undefined = undefined
 
   private _currentChannel: core.Primitive | undefined
 
@@ -76,19 +68,19 @@ export class ChannelExecutor<in out Env, in InErr, in InElem, in InDone, out Out
   private _emitted: unknown | undefined = undefined
 
   private _executeCloseLastSubstream: (
-    effect: Effect.Effect<Env, never, unknown>
-  ) => Effect.Effect<Env, never, unknown>
+    effect: Effect.Effect<unknown, never, Env>
+  ) => Effect.Effect<unknown, never, Env>
 
   private _input: ErasedExecutor<Env> | undefined = undefined
 
-  private _inProgressFinalizer: Effect.Effect<Env, never, unknown> | undefined = undefined
+  private _inProgressFinalizer: Effect.Effect<unknown, never, Env> | undefined = undefined
 
   private _providedEnv: Context.Context<unknown> | undefined
 
   constructor(
-    initialChannel: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+    initialChannel: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
     providedEnv: Context.Context<unknown> | undefined,
-    executeCloseLastSubstream: (effect: Effect.Effect<Env, never, unknown>) => Effect.Effect<Env, never, unknown>
+    executeCloseLastSubstream: (effect: Effect.Effect<unknown, never, Env>) => Effect.Effect<unknown, never, Env>
   ) {
     this._currentChannel = initialChannel as core.Primitive
     this._executeCloseLastSubstream = executeCloseLastSubstream
@@ -128,7 +120,7 @@ export class ChannelExecutor<in out Env, in InErr, in InElem, in InDone, out Out
                     const inputExecutor = this._input
                     this._input = undefined
 
-                    const drainer = (): Effect.Effect<Env, never, unknown> =>
+                    const drainer = (): Effect.Effect<unknown, never, Env> =>
                       Effect.flatMap(bridgeInput.awaitRead(), () =>
                         Effect.suspend(() => {
                           const state = inputExecutor.run() as ChannelState.Primitive
@@ -159,7 +151,7 @@ export class ChannelExecutor<in out Env, in InErr, in InElem, in InDone, out Out
                               )
                             }
                           }
-                        })) as Effect.Effect<Env, never, unknown>
+                        })) as Effect.Effect<unknown, never, Env>
 
                     result = ChannelState.FromEffect(
                       Effect.flatMap(
@@ -184,13 +176,13 @@ export class ChannelExecutor<in out Env, in InErr, in InElem, in InDone, out Out
                 case ChannelOpCodes.OP_CONCAT_ALL: {
                   const executor: ErasedExecutor<Env> = new ChannelExecutor(
                     this._currentChannel.value() as Channel.Channel<
-                      Env,
-                      unknown,
-                      unknown,
+                      never,
                       unknown,
                       never,
+                      unknown,
                       never,
-                      never
+                      unknown,
+                      Env
                     >,
                     this._providedEnv,
                     (effect) =>
@@ -278,7 +270,7 @@ export class ChannelExecutor<in out Env, in InErr, in InElem, in InDone, out Out
                   const previousInput = this._input
 
                   const leftExec: ErasedExecutor<Env> = new ChannelExecutor(
-                    this._currentChannel.left() as Channel.Channel<Env, unknown, unknown, unknown, never, never, never>,
+                    this._currentChannel.left() as Channel.Channel<never, unknown, never, unknown, never, unknown, Env>,
                     this._providedEnv,
                     (effect) => this._executeCloseLastSubstream(effect)
                   )
@@ -361,8 +353,8 @@ export class ChannelExecutor<in out Env, in InErr, in InElem, in InDone, out Out
     return result
   }
 
-  getDone(): Exit.Exit<OutErr, OutDone> {
-    return this._done as Exit.Exit<OutErr, OutDone>
+  getDone(): Exit.Exit<OutDone, OutErr> {
+    return this._done as Exit.Exit<OutDone, OutErr>
   }
 
   getEmit(): OutElem {
@@ -377,11 +369,11 @@ export class ChannelExecutor<in out Env, in InErr, in InElem, in InDone, out Out
     this._inProgressFinalizer = undefined
   }
 
-  storeInProgressFinalizer(finalizer: Effect.Effect<Env, never, unknown> | undefined): void {
+  storeInProgressFinalizer(finalizer: Effect.Effect<unknown, never, Env> | undefined): void {
     this._inProgressFinalizer = finalizer
   }
 
-  popAllFinalizers(exit: Exit.Exit<unknown, unknown>): Effect.Effect<Env, never, unknown> {
+  popAllFinalizers(exit: Exit.Exit<unknown, unknown>): Effect.Effect<unknown, never, Env> {
     const finalizers: Array<ErasedFinalizer<Env>> = []
     let next = this._doneStack.pop() as Continuation.Primitive | undefined
     while (next) {
@@ -391,9 +383,9 @@ export class ChannelExecutor<in out Env, in InErr, in InElem, in InDone, out Out
       next = this._doneStack.pop() as Continuation.Primitive | undefined
     }
     const effect = (finalizers.length === 0 ? Effect.unit : runFinalizers(finalizers, exit)) as Effect.Effect<
-      Env,
+      unknown,
       never,
-      unknown
+      Env
     >
     this.storeInProgressFinalizer(effect)
     return effect
@@ -415,7 +407,7 @@ export class ChannelExecutor<in out Env, in InErr, in InElem, in InDone, out Out
   restorePipe(
     exit: Exit.Exit<unknown, unknown>,
     prev: ErasedExecutor<Env> | undefined
-  ): Effect.Effect<Env, never, unknown> | undefined {
+  ): Effect.Effect<unknown, never, Env> | undefined {
     const currInput = this._input
     this._input = prev
     if (currInput !== undefined) {
@@ -425,8 +417,8 @@ export class ChannelExecutor<in out Env, in InErr, in InElem, in InDone, out Out
     return Effect.unit
   }
 
-  close(exit: Exit.Exit<unknown, unknown>): Effect.Effect<Env, never, unknown> | undefined {
-    let runInProgressFinalizers: Effect.Effect<Env, never, unknown> | undefined = undefined
+  close(exit: Exit.Exit<unknown, unknown>): Effect.Effect<unknown, never, Env> | undefined {
+    let runInProgressFinalizers: Effect.Effect<unknown, never, Env> | undefined = undefined
     const finalizer = this._inProgressFinalizer
     if (finalizer !== undefined) {
       runInProgressFinalizers = pipe(
@@ -435,7 +427,7 @@ export class ChannelExecutor<in out Env, in InErr, in InElem, in InDone, out Out
       )
     }
 
-    let closeSelf: Effect.Effect<Env, never, unknown> | undefined = undefined
+    let closeSelf: Effect.Effect<unknown, never, Env> | undefined = undefined
     const selfFinalizers = this.popAllFinalizers(exit)
     if (selfFinalizers !== undefined) {
       closeSelf = pipe(
@@ -546,7 +538,7 @@ export class ChannelExecutor<in out Env, in InErr, in InElem, in InDone, out Out
 
   runBracketOut(bracketOut: core.BracketOut): ChannelState.ChannelState<Env, unknown> {
     const effect = Effect.uninterruptible(
-      Effect.matchCauseEffect(this.provide(bracketOut.acquire() as Effect.Effect<Env, OutErr, OutDone>), {
+      Effect.matchCauseEffect(this.provide(bracketOut.acquire() as Effect.Effect<OutDone, OutErr, Env>), {
         onFailure: (cause) =>
           Effect.sync(() => {
             this._currentChannel = core.failCause(cause) as core.Primitive
@@ -554,7 +546,7 @@ export class ChannelExecutor<in out Env, in InErr, in InElem, in InDone, out Out
         onSuccess: (out) =>
           Effect.sync(() => {
             this.addFinalizer((exit) =>
-              this.provide(bracketOut.finalizer(out, exit)) as Effect.Effect<Env, never, unknown>
+              this.provide(bracketOut.finalizer(out, exit)) as Effect.Effect<unknown, never, Env>
             )
             this._currentChannel = core.write(out) as core.Primitive
           })
@@ -609,7 +601,7 @@ export class ChannelExecutor<in out Env, in InErr, in InElem, in InDone, out Out
     this._activeSubexecutor = nextSubExec
   }
 
-  finishWithExit(exit: Exit.Exit<unknown, unknown>): Effect.Effect<Env, unknown, unknown> {
+  finishWithExit(exit: Exit.Exit<unknown, unknown>): Effect.Effect<unknown, unknown, Env> {
     const state = Exit.match(exit, {
       onFailure: (cause) => this.doneHalt(cause),
       onSuccess: (value) => this.doneSucceed(value)
@@ -622,7 +614,7 @@ export class ChannelExecutor<in out Env, in InErr, in InElem, in InDone, out Out
 
   finishSubexecutorWithCloseEffect(
     subexecutorDone: Exit.Exit<unknown, unknown>,
-    ...closeFuncs: Array<(exit: Exit.Exit<unknown, unknown>) => Effect.Effect<Env, never, unknown> | undefined>
+    ...closeFuncs: Array<(exit: Exit.Exit<unknown, unknown>) => Effect.Effect<unknown, never, Env> | undefined>
   ): ChannelState.ChannelState<Env, unknown> | undefined {
     this.addFinalizer(() =>
       pipe(
@@ -695,7 +687,7 @@ export class ChannelExecutor<in out Env, in InErr, in InElem, in InDone, out Out
           const state = this.handleSubexecutorFailure(childExecutor, parentSubexecutor, cause)
           return state === undefined ?
             undefined :
-            ChannelState.effectOrUndefinedIgnored(state) as Effect.Effect<Env, never, void>
+            ChannelState.effectOrUndefinedIgnored(state) as Effect.Effect<void, never, Env>
         },
         onSuccess: (doneValue) => {
           this.finishWithDoneValue(childExecutor, parentSubexecutor, doneValue)
@@ -1006,17 +998,17 @@ export class ChannelExecutor<in out Env, in InErr, in InElem, in InDone, out Out
   }
 }
 
-const ifNotNull = <Env>(effect: Effect.Effect<Env, never, unknown> | undefined): Effect.Effect<Env, never, unknown> =>
+const ifNotNull = <Env>(effect: Effect.Effect<unknown, never, Env> | undefined): Effect.Effect<unknown, never, Env> =>
   effect !== undefined ? effect : Effect.unit
 
 const runFinalizers = <Env>(
   finalizers: Array<ErasedFinalizer<Env>>,
   exit: Exit.Exit<unknown, unknown>
-): Effect.Effect<Env, never, unknown> => {
+): Effect.Effect<unknown, never, Env> => {
   return pipe(
     Effect.forEach(finalizers, (fin) => Effect.exit(fin(exit))),
     Effect.map((exits) => pipe(Exit.all(exits), Option.getOrElse(() => Exit.unit))),
-    Effect.flatMap((exit) => Effect.suspend(() => exit as Exit.Exit<never, unknown>))
+    Effect.flatMap((exit) => Effect.suspend(() => exit as Exit.Exit<unknown>))
   )
 }
 
@@ -1025,11 +1017,11 @@ const runFinalizers = <Env>(
  */
 export const readUpstream = <R, E, E2, A>(
   r: ChannelState.Read,
-  onSuccess: () => Effect.Effect<R, E2, A>,
-  onFailure: (cause: Cause.Cause<E>) => Effect.Effect<R, E2, A>
-): Effect.Effect<R, E2, A> => {
+  onSuccess: () => Effect.Effect<A, E2, R>,
+  onFailure: (cause: Cause.Cause<E>) => Effect.Effect<A, E2, R>
+): Effect.Effect<A, E2, R> => {
   const readStack = [r as ChannelState.Read]
-  const read = (): Effect.Effect<R, E2, A> => {
+  const read = (): Effect.Effect<A, E2, R> => {
     const current = readStack.pop()
     if (current === undefined || current.upstream === undefined) {
       return Effect.dieMessage("Unexpected end of input for channel execution")
@@ -1043,7 +1035,7 @@ export const readUpstream = <R, E, E2, A>(
             return Effect.suspend(onSuccess)
           }
           return pipe(
-            emitEffect as Effect.Effect<never, never, void>,
+            emitEffect as Effect.Effect<void>,
             Effect.matchCauseEffect({ onFailure, onSuccess })
           )
         }
@@ -1051,7 +1043,7 @@ export const readUpstream = <R, E, E2, A>(
           return Effect.suspend(() => read())
         }
         return pipe(
-          emitEffect as Effect.Effect<never, never, void>,
+          emitEffect as Effect.Effect<void>,
           Effect.matchCauseEffect({ onFailure, onSuccess: () => read() })
         )
       }
@@ -1063,7 +1055,7 @@ export const readUpstream = <R, E, E2, A>(
             return Effect.suspend(onSuccess)
           }
           return pipe(
-            doneEffect as Effect.Effect<never, never, void>,
+            doneEffect as Effect.Effect<void>,
             Effect.matchCauseEffect({ onFailure, onSuccess })
           )
         }
@@ -1071,7 +1063,7 @@ export const readUpstream = <R, E, E2, A>(
           return Effect.suspend(() => read())
         }
         return pipe(
-          doneEffect as Effect.Effect<never, never, void>,
+          doneEffect as Effect.Effect<void>,
           Effect.matchCauseEffect({ onFailure, onSuccess: () => read() })
         )
       }
@@ -1079,10 +1071,10 @@ export const readUpstream = <R, E, E2, A>(
       case ChannelStateOpCodes.OP_FROM_EFFECT: {
         readStack.push(current)
         return pipe(
-          current.onEffect(state.effect as Effect.Effect<never, never, void>) as Effect.Effect<never, never, void>,
+          current.onEffect(state.effect as Effect.Effect<void>) as Effect.Effect<void>,
           Effect.catchAllCause((cause) =>
             Effect.suspend(() => {
-              const doneEffect = current.onDone(Exit.failCause(cause)) as Effect.Effect<never, never, void>
+              const doneEffect = current.onDone(Exit.failCause(cause)) as Effect.Effect<void>
               return doneEffect === undefined ? Effect.unit : doneEffect
             })
           ),
@@ -1102,16 +1094,16 @@ export const readUpstream = <R, E, E2, A>(
 
 /** @internal */
 export const run = <Env, InErr, InDone, OutErr, OutDone>(
-  self: Channel.Channel<Env, InErr, unknown, InDone, OutErr, never, OutDone>
-): Effect.Effect<Env, OutErr, OutDone> => pipe(runScoped(self), Effect.scoped)
+  self: Channel.Channel<never, unknown, OutErr, InErr, OutDone, InDone, Env>
+): Effect.Effect<OutDone, OutErr, Env> => pipe(runScoped(self), Effect.scoped)
 
 /** @internal */
 export const runScoped = <Env, InErr, InDone, OutErr, OutDone>(
-  self: Channel.Channel<Env, InErr, unknown, InDone, OutErr, never, OutDone>
-): Effect.Effect<Env | Scope.Scope, OutErr, OutDone> => {
+  self: Channel.Channel<never, unknown, OutErr, InErr, OutDone, InDone, Env>
+): Effect.Effect<OutDone, OutErr, Env | Scope.Scope> => {
   const run = (
-    channelDeferred: Deferred.Deferred<OutErr, OutDone>,
-    scopeDeferred: Deferred.Deferred<never, void>,
+    channelDeferred: Deferred.Deferred<OutDone, OutErr>,
+    scopeDeferred: Deferred.Deferred<void>,
     scope: Scope.Scope
   ) =>
     Effect.acquireUseRelease(
@@ -1141,8 +1133,8 @@ export const runScoped = <Env, InErr, InDone, OutErr, OutDone>(
       pipe(
         Effect.all([
           Scope.fork(parent, ExecutionStrategy.sequential),
-          Deferred.make<OutErr, OutDone>(),
-          Deferred.make<never, void>()
+          Deferred.make<OutDone, OutErr>(),
+          Deferred.make<void>()
         ]),
         Effect.flatMap(([child, channelDeferred, scopeDeferred]) =>
           pipe(
@@ -1163,13 +1155,13 @@ export const runScoped = <Env, InErr, InDone, OutErr, OutDone>(
 /** @internal */
 const runScopedInterpret = <Env, InErr, InDone, OutErr, OutDone>(
   channelState: ChannelState.ChannelState<Env, OutErr>,
-  exec: ChannelExecutor<Env, InErr, unknown, InDone, OutErr, never, OutDone>
-): Effect.Effect<Env, OutErr, OutDone> => {
+  exec: ChannelExecutor<never, unknown, OutErr, InErr, OutDone, InDone, Env>
+): Effect.Effect<OutDone, OutErr, Env> => {
   const op = channelState as ChannelState.Primitive
   switch (op._tag) {
     case ChannelStateOpCodes.OP_FROM_EFFECT: {
       return pipe(
-        op.effect as Effect.Effect<Env, OutErr, OutDone>,
+        op.effect as Effect.Effect<OutDone, OutErr, Env>,
         Effect.flatMap(() => runScopedInterpret(exec.run() as ChannelState.ChannelState<Env, OutErr>, exec))
       )
     }
@@ -1188,7 +1180,7 @@ const runScopedInterpret = <Env, InErr, InDone, OutErr, OutDone>(
         op,
         () => runScopedInterpret(exec.run() as ChannelState.ChannelState<Env, OutErr>, exec),
         Effect.failCause
-      ) as Effect.Effect<Env, OutErr, OutDone>
+      ) as Effect.Effect<OutDone, OutErr, Env>
     }
   }
 }