diff --git a/.changeset/quiet-peas-carry.md b/.changeset/quiet-peas-carry.md
new file mode 100644
index 0000000000..d0e90939cb
--- /dev/null
+++ b/.changeset/quiet-peas-carry.md
@@ -0,0 +1,5 @@
+---
+"effect": minor
+---
+
+change `Take` type parameters order from `Take<E, A>` to `Take<A, E = never>`
diff --git a/packages/effect/mod.sh b/packages/effect/mod.sh
index cf0a298205..f2857cf163 100755
--- a/packages/effect/mod.sh
+++ b/packages/effect/mod.sh
@@ -1,5 +1,5 @@
 #!/bin/bash
-dirs=(../effect/src)
+dirs=(../effect/test)
 for dir in ${dirs[@]};
 do
 echo Refactoring $dir
diff --git a/packages/effect/mod.ts b/packages/effect/mod.ts
index 5b77d37b6f..42f5b8d802 100644
--- a/packages/effect/mod.ts
+++ b/packages/effect/mod.ts
@@ -7,10 +7,12 @@ const enabled = {
   swapSTMGenParams: false,
   swapDeferredParams: false,
   swapTDeferredParams: false,
+  swapTakeParams: false,
   cleanupSTM: false,
   cleanupEffect: false,
   cleanupStream: false,
-  cleanupExit: false
+  cleanupExit: false,
+  cleanupTake: true
 }
 
 const cleanup = (name: string) => (ast: cs.ASTPath<cs.TSTypeReference>) => {
@@ -31,6 +33,7 @@ const cleanupEffect = cleanup("Effect")
 const cleanupStream = cleanup("Stream")
 const cleanupExit = cleanup("Exit")
 const cleanupSTM = cleanup("STM")
+const cleanupTake = cleanup("Take")
 
 const filter = (ast: cs.ASTPath<cs.TSTypeReference>, nodeName: string) => {
   const name = ast.value.typeName
@@ -71,8 +74,8 @@ const swapParamsREA = (nodeName: string) => (ast: cs.ASTPath<cs.TSTypeReference>
   }
 }
 
-const swapDeferredParams = (ast: cs.ASTPath<cs.TSTypeReference>) => {
-  const is = filter(ast, "Deferred")
+const swapParamsEA = (nodeName: string) => (ast: cs.ASTPath<cs.TSTypeReference>) => {
+  const is = filter(ast, nodeName)
   if (
     is(ast.value.typeName) &&
     ast.value.typeParameters &&
@@ -80,22 +83,14 @@ const swapDeferredParams = (ast: cs.ASTPath<cs.TSTypeReference>) => {
   ) {
     const params = ast.value.typeParameters.params
     const newParams = [params[1], params[0]]
+    popNever(newParams)
     ast.value.typeParameters.params = newParams
   }
 }
 
-const swapTDeferredParams = (ast: cs.ASTPath<cs.TSTypeReference>) => {
-  const is = filter(ast, "TDeferred")
-  if (
-    is(ast.value.typeName) &&
-    ast.value.typeParameters &&
-    ast.value.typeParameters.params.length === 2
-  ) {
-    const params = ast.value.typeParameters.params
-    const newParams = [params[1], params[0]]
-    ast.value.typeParameters.params = newParams
-  }
-}
+const swapDeferredParams = swapParamsEA("Deferred")
+const swapTDeferredParams = swapParamsEA("TDeferred")
+const swapTakeParams = swapParamsEA("Take")
 
 const swapSTMParams = swapParamsREA("STM")
 const swapSTMGenParams = swapParamsREA("STMGen")
@@ -141,6 +136,9 @@ export default function transformer(file: cs.FileInfo, api: cs.API) {
     if (enabled.swapTDeferredParams) {
       swapTDeferredParams(ast)
     }
+    if (enabled.swapTakeParams) {
+      swapTakeParams(ast)
+    }
     if (enabled.cleanupEffect) {
       cleanupEffect(ast)
     }
@@ -153,6 +151,9 @@ export default function transformer(file: cs.FileInfo, api: cs.API) {
     if (enabled.cleanupSTM) {
       cleanupSTM(ast)
     }
+    if (enabled.cleanupTake) {
+      cleanupTake(ast)
+    }
   })
 
   return root.toSource()
diff --git a/packages/effect/src/GroupBy.ts b/packages/effect/src/GroupBy.ts
index 092a62c55b..520b4bf748 100644
--- a/packages/effect/src/GroupBy.ts
+++ b/packages/effect/src/GroupBy.ts
@@ -30,7 +30,7 @@ export type GroupByTypeId = typeof GroupByTypeId
  * @category models
  */
 export interface GroupBy<out R, out E, out K, out V> extends GroupBy.Variance<R, E, K, V>, Pipeable {
-  readonly grouped: Stream.Stream<readonly [K, Queue.Dequeue<Take.Take<E, V>>], E, R>
+  readonly grouped: Stream.Stream<readonly [K, Queue.Dequeue<Take.Take<V, E>>], E, R>
 }
 
 /**
@@ -99,5 +99,5 @@ export const first: {
  * @category constructors
  */
 export const make: <R, E, K, V>(
-  grouped: Stream.Stream<readonly [K, Queue.Dequeue<Take.Take<E, V>>], E, R>
+  grouped: Stream.Stream<readonly [K, Queue.Dequeue<Take.Take<V, E>>], E, R>
 ) => GroupBy<R, E, K, V> = internal.make
diff --git a/packages/effect/src/Stream.ts b/packages/effect/src/Stream.ts
index d0ee74be06..74cc1b254f 100644
--- a/packages/effect/src/Stream.ts
+++ b/packages/effect/src/Stream.ts
@@ -399,12 +399,12 @@ export const broadcastedQueues: {
     maximumLag: number
   ): <A, E, R>(
     self: Stream<A, E, R>
-  ) => Effect.Effect<Stream.DynamicTuple<Queue.Dequeue<Take.Take<E, A>>, N>, never, R | Scope.Scope>
+  ) => Effect.Effect<Stream.DynamicTuple<Queue.Dequeue<Take.Take<A, E>>, N>, never, R | Scope.Scope>
   <A, E, R, N extends number>(
     self: Stream<A, E, R>,
     n: N,
     maximumLag: number
-  ): Effect.Effect<Stream.DynamicTuple<Queue.Dequeue<Take.Take<E, A>>, N>, never, Scope.Scope | R>
+  ): Effect.Effect<Stream.DynamicTuple<Queue.Dequeue<Take.Take<A, E>>, N>, never, Scope.Scope | R>
 } = internal.broadcastedQueues
 
 /**
@@ -422,11 +422,11 @@ export const broadcastedQueuesDynamic: {
     maximumLag: number
   ): <A, E, R>(
     self: Stream<A, E, R>
-  ) => Effect.Effect<Effect.Effect<Queue.Dequeue<Take.Take<E, A>>, never, Scope.Scope>, never, R | Scope.Scope>
+  ) => Effect.Effect<Effect.Effect<Queue.Dequeue<Take.Take<A, E>>, never, Scope.Scope>, never, R | Scope.Scope>
   <A, E, R>(
     self: Stream<A, E, R>,
     maximumLag: number
-  ): Effect.Effect<Effect.Effect<Queue.Dequeue<Take.Take<E, A>>, never, Scope.Scope>, never, Scope.Scope | R>
+  ): Effect.Effect<Effect.Effect<Queue.Dequeue<Take.Take<A, E>>, never, Scope.Scope>, never, Scope.Scope | R>
 } = internal.broadcastedQueuesDynamic
 
 /**
@@ -1397,7 +1397,7 @@ export const flattenIterables: <A, E, R>(self: Stream<Iterable<A>, E, R>) => Str
  * @since 2.0.0
  * @category sequencing
  */
