From 2c52048f4bb11304819ddce5868f35590885498b Mon Sep 17 00:00:00 2001
From: Giulio Canti <giulio.canti@gmail.com>
Date: Wed, 7 Feb 2024 08:50:02 +0100
Subject: [PATCH] =?UTF-8?q?change=20`Runtime.RunCallbackOptions`=20type=20?=
 =?UTF-8?q?parameters=20order=20from=20`RunCa=E2=80=A6=20(#2069)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .changeset/afraid-pumpkins-attack.md          |  5 ++++
 .changeset/brave-days-invite.md               |  5 ++++
 .changeset/fuzzy-lamps-live.md                |  5 ++++
 packages/effect/src/Effect.ts                 |  4 +--
 packages/effect/src/Runtime.ts                | 14 +++++-----
 packages/effect/src/Stream.ts                 |  2 +-
 packages/effect/src/internal/keyedPool.ts     | 12 ++++-----
 packages/effect/src/internal/pool.ts          | 26 +++++++++----------
 packages/effect/src/internal/runtime.ts       |  8 +++---
 packages/effect/src/internal/sink.ts          | 10 +++----
 packages/effect/src/internal/stm/core.ts      | 12 ++++-----
 packages/effect/src/internal/stm/stm.ts       |  2 +-
 .../effect/src/internal/stm/stm/stmState.ts   | 14 +++++-----
 .../effect/src/internal/stm/stm/tryCommit.ts  |  6 ++---
 packages/effect/src/internal/stream.ts        | 13 +++++-----
 .../src/internal/stream/debounceState.ts      |  8 +++---
 16 files changed, 80 insertions(+), 66 deletions(-)
 create mode 100644 .changeset/afraid-pumpkins-attack.md
 create mode 100644 .changeset/brave-days-invite.md
 create mode 100644 .changeset/fuzzy-lamps-live.md

diff --git a/.changeset/afraid-pumpkins-attack.md b/.changeset/afraid-pumpkins-attack.md
new file mode 100644
index 0000000000..1da97cc659
--- /dev/null
+++ b/.changeset/afraid-pumpkins-attack.md
@@ -0,0 +1,5 @@
+---
+"effect": minor
+---
+
+change `Runtime.AsyncFiberException` type parameters order from `AsyncFiberException<E, A>` to `AsyncFiberException<A, E = never>`
diff --git a/.changeset/brave-days-invite.md b/.changeset/brave-days-invite.md
new file mode 100644
index 0000000000..f87cabe0d3
--- /dev/null
+++ b/.changeset/brave-days-invite.md
@@ -0,0 +1,5 @@
+---
+"effect": minor
+---
+
+change `Runtime.Cancel` type parameters order from `Cancel<E, A>` to `Cancel<A, E = never>`
diff --git a/.changeset/fuzzy-lamps-live.md b/.changeset/fuzzy-lamps-live.md
new file mode 100644
index 0000000000..0611ccb98f
--- /dev/null
+++ b/.changeset/fuzzy-lamps-live.md
@@ -0,0 +1,5 @@
+---
+"effect": minor
+---
+
+change `Runtime.RunCallbackOptions` type parameters order from `RunCallbackOptions<E, A>` to `RunCallbackOptions<A, E = never>`
diff --git a/packages/effect/src/Effect.ts b/packages/effect/src/Effect.ts
index 4d4a706ca8..de96cd21e0 100644
--- a/packages/effect/src/Effect.ts
+++ b/packages/effect/src/Effect.ts
@@ -4714,8 +4714,8 @@ export const runFork: <A, E>(
  */
 export const runCallback: <A, E>(
   effect: Effect<A, E>,
-  options?: Runtime.RunCallbackOptions<E, A> | undefined
-) => Runtime.Cancel<E, A> = _runtime.unsafeRunEffect
+  options?: Runtime.RunCallbackOptions<A, E> | undefined
+) => Runtime.Cancel<A, E> = _runtime.unsafeRunEffect
 
 /**
  * Runs an `Effect` workflow, returning a `Promise` which resolves with the
diff --git a/packages/effect/src/Runtime.ts b/packages/effect/src/Runtime.ts
index 1b66fc3acd..f6e6745c5c 100644
--- a/packages/effect/src/Runtime.ts
+++ b/packages/effect/src/Runtime.ts
@@ -19,7 +19,7 @@ import type { Scope } from "./Scope.js"
  * @since 2.0.0
  * @category models
  */
-export interface AsyncFiberException<out E, out A> {
+export interface AsyncFiberException<out A, out E = never> {
   readonly _tag: "AsyncFiberException"
   readonly fiber: Fiber.RuntimeFiber<A, E>
 }
@@ -28,8 +28,8 @@ export interface AsyncFiberException<out E, out A> {
  * @since 2.0.0
  * @category models
  */
-export interface Cancel<out E, out A> {
-  (fiberId?: FiberId.FiberId, options?: RunCallbackOptions<E, A> | undefined): void
+export interface Cancel<out A, out E = never> {
+  (fiberId?: FiberId.FiberId, options?: RunCallbackOptions<A, E> | undefined): void
 }
 
 /**
@@ -100,7 +100,7 @@ export const runSync: <R>(runtime: Runtime<R>) => <A, E>(effect: Effect.Effect<A
  * @since 2.0.0
  * @category models
  */
-export interface RunCallbackOptions<E, A> extends RunForkOptions {
+export interface RunCallbackOptions<in A, in E = never> extends RunForkOptions {
   readonly onExit?: ((exit: Exit.Exit<A, E>) => void) | undefined
 }
 
@@ -116,10 +116,10 @@ export interface RunCallbackOptions<E, A> extends RunForkOptions {
  */
 export const runCallback: <R>(
   runtime: Runtime<R>
-) => <E, A>(
+) => <A, E>(
   effect: Effect.Effect<A, E, R>,
-  options?: RunCallbackOptions<E, A> | undefined
-) => (fiberId?: FiberId.FiberId | undefined, options?: RunCallbackOptions<E, A> | undefined) => void =
+  options?: RunCallbackOptions<A, E> | undefined
+) => (fiberId?: FiberId.FiberId | undefined, options?: RunCallbackOptions<A, E> | undefined) => void =
   internal.unsafeRunCallback
 
 /**
diff --git a/packages/effect/src/Stream.ts b/packages/effect/src/Stream.ts
index d4a76893f7..0007eebc4e 100644
--- a/packages/effect/src/Stream.ts
+++ b/packages/effect/src/Stream.ts
@@ -3873,7 +3873,7 @@ export const toQueueOfElements: {
  * @since 2.0.0
  * @category destructors
  */
-export const toReadableStream: <E, A>(source: Stream<A, E>) => ReadableStream<A> = internal.toReadableStream
+export const toReadableStream: <A, E>(source: Stream<A, E>) => ReadableStream<A> = internal.toReadableStream
 
 /**
  * Applies the transducer to the stream and emits its outputs.
diff --git a/packages/effect/src/internal/keyedPool.ts b/packages/effect/src/internal/keyedPool.ts
index 9dd786f152..420d94915e 100644
--- a/packages/effect/src/internal/keyedPool.ts
+++ b/packages/effect/src/internal/keyedPool.ts
@@ -53,7 +53,7 @@ class KeyedPoolImpl<in K, in out A, out E = never> implements KeyedPool.KeyedPoo
   }
 }
 
-type MapValue<E, A> = Complete<A, E> | Pending<A, E>
+type MapValue<A, E> = Complete<A, E> | Pending<A, E>
 
 class Complete<in out A, out E> implements Equal.Equal {
   readonly _tag = "Complete"
@@ -101,22 +101,22 @@ const makeImpl = <K, A, E, R>(
     fiberRuntime.all([
       core.context<R>(),
       core.fiberId,
-      core.sync(() => MutableRef.make(HashMap.empty<K, MapValue<E, A>>())),
+      core.sync(() => MutableRef.make(HashMap.empty<K, MapValue<A, E>>())),
       fiberRuntime.scopeMake()
     ]),
     core.map(([context, fiberId, map, scope]) => {
       const getOrCreatePool = (key: K): Effect.Effect<Pool.Pool<A, E>> =>
         core.suspend(() => {
-          let value: MapValue<E, A> | undefined = Option.getOrUndefined(HashMap.get(MutableRef.get(map), key))
+          let value: MapValue<A, E> | undefined = Option.getOrUndefined(HashMap.get(MutableRef.get(map), key))
           if (value === undefined) {
             return core.uninterruptibleMask((restore) => {
               const deferred = core.deferredUnsafeMake<Pool.Pool<A, E>>(fiberId)
               value = new Pending(deferred)
-              let previous: MapValue<E, A> | undefined = undefined
+              let previous: MapValue<A, E> | undefined = undefined
               if (HashMap.has(MutableRef.get(map), key)) {
                 previous = Option.getOrUndefined(HashMap.get(MutableRef.get(map), key))
               } else {
-                MutableRef.update(map, HashMap.set(key, value as MapValue<E, A>))
+                MutableRef.update(map, HashMap.set(key, value as MapValue<A, E>))
               }
               if (previous === undefined) {
                 return pipe(
@@ -143,7 +143,7 @@ const makeImpl = <K, A, E, R>(
                       )
                     },
                     onSuccess: (pool) => {
-                      MutableRef.update(map, HashMap.set(key, new Complete(pool) as MapValue<E, A>))
+                      MutableRef.update(map, HashMap.set(key, new Complete(pool) as MapValue<A, E>))
                       return core.as(
                         core.deferredSucceed(deferred, pool),
                         pool
diff --git a/packages/effect/src/internal/pool.ts b/packages/effect/src/internal/pool.ts
index 67e32b28b4..dd2e0e9a58 100644
--- a/packages/effect/src/internal/pool.ts
+++ b/packages/effect/src/internal/pool.ts
@@ -39,7 +39,7 @@ interface PoolState {
   readonly free: number
 }
 
-interface Attempted<E, A> {
+interface Attempted<A, E> {
   readonly result: Exit.Exit<A, E>
   readonly finalizer: Effect.Effect<unknown>
 }
@@ -141,7 +141,7 @@ class PoolImpl<in out A, in out E> implements Pool.Pool<A, E> {
     readonly max: number,
     readonly isShuttingDown: Ref.Ref<boolean>,
     readonly state: Ref.Ref<PoolState>,
-    readonly items: Queue.Queue<Attempted<E, A>>,
+    readonly items: Queue.Queue<Attempted<A, E>>,
     readonly invalidated: Ref.Ref<HashSet.HashSet<A>>,
     readonly track: (exit: Exit.Exit<A, E>) => Effect.Effect<unknown>
   ) {}
@@ -178,7 +178,7 @@ class PoolImpl<in out A, in out E> implements Pool.Pool<A, E> {
   get get(): Effect.Effect<A, E, Scope.Scope> {
     const acquire = (
       restore: <AX, EX, RX>(effect: Effect.Effect<AX, EX, RX>) => Effect.Effect<AX, EX, RX>
-    ): Effect.Effect<Attempted<E, A>> =>
+    ): Effect.Effect<Attempted<A, E>> =>
       core.flatMap(ref.get(this.isShuttingDown), (down) =>
         down
           ? core.interrupt
@@ -214,7 +214,7 @@ class PoolImpl<in out A, in out E> implements Pool.Pool<A, E> {
             return [core.interrupt, state] as const
           })))
 
-    const release = (attempted: Attempted<E, A>): Effect.Effect<unknown> =>
+    const release = (attempted: Attempted<A, E>): Effect.Effect<unknown> =>
       core.exitMatch(attempted.result, {
         onFailure: () =>
           core.flatten(ref.modify(this.state, (state) => {
@@ -266,7 +266,7 @@ const allocate = <A, E>(
       core.exit(restore(fiberRuntime.scopeExtend(self.creator, scope))),
       (exit) =>
         core.flatMap(
-          core.succeed<Attempted<E, A>>({
+          core.succeed<Attempted<A, E>>({
             result: exit as Exit.Exit<A, E>,
             finalizer: core.scopeClose(scope, core.exitSucceed(void 0))
           }),
@@ -292,7 +292,7 @@ const excess = <A, E>(self: PoolImpl<A, E>): Effect.Effect<number> =>
 
 const finalizeInvalid = <A, E>(
   self: PoolImpl<A, E>,
-  attempted: Attempted<E, A>
+  attempted: Attempted<A, E>
 ): Effect.Effect<unknown> =>
   pipe(
     forEach(attempted, (a) => ref.update(self.invalidated, HashSet.remove(a))),
@@ -337,7 +337,7 @@ const getAndShutdown = <A, E>(self: PoolImpl<A, E>): Effect.Effect<void> =>
 /**
  * Begins pre-allocating pool entries based on minimum pool size.
  */
-const initialize = <E, A>(self: PoolImpl<A, E>): Effect.Effect<void> =>
+const initialize = <A, E>(self: PoolImpl<A, E>): Effect.Effect<void> =>
   fiberRuntime.replicateEffect(
     core.uninterruptibleMask((restore) =>
       core.flatten(ref.modify(self.state, (state) => {
@@ -357,7 +357,7 @@ const initialize = <E, A>(self: PoolImpl<A, E>): Effect.Effect<void> =>
 /**
  * Shrinks the pool down, but never to less than the minimum size.
  */
-const shrink = <E, A>(self: PoolImpl<A, E>): Effect.Effect<void> =>
+const shrink = <A, E>(self: PoolImpl<A, E>): Effect.Effect<void> =>
   core.uninterruptible(
     core.flatten(ref.modify(self.state, (state) => {
       if (state.size > self.min && state.free > 0) {
@@ -379,16 +379,16 @@ const shrink = <E, A>(self: PoolImpl<A, E>): Effect.Effect<void> =>
     }))
   )
 
-const shutdown = <E, A>(self: PoolImpl<A, E>): Effect.Effect<void> =>
+const shutdown = <A, E>(self: PoolImpl<A, E>): Effect.Effect<void> =>
   core.flatten(ref.modify(self.isShuttingDown, (down) =>
     down
       ? [queue.awaitShutdown(self.items), true] as const
       : [core.zipRight(getAndShutdown(self), queue.awaitShutdown(self.items)), true]))
 
-const isFailure = <E, A>(self: Attempted<E, A>): boolean => core.exitIsFailure(self.result)
+const isFailure = <A, E>(self: Attempted<A, E>): boolean => core.exitIsFailure(self.result)
 
 const forEach = <E, A, E2, R>(
-  self: Attempted<E, A>,
+  self: Attempted<A, E>,
   f: (a: A) => Effect.Effect<unknown, E2, R>
 ): Effect.Effect<unknown, E2, R> =>
   core.exitMatch(self.result, {
@@ -396,7 +396,7 @@ const forEach = <E, A, E2, R>(
     onSuccess: f
   })
 
-const toEffect = <E, A>(self: Attempted<E, A>): Effect.Effect<A, E> => self.result
+const toEffect = <A, E>(self: Attempted<A, E>): Effect.Effect<A, E> => self.result
 
 /**
  * A more powerful variant of `make` that allows specifying a `Strategy` that
@@ -417,7 +417,7 @@ const makeWith = <A, E, R, S, R2>(
         core.context<R>(),
         ref.make(false),
         ref.make<PoolState>({ size: 0, free: 0 }),
-        queue.bounded<Attempted<E, A>>(options.max),
+        queue.bounded<Attempted<A, E>>(options.max),
         ref.make(HashSet.empty<A>()),
         options.strategy.initial()
       ]),
diff --git a/packages/effect/src/internal/runtime.ts b/packages/effect/src/internal/runtime.ts
index 173bf63b92..5f11c1228b 100644
--- a/packages/effect/src/internal/runtime.ts
+++ b/packages/effect/src/internal/runtime.ts
@@ -97,10 +97,10 @@ export const unsafeFork = <R>(runtime: Runtime.Runtime<R>) =>
 
 /** @internal */
 export const unsafeRunCallback = <R>(runtime: Runtime.Runtime<R>) =>
-<E, A>(
+<A, E>(
   effect: Effect.Effect<A, E, R>,
-  options: Runtime.RunCallbackOptions<E, A> = {}
-): (fiberId?: FiberId.FiberId, options?: Runtime.RunCallbackOptions<E, A> | undefined) => void => {
+  options: Runtime.RunCallbackOptions<A, E> = {}
+): (fiberId?: FiberId.FiberId, options?: Runtime.RunCallbackOptions<A, E> | undefined) => void => {
   const fiberRuntime = unsafeFork(runtime)(effect, options)
 
   if (options.onExit) {
@@ -131,7 +131,7 @@ export const unsafeRunSync = <R>(runtime: Runtime.Runtime<R>) => <A, E>(effect:
   }
 }
 
-const asyncFiberException = <A, E>(fiber: Fiber.RuntimeFiber<A, E>): Runtime.AsyncFiberException<E, A> => {
+const asyncFiberException = <A, E>(fiber: Fiber.RuntimeFiber<A, E>): Runtime.AsyncFiberException<A, E> => {
   const limit = Error.stackTraceLimit
   Error.stackTraceLimit = 0
   const error = (new Error()) as any
diff --git a/packages/effect/src/internal/sink.ts b/packages/effect/src/internal/sink.ts
index 4abb7067a0..d10556854a 100644
--- a/packages/effect/src/internal/sink.ts
+++ b/packages/effect/src/internal/sink.ts
@@ -1825,7 +1825,7 @@ export const splitWhere = dual<
     core.fromEffect(Ref.make(Chunk.empty<In>())),
     core.flatMap((ref) =>
       pipe(
-        splitWhereSplitter<E, In>(false, ref, f),
+        splitWhereSplitter<In, E>(false, ref, f),
         channel.pipeToOrFail(toChannel(self)),
         core.collectElements,
         core.flatMap(([leftovers, z]) =>
@@ -1846,7 +1846,7 @@ export const splitWhere = dual<
 })
 
 /** @internal */
-const splitWhereSplitter = <E, A>(
+const splitWhereSplitter = <A, E>(
   written: boolean,
   leftovers: Ref.Ref<Chunk.Chunk<A>>,
   f: Predicate<A>
@@ -1854,14 +1854,14 @@ const splitWhereSplitter = <E, A>(
   core.readWithCause({
     onInput: (input) => {
       if (Chunk.isEmpty(input)) {
-        return splitWhereSplitter<E, A>(written, leftovers, f)
+        return splitWhereSplitter(written, leftovers, f)
       }
       if (written) {
         const index = indexWhere(input, f)
         if (index === -1) {
           return channel.zipRight(
             core.write(input),
-            splitWhereSplitter<E, A>(true, leftovers, f)
+            splitWhereSplitter<A, E>(true, leftovers, f)
           )
         }
         const [left, right] = Chunk.splitAt(input, index)
@@ -1874,7 +1874,7 @@ const splitWhereSplitter = <E, A>(
       if (index === -1) {
         return channel.zipRight(
           core.write(input),
-          splitWhereSplitter<E, A>(true, leftovers, f)
+          splitWhereSplitter<A, E>(true, leftovers, f)
         )
       }
       const [left, right] = pipe(input, Chunk.splitAt(Math.max(index, 1)))
diff --git a/packages/effect/src/internal/stm/core.ts b/packages/effect/src/internal/stm/core.ts
index 5427fdc022..474e98a0c8 100644
--- a/packages/effect/src/internal/stm/core.ts
+++ b/packages/effect/src/internal/stm/core.ts
@@ -204,7 +204,7 @@ export const unsafeAtomically = <A, E, R>(
       }
       case TryCommitOpCodes.OP_SUSPEND: {
         const txnId = TxnId.make()
-        const state: { value: STMState.STMState<E, A> } = { value: STMState.running }
+        const state: { value: STMState.STMState<A, E> } = { value: STMState.running }
         const effect = Effect.async(
           (k: (effect: Effect.Effect<A, E, R>) => unknown): void =>
             tryCommitAsync(fiberId, self, txnId, state, env, scheduler, priority, k)
@@ -235,11 +235,11 @@ export const unsafeAtomically = <A, E, R>(
 const tryCommit = <A, E, R>(
   fiberId: FiberId.FiberId,
   stm: STM.STM<A, E, R>,
-  state: { value: STMState.STMState<E, A> },
+  state: { value: STMState.STMState<A, E> },
   env: Context.Context<R>,
   scheduler: Scheduler.Scheduler,
   priority: number
-): TryCommit.TryCommit<E, A> => {
+): TryCommit.TryCommit<A, E> => {
   const journal: Journal.Journal = new Map()
   const tExit = new STMDriver(stm, journal, fiberId, env).run()
   const analysis = Journal.analyzeJournal(journal)
@@ -300,7 +300,7 @@ const tryCommitSync = <A, E, R>(
   env: Context.Context<R>,
   scheduler: Scheduler.Scheduler,
   priority: number
-): TryCommit.TryCommit<E, A> => {
+): TryCommit.TryCommit<A, E> => {
   const journal: Journal.Journal = new Map()
   const tExit = new STMDriver(stm, journal, fiberId, env).run()
   const analysis = Journal.analyzeJournal(journal)
@@ -355,7 +355,7 @@ const tryCommitAsync = <A, E, R>(
   fiberId: FiberId.FiberId,
   self: STM.STM<A, E, R>,
   txnId: TxnId.TxnId,
-  state: { value: STMState.STMState<E, A> },
+  state: { value: STMState.STMState<A, E> },
   context: Context.Context<R>,
   scheduler: Scheduler.Scheduler,
   priority: number,
@@ -386,7 +386,7 @@ const completeTodos = <A, E>(
   journal: Journal.Journal,
   scheduler: Scheduler.Scheduler,
   priority: number
-): TryCommit.TryCommit<E, A> => {
+): TryCommit.TryCommit<A, E> => {
   const todos = Journal.collectTodos(journal)
   if (todos.size > 0) {
     scheduler.scheduleTask(() => Journal.execTodos(todos), priority)
diff --git a/packages/effect/src/internal/stm/stm.ts b/packages/effect/src/internal/stm/stm.ts
index c9b7e5fa5d..661f5604c3 100644
--- a/packages/effect/src/internal/stm/stm.ts
+++ b/packages/effect/src/internal/stm/stm.ts
@@ -38,7 +38,7 @@ export const acquireUseRelease = dual<
   release: (resource: A) => STM.STM<A3, E3, R3>
 ): Effect.Effect<A2, E | E2 | E3, R | R2 | R3> =>
   Effect.uninterruptibleMask((restore) => {
-    let state: STMState.STMState<E, A> = STMState.running
+    let state: STMState.STMState<A, E> = STMState.running
     return pipe(
       restore(
         core.unsafeAtomically(
diff --git a/packages/effect/src/internal/stm/stm/stmState.ts b/packages/effect/src/internal/stm/stm/stmState.ts
index 288eb8cd6e..9c19706bfc 100644
--- a/packages/effect/src/internal/stm/stm/stmState.ts
+++ b/packages/effect/src/internal/stm/stm/stmState.ts
@@ -17,10 +17,10 @@ export const STMStateTypeId = Symbol.for(STMStateSymbolKey)
 export type STMStateTypeId = typeof STMStateTypeId
 
 /** @internal */
-export type STMState<E, A> = Done<E, A> | Interrupted | Running
+export type STMState<A, E> = Done<A, E> | Interrupted | Running
 
 /** @internal */
-export interface Done<out E, out A> extends Equal.Equal {
+export interface Done<out A, out E = never> extends Equal.Equal {
   readonly [STMStateTypeId]: STMStateTypeId
   readonly _tag: OpCodes.OP_DONE
   readonly exit: Exit.Exit<A, E>
@@ -42,22 +42,22 @@ export interface Running extends Equal.Equal {
 export const isSTMState = (u: unknown): u is STMState<unknown, unknown> => hasProperty(u, STMStateTypeId)
 
 /** @internal */
-export const isRunning = <E, A>(self: STMState<E, A>): self is Running => {
+export const isRunning = <A, E>(self: STMState<A, E>): self is Running => {
   return self._tag === OpCodes.OP_RUNNING
 }
 
 /** @internal */
-export const isDone = <E, A>(self: STMState<E, A>): self is Done<E, A> => {
+export const isDone = <A, E>(self: STMState<A, E>): self is Done<A, E> => {
   return self._tag === OpCodes.OP_DONE
 }
 
 /** @internal */
-export const isInterrupted = <E, A>(self: STMState<E, A>): self is Interrupted => {
+export const isInterrupted = <A, E>(self: STMState<A, E>): self is Interrupted => {
   return self._tag === OpCodes.OP_INTERRUPTED
 }
 
 /** @internal */
-export const done = <A, E>(exit: Exit.Exit<A, E>): STMState<E, A> => {
+export const done = <A, E>(exit: Exit.Exit<A, E>): STMState<A, E> => {
   return {
     [STMStateTypeId]: STMStateTypeId,
     _tag: OpCodes.OP_DONE,
@@ -108,7 +108,7 @@ export const running: STMState<never, never> = {
 }
 
 /** @internal */
-export const fromTExit = <E, A>(tExit: TExit.TExit<A, E>): STMState<E, A> => {
+export const fromTExit = <A, E>(tExit: TExit.TExit<A, E>): STMState<A, E> => {
   switch (tExit._tag) {
     case TExitOpCodes.OP_FAIL: {
       return done(Exit.fail(tExit.error))
diff --git a/packages/effect/src/internal/stm/stm/tryCommit.ts b/packages/effect/src/internal/stm/stm/tryCommit.ts
index 54e58ac808..9ad518ef48 100644
--- a/packages/effect/src/internal/stm/stm/tryCommit.ts
+++ b/packages/effect/src/internal/stm/stm/tryCommit.ts
@@ -3,10 +3,10 @@ import * as OpCodes from "../opCodes/tryCommit.js"
 import type * as Journal from "./journal.js"
 
 /** @internal */
-export type TryCommit<E, A> = Done<E, A> | Suspend
+export type TryCommit<A, E> = Done<A, E> | Suspend
 
 /** @internal */
-export interface Done<out E, out A> {
+export interface Done<out A, out E> {
   readonly _tag: OpCodes.OP_DONE
   readonly exit: Exit.Exit<A, E>
 }
@@ -18,7 +18,7 @@ export interface Suspend {
 }
 
 /** @internal */
-export const done = <A, E>(exit: Exit.Exit<A, E>): TryCommit<E, A> => {
+export const done = <A, E>(exit: Exit.Exit<A, E>): TryCommit<A, E> => {
   return {
     _tag: OpCodes.OP_DONE,
     exit
diff --git a/packages/effect/src/internal/stream.ts b/packages/effect/src/internal/stream.ts
index 34144e2900..d2aa89c50e 100644
--- a/packages/effect/src/internal/stream.ts
+++ b/packages/effect/src/internal/stream.ts
@@ -1680,7 +1680,7 @@ export const debounce = dual<
                   )
               })
             const consumer = (
-              state: DebounceState.DebounceState<E, A>
+              state: DebounceState.DebounceState<A, E>
             ): Channel.Channel<Chunk.Chunk<A>, unknown, E, unknown, unknown, unknown> => {
               switch (state._tag) {
                 case DebounceState.OP_NOT_STARTED: {
@@ -4725,13 +4725,13 @@ export const rechunk = dual<
 >(2, <A, E, R>(self: Stream.Stream<A, E, R>, n: number): Stream.Stream<A, E, R> =>
   suspend(() => {
     const target = Math.max(n, 1)
-    const process = rechunkProcess<E, A>(new StreamRechunker(target), target)
+    const process = rechunkProcess(new StreamRechunker(target), target)
     return new StreamImpl(pipe(toChannel(self), core.pipeTo(process)))
   }))
 
 /** @internal */
-const rechunkProcess = <E, A>(
-  rechunker: StreamRechunker<E, A>,
+const rechunkProcess = <A, E>(
+  rechunker: StreamRechunker<A, E>,
   target: number
 ): Channel.Channel<Chunk.Chunk<A>, Chunk.Chunk<A>, E, E, unknown, unknown> =>
   core.readWithCause({
@@ -4767,8 +4767,7 @@ const rechunkProcess = <E, A>(
     onDone: () => rechunker.emitIfNotEmpty()
   })
 
-/** @internal */
-class StreamRechunker<in out E, out A> {
+class StreamRechunker<out A, in out E> {
   private builder: Array<A> = []
   private pos = 0
 
@@ -6656,7 +6655,7 @@ export const toQueueOfElements = dual<
   ))
 
 /** @internal */
-export const toReadableStream = <E, A>(source: Stream.Stream<A, E>) => {
+export const toReadableStream = <A, E>(source: Stream.Stream<A, E>) => {
   let pull: Effect.Effect<void>
   let scope: Scope.CloseableScope
   return new ReadableStream<A>({
diff --git a/packages/effect/src/internal/stream/debounceState.ts b/packages/effect/src/internal/stream/debounceState.ts
index f73deb3a15..957e77f9f8 100644
--- a/packages/effect/src/internal/stream/debounceState.ts
+++ b/packages/effect/src/internal/stream/debounceState.ts
@@ -3,7 +3,7 @@ import type * as Fiber from "../../Fiber.js"
 import type * as HandoffSignal from "./handoffSignal.js"
 
 /** @internal */
-export type DebounceState<E, A> = NotStarted | Previous<A> | Current<E, A>
+export type DebounceState<A, E = never> = NotStarted | Previous<A> | Current<A, E>
 
 /** @internal */
 export const OP_NOT_STARTED = "NotStarted" as const
@@ -34,7 +34,7 @@ export interface Previous<out A> {
 }
 
 /** @internal */
-export interface Current<out E, out A> {
+export interface Current<out A, out E = never> {
   readonly _tag: OP_CURRENT
   readonly fiber: Fiber.Fiber<HandoffSignal.HandoffSignal<E, A>, E>
 }
@@ -45,13 +45,13 @@ export const notStarted: DebounceState<never, never> = {
 }
 
 /** @internal */
-export const previous = <A>(fiber: Fiber.Fiber<Chunk.Chunk<A>>): DebounceState<never, A> => ({
+export const previous = <A>(fiber: Fiber.Fiber<Chunk.Chunk<A>>): DebounceState<A> => ({
   _tag: OP_PREVIOUS,
   fiber
 })
 
 /** @internal */
-export const current = <E, A>(fiber: Fiber.Fiber<HandoffSignal.HandoffSignal<E, A>, E>): DebounceState<E, A> => ({
+export const current = <E, A>(fiber: Fiber.Fiber<HandoffSignal.HandoffSignal<E, A>, E>): DebounceState<A, E> => ({
   _tag: OP_CURRENT,
   fiber
 })