@typed/fx 1.22.2 → 1.24.0

package/src/Push.ts

@@ -18,8 +18,8 @@ import * as Sink from "./Sink.js"
  * more complex use cases.
  * @since 1.20.0
  */
-export interface Push<out R, in E, in A, out R2, out E2, out B>
-  extends Sink.Sink<R, E, A>, Fx<R2, E2, B>, Pipeable.Pipeable
+export interface Push<in A, in E, out R, out B, out E2, out R2>
+  extends Sink.Sink<A, E, R>, Fx<B, E2, R2>, Pipeable.Pipeable
 {}
 
 /**
@@ -36,32 +36,32 @@ export namespace Push {
  * @since 1.20.0
  */
 export const make: {
-  <R2, E2, B>(fx: Fx<R2, E2, B>): <R, E, A>(sink: Sink.Sink<R, E, A>) => Push<R, E, A, R2, E2, B>
-  <R, E, A, R2, E2, B>(sink: Sink.Sink<R, E, A>, fx: Fx<R2, E2, B>): Push<R, E, A, R2, E2, B>
-} = dual(2, function make<R, E, A, R2, E2, B>(
-  sink: Sink.Sink<R, E, A>,
-  fx: Fx<R2, E2, B>
-): Push<R, E, A, R2, E2, B> {
+  <B, E2, R2>(fx: Fx<B, E2, R2>): <A, E, R>(sink: Sink.Sink<A, E, R>) => Push<A, E, R, B, E2, R2>
+  <A, E, R, B, E2, R2>(sink: Sink.Sink<A, E, R>, fx: Fx<B, E2, R2>): Push<A, E, R, B, E2, R2>
+} = dual(2, function make<A, E, R, B, E2, R2>(
+  sink: Sink.Sink<A, E, R>,
+  fx: Fx<B, E2, R2>
+): Push<A, E, R, B, E2, R2> {
   return new PushImpl(sink, fx)
 })
 
-class PushImpl<R, E, A, R2, E2, B> extends FxBase<R2, E2, B> implements Push<R, E, A, R2, E2, B> {
-  constructor(readonly sink: Sink.Sink<R, E, A>, readonly fx: Fx<R2, E2, B>) {
+class PushImpl<A, E, R, B, E2, R2> extends FxBase<B, E2, R2> implements Push<A, E, R, B, E2, R2> {
+  constructor(readonly sink: Sink.Sink<A, E, R>, readonly fx: Fx<B, E2, R2>) {
     super()
 
     this.onFailure = this.onFailure.bind(this)
     this.onSuccess = this.onSuccess.bind(this)
   }
 
-  run<R3>(sink: Sink.Sink<R3, E2, B>): Effect.Effect<R2 | R3, never, unknown> {
+  run<R3>(sink: Sink.Sink<B, E2, R3>): Effect.Effect<unknown, never, R2 | R3> {
     return this.fx.run(sink)
   }
 
-  onFailure(cause: Cause<E>): Effect.Effect<R, never, unknown> {
+  onFailure(cause: Cause<E>): Effect.Effect<unknown, never, R> {
     return this.sink.onFailure(cause)
   }
 
-  onSuccess(value: A): Effect.Effect<R, never, unknown> {
+  onSuccess(value: A): Effect.Effect<unknown, never, R> {
     return this.sink.onSuccess(value)
   }
 
@@ -99,17 +99,17 @@ export const mapInput: {
  */
 export const mapInputEffect: {
   <C, R3, E, A>(
-    f: (c: C) => Effect.Effect<R3, E, A>
-  ): <R, R2, E2, B>(push: Push<R, E, A, R2, E2, B>) => Push<R | R3, E, C, R2, E2, B>
-
-  <R, E, A, R2, E2, B, R3, C>(
-    push: Push<R, E, A, R2, E2, B>,
-    f: (c: C) => Effect.Effect<R3, E, A>
-  ): Push<R | R3, E, C, R2, E2, B>
-} = dual(2, function mapInputEffect<R, E, A, R2, E2, B, R3, C>(
-  push: Push<R, E, A, R2, E2, B>,
-  f: (c: C) => Effect.Effect<R3, E, A>
-): Push<R | R3, E, C, R2, E2, B> {
+    f: (c: C) => Effect.Effect<A, E, R3>
+  ): <R, B, E2, R2>(push: Push<A, E, R, B, E2, R2>) => Push<C, E, R | R3, B, E2, R2>
+
+  <A, E, R, B, E2, R2, R3, C>(
+    push: Push<A, E, R, B, E2, R2>,
+    f: (c: C) => Effect.Effect<A, E, R3>
+  ): Push<C, E, R | R3, B, E2, R2>
+} = dual(2, function mapInputEffect<A, E, R, B, E2, R2, R3, C>(
+  push: Push<A, E, R, B, E2, R2>,
+  f: (c: C) => Effect.Effect<A, E, R3>
+): Push<C, E, R | R3, B, E2, R2> {
   return make(
     Sink.mapEffect(push, f),
     push
@@ -123,11 +123,11 @@ export const filterInput: {
   <A>(f: (a: A) => boolean): <P extends Push.Any>(
     push: P
   ) => Push<Sink.Context<P>, Sink.Error<P>, A, Fx.Context<P>, Fx.Error<P>, Fx.Success<P>>
-  <R, E, A, R2, E2, B>(push: Push<R, E, A, R2, E2, B>, f: (a: A) => boolean): Push<R, E, A, R2, E2, B>
-} = dual(2, function filterInput<R, E, A, R2, E2, B>(
-  push: Push<R, E, A, R2, E2, B>,
+  <A, E, R, B, E2, R2>(push: Push<A, E, R, B, E2, R2>, f: (a: A) => boolean): Push<A, E, R, B, E2, R2>
+} = dual(2, function filterInput<A, E, R, B, E2, R2>(
+  push: Push<A, E, R, B, E2, R2>,
   f: (a: A) => boolean
-): Push<R, E, A, R2, E2, B> {
+): Push<A, E, R, B, E2, R2> {
   return make(
     Sink.filter(push, f),
     push
@@ -138,20 +138,20 @@ export const filterInput: {
  * @since 1.20.0
  */
 export const filterInputEffect: {
-  <A, R3, E>(f: (a: A) => Effect.Effect<R3, E, boolean>): <R, R2, E2, B>(
-    push: Push<R, E, A, R2, E2, B>
-  ) => Push<R | R3, E, A, R2, E2, B>
-
-  <R, E, A, R2, E2, B, R3>(
-    push: Push<R, E, A, R2, E2, B>,
-    f: (a: A) => Effect.Effect<R3, E, boolean>
-  ): Push<R | R3, E, A, R2, E2, B>
-} = dual(2, function filterInputEffect<R, E, A, R2, E2, B, R3>(
-  push: Push<R, E, A, R2, E2, B>,
-  f: (a: A) => Effect.Effect<R3, E, boolean>
-): Push<R | R3, E, A, R2, E2, B> {
+  <A, R3, E>(f: (a: A) => Effect.Effect<boolean, E, R3>): <R, B, E2, R2>(
+    push: Push<A, E, R, B, E2, R2>
+  ) => Push<A, E, R | R3, B, E2, R2>
+
+  <A, E, R, B, E2, R2, R3>(
+    push: Push<A, E, R, B, E2, R2>,
+    f: (a: A) => Effect.Effect<boolean, E, R3>
+  ): Push<A, E, R | R3, B, E2, R2>
+} = dual(2, function filterInputEffect<A, E, R, B, E2, R2, R3>(
+  push: Push<A, E, R, B, E2, R2>,
+  f: (a: A) => Effect.Effect<boolean, E, R3>
+): Push<A, E, R | R3, B, E2, R2> {
   return make(
-    Sink.filterEffect<R | R3, E, A>(push, f),
+    Sink.filterEffect<A, E, R | R3>(push, f),
     push
   )
 })
@@ -162,12 +162,12 @@ export const filterInputEffect: {
 export const filterMapInput: {
   <C, A>(f: (c: C) => Option.Option<A>): <P extends Push.Any>(
     push: P
-  ) => Push<Sink.Context<P>, Sink.Error<P>, C, Fx.Context<P>, Fx.Error<P>, Fx.Success<P>>
-  <R, E, A, R2, E2, B, C>(push: Push<R, E, A, R2, E2, B>, f: (c: C) => Option.Option<A>): Push<R, E, C, R2, E2, B>
-} = dual(2, function filterMapInput<R, E, A, R2, E2, B, C>(
-  push: Push<R, E, A, R2, E2, B>,
+  ) => Push<C, Sink.Error<P>, Sink.Context<P>, Fx.Success<P>, Fx.Error<P>, Fx.Context<P>>
+  <A, E, R, B, E2, R2, C>(push: Push<A, E, R, B, E2, R2>, f: (c: C) => Option.Option<A>): Push<C, E, R, B, E2, R2>
+} = dual(2, function filterMapInput<A, E, R, B, E2, R2, C>(
+  push: Push<A, E, R, B, E2, R2>,
   f: (c: C) => Option.Option<A>
-): Push<R, E, C, R2, E2, B> {
+): Push<C, E, R, B, E2, R2> {
   return make(
     Sink.filterMap(push, f),
     push
@@ -178,17 +178,17 @@ export const filterMapInput: {
  * @since 1.20.0
  */
 export const filterMapInputEffect: {
-  <C, R3, E, A>(f: (c: C) => Effect.Effect<R3, E, Option.Option<A>>): <R, R2, E2, B>(
-    push: Push<R, E, A, R2, E2, B>
-  ) => Push<R | R3, E, C, R2, E2, B>
-  <R, E, A, R2, E2, B, R3, C>(
-    push: Push<R, E, A, R2, E2, B>,
-    f: (c: C) => Effect.Effect<R3, E, Option.Option<A>>
-  ): Push<R | R3, E, C, R2, E2, B>
-} = dual(2, function filterMapInputEffect<R, E, A, R2, E2, B, R3, C>(
-  push: Push<R, E, A, R2, E2, B>,
-  f: (c: C) => Effect.Effect<R3, E, Option.Option<A>>
-): Push<R | R3, E, C, R2, E2, B> {
+  <C, R3, E, A>(f: (c: C) => Effect.Effect<Option.Option<A>, E, R3>): <R, B, E2, R2>(
+    push: Push<A, E, R, B, E2, R2>
+  ) => Push<C, E, R | R3, B, E2, R2>
+  <A, E, R, B, E2, R2, R3, C>(
+    push: Push<A, E, R, B, E2, R2>,
+    f: (c: C) => Effect.Effect<Option.Option<A>, E, R3>
+  ): Push<C, E, R | R3, B, E2, R2>
+} = dual(2, function filterMapInputEffect<A, E, R, B, E2, R2, R3, C>(
+  push: Push<A, E, R, B, E2, R2>,
+  f: (c: C) => Effect.Effect<Option.Option<A>, E, R3>
+): Push<C, E, R | R3, B, E2, R2> {
   return make(
     Sink.filterMapEffect(push, f),
     push
@@ -199,12 +199,12 @@ export const filterMapInputEffect: {
  * @since 1.20.0
  */
 export const map: {
-  <B, C>(f: (b: B) => C): <R, E, A, R2, E2>(push: Push<R, E, A, R2, E2, B>) => Push<R, E, A, R2, E2, C>
-  <R, E, A, R2, E2, B, C>(push: Push<R, E, A, R2, E2, B>, f: (b: B) => C): Push<R, E, A, R2, E2, C>
-} = dual(2, function map<R, E, A, R2, E2, B, C>(
-  push: Push<R, E, A, R2, E2, B>,
+  <B, C>(f: (b: B) => C): <A, E, R, E2, R2>(push: Push<A, E, R, B, E2, R2>) => Push<A, E, R, C, E2, R2>
+  <A, E, R, B, E2, R2, C>(push: Push<A, E, R, B, E2, R2>, f: (b: B) => C): Push<A, E, R, C, E2, R2>
+} = dual(2, function map<A, E, R, B, E2, R2, C>(
+  push: Push<A, E, R, B, E2, R2>,
   f: (b: B) => C
-): Push<R, E, A, R2, E2, C> {
+): Push<A, E, R, C, E2, R2> {
   return make(
     push,
     core.map(push, f)
@@ -215,17 +215,17 @@ export const map: {
  * @since 1.20.0
  */
 export const mapEffect: {
-  <B, R3, E3, C>(f: (b: B) => Effect.Effect<R3, E3, C>): <R, E, A, R2, E2>(
-    push: Push<R, E, A, R2, E2, B>
-  ) => Push<R, E, A, R2 | R3, E2 | E3, C>
-  <R, E, A, R2, E2, B, R3, E3, C>(
-    push: Push<R, E, A, R2, E2, B>,
-    f: (b: B) => Effect.Effect<R3, E3, C>
-  ): Push<R, E, A, R2 | R3, E2 | E3, C>
-} = dual(2, function mapEffect<R, E, A, R2, E2, B, R3, E3, C>(
-  push: Push<R, E, A, R2, E2, B>,
-  f: (b: B) => Effect.Effect<R3, E3, C>
-): Push<R, E, A, R2 | R3, E2 | E3, C> {
+  <B, C, E3, R3>(f: (b: B) => Effect.Effect<C, E3, R3>): <A, E, R, E2, R2>(
+    push: Push<A, E, R, B, E2, R2>
+  ) => Push<A, E, R, C, E2 | E3, R2 | R3>
+  <A, E, R, B, E2, R2, C, E3, R3>(
+    push: Push<A, E, R, B, E2, R2>,
+    f: (b: B) => Effect.Effect<C, E3, R3>
+  ): Push<A, E, R, C, E2 | E3, R2 | R3>
+} = dual(2, function mapEffect<A, E, R, B, E2, R2, C, E3, R3>(
+  push: Push<A, E, R, B, E2, R2>,
+  f: (b: B) => Effect.Effect<C, E3, R3>
+): Push<A, E, R, C, E2 | E3, R2 | R3> {
   return make(
     push,
     core.mapEffect(push, f)
@@ -236,12 +236,12 @@ export const mapEffect: {
  * @since 1.20.0
  */
 export const filter: {
-  <B>(f: (b: B) => boolean): <R, E, A, R2, E2>(push: Push<R, E, A, R2, E2, B>) => Push<R, E, A, R2, E2, B>
-  <R, E, A, R2, E2, B>(push: Push<R, E, A, R2, E2, B>, f: (b: B) => boolean): Push<R, E, A, R2, E2, B>
-} = dual(2, function filter<R, E, A, R2, E2, B>(
-  push: Push<R, E, A, R2, E2, B>,
+  <B>(f: (b: B) => boolean): <A, E, R, E2, R2>(push: Push<A, E, R, B, E2, R2>) => Push<A, E, R, B, E2, R2>
+  <A, E, R, B, E2, R2>(push: Push<A, E, R, B, E2, R2>, f: (b: B) => boolean): Push<A, E, R, B, E2, R2>
+} = dual(2, function filter<A, E, R, B, E2, R2>(
+  push: Push<A, E, R, B, E2, R2>,
   f: (b: B) => boolean
-): Push<R, E, A, R2, E2, B> {
+): Push<A, E, R, B, E2, R2> {
   return make(
     push,
     core.filter(push, f)
@@ -252,17 +252,17 @@ export const filter: {
  * @since 1.20.0
  */
 export const filterEffect: {
-  <B, R3, E3>(f: (b: B) => Effect.Effect<R3, E3, boolean>): <R, E, A, R2, E2>(
-    push: Push<R, E, A, R2, E2, B>
-  ) => Push<R, E, A, R2 | R3, E2 | E3, B>
-  <R, E, A, R2, E2, B, R3, E3>(
-    push: Push<R, E, A, R2, E2, B>,
-    f: (b: B) => Effect.Effect<R3, E3, boolean>
-  ): Push<R, E, A, R2 | R3, E2 | E3, B>
-} = dual(2, function filterEffect<R, E, A, R2, E2, B, R3, E3>(
-  push: Push<R, E, A, R2, E2, B>,
-  f: (b: B) => Effect.Effect<R3, E3, boolean>
-): Push<R, E, A, R2 | R3, E2 | E3, B> {
+  <B, R3, E3>(f: (b: B) => Effect.Effect<boolean, E3, R3>): <A, E, R, E2, R2>(
+    push: Push<A, E, R, B, E2, R2>
+  ) => Push<A, E, R, B, E2 | E3, R2 | R3>
+  <A, E, R, B, E2, R2, R3, E3>(
+    push: Push<A, E, R, B, E2, R2>,
+    f: (b: B) => Effect.Effect<boolean, E3, R3>
+  ): Push<A, E, R, B, E2 | E3, R2 | R3>
+} = dual(2, function filterEffect<A, E, R, B, E2, R2, R3, E3>(
+  push: Push<A, E, R, B, E2, R2>,
+  f: (b: B) => Effect.Effect<boolean, E3, R3>
+): Push<A, E, R, B, E2 | E3, R2 | R3> {
   return make(
     push,
     core.filterEffect(push, f)
@@ -273,14 +273,14 @@ export const filterEffect: {
  * @since 1.20.0
  */
 export const filterMap: {
-  <B, C>(f: (b: B) => Option.Option<C>): <R, E, A, R2, E2>(
-    push: Push<R, E, A, R2, E2, B>
-  ) => Push<R, E, A, R2, E2, C>
-  <R, E, A, R2, E2, B, C>(push: Push<R, E, A, R2, E2, B>, f: (b: B) => Option.Option<C>): Push<R, E, A, R2, E2, C>
-} = dual(2, function filterMap<R, E, A, R2, E2, B, C>(
-  push: Push<R, E, A, R2, E2, B>,
+  <B, C>(f: (b: B) => Option.Option<C>): <A, E, R, E2, R2>(
+    push: Push<A, E, R, B, E2, R2>
+  ) => Push<A, E, R, C, E2, R2>
+  <A, E, R, B, E2, R2, C>(push: Push<A, E, R, B, E2, R2>, f: (b: B) => Option.Option<C>): Push<A, E, R, C, E2, R2>
+} = dual(2, function filterMap<A, E, R, B, E2, R2, C>(
+  push: Push<A, E, R, B, E2, R2>,
   f: (b: B) => Option.Option<C>
-): Push<R, E, A, R2, E2, C> {
+): Push<A, E, R, C, E2, R2> {
   return make(
     push,
     core.filterMap(push, f)
@@ -291,17 +291,17 @@ export const filterMap: {
  * @since 1.20.0
  */
 export const filterMapEffect: {
-  <B, R3, E3, C>(f: (b: B) => Effect.Effect<R3, E3, Option.Option<C>>): <R, E, A, R2, E2>(
-    push: Push<R, E, A, R2, E2, B>
-  ) => Push<R, E, A, R2 | R3, E2 | E3, C>
-  <R, E, A, R2, E2, B, R3, E3, C>(
-    push: Push<R, E, A, R2, E2, B>,
-    f: (b: B) => Effect.Effect<R3, E3, Option.Option<C>>
-  ): Push<R, E, A, R2 | R3, E2 | E3, C>
-} = dual(2, function filterMapEffect<R, E, A, R2, E2, B, R3, E3, C>(
-  push: Push<R, E, A, R2, E2, B>,
-  f: (b: B) => Effect.Effect<R3, E3, Option.Option<C>>
-): Push<R, E, A, R2 | R3, E2 | E3, C> {
+  <B, C, E3, R3>(f: (b: B) => Effect.Effect<Option.Option<C>, E3, R3>): <A, E, R, E2, R2>(
+    push: Push<A, E, R, B, E2, R2>
+  ) => Push<A, E, R, C, E2 | E3, R2 | R3>
+  <A, E, R, B, E2, R2, C, E3, R3>(
+    push: Push<A, E, R, B, E2, R2>,
+    f: (b: B) => Effect.Effect<Option.Option<C>, E3, R3>
+  ): Push<A, E, R, C, E2 | E3, R2 | R3>
+} = dual(2, function filterMapEffect<A, E, R, B, E2, R2, C, E3, R3>(
+  push: Push<A, E, R, B, E2, R2>,
+  f: (b: B) => Effect.Effect<Option.Option<C>, E3, R3>
+): Push<A, E, R, C, E2 | E3, R2 | R3> {
   return make(
     push,
     core.filterMapEffect(push, f)
@@ -312,17 +312,17 @@ export const filterMapEffect: {
  * @since 1.20.0
  */
 export const switchMap: {
-  <B, R3, E3, C>(f: (b: B) => Fx<R3, E3, C>): <R, E, A, R2, E2>(
-    push: Push<R, E, A, R2, E2, B>
-  ) => Push<R, E, A, Scope.Scope | R2 | R3, E2 | E3, C>
-  <R, E, A, R2, E2, B, R3, E3, C>(
-    push: Push<R, E, A, R2, E2, B>,
-    f: (b: B) => Fx<R3, E3, C>
-  ): Push<R, E, A, Scope.Scope | R2 | R3, E2 | E3, C>
-} = dual(2, function switchMap<R, E, A, R2, E2, B, R3, E3, C>(
-  push: Push<R, E, A, R2, E2, B>,
-  f: (b: B) => Fx<R3, E3, C>
-): Push<R, E, A, R2 | R3 | Scope.Scope, E2 | E3, C> {
+  <B, C, E3, R3>(f: (b: B) => Fx<C, E3, R3>): <A, E, R, E2, R2>(
+    push: Push<A, E, R, B, E2, R2>
+  ) => Push<A, E, R, Scope.Scope | C, E2 | E3, R2 | R3>
+  <A, E, R, B, E2, R2, C, E3, R3>(
+    push: Push<A, E, R, B, E2, R2>,
+    f: (b: B) => Fx<C, E3, R3>
+  ): Push<A, E, R, C, E2 | E3, R2 | R3 | Scope.Scope>
+} = dual(2, function switchMap<A, E, R, B, E2, R2, C, E3, R3>(
+  push: Push<A, E, R, B, E2, R2>,
+  f: (b: B) => Fx<C, E3, R3>
+): Push<A, E, R, C, E2 | E3, R2 | R3 | Scope.Scope> {
   return make(
     push,
     core.switchMap(push, f)
@@ -333,17 +333,17 @@ export const switchMap: {
  * @since 1.20.0
  */
 export const switchMapEffect: {
-  <B, R3, E3, C>(f: (b: B) => Effect.Effect<R3, E3, C>): <R, E, A, R2, E2>(
-    push: Push<R, E, A, R2, E2, B>
-  ) => Push<R, E, A, Scope.Scope | R2 | R3, E2 | E3, C>
-  <R, E, A, R2, E2, B, R3, E3, C>(
-    push: Push<R, E, A, R2, E2, B>,
-    f: (b: B) => Effect.Effect<R3, E3, C>
-  ): Push<R, E, A, Scope.Scope | R2 | R3, E2 | E3, C>
-} = dual(2, function switchMapEffect<R, E, A, R2, E2, B, R3, E3, C>(
-  push: Push<R, E, A, R2, E2, B>,
-  f: (b: B) => Effect.Effect<R3, E3, C>
-): Push<R, E, A, R2 | R3 | Scope.Scope, E2 | E3, C> {
+  <B, C, E3, R3>(f: (b: B) => Effect.Effect<C, E3, R3>): <A, E, R, E2, R2>(
+    push: Push<A, E, R, B, E2, R2>
+  ) => Push<A, E, R, Scope.Scope | C, E2 | E3, R2 | R3>
+  <A, E, R, B, E2, R2, C, E3, R3>(
+    push: Push<A, E, R, B, E2, R2>,
+    f: (b: B) => Effect.Effect<C, E3, R3>
+  ): Push<A, E, R, Scope.Scope | C, E2 | E3, R2 | R3>
+} = dual(2, function switchMapEffect<A, E, R, B, E2, R2, C, E3, R3>(
+  push: Push<A, E, R, B, E2, R2>,
+  f: (b: B) => Effect.Effect<C, E3, R3>
+): Push<A, E, R, C, E2 | E3, R2 | R3 | Scope.Scope> {
   return make(
     push,
     core.switchMapEffect(push, f)
@@ -354,17 +354,17 @@ export const switchMapEffect: {
  * @since 1.20.0
  */
 export const flatMap: {
-  <B, R3, E3, C>(f: (b: B) => Fx<R3, E3, C>): <R, E, A, R2, E2>(
-    push: Push<R, E, A, R2, E2, B>
-  ) => Push<R, E, A, R2 | R3 | Scope.Scope, E2 | E3, C>
-  <R, E, A, R2, E2, B, R3, E3, C>(
-    push: Push<R, E, A, R2, E2, B>,
-    f: (b: B) => Fx<R3, E3, C>
-  ): Push<R, E, A, R2 | R3 | Scope.Scope, E2 | E3, C>
-} = dual(2, function flatMap<R, E, A, R2, E2, B, R3, E3, C>(
-  push: Push<R, E, A, R2, E2, B>,
-  f: (b: B) => Fx<R3, E3, C>
-): Push<R, E, A, R2 | R3 | Scope.Scope, E2 | E3, C> {
+  <B, C, E3, R3>(f: (b: B) => Fx<C, E3, R3>): <A, E, R, E2, R2>(
+    push: Push<A, E, R, B, E2, R2>
+  ) => Push<A, E, R, C, E2 | E3, R2 | R3 | Scope.Scope>
+  <A, E, R, B, E2, R2, C, E3, R3>(
+    push: Push<A, E, R, B, E2, R2>,
+    f: (b: B) => Fx<C, E3, R3>
+  ): Push<A, E, R, C, E2 | E3, R2 | R3 | Scope.Scope>
+} = dual(2, function flatMap<A, E, R, B, E2, R2, C, E3, R3>(
+  push: Push<A, E, R, B, E2, R2>,
+  f: (b: B) => Fx<C, E3, R3>
+): Push<A, E, R, C, E2 | E3, R2 | R3 | Scope.Scope> {
   return make(
     push,
     core.flatMap(push, f)
@@ -375,17 +375,17 @@ export const flatMap: {
  * @since 1.20.0
  */
 export const flatMapEffect: {
-  <B, R3, E3, C>(f: (b: B) => Effect.Effect<R3, E3, C>): <R, E, A, R2, E2>(
-    push: Push<R, E, A, R2, E2, B>
-  ) => Push<R, E, A, R2 | R3 | Scope.Scope, E2 | E3, C>
-  <R, E, A, R2, E2, B, R3, E3, C>(
-    push: Push<R, E, A, R2, E2, B>,
-    f: (b: B) => Effect.Effect<R3, E3, C>
-  ): Push<R, E, A, Scope.Scope | R2 | R3, E2 | E3, C>
-} = dual(2, function flatMapEffect<R, E, A, R2, E2, B, R3, E3, C>(
-  push: Push<R, E, A, R2, E2, B>,
-  f: (b: B) => Effect.Effect<R3, E3, C>
-): Push<R, E, A, R2 | R3 | Scope.Scope, E2 | E3, C> {
+  <B, C, E3, R3>(f: (b: B) => Effect.Effect<C, E3, R3>): <A, E, R, E2, R2>(
+    push: Push<A, E, R, B, E2, R2>
+  ) => Push<A, E, R, C, E2 | E3, R2 | R3 | Scope.Scope>
+  <A, E, R, B, E2, R2, C, E3, R3>(
+    push: Push<A, E, R, B, E2, R2>,
+    f: (b: B) => Effect.Effect<C, E3, R3>
+  ): Push<A, E, R, Scope.Scope | C, E2 | E3, R2 | R3>
+} = dual(2, function flatMapEffect<A, E, R, B, E2, R2, C, E3, R3>(
+  push: Push<A, E, R, B, E2, R2>,
+  f: (b: B) => Effect.Effect<C, E3, R3>
+): Push<A, E, R, C, E2 | E3, R2 | R3 | Scope.Scope> {
   return make(
     push,
     core.flatMapEffect(push, f)
@@ -396,17 +396,17 @@ export const flatMapEffect: {
  * @since 1.20.0
  */
 export const exhaustMap: {
-  <B, R3, E3, C>(f: (b: B) => Fx<R3, E3, C>): <R, E, A, R2, E2>(
-    push: Push<R, E, A, R2, E2, B>
-  ) => Push<R, E, A, R2 | R3 | Scope.Scope, E2 | E3, C>
-  <R, E, A, R2, E2, B, R3, E3, C>(
-    push: Push<R, E, A, R2, E2, B>,
-    f: (b: B) => Fx<R3, E3, C>
-  ): Push<R, E, A, R2 | R3 | Scope.Scope, E2 | E3, C>
-} = dual(2, function exhaustMap<R, E, A, R2, E2, B, R3, E3, C>(
-  push: Push<R, E, A, R2, E2, B>,
-  f: (b: B) => Fx<R3, E3, C>
-): Push<R, E, A, R2 | R3 | Scope.Scope, E2 | E3, C> {
+  <B, C, E3, R3>(f: (b: B) => Fx<C, E3, R3>): <A, E, R, E2, R2>(
+    push: Push<A, E, R, B, E2, R2>
+  ) => Push<A, E, R, C, E2 | E3, R2 | R3 | Scope.Scope>
+  <A, E, R, B, E2, R2, C, E3, R3>(
+    push: Push<A, E, R, B, E2, R2>,
+    f: (b: B) => Fx<C, E3, R3>
+  ): Push<A, E, R, C, E2 | E3, R2 | R3 | Scope.Scope>
+} = dual(2, function exhaustMap<A, E, R, B, E2, R2, C, E3, R3>(
+  push: Push<A, E, R, B, E2, R2>,
+  f: (b: B) => Fx<C, E3, R3>
+): Push<A, E, R, C, E2 | E3, R2 | R3 | Scope.Scope> {
   return make(
     push,
     core.exhaustMap(push, f)
@@ -417,17 +417,17 @@ export const exhaustMap: {
  * @since 1.20.0
  */
 export const exhaustMapEffect: {
-  <B, R3, E3, C>(f: (b: B) => Effect.Effect<R3, E3, C>): <R, E, A, R2, E2>(
-    push: Push<R, E, A, R2, E2, B>
-  ) => Push<R, E, A, R2 | R3 | Scope.Scope, E2 | E3, C>
-  <R, E, A, R2, E2, B, R3, E3, C>(
-    push: Push<R, E, A, R2, E2, B>,
-    f: (b: B) => Effect.Effect<R3, E3, C>
-  ): Push<R, E, A, Scope.Scope | R2 | R3, E2 | E3, C>
-} = dual(2, function exhaustMapEffect<R, E, A, R2, E2, B, R3, E3, C>(
-  push: Push<R, E, A, R2, E2, B>,
-  f: (b: B) => Effect.Effect<R3, E3, C>
-): Push<R, E, A, R2 | R3 | Scope.Scope, E2 | E3, C> {
+  <B, C, E3, R3>(f: (b: B) => Effect.Effect<C, E3, R3>): <A, E, R, E2, R2>(
+    push: Push<A, E, R, B, E2, R2>
+  ) => Push<A, E, R, C, E2 | E3, R2 | R3 | Scope.Scope>
+  <A, E, R, B, E2, R2, C, E3, R3>(
+    push: Push<A, E, R, B, E2, R2>,
+    f: (b: B) => Effect.Effect<C, E3, R3>
+  ): Push<A, E, R, Scope.Scope | C, E2 | E3, R2 | R3>
+} = dual(2, function exhaustMapEffect<A, E, R, B, E2, R2, C, E3, R3>(
+  push: Push<A, E, R, B, E2, R2>,
+  f: (b: B) => Effect.Effect<C, E3, R3>
+): Push<A, E, R, C, E2 | E3, R2 | R3 | Scope.Scope> {
   return make(
     push,
     core.exhaustMapEffect(push, f)
@@ -438,17 +438,17 @@ export const exhaustMapEffect: {
  * @since 1.20.0
  */
 export const exhaustMapLatest: {
-  <B, R3, E3, C>(f: (b: B) => Fx<R3, E3, C>): <R, E, A, R2, E2>(
-    push: Push<R, E, A, R2, E2, B>
-  ) => Push<R, E, A, R2 | R3 | Scope.Scope, E2 | E3, C>
-  <R, E, A, R2, E2, B, R3, E3, C>(
-    push: Push<R, E, A, R2, E2, B>,
-    f: (b: B) => Fx<R3, E3, C>
-  ): Push<R, E, A, R2 | R3 | Scope.Scope, E2 | E3, C>
-} = dual(2, function exhaustMapLatest<R, E, A, R2, E2, B, R3, E3, C>(
-  push: Push<R, E, A, R2, E2, B>,
-  f: (b: B) => Fx<R3, E3, C>
-): Push<R, E, A, R2 | R3 | Scope.Scope, E2 | E3, C> {
+  <B, C, E3, R3>(f: (b: B) => Fx<C, E3, R3>): <A, E, R, E2, R2>(
+    push: Push<A, E, R, B, E2, R2>
+  ) => Push<A, E, R, C, E2 | E3, R2 | R3 | Scope.Scope>
+  <A, E, R, B, E2, R2, C, E3, R3>(
+    push: Push<A, E, R, B, E2, R2>,
+    f: (b: B) => Fx<C, E3, R3>
+  ): Push<A, E, R, C, E2 | E3, R2 | R3 | Scope.Scope>
+} = dual(2, function exhaustMapLatest<A, E, R, B, E2, R2, C, E3, R3>(
+  push: Push<A, E, R, B, E2, R2>,
+  f: (b: B) => Fx<C, E3, R3>
+): Push<A, E, R, C, E2 | E3, R2 | R3 | Scope.Scope> {
   return make(
     push,
     core.exhaustMapLatest(push, f)
@@ -459,17 +459,17 @@ export const exhaustMapLatest: {
  * @since 1.20.0
  */
 export const exhaustMapLatestEffect: {
-  <B, R3, E3, C>(f: (b: B) => Effect.Effect<R3, E3, C>): <R, E, A, R2, E2>(
-    push: Push<R, E, A, R2, E2, B>
-  ) => Push<R, E, A, R2 | R3 | Scope.Scope, E2 | E3, C>
-  <R, E, A, R2, E2, B, R3, E3, C>(
-    push: Push<R, E, A, R2, E2, B>,
-    f: (b: B) => Effect.Effect<R3, E3, C>
-  ): Push<R, E, A, Scope.Scope | R2 | R3, E2 | E3, C>
-} = dual(2, function exhaustMapLatestEffect<R, E, A, R2, E2, B, R3, E3, C>(
-  push: Push<R, E, A, R2, E2, B>,
-  f: (b: B) => Effect.Effect<R3, E3, C>
-): Push<R, E, A, R2 | R3 | Scope.Scope, E2 | E3, C> {
+  <B, C, E3, R3>(f: (b: B) => Effect.Effect<C, E3, R3>): <A, E, R, E2, R2>(
+    push: Push<A, E, R, B, E2, R2>
+  ) => Push<A, E, R, C, E2 | E3, R2 | R3 | Scope.Scope>
+  <A, E, R, B, E2, R2, C, E3, R3>(
+    push: Push<A, E, R, B, E2, R2>,
+    f: (b: B) => Effect.Effect<C, E3, R3>
+  ): Push<A, E, R, Scope.Scope | C, E2 | E3, R2 | R3>
+} = dual(2, function exhaustMapLatestEffect<A, E, R, B, E2, R2, C, E3, R3>(
+  push: Push<A, E, R, B, E2, R2>,
+  f: (b: B) => Effect.Effect<C, E3, R3>
+): Push<A, E, R, C, E2 | E3, R2 | R3 | Scope.Scope> {
   return make(
     push,
     core.exhaustMapLatestEffect(push, f)