-export const flattenTake: <R, E, E2, A>(self: Stream<Take.Take<E2, A>, E, R>) => Stream<A, E | E2, R> =
+export const flattenTake: <R, E, E2, A>(self: Stream<Take.Take<A, E2>, E, R>) => Stream<A, E | E2, R> =
   internal.flattenTake
 
 /**
@@ -3180,8 +3180,8 @@ export const runHead: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<Option.O
  * @category destructors
  */
 export const runIntoPubSub: {
-  <E, A>(pubsub: PubSub.PubSub<Take.Take<E, A>>): <R>(self: Stream<A, E, R>) => Effect.Effect<void, never, R>
-  <A, E, R>(self: Stream<A, E, R>, pubsub: PubSub.PubSub<Take.Take<E, A>>): Effect.Effect<void, never, R>
+  <E, A>(pubsub: PubSub.PubSub<Take.Take<A, E>>): <R>(self: Stream<A, E, R>) => Effect.Effect<void, never, R>
+  <A, E, R>(self: Stream<A, E, R>, pubsub: PubSub.PubSub<Take.Take<A, E>>): Effect.Effect<void, never, R>
 } = internal.runIntoPubSub
 
 /**
@@ -3193,9 +3193,9 @@ export const runIntoPubSub: {
  */
 export const runIntoPubSubScoped: {
   <E, A>(
-    pubsub: PubSub.PubSub<Take.Take<E, A>>
+    pubsub: PubSub.PubSub<Take.Take<A, E>>
   ): <R>(self: Stream<A, E, R>) => Effect.Effect<void, never, Scope.Scope | R>
-  <A, E, R>(self: Stream<A, E, R>, pubsub: PubSub.PubSub<Take.Take<E, A>>): Effect.Effect<void, never, Scope.Scope | R>
+  <A, E, R>(self: Stream<A, E, R>, pubsub: PubSub.PubSub<Take.Take<A, E>>): Effect.Effect<void, never, Scope.Scope | R>
 } = internal.runIntoPubSubScoped
 
 /**
@@ -3206,8 +3206,8 @@ export const runIntoPubSubScoped: {
  * @category destructors
  */
 export const runIntoQueue: {
-  <E, A>(queue: Queue.Enqueue<Take.Take<E, A>>): <R>(self: Stream<A, E, R>) => Effect.Effect<void, never, R>
-  <A, E, R>(self: Stream<A, E, R>, queue: Queue.Enqueue<Take.Take<E, A>>): Effect.Effect<void, never, R>
+  <E, A>(queue: Queue.Enqueue<Take.Take<A, E>>): <R>(self: Stream<A, E, R>) => Effect.Effect<void, never, R>
+  <A, E, R>(self: Stream<A, E, R>, queue: Queue.Enqueue<Take.Take<A, E>>): Effect.Effect<void, never, R>
 } = internal.runIntoQueue
 
 /**
@@ -3236,9 +3236,9 @@ export const runIntoQueueElementsScoped: {
  */
 export const runIntoQueueScoped: {
   <E, A>(
-    queue: Queue.Enqueue<Take.Take<E, A>>
+    queue: Queue.Enqueue<Take.Take<A, E>>
   ): <R>(self: Stream<A, E, R>) => Effect.Effect<void, never, Scope.Scope | R>
-  <A, E, R>(self: Stream<A, E, R>, queue: Queue.Enqueue<Take.Take<E, A>>): Effect.Effect<void, never, Scope.Scope | R>
+  <A, E, R>(self: Stream<A, E, R>, queue: Queue.Enqueue<Take.Take<A, E>>): Effect.Effect<void, never, Scope.Scope | R>
 } = internal.runIntoQueueScoped
 
 /**
@@ -3799,11 +3799,11 @@ export const timeoutTo: {
 export const toPubSub: {
   (
     capacity: number
-  ): <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<PubSub.PubSub<Take.Take<E, A>>, never, Scope.Scope | R>
+  ): <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<PubSub.PubSub<Take.Take<A, E>>, never, Scope.Scope | R>
   <A, E, R>(
     self: Stream<A, E, R>,
     capacity: number
-  ): Effect.Effect<PubSub.PubSub<Take.Take<E, A>>, never, Scope.Scope | R>
+  ): Effect.Effect<PubSub.PubSub<Take.Take<A, E>>, never, Scope.Scope | R>
 } = internal.toPubSub
 
 /**
@@ -3834,14 +3834,14 @@ export const toQueue: {
       | { readonly strategy?: "dropping" | "sliding" | "suspend" | undefined; readonly capacity?: number | undefined }
       | { readonly strategy: "unbounded" }
       | undefined
-  ): <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<Queue.Dequeue<Take.Take<E, A>>, never, Scope.Scope | R>
+  ): <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<Queue.Dequeue<Take.Take<A, E>>, never, Scope.Scope | R>
   <A, E, R>(
     self: Stream<A, E, R>,
     options?:
       | { readonly strategy?: "dropping" | "sliding" | "suspend" | undefined; readonly capacity?: number | undefined }
       | { readonly strategy: "unbounded" }
       | undefined
-  ): Effect.Effect<Queue.Dequeue<Take.Take<E, A>>, never, Scope.Scope | R>
+  ): Effect.Effect<Queue.Dequeue<Take.Take<A, E>>, never, Scope.Scope | R>
 } = internal.toQueue
 
 /**
diff --git a/packages/effect/src/Take.ts b/packages/effect/src/Take.ts
index 86008a3a3b..b41a2b6ea0 100644
--- a/packages/effect/src/Take.ts
+++ b/packages/effect/src/Take.ts
@@ -23,14 +23,14 @@ export const TakeTypeId: unique symbol = internal.TakeTypeId
 export type TakeTypeId = typeof TakeTypeId
 
 /**
- * A `Take<E, A>` represents a single `take` from a queue modeling a stream of
+ * A `Take<A, E>` represents a single `take` from a queue modeling a stream of
  * values. A `Take` may be a failure cause `Cause<E>`, a chunk value `Chunk<A>`,
  * or an end-of-stream marker.
  *
  * @since 2.0.0
  * @category models
  */
-export interface Take<out E, out A> extends Take.Variance<E, A>, Pipeable {
+export interface Take<out A, out E = never> extends Take.Variance<A, E>, Pipeable {
   /** @internal */
   readonly exit: Exit.Exit<Chunk.Chunk<A>, Option.Option<E>>
 }
@@ -43,10 +43,10 @@ export declare namespace Take {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<out E, out A> {
+  export interface Variance<out A, out E> {
     readonly [TakeTypeId]: {
-      readonly _E: Types.Covariant<E>
       readonly _A: Types.Covariant<A>
+      readonly _E: Types.Covariant<E>
     }
   }
 }
@@ -57,7 +57,7 @@ export declare namespace Take {
  * @since 2.0.0
  * @category constructors
  */
-export const chunk: <A>(chunk: Chunk.Chunk<A>) => Take<never, A> = internal.chunk
+export const chunk: <A>(chunk: Chunk.Chunk<A>) => Take<A> = internal.chunk
 
 /**
  * Creates a failing `Take` with the specified defect.
@@ -65,7 +65,7 @@ export const chunk: <A>(chunk: Chunk.Chunk<A>) => Take<never, A> = internal.chun
  * @since 2.0.0
  * @category constructors
  */
-export const die: (defect: unknown) => Take<never, never> = internal.die
+export const die: (defect: unknown) => Take<never> = internal.die
 
 /**
  * Creates a failing `Take` with the specified error message.
@@ -73,15 +73,15 @@ export const die: (defect: unknown) => Take<never, never> = internal.die
  * @since 2.0.0
  * @category constructors
  */
-export const dieMessage: (message: string) => Take<never, never> = internal.dieMessage
+export const dieMessage: (message: string) => Take<never> = internal.dieMessage
 
 /**
- * Transforms a `Take<E, A>` to an `Effect<never, E, A>`.
+ * Transforms a `Take<A, E>` to an `Effect<A, E>`.
  *
  * @since 2.0.0
  * @category destructors
  */
-export const done: <E, A>(self: Take<E, A>) => Effect.Effect<Chunk.Chunk<A>, Option.Option<E>> = internal.done
+export const done: <A, E>(self: Take<A, E>) => Effect.Effect<Chunk.Chunk<A>, Option.Option<E>> = internal.done
 
 /**
  * Represents the end-of-stream marker.
@@ -89,7 +89,7 @@ export const done: <E, A>(self: Take<E, A>) => Effect.Effect<Chunk.Chunk<A>, Opt
  * @since 2.0.0
  * @category constructors
  */
-export const end: Take<never, never> = internal.end
+export const end: Take<never> = internal.end
 
 /**
  * Creates a failing `Take` with the specified error.
@@ -97,7 +97,7 @@ export const end: Take<never, never> = internal.end
  * @since 2.0.0
  * @category constructors
  */
-export const fail: <E>(error: E) => Take<E, never> = internal.fail
+export const fail: <E>(error: E) => Take<never, E> = internal.fail
 
 /**
  * Creates a failing `Take` with the specified cause.
@@ -105,17 +105,17 @@ export const fail: <E>(error: E) => Take<E, never> = internal.fail
  * @since 2.0.0
  * @category constructors
  */
-export const failCause: <E>(cause: Cause.Cause<E>) => Take<E, never> = internal.failCause
+export const failCause: <E>(cause: Cause.Cause<E>) => Take<never, E> = internal.failCause
 
 /**
  * Creates an effect from `Effect<A, E, R>` that does not fail, but succeeds with
- * the `Take<E, A>`. Error from stream when pulling is converted to
+ * the `Take<A, E>`. Error from stream when pulling is converted to
  * `Take.failCause`. Creates a single value chunk.
  *
  * @since 2.0.0
  * @category constructors
  */
-export const fromEffect: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<Take<E, A>, never, R> =
+export const fromEffect: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<Take<A, E>, never, R> =
   internal.fromEffect
 
 /**
@@ -124,11 +124,11 @@ export const fromEffect: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Eff
  * @since 2.0.0
  * @category constructors
  */
-export const fromExit: <A, E>(exit: Exit.Exit<A, E>) => Take<E, A> = internal.fromExit
+export const fromExit: <A, E>(exit: Exit.Exit<A, E>) => Take<A, E> = internal.fromExit
 
 /**
  * Creates effect from `Effect<Chunk<A>, Option<E>, R>` that does not fail, but
- * succeeds with the `Take<E, A>`. Errors from stream when pulling are converted
+ * succeeds with the `Take<A, E>`. Errors from stream when pulling are converted
  * to `Take.failCause`, and the end-of-stream is converted to `Take.end`.
  *
  * @since 2.0.0
@@ -136,7 +136,7 @@ export const fromExit: <A, E>(exit: Exit.Exit<A, E>) => Take<E, A> = internal.fr
  */
 export const fromPull: <A, E, R>(
   pull: Effect.Effect<Chunk.Chunk<A>, Option.Option<E>, R>
-) => Effect.Effect<Take<E, A>, never, R> = internal.fromPull
+) => Effect.Effect<Take<A, E>, never, R> = internal.fromPull
 
 /**
  * Checks if this `take` is done (`Take.end`).
@@ -144,7 +144,7 @@ export const fromPull: <A, E, R>(
  * @since 2.0.0
  * @category getters
  */
-export const isDone: <E, A>(self: Take<E, A>) => boolean = internal.isDone
+export const isDone: <A, E>(self: Take<A, E>) => boolean = internal.isDone
 
 /**
  * Checks if this `take` is a failure.
@@ -152,7 +152,7 @@ export const isDone: <E, A>(self: Take<E, A>) => boolean = internal.isDone
  * @since 2.0.0
  * @category getters
  */
-export const isFailure: <E, A>(self: Take<E, A>) => boolean = internal.isFailure
+export const isFailure: <A, E>(self: Take<A, E>) => boolean = internal.isFailure
 
 /**
  * Checks if this `take` is a success.
@@ -160,7 +160,7 @@ export const isFailure: <E, A>(self: Take<E, A>) => boolean = internal.isFailure
  * @since 2.0.0
  * @category getters
  */
-export const isSuccess: <E, A>(self: Take<E, A>) => boolean = internal.isSuccess
+export const isSuccess: <A, E>(self: Take<A, E>) => boolean = internal.isSuccess
 
 /**
  * Constructs a `Take`.
@@ -168,17 +168,17 @@ export const isSuccess: <E, A>(self: Take<E, A>) => boolean = internal.isSuccess
  * @since 2.0.0
  * @category constructors
  */
-export const make: <E, A>(exit: Exit.Exit<Chunk.Chunk<A>, Option.Option<E>>) => Take<E, A> = internal.make
+export const make: <A, E>(exit: Exit.Exit<Chunk.Chunk<A>, Option.Option<E>>) => Take<A, E> = internal.make
 
 /**
- * Transforms `Take<E, A>` to `Take<E, B>` by applying function `f`.
+ * Transforms `Take<A, E>` to `Take<B, A>` by applying function `f`.
  *
  * @since 2.0.0
  * @category mapping
  */
 export const map: {
-  <A, B>(f: (a: A) => B): <E>(self: Take<E, A>) => Take<E, B>
-  <E, A, B>(self: Take<E, A>, f: (a: A) => B): Take<E, B>
+  <A, B>(f: (a: A) => B): <E>(self: Take<A, E>) => Take<B, E>
+  <A, E, B>(self: Take<A, E>, f: (a: A) => B): Take<B, E>
 } = internal.map
 
 /**
@@ -195,9 +195,9 @@ export const match: {
       readonly onFailure: (cause: Cause.Cause<E>) => Z2
       readonly onSuccess: (chunk: Chunk.Chunk<A>) => Z3
     }
-  ): (self: Take<E, A>) => Z | Z2 | Z3
-  <Z, E, Z2, A, Z3>(
-    self: Take<E, A>,
+  ): (self: Take<A, E>) => Z | Z2 | Z3
+  <A, E, Z, Z2, Z3>(
+    self: Take<A, E>,
     options: {
       readonly onEnd: () => Z
       readonly onFailure: (cause: Cause.Cause<E>) => Z2
@@ -216,21 +216,21 @@ export const match: {
  * @category destructors
  */
 export const matchEffect: {
-  <R, E2, Z, R2, E, Z2, A, R3, E3, Z3>(
+  <Z, E2, R, E, Z2, R2, A, Z3, E3, R3>(
     options: {
       readonly onEnd: Effect.Effect<Z, E2, R>
       readonly onFailure: (cause: Cause.Cause<E>) => Effect.Effect<Z2, E2, R2>
       readonly onSuccess: (chunk: Chunk.Chunk<A>) => Effect.Effect<Z3, E3, R3>
     }
-  ): (self: Take<E, A>) => Effect.Effect<Z | Z2 | Z3, E2 | E | E3, R | R2 | R3>
-  <R, E2, Z, R2, E, Z2, A, R3, E3, Z3>(
-    self: Take<E, A>,
+  ): (self: Take<A, E>) => Effect.Effect<Z | Z2 | Z3, E2 | E | E3, R | R2 | R3>
+  <A, E, Z, E2, R, Z2, R2, Z3, E3, R3>(
+    self: Take<A, E>,
     options: {
       readonly onEnd: Effect.Effect<Z, E2, R>
       readonly onFailure: (cause: Cause.Cause<E>) => Effect.Effect<Z2, E2, R2>
       readonly onSuccess: (chunk: Chunk.Chunk<A>) => Effect.Effect<Z3, E3, R3>
     }
-  ): Effect.Effect<Z | Z2 | Z3, E2 | E | E3, R | R2 | R3>
+  ): Effect.Effect<Z | Z2 | Z3, E | E2 | E3, R | R2 | R3>
 } = internal.matchEffect
 
 /**
@@ -239,7 +239,7 @@ export const matchEffect: {
  * @since 2.0.0
  * @category constructors
  */
-export const of: <A>(value: A) => Take<never, A> = internal.of
+export const of: <A>(value: A) => Take<A> = internal.of
 
 /**
  * Returns an effect that effectfully "peeks" at the success of this take.
@@ -248,11 +248,11 @@ export const of: <A>(value: A) => Take<never, A> = internal.of
  * @category sequencing
  */
 export const tap: {
-  <A, R, E2, _>(
+  <A, _, E2, R>(
     f: (chunk: Chunk.Chunk<A>) => Effect.Effect<_, E2, R>
-  ): <E>(self: Take<E, A>) => Effect.Effect<void, E2 | E, R>
-  <E, A, R, E2, _>(
-    self: Take<E, A>,
+  ): <E>(self: Take<A, E>) => Effect.Effect<void, E2 | E, R>
+  <A, E, _, E2, R>(
+    self: Take<A, E>,
     f: (chunk: Chunk.Chunk<A>) => Effect.Effect<_, E2, R>
   ): Effect.Effect<void, E | E2, R>
 } = internal.tap
diff --git a/packages/effect/src/internal/configProvider.ts b/packages/effect/src/internal/configProvider.ts
index 88d28595c9..e00c2fd0df 100644
--- a/packages/effect/src/internal/configProvider.ts
+++ b/packages/effect/src/internal/configProvider.ts
@@ -626,9 +626,7 @@ const transpose = <A>(array: ReadonlyArray<ReadonlyArray<A>>): ReadonlyArray<Rea
   return Object.keys(array[0]).map((column) => array.map((row) => row[column as any]))
 }
 
-const escapeRegex = (string: string): string => {
-  return string.replace(/[/\-\\^$*+?.()|[\]{}]/g, "\\$&")
-}
+const escapeRegex = (string: string): string => string.replace(/[/\-\\^$*+?.()|[\]{}]/g, "\\$&")
 
 const indicesFrom = (quotedIndices: HashSet.HashSet<string>): Effect.Effect<ReadonlyArray<number>> =>
   pipe(
diff --git a/packages/effect/src/internal/groupBy.ts b/packages/effect/src/internal/groupBy.ts
index 3b0b3a872b..a45b99e18d 100644
--- a/packages/effect/src/internal/groupBy.ts
+++ b/packages/effect/src/internal/groupBy.ts
@@ -113,7 +113,7 @@ export const first = dual<
 
 /** @internal */
 export const make = <R, E, K, V>(
-  grouped: Stream.Stream<readonly [K, Queue.Dequeue<Take.Take<E, V>>], E, R>
+  grouped: Stream.Stream<readonly [K, Queue.Dequeue<Take.Take<V, E>>], E, R>
 ): GroupBy.GroupBy<R, E, K, V> => ({
   [GroupByTypeId]: groupByVariance,
   pipe() {
@@ -155,7 +155,7 @@ export const groupBy = dual<
             Deferred.make<(key: K, value: V) => Effect.Effect<Predicate<number>>>()
           )
           const output = yield* $(Effect.acquireRelease(
-            Queue.bounded<Exit.Exit<readonly [K, Queue.Dequeue<Take.Take<E | E2, V>>], Option.Option<E | E2>>>(
+            Queue.bounded<Exit.Exit<readonly [K, Queue.Dequeue<Take.Take<V, E | E2>>], Option.Option<E | E2>>>(
               options?.bufferSize ?? 16
             ),
             (queue) => Queue.shutdown(queue)
@@ -417,8 +417,8 @@ export const groupByKey = dual<
     }
   ): GroupBy.GroupBy<R, E, K, A> => {
     const loop = (
-      map: Map<K, Queue.Queue<Take.Take<E, A>>>,
-      outerQueue: Queue.Queue<Take.Take<E, readonly [K, Queue.Queue<Take.Take<E, A>>]>>
+      map: Map<K, Queue.Queue<Take.Take<A, E>>>,
+      outerQueue: Queue.Queue<Take.Take<readonly [K, Queue.Queue<Take.Take<A, E>>], E>>
     ): Channel.Channel<R, E, Chunk.Chunk<A>, unknown, E, never, unknown> =>
       core.readWithCause({
         onInput: (input: Chunk.Chunk<A>) =>
@@ -428,7 +428,7 @@ export const groupByKey = dual<
                 const innerQueue = map.get(key)
                 if (innerQueue === undefined) {
                   return pipe(
-                    Queue.bounded<Take.Take<E, A>>(options?.bufferSize ?? 16),
+                    Queue.bounded<Take.Take<A, E>>(options?.bufferSize ?? 16),
                     Effect.flatMap((innerQueue) =>
                       pipe(
                         Effect.sync(() => {
@@ -483,11 +483,11 @@ export const groupByKey = dual<
       })
     return make(stream.unwrapScoped(
       pipe(
-        Effect.sync(() => new Map<K, Queue.Queue<Take.Take<E, A>>>()),
+        Effect.sync(() => new Map<K, Queue.Queue<Take.Take<A, E>>>()),
         Effect.flatMap((map) =>
           pipe(
             Effect.acquireRelease(
-              Queue.unbounded<Take.Take<E, readonly [K, Queue.Queue<Take.Take<E, A>>]>>(),
+              Queue.unbounded<Take.Take<readonly [K, Queue.Queue<Take.Take<A, E>>], E>>(),
               (queue) => Queue.shutdown(queue)
             ),
             Effect.flatMap((queue) =>
diff --git a/packages/effect/src/internal/logSpan.ts b/packages/effect/src/internal/logSpan.ts
index 86b60a663e..4b9a4c5af9 100644
--- a/packages/effect/src/internal/logSpan.ts
+++ b/packages/effect/src/internal/logSpan.ts
@@ -7,9 +7,7 @@ export const make = (label: string, startTime: number): LogSpan.LogSpan => ({
 })
 
 /** @internal */
-export const render = (now: number) => {
-  return (self: LogSpan.LogSpan): string => {
-    const label = self.label.replace(/[\s="]/g, "_")
-    return `${label}=${now - self.startTime}ms`
-  }
+export const render = (now: number) => (self: LogSpan.LogSpan): string => {
+  const label = self.label.replace(/[\s="]/g, "_")
+  return `${label}=${now - self.startTime}ms`
 }
diff --git a/packages/effect/src/internal/stm/tDeferred.ts b/packages/effect/src/internal/stm/tDeferred.ts
index 0169492776..ca3ad8f466 100644
--- a/packages/effect/src/internal/stm/tDeferred.ts
+++ b/packages/effect/src/internal/stm/tDeferred.ts
@@ -18,7 +18,9 @@ export const TDeferredTypeId: TDeferred.TDeferredTypeId = Symbol.for(
 
 /** @internal */
 const tDeferredVariance = {
+  /* c8 ignore next */
   _A: (_: any) => _,
+  /* c8 ignore next */
   _E: (_: any) => _
 }
 
diff --git a/packages/effect/src/internal/stream.ts b/packages/effect/src/internal/stream.ts
index dea6393530..dc99e357a2 100644
--- a/packages/effect/src/internal/stream.ts
+++ b/packages/effect/src/internal/stream.ts
@@ -477,7 +477,7 @@ export const asyncEffect = <A, E = never, R = never>(
 ): Stream.Stream<A, E, R> =>
   pipe(
     Effect.acquireRelease(
-      Queue.bounded<Take.Take<E, A>>(outputBuffer),
+      Queue.bounded<Take.Take<A, E>>(outputBuffer),
       (queue) => Queue.shutdown(queue)
     ),
     Effect.flatMap((output) =>
@@ -534,7 +534,7 @@ export const asyncInterrupt = <A, E = never, R = never>(
 ): Stream.Stream<A, E, R> =>
   pipe(
     Effect.acquireRelease(
-      Queue.bounded<Take.Take<E, A>>(outputBuffer),
+      Queue.bounded<Take.Take<A, E>>(outputBuffer),
       (queue) => Queue.shutdown(queue)
     ),
     Effect.flatMap((output) =>
@@ -610,7 +610,7 @@ export const asyncScoped = <A, E = never, R = never>(
 ): Stream.Stream<A, E, Exclude<R, Scope.Scope>> =>
   pipe(
     Effect.acquireRelease(
-      Queue.bounded<Take.Take<E, A>>(outputBuffer),
+      Queue.bounded<Take.Take<A, E>>(outputBuffer),
       (queue) => Queue.shutdown(queue)
     ),
     Effect.flatMap((output) =>
@@ -766,21 +766,21 @@ export const broadcastedQueues = dual<
     maximumLag: number
   ) => <A, E, R>(
     self: Stream.Stream<A, E, R>
-  ) => Effect.Effect<Stream.Stream.DynamicTuple<Queue.Dequeue<Take.Take<E, A>>, N>, never, Scope.Scope | R>,
+  ) => Effect.Effect<Stream.Stream.DynamicTuple<Queue.Dequeue<Take.Take<A, E>>, N>, never, Scope.Scope | R>,
   <A, E, R, N extends number>(
     self: Stream.Stream<A, E, R>,
     n: N,
     maximumLag: number
-  ) => Effect.Effect<Stream.Stream.DynamicTuple<Queue.Dequeue<Take.Take<E, A>>, N>, never, Scope.Scope | R>
+  ) => Effect.Effect<Stream.Stream.DynamicTuple<Queue.Dequeue<Take.Take<A, E>>, N>, never, Scope.Scope | R>
 >(3, <A, E, R, N extends number>(
   self: Stream.Stream<A, E, R>,
   n: N,
   maximumLag: number
-): Effect.Effect<Stream.Stream.DynamicTuple<Queue.Dequeue<Take.Take<E, A>>, N>, never, Scope.Scope | R> =>
-  Effect.flatMap(PubSub.bounded<Take.Take<E, A>>(maximumLag), (pubsub) =>
+): Effect.Effect<Stream.Stream.DynamicTuple<Queue.Dequeue<Take.Take<A, E>>, N>, never, Scope.Scope | R> =>
+  Effect.flatMap(PubSub.bounded<Take.Take<A, E>>(maximumLag), (pubsub) =>
     pipe(
       Effect.all(Array.from({ length: n }, () => PubSub.subscribe(pubsub))) as Effect.Effect<
-        Stream.Stream.DynamicTuple<Queue.Dequeue<Take.Take<E, A>>, N>,
+        Stream.Stream.DynamicTuple<Queue.Dequeue<Take.Take<A, E>>, N>,
         never,
         R
       >,
@@ -793,15 +793,15 @@ export const broadcastedQueuesDynamic = dual<
     maximumLag: number
   ) => <A, E, R>(
     self: Stream.Stream<A, E, R>
-  ) => Effect.Effect<Effect.Effect<Queue.Dequeue<Take.Take<E, A>>, never, Scope.Scope>, never, Scope.Scope | R>,
+  ) => Effect.Effect<Effect.Effect<Queue.Dequeue<Take.Take<A, E>>, never, Scope.Scope>, never, Scope.Scope | R>,
   <A, E, R>(
     self: Stream.Stream<A, E, R>,
     maximumLag: number
-  ) => Effect.Effect<Effect.Effect<Queue.Dequeue<Take.Take<E, A>>, never, Scope.Scope>, never, Scope.Scope | R>
+  ) => Effect.Effect<Effect.Effect<Queue.Dequeue<Take.Take<A, E>>, never, Scope.Scope>, never, Scope.Scope | R>
 >(2, <A, E, R>(
   self: Stream.Stream<A, E, R>,
   maximumLag: number
-): Effect.Effect<Effect.Effect<Queue.Dequeue<Take.Take<E, A>>, never, Scope.Scope>, never, Scope.Scope | R> =>
+): Effect.Effect<Effect.Effect<Queue.Dequeue<Take.Take<A, E>>, never, Scope.Scope>, never, Scope.Scope | R> =>
   Effect.map(toPubSub(self, maximumLag), PubSub.subscribe))
 
 /** @internal */
@@ -902,7 +902,7 @@ const bufferChunksDropping = dual<
   <A, E, R>(self: Stream.Stream<A, E, R>, capacity: number) => Stream.Stream<A, E, R>
 >(2, <A, E, R>(self: Stream.Stream<A, E, R>, capacity: number): Stream.Stream<A, E, R> => {
   const queue = Effect.acquireRelease(
-    Queue.dropping<readonly [Take.Take<E, A>, Deferred.Deferred<void, never>]>(capacity),
+    Queue.dropping<readonly [Take.Take<A, E>, Deferred.Deferred<void, never>]>(capacity),
     (queue) => Queue.shutdown(queue)
   )
   return new StreamImpl(bufferSignal(queue, toChannel(self)))
@@ -913,7 +913,7 @@ const bufferChunksSliding = dual<
   <A, E, R>(self: Stream.Stream<A, E, R>, capacity: number) => Stream.Stream<A, E, R>
 >(2, <A, E, R>(self: Stream.Stream<A, E, R>, capacity: number): Stream.Stream<A, E, R> => {
   const queue = Effect.acquireRelease(
-    Queue.sliding<readonly [Take.Take<E, A>, Deferred.Deferred<void, never>]>(capacity),
+    Queue.sliding<readonly [Take.Take<A, E>, Deferred.Deferred<void, never>]>(capacity),
     (queue) => Queue.shutdown(queue)
   )
   return new StreamImpl(bufferSignal(queue, toChannel(self)))
@@ -924,7 +924,7 @@ const bufferDropping = dual<
   <A, E, R>(self: Stream.Stream<A, E, R>, capacity: number) => Stream.Stream<A, E, R>
 >(2, <A, E, R>(self: Stream.Stream<A, E, R>, capacity: number): Stream.Stream<A, E, R> => {
   const queue = Effect.acquireRelease(
-    Queue.dropping<readonly [Take.Take<E, A>, Deferred.Deferred<void, never>]>(capacity),
+    Queue.dropping<readonly [Take.Take<A, E>, Deferred.Deferred<void, never>]>(capacity),
     (queue) => Queue.shutdown(queue)
   )
   return new StreamImpl(bufferSignal(queue, toChannel(rechunk(1)(self))))
@@ -935,7 +935,7 @@ const bufferSliding = dual<
   <A, E, R>(self: Stream.Stream<A, E, R>, capacity: number) => Stream.Stream<A, E, R>
 >(2, <A, E, R>(self: Stream.Stream<A, E, R>, capacity: number): Stream.Stream<A, E, R> => {
   const queue = Effect.acquireRelease(
-    Queue.sliding<readonly [Take.Take<E, A>, Deferred.Deferred<void, never>]>(capacity),
+    Queue.sliding<readonly [Take.Take<A, E>, Deferred.Deferred<void, never>]>(capacity),
     (queue) => Queue.shutdown(queue)
   )
   return new StreamImpl(bufferSignal(queue, toChannel(pipe(self, rechunk(1)))))
@@ -961,14 +961,14 @@ const bufferUnbounded = <A, E, R>(self: Stream.Stream<A, E, R>): Stream.Stream<A
 }
 
 const bufferSignal = <A, E, R>(
-  scoped: Effect.Effect<Queue.Queue<readonly [Take.Take<E, A>, Deferred.Deferred<void, never>]>, never, Scope.Scope>,
+  scoped: Effect.Effect<Queue.Queue<readonly [Take.Take<A, E>, Deferred.Deferred<void, never>]>, never, Scope.Scope>,
   bufferChannel: Channel.Channel<R, unknown, unknown, unknown, E, Chunk.Chunk<A>, void>
 ): Channel.Channel<R, unknown, unknown, unknown, E, Chunk.Chunk<A>, void> => {
   const producer = (
-    queue: Queue.Queue<readonly [Take.Take<E, A>, Deferred.Deferred<void, never>]>,
+    queue: Queue.Queue<readonly [Take.Take<A, E>, Deferred.Deferred<void, never>]>,
     ref: Ref.Ref<Deferred.Deferred<void, never>>
   ): Channel.Channel<R, E, Chunk.Chunk<A>, unknown, never, never, unknown> => {
-    const terminate = (take: Take.Take<E, A>): Channel.Channel<R, E, Chunk.Chunk<A>, unknown, never, never, unknown> =>
+    const terminate = (take: Take.Take<A, E>): Channel.Channel<R, E, Chunk.Chunk<A>, unknown, never, never, unknown> =>
       pipe(
         Ref.get(ref),
         Effect.tap(Deferred.await),
@@ -1003,7 +1003,7 @@ const bufferSignal = <A, E, R>(
     })
   }
   const consumer = (
-    queue: Queue.Queue<readonly [Take.Take<E, A>, Deferred.Deferred<void, never>]>
+    queue: Queue.Queue<readonly [Take.Take<A, E>, Deferred.Deferred<void, never>]>
   ): Channel.Channel<R, unknown, unknown, unknown, E, Chunk.Chunk<A>, void> => {
     const process: Channel.Channel<never, unknown, unknown, unknown, E, Chunk.Chunk<A>, void> = pipe(
       core.fromEffect(Queue.take(queue)),
@@ -1460,7 +1460,7 @@ export const combineChunks = dual<
   ) => Effect.Effect<Exit.Exit<readonly [Chunk.Chunk<A3>, S], Option.Option<E2 | E>>, never, R5>
 ): Stream.Stream<A3, E2 | E, R2 | R3 | R4 | R5 | R> => {
   const producer = <Err, Elem>(
-    handoff: Handoff.Handoff<Take.Take<Err, Elem>>,
+    handoff: Handoff.Handoff<Take.Take<Elem, Err>>,
     latch: Handoff.Handoff<void>
   ): Channel.Channel<R, Err, Chunk.Chunk<Elem>, unknown, never, never, unknown> =>
     channel.zipRight(
@@ -1470,26 +1470,26 @@ export const combineChunks = dual<
           core.flatMap(
             core.fromEffect(pipe(
               handoff,
-              Handoff.offer<Take.Take<Err, Elem>>(_take.chunk(input))
+              Handoff.offer<Take.Take<Elem, Err>>(_take.chunk(input))
             )),
             () => producer(handoff, latch)
           ),
         onFailure: (cause) =>
           core.fromEffect(
-            Handoff.offer<Take.Take<Err, Elem>>(
+            Handoff.offer<Take.Take<Elem, Err>>(
               handoff,
               _take.failCause(cause)
             )
           ),
         onDone: (): Channel.Channel<R, Err, Chunk.Chunk<Elem>, unknown, never, never, unknown> =>
-          core.fromEffect(Handoff.offer<Take.Take<Err, Elem>>(handoff, _take.end))
+          core.fromEffect(Handoff.offer<Take.Take<Elem, Err>>(handoff, _take.end))
       })
     )
   return new StreamImpl(
     pipe(
       Effect.all([
-        Handoff.make<Take.Take<E, A>>(),
-        Handoff.make<Take.Take<E2, A2>>(),
+        Handoff.make<Take.Take<A, E>>(),
+        Handoff.make<Take.Take<A2, E2>>(),
         Handoff.make<void>(),
         Handoff.make<void>()
       ]),
@@ -2818,7 +2818,7 @@ export const flattenIterables = <A, E, R>(self: Stream.Stream<Iterable<A>, E, R>
   pipe(self, map(Chunk.fromIterable), flattenChunks)
 
 /** @internal */
-export const flattenTake = <R, E, E2, A>(self: Stream.Stream<Take.Take<E2, A>, E, R>): Stream.Stream<A, E | E2, R> =>
+export const flattenTake = <R, E, E2, A>(self: Stream.Stream<Take.Take<A, E2>, E, R>): Stream.Stream<A, E | E2, R> =>
   flattenChunks(flattenExitOption(pipe(self, map((take) => take.exit))))
 
 /** @internal */
@@ -3384,33 +3384,33 @@ export const interleaveWith = dual<
     decider: Stream.Stream<boolean, E3, R3>
   ): Stream.Stream<A2 | A, E2 | E3 | E, R2 | R3 | R> => {
     const producer = (
-      handoff: Handoff.Handoff<Take.Take<E | E2 | E3, A | A2>>
+      handoff: Handoff.Handoff<Take.Take<A | A2, E | E2 | E3>>
     ): Channel.Channel<R | R2 | R3, E | E2 | E3, A | A2, unknown, never, never, void> =>
       core.readWithCause({
         onInput: (value: A | A2) =>
           core.flatMap(
             core.fromEffect(
-              Handoff.offer<Take.Take<E | E2 | E3, A | A2>>(handoff, _take.of(value))
+              Handoff.offer<Take.Take<A | A2, E | E2 | E3>>(handoff, _take.of(value))
             ),
             () => producer(handoff)
           ),
         onFailure: (cause) =>
           core.fromEffect(
-            Handoff.offer<Take.Take<E | E2 | E3, A | A2>>(
+            Handoff.offer<Take.Take<A | A2, E | E2 | E3>>(
               handoff,
               _take.failCause(cause)
             )
           ),
         onDone: () =>
           core.fromEffect(
-            Handoff.offer<Take.Take<E | E2 | E3, A | A2>>(handoff, _take.end)
+            Handoff.offer<Take.Take<A | A2, E | E2 | E3>>(handoff, _take.end)
           )
       })
     return new StreamImpl(
       channel.unwrapScoped(
         pipe(
-          Handoff.make<Take.Take<E | E2 | E3, A | A2>>(),
-          Effect.zip(Handoff.make<Take.Take<E | E2 | E3, A | A2>>()),
+          Handoff.make<Take.Take<A | A2, E | E2 | E3>>(),
+          Effect.zip(Handoff.make<Take.Take<A | A2, E | E2 | E3>>()),
           Effect.tap(([left]) =>
             pipe(
               toChannel(self),
@@ -5383,35 +5383,35 @@ export const runHead = <A, E, R>(self: Stream.Stream<A, E, R>): Effect.Effect<Op
 
 /** @internal */
 export const runIntoPubSub = dual<
-  <E, A>(pubsub: PubSub.PubSub<Take.Take<E, A>>) => <R>(self: Stream.Stream<A, E, R>) => Effect.Effect<void, never, R>,
-  <A, E, R>(self: Stream.Stream<A, E, R>, pubsub: PubSub.PubSub<Take.Take<E, A>>) => Effect.Effect<void, never, R>
+  <E, A>(pubsub: PubSub.PubSub<Take.Take<A, E>>) => <R>(self: Stream.Stream<A, E, R>) => Effect.Effect<void, never, R>,
+  <A, E, R>(self: Stream.Stream<A, E, R>, pubsub: PubSub.PubSub<Take.Take<A, E>>) => Effect.Effect<void, never, R>
 >(
   2,
-  <A, E, R>(self: Stream.Stream<A, E, R>, pubsub: PubSub.PubSub<Take.Take<E, A>>): Effect.Effect<void, never, R> =>
+  <A, E, R>(self: Stream.Stream<A, E, R>, pubsub: PubSub.PubSub<Take.Take<A, E>>): Effect.Effect<void, never, R> =>
     pipe(self, runIntoQueue(pubsub))
 )
 
 /** @internal */
 export const runIntoPubSubScoped = dual<
   <E, A>(
-    pubsub: PubSub.PubSub<Take.Take<E, A>>
+    pubsub: PubSub.PubSub<Take.Take<A, E>>
   ) => <R>(self: Stream.Stream<A, E, R>) => Effect.Effect<void, never, Scope.Scope | R>,
   <A, E, R>(
     self: Stream.Stream<A, E, R>,
-    pubsub: PubSub.PubSub<Take.Take<E, A>>
+    pubsub: PubSub.PubSub<Take.Take<A, E>>
   ) => Effect.Effect<void, never, Scope.Scope | R>
 >(2, <A, E, R>(
   self: Stream.Stream<A, E, R>,
-  pubsub: PubSub.PubSub<Take.Take<E, A>>
+  pubsub: PubSub.PubSub<Take.Take<A, E>>
 ): Effect.Effect<void, never, Scope.Scope | R> => pipe(self, runIntoQueueScoped(pubsub)))
 
 /** @internal */
 export const runIntoQueue = dual<
-  <E, A>(queue: Queue.Enqueue<Take.Take<E, A>>) => <R>(self: Stream.Stream<A, E, R>) => Effect.Effect<void, never, R>,
-  <A, E, R>(self: Stream.Stream<A, E, R>, queue: Queue.Enqueue<Take.Take<E, A>>) => Effect.Effect<void, never, R>
+  <E, A>(queue: Queue.Enqueue<Take.Take<A, E>>) => <R>(self: Stream.Stream<A, E, R>) => Effect.Effect<void, never, R>,
+  <A, E, R>(self: Stream.Stream<A, E, R>, queue: Queue.Enqueue<Take.Take<A, E>>) => Effect.Effect<void, never, R>
 >(
   2,
-  <A, E, R>(self: Stream.Stream<A, E, R>, queue: Queue.Enqueue<Take.Take<E, A>>): Effect.Effect<void, never, R> =>
+  <A, E, R>(self: Stream.Stream<A, E, R>, queue: Queue.Enqueue<Take.Take<A, E>>): Effect.Effect<void, never, R> =>
     pipe(self, runIntoQueueScoped(queue), Effect.scoped)
 )
 
@@ -5449,17 +5449,17 @@ export const runIntoQueueElementsScoped = dual<
 /** @internal */
 export const runIntoQueueScoped = dual<
   <E, A>(
-    queue: Queue.Enqueue<Take.Take<E, A>>
+    queue: Queue.Enqueue<Take.Take<A, E>>
   ) => <R>(self: Stream.Stream<A, E, R>) => Effect.Effect<void, never, Scope.Scope | R>,
   <A, E, R>(
     self: Stream.Stream<A, E, R>,
-    queue: Queue.Enqueue<Take.Take<E, A>>
+    queue: Queue.Enqueue<Take.Take<A, E>>
   ) => Effect.Effect<void, never, Scope.Scope | R>
 >(2, <A, E, R>(
   self: Stream.Stream<A, E, R>,
-  queue: Queue.Enqueue<Take.Take<E, A>>
+  queue: Queue.Enqueue<Take.Take<A, E>>
 ): Effect.Effect<void, never, Scope.Scope | R> => {
-  const writer: Channel.Channel<R, E, Chunk.Chunk<A>, unknown, never, Take.Take<E, A>, unknown> = core
+  const writer: Channel.Channel<R, E, Chunk.Chunk<A>, unknown, never, Take.Take<A, E>, unknown> = core
     .readWithCause({
       onInput: (input: Chunk.Chunk<A>) => core.flatMap(core.write(_take.chunk(input)), () => writer),
       onFailure: (cause) => core.write(_take.failCause(cause)),
@@ -6233,7 +6233,7 @@ export const tapSink = dual<
     sink: Sink.Sink<R2, E2, A, unknown, unknown>
   ): Stream.Stream<A, E | E2, R | R2> =>
     pipe(
-      fromEffect(Effect.all([Queue.bounded<Take.Take<E | E2, A>>(1), Deferred.make<void>()])),
+      fromEffect(Effect.all([Queue.bounded<Take.Take<A, E | E2>>(1), Deferred.make<void>()])),
       flatMap(([queue, deferred]) => {
         const right = flattenTake(fromQueue(queue, { maxChunkSize: 1 }))
         const loop: Channel.Channel<R2, E, Chunk.Chunk<A>, unknown, E | E2, Chunk.Chunk<A>, unknown> = core
@@ -6563,18 +6563,18 @@ export const timeoutTo = dual<
 export const toPubSub = dual<
   (
     capacity: number
-  ) => <A, E, R>(self: Stream.Stream<A, E, R>) => Effect.Effect<PubSub.PubSub<Take.Take<E, A>>, never, Scope.Scope | R>,
+  ) => <A, E, R>(self: Stream.Stream<A, E, R>) => Effect.Effect<PubSub.PubSub<Take.Take<A, E>>, never, Scope.Scope | R>,
   <A, E, R>(
     self: Stream.Stream<A, E, R>,
     capacity: number
-  ) => Effect.Effect<PubSub.PubSub<Take.Take<E, A>>, never, Scope.Scope | R>
+  ) => Effect.Effect<PubSub.PubSub<Take.Take<A, E>>, never, Scope.Scope | R>
 >(2, <A, E, R>(
   self: Stream.Stream<A, E, R>,
   capacity: number
-): Effect.Effect<PubSub.PubSub<Take.Take<E, A>>, never, Scope.Scope | R> =>
+): Effect.Effect<PubSub.PubSub<Take.Take<A, E>>, never, Scope.Scope | R> =>
   pipe(
     Effect.acquireRelease(
-      PubSub.bounded<Take.Take<E, A>>(capacity),
+      PubSub.bounded<Take.Take<A, E>>(capacity),
       (pubsub) => PubSub.shutdown(pubsub)
     ),
     Effect.tap((pubsub) => pipe(self, runIntoPubSubScoped(pubsub), Effect.forkScoped))
@@ -6605,7 +6605,7 @@ export const toQueue = dual<
     }
   ) => <A, E, R>(
     self: Stream.Stream<A, E, R>
-  ) => Effect.Effect<Queue.Dequeue<Take.Take<E, A>>, never, R | Scope.Scope>,
+  ) => Effect.Effect<Queue.Dequeue<Take.Take<A, E>>, never, R | Scope.Scope>,
   <A, E, R>(
     self: Stream.Stream<A, E, R>,
     options?: {
@@ -6614,7 +6614,7 @@ export const toQueue = dual<
     } | {
       readonly strategy: "unbounded"
     }
-  ) => Effect.Effect<Queue.Dequeue<Take.Take<E, A>>, never, R | Scope.Scope>
+  ) => Effect.Effect<Queue.Dequeue<Take.Take<A, E>>, never, R | Scope.Scope>
 >((args) => isStream(args[0]), <A, E, R>(
   self: Stream.Stream<A, E, R>,
   options?: {
@@ -6627,12 +6627,12 @@ export const toQueue = dual<
   Effect.tap(
     Effect.acquireRelease(
       options?.strategy === "unbounded" ?
-        Queue.unbounded<Take.Take<E, A>>() :
+        Queue.unbounded<Take.Take<A, E>>() :
         options?.strategy === "dropping" ?
-        Queue.dropping<Take.Take<E, A>>(options.capacity ?? 2) :
+        Queue.dropping<Take.Take<A, E>>(options.capacity ?? 2) :
         options?.strategy === "sliding" ?
-        Queue.sliding<Take.Take<E, A>>(options.capacity ?? 2) :
-        Queue.bounded<Take.Take<E, A>>(options?.capacity ?? 2),
+        Queue.sliding<Take.Take<A, E>>(options.capacity ?? 2) :
+        Queue.bounded<Take.Take<A, E>>(options?.capacity ?? 2),
       (queue) => Queue.shutdown(queue)
     ),
     (queue) => Effect.forkScoped(runIntoQueueScoped(self, queue))
diff --git a/packages/effect/src/internal/stream/pull.ts b/packages/effect/src/internal/stream/pull.ts
index 7cd5cfcdff..2f8108085e 100644
--- a/packages/effect/src/internal/stream/pull.ts
+++ b/packages/effect/src/internal/stream/pull.ts
@@ -30,5 +30,5 @@ export const failCause = <E>(cause: Cause.Cause<E>): Effect.Effect<never, Option
 
 /** @internal */
 export const fromDequeue = <E, A>(
-  dequeue: Queue.Dequeue<Take.Take<E, A>>
+  dequeue: Queue.Dequeue<Take.Take<A, E>>
 ): Effect.Effect<Chunk.Chunk<A>, Option.Option<E>> => Effect.flatMap(Queue.take(dequeue), take.done)
diff --git a/packages/effect/src/internal/take.ts b/packages/effect/src/internal/take.ts
index 8d39a16ac1..51b090682e 100644
--- a/packages/effect/src/internal/take.ts
+++ b/packages/effect/src/internal/take.ts
@@ -17,13 +17,13 @@ export const TakeTypeId: Take.TakeTypeId = Symbol.for(
 
 const takeVariance = {
   /* c8 ignore next */
-  _E: (_: never) => _,
+  _A: (_: never) => _,
   /* c8 ignore next */
-  _A: (_: never) => _
+  _E: (_: never) => _
 }
 
 /** @internal */
-export class TakeImpl<out E, out A> implements Take.Take<E, A> {
+export class TakeImpl<out A, out E = never> implements Take.Take<A, E> {
   readonly [TakeTypeId] = takeVariance
   constructor(readonly exit: Exit.Exit<Chunk.Chunk<A>, Option.Option<E>>) {
   }
@@ -33,41 +33,41 @@ export class TakeImpl<out E, out A> implements Take.Take<E, A> {
 }
 
 /** @internal */
-export const chunk = <A>(chunk: Chunk.Chunk<A>): Take.Take<never, A> => new TakeImpl(Exit.succeed(chunk))
+export const chunk = <A>(chunk: Chunk.Chunk<A>): Take.Take<A> => new TakeImpl(Exit.succeed(chunk))
 
 /** @internal */
-export const die = (defect: unknown): Take.Take<never, never> => new TakeImpl(Exit.die(defect))
+export const die = (defect: unknown): Take.Take<never> => new TakeImpl(Exit.die(defect))
 
 /** @internal */
-export const dieMessage = (message: string): Take.Take<never, never> =>
+export const dieMessage = (message: string): Take.Take<never> =>
   new TakeImpl(Exit.die(new Cause.RuntimeException(message)))
 
 /** @internal */
-export const done = <E, A>(self: Take.Take<E, A>): Effect.Effect<Chunk.Chunk<A>, Option.Option<E>> =>
+export const done = <A, E>(self: Take.Take<A, E>): Effect.Effect<Chunk.Chunk<A>, Option.Option<E>> =>
   Effect.suspend(() => self.exit)
 
 /** @internal */
-export const end: Take.Take<never, never> = new TakeImpl(Exit.fail(Option.none()))
+export const end: Take.Take<never> = new TakeImpl(Exit.fail(Option.none()))
 
 /** @internal */
-export const fail = <E>(error: E): Take.Take<E, never> => new TakeImpl(Exit.fail(Option.some(error)))
+export const fail = <E>(error: E): Take.Take<never, E> => new TakeImpl(Exit.fail(Option.some(error)))
 
 /** @internal */
-export const failCause = <E>(cause: Cause.Cause<E>): Take.Take<E, never> =>
+export const failCause = <E>(cause: Cause.Cause<E>): Take.Take<never, E> =>
   new TakeImpl(Exit.failCause(pipe(cause, Cause.map(Option.some))))
 
 /** @internal */
-export const fromEffect = <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<Take.Take<E, A>, never, R> =>
+export const fromEffect = <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<Take.Take<A, E>, never, R> =>
   Effect.matchCause(effect, { onFailure: failCause, onSuccess: of })
 
 /** @internal */
-export const fromExit = <A, E>(exit: Exit.Exit<A, E>): Take.Take<E, A> =>
+export const fromExit = <A, E>(exit: Exit.Exit<A, E>): Take.Take<A, E> =>
   new TakeImpl(pipe(exit, Exit.mapBoth({ onFailure: Option.some, onSuccess: Chunk.of })))
 
 /** @internal */
 export const fromPull = <A, E, R>(
   pull: Effect.Effect<Chunk.Chunk<A>, Option.Option<E>, R>
-): Effect.Effect<Take.Take<E, A>, never, R> =>
+): Effect.Effect<Take.Take<A, E>, never, R> =>
   Effect.matchCause(pull, {
     onFailure: (cause) =>
       Option.match(Cause.flipCauseOption(cause), {
@@ -78,21 +78,21 @@ export const fromPull = <A, E, R>(
   })
 
 /** @internal */
-export const isDone = <E, A>(self: Take.Take<E, A>): boolean =>
+export const isDone = <A, E>(self: Take.Take<A, E>): boolean =>
   Exit.match(self.exit, {
     onFailure: (cause) => Option.isNone(Cause.flipCauseOption(cause)),
     onSuccess: constFalse
   })
 
 /** @internal */
-export const isFailure = <E, A>(self: Take.Take<E, A>): boolean =>
+export const isFailure = <A, E>(self: Take.Take<A, E>): boolean =>
   Exit.match(self.exit, {
     onFailure: (cause) => Option.isSome(Cause.flipCauseOption(cause)),
     onSuccess: constFalse
   })
 
 /** @internal */
-export const isSuccess = <E, A>(self: Take.Take<E, A>): boolean =>
+export const isSuccess = <A, E>(self: Take.Take<A, E>): boolean =>
   Exit.match(self.exit, {
     onFailure: constFalse,
     onSuccess: constTrue
@@ -101,7 +101,7 @@ export const isSuccess = <E, A>(self: Take.Take<E, A>): boolean =>
 /** @internal */
 export const make = <A, E>(
   exit: Exit.Exit<Chunk.Chunk<A>, Option.Option<E>>
-): Take.Take<E, A> => new TakeImpl(exit)
+): Take.Take<A, E> => new TakeImpl(exit)
 
 /** @internal */
 export const match = dual<
@@ -111,17 +111,17 @@ export const match = dual<
       readonly onFailure: (cause: Cause.Cause<E>) => Z2
       readonly onSuccess: (chunk: Chunk.Chunk<A>) => Z3
     }
-  ) => (self: Take.Take<E, A>) => Z | Z2 | Z3,
-  <Z, E, Z2, A, Z3>(
-    self: Take.Take<E, A>,
+  ) => (self: Take.Take<A, E>) => Z | Z2 | Z3,
+  <A, E, Z, Z2, Z3>(
+    self: Take.Take<A, E>,
     options: {
       readonly onEnd: () => Z
       readonly onFailure: (cause: Cause.Cause<E>) => Z2
       readonly onSuccess: (chunk: Chunk.Chunk<A>) => Z3
     }
   ) => Z | Z2 | Z3
->(2, <Z, E, Z2, A, Z3>(
-  self: Take.Take<E, A>,
+>(2, <A, E, Z, Z2, Z3>(
+  self: Take.Take<A, E>,
   { onEnd, onFailure, onSuccess }: {
     readonly onEnd: () => Z
     readonly onFailure: (cause: Cause.Cause<E>) => Z2
@@ -139,23 +139,23 @@ export const match = dual<
 
 /** @internal */
 export const matchEffect = dual<
-  <R, E2, Z, R2, E, Z2, A, R3, E3, Z3>(
+  <Z, E2, R, E, Z2, R2, A, Z3, E3, R3>(
     options: {
       readonly onEnd: Effect.Effect<Z, E2, R>
       readonly onFailure: (cause: Cause.Cause<E>) => Effect.Effect<Z2, E2, R2>
       readonly onSuccess: (chunk: Chunk.Chunk<A>) => Effect.Effect<Z3, E3, R3>
     }
-  ) => (self: Take.Take<E, A>) => Effect.Effect<Z | Z2 | Z3, E2 | E | E3, R | R2 | R3>,
-  <R, E2, Z, R2, E, Z2, A, R3, E3, Z3>(
-    self: Take.Take<E, A>,
+  ) => (self: Take.Take<A, E>) => Effect.Effect<Z | Z2 | Z3, E2 | E | E3, R | R2 | R3>,
+  <A, E, Z, E2, R, Z2, R2, Z3, E3, R3>(
+    self: Take.Take<A, E>,
     options: {
       readonly onEnd: Effect.Effect<Z, E2, R>
       readonly onFailure: (cause: Cause.Cause<E>) => Effect.Effect<Z2, E2, R2>
       readonly onSuccess: (chunk: Chunk.Chunk<A>) => Effect.Effect<Z3, E3, R3>
     }
   ) => Effect.Effect<Z | Z2 | Z3, E2 | E | E3, R | R2 | R3>
->(2, <R, E2, Z, R2, E, Z2, A, R3, E3, Z3>(
-  self: Take.Take<E, A>,
+>(2, <A, E, Z, E2, R, Z2, R2, Z3, E3, R3>(
+  self: Take.Take<A, E>,
   { onEnd, onFailure, onSuccess }: {
     readonly onEnd: Effect.Effect<Z, E2, R>
     readonly onFailure: (cause: Cause.Cause<E>) => Effect.Effect<Z2, E2, R2>
@@ -173,27 +173,27 @@ export const matchEffect = dual<
 
 /** @internal */
 export const map = dual<
-  <A, B>(f: (a: A) => B) => <E>(self: Take.Take<E, A>) => Take.Take<E, B>,
-  <E, A, B>(self: Take.Take<E, A>, f: (a: A) => B) => Take.Take<E, B>
+  <A, B>(f: (a: A) => B) => <E>(self: Take.Take<A, E>) => Take.Take<B, E>,
+  <A, E, B>(self: Take.Take<A, E>, f: (a: A) => B) => Take.Take<B, E>
 >(
   2,
-  <E, A, B>(self: Take.Take<E, A>, f: (a: A) => B): Take.Take<E, B> =>
+  <A, E, B>(self: Take.Take<A, E>, f: (a: A) => B): Take.Take<B, E> =>
     new TakeImpl(pipe(self.exit, Exit.map(Chunk.map(f))))
 )
 
 /** @internal */
-export const of = <A>(value: A): Take.Take<never, A> => new TakeImpl(Exit.succeed(Chunk.of(value)))
+export const of = <A>(value: A): Take.Take<A> => new TakeImpl(Exit.succeed(Chunk.of(value)))
 
 /** @internal */
 export const tap = dual<
-  <A, R, E2, _>(
+  <A, _, E2, R>(
     f: (chunk: Chunk.Chunk<A>) => Effect.Effect<_, E2, R>
-  ) => <E>(self: Take.Take<E, A>) => Effect.Effect<void, E2 | E, R>,
-  <E, A, R, E2, _>(
-    self: Take.Take<E, A>,
+  ) => <E>(self: Take.Take<A, E>) => Effect.Effect<void, E2 | E, R>,
+  <A, E, _, E2, R>(
+    self: Take.Take<A, E>,
     f: (chunk: Chunk.Chunk<A>) => Effect.Effect<_, E2, R>
   ) => Effect.Effect<void, E2 | E, R>
->(2, <E, A, R, E2, _>(
-  self: Take.Take<E, A>,
+>(2, <A, E, _, E2, R>(
+  self: Take.Take<A, E>,
   f: (chunk: Chunk.Chunk<A>) => Effect.Effect<_, E2, R>
 ): Effect.Effect<void, E2 | E, R> => pipe(self.exit, Exit.forEachEffect(f), Effect.asUnit))
diff --git a/packages/effect/test/Stream/aggregation.test.ts b/packages/effect/test/Stream/aggregation.test.ts
index b3a7c07735..2e2225c241 100644
--- a/packages/effect/test/Stream/aggregation.test.ts
+++ b/packages/effect/test/Stream/aggregation.test.ts
@@ -141,7 +141,7 @@ describe("Stream", () => {
   // Explicitly uses live Clock
   it.effect("issue from zio-kafka", () =>
     Effect.gen(function*($) {
-      const queue = yield* $(Queue.unbounded<Take.Take<never, number>>())
+      const queue = yield* $(Queue.unbounded<Take.Take<number>>())
       const fiber = yield* $(
         Stream.fromQueue(queue),
         Stream.flattenTake,
diff --git a/packages/effect/test/Stream/sequencing.test.ts b/packages/effect/test/Stream/sequencing.test.ts
index 6bb36a76b7..76bc8f6018 100644
--- a/packages/effect/test/Stream/sequencing.test.ts
+++ b/packages/effect/test/Stream/sequencing.test.ts
@@ -786,7 +786,7 @@ describe("Stream", () => {
   it.effect("flattenTake - works with empty streams", () =>
     Effect.gen(function*($) {
       const result = yield* $(
-        Stream.fromIterable<Take.Take<never, never>>([]),
+        Stream.fromIterable<Take.Take<never>>([]),
         Stream.flattenTake,
         Stream.runCollect
       )
diff --git a/packages/effect/test/Stream/zipping.test.ts b/packages/effect/test/Stream/zipping.test.ts
index 92133211f4..699ce57c8a 100644
--- a/packages/effect/test/Stream/zipping.test.ts
+++ b/packages/effect/test/Stream/zipping.test.ts
@@ -205,7 +205,7 @@ describe("Stream", () => {
     Effect.gen(function*($) {
       const left = yield* $(Queue.unbounded<Chunk.Chunk<number>>())
       const right = yield* $(Queue.unbounded<Chunk.Chunk<number>>())
-      const output = yield* $(Queue.bounded<Take.Take<never, readonly [number, number]>>(1))
+      const output = yield* $(Queue.bounded<Take.Take<readonly [number, number]>>(1))
       yield* $(
         Stream.fromChunkQueue(left),
         Stream.zipLatest(Stream.fromChunkQueue(right)),