effect 2.2.5 → 2.3.1

package/src/internal/sink.ts

@@ -30,22 +30,24 @@ export const SinkTypeId: Sink.SinkTypeId = Symbol.for("effect/Sink") as Sink.Sin
 
 const sinkVariance = {
   /* c8 ignore next */
-  _R: (_: never) => _,
-  /* c8 ignore next */
-  _E: (_: never) => _,
+  _A: (_: never) => _,
   /* c8 ignore next */
   _In: (_: unknown) => _,
   /* c8 ignore next */
   _L: (_: never) => _,
   /* c8 ignore next */
-  _Z: (_: never) => _
+  _E: (_: never) => _,
+  /* c8 ignore next */
+  _R: (_: never) => _
 }
 
 /** @internal */
-export class SinkImpl<out R, out E, in In, out L, out Z> implements Sink.Sink<R, E, In, L, Z> {
+export class SinkImpl<out A, in In = unknown, out L = never, out E = never, out R = never>
+  implements Sink.Sink<A, In, L, E, R>
+{
   readonly [SinkTypeId] = sinkVariance
   constructor(
-    readonly channel: Channel.Channel<R, never, Chunk.Chunk<In>, unknown, E, Chunk.Chunk<L>, Z>
+    readonly channel: Channel.Channel<Chunk.Chunk<L>, Chunk.Chunk<In>, E, never, A, unknown, R>
   ) {
   }
   pipe() {
@@ -58,26 +60,25 @@ export const isSink = (u: unknown): u is Sink.Sink<unknown, unknown, unknown, un
   hasProperty(u, SinkTypeId)
 
 /** @internal */
-export const suspend = <R, E, In, L, Z>(evaluate: LazyArg<Sink.Sink<R, E, In, L, Z>>): Sink.Sink<R, E, In, L, Z> =>
+export const suspend = <A, In, L, E, R>(evaluate: LazyArg<Sink.Sink<A, In, L, E, R>>): Sink.Sink<A, In, L, E, R> =>
   new SinkImpl(core.suspend(() => toChannel(evaluate())))
 
 /** @internal */
 export const as = dual<
-  <Z2>(z: Z2) => <R, E, In, L, Z>(self: Sink.Sink<R, E, In, L, Z>) => Sink.Sink<R, E, In, L, Z2>,
-  <R, E, In, L, Z, Z2>(self: Sink.Sink<R, E, In, L, Z>, z: Z2) => Sink.Sink<R, E, In, L, Z2>
+  <A2>(a: A2) => <A, In, L, E, R>(self: Sink.Sink<A, In, L, E, R>) => Sink.Sink<A2, In, L, E, R>,
+  <A, In, L, E, R, A2>(self: Sink.Sink<A, In, L, E, R>, a: A2) => Sink.Sink<A2, In, L, E, R>
 >(
   2,
-  <R, E, In, L, Z, Z2>(self: Sink.Sink<R, E, In, L, Z>, z: Z2): Sink.Sink<R, E, In, L, Z2> => pipe(self, map(() => z))
+  (self, a) => pipe(self, map(() => a))
 )
 
 /** @internal */
-export const collectAll = <In>(): Sink.Sink<never, never, In, never, Chunk.Chunk<In>> =>
-  new SinkImpl(collectAllLoop(Chunk.empty()))
+export const collectAll = <In>(): Sink.Sink<Chunk.Chunk<In>, In> => new SinkImpl(collectAllLoop(Chunk.empty()))
 
 /** @internal */
 const collectAllLoop = <In>(
   acc: Chunk.Chunk<In>
-): Channel.Channel<never, never, Chunk.Chunk<In>, unknown, never, never, Chunk.Chunk<In>> =>
+): Channel.Channel<never, Chunk.Chunk<In>, never, never, Chunk.Chunk<In>, unknown> =>
   core.readWithCause({
     onInput: (chunk: Chunk.Chunk<In>) => collectAllLoop(pipe(acc, Chunk.appendAll(chunk))),
     onFailure: core.failCause,
@@ -85,14 +86,14 @@ const collectAllLoop = <In>(
   })
 
 /** @internal */
-export const collectAllN = <In>(n: number): Sink.Sink<never, never, In, In, Chunk.Chunk<In>> =>
+export const collectAllN = <In>(n: number): Sink.Sink<Chunk.Chunk<In>, In, In> =>
   suspend(() => fromChannel(collectAllNLoop(n, Chunk.empty())))
 
 /** @internal */
 const collectAllNLoop = <In>(
   n: number,
   acc: Chunk.Chunk<In>
-): Channel.Channel<never, never, Chunk.Chunk<In>, unknown, never, Chunk.Chunk<In>, Chunk.Chunk<In>> =>
+): Channel.Channel<Chunk.Chunk<In>, Chunk.Chunk<In>, never, never, Chunk.Chunk<In>, unknown> =>
   core.readWithCause({
     onInput: (chunk: Chunk.Chunk<In>) => {
       const [collected, leftovers] = Chunk.splitAt(chunk, n)
@@ -109,20 +110,20 @@ const collectAllNLoop = <In>(
   })
 
 /** @internal */
-export const collectAllFrom = <R, E, In, L extends In, Z>(
-  self: Sink.Sink<R, E, In, L, Z>
-): Sink.Sink<R, E, In, L, Chunk.Chunk<Z>> =>
+export const collectAllFrom = <A, In, L extends In, E, R>(
+  self: Sink.Sink<A, In, L, E, R>
+): Sink.Sink<Chunk.Chunk<A>, In, L, E, R> =>
   collectAllWhileWith(self, {
-    initial: Chunk.empty<Z>(),
+    initial: Chunk.empty<A>(),
     while: constTrue,
-    body: (chunk, z) => pipe(chunk, Chunk.append(z))
+    body: (chunk, a) => pipe(chunk, Chunk.append(a))
   })
 
 /** @internal */
 export const collectAllToMap = <In, K>(
   key: (input: In) => K,
   merge: (x: In, y: In) => In
-): Sink.Sink<never, never, In, never, HashMap.HashMap<K, In>> => {
+): Sink.Sink<HashMap.HashMap<K, In>, In> => {
   return pipe(
     foldLeftChunks(HashMap.empty<K, In>(), (map, chunk) =>
       pipe(
@@ -143,7 +144,7 @@ export const collectAllToMapN = <In, K>(
   n: number,
   key: (input: In) => K,
   merge: (x: In, y: In) => In
-): Sink.Sink<never, never, In, In, HashMap.HashMap<K, In>> => {
+): Sink.Sink<HashMap.HashMap<K, In>, In, In> => {
   return foldWeighted<HashMap.HashMap<K, In>, In>({
     initial: HashMap.empty(),
     maxCost: n,
@@ -159,14 +160,14 @@ export const collectAllToMapN = <In, K>(
 }
 
 /** @internal */
-export const collectAllToSet = <In>(): Sink.Sink<never, never, In, never, HashSet.HashSet<In>> =>
+export const collectAllToSet = <In>(): Sink.Sink<HashSet.HashSet<In>, In> =>
   foldLeftChunks<HashSet.HashSet<In>, In>(
     HashSet.empty(),
     (acc, chunk) => pipe(chunk, Chunk.reduce(acc, (acc, input) => pipe(acc, HashSet.add(input))))
   )
 
 /** @internal */
-export const collectAllToSetN = <In>(n: number): Sink.Sink<never, never, In, In, HashSet.HashSet<In>> =>
+export const collectAllToSetN = <In>(n: number): Sink.Sink<HashSet.HashSet<In>, In, In> =>
   foldWeighted<HashSet.HashSet<In>, In>({
     initial: HashSet.empty(),
     maxCost: n,
@@ -175,7 +176,7 @@ export const collectAllToSetN = <In>(n: number): Sink.Sink<never, never, In, In,
   })
 
 /** @internal */
-export const collectAllUntil = <In>(p: Predicate<In>): Sink.Sink<never, never, In, In, Chunk.Chunk<In>> => {
+export const collectAllUntil = <In>(p: Predicate<In>): Sink.Sink<Chunk.Chunk<In>, In, In> => {
   return pipe(
     fold<[Chunk.Chunk<In>, boolean], In>(
       [Chunk.empty(), true],
@@ -187,9 +188,9 @@ export const collectAllUntil = <In>(p: Predicate<In>): Sink.Sink<never, never, I
 }
 
 /** @internal */
-export const collectAllUntilEffect = <In, R, E>(p: (input: In) => Effect.Effect<R, E, boolean>) => {
+export const collectAllUntilEffect = <In, E, R>(p: (input: In) => Effect.Effect<boolean, E, R>) => {
   return pipe(
-    foldEffect<[Chunk.Chunk<In>, boolean], R, E, In>(
+    foldEffect<[Chunk.Chunk<In>, boolean], In, E, R>(
       [Chunk.empty(), true],
       (tuple) => tuple[1],
       ([chunk, _], input) => pipe(p(input), Effect.map((bool) => [pipe(chunk, Chunk.append(input)), !bool]))
@@ -200,16 +201,16 @@ export const collectAllUntilEffect = <In, R, E>(p: (input: In) => Effect.Effect<
 
 /** @internal */
 export const collectAllWhile: {
-  <In, Out extends In>(refinement: Refinement<In, Out>): Sink.Sink<never, never, In, In, Chunk.Chunk<Out>>
-  <In>(predicate: Predicate<In>): Sink.Sink<never, never, In, In, Chunk.Chunk<In>>
-} = <In>(predicate: Predicate<In>): Sink.Sink<never, never, In, In, Chunk.Chunk<In>> =>
+  <In, Out extends In>(refinement: Refinement<In, Out>): Sink.Sink<Chunk.Chunk<Out>, In, In>
+  <In>(predicate: Predicate<In>): Sink.Sink<Chunk.Chunk<In>, In, In>
+} = <In>(predicate: Predicate<In>): Sink.Sink<Chunk.Chunk<In>, In, In> =>
   fromChannel(collectAllWhileReader(predicate, Chunk.empty()))
 
 /** @internal */
 const collectAllWhileReader = <In>(
   predicate: Predicate<In>,
   done: Chunk.Chunk<In>
-): Channel.Channel<never, never, Chunk.Chunk<In>, unknown, never, Chunk.Chunk<In>, Chunk.Chunk<In>> =>
+): Channel.Channel<Chunk.Chunk<In>, Chunk.Chunk<In>, never, never, Chunk.Chunk<In>, unknown> =>
   core.readWith({
     onInput: (input: Chunk.Chunk<In>) => {
       const [collected, leftovers] = pipe(Chunk.toReadonlyArray(input), ReadonlyArray.span(predicate))
@@ -229,15 +230,15 @@ const collectAllWhileReader = <In>(
   })
 
 /** @internal */
-export const collectAllWhileEffect = <In, R, E>(
-  predicate: (input: In) => Effect.Effect<R, E, boolean>
-): Sink.Sink<R, E, In, In, Chunk.Chunk<In>> => fromChannel(collectAllWhileEffectReader(predicate, Chunk.empty()))
+export const collectAllWhileEffect = <In, E, R>(
+  predicate: (input: In) => Effect.Effect<boolean, E, R>
+): Sink.Sink<Chunk.Chunk<In>, In, In, E, R> => fromChannel(collectAllWhileEffectReader(predicate, Chunk.empty()))
 
 /** @internal */
 const collectAllWhileEffectReader = <In, R, E>(
-  predicate: (input: In) => Effect.Effect<R, E, boolean>,
+  predicate: (input: In) => Effect.Effect<boolean, E, R>,
   done: Chunk.Chunk<In>
-): Channel.Channel<R, never, Chunk.Chunk<In>, unknown, E, Chunk.Chunk<In>, Chunk.Chunk<In>> =>
+): Channel.Channel<Chunk.Chunk<In>, Chunk.Chunk<In>, E, never, Chunk.Chunk<In>, unknown, R> =>
   core.readWith({
     onInput: (input: Chunk.Chunk<In>) =>
       pipe(
@@ -255,32 +256,32 @@ const collectAllWhileEffectReader = <In, R, E>(
   })
 
 /** @internal */
-export const collectAllWhileWith = dual<
-  <Z, S>(
+export const collectAllWhileWith: {
+  <A, S>(
     options: {
       readonly initial: S
-      readonly while: Predicate<Z>
-      readonly body: (s: S, z: Z) => S
+      readonly while: Predicate<A>
+      readonly body: (s: S, a: A) => S
     }
-  ) => <R, E, In, L extends In>(self: Sink.Sink<R, E, In, L, Z>) => Sink.Sink<R, E, In, L, S>,
-  <R, E, In, L extends In, Z, S>(
-    self: Sink.Sink<R, E, In, L, Z>,
+  ): <In, L extends In, E, R>(self: Sink.Sink<A, In, L, E, R>) => Sink.Sink<S, In, L, E, R>
+  <A, In, L extends In, E, R, S>(
+    self: Sink.Sink<A, In, L, E, R>,
     options: {
       readonly initial: S
-      readonly while: Predicate<Z>
-      readonly body: (s: S, z: Z) => S
+      readonly while: Predicate<A>
+      readonly body: (s: S, a: A) => S
     }
-  ) => Sink.Sink<R, E, In, L, S>
->(
+  ): Sink.Sink<S, In, L, E, R>
+} = dual(
   2,
-  <R, E, In, L extends In, Z, S>(
-    self: Sink.Sink<R, E, In, L, Z>,
+  <A, In, L extends In, E, R, S>(
+    self: Sink.Sink<A, In, L, E, R>,
     options: {
       readonly initial: S
-      readonly while: Predicate<Z>
-      readonly body: (s: S, z: Z) => S
+      readonly while: Predicate<A>
+      readonly body: (s: S, a: A) => S
     }
-  ): Sink.Sink<R, E, In, L, S> => {
+  ): Sink.Sink<S, In, L, E, R> => {
     const refs = pipe(
       Ref.make(Chunk.empty<In>()),
       Effect.zip(Ref.make(false))
@@ -288,8 +289,8 @@ export const collectAllWhileWith = dual<
     const newChannel = pipe(
       core.fromEffect(refs),
       core.flatMap(([leftoversRef, upstreamDoneRef]) => {
-        const upstreamMarker: Channel.Channel<never, never, Chunk.Chunk<In>, unknown, never, Chunk.Chunk<In>, unknown> =
-          core.readWith({
+        const upstreamMarker: Channel.Channel<Chunk.Chunk<In>, Chunk.Chunk<In>, never, never, unknown, unknown> = core
+          .readWith({
             onInput: (input) => pipe(core.write(input), core.flatMap(() => upstreamMarker)),
             onFailure: core.fail,
             onDone: (done) => pipe(core.fromEffect(Ref.set(upstreamDoneRef, true)), channel.as(done))
@@ -309,13 +310,13 @@ export const collectAllWhileWith = dual<
 
 /** @internal */
 const collectAllWhileWithLoop = <R, E, In, L extends In, Z, S>(
-  self: Sink.Sink<R, E, In, L, Z>,
+  self: Sink.Sink<Z, In, L, E, R>,
   leftoversRef: Ref.Ref<Chunk.Chunk<In>>,
   upstreamDoneRef: Ref.Ref<boolean>,
   currentResult: S,
   p: Predicate<Z>,
   f: (s: S, z: Z) => S
-): Channel.Channel<R, never, Chunk.Chunk<In>, unknown, E, Chunk.Chunk<L>, S> => {
+): Channel.Channel<Chunk.Chunk<L>, Chunk.Chunk<In>, E, never, S, unknown, R> => {
   return pipe(
     toChannel(self),
     channel.doneCollect,
@@ -345,36 +346,36 @@ const collectAllWhileWithLoop = <R, E, In, L extends In, Z, S>(
 }
 
 /** @internal */
-export const collectLeftover = <R, E, In, L, Z>(
-  self: Sink.Sink<R, E, In, L, Z>
-): Sink.Sink<R, E, In, never, [Z, Chunk.Chunk<L>]> =>
+export const collectLeftover = <A, In, L, E, R>(
+  self: Sink.Sink<A, In, L, E, R>
+): Sink.Sink<[A, Chunk.Chunk<L>], In, never, E, R> =>
   new SinkImpl(pipe(core.collectElements(toChannel(self)), channel.map(([chunks, z]) => [z, Chunk.flatten(chunks)])))
 
 /** @internal */
 export const mapInput = dual<
-  <In0, In>(f: (input: In0) => In) => <R, E, L, Z>(self: Sink.Sink<R, E, In, L, Z>) => Sink.Sink<R, E, In0, L, Z>,
-  <R, E, L, Z, In0, In>(self: Sink.Sink<R, E, In, L, Z>, f: (input: In0) => In) => Sink.Sink<R, E, In0, L, Z>
+  <In0, In>(f: (input: In0) => In) => <A, L, E, R>(self: Sink.Sink<A, In, L, E, R>) => Sink.Sink<A, In0, L, E, R>,
+  <A, In, L, E, R, In0>(self: Sink.Sink<A, In, L, E, R>, f: (input: In0) => In) => Sink.Sink<A, In0, L, E, R>
 >(
   2,
-  <R, E, L, Z, In0, In>(self: Sink.Sink<R, E, In, L, Z>, f: (input: In0) => In): Sink.Sink<R, E, In0, L, Z> =>
+  <A, In, L, E, R, In0>(self: Sink.Sink<A, In, L, E, R>, f: (input: In0) => In): Sink.Sink<A, In0, L, E, R> =>
     pipe(self, mapInputChunks(Chunk.map(f)))
 )
 
 /** @internal */
 export const mapInputEffect = dual<
-  <In0, R2, E2, In>(
-    f: (input: In0) => Effect.Effect<R2, E2, In>
-  ) => <R, E, L, Z>(self: Sink.Sink<R, E, In, L, Z>) => Sink.Sink<R2 | R, E2 | E, In0, L, Z>,
-  <R, E, L, Z, In0, R2, E2, In>(
-    self: Sink.Sink<R, E, In, L, Z>,
-    f: (input: In0) => Effect.Effect<R2, E2, In>
-  ) => Sink.Sink<R2 | R, E2 | E, In0, L, Z>
+  <In0, In, E2, R2>(
+    f: (input: In0) => Effect.Effect<In, E2, R2>
+  ) => <A, L, E, R>(self: Sink.Sink<A, In, L, E, R>) => Sink.Sink<A, In0, L, E2 | E, R2 | R>,
+  <A, In, L, E, R, In0, E2, R2>(
+    self: Sink.Sink<A, In, L, E, R>,
+    f: (input: In0) => Effect.Effect<In, E2, R2>
+  ) => Sink.Sink<A, In0, L, E2 | E, R2 | R>
 >(
   2,
-  <R, E, L, Z, In0, R2, E2, In>(
-    self: Sink.Sink<R, E, In, L, Z>,
-    f: (input: In0) => Effect.Effect<R2, E2, In>
-  ): Sink.Sink<R | R2, E | E2, In0, L, Z> =>
+  <A, In, L, E, R, In0, E2, R2>(
+    self: Sink.Sink<A, In, L, E, R>,
+    f: (input: In0) => Effect.Effect<In, E2, R2>
+  ): Sink.Sink<A, In0, L, E | E2, R | R2> =>
     mapInputChunksEffect(
       self,
       (chunk) =>
@@ -389,18 +390,18 @@ export const mapInputEffect = dual<
 export const mapInputChunks = dual<
   <In0, In>(
     f: (chunk: Chunk.Chunk<In0>) => Chunk.Chunk<In>
-  ) => <R, E, L, Z>(self: Sink.Sink<R, E, In, L, Z>) => Sink.Sink<R, E, In0, L, Z>,
-  <R, E, L, Z, In0, In>(
-    self: Sink.Sink<R, E, In, L, Z>,
+  ) => <A, L, E, R>(self: Sink.Sink<A, In, L, E, R>) => Sink.Sink<A, In0, L, E, R>,
+  <A, In, L, E, R, In0>(
+    self: Sink.Sink<A, In, L, E, R>,
     f: (chunk: Chunk.Chunk<In0>) => Chunk.Chunk<In>
-  ) => Sink.Sink<R, E, In0, L, Z>
+  ) => Sink.Sink<A, In0, L, E, R>
 >(
   2,
-  <R, E, L, Z, In0, In>(
-    self: Sink.Sink<R, E, In, L, Z>,
+  <A, In, L, E, R, In0>(
+    self: Sink.Sink<A, In, L, E, R>,
     f: (chunk: Chunk.Chunk<In0>) => Chunk.Chunk<In>
-  ): Sink.Sink<R, E, In0, L, Z> => {
-    const loop: Channel.Channel<R, never, Chunk.Chunk<In0>, unknown, never, Chunk.Chunk<In>, unknown> = core.readWith({
+  ): Sink.Sink<A, In0, L, E, R> => {
+    const loop: Channel.Channel<Chunk.Chunk<In>, Chunk.Chunk<In0>, never, never, unknown, unknown, R> = core.readWith({
       onInput: (chunk) => pipe(core.write(f(chunk)), core.flatMap(() => loop)),
       onFailure: core.fail,
       onDone: core.succeed
@@ -411,20 +412,20 @@ export const mapInputChunks = dual<
 
 /** @internal */
 export const mapInputChunksEffect = dual<
-  <In0, R2, E2, In>(
-    f: (chunk: Chunk.Chunk<In0>) => Effect.Effect<R2, E2, Chunk.Chunk<In>>
-  ) => <R, E, L, Z>(self: Sink.Sink<R, E, In, L, Z>) => Sink.Sink<R2 | R, E2 | E, In0, L, Z>,
-  <R, E, L, Z, In0, R2, E2, In>(
-    self: Sink.Sink<R, E, In, L, Z>,
-    f: (chunk: Chunk.Chunk<In0>) => Effect.Effect<R2, E2, Chunk.Chunk<In>>
-  ) => Sink.Sink<R2 | R, E2 | E, In0, L, Z>
+  <In0, In, E2, R2>(
+    f: (chunk: Chunk.Chunk<In0>) => Effect.Effect<Chunk.Chunk<In>, E2, R2>
+  ) => <A, L, E, R>(self: Sink.Sink<A, In, L, E, R>) => Sink.Sink<A, In0, L, E2 | E, R2 | R>,
+  <A, In, L, E, R, In0, E2, R2>(
+    self: Sink.Sink<A, In, L, E, R>,
+    f: (chunk: Chunk.Chunk<In0>) => Effect.Effect<Chunk.Chunk<In>, E2, R2>
+  ) => Sink.Sink<A, In0, L, E2 | E, R2 | R>
 >(
   2,
-  <R, E, L, Z, In0, R2, E2, In>(
-    self: Sink.Sink<R, E, In, L, Z>,
-    f: (chunk: Chunk.Chunk<In0>) => Effect.Effect<R2, E2, Chunk.Chunk<In>>
-  ): Sink.Sink<R | R2, E | E2, In0, L, Z> => {
-    const loop: Channel.Channel<R | R2, never, Chunk.Chunk<In0>, unknown, E2, Chunk.Chunk<In>, unknown> = core
+  <A, In, L, E, R, In0, E2, R2>(
+    self: Sink.Sink<A, In, L, E, R>,
+    f: (chunk: Chunk.Chunk<In0>) => Effect.Effect<Chunk.Chunk<In>, E2, R2>
+  ): Sink.Sink<A, In0, L, E | E2, R | R2> => {
+    const loop: Channel.Channel<Chunk.Chunk<In>, Chunk.Chunk<In0>, E2, never, unknown, unknown, R | R2> = core
       .readWith({
         onInput: (chunk) => pipe(core.fromEffect(f(chunk)), core.flatMap(core.write), core.flatMap(() => loop)),
         onFailure: core.fail,
@@ -435,66 +436,60 @@ export const mapInputChunksEffect = dual<
 )
 
 /** @internal */
-export const die = (defect: unknown): Sink.Sink<never, never, unknown, never, never> => failCause(Cause.die(defect))
+export const die = (defect: unknown): Sink.Sink<never, unknown> => failCause(Cause.die(defect))
 
 /** @internal */
-export const dieMessage = (message: string): Sink.Sink<never, never, unknown, never, never> =>
+export const dieMessage = (message: string): Sink.Sink<never, unknown> =>
   failCause(Cause.die(new Cause.RuntimeException(message)))
 
 /** @internal */
-export const dieSync = (evaluate: LazyArg<unknown>): Sink.Sink<never, never, unknown, never, never> =>
+export const dieSync = (evaluate: LazyArg<unknown>): Sink.Sink<never, unknown> =>
   failCauseSync(() => Cause.die(evaluate()))
 
 /** @internal */
 export const dimap = dual<
-  <In0, In, Z, Z2>(
+  <In0, In, A, A2>(
     options: {
       readonly onInput: (input: In0) => In
-      readonly onDone: (z: Z) => Z2
+      readonly onDone: (a: A) => A2
     }
-  ) => <R, E, L>(self: Sink.Sink<R, E, In, L, Z>) => Sink.Sink<R, E, In0, L, Z2>,
-  <R, E, L, In0, In, Z, Z2>(
-    self: Sink.Sink<R, E, In, L, Z>,
+  ) => <L, E, R>(self: Sink.Sink<A, In, L, E, R>) => Sink.Sink<A2, In0, L, E, R>,
+  <A, In, L, E, R, In0, A2>(
+    self: Sink.Sink<A, In, L, E, R>,
     options: {
       readonly onInput: (input: In0) => In
-      readonly onDone: (z: Z) => Z2
+      readonly onDone: (a: A) => A2
     }
-  ) => Sink.Sink<R, E, In0, L, Z2>
+  ) => Sink.Sink<A2, In0, L, E, R>
 >(
   2,
-  <R, E, L, In0, In, Z, Z2>(
-    self: Sink.Sink<R, E, In, L, Z>,
+  <A, In, L, E, R, In0, A2>(
+    self: Sink.Sink<A, In, L, E, R>,
     options: {
       readonly onInput: (input: In0) => In
-      readonly onDone: (z: Z) => Z2
+      readonly onDone: (a: A) => A2
     }
-  ): Sink.Sink<R, E, In0, L, Z2> => map(mapInput(self, options.onInput), options.onDone)
+  ): Sink.Sink<A2, In0, L, E, R> => map(mapInput(self, options.onInput), options.onDone)
 )
 
 /** @internal */
 export const dimapEffect = dual<
-  <In0, R2, E2, In, Z, R3, E3, Z2>(
+  <In0, R2, E2, In, A, R3, E3, A2>(
     options: {
-      readonly onInput: (input: In0) => Effect.Effect<R2, E2, In>
-      readonly onDone: (z: Z) => Effect.Effect<R3, E3, Z2>
+      readonly onInput: (input: In0) => Effect.Effect<In, E2, R2>
+      readonly onDone: (a: A) => Effect.Effect<A2, E3, R3>
     }
-  ) => <R, E, L>(self: Sink.Sink<R, E, In, L, Z>) => Sink.Sink<R2 | R3 | R, E2 | E3 | E, In0, L, Z2>,
-  <R, E, L, In0, R2, E2, In, Z, R3, E3, Z2>(
-    self: Sink.Sink<R, E, In, L, Z>,
+  ) => <R, E, L>(self: Sink.Sink<A, In, L, E, R>) => Sink.Sink<A2, In0, L, E2 | E3 | E, R2 | R3 | R>,
+  <A, In, L, E, R, In0, E2, R2, A2, E3, R3>(
+    self: Sink.Sink<A, In, L, E, R>,
     options: {
-      readonly onInput: (input: In0) => Effect.Effect<R2, E2, In>
-      readonly onDone: (z: Z) => Effect.Effect<R3, E3, Z2>
+      readonly onInput: (input: In0) => Effect.Effect<In, E2, R2>
+      readonly onDone: (a: A) => Effect.Effect<A2, E3, R3>
     }
-  ) => Sink.Sink<R2 | R3 | R, E2 | E3 | E, In0, L, Z2>
+  ) => Sink.Sink<A2, In0, L, E2 | E3 | E, R2 | R3 | R>
 >(
   2,
-  <R, E, L, In0, R2, E2, In, Z, R3, E3, Z2>(
-    self: Sink.Sink<R, E, In, L, Z>,
-    options: {
-      readonly onInput: (input: In0) => Effect.Effect<R2, E2, In>
-      readonly onDone: (z: Z) => Effect.Effect<R3, E3, Z2>
-    }
-  ): Sink.Sink<R | R2 | R3, E | E2 | E3, In0, L, Z2> =>
+  (self, options) =>
     mapEffect(
       mapInputEffect(self, options.onInput),
       options.onDone
@@ -503,28 +498,22 @@ export const dimapEffect = dual<
 
 /** @internal */
 export const dimapChunks = dual<
-  <In0, In, Z, Z2>(
+  <In0, In, A, A2>(
     options: {
       readonly onInput: (chunk: Chunk.Chunk<In0>) => Chunk.Chunk<In>
-      readonly onDone: (z: Z) => Z2
+      readonly onDone: (a: A) => A2
     }
-  ) => <R, E, L>(self: Sink.Sink<R, E, In, L, Z>) => Sink.Sink<R, E, In0, L, Z2>,
-  <R, E, L, In0, In, Z, Z2>(
-    self: Sink.Sink<R, E, In, L, Z>,
+  ) => <L, E, R>(self: Sink.Sink<A, In, L, E, R>) => Sink.Sink<A2, In0, L, E, R>,
+  <A, In, L, E, R, In0, A2>(
+    self: Sink.Sink<A, In, L, E, R>,
     options: {
       readonly onInput: (chunk: Chunk.Chunk<In0>) => Chunk.Chunk<In>
-      readonly onDone: (z: Z) => Z2
+      readonly onDone: (a: A) => A2
     }
-  ) => Sink.Sink<R, E, In0, L, Z2>
+  ) => Sink.Sink<A2, In0, L, E, R>
 >(
   2,
-  <R, E, L, In0, In, Z, Z2>(
-    self: Sink.Sink<R, E, In, L, Z>,
-    options: {
-      readonly onInput: (chunk: Chunk.Chunk<In0>) => Chunk.Chunk<In>
-      readonly onDone: (z: Z) => Z2
-    }
-  ): Sink.Sink<R, E, In0, L, Z2> =>
+  (self, options) =>
     map(
       mapInputChunks(self, options.onInput),
       options.onDone
@@ -533,44 +522,36 @@ export const dimapChunks = dual<
 
 /** @internal */
 export const dimapChunksEffect = dual<
-  <In0, R2, E2, In, Z, R3, E3, Z2>(
+  <In0, In, E2, R2, A, A2, E3, R3>(
     options: {
-      readonly onInput: (chunk: Chunk.Chunk<In0>) => Effect.Effect<R2, E2, Chunk.Chunk<In>>
-      readonly onDone: (z: Z) => Effect.Effect<R3, E3, Z2>
+      readonly onInput: (chunk: Chunk.Chunk<In0>) => Effect.Effect<Chunk.Chunk<In>, E2, R2>
+      readonly onDone: (a: A) => Effect.Effect<A2, E3, R3>
     }
-  ) => <R, E, L>(self: Sink.Sink<R, E, In, L, Z>) => Sink.Sink<R2 | R3 | R, E2 | E3 | E, In0, L, Z2>,
-  <R, E, L, In0, R2, E2, In, Z, R3, E3, Z2>(
-    self: Sink.Sink<R, E, In, L, Z>,
+  ) => <R, E, L>(self: Sink.Sink<A, In, L, E, R>) => Sink.Sink<A2, In0, L, E2 | E3 | E, R2 | R3 | R>,
+  <A, In, L, E, R, In0, E2, R2, A2, E3, R3>(
+    self: Sink.Sink<A, In, L, E, R>,
     options: {
-      readonly onInput: (chunk: Chunk.Chunk<In0>) => Effect.Effect<R2, E2, Chunk.Chunk<In>>
-      readonly onDone: (z: Z) => Effect.Effect<R3, E3, Z2>
+      readonly onInput: (chunk: Chunk.Chunk<In0>) => Effect.Effect<Chunk.Chunk<In>, E2, R2>
+      readonly onDone: (a: A) => Effect.Effect<A2, E3, R3>
     }
-  ) => Sink.Sink<R2 | R3 | R, E2 | E3 | E, In0, L, Z2>
+  ) => Sink.Sink<A2, In0, L, E2 | E3 | E, R2 | R3 | R>
 >(
   2,
-  <R, E, L, In0, R2, E2, In, Z, R3, E3, Z2>(
-    self: Sink.Sink<R, E, In, L, Z>,
-    options: {
-      readonly onInput: (chunk: Chunk.Chunk<In0>) => Effect.Effect<R2, E2, Chunk.Chunk<In>>
-      readonly onDone: (z: Z) => Effect.Effect<R3, E3, Z2>
-    }
-  ): Sink.Sink<R | R2 | R3, E | E2 | E3, In0, L, Z2> =>
-    mapEffect(mapInputChunksEffect(self, options.onInput), options.onDone)
+  (self, options) => mapEffect(mapInputChunksEffect(self, options.onInput), options.onDone)
 )
 
 /** @internal */
-export const drain: Sink.Sink<never, never, unknown, never, void> = new SinkImpl(
-  channel.drain(channel.identityChannel<never, unknown, unknown>())
+export const drain: Sink.Sink<void, unknown> = new SinkImpl(
+  channel.drain(channel.identityChannel())
 )
 
 /** @internal */
-export const drop = <In>(n: number): Sink.Sink<never, never, In, In, unknown> =>
-  suspend(() => new SinkImpl(dropLoop(n)))
+export const drop = <In>(n: number): Sink.Sink<unknown, In, In> => suspend(() => new SinkImpl(dropLoop(n)))
 
 /** @internal */
 const dropLoop = <In>(
   n: number
-): Channel.Channel<never, never, Chunk.Chunk<In>, unknown, never, Chunk.Chunk<In>, unknown> =>
+): Channel.Channel<Chunk.Chunk<In>, Chunk.Chunk<In>, never, never, unknown, unknown> =>
   core.readWith({
     onInput: (input: Chunk.Chunk<In>) => {
       const dropped = pipe(input, Chunk.drop(n))
@@ -581,7 +562,7 @@ const dropLoop = <In>(
       }
       return pipe(
         core.write(dropped),
-        channel.zipRight(channel.identityChannel<never, Chunk.Chunk<In>, unknown>())
+        channel.zipRight(channel.identityChannel<Chunk.Chunk<In>, never, unknown>())
       )
     },
     onFailure: core.fail,
@@ -589,20 +570,20 @@ const dropLoop = <In>(
   })
 
 /** @internal */
-export const dropUntil = <In>(predicate: Predicate<In>): Sink.Sink<never, never, In, In, unknown> =>
+export const dropUntil = <In>(predicate: Predicate<In>): Sink.Sink<unknown, In, In> =>
   new SinkImpl(
     pipe(toChannel(dropWhile((input: In) => !predicate(input))), channel.pipeToOrFail(toChannel(drop<In>(1))))
   )
 
 /** @internal */
-export const dropUntilEffect = <In, R, E>(
-  predicate: (input: In) => Effect.Effect<R, E, boolean>
-): Sink.Sink<R, E, In, In, unknown> => suspend(() => new SinkImpl(dropUntilEffectReader(predicate)))
+export const dropUntilEffect = <In, E, R>(
+  predicate: (input: In) => Effect.Effect<boolean, E, R>
+): Sink.Sink<unknown, In, In, E, R> => suspend(() => new SinkImpl(dropUntilEffectReader(predicate)))
 
 /** @internal */
 const dropUntilEffectReader = <In, R, E>(
-  predicate: (input: In) => Effect.Effect<R, E, boolean>
-): Channel.Channel<R, E, Chunk.Chunk<In>, unknown, E, Chunk.Chunk<In>, unknown> =>
+  predicate: (input: In) => Effect.Effect<boolean, E, R>
+): Channel.Channel<Chunk.Chunk<In>, Chunk.Chunk<In>, E, E, unknown, unknown, R> =>
   core.readWith({
     onInput: (input: Chunk.Chunk<In>) =>
       pipe(
@@ -614,7 +595,7 @@ const dropUntilEffectReader = <In, R, E>(
             dropUntilEffectReader(predicate) :
             pipe(
               core.write(Chunk.unsafeFromArray(leftover)),
-              channel.zipRight(channel.identityChannel<E, Chunk.Chunk<In>, unknown>())
+              channel.zipRight(channel.identityChannel<Chunk.Chunk<In>, E, unknown>())
             )
         }),
         channel.unwrap
@@ -624,34 +605,34 @@ const dropUntilEffectReader = <In, R, E>(
   })
 
 /** @internal */
-export const dropWhile = <In>(predicate: Predicate<In>): Sink.Sink<never, never, In, In, unknown> =>
+export const dropWhile = <In>(predicate: Predicate<In>): Sink.Sink<unknown, In, In> =>
   new SinkImpl(dropWhileReader(predicate))
 
 /** @internal */
 const dropWhileReader = <In>(
   predicate: Predicate<In>
-): Channel.Channel<never, never, Chunk.Chunk<In>, unknown, never, Chunk.Chunk<In>, unknown> =>
+): Channel.Channel<Chunk.Chunk<In>, Chunk.Chunk<In>, never, never, unknown, unknown> =>
   core.readWith({
     onInput: (input: Chunk.Chunk<In>) => {
       const out = pipe(input, Chunk.dropWhile(predicate))
       if (Chunk.isEmpty(out)) {
         return dropWhileReader(predicate)
       }
-      return pipe(core.write(out), channel.zipRight(channel.identityChannel<never, Chunk.Chunk<In>, unknown>()))
+      return pipe(core.write(out), channel.zipRight(channel.identityChannel<Chunk.Chunk<In>, never, unknown>()))
     },
     onFailure: core.fail,
     onDone: core.succeedNow
   })
 
 /** @internal */
-export const dropWhileEffect = <In, R, E>(
-  predicate: (input: In) => Effect.Effect<R, E, boolean>
-): Sink.Sink<R, E, In, In, unknown> => suspend(() => new SinkImpl(dropWhileEffectReader(predicate)))
+export const dropWhileEffect = <In, E, R>(
+  predicate: (input: In) => Effect.Effect<boolean, E, R>
+): Sink.Sink<unknown, In, In, E, R> => suspend(() => new SinkImpl(dropWhileEffectReader(predicate)))
 
 /** @internal */
 const dropWhileEffectReader = <In, R, E>(
-  predicate: (input: In) => Effect.Effect<R, E, boolean>
-): Channel.Channel<R, E, Chunk.Chunk<In>, unknown, E, Chunk.Chunk<In>, unknown> =>
+  predicate: (input: In) => Effect.Effect<boolean, E, R>
+): Channel.Channel<Chunk.Chunk<In>, Chunk.Chunk<In>, E, E, unknown, unknown, R> =>
   core.readWith({
     onInput: (input: Chunk.Chunk<In>) =>
       pipe(
@@ -663,7 +644,7 @@ const dropWhileEffectReader = <In, R, E>(
             dropWhileEffectReader(predicate) :
             pipe(
               core.write(Chunk.unsafeFromArray(leftover)),
-              channel.zipRight(channel.identityChannel<E, Chunk.Chunk<In>, unknown>())
+              channel.zipRight(channel.identityChannel<Chunk.Chunk<In>, E, unknown>())
             )
         }),
         channel.unwrap
@@ -674,102 +655,93 @@ const dropWhileEffectReader = <In, R, E>(
 
 /** @internal */
 export const ensuring = dual<
-  <R2, _>(
-    finalizer: Effect.Effect<R2, never, _>
-  ) => <R, E, In, L, Z>(self: Sink.Sink<R, E, In, L, Z>) => Sink.Sink<R2 | R, E, In, L, Z>,
-  <R, E, In, L, Z, R2, _>(
-    self: Sink.Sink<R, E, In, L, Z>,
-    finalizer: Effect.Effect<R2, never, _>
-  ) => Sink.Sink<R2 | R, E, In, L, Z>
+  <_, R2>(
+    finalizer: Effect.Effect<_, never, R2>
+  ) => <A, In, L, E, R>(self: Sink.Sink<A, In, L, E, R>) => Sink.Sink<A, In, L, E, R2 | R>,
+  <A, In, L, E, R, _, R2>(
+    self: Sink.Sink<A, In, L, E, R>,
+    finalizer: Effect.Effect<_, never, R2>
+  ) => Sink.Sink<A, In, L, E, R2 | R>
 >(
   2,
-  <R, E, In, L, Z, R2, _>(
-    self: Sink.Sink<R, E, In, L, Z>,
-    finalizer: Effect.Effect<R2, never, _>
-  ): Sink.Sink<R | R2, E, In, L, Z> => new SinkImpl(pipe(self, toChannel, channel.ensuring(finalizer)))
+  (self, finalizer) => new SinkImpl(pipe(self, toChannel, channel.ensuring(finalizer)))
 )
 
 /** @internal */
 export const ensuringWith = dual<
-  <E, Z, R2, _>(
-    finalizer: (exit: Exit.Exit<E, Z>) => Effect.Effect<R2, never, _>
-  ) => <R, In, L>(self: Sink.Sink<R, E, In, L, Z>) => Sink.Sink<R2 | R, E, In, L, Z>,
-  <R, In, L, E, Z, R2, _>(
-    self: Sink.Sink<R, E, In, L, Z>,
-    finalizer: (exit: Exit.Exit<E, Z>) => Effect.Effect<R2, never, _>
-  ) => Sink.Sink<R2 | R, E, In, L, Z>
+  <A, E, _, R2>(
+    finalizer: (exit: Exit.Exit<A, E>) => Effect.Effect<_, never, R2>
+  ) => <In, L, R>(self: Sink.Sink<A, In, L, E, R>) => Sink.Sink<A, In, L, E, R2 | R>,
+  <A, In, L, E, R, _, R2>(
+    self: Sink.Sink<A, In, L, E, R>,
+    finalizer: (exit: Exit.Exit<A, E>) => Effect.Effect<_, never, R2>
+  ) => Sink.Sink<A, In, L, E, R2 | R>
 >(
   2,
-  <R, In, L, E, Z, R2, _>(
-    self: Sink.Sink<R, E, In, L, Z>,
-    finalizer: (exit: Exit.Exit<E, Z>) => Effect.Effect<R2, never, _>
-  ): Sink.Sink<R | R2, E, In, L, Z> => new SinkImpl(pipe(self, toChannel, core.ensuringWith(finalizer)))
+  (self, finalizer) => new SinkImpl(pipe(self, toChannel, core.ensuringWith(finalizer)))
 )
 
 /** @internal */
-export const context = <R>(): Sink.Sink<R, never, unknown, never, Context.Context<R>> => fromEffect(Effect.context<R>())
+export const context = <R>(): Sink.Sink<Context.Context<R>, unknown, never, never, R> => fromEffect(Effect.context<R>())
 
 /** @internal */
 export const contextWith = <R, Z>(
   f: (context: Context.Context<R>) => Z
-): Sink.Sink<R, never, unknown, never, Z> => pipe(context<R>(), map(f))
+): Sink.Sink<Z, unknown, never, never, R> => pipe(context<R>(), map(f))
 
 /** @internal */
-export const contextWithEffect = <R0, R, E, Z>(
-  f: (context: Context.Context<R0>) => Effect.Effect<R, E, Z>
-): Sink.Sink<R0 | R, E, unknown, never, Z> => pipe(context<R0>(), mapEffect(f))
+export const contextWithEffect = <R0, A, E, R>(
+  f: (context: Context.Context<R0>) => Effect.Effect<A, E, R>
+): Sink.Sink<A, unknown, never, E, R0 | R> => pipe(context<R0>(), mapEffect(f))
 
 /** @internal */
-export const contextWithSink = <R0, R, E, In, L, Z>(
-  f: (context: Context.Context<R0>) => Sink.Sink<R, E, In, L, Z>
-): Sink.Sink<R0 | R, E, In, L, Z> =>
+export const contextWithSink = <R0, A, In, L, E, R>(
+  f: (context: Context.Context<R0>) => Sink.Sink<A, In, L, E, R>
+): Sink.Sink<A, In, L, E, R0 | R> =>
   new SinkImpl(channel.unwrap(pipe(Effect.contextWith((context) => toChannel(f(context))))))
 
 /** @internal */
-export const every = <In>(predicate: Predicate<In>): Sink.Sink<never, never, In, In, boolean> =>
+export const every = <In>(predicate: Predicate<In>): Sink.Sink<boolean, In, In> =>
   fold(true, identity, (acc, input) => acc && predicate(input))
 
 /** @internal */
-export const fail = <E>(e: E): Sink.Sink<never, E, unknown, never, never> => new SinkImpl(core.fail(e))
+export const fail = <E>(e: E): Sink.Sink<never, unknown, never, E> => new SinkImpl(core.fail(e))
 
 /** @internal */
-export const failSync = <E>(evaluate: LazyArg<E>): Sink.Sink<never, E, unknown, never, never> =>
+export const failSync = <E>(evaluate: LazyArg<E>): Sink.Sink<never, unknown, never, E> =>
   new SinkImpl(core.failSync(evaluate))
 
 /** @internal */
-export const failCause = <E>(cause: Cause.Cause<E>): Sink.Sink<never, E, unknown, never, never> =>
+export const failCause = <E>(cause: Cause.Cause<E>): Sink.Sink<never, unknown, never, E> =>
   new SinkImpl(core.failCause(cause))
 
 /** @internal */
-export const failCauseSync = <E>(evaluate: LazyArg<Cause.Cause<E>>): Sink.Sink<never, E, unknown, never, never> =>
+export const failCauseSync = <E>(evaluate: LazyArg<Cause.Cause<E>>): Sink.Sink<never, unknown, never, E> =>
   new SinkImpl(core.failCauseSync(evaluate))
 
 /** @internal */
 export const filterInput: {
   <In, In1 extends In, In2 extends In1>(
     f: Refinement<In1, In2>
-  ): <R, E, L, Z>(self: Sink.Sink<R, E, In, L, Z>) => Sink.Sink<R, E, In2, L, Z>
-  <In, In1 extends In>(f: Predicate<In1>): <R, E, L, Z>(self: Sink.Sink<R, E, In, L, Z>) => Sink.Sink<R, E, In1, L, Z>
+  ): <A, L, E, R>(self: Sink.Sink<A, In, L, E, R>) => Sink.Sink<A, In2, L, E, R>
+  <In, In1 extends In>(f: Predicate<In1>): <A, L, E, R>(self: Sink.Sink<A, In, L, E, R>) => Sink.Sink<A, In1, L, E, R>
 } = <In, In1 extends In>(f: Predicate<In1>) => {
-  return <R, E, L, Z>(self: Sink.Sink<R, E, In, L, Z>): Sink.Sink<R, E, In1, L, Z> =>
+  return <A, L, E, R>(self: Sink.Sink<A, In, L, E, R>): Sink.Sink<A, In1, L, E, R> =>
     pipe(self, mapInputChunks(Chunk.filter(f)))
 }
 
 /** @internal */
 export const filterInputEffect = dual<
-  <R2, E2, In, In1 extends In>(
-    f: (input: In1) => Effect.Effect<R2, E2, boolean>
-  ) => <R, E, L, Z>(self: Sink.Sink<R, E, In, L, Z>) => Sink.Sink<R2 | R, E2 | E, In1, L, Z>,
-  <R, E, L, Z, R2, E2, In, In1 extends In>(
-    self: Sink.Sink<R, E, In, L, Z>,
-    f: (input: In1) => Effect.Effect<R2, E2, boolean>
-  ) => Sink.Sink<R2 | R, E2 | E, In1, L, Z>
+  <In, In1 extends In, E2, R2>(
+    f: (input: In1) => Effect.Effect<boolean, E2, R2>
+  ) => <A, L, E, R>(self: Sink.Sink<A, In, L, E, R>) => Sink.Sink<A, In1, L, E2 | E, R2 | R>,
+  <A, In, L, E, R, In1 extends In, E2, R2>(
+    self: Sink.Sink<A, In, L, E, R>,
+    f: (input: In1) => Effect.Effect<boolean, E2, R2>
+  ) => Sink.Sink<A, In1, L, E2 | E, R2 | R>
 >(
   2,
-  <R, E, L, Z, R2, E2, In, In1 extends In>(
-    self: Sink.Sink<R, E, In, L, Z>,
-    f: (input: In1) => Effect.Effect<R2, E2, boolean>
-  ): Sink.Sink<R | R2, E | E2, In1, L, Z> =>
+  (self, f) =>
     mapInputChunksEffect(
       self,
       (chunk) => Effect.map(Effect.filter(chunk, f), Chunk.unsafeFromArray)
@@ -778,32 +750,32 @@ export const filterInputEffect = dual<
 
 /** @internal */
 export const findEffect = dual<
-  <Z, R2, E2>(
-    f: (z: Z) => Effect.Effect<R2, E2, boolean>
-  ) => <R, E, In, L extends In>(self: Sink.Sink<R, E, In, L, Z>) => Sink.Sink<R2 | R, E2 | E, In, L, Option.Option<Z>>,
-  <R, E, In, L extends In, Z, R2, E2>(
-    self: Sink.Sink<R, E, In, L, Z>,
-    f: (z: Z) => Effect.Effect<R2, E2, boolean>
-  ) => Sink.Sink<R2 | R, E2 | E, In, L, Option.Option<Z>>
+  <A, E2, R2>(
+    f: (a: A) => Effect.Effect<boolean, E2, R2>
+  ) => <In, L extends In, E, R>(self: Sink.Sink<A, In, L, E, R>) => Sink.Sink<Option.Option<A>, In, L, E2 | E, R2 | R>,
+  <A, In, L extends In, E, R, E2, R2>(
+    self: Sink.Sink<A, In, L, E, R>,
+    f: (a: A) => Effect.Effect<boolean, E2, R2>
+  ) => Sink.Sink<Option.Option<A>, In, L, E2 | E, R2 | R>
 >(
   2,
-  <R, E, In, L extends In, Z, R2, E2>(
-    self: Sink.Sink<R, E, In, L, Z>,
-    f: (z: Z) => Effect.Effect<R2, E2, boolean>
-  ): Sink.Sink<R | R2, E | E2, In, L, Option.Option<Z>> => {
+  <A, In, L extends In, E, R, E2, R2>(
+    self: Sink.Sink<A, In, L, E, R>,
+    f: (a: A) => Effect.Effect<boolean, E2, R2>
+  ): Sink.Sink<Option.Option<A>, In, L, E2 | E, R2 | R> => {
     const newChannel = pipe(
       core.fromEffect(pipe(
         Ref.make(Chunk.empty<In>()),
         Effect.zip(Ref.make(false))
       )),
       core.flatMap(([leftoversRef, upstreamDoneRef]) => {
-        const upstreamMarker: Channel.Channel<never, never, Chunk.Chunk<In>, unknown, never, Chunk.Chunk<In>, unknown> =
-          core.readWith({
+        const upstreamMarker: Channel.Channel<Chunk.Chunk<In>, Chunk.Chunk<In>, never, never, unknown, unknown> = core
+          .readWith({
             onInput: (input) => pipe(core.write(input), core.flatMap(() => upstreamMarker)),
             onFailure: core.fail,
             onDone: (done) => pipe(core.fromEffect(Ref.set(upstreamDoneRef, true)), channel.as(done))
           })
-        const loop: Channel.Channel<R | R2, never, Chunk.Chunk<In>, unknown, E | E2, Chunk.Chunk<L>, Option.Option<Z>> =
+        const loop: Channel.Channel<Chunk.Chunk<L>, Chunk.Chunk<In>, E | E2, never, Option.Option<A>, unknown, R | R2> =
           channel.foldChannel(core.collectElements(toChannel(self)), {
             onFailure: core.fail,
             onSuccess: ([leftovers, doneValue]) =>
@@ -841,15 +813,15 @@ export const findEffect = dual<
 export const fold = <S, In>(
   s: S,
   contFn: Predicate<S>,
-  f: (z: S, input: In) => S
-): Sink.Sink<never, never, In, In, S> => suspend(() => new SinkImpl(foldReader(s, contFn, f)))
+  f: (s: S, input: In) => S
+): Sink.Sink<S, In, In> => suspend(() => new SinkImpl(foldReader(s, contFn, f)))
 
 /** @internal */
 const foldReader = <S, In>(
   s: S,
   contFn: Predicate<S>,
   f: (z: S, input: In) => S
-): Channel.Channel<never, never, Chunk.Chunk<In>, unknown, never, Chunk.Chunk<In>, S> => {
+): Channel.Channel<Chunk.Chunk<In>, Chunk.Chunk<In>, never, never, S, unknown> => {
   if (!contFn(s)) {
     return core.succeedNow(s)
   }
@@ -887,36 +859,36 @@ const foldChunkSplit = <S, In>(
 
 /** @internal */
 export const foldSink = dual<
-  <R1, R2, E, E1, E2, In, In1 extends In, In2 extends In, L, L1, L2, Z, Z1, Z2>(
+  <E, A1, In, In1 extends In, L1, E1, R1, A, A2, In2 extends In, L2, E2, R2>(
     options: {
-      readonly onFailure: (err: E) => Sink.Sink<R1, E1, In1, L1, Z1>
-      readonly onSuccess: (z: Z) => Sink.Sink<R2, E2, In2, L2, Z2>
+      readonly onFailure: (err: E) => Sink.Sink<A1, In1, L1, E1, R1>
+      readonly onSuccess: (a: A) => Sink.Sink<A2, In2, L2, E2, R2>
     }
-  ) => <R>(self: Sink.Sink<R, E, In, L, Z>) => Sink.Sink<R1 | R2 | R, E1 | E2, In1 & In2, L1 | L2, Z1 | Z2>,
-  <R, R1, R2, E, E1, E2, In, In1 extends In, In2 extends In, L, L1, L2, Z, Z1, Z2>(
-    self: Sink.Sink<R, E, In, L, Z>,
+  ) => <L, R>(self: Sink.Sink<A, In, L, E, R>) => Sink.Sink<A1 | A2, In1 & In2, L1 | L2, E1 | E2, R1 | R2 | R>,
+  <A, In, L, E, R, A1, In1 extends In, L1, E1, R1, A2, In2 extends In, L2, E2, R2>(
+    self: Sink.Sink<A, In, L, E, R>,
     options: {
-      readonly onFailure: (err: E) => Sink.Sink<R1, E1, In1, L1, Z1>
-      readonly onSuccess: (z: Z) => Sink.Sink<R2, E2, In2, L2, Z2>
+      readonly onFailure: (err: E) => Sink.Sink<A1, In1, L1, E1, R1>
+      readonly onSuccess: (a: A) => Sink.Sink<A2, In2, L2, E2, R2>
     }
-  ) => Sink.Sink<R1 | R2 | R, E1 | E2, In1 & In2, L1 | L2, Z1 | Z2>
+  ) => Sink.Sink<A1 | A2, In1 & In2, L1 | L2, E1 | E2, R1 | R2 | R>
 >(
   2,
-  <R, R1, R2, E, E1, E2, In, In1 extends In, In2 extends In, L, L1, L2, Z, Z1, Z2>(
-    self: Sink.Sink<R, E, In, L, Z>,
+  <A, In, L, E, R, A1, In1 extends In, L1, E1, R1, A2, In2 extends In, L2, E2, R2>(
+    self: Sink.Sink<A, In, L, E, R>,
     options: {
-      readonly onFailure: (err: E) => Sink.Sink<R1, E1, In1, L1, Z1>
-      readonly onSuccess: (z: Z) => Sink.Sink<R2, E2, In2, L2, Z2>
+      readonly onFailure: (err: E) => Sink.Sink<A1, In1, L1, E1, R1>
+      readonly onSuccess: (z: A) => Sink.Sink<A2, In2, L2, E2, R2>
     }
-  ): Sink.Sink<R | R1 | R2, E1 | E2, In1 & In2, L1 | L2, Z1 | Z2> => {
+  ): Sink.Sink<A1 | A2, In1 & In2, L1 | L2, E1 | E2, R | R1 | R2> => {
     const newChannel: Channel.Channel<
-      R | R1 | R2,
-      never,
+      Chunk.Chunk<L1 | L2>,
       Chunk.Chunk<In1 & In2>,
-      unknown,
       E1 | E2,
-      Chunk.Chunk<L1 | L2>,
-      Z1 | Z2
+      never,
+      A1 | A2,
+      unknown,
+      R | R1 | R2
     > = pipe(
       toChannel(self),
       core.collectElements,
@@ -937,7 +909,7 @@ export const foldSink = dual<
               // L <: In1 and therefore Chunk[L] can be safely cast to Chunk[In1].
               core.flatMap((chunk) => channel.writeChunk(chunk as Chunk.Chunk<Chunk.Chunk<In1 & In2>>))
             )
-            const passthrough = channel.identityChannel<never, Chunk.Chunk<In1 & In2>, unknown>()
+            const passthrough = channel.identityChannel<Chunk.Chunk<In1 & In2>, never, unknown>()
             const continuationSink = pipe(
               refReader,
               channel.zipRight(passthrough),
@@ -965,14 +937,14 @@ export const foldChunks = <S, In>(
   s: S,
   contFn: Predicate<S>,
   f: (s: S, chunk: Chunk.Chunk<In>) => S
-): Sink.Sink<never, never, In, never, S> => suspend(() => new SinkImpl(foldChunksReader(s, contFn, f)))
+): Sink.Sink<S, In> => suspend(() => new SinkImpl(foldChunksReader(s, contFn, f)))
 
 /** @internal */
 const foldChunksReader = <S, In>(
   s: S,
   contFn: Predicate<S>,
   f: (s: S, chunk: Chunk.Chunk<In>) => S
-): Channel.Channel<never, never, Chunk.Chunk<In>, unknown, never, never, S> => {
+): Channel.Channel<never, Chunk.Chunk<In>, never, never, S, unknown> => {
   if (!contFn(s)) {
     return core.succeedNow(s)
   }
@@ -984,18 +956,18 @@ const foldChunksReader = <S, In>(
 }
 
 /** @internal */
-export const foldChunksEffect = <S, R, E, In>(
+export const foldChunksEffect = <S, In, E, R>(
   s: S,
   contFn: Predicate<S>,
-  f: (s: S, chunk: Chunk.Chunk<In>) => Effect.Effect<R, E, S>
-): Sink.Sink<R, E, In, In, S> => suspend(() => new SinkImpl(foldChunksEffectReader(s, contFn, f)))
+  f: (s: S, chunk: Chunk.Chunk<In>) => Effect.Effect<S, E, R>
+): Sink.Sink<S, In, In, E, R> => suspend(() => new SinkImpl(foldChunksEffectReader(s, contFn, f)))
 
 /** @internal */
 const foldChunksEffectReader = <S, R, E, In>(
   s: S,
   contFn: Predicate<S>,
-  f: (s: S, chunk: Chunk.Chunk<In>) => Effect.Effect<R, E, S>
-): Channel.Channel<R, E, Chunk.Chunk<In>, unknown, E, never, S> => {
+  f: (s: S, chunk: Chunk.Chunk<In>) => Effect.Effect<S, E, R>
+): Channel.Channel<never, Chunk.Chunk<In>, E, E, S, unknown, R> => {
   if (!contFn(s)) {
     return core.succeedNow(s)
   }
@@ -1011,18 +983,18 @@ const foldChunksEffectReader = <S, R, E, In>(
 }
 
 /** @internal */
-export const foldEffect = <S, R, E, In>(
+export const foldEffect = <S, In, E, R>(
   s: S,
   contFn: Predicate<S>,
-  f: (s: S, input: In) => Effect.Effect<R, E, S>
-): Sink.Sink<R, E, In, In, S> => suspend(() => new SinkImpl(foldEffectReader(s, contFn, f)))
+  f: (s: S, input: In) => Effect.Effect<S, E, R>
+): Sink.Sink<S, In, In, E, R> => suspend(() => new SinkImpl(foldEffectReader(s, contFn, f)))
 
 /** @internal */
 const foldEffectReader = <S, In, R, E>(
   s: S,
   contFn: Predicate<S>,
-  f: (s: S, input: In) => Effect.Effect<R, E, S>
-): Channel.Channel<R, E, Chunk.Chunk<In>, unknown, E, Chunk.Chunk<In>, S> => {
+  f: (s: S, input: In) => Effect.Effect<S, E, R>
+): Channel.Channel<Chunk.Chunk<In>, Chunk.Chunk<In>, E, E, S, unknown, R> => {
   if (!contFn(s)) {
     return core.succeedNow(s)
   }
@@ -1050,8 +1022,8 @@ const foldChunkSplitEffect = <S, R, E, In>(
   s: S,
   chunk: Chunk.Chunk<In>,
   contFn: Predicate<S>,
-  f: (s: S, input: In) => Effect.Effect<R, E, S>
-): Effect.Effect<R, E, [S, Option.Option<Chunk.Chunk<In>>]> =>
+  f: (s: S, input: In) => Effect.Effect<S, E, R>
+): Effect.Effect<[S, Option.Option<Chunk.Chunk<In>>], E, R> =>
   foldChunkSplitEffectInternal(s, chunk, 0, chunk.length, contFn, f)
 
 /** @internal */
@@ -1061,8 +1033,8 @@ const foldChunkSplitEffectInternal = <S, R, E, In>(
   index: number,
   length: number,
   contFn: Predicate<S>,
-  f: (s: S, input: In) => Effect.Effect<R, E, S>
-): Effect.Effect<R, E, [S, Option.Option<Chunk.Chunk<In>>]> => {
+  f: (s: S, input: In) => Effect.Effect<S, E, R>
+): Effect.Effect<[S, Option.Option<Chunk.Chunk<In>>], E, R> => {
   if (index === length) {
     return Effect.succeed([s, Option.none()])
   }
@@ -1077,29 +1049,29 @@ const foldChunkSplitEffectInternal = <S, R, E, In>(
 }
 
 /** @internal */
-export const foldLeft = <S, In>(s: S, f: (s: S, input: In) => S): Sink.Sink<never, never, In, never, S> =>
+export const foldLeft = <S, In>(s: S, f: (s: S, input: In) => S): Sink.Sink<S, In> =>
   ignoreLeftover(fold(s, constTrue, f))
 
 /** @internal */
 export const foldLeftChunks = <S, In>(
   s: S,
   f: (s: S, chunk: Chunk.Chunk<In>) => S
-): Sink.Sink<never, never, In, never, S> => foldChunks(s, constTrue, f)
+): Sink.Sink<S, In> => foldChunks(s, constTrue, f)
 
 /** @internal */
-export const foldLeftChunksEffect = <S, R, E, In>(
+export const foldLeftChunksEffect = <S, In, E, R>(
   s: S,
-  f: (s: S, chunk: Chunk.Chunk<In>) => Effect.Effect<R, E, S>
-): Sink.Sink<R, E, In, never, S> => ignoreLeftover(foldChunksEffect(s, constTrue, f))
+  f: (s: S, chunk: Chunk.Chunk<In>) => Effect.Effect<S, E, R>
+): Sink.Sink<S, In, never, E, R> => ignoreLeftover(foldChunksEffect(s, constTrue, f))
 
 /** @internal */
-export const foldLeftEffect = <S, R, E, In>(
+export const foldLeftEffect = <S, In, E, R>(
   s: S,
-  f: (s: S, input: In) => Effect.Effect<R, E, S>
-): Sink.Sink<R, E, In, In, S> => foldEffect(s, constTrue, f)
+  f: (s: S, input: In) => Effect.Effect<S, E, R>
+): Sink.Sink<S, In, In, E, R> => foldEffect(s, constTrue, f)
 
 /** @internal */
-export const foldUntil = <S, In>(s: S, max: number, f: (z: S, input: In) => S): Sink.Sink<never, never, In, In, S> =>
+export const foldUntil = <S, In>(s: S, max: number, f: (s: S, input: In) => S): Sink.Sink<S, In, In> =>
   pipe(
     fold<[S, number], In>(
       [s, 0],
@@ -1110,11 +1082,11 @@ export const foldUntil = <S, In>(s: S, max: number, f: (z: S, input: In) => S):
   )
 
 /** @internal */
-export const foldUntilEffect = <S, R, E, In>(
+export const foldUntilEffect = <S, In, E, R>(
   s: S,
   max: number,
-  f: (s: S, input: In) => Effect.Effect<R, E, S>
-): Sink.Sink<R, E, In, In, S> =>
+  f: (s: S, input: In) => Effect.Effect<S, E, R>
+): Sink.Sink<S, In, In, E, R> =>
   pipe(
     foldEffect(
       [s, 0 as number] as const,
@@ -1132,7 +1104,7 @@ export const foldWeighted = <S, In>(
     readonly cost: (s: S, input: In) => number
     readonly body: (s: S, input: In) => S
   }
-): Sink.Sink<never, never, In, In, S> =>
+): Sink.Sink<S, In, In> =>
   foldWeightedDecompose({
     ...options,
     decompose: Chunk.of
@@ -1147,7 +1119,7 @@ export const foldWeightedDecompose = <S, In>(
     readonly decompose: (input: In) => Chunk.Chunk<In>
     readonly body: (s: S, input: In) => S
   }
-): Sink.Sink<never, never, In, In, S> =>
+): Sink.Sink<S, In, In> =>
   suspend(() =>
     new SinkImpl(
       foldWeightedDecomposeLoop(
@@ -1171,7 +1143,7 @@ const foldWeightedDecomposeLoop = <S, In>(
   costFn: (s: S, input: In) => number,
   decompose: (input: In) => Chunk.Chunk<In>,
   f: (s: S, input: In) => S
-): Channel.Channel<never, never, Chunk.Chunk<In>, unknown, never, Chunk.Chunk<In>, S> =>
+): Channel.Channel<Chunk.Chunk<In>, Chunk.Chunk<In>, never, never, S, unknown> =>
   core.readWith({
     onInput: (input: Chunk.Chunk<In>) => {
       const [nextS, nextCost, nextDirty, leftovers] = foldWeightedDecomposeFold(
@@ -1236,15 +1208,15 @@ const foldWeightedDecomposeFold = <In, S>(
 }
 
 /** @internal */
-export const foldWeightedDecomposeEffect = <S, In, R, E, R2, E2, R3, E3>(
+export const foldWeightedDecomposeEffect = <S, In, E, R, E2, R2, E3, R3>(
   options: {
     readonly initial: S
     readonly maxCost: number
-    readonly cost: (s: S, input: In) => Effect.Effect<R, E, number>
-    readonly decompose: (input: In) => Effect.Effect<R2, E2, Chunk.Chunk<In>>
-    readonly body: (s: S, input: In) => Effect.Effect<R3, E3, S>
+    readonly cost: (s: S, input: In) => Effect.Effect<number, E, R>
+    readonly decompose: (input: In) => Effect.Effect<Chunk.Chunk<In>, E2, R2>
+    readonly body: (s: S, input: In) => Effect.Effect<S, E3, R3>
   }
-): Sink.Sink<R | R2 | R3, E | E2 | E3, In, In, S> =>
+): Sink.Sink<S, In, In, E | E2 | E3, R | R2 | R3> =>
   suspend(() =>
     new SinkImpl(
       foldWeightedDecomposeEffectLoop(
@@ -1260,14 +1232,14 @@ export const foldWeightedDecomposeEffect = <S, In, R, E, R2, E2, R3, E3>(
   )
 
 /** @internal */
-export const foldWeightedEffect = <S, In, R, E, R2, E2>(
+export const foldWeightedEffect = <S, In, E, R, E2, R2>(
   options: {
     readonly initial: S
     readonly maxCost: number
-    readonly cost: (s: S, input: In) => Effect.Effect<R, E, number>
-    readonly body: (s: S, input: In) => Effect.Effect<R2, E2, S>
+    readonly cost: (s: S, input: In) => Effect.Effect<number, E, R>
+    readonly body: (s: S, input: In) => Effect.Effect<S, E2, R2>
   }
-): Sink.Sink<R | R2, E | E2, In, In, S> =>
+): Sink.Sink<S, In, In, E | E2, R | R2> =>
   foldWeightedDecomposeEffect({
     ...options,
     decompose: (input) => Effect.succeed(Chunk.of(input))
@@ -1277,12 +1249,12 @@ export const foldWeightedEffect = <S, In, R, E, R2, E2>(
 const foldWeightedDecomposeEffectLoop = <S, In, R, E, R2, E2, R3, E3>(
   s: S,
   max: number,
-  costFn: (s: S, input: In) => Effect.Effect<R, E, number>,
-  decompose: (input: In) => Effect.Effect<R2, E2, Chunk.Chunk<In>>,
-  f: (s: S, input: In) => Effect.Effect<R3, E3, S>,
+  costFn: (s: S, input: In) => Effect.Effect<number, E, R>,
+  decompose: (input: In) => Effect.Effect<Chunk.Chunk<In>, E2, R2>,
+  f: (s: S, input: In) => Effect.Effect<S, E3, R3>,
   cost: number,
   dirty: boolean
-): Channel.Channel<R | R2 | R3, E | E2 | E3, Chunk.Chunk<In>, unknown, E | E2 | E3, Chunk.Chunk<In>, S> =>
+): Channel.Channel<Chunk.Chunk<In>, Chunk.Chunk<In>, E | E2 | E3, E | E2 | E3, S, unknown, R | R2 | R3> =>
   core.readWith({
     onInput: (input: Chunk.Chunk<In>) =>
       pipe(
@@ -1305,14 +1277,14 @@ const foldWeightedDecomposeEffectLoop = <S, In, R, E, R2, E2, R3, E3>(
 const foldWeightedDecomposeEffectFold = <S, In, R, E, R2, E2, R3, E3>(
   s: S,
   max: number,
-  costFn: (s: S, input: In) => Effect.Effect<R, E, number>,
-  decompose: (input: In) => Effect.Effect<R2, E2, Chunk.Chunk<In>>,
-  f: (s: S, input: In) => Effect.Effect<R3, E3, S>,
+  costFn: (s: S, input: In) => Effect.Effect<number, E, R>,
+  decompose: (input: In) => Effect.Effect<Chunk.Chunk<In>, E2, R2>,
+  f: (s: S, input: In) => Effect.Effect<S, E3, R3>,
   input: Chunk.Chunk<In>,
   dirty: boolean,
   cost: number,
   index: number
-): Effect.Effect<R | R2 | R3, E | E2 | E3, [S, number, boolean, Chunk.Chunk<In>]> => {
+): Effect.Effect<[S, number, boolean, Chunk.Chunk<In>], E | E2 | E3, R | R2 | R3> => {
   if (index === input.length) {
     return Effect.succeed([s, cost, dirty, Chunk.empty<In>()])
   }
@@ -1358,24 +1330,21 @@ const foldWeightedDecomposeEffectFold = <S, In, R, E, R2, E2, R3, E3>(
 
 /** @internal */
 export const flatMap = dual<
-  <R1, E1, In, In1 extends In, L, L1, Z, Z1>(
-    f: (z: Z) => Sink.Sink<R1, E1, In1, L1, Z1>
-  ) => <R, E>(self: Sink.Sink<R, E, In, L, Z>) => Sink.Sink<R1 | R, E1 | E, In & In1, L | L1, Z1>,
-  <R, E, R1, E1, In, In1 extends In, L, L1, Z, Z1>(
-    self: Sink.Sink<R, E, In, L, Z>,
-    f: (z: Z) => Sink.Sink<R1, E1, In1, L1, Z1>
-  ) => Sink.Sink<R1 | R, E1 | E, In & In1, L | L1, Z1>
+  <A, A1, In, In1 extends In, L1, E1, R1>(
+    f: (a: A) => Sink.Sink<A1, In1, L1, E1, R1>
+  ) => <L, E, R>(self: Sink.Sink<A, In, L, E, R>) => Sink.Sink<A1, In & In1, L | L1, E1 | E, R1 | R>,
+  <A, In, L, E, R, A1, In1 extends In, L1, E1, R1>(
+    self: Sink.Sink<A, In, L, E, R>,
+    f: (a: A) => Sink.Sink<A1, In1, L1, E1, R1>
+  ) => Sink.Sink<A1, In & In1, L | L1, E1 | E, R1 | R>
 >(
   2,
-  <R, E, R1, E1, In, In1 extends In, L, L1, Z, Z1>(
-    self: Sink.Sink<R, E, In, L, Z>,
-    f: (z: Z) => Sink.Sink<R1, E1, In1, L1, Z1>
-  ): Sink.Sink<R | R1, E | E1, In & In1, L | L1, Z1> => foldSink(self, { onFailure: fail, onSuccess: f })
+  (self, f) => foldSink(self, { onFailure: fail, onSuccess: f })
 )
 
 /** @internal */
-export const forEach = <In, R, E, _>(f: (input: In) => Effect.Effect<R, E, _>): Sink.Sink<R, E, In, never, void> => {
-  const process: Channel.Channel<R, E, Chunk.Chunk<In>, unknown, E, never, void> = core.readWithCause({
+export const forEach = <In, _, E, R>(f: (input: In) => Effect.Effect<_, E, R>): Sink.Sink<void, In, never, E, R> => {
+  const process: Channel.Channel<never, Chunk.Chunk<In>, E, E, void, unknown, R> = core.readWithCause({
     onInput: (input: Chunk.Chunk<In>) =>
       pipe(core.fromEffect(Effect.forEach(input, (v) => f(v), { discard: true })), core.flatMap(() => process)),
     onFailure: core.failCause,
@@ -1385,10 +1354,10 @@ export const forEach = <In, R, E, _>(f: (input: In) => Effect.Effect<R, E, _>):
 }
 
 /** @internal */
-export const forEachChunk = <In, R, E, _>(
-  f: (input: Chunk.Chunk<In>) => Effect.Effect<R, E, _>
-): Sink.Sink<R, E, In, never, void> => {
-  const process: Channel.Channel<R, E, Chunk.Chunk<In>, unknown, E, never, void> = core.readWithCause({
+export const forEachChunk = <In, _, E, R>(
+  f: (input: Chunk.Chunk<In>) => Effect.Effect<_, E, R>
+): Sink.Sink<void, In, never, E, R> => {
+  const process: Channel.Channel<never, Chunk.Chunk<In>, E, E, void, unknown, R> = core.readWithCause({
     onInput: (input: Chunk.Chunk<In>) => pipe(core.fromEffect(f(input)), core.flatMap(() => process)),
     onFailure: core.failCause,
     onDone: () => core.unit
@@ -1397,10 +1366,10 @@ export const forEachChunk = <In, R, E, _>(
 }
 
 /** @internal */
-export const forEachWhile = <In, R, E>(
-  f: (input: In) => Effect.Effect<R, E, boolean>
-): Sink.Sink<R, E, In, In, void> => {
-  const process: Channel.Channel<R, E, Chunk.Chunk<In>, unknown, E, Chunk.Chunk<In>, void> = core.readWithCause({
+export const forEachWhile = <In, E, R>(
+  f: (input: In) => Effect.Effect<boolean, E, R>
+): Sink.Sink<void, In, In, E, R> => {
+  const process: Channel.Channel<Chunk.Chunk<In>, Chunk.Chunk<In>, E, E, void, unknown, R> = core.readWithCause({
     onInput: (input: Chunk.Chunk<In>) => forEachWhileReader(f, input, 0, input.length, process),
     onFailure: core.failCause,
     onDone: () => core.unit
@@ -1409,13 +1378,13 @@ export const forEachWhile = <In, R, E>(
 }
 
 /** @internal */
-const forEachWhileReader = <In, R, E>(
-  f: (input: In) => Effect.Effect<R, E, boolean>,
+const forEachWhileReader = <In, E, R>(
+  f: (input: In) => Effect.Effect<boolean, E, R>,
   input: Chunk.Chunk<In>,
   index: number,
   length: number,
-  cont: Channel.Channel<R, E, Chunk.Chunk<In>, unknown, E, Chunk.Chunk<In>, void>
-): Channel.Channel<R, E, Chunk.Chunk<In>, unknown, E, Chunk.Chunk<In>, void> => {
+  cont: Channel.Channel<Chunk.Chunk<In>, Chunk.Chunk<In>, E, E, void, unknown, R>
+): Channel.Channel<Chunk.Chunk<In>, Chunk.Chunk<In>, E, E, void, unknown, R> => {
   if (index === length) {
     return cont
   }
@@ -1431,10 +1400,10 @@ const forEachWhileReader = <In, R, E>(
 }
 
 /** @internal */
-export const forEachChunkWhile = <In, R, E>(
-  f: (input: Chunk.Chunk<In>) => Effect.Effect<R, E, boolean>
-): Sink.Sink<R, E, In, In, void> => {
-  const reader: Channel.Channel<R, E, Chunk.Chunk<In>, unknown, E, never, void> = core.readWith({
+export const forEachChunkWhile = <In, E, R>(
+  f: (input: Chunk.Chunk<In>) => Effect.Effect<boolean, E, R>
+): Sink.Sink<void, In, In, E, R> => {
+  const reader: Channel.Channel<never, Chunk.Chunk<In>, E, E, void, unknown, R> = core.readWith({
     onInput: (input: Chunk.Chunk<In>) =>
       pipe(
         core.fromEffect(f(input)),
@@ -1447,12 +1416,12 @@ export const forEachChunkWhile = <In, R, E>(
 }
 
 /** @internal */
-export const fromChannel = <R, E, In, L, Z>(
-  channel: Channel.Channel<R, never, Chunk.Chunk<In>, unknown, E, Chunk.Chunk<L>, Z>
-): Sink.Sink<R, E, In, L, Z> => new SinkImpl(channel)
+export const fromChannel = <L, In, E, A, R>(
+  channel: Channel.Channel<Chunk.Chunk<L>, Chunk.Chunk<In>, E, never, A, unknown, R>
+): Sink.Sink<A, In, L, E, R> => new SinkImpl(channel)
 
 /** @internal */
-export const fromEffect = <R, E, Z>(effect: Effect.Effect<R, E, Z>): Sink.Sink<R, E, unknown, never, Z> =>
+export const fromEffect = <A, E, R>(effect: Effect.Effect<A, E, R>): Sink.Sink<A, unknown, never, E, R> =>
   new SinkImpl(core.fromEffect(effect))
 
 /** @internal */
@@ -1461,23 +1430,23 @@ export const fromPubSub = <In>(
   options?: {
     readonly shutdown?: boolean | undefined
   }
-): Sink.Sink<never, never, In, never, void> => fromQueue(pubsub, options)
+): Sink.Sink<void, In> => fromQueue(pubsub, options)
 
 /** @internal */
-export const fromPush = <R, E, In, L, Z>(
+export const fromPush = <In, E, A, L, R>(
   push: Effect.Effect<
-    R,
+    (_: Option.Option<Chunk.Chunk<In>>) => Effect.Effect<void, readonly [Either.Either<E, A>, Chunk.Chunk<L>], R>,
     never,
-    (_: Option.Option<Chunk.Chunk<In>>) => Effect.Effect<R, readonly [Either.Either<E, Z>, Chunk.Chunk<L>], void>
+    R
   >
-): Sink.Sink<Exclude<R, Scope.Scope>, E, In, L, Z> =>
+): Sink.Sink<A, In, L, E, Exclude<R, Scope.Scope>> =>
   new SinkImpl(channel.unwrapScoped(pipe(push, Effect.map(fromPushPull))))
 
 const fromPushPull = <R, E, In, L, Z>(
   push: (
     option: Option.Option<Chunk.Chunk<In>>
-  ) => Effect.Effect<R, readonly [Either.Either<E, Z>, Chunk.Chunk<L>], void>
-): Channel.Channel<R, never, Chunk.Chunk<In>, unknown, E, Chunk.Chunk<L>, Z> =>
+  ) => Effect.Effect<void, readonly [Either.Either<E, Z>, Chunk.Chunk<L>], R>
+): Channel.Channel<Chunk.Chunk<L>, Chunk.Chunk<In>, E, never, Z, unknown, R> =>
   core.readWith({
     onInput: (input: Chunk.Chunk<In>) =>
       channel.foldChannel(core.fromEffect(push(Option.some(input))), {
@@ -1511,7 +1480,7 @@ export const fromQueue = <In>(
   options?: {
     readonly shutdown?: boolean | undefined
   }
-): Sink.Sink<never, never, In, never, void> =>
+): Sink.Sink<void, In> =>
   options?.shutdown ?
     unwrapScoped(
       Effect.map(
@@ -1522,7 +1491,7 @@ export const fromQueue = <In>(
     forEachChunk((input: Chunk.Chunk<In>) => pipe(Queue.offerAll(queue, input)))
 
 /** @internal */
-export const head = <In>(): Sink.Sink<never, never, In, In, Option.Option<In>> =>
+export const head = <In>(): Sink.Sink<Option.Option<In>, In, In> =>
   fold(
     Option.none() as Option.Option<In>,
     Option.isNone,
@@ -1534,138 +1503,123 @@ export const head = <In>(): Sink.Sink<never, never, In, In, Option.Option<In>> =
   )
 
 /** @internal */
-export const ignoreLeftover = <R, E, In, L, Z>(self: Sink.Sink<R, E, In, L, Z>): Sink.Sink<R, E, In, never, Z> =>
+export const ignoreLeftover = <A, In, L, E, R>(self: Sink.Sink<A, In, L, E, R>): Sink.Sink<A, In, never, E, R> =>
   new SinkImpl(channel.drain(toChannel(self)))
 
 /** @internal */
-export const last = <In>(): Sink.Sink<never, never, In, In, Option.Option<In>> =>
+export const last = <In>(): Sink.Sink<Option.Option<In>, In, In> =>
   foldLeftChunks(Option.none<In>(), (s, input) => Option.orElse(Chunk.last(input), () => s))
 
 /** @internal */
-export const leftover = <L>(chunk: Chunk.Chunk<L>): Sink.Sink<never, never, unknown, L, void> =>
+export const leftover = <L>(chunk: Chunk.Chunk<L>): Sink.Sink<void, unknown, L> =>
   new SinkImpl(core.suspend(() => core.write(chunk)))
 
 /** @internal */
 export const map = dual<
-  <Z, Z2>(f: (z: Z) => Z2) => <R, E, In, L>(self: Sink.Sink<R, E, In, L, Z>) => Sink.Sink<R, E, In, L, Z2>,
-  <R, E, In, L, Z, Z2>(self: Sink.Sink<R, E, In, L, Z>, f: (z: Z) => Z2) => Sink.Sink<R, E, In, L, Z2>
->(2, <R, E, In, L, Z, Z2>(self: Sink.Sink<R, E, In, L, Z>, f: (z: Z) => Z2): Sink.Sink<R, E, In, L, Z2> => {
+  <A, A2>(f: (a: A) => A2) => <In, L, E, R>(self: Sink.Sink<A, In, L, E, R>) => Sink.Sink<A2, In, L, E, R>,
+  <A, In, L, E, R, A2>(self: Sink.Sink<A, In, L, E, R>, f: (a: A) => A2) => Sink.Sink<A2, In, L, E, R>
+>(2, (self, f) => {
   return new SinkImpl(pipe(toChannel(self), channel.map(f)))
 })
 
 /** @internal */
 export const mapEffect = dual<
-  <Z, R2, E2, Z2>(
-    f: (z: Z) => Effect.Effect<R2, E2, Z2>
-  ) => <R, E, In, L>(self: Sink.Sink<R, E, In, L, Z>) => Sink.Sink<R2 | R, E2 | E, In, L, Z2>,
-  <R, E, In, L, Z, R2, E2, Z2>(
-    self: Sink.Sink<R, E, In, L, Z>,
-    f: (z: Z) => Effect.Effect<R2, E2, Z2>
-  ) => Sink.Sink<R2 | R, E2 | E, In, L, Z2>
+  <A, A2, E2, R2>(
+    f: (a: A) => Effect.Effect<A2, E2, R2>
+  ) => <In, L, E, R>(self: Sink.Sink<A, In, L, E, R>) => Sink.Sink<A2, In, L, E2 | E, R2 | R>,
+  <A, In, L, E, R, A2, E2, R2>(
+    self: Sink.Sink<A, In, L, E, R>,
+    f: (a: A) => Effect.Effect<A2, E2, R2>
+  ) => Sink.Sink<A2, In, L, E2 | E, R2 | R>
 >(
   2,
-  <R, E, In, L, Z, R2, E2, Z2>(
-    self: Sink.Sink<R, E, In, L, Z>,
-    f: (z: Z) => Effect.Effect<R2, E2, Z2>
-  ): Sink.Sink<R | R2, E | E2, In, L, Z2> => new SinkImpl(pipe(toChannel(self), channel.mapEffect(f)))
+  (self, f) => new SinkImpl(pipe(toChannel(self), channel.mapEffect(f)))
 )
 
 /** @internal */
 export const mapError = dual<
-  <E, E2>(f: (error: E) => E2) => <R, In, L, Z>(self: Sink.Sink<R, E, In, L, Z>) => Sink.Sink<R, E2, In, L, Z>,
-  <R, In, L, Z, E, E2>(self: Sink.Sink<R, E, In, L, Z>, f: (error: E) => E2) => Sink.Sink<R, E2, In, L, Z>
+  <E, E2>(f: (error: E) => E2) => <A, In, L, R>(self: Sink.Sink<A, In, L, E, R>) => Sink.Sink<A, In, L, E2, R>,
+  <A, In, L, E, R, E2>(self: Sink.Sink<A, In, L, E, R>, f: (error: E) => E2) => Sink.Sink<A, In, L, E2, R>
 >(
   2,
-  <R, In, L, Z, E, E2>(self: Sink.Sink<R, E, In, L, Z>, f: (error: E) => E2): Sink.Sink<R, E2, In, L, Z> =>
-    new SinkImpl(pipe(toChannel(self), channel.mapError(f)))
+  (self, f) => new SinkImpl(pipe(toChannel(self), channel.mapError(f)))
 )
 
 /** @internal */
 export const mapLeftover = dual<
-  <L, L2>(f: (leftover: L) => L2) => <R, E, In, Z>(self: Sink.Sink<R, E, In, L, Z>) => Sink.Sink<R, E, In, L2, Z>,
-  <R, E, In, Z, L, L2>(self: Sink.Sink<R, E, In, L, Z>, f: (leftover: L) => L2) => Sink.Sink<R, E, In, L2, Z>
+  <L, L2>(f: (leftover: L) => L2) => <A, In, E, R>(self: Sink.Sink<A, In, L, E, R>) => Sink.Sink<A, In, L2, E, R>,
+  <A, In, L, E, R, L2>(self: Sink.Sink<A, In, L, E, R>, f: (leftover: L) => L2) => Sink.Sink<A, In, L2, E, R>
 >(
   2,
-  <R, E, In, Z, L, L2>(self: Sink.Sink<R, E, In, L, Z>, f: (leftover: L) => L2): Sink.Sink<R, E, In, L2, Z> =>
-    new SinkImpl(pipe(toChannel(self), channel.mapOut(Chunk.map(f))))
+  (self, f) => new SinkImpl(pipe(toChannel(self), channel.mapOut(Chunk.map(f))))
 )
 
 /** @internal */
-export const never: Sink.Sink<never, never, unknown, never, never> = fromEffect(Effect.never)
+export const never: Sink.Sink<never, unknown> = fromEffect(Effect.never)
 
 /** @internal */
 export const orElse = dual<
-  <R2, E2, In2, L2, Z2>(
-    that: LazyArg<Sink.Sink<R2, E2, In2, L2, Z2>>
-  ) => <R, E, In, L, Z>(self: Sink.Sink<R, E, In, L, Z>) => Sink.Sink<R2 | R, E2 | E, In & In2, L2 | L, Z2 | Z>,
-  <R, E, In, L, Z, R2, E2, In2, L2, Z2>(
-    self: Sink.Sink<R, E, In, L, Z>,
-    that: LazyArg<Sink.Sink<R2, E2, In2, L2, Z2>>
-  ) => Sink.Sink<R2 | R, E2 | E, In & In2, L2 | L, Z2 | Z>
+  <A2, In2, L2, E2, R2>(
+    that: LazyArg<Sink.Sink<A2, In2, L2, E2, R2>>
+  ) => <A, In, L, E, R>(self: Sink.Sink<A, In, L, E, R>) => Sink.Sink<A2 | A, In & In2, L2 | L, E2 | E, R2 | R>,
+  <A, In, L, E, R, A2, In2, L2, E2, R2>(
+    self: Sink.Sink<A, In, L, E, R>,
+    that: LazyArg<Sink.Sink<A2, In2, L2, E2, R2>>
+  ) => Sink.Sink<A2 | A, In & In2, L2 | L, E2 | E, R2 | R>
 >(
   2,
-  <R, E, In, L, Z, R2, E2, In2, L2, Z2>(
-    self: Sink.Sink<R, E, In, L, Z>,
-    that: LazyArg<Sink.Sink<R2, E2, In2, L2, Z2>>
-  ): Sink.Sink<R | R2, E | E2, In & In2, L | L2, Z | Z2> =>
-    new SinkImpl<R | R2, E | E2, In & In2, L | L2, Z | Z2>(
+  <A, In, L, E, R, A2, In2, L2, E2, R2>(
+    self: Sink.Sink<A, In, L, E, R>,
+    that: LazyArg<Sink.Sink<A2, In2, L2, E2, R2>>
+  ): Sink.Sink<A | A2, In & In2, L | L2, E | E2, R | R2> =>
+    new SinkImpl<A | A2, In & In2, L | L2, E | E2, R | R2>(
       pipe(toChannel(self), channel.orElse(() => toChannel(that())))
     )
 )
 
 /** @internal */
 export const provideContext = dual<
-  <R>(context: Context.Context<R>) => <E, In, L, Z>(self: Sink.Sink<R, E, In, L, Z>) => Sink.Sink<never, E, In, L, Z>,
-  <E, In, L, Z, R>(self: Sink.Sink<R, E, In, L, Z>, context: Context.Context<R>) => Sink.Sink<never, E, In, L, Z>
+  <R>(context: Context.Context<R>) => <A, In, L, E>(self: Sink.Sink<A, In, L, E, R>) => Sink.Sink<A, In, L, E>,
+  <A, In, L, E, R>(self: Sink.Sink<A, In, L, E, R>, context: Context.Context<R>) => Sink.Sink<A, In, L, E>
 >(
   2,
-  <E, In, L, Z, R>(self: Sink.Sink<R, E, In, L, Z>, context: Context.Context<R>): Sink.Sink<never, E, In, L, Z> =>
-    new SinkImpl(pipe(toChannel(self), core.provideContext(context)))
+  (self, context) => new SinkImpl(pipe(toChannel(self), core.provideContext(context)))
 )
 
 /** @internal */
 export const race = dual<
-  <R1, E1, In1, L1, Z1>(
-    that: Sink.Sink<R1, E1, In1, L1, Z1>
-  ) => <R, E, In, L, Z>(self: Sink.Sink<R, E, In, L, Z>) => Sink.Sink<R1 | R, E1 | E, In & In1, L1 | L, Z1 | Z>,
-  <R, E, In, L, Z, R1, E1, In1, L1, Z1>(
-    self: Sink.Sink<R, E, In, L, Z>,
-    that: Sink.Sink<R1, E1, In1, L1, Z1>
-  ) => Sink.Sink<R1 | R, E1 | E, In & In1, L1 | L, Z1 | Z>
+  <R1, E1, In1, L1, A1>(
+    that: Sink.Sink<A1, In1, L1, E1, R1>
+  ) => <R, E, In, L, A>(self: Sink.Sink<A, In, L, E, R>) => Sink.Sink<A1 | A, In & In1, L1 | L, E1 | E, R1 | R>,
+  <A, In, L, E, R, A1, In1, L1, E1, R1>(
+    self: Sink.Sink<A, In, L, E, R>,
+    that: Sink.Sink<A1, In1, L1, E1, R1>
+  ) => Sink.Sink<A1 | A, In & In1, L1 | L, E1 | E, R1 | R>
 >(
   2,
-  <R, E, In, L, Z, R1, E1, In1, L1, Z1>(
-    self: Sink.Sink<R, E, In, L, Z>,
-    that: Sink.Sink<R1, E1, In1, L1, Z1>
-  ): Sink.Sink<R | R1, E | E1, In & In1, L | L1, Z | Z1> => pipe(self, raceBoth(that), map(Either.merge))
+  (self, that) => pipe(self, raceBoth(that), map(Either.merge))
 )
 
 /** @internal */
 export const raceBoth = dual<
-  <R1, E1, In1, L1, Z1>(
-    that: Sink.Sink<R1, E1, In1, L1, Z1>,
+  <A1, In1, L1, E1, R1>(
+    that: Sink.Sink<A1, In1, L1, E1, R1>,
     options?: {
       readonly capacity?: number | undefined
     }
-  ) => <R, E, In, L, Z>(
-    self: Sink.Sink<R, E, In, L, Z>
-  ) => Sink.Sink<R1 | R, E1 | E, In & In1, L1 | L, Either.Either<Z, Z1>>,
-  <R, E, In, L, Z, R1, E1, In1, L1, Z1>(
-    self: Sink.Sink<R, E, In, L, Z>,
-    that: Sink.Sink<R1, E1, In1, L1, Z1>,
+  ) => <A, In, L, E, R>(
+    self: Sink.Sink<A, In, L, E, R>
+  ) => Sink.Sink<Either.Either<A, A1>, In & In1, L1 | L, E1 | E, R1 | R>,
+  <A, In, L, E, R, A1, In1, L1, E1, R1>(
+    self: Sink.Sink<A, In, L, E, R>,
+    that: Sink.Sink<A1, In1, L1, E1, R1>,
     options?: {
       readonly capacity?: number | undefined
     }
-  ) => Sink.Sink<R1 | R, E1 | E, In & In1, L1 | L, Either.Either<Z, Z1>>
+  ) => Sink.Sink<Either.Either<A, A1>, In & In1, L1 | L, E1 | E, R1 | R>
 >(
   (args) => isSink(args[1]),
-  <R, E, In, L, Z, R1, E1, In1, L1, Z1>(
-    self: Sink.Sink<R, E, In, L, Z>,
-    that: Sink.Sink<R1, E1, In1, L1, Z1>,
-    options?: {
-      readonly capacity?: number | undefined
-    }
-  ): Sink.Sink<R | R1, E | E1, In & In1, L | L1, Either.Either<Z, Z1>> =>
+  (self, that, options) =>
     raceWith(self, {
       other: that,
       onSelfDone: (selfDone) => mergeDecision.Done(Effect.map(selfDone, Either.left)),
@@ -1676,37 +1630,37 @@ export const raceBoth = dual<
 
 /** @internal */
 export const raceWith = dual<
-  <R2, E2, In2, L2, Z2, E, Z, Z3, Z4>(
+  <A2, In2, L2, E2, R2, A, E, A3, A4>(
     options: {
-      readonly other: Sink.Sink<R2, E2, In2, L2, Z2>
-      readonly onSelfDone: (exit: Exit.Exit<E, Z>) => MergeDecision.MergeDecision<R2, E2, Z2, E2 | E, Z3>
-      readonly onOtherDone: (exit: Exit.Exit<E2, Z2>) => MergeDecision.MergeDecision<R2, E, Z, E2 | E, Z4>
+      readonly other: Sink.Sink<A2, In2, L2, E2, R2>
+      readonly onSelfDone: (exit: Exit.Exit<A, E>) => MergeDecision.MergeDecision<R2, E2, A2, E2 | E, A3>
+      readonly onOtherDone: (exit: Exit.Exit<A2, E2>) => MergeDecision.MergeDecision<R2, E, A, E2 | E, A4>
       readonly capacity?: number | undefined
     }
-  ) => <R, In, L>(self: Sink.Sink<R, E, In, L, Z>) => Sink.Sink<R2 | R, E2 | E, In & In2, L2 | L, Z3 | Z4>,
-  <R, In, L, R2, E2, In2, L2, Z2, E, Z, Z3, Z4>(
-    self: Sink.Sink<R, E, In, L, Z>,
+  ) => <In, L, R>(self: Sink.Sink<A, In, L, E, R>) => Sink.Sink<A3 | A4, In & In2, L2 | L, E2 | E, R2 | R>,
+  <A, In, L, E, R, A2, In2, L2, E2, R2, A3, A4>(
+    self: Sink.Sink<A, In, L, E, R>,
     options: {
-      readonly other: Sink.Sink<R2, E2, In2, L2, Z2>
-      readonly onSelfDone: (exit: Exit.Exit<E, Z>) => MergeDecision.MergeDecision<R2, E2, Z2, E2 | E, Z3>
-      readonly onOtherDone: (exit: Exit.Exit<E2, Z2>) => MergeDecision.MergeDecision<R2, E, Z, E2 | E, Z4>
+      readonly other: Sink.Sink<A2, In2, L2, E2, R2>
+      readonly onSelfDone: (exit: Exit.Exit<A, E>) => MergeDecision.MergeDecision<R2, E2, A2, E2 | E, A3>
+      readonly onOtherDone: (exit: Exit.Exit<A2, E2>) => MergeDecision.MergeDecision<R2, E, A, E2 | E, A4>
       readonly capacity?: number | undefined
     }
-  ) => Sink.Sink<R2 | R, E2 | E, In & In2, L2 | L, Z3 | Z4>
+  ) => Sink.Sink<A3 | A4, In & In2, L2 | L, E2 | E, R2 | R>
 >(
   2,
-  <R, In, L, R2, E2, In2, L2, Z2, E, Z, Z3, Z4>(
-    self: Sink.Sink<R, E, In, L, Z>,
+  <A, In, L, E, R, A2, In2, L2, E2, R2, A3, A4>(
+    self: Sink.Sink<A, In, L, E, R>,
     options: {
-      readonly other: Sink.Sink<R2, E2, In2, L2, Z2>
-      readonly onSelfDone: (exit: Exit.Exit<E, Z>) => MergeDecision.MergeDecision<R2, E2, Z2, E2 | E, Z3>
-      readonly onOtherDone: (exit: Exit.Exit<E2, Z2>) => MergeDecision.MergeDecision<R2, E, Z, E2 | E, Z4>
+      readonly other: Sink.Sink<A2, In2, L2, E2, R2>
+      readonly onSelfDone: (exit: Exit.Exit<A, E>) => MergeDecision.MergeDecision<R2, E2, A2, E2 | E, A3>
+      readonly onOtherDone: (exit: Exit.Exit<A2, E2>) => MergeDecision.MergeDecision<R2, E, A, E2 | E, A4>
       readonly capacity?: number | undefined
     }
-  ): Sink.Sink<R | R2, E | E2, In & In2, L | L2, Z3 | Z4> => {
+  ): Sink.Sink<A3 | A4, In & In2, L2 | L, E2 | E, R2 | R> => {
     const scoped = Effect.gen(function*($) {
       const pubsub = yield* $(
-        PubSub.bounded<Either.Either<Exit.Exit<never, unknown>, Chunk.Chunk<In & In2>>>(options?.capacity ?? 16)
+        PubSub.bounded<Either.Either<Exit.Exit<unknown>, Chunk.Chunk<In & In2>>>(options?.capacity ?? 16)
       )
       const channel1 = yield* $(channel.fromPubSubScoped(pubsub))
       const channel2 = yield* $(channel.fromPubSubScoped(pubsub))
@@ -1721,13 +1675,13 @@ export const raceWith = dual<
         })
       )
       const racedChannel: Channel.Channel<
-        R | R2,
-        never,
+        Chunk.Chunk<L | L2>,
         Chunk.Chunk<In & In2>,
-        unknown,
         E | E2,
-        Chunk.Chunk<L | L2>,
-        Z3 | Z4
+        never,
+        A3 | A4,
+        unknown,
+        R | R2
       > = channel.mergeWith(reader, {
         other: writer,
         onSelfDone: (_) => mergeDecision.Await((exit) => Effect.suspend(() => exit)),
@@ -1743,17 +1697,14 @@ export const raceWith = dual<
 export const refineOrDie = dual<
   <E, E2>(
     pf: (error: E) => Option.Option<E2>
-  ) => <R, In, L, Z>(self: Sink.Sink<R, E, In, L, Z>) => Sink.Sink<R, E2, In, L, Z>,
-  <R, In, L, Z, E, E2>(
-    self: Sink.Sink<R, E, In, L, Z>,
+  ) => <A, In, L, R>(self: Sink.Sink<A, In, L, E, R>) => Sink.Sink<A, In, L, E2, R>,
+  <A, In, L, E, R, E2>(
+    self: Sink.Sink<A, In, L, E, R>,
     pf: (error: E) => Option.Option<E2>
-  ) => Sink.Sink<R, E2, In, L, Z>
+  ) => Sink.Sink<A, In, L, E2, R>
 >(
   2,
-  <R, In, L, Z, E, E2>(
-    self: Sink.Sink<R, E, In, L, Z>,
-    pf: (error: E) => Option.Option<E2>
-  ): Sink.Sink<R, E2, In, L, Z> => pipe(self, refineOrDieWith(pf, identity))
+  (self, pf) => pipe(self, refineOrDieWith(pf, identity))
 )
 
 /** @internal */
@@ -1761,19 +1712,15 @@ export const refineOrDieWith = dual<
   <E, E2>(
     pf: (error: E) => Option.Option<E2>,
     f: (error: E) => unknown
-  ) => <R, In, L, Z>(self: Sink.Sink<R, E, In, L, Z>) => Sink.Sink<R, E2, In, L, Z>,
-  <R, In, L, Z, E, E2>(
-    self: Sink.Sink<R, E, In, L, Z>,
+  ) => <A, In, L, R>(self: Sink.Sink<A, In, L, E, R>) => Sink.Sink<A, In, L, E2, R>,
+  <A, In, L, E, R, E2>(
+    self: Sink.Sink<A, In, L, E, R>,
     pf: (error: E) => Option.Option<E2>,
     f: (error: E) => unknown
-  ) => Sink.Sink<R, E2, In, L, Z>
+  ) => Sink.Sink<A, In, L, E2, R>
 >(
   3,
-  <R, In, L, Z, E, E2>(
-    self: Sink.Sink<R, E, In, L, Z>,
-    pf: (error: E) => Option.Option<E2>,
-    f: (error: E) => unknown
-  ): Sink.Sink<R, E2, In, L, Z> => {
+  (self, pf, f) => {
     const newChannel = pipe(
       self,
       toChannel,
@@ -1791,41 +1738,41 @@ export const refineOrDieWith = dual<
 /** @internal */
 export const service = <T extends Context.Tag<any, any>>(
   tag: T
-): Sink.Sink<Context.Tag.Identifier<T>, never, unknown, never, Context.Tag.Service<T>> => serviceWith(tag, identity)
+): Sink.Sink<Context.Tag.Service<T>, unknown, never, never, Context.Tag.Identifier<T>> => serviceWith(tag, identity)
 
 /** @internal */
 export const serviceWith = <T extends Context.Tag<any, any>, Z>(
   tag: T,
   f: (service: Context.Tag.Service<T>) => Z
-): Sink.Sink<Context.Tag.Identifier<T>, never, unknown, never, Z> => fromEffect(Effect.map(tag, f))
+): Sink.Sink<Z, unknown, never, never, Context.Tag.Identifier<T>> => fromEffect(Effect.map(tag, f))
 
 /** @internal */
 export const serviceWithEffect = <T extends Context.Tag<any, any>, R, E, Z>(
   tag: T,
-  f: (service: Context.Tag.Service<T>) => Effect.Effect<R, E, Z>
-): Sink.Sink<R | Context.Tag.Identifier<T>, E, unknown, never, Z> => fromEffect(Effect.flatMap(tag, f))
+  f: (service: Context.Tag.Service<T>) => Effect.Effect<Z, E, R>
+): Sink.Sink<Z, unknown, never, E, R | Context.Tag.Identifier<T>> => fromEffect(Effect.flatMap(tag, f))
 
 /** @internal */
 export const serviceWithSink = <T extends Context.Tag<any, any>, R, E, In, L, Z>(
   tag: T,
-  f: (service: Context.Tag.Service<T>) => Sink.Sink<R, E, In, L, Z>
-): Sink.Sink<R | Context.Tag.Identifier<T>, E, In, L, Z> =>
+  f: (service: Context.Tag.Service<T>) => Sink.Sink<Z, In, L, E, R>
+): Sink.Sink<Z, In, L, E, R | Context.Tag.Identifier<T>> =>
   new SinkImpl(pipe(Effect.map(tag, (service) => toChannel(f(service))), channel.unwrap))
 
 /** @internal */
-export const some = <In>(predicate: Predicate<In>): Sink.Sink<never, never, In, In, boolean> =>
+export const some = <In>(predicate: Predicate<In>): Sink.Sink<boolean, In, In> =>
   fold(false, (bool) => !bool, (acc, input) => acc || predicate(input))
 
 /** @internal */
 export const splitWhere = dual<
-  <In>(f: Predicate<In>) => <R, E, L extends In, Z>(self: Sink.Sink<R, E, In, L, Z>) => Sink.Sink<R, E, In, In, Z>,
-  <R, E, L extends In, Z, In>(self: Sink.Sink<R, E, In, L, Z>, f: Predicate<In>) => Sink.Sink<R, E, In, In, Z>
->(2, <R, E, L extends In, Z, In>(self: Sink.Sink<R, E, In, L, Z>, f: Predicate<In>): Sink.Sink<R, E, In, In, Z> => {
+  <In>(f: Predicate<In>) => <A, L extends In, E, R>(self: Sink.Sink<A, In, L, E, R>) => Sink.Sink<A, In, In, E, R>,
+  <A, In, L extends In, E, R>(self: Sink.Sink<A, In, L, E, R>, f: Predicate<In>) => Sink.Sink<A, In, In, E, R>
+>(2, <A, In, L extends In, E, R>(self: Sink.Sink<A, In, L, E, R>, f: Predicate<In>): Sink.Sink<A, In, In, E, R> => {
   const newChannel = pipe(
     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,22 +1793,22 @@ export const splitWhere = dual<
 })
 
 /** @internal */
-const splitWhereSplitter = <E, A>(
+const splitWhereSplitter = <A, E>(
   written: boolean,
   leftovers: Ref.Ref<Chunk.Chunk<A>>,
   f: Predicate<A>
-): Channel.Channel<never, never, Chunk.Chunk<A>, unknown, E, Chunk.Chunk<A>, unknown> =>
+): Channel.Channel<Chunk.Chunk<A>, Chunk.Chunk<A>, E, never, unknown, unknown> =>
   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 +1821,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)))
@@ -1901,32 +1848,28 @@ const indexWhere = <A>(self: Chunk.Chunk<A>, predicate: Predicate<A>, from = 0):
 }
 
 /** @internal */
-export const succeed = <Z>(z: Z): Sink.Sink<never, never, unknown, never, Z> => new SinkImpl(core.succeed(z))
+export const succeed = <A>(a: A): Sink.Sink<A, unknown> => new SinkImpl(core.succeed(a))
 
 /** @internal */
-export const sum: Sink.Sink<never, never, number, never, number> = foldLeftChunks(
+export const sum: Sink.Sink<number, number> = foldLeftChunks(
   0,
   (acc, chunk) => acc + Chunk.reduce(chunk, 0, (s, a) => s + a)
 )
 
 /** @internal */
 export const summarized = dual<
-  <R2, E2, Z2, Z3>(
-    summary: Effect.Effect<R2, E2, Z2>,
-    f: (start: Z2, end: Z2) => Z3
-  ) => <R, E, In, L, Z>(self: Sink.Sink<R, E, In, L, Z>) => Sink.Sink<R2 | R, E2 | E, In, L, [Z, Z3]>,
-  <R, E, In, L, Z, R2, E2, Z2, Z3>(
-    self: Sink.Sink<R, E, In, L, Z>,
-    summary: Effect.Effect<R2, E2, Z2>,
-    f: (start: Z2, end: Z2) => Z3
-  ) => Sink.Sink<R2 | R, E2 | E, In, L, [Z, Z3]>
+  <A2, E2, R2, A3>(
+    summary: Effect.Effect<A2, E2, R2>,
+    f: (start: A2, end: A2) => A3
+  ) => <A, In, L, E, R>(self: Sink.Sink<A, In, L, E, R>) => Sink.Sink<[A, A3], In, L, E2 | E, R2 | R>,
+  <A, In, L, E, R, A2, E2, R2, A3>(
+    self: Sink.Sink<A, In, L, E, R>,
+    summary: Effect.Effect<A2, E2, R2>,
+    f: (start: A2, end: A2) => A3
+  ) => Sink.Sink<[A, A3], In, L, E2 | E, R2 | R>
 >(
   3,
-  <R, E, In, L, Z, R2, E2, Z2, Z3>(
-    self: Sink.Sink<R, E, In, L, Z>,
-    summary: Effect.Effect<R2, E2, Z2>,
-    f: (start: Z2, end: Z2) => Z3
-  ): Sink.Sink<R | R2, E | E2, In, L, [Z, Z3]> => {
+  (self, summary, f) => {
     const newChannel = pipe(
       core.fromEffect(summary),
       core.flatMap((start) =>
@@ -1947,11 +1890,10 @@ export const summarized = dual<
 )
 
 /** @internal */
-export const sync = <Z>(evaluate: LazyArg<Z>): Sink.Sink<never, never, unknown, never, Z> =>
-  new SinkImpl(core.sync(evaluate))
+export const sync = <A>(evaluate: LazyArg<A>): Sink.Sink<A, unknown> => new SinkImpl(core.sync(evaluate))
 
 /** @internal */
-export const take = <In>(n: number): Sink.Sink<never, never, In, In, Chunk.Chunk<In>> =>
+export const take = <In>(n: number): Sink.Sink<Chunk.Chunk<In>, In, In> =>
   pipe(
     foldChunks<Chunk.Chunk<In>, In>(
       Chunk.empty(),
@@ -1965,146 +1907,146 @@ export const take = <In>(n: number): Sink.Sink<never, never, In, In, Chunk.Chunk
   )
 
 /** @internal */
-export const toChannel = <R, E, In, L, Z>(
-  self: Sink.Sink<R, E, In, L, Z>
-): Channel.Channel<R, never, Chunk.Chunk<In>, unknown, E, Chunk.Chunk<L>, Z> =>
+export const toChannel = <R, E, In, L, A>(
+  self: Sink.Sink<A, In, L, E, R>
+): Channel.Channel<Chunk.Chunk<L>, Chunk.Chunk<In>, E, never, A, unknown, R> =>
   Effect.isEffect(self) ?
-    toChannel(fromEffect(self as Effect.Effect<R, E, Z>)) :
-    (self as SinkImpl<R, E, In, L, Z>).channel
+    toChannel(fromEffect(self as Effect.Effect<A, E, R>)) :
+    (self as SinkImpl<A, In, L, E, R>).channel
 
 /** @internal */
-export const unwrap = <R, E, R2, E2, In, L, Z>(
-  effect: Effect.Effect<R, E, Sink.Sink<R2, E2, In, L, Z>>
-): Sink.Sink<R | R2, E | E2, In, L, Z> =>
+export const unwrap = <A, In, L, E2, R2, E, R>(
+  effect: Effect.Effect<Sink.Sink<A, In, L, E2, R2>, E, R>
+): Sink.Sink<A, In, L, E | E2, R | R2> =>
   new SinkImpl(
     channel.unwrap(pipe(effect, Effect.map((sink) => toChannel(sink))))
   )
 
 /** @internal */
-export const unwrapScoped = <R, E, In, L, Z>(
-  effect: Effect.Effect<R, E, Sink.Sink<R, E, In, L, Z>>
-): Sink.Sink<Exclude<R, Scope.Scope>, E, In, L, Z> => {
+export const unwrapScoped = <A, In, L, E, R>(
+  effect: Effect.Effect<Sink.Sink<A, In, L, E, R>, E, R>
+): Sink.Sink<A, In, L, E, Exclude<R, Scope.Scope>> => {
   return new SinkImpl(channel.unwrapScoped(pipe(effect, Effect.map((sink) => toChannel(sink)))))
 }
 
 /** @internal */
-export const withDuration = <R, E, In, L, Z>(
-  self: Sink.Sink<R, E, In, L, Z>
-): Sink.Sink<R, E, In, L, [Z, Duration.Duration]> =>
+export const withDuration = <A, In, L, E, R>(
+  self: Sink.Sink<A, In, L, E, R>
+): Sink.Sink<[A, Duration.Duration], In, L, E, R> =>
   pipe(self, summarized(Clock.currentTimeMillis, (start, end) => Duration.millis(end - start)))
 
 /** @internal */
 export const zip = dual<
-  <R2, E2, In, In2 extends In, L, L2, Z, Z2>(
-    that: Sink.Sink<R2, E2, In2, L2, Z2>,
+  <A2, In, In2 extends In, L2, E2, R2>(
+    that: Sink.Sink<A2, In2, L2, E2, R2>,
     options?: {
       readonly concurrent?: boolean | undefined
     }
-  ) => <R, E>(self: Sink.Sink<R, E, In, L, Z>) => Sink.Sink<R2 | R, E2 | E, In & In2, L | L2, [Z, Z2]>,
-  <R, E, R2, E2, In, In2 extends In, L, L2, Z, Z2>(
-    self: Sink.Sink<R, E, In, L, Z>,
-    that: Sink.Sink<R2, E2, In2, L2, Z2>,
+  ) => <A, L, E, R>(self: Sink.Sink<A, In, L, E, R>) => Sink.Sink<[A, A2], In & In2, L | L2, E2 | E, R2 | R>,
+  <A, In, L, E, R, A2, In2 extends In, L2, E2, R2>(
+    self: Sink.Sink<A, In, L, E, R>,
+    that: Sink.Sink<A2, In2, L2, E2, R2>,
     options?: {
       readonly concurrent?: boolean | undefined
     }
-  ) => Sink.Sink<R2 | R, E2 | E, In & In2, L | L2, [Z, Z2]>
+  ) => Sink.Sink<[A, A2], In & In2, L | L2, E2 | E, R2 | R>
 >(
   (args) => isSink(args[1]),
-  <R, E, R2, E2, In, In2 extends In, L, L2, Z, Z2>(
-    self: Sink.Sink<R, E, In, L, Z>,
-    that: Sink.Sink<R2, E2, In2, L2, Z2>,
+  <A, In, L, E, R, A2, In2 extends In, L2, E2, R2>(
+    self: Sink.Sink<A, In, L, E, R>,
+    that: Sink.Sink<A2, In2, L2, E2, R2>,
     options?: {
       readonly concurrent?: boolean | undefined
     }
-  ): Sink.Sink<R | R2, E | E2, In & In2, L | L2, [Z, Z2]> => zipWith(self, that, (z, z2) => [z, z2], options)
+  ): Sink.Sink<[A, A2], In & In2, L | L2, E2 | E, R2 | R> => zipWith(self, that, (z, z2) => [z, z2], options)
 )
 
 /** @internal */
 export const zipLeft = dual<
-  <R2, E2, In, In2 extends In, L, L2, Z, Z2>(
-    that: Sink.Sink<R2, E2, In2, L2, Z2>,
+  <A2, In, In2 extends In, L2, E2, R2>(
+    that: Sink.Sink<A2, In2, L2, E2, R2>,
     options?: {
       readonly concurrent?: boolean | undefined
     }
-  ) => <R, E>(self: Sink.Sink<R, E, In, L, Z>) => Sink.Sink<R2 | R, E2 | E, In & In2, L | L2, Z>,
-  <R, E, R2, E2, In, In2 extends In, L, L2, Z, Z2>(
-    self: Sink.Sink<R, E, In, L, Z>,
-    that: Sink.Sink<R2, E2, In2, L2, Z2>,
+  ) => <A, L, E, R>(self: Sink.Sink<A, In, L, E, R>) => Sink.Sink<A, In & In2, L | L2, E2 | E, R2 | R>,
+  <A, In, L, E, R, A2, In2 extends In, L2, E2, R2>(
+    self: Sink.Sink<A, In, L, E, R>,
+    that: Sink.Sink<A2, In2, L2, E2, R2>,
     options?: {
       readonly concurrent?: boolean | undefined
     }
-  ) => Sink.Sink<R2 | R, E2 | E, In & In2, L | L2, Z>
+  ) => Sink.Sink<A, In & In2, L | L2, E2 | E, R2 | R>
 >(
   (args) => isSink(args[1]),
-  <R, E, R2, E2, In, In2 extends In, L, L2, Z, Z2>(
-    self: Sink.Sink<R, E, In, L, Z>,
-    that: Sink.Sink<R2, E2, In2, L2, Z2>,
+  <A, In, L, E, R, A2, In2 extends In, L2, E2, R2>(
+    self: Sink.Sink<A, In, L, E, R>,
+    that: Sink.Sink<A2, In2, L2, E2, R2>,
     options?: {
       readonly concurrent?: boolean | undefined
     }
-  ): Sink.Sink<R | R2, E | E2, In & In2, L | L2, Z> => zipWith(self, that, (z, _) => z, options)
+  ): Sink.Sink<A, In & In2, L | L2, E2 | E, R2 | R> => zipWith(self, that, (z, _) => z, options)
 )
 
 /** @internal */
 export const zipRight = dual<
-  <R2, E2, In, In2 extends In, L, L2, Z, Z2>(
-    that: Sink.Sink<R2, E2, In2, L2, Z2>,
+  <A2, In, In2 extends In, L2, E2, R2>(
+    that: Sink.Sink<A2, In2, L2, E2, R2>,
     options?: {
       readonly concurrent?: boolean | undefined
     }
-  ) => <R, E>(self: Sink.Sink<R, E, In, L, Z>) => Sink.Sink<R2 | R, E2 | E, In & In2, L | L2, Z2>,
-  <R, E, R2, E2, In, In2 extends In, L, L2, Z, Z2>(
-    self: Sink.Sink<R, E, In, L, Z>,
-    that: Sink.Sink<R2, E2, In2, L2, Z2>,
+  ) => <A, L, E, R>(self: Sink.Sink<A, In, L, E, R>) => Sink.Sink<A2, In & In2, L | L2, E2 | E, R2 | R>,
+  <A, In, L, E, R, A2, In2 extends In, L2, E2, R2>(
+    self: Sink.Sink<A, In, L, E, R>,
+    that: Sink.Sink<A2, In2, L2, E2, R2>,
     options?: {
       readonly concurrent?: boolean | undefined
     }
-  ) => Sink.Sink<R2 | R, E2 | E, In & In2, L | L2, Z2>
+  ) => Sink.Sink<A2, In & In2, L | L2, E2 | E, R2 | R>
 >(
   (args) => isSink(args[1]),
-  <R, E, R2, E2, In, In2 extends In, L, L2, Z, Z2>(
-    self: Sink.Sink<R, E, In, L, Z>,
-    that: Sink.Sink<R2, E2, In2, L2, Z2>,
+  <A, In, L, E, R, A2, In2 extends In, L2, E2, R2>(
+    self: Sink.Sink<A, In, L, E, R>,
+    that: Sink.Sink<A2, In2, L2, E2, R2>,
     options?: {
       readonly concurrent?: boolean | undefined
     }
-  ): Sink.Sink<R | R2, E | E2, In & In2, L | L2, Z2> => zipWith(self, that, (_, z2) => z2, options)
+  ): Sink.Sink<A2, In & In2, L | L2, E2 | E, R2 | R> => zipWith(self, that, (_, z2) => z2, options)
 )
 
 /** @internal */
 export const zipWith = dual<
-  <R2, E2, In, In2 extends In, L, L2, Z, Z2, Z3>(
-    that: Sink.Sink<R2, E2, In2, L2, Z2>,
-    f: (z: Z, z1: Z2) => Z3,
+  <A2, In, In2 extends In, L2, E2, R2, A, A3>(
+    that: Sink.Sink<A2, In2, L2, E2, R2>,
+    f: (a: A, a2: A2) => A3,
     options?: {
       readonly concurrent?: boolean | undefined
     }
-  ) => <R, E>(self: Sink.Sink<R, E, In, L, Z>) => Sink.Sink<R2 | R, E2 | E, In & In2, L | L2, Z3>,
-  <R, E, R2, E2, In, In2 extends In, L, L2, Z, Z2, Z3>(
-    self: Sink.Sink<R, E, In, L, Z>,
-    that: Sink.Sink<R2, E2, In2, L2, Z2>,
-    f: (z: Z, z1: Z2) => Z3,
+  ) => <L, E, R>(self: Sink.Sink<A, In, L, E, R>) => Sink.Sink<A3, In & In2, L | L2, E2 | E, R2 | R>,
+  <A, In, L, E, R, A2, In2 extends In, L2, E2, R2, A3>(
+    self: Sink.Sink<A, In, L, E, R>,
+    that: Sink.Sink<A2, In2, L2, E2, R2>,
+    f: (a: A, a2: A2) => A3,
     options?: {
       readonly concurrent?: boolean | undefined
     }
-  ) => Sink.Sink<R2 | R, E2 | E, In & In2, L | L2, Z3>
+  ) => Sink.Sink<A3, In & In2, L | L2, E2 | E, R2 | R>
 >(
   (args) => isSink(args[1]),
-  <R, E, R2, E2, In, In2 extends In, L, L2, Z, Z2, Z3>(
-    self: Sink.Sink<R, E, In, L, Z>,
-    that: Sink.Sink<R2, E2, In2, L2, Z2>,
-    f: (z: Z, z1: Z2) => Z3,
+  <A, In, L, E, R, A2, In2 extends In, L2, E2, R2, A3>(
+    self: Sink.Sink<A, In, L, E, R>,
+    that: Sink.Sink<A2, In2, L2, E2, R2>,
+    f: (a: A, a2: A2) => A3,
     options?: {
       readonly concurrent?: boolean | undefined
     }
-  ): Sink.Sink<R | R2, E | E2, In & In2, L | L2, Z3> =>
+  ): Sink.Sink<A3, In & In2, L | L2, E2 | E, R2 | R> =>
     options?.concurrent ?
       raceWith(self, {
         other: that,
         onSelfDone: Exit.match({
           onFailure: (cause) => mergeDecision.Done(Effect.failCause(cause)),
           onSuccess: (leftZ) =>
-            mergeDecision.Await<R | R2, E2, Z2, E | E2, Z3>(
+            mergeDecision.Await<R | R2, E2, A2, E | E2, A3>(
               Exit.match({
                 onFailure: Effect.failCause,
                 onSuccess: (rightZ) => Effect.succeed(f(leftZ, rightZ))
@@ -2114,7 +2056,7 @@ export const zipWith = dual<
         onOtherDone: Exit.match({
           onFailure: (cause) => mergeDecision.Done(Effect.failCause(cause)),
           onSuccess: (rightZ) =>
-            mergeDecision.Await<R | R2, E, Z, E | E2, Z3>(
+            mergeDecision.Await<R | R2, E, A, E | E2, A3>(
               Exit.match({
                 onFailure: Effect.failCause,
                 onSuccess: (leftZ) => Effect.succeed(f(leftZ, rightZ))
@@ -2128,20 +2070,20 @@ export const zipWith = dual<
 // Circular with Channel
 
 /** @internal */
-export const channelToSink = <Env, InErr, InElem, OutErr, OutElem, OutDone>(
-  self: Channel.Channel<Env, InErr, Chunk.Chunk<InElem>, unknown, OutErr, Chunk.Chunk<OutElem>, OutDone>
-): Sink.Sink<Env, OutErr, InElem, OutElem, OutDone> => new SinkImpl(self)
+export const channelToSink = <OutElem, InElem, OutErr, InErr, OutDone, Env>(
+  self: Channel.Channel<Chunk.Chunk<OutElem>, Chunk.Chunk<InElem>, OutErr, InErr, OutDone, unknown, Env>
+): Sink.Sink<OutDone, InElem, OutElem, OutErr, Env> => new SinkImpl(self)
 
 // Constants
 
 /** @internal */
-export const count: Sink.Sink<never, never, unknown, never, number> = foldLeftChunks(
+export const count: Sink.Sink<number, unknown> = foldLeftChunks(
   0,
   (acc, chunk) => acc + chunk.length
 )
 
 /** @internal */
-export const mkString: Sink.Sink<never, never, unknown, never, string> = suspend(() => {
+export const mkString: Sink.Sink<string, unknown> = suspend(() => {
   const strings: Array<string> = []
   return pipe(
     foldLeftChunks<void, unknown>(void 0, (_, elems) =>
@@ -2153,7 +2095,7 @@ export const mkString: Sink.Sink<never, never, unknown, never, string> = suspend
 })
 
 /** @internal */
-export const timed: Sink.Sink<never, never, unknown, never, Duration.Duration> = pipe(
+export const timed: Sink.Sink<Duration.Duration, unknown> = pipe(
   withDuration(drain),
   map((tuple) => tuple[1])
 )