effect 2.3.8 → 2.4.1

package/src/Struct.ts

@@ -23,12 +23,14 @@ import type { MatchRecord, Simplify } from "./Types.js"
 export const pick = <Keys extends Array<PropertyKey>>(
   ...keys: Keys
 ) =>
-<S extends Record<Keys[number], any>>(
+<S extends { [K in Keys[number]]?: any }>(
   s: S
-): MatchRecord<S, { [K in Keys[number]]: S[K] | undefined }, { [K in Keys[number]]: S[K] }> => {
+): MatchRecord<S, { [K in Keys[number]]?: S[K] }, Simplify<Pick<S, Keys[number]>>> => {
   const out: any = {}
   for (const k of keys) {
-    out[k] = (s as any)[k]
+    if (k in s) {
+      out[k] = (s as any)[k]
+    }
   }
   return out
 }
@@ -47,7 +49,7 @@ export const pick = <Keys extends Array<PropertyKey>>(
 export const omit = <Keys extends Array<PropertyKey>>(
   ...keys: Keys
 ) =>
-<S extends Record<Keys[number], any>>(s: S): Simplify<Omit<S, Keys[number]>> => {
+<S extends { [K in Keys[number]]?: any }>(s: S): Simplify<Omit<S, Keys[number]>> => {
   const out: any = { ...s }
   for (const k of keys) {
     delete out[k]
@@ -167,4 +169,5 @@ export const evolve: {
  * @since 2.0.0
  */
 export const get =
-  <K extends PropertyKey>(key: K) => <S extends Record<K, any>>(s: S): MatchRecord<S, S[K] | undefined, S[K]> => s[key]
+  <K extends PropertyKey>(key: K) => <S extends { [P in K]?: any }>(s: S): MatchRecord<S, S[K] | undefined, S[K]> =>
+    s[key]

package/src/SubscriptionRef.ts

@@ -139,8 +139,8 @@ export const modify: {
  * @category utils
  */
 export const modifyEffect: {
-  <A, R, E, B>(f: (a: A) => Effect.Effect<readonly [B, A], E, R>): (self: SubscriptionRef<A>) => Effect.Effect<B, E, R>
-  <A, R, E, B>(self: SubscriptionRef<A>, f: (a: A) => Effect.Effect<readonly [B, A], E, R>): Effect.Effect<B, E, R>
+  <B, A, E, R>(f: (a: A) => Effect.Effect<readonly [B, A], E, R>): (self: SubscriptionRef<A>) => Effect.Effect<B, E, R>
+  <A, B, E, R>(self: SubscriptionRef<A>, f: (a: A) => Effect.Effect<readonly [B, A], E, R>): Effect.Effect<B, E, R>
 } = internal.modifyEffect
 
 /**

package/src/TArray.ts

@@ -70,8 +70,8 @@ export const collectFirst: {
  * @category elements
  */
 export const collectFirstSTM: {
-  <A, R, E, B>(pf: (a: A) => Option.Option<STM.STM<B, E, R>>): (self: TArray<A>) => STM.STM<Option.Option<B>, E, R>
-  <A, R, E, B>(self: TArray<A>, pf: (a: A) => Option.Option<STM.STM<B, E, R>>): STM.STM<Option.Option<B>, E, R>
+  <A, B, E, R>(pf: (a: A) => Option.Option<STM.STM<B, E, R>>): (self: TArray<A>) => STM.STM<Option.Option<B>, E, R>
+  <A, B, E, R>(self: TArray<A>, pf: (a: A) => Option.Option<STM.STM<B, E, R>>): STM.STM<Option.Option<B>, E, R>
 } = internal.collectFirstSTM
 
 /**

package/src/TDeferred.ts

@@ -31,7 +31,7 @@ export interface TDeferred<in out A, in out E = never> extends TDeferred.Varianc
  */
 export interface TDeferred<in out A, in out E> {
   /** @internal */
-  readonly ref: TRef.TRef<Option.Option<Either.Either<E, A>>>
+  readonly ref: TRef.TRef<Option.Option<Either.Either<A, E>>>
 }
 
 /**
@@ -65,8 +65,8 @@ export {
  * @category mutations
  */
 export const done: {
-  <E, A>(either: Either.Either<E, A>): (self: TDeferred<A, E>) => STM.STM<boolean>
-  <A, E>(self: TDeferred<A, E>, either: Either.Either<E, A>): STM.STM<boolean>
+  <A, E>(either: Either.Either<A, E>): (self: TDeferred<A, E>) => STM.STM<boolean>
+  <A, E>(self: TDeferred<A, E>, either: Either.Either<A, E>): STM.STM<boolean>
 } = internal.done
 
 /**
@@ -88,7 +88,7 @@ export const make: <A, E = never>() => STM.STM<TDeferred<A, E>> = internal.make
  * @since 2.0.0
  * @category getters
  */
-export const poll: <A, E>(self: TDeferred<A, E>) => STM.STM<Option.Option<Either.Either<E, A>>> = internal.poll
+export const poll: <A, E>(self: TDeferred<A, E>) => STM.STM<Option.Option<Either.Either<A, E>>> = internal.poll
 
 /**
  * @since 2.0.0

package/src/TMap.ts

@@ -86,10 +86,10 @@ export const find: {
  * @category elements
  */
 export const findSTM: {
-  <K, V, R, E, A>(
+  <K, V, A, E, R>(
     f: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>
   ): (self: TMap<K, V>) => STM.STM<Option.Option<A>, E, R>
-  <K, V, R, E, A>(
+  <K, V, A, E, R>(
     self: TMap<K, V>,
     f: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>
   ): STM.STM<Option.Option<A>, E, R>
@@ -115,10 +115,10 @@ export const findAll: {
  * @category elements
  */
 export const findAllSTM: {
-  <K, V, R, E, A>(
+  <K, V, A, E, R>(
     pf: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>
   ): (self: TMap<K, V>) => STM.STM<Array<A>, E, R>
-  <K, V, R, E, A>(self: TMap<K, V>, pf: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>): STM.STM<Array<A>, E, R>
+  <K, V, A, E, R>(self: TMap<K, V>, pf: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>): STM.STM<Array<A>, E, R>
 } = internal.findAllSTM
 
 /**
@@ -128,8 +128,8 @@ export const findAllSTM: {
  * @category elements
  */
 export const forEach: {
-  <K, V, R, E, _>(f: (key: K, value: V) => STM.STM<_, E, R>): (self: TMap<K, V>) => STM.STM<void, E, R>
-  <K, V, R, E, _>(self: TMap<K, V>, f: (key: K, value: V) => STM.STM<_, E, R>): STM.STM<void, E, R>
+  <K, V, X, E, R>(f: (key: K, value: V) => STM.STM<X, E, R>): (self: TMap<K, V>) => STM.STM<void, E, R>
+  <K, V, X, E, R>(self: TMap<K, V>, f: (key: K, value: V) => STM.STM<X, E, R>): STM.STM<void, E, R>
 } = internal.forEach
 
 /**
@@ -377,8 +377,8 @@ export const takeFirst: {
  * @category mutations
  */
 export const takeFirstSTM: {
-  <K, V, R, E, A>(pf: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>): (self: TMap<K, V>) => STM.STM<A, E, R>
-  <K, V, R, E, A>(self: TMap<K, V>, pf: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>): STM.STM<A, E, R>
+  <K, V, A, E, R>(pf: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>): (self: TMap<K, V>) => STM.STM<A, E, R>
+  <K, V, A, E, R>(self: TMap<K, V>, pf: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>): STM.STM<A, E, R>
 } = internal.takeFirstSTM
 
 /**
@@ -399,10 +399,10 @@ export const takeSome: {
  * @category mutations
  */
 export const takeSomeSTM: {
-  <K, V, R, E, A>(
+  <K, V, A, E, R>(
     pf: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>
   ): (self: TMap<K, V>) => STM.STM<[A, ...Array<A>], E, R>
-  <K, V, R, E, A>(
+  <K, V, A, E, R>(
     self: TMap<K, V>,
     pf: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>
   ): STM.STM<[A, ...Array<A>], E, R>

package/src/TSet.ts

@@ -272,8 +272,8 @@ export const takeFirst: {
  * @category mutations
  */
 export const takeFirstSTM: {
-  <A, R, E, B>(pf: (a: A) => STM.STM<B, Option.Option<E>, R>): (self: TSet<A>) => STM.STM<B, E, R>
-  <A, R, E, B>(self: TSet<A>, pf: (a: A) => STM.STM<B, Option.Option<E>, R>): STM.STM<B, E, R>
+  <A, B, E, R>(pf: (a: A) => STM.STM<B, Option.Option<E>, R>): (self: TSet<A>) => STM.STM<B, E, R>
+  <A, B, E, R>(self: TSet<A>, pf: (a: A) => STM.STM<B, Option.Option<E>, R>): STM.STM<B, E, R>
 } = internal.takeFirstSTM
 
 /**
@@ -294,8 +294,8 @@ export const takeSome: {
  * @category mutations
  */
 export const takeSomeSTM: {
-  <A, R, E, B>(pf: (a: A) => STM.STM<B, Option.Option<E>, R>): (self: TSet<A>) => STM.STM<[B, ...Array<B>], E, R>
-  <A, R, E, B>(self: TSet<A>, pf: (a: A) => STM.STM<B, Option.Option<E>, R>): STM.STM<[B, ...Array<B>], E, R>
+  <A, B, E, R>(pf: (a: A) => STM.STM<B, Option.Option<E>, R>): (self: TSet<A>) => STM.STM<[B, ...Array<B>], E, R>
+  <A, B, E, R>(self: TSet<A>, pf: (a: A) => STM.STM<B, Option.Option<E>, R>): STM.STM<[B, ...Array<B>], E, R>
 } = internal.takeSomeSTM
 
 /**

package/src/Take.ts

@@ -248,11 +248,11 @@ export const of: <A>(value: A) => Take<A> = internal.of
  * @category sequencing
  */
 export const tap: {
-  <A, _, E2, R>(
-    f: (chunk: Chunk.Chunk<A>) => Effect.Effect<_, E2, R>
+  <A, X, E2, R>(
+    f: (chunk: Chunk.Chunk<A>) => Effect.Effect<X, E2, R>
   ): <E>(self: Take<A, E>) => Effect.Effect<void, E2 | E, R>
-  <A, E, _, E2, R>(
+  <A, E, X, E2, R>(
     self: Take<A, E>,
-    f: (chunk: Chunk.Chunk<A>) => Effect.Effect<_, E2, R>
+    f: (chunk: Chunk.Chunk<A>) => Effect.Effect<X, E2, R>
   ): Effect.Effect<void, E | E2, R>
 } = internal.tap

package/src/TestAnnotation.ts

@@ -81,9 +81,9 @@ export const make = <A>(
  * @since 2.0.0
  */
 export const compose = <A>(
-  left: Either.Either<number, Chunk.Chunk<A>>,
-  right: Either.Either<number, Chunk.Chunk<A>>
-): Either.Either<number, Chunk.Chunk<A>> => {
+  left: Either.Either<Chunk.Chunk<A>, number>,
+  right: Either.Either<Chunk.Chunk<A>, number>
+): Either.Either<Chunk.Chunk<A>, number> => {
   if (Either.isLeft(left) && Either.isLeft(right)) {
     return Either.left(left.left + right.left)
   }
@@ -103,12 +103,9 @@ export const compose = <A>(
  * @since 2.0.0
  */
 export const fibers: TestAnnotation<
-  Either.Either<
-    number,
-    Chunk.Chunk<MutableRef.MutableRef<SortedSet.SortedSet<Fiber.RuntimeFiber<unknown, unknown>>>>
-  >
+  Either.Either<Chunk.Chunk<MutableRef.MutableRef<SortedSet.SortedSet<Fiber.RuntimeFiber<unknown, unknown>>>>, number>
 > = make<
-  Either.Either<number, Chunk.Chunk<MutableRef.MutableRef<SortedSet.SortedSet<Fiber.RuntimeFiber<unknown, unknown>>>>>
+  Either.Either<Chunk.Chunk<MutableRef.MutableRef<SortedSet.SortedSet<Fiber.RuntimeFiber<unknown, unknown>>>>, number>
 >(
   "fibers",
   Either.left(0),

package/src/Types.ts

@@ -114,6 +114,17 @@ export type MergeRight<K, H> = Simplify<
   }
 >
 
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export type MergeRecord<K, H> = {
+  [k in keyof K | keyof H]: k extends keyof K ? K[k]
+    : k extends keyof H ? H[k]
+    : never
+} extends infer X ? X
+  : never
+
 /**
  * Describes the concurrency to use when executing multiple Effect's.
  *

package/src/internal/blockedRequests.ts

@@ -103,7 +103,7 @@ export const reduce = <Z>(
   reducer: RequestBlock.RequestBlock.Reducer<Z>
 ): Z => {
   let input: List.List<RequestBlock.RequestBlock> = List.of(self)
-  let output = List.empty<Either.Either<BlockedRequestsCase, Z>>()
+  let output = List.empty<Either.Either<Z, BlockedRequestsCase>>()
   while (List.isCons(input)) {
     const current: RequestBlock.RequestBlock = input.head
     switch (current._tag) {
@@ -429,7 +429,7 @@ class SequentialImpl implements SequentialCollection {
 }
 
 /** @internal */
-export const sequentialCollectionMake = <R, A>(
+export const sequentialCollectionMake = <A, R>(
   map: HashMap.HashMap<
     RequestResolver.RequestResolver<A, R>,
     Array<Array<Request.Entry<A>>>

package/src/internal/cause.ts

@@ -234,7 +234,7 @@ export const failureOption = <E>(self: Cause.Cause<E>): Option.Option<E> =>
       Option.none())
 
 /** @internal */
-export const failureOrCause = <E>(self: Cause.Cause<E>): Either.Either<E, Cause.Cause<never>> => {
+export const failureOrCause = <E>(self: Cause.Cause<E>): Either.Either<Cause.Cause<never>, E> => {
   const option = failureOption(self)
   switch (option._tag) {
     case "None": {
@@ -892,7 +892,7 @@ export const reduceWithContext = dual<
   <C, E, Z>(self: Cause.Cause<E>, context: C, reducer: Cause.CauseReducer<C, E, Z>) => Z
 >(3, <C, E, Z>(self: Cause.Cause<E>, context: C, reducer: Cause.CauseReducer<C, E, Z>) => {
   const input: Array<Cause.Cause<E>> = [self]
-  const output: Array<Either.Either<CauseCase, Z>> = []
+  const output: Array<Either.Either<Z, CauseCase>> = []
   while (input.length > 0) {
     const cause = input.pop()!
     switch (cause._tag) {

package/src/internal/channel/channelExecutor.ts

@@ -87,8 +87,8 @@ export class ChannelExecutor<
     this._providedEnv = providedEnv
   }
 
-  run(): ChannelState.ChannelState<Env, unknown> {
-    let result: ChannelState.ChannelState<Env, unknown> | undefined = undefined
+  run(): ChannelState.ChannelState<unknown, Env> {
+    let result: ChannelState.ChannelState<unknown, Env> | undefined = undefined
     while (result === undefined) {
       if (this._cancelled !== undefined) {
         result = this.processCancellation()
@@ -153,7 +153,7 @@ export class ChannelExecutor<
                           }
                         })) as Effect.Effect<unknown, never, Env>
 
-                    result = ChannelState.FromEffect(
+                    result = ChannelState.fromEffect(
                       Effect.flatMap(
                         Effect.forkDaemon(drainer()),
                         (fiber) =>
@@ -246,7 +246,7 @@ export class ChannelExecutor<
                       Effect.provide(this._providedEnv)
                     )
 
-                  result = ChannelState.FromEffect(
+                  result = ChannelState.fromEffect(
                     Effect.matchCauseEffect(effect, {
                       onFailure: (cause) => {
                         const state = this.doneHalt(cause)
@@ -261,7 +261,7 @@ export class ChannelExecutor<
                           Effect.unit
                       }
                     })
-                  ) as ChannelState.ChannelState<Env, unknown> | undefined
+                  ) as ChannelState.ChannelState<unknown, Env> | undefined
 
                   break
                 }
@@ -459,7 +459,7 @@ export class ChannelExecutor<
     )
   }
 
-  doneSucceed(value: unknown): ChannelState.ChannelState<Env, unknown> | undefined {
+  doneSucceed(value: unknown): ChannelState.ChannelState<unknown, Env> | undefined {
     if (this._doneStack.length === 0) {
       this._done = Exit.succeed(value)
       this._currentChannel = undefined
@@ -491,10 +491,10 @@ export class ChannelExecutor<
       Effect.flatMap(() => Effect.sync(() => this.doneSucceed(value)))
     )
 
-    return ChannelState.FromEffect(effect)
+    return ChannelState.fromEffect(effect)
   }
 
-  doneHalt(cause: Cause.Cause<unknown>): ChannelState.ChannelState<Env, unknown> | undefined {
+  doneHalt(cause: Cause.Cause<unknown>): ChannelState.ChannelState<unknown, Env> | undefined {
     if (this._doneStack.length === 0) {
       this._done = Exit.failCause(cause)
       this._currentChannel = undefined
@@ -526,17 +526,17 @@ export class ChannelExecutor<
       Effect.flatMap(() => Effect.sync(() => this.doneHalt(cause)))
     )
 
-    return ChannelState.FromEffect(effect)
+    return ChannelState.fromEffect(effect)
   }
 
-  processCancellation(): ChannelState.ChannelState<Env, unknown> {
+  processCancellation(): ChannelState.ChannelState<unknown, Env> {
     this._currentChannel = undefined
     this._done = this._cancelled
     this._cancelled = undefined
     return ChannelState.Done()
   }
 
-  runBracketOut(bracketOut: core.BracketOut): ChannelState.ChannelState<Env, unknown> {
+  runBracketOut(bracketOut: core.BracketOut): ChannelState.ChannelState<unknown, Env> {
     const effect = Effect.uninterruptible(
       Effect.matchCauseEffect(this.provide(bracketOut.acquire() as Effect.Effect<OutDone, OutErr, Env>), {
         onFailure: (cause) =>
@@ -552,7 +552,7 @@ export class ChannelExecutor<
           })
       })
     )
-    return ChannelState.FromEffect(effect) as ChannelState.ChannelState<Env, unknown>
+    return ChannelState.fromEffect(effect) as ChannelState.ChannelState<unknown, Env>
   }
 
   provide(effect: Effect.Effect<unknown, unknown, unknown>): Effect.Effect<unknown, unknown, unknown> {
@@ -571,7 +571,7 @@ export class ChannelExecutor<
     this._doneStack.push(new Continuation.ContinuationFinalizerImpl(f))
   }
 
-  runSubexecutor(): ChannelState.ChannelState<Env, unknown> | undefined {
+  runSubexecutor(): ChannelState.ChannelState<unknown, Env> | undefined {
     const subexecutor = this._activeSubexecutor as Subexecutor.Primitive<Env>
     switch (subexecutor._tag) {
       case Subexecutor.OP_PULL_FROM_CHILD: {
@@ -615,7 +615,7 @@ export class ChannelExecutor<
   finishSubexecutorWithCloseEffect(
     subexecutorDone: Exit.Exit<unknown, unknown>,
     ...closeFuncs: Array<(exit: Exit.Exit<unknown, unknown>) => Effect.Effect<unknown, never, Env> | undefined>
-  ): ChannelState.ChannelState<Env, unknown> | undefined {
+  ): ChannelState.ChannelState<unknown, Env> | undefined {
     this.addFinalizer(() =>
       pipe(
         closeFuncs,
@@ -659,7 +659,7 @@ export class ChannelExecutor<
     parentSubexecutor: Subexecutor.Subexecutor<Env>,
     onEmitted: (emitted: unknown) => ChildExecutorDecision.ChildExecutorDecision,
     subexecutor: Subexecutor.PullFromChild<Env>
-  ): ChannelState.ChannelState<Env, unknown> | undefined {
+  ): ChannelState.ChannelState<unknown, Env> | undefined {
     return ChannelState.Read(
       childExecutor,
       identity,
@@ -753,7 +753,7 @@ export class ChannelExecutor<
     childExecutor: ErasedExecutor<Env>,
     parentSubexecutor: Subexecutor.Subexecutor<Env>,
     cause: Cause.Cause<unknown>
-  ): ChannelState.ChannelState<Env, unknown> | undefined {
+  ): ChannelState.ChannelState<unknown, Env> | undefined {
     return this.finishSubexecutorWithCloseEffect(
       Exit.failCause(cause),
       (exit) => parentSubexecutor.close(exit),
@@ -763,7 +763,7 @@ export class ChannelExecutor<
 
   pullFromUpstream(
     subexecutor: Subexecutor.PullFromUpstream<Env>
-  ): ChannelState.ChannelState<Env, unknown> | undefined {
+  ): ChannelState.ChannelState<unknown, Env> | undefined {
     if (subexecutor.activeChildExecutors.length === 0) {
       return this.performPullFromUpstream(subexecutor)
     }
@@ -798,7 +798,7 @@ export class ChannelExecutor<
 
   performPullFromUpstream(
     subexecutor: Subexecutor.PullFromUpstream<Env>
-  ): ChannelState.ChannelState<Env, unknown> | undefined {
+  ): ChannelState.ChannelState<unknown, Env> | undefined {
     return ChannelState.Read(
       subexecutor.upstreamExecutor,
       (effect) => {
@@ -924,14 +924,14 @@ export class ChannelExecutor<
         return state === undefined ?
           undefined :
           // NOTE: assuming finalizers cannot fail
-          ChannelState.effectOrUndefinedIgnored(state as ChannelState.ChannelState<Env, never>)
+          ChannelState.effectOrUndefinedIgnored(state as ChannelState.ChannelState<never, Env>)
       }
     )
   }
 
   drainChildExecutors(
     subexecutor: Subexecutor.DrainChildExecutors<Env>
-  ): ChannelState.ChannelState<Env, unknown> | undefined {
+  ): ChannelState.ChannelState<unknown, Env> | undefined {
     if (subexecutor.activeChildExecutors.length === 0) {
       const lastClose = this._closeLastSubstream
       if (lastClose !== undefined) {
@@ -1015,7 +1015,7 @@ const runFinalizers = <Env>(
 /**
  * @internal
  */
-export const readUpstream = <R, E, E2, A>(
+export const readUpstream = <A, E2, R, E>(
   r: ChannelState.Read,
   onSuccess: () => Effect.Effect<A, E2, R>,
   onFailure: (cause: Cause.Cause<E>) => Effect.Effect<A, E2, R>
@@ -1111,7 +1111,7 @@ export const runScoped = <Env, InErr, InDone, OutErr, OutDone>(
       (exec) =>
         Effect.suspend(() =>
           pipe(
-            runScopedInterpret(exec.run() as ChannelState.ChannelState<Env, OutErr>, exec),
+            runScopedInterpret(exec.run() as ChannelState.ChannelState<OutErr, Env>, exec),
             Effect.intoDeferred(channelDeferred),
             Effect.zipRight(Deferred.await(channelDeferred)),
             Effect.zipLeft(Deferred.await(scopeDeferred))
@@ -1154,7 +1154,7 @@ export const runScoped = <Env, InErr, InDone, OutErr, OutDone>(
 
 /** @internal */
 const runScopedInterpret = <Env, InErr, InDone, OutErr, OutDone>(
-  channelState: ChannelState.ChannelState<Env, OutErr>,
+  channelState: ChannelState.ChannelState<OutErr, Env>,
   exec: ChannelExecutor<never, unknown, OutErr, InErr, OutDone, InDone, Env>
 ): Effect.Effect<OutDone, OutErr, Env> => {
   const op = channelState as ChannelState.Primitive
@@ -1162,13 +1162,13 @@ const runScopedInterpret = <Env, InErr, InDone, OutErr, OutDone>(
     case ChannelStateOpCodes.OP_FROM_EFFECT: {
       return pipe(
         op.effect as Effect.Effect<OutDone, OutErr, Env>,
-        Effect.flatMap(() => runScopedInterpret(exec.run() as ChannelState.ChannelState<Env, OutErr>, exec))
+        Effect.flatMap(() => runScopedInterpret(exec.run() as ChannelState.ChannelState<OutErr, Env>, exec))
       )
     }
     case ChannelStateOpCodes.OP_EMIT: {
       // Can't really happen because Out <:< Nothing. So just skip ahead.
       return runScopedInterpret<Env, InErr, InDone, OutErr, OutDone>(
-        exec.run() as ChannelState.ChannelState<Env, OutErr>,
+        exec.run() as ChannelState.ChannelState<OutErr, Env>,
         exec
       )
     }
@@ -1178,7 +1178,7 @@ const runScopedInterpret = <Env, InErr, InDone, OutErr, OutDone>(
     case ChannelStateOpCodes.OP_READ: {
       return readUpstream(
         op,
-        () => runScopedInterpret(exec.run() as ChannelState.ChannelState<Env, OutErr>, exec),
+        () => runScopedInterpret(exec.run() as ChannelState.ChannelState<OutErr, Env>, exec),
         Effect.failCause
       ) as Effect.Effect<OutDone, OutErr, Env>
     }

package/src/internal/channel/channelState.ts

@@ -12,23 +12,23 @@ export const ChannelStateTypeId = Symbol.for("effect/ChannelState")
 export type ChannelStateTypeId = typeof ChannelStateTypeId
 
 /** @internal */
-export interface ChannelState<out R, out E> extends ChannelState.Variance<R, E> {}
+export interface ChannelState<out E, out R> extends ChannelState.Variance<E, R> {}
 
 /** @internal */
 export declare namespace ChannelState {
-  export interface Variance<out R, out E> {
+  export interface Variance<out E, out R> {
     readonly [ChannelStateTypeId]: {
-      readonly _R: Types.Covariant<R>
       readonly _E: Types.Covariant<E>
+      readonly _R: Types.Covariant<R>
     }
   }
 }
 
 const channelStateVariance = {
   /* c8 ignore next */
-  _R: (_: never) => _,
+  _E: (_: never) => _,
   /* c8 ignore next */
-  _E: (_: never) => _
+  _R: (_: never) => _
 }
 
 /** @internal */
@@ -86,7 +86,7 @@ export const Emit = (): ChannelState<never, never> => {
 }
 
 /** @internal */
-export const FromEffect = <R, E, _>(effect: Effect.Effect<_, E, R>): ChannelState<R, E> => {
+export const fromEffect = <X, E, R>(effect: Effect.Effect<X, E, R>): ChannelState<E, R> => {
   const op = Object.create(proto)
   op._tag = OpCodes.OP_FROM_EFFECT
   op.effect = effect
@@ -99,7 +99,7 @@ export const Read = <R>(
   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> => {
+): ChannelState<never, R> => {
   const op = Object.create(proto)
   op._tag = OpCodes.OP_READ
   op.upstream = upstream
@@ -113,22 +113,22 @@ export const Read = <R>(
 export const isChannelState = (u: unknown): u is ChannelState<unknown, unknown> => hasProperty(u, ChannelStateTypeId)
 
 /** @internal */
-export const isDone = <R, E>(self: ChannelState<R, E>): self is Done => (self as Primitive)._tag === OpCodes.OP_DONE
+export const isDone = <E, R>(self: ChannelState<E, R>): self is Done => (self as Primitive)._tag === OpCodes.OP_DONE
 
 /** @internal */
-export const isEmit = <R, E>(self: ChannelState<R, E>): self is Emit => (self as Primitive)._tag === OpCodes.OP_EMIT
+export const isEmit = <E, R>(self: ChannelState<E, R>): self is Emit => (self as Primitive)._tag === OpCodes.OP_EMIT
 
 /** @internal */
-export const isFromEffect = <R, E>(self: ChannelState<R, E>): self is FromEffect =>
+export const isFromEffect = <E, R>(self: ChannelState<E, R>): self is FromEffect =>
   (self as Primitive)._tag === OpCodes.OP_FROM_EFFECT
 
 /** @internal */
-export const isRead = <R, E>(self: ChannelState<R, E>): self is Read => (self as Primitive)._tag === OpCodes.OP_READ
+export const isRead = <E, R>(self: ChannelState<E, R>): self is Read => (self as Primitive)._tag === OpCodes.OP_READ
 
 /** @internal */
-export const effect = <R, E>(self: ChannelState<R, E>): Effect.Effect<void, E, R> =>
+export const effect = <E, R>(self: ChannelState<E, R>): 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<void, E, R> | undefined =>
+export const effectOrUndefinedIgnored = <E, R>(self: ChannelState<E, R>): Effect.Effect<void, E, R> | undefined =>
   isFromEffect(self) ? Effect.ignore(self.effect as Effect.Effect<void, E, R>) : undefined

package/src/internal/channel/mergeDecision.ts

@@ -72,7 +72,7 @@ export const Await = <R, E0, Z0, E, Z>(
 }
 
 /** @internal */
-export const AwaitConst = <R, E, Z>(
+export const AwaitConst = <Z, E, R>(
   effect: Effect.Effect<Z, E, R>
 ): MergeDecision.MergeDecision<R, unknown, unknown, E, Z> => Await(() => effect)
 

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<Either.Either<Done, Elem>, Err>,
-  right: Fiber.Fiber<Either.Either<Done1, Elem>, Err1>
+  left: Fiber.Fiber<Either.Either<Elem, Done>, Err>,
+  right: Fiber.Fiber<Either.Either<Elem, Done1>, Err1>
 ): MergeState.MergeState<Env, Err, Err1, Err2, Elem, Done, Done1, Done2> => {
   const op = Object.create(proto)
   op._tag = OpCodes.OP_BOTH_RUNNING
@@ -84,8 +84,8 @@ export const match = dual<
   <Env, Err, Err1, Err2, Elem, Done, Done1, Done2, Z>(
     options: {
       readonly onBothRunning: (
-        left: Fiber.Fiber<Either.Either<Done, Elem>, Err>,
-        right: Fiber.Fiber<Either.Either<Done1, Elem>, Err1>
+        left: Fiber.Fiber<Either.Either<Elem, Done>, Err>,
+        right: Fiber.Fiber<Either.Either<Elem, Done1>, Err1>
       ) => 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
@@ -95,8 +95,8 @@ export const match = dual<
     self: MergeState.MergeState<Env, Err, Err1, Err2, Elem, Done, Done1, Done2>,
     options: {
       readonly onBothRunning: (
-        left: Fiber.Fiber<Either.Either<Done, Elem>, Err>,
-        right: Fiber.Fiber<Either.Either<Done1, Elem>, Err1>
+        left: Fiber.Fiber<Either.Either<Elem, Done>, Err>,
+        right: Fiber.Fiber<Either.Either<Elem, Done1>, Err1>
       ) => 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

package/src/internal/channel/singleProducerAsyncInput.ts

@@ -47,7 +47,7 @@ interface Empty {
 /** @internal */
 interface Emit<Err, Elem, Done> {
   readonly _tag: OP_STATE_EMIT
-  readonly notifyConsumers: ReadonlyArray<Deferred.Deferred<Either.Either<Done, Elem>, Err>>
+  readonly notifyConsumers: ReadonlyArray<Deferred.Deferred<Either.Either<Elem, Done>, Err>>
 }
 
 /** @internal */
@@ -70,7 +70,7 @@ const stateEmpty = (notifyProducer: Deferred.Deferred<void>): State<never, never
 
 /** @internal */
 const stateEmit = <Err, Elem, Done>(
-  notifyConsumers: ReadonlyArray<Deferred.Deferred<Either.Either<Done, Elem>, Err>>
+  notifyConsumers: ReadonlyArray<Deferred.Deferred<Either.Either<Elem, Done>, Err>>
 ): State<Err, Elem, Done> => ({
   _tag: OP_STATE_EMIT,
   notifyConsumers
@@ -198,10 +198,10 @@ class SingleProducerAsyncInputImpl<in out Err, in out Elem, in out Done>
     )
   }
 
-  get take(): Effect.Effect<Exit.Exit<Elem, Either.Either<Err, Done>>> {
+  get take(): Effect.Effect<Exit.Exit<Elem, Either.Either<Done, Err>>> {
     return this.takeWith(
       (cause) => Exit.failCause(Cause.map(cause, Either.left)),
-      (elem) => Exit.succeed(elem) as Exit.Exit<Elem, Either.Either<Err, Done>>,
+      (elem) => Exit.succeed(elem) as Exit.Exit<Elem, Either.Either<Done, Err>>,
       (done) => Exit.fail(Either.right(done))
     )
   }
@@ -211,7 +211,7 @@ class SingleProducerAsyncInputImpl<in out Err, in out Elem, in out Done>
     onElement: (element: Elem) => A,
     onDone: (value: Done) => A
   ): Effect.Effect<A> {
-    return Effect.flatMap(Deferred.make<Either.Either<Done, Elem>, Err>(), (deferred) =>
+    return Effect.flatMap(Deferred.make<Either.Either<Elem, Done>, Err>(), (deferred) =>
       Effect.flatten(
         Ref.modify(this.ref, (state) => {
           switch (state._tag) {