@typed/fx 1.22.2 → 1.23.0

package/src/Guard.ts

@@ -10,7 +10,7 @@ import * as Option from "effect/Option"
 /**
  * @since 1.18.0
  */
-export type Guard<in I, out R, out E, out O> = (input: I) => Effect.Effect<R, E, Option.Option<O>>
+export type Guard<in I, out R, out E, out O> = (input: I) => Effect.Effect<Option.Option<O>, E, R>
 
 /**
  * @since 1.18.0
@@ -59,12 +59,12 @@ export const compose: {
  */
 export const mapEffect: {
   <O, R2, E2, B>(
-    f: (o: O) => Effect.Effect<R2, E2, B>
+    f: (o: O) => Effect.Effect<B, E2, R2>
   ): <I, R, E>(guard: Guard<I, R, E, O>) => Guard<I, R | R2, E | E2, B>
-  <I, R, E, O, R2, E2, B>(guard: Guard<I, R, E, O>, f: (o: O) => Effect.Effect<R2, E2, B>): Guard<I, R | R2, E | E2, B>
+  <I, R, E, O, R2, E2, B>(guard: Guard<I, R, E, O>, f: (o: O) => Effect.Effect<B, E2, R2>): Guard<I, R | R2, E | E2, B>
 } = dual(2, function mapEffect<I, R, E, O, R2, E2, B>(
   guard: Guard<I, R, E, O>,
-  f: (o: O) => Effect.Effect<R2, E2, B>
+  f: (o: O) => Effect.Effect<B, E2, R2>
 ): Guard<I, R | R2, E | E2, B> {
   return compose(guard, (o) => Effect.asSome(f(o)))
 })
@@ -87,12 +87,12 @@ export const map: {
  */
 export const tap: {
   <O, R2, E2, B>(
-    f: (o: O) => Effect.Effect<R2, E2, B>
+    f: (o: O) => Effect.Effect<B, E2, R2>
   ): <I, R, E>(guard: Guard<I, R, E, O>) => Guard<I, R | R2, E | E2, O>
-  <I, R, E, O, R2, E2, B>(guard: Guard<I, R, E, O>, f: (o: O) => Effect.Effect<R2, E2, B>): Guard<I, R | R2, E | E2, O>
+  <I, R, E, O, R2, E2, B>(guard: Guard<I, R, E, O>, f: (o: O) => Effect.Effect<B, E2, R2>): Guard<I, R | R2, E | E2, O>
 } = dual(2, function tap<I, R, E, O, R2, E2, B>(
   guard: Guard<I, R, E, O>,
-  f: (o: O) => Effect.Effect<R2, E2, B>
+  f: (o: O) => Effect.Effect<B, E2, R2>
 ): Guard<I, R | R2, E | E2, O> {
   return compose(guard, (o) => Effect.as(f(o), Option.some(o)))
 })

package/src/Idle.ts

@@ -112,7 +112,7 @@ export const defaultIdleScheduler: IdleScheduler = globalValue(
  * @since 1.18.0
  * @category combinators
  */
-export const withIdleScheduler: <R, E, B>(self: Effect.Effect<R, E, B>) => Effect.Effect<R, E, B> = Effect
+export const withIdleScheduler: <R, E, B>(self: Effect.Effect<B, E, R>) => Effect.Effect<B, E, R> = Effect
   .withScheduler(defaultIdleScheduler)
 
 /**
@@ -120,14 +120,14 @@ export const withIdleScheduler: <R, E, B>(self: Effect.Effect<R, E, B>) => Effec
  * @since 1.18.0
  * @category layers
  */
-export const setIdleScheduler: Layer.Layer<never, never, never> = Layer.setScheduler(defaultIdleScheduler)
+export const setIdleScheduler: Layer.Layer<never> = Layer.setScheduler(defaultIdleScheduler)
 
 /**
  * Request to run some work with requestIdleCallback returning an IdleDeadline
  * @since 1.18.0
  * @category scoped
  */
-export const whenIdle = (options?: IdleRequestOptions): Effect.Effect<Scope.Scope, never, IdleDeadline> =>
+export const whenIdle = (options?: IdleRequestOptions): Effect.Effect<IdleDeadline, never, Scope.Scope> =>
   Effect.asyncEffect((resume) => {
     const id = requestIdleCallback((deadline) => resume(Effect.succeed(deadline)), options)
 
@@ -148,8 +148,8 @@ export function shouldContinue(deadline: IdleDeadline): boolean {
  * @category params
  */
 export interface WhileIdleRequestOptions<R, E, R2, E2> extends IdleRequestOptions {
-  readonly while: Effect.Effect<R, E, boolean>
-  readonly body: Effect.Effect<R2, E2, unknown>
+  readonly while: Effect.Effect<boolean, E, R>
+  readonly body: Effect.Effect<unknown, E2, R2>
 }
 
 /**
@@ -158,7 +158,7 @@ export interface WhileIdleRequestOptions<R, E, R2, E2> extends IdleRequestOption
  */
 export const whileIdle = <R, E, R2, E2>(
   options: WhileIdleRequestOptions<R, E, R2, E2>
-): Effect.Effect<Scope.Scope | R | R2, E | E2, void> =>
+): Effect.Effect<void, E | E2, Scope.Scope | R | R2> =>
   Effect.gen(function*(_) {
     while (yield* _(options.while)) {
       const deadline = yield* _(whenIdle(options))
@@ -175,27 +175,27 @@ export const whileIdle = <R, E, R2, E2>(
  */
 export function dequeueWhileIdle<A, R2, E2, B>(
   dequeue: Queue.Dequeue<A>,
-  f: (a: A) => Effect.Effect<R2, E2, B>,
+  f: (a: A) => Effect.Effect<B, E2, R2>,
   options?: IdleRequestOptions
-): Effect.Effect<R2 | Scope.Scope, E2, void>
+): Effect.Effect<void, E2, R2 | Scope.Scope>
 
 export function dequeueWhileIdle<I, A, R2, E2, B>(
   dequeue: Context.Dequeue<I, A>,
-  f: (a: A) => Effect.Effect<R2, E2, B>,
+  f: (a: A) => Effect.Effect<B, E2, R2>,
   options?: IdleRequestOptions
-): Effect.Effect<I | R2 | Scope.Scope, E2, void>
+): Effect.Effect<void, E2, I | R2 | Scope.Scope>
 
 export function dequeueWhileIdle<I = never, A = unknown, R2 = never, E2 = never, B = unknown>(
   dequeue: Context.Dequeue<I, A> | Queue.Dequeue<A>,
-  f: (a: A) => Effect.Effect<R2, E2, B>,
+  f: (a: A) => Effect.Effect<B, E2, R2>,
   options?: IdleRequestOptions
-): Effect.Effect<I | R2 | Scope.Scope, E2, void>
+): Effect.Effect<void, E2, I | R2 | Scope.Scope>
 
 export function dequeueWhileIdle<I, A, R2, E2, B>(
   dequeue: Context.Dequeue<I, A> | Queue.Dequeue<A>,
-  f: (a: A) => Effect.Effect<R2, E2, B>,
+  f: (a: A) => Effect.Effect<B, E2, R2>,
   options?: IdleRequestOptions
-): Effect.Effect<I | R2 | Scope.Scope, E2, void> {
+): Effect.Effect<void, E2, I | R2 | Scope.Scope> {
   return whileIdle({
     while: dequeueIsActive(dequeue),
     body: Effect.flatMap(dequeue.take, f),
@@ -209,10 +209,10 @@ export function dequeueWhileIdle<I, A, R2, E2, B>(
 export interface IdleQueue<I> {
   readonly add: <R>(
     part: I,
-    task: Effect.Effect<R, never, unknown>
-  ) => Effect.Effect<R | Scope.Scope, never, void>
+    task: Effect.Effect<unknown, never, R>
+  ) => Effect.Effect<void, never, R | Scope.Scope>
 
-  readonly interrupt: Effect.Effect<never, never, void>
+  readonly interrupt: Effect.Effect<void>
 }
 
 /**
@@ -220,20 +220,20 @@ export interface IdleQueue<I> {
  */
 export const makeIdleQueue = <I>(
   options?: IdleRequestOptions
-): Effect.Effect<Scope.Scope, never, IdleQueue<I>> =>
+): Effect.Effect<IdleQueue<I>, never, Scope.Scope> =>
   withScope((scope) => Effect.sync(() => new IdleQueueImpl<I>(scope, options)), ExecutionStrategy.sequential)
 
 class IdleQueueImpl<I> implements IdleQueue<I> {
-  queue = new Map<I, Effect.Effect<never, never, unknown>>()
+  queue = new Map<I, Effect.Effect<unknown>>()
   scheduled = false
 
-  readonly interrupt: Effect.Effect<never, never, void>
-  readonly scheduleNextRun: Effect.Effect<never, never, void>
+  readonly interrupt: Effect.Effect<void>
+  readonly scheduleNextRun: Effect.Effect<void>
 
   constructor(readonly scope: Scope.CloseableScope, readonly options?: IdleRequestOptions) {
     this.interrupt = Effect.fiberIdWith((id) => Scope.close(scope, Exit.interrupt(id)))
 
-    const run: Effect.Effect<Scope.Scope, never, void> = Effect.flatMap(
+    const run: Effect.Effect<void, never, Scope.Scope> = Effect.flatMap(
       whenIdle(this.options),
       (deadline) =>
         Effect.gen(this, function*(_) {
@@ -274,7 +274,7 @@ class IdleQueueImpl<I> implements IdleQueue<I> {
     )
   }
 
-  add = <R>(part: I, task: Effect.Effect<R, never, unknown>) =>
+  add = <R>(part: I, task: Effect.Effect<unknown, never, R>) =>
     Effect.contextWithEffect((ctx: Context.Context<R>) => {
       const provided = Effect.provide(task, ctx)
       this.queue.set(part, provided)

package/src/Match.ts

@@ -116,7 +116,7 @@ const variance: Matcher.Variance<any, any, any, any> = {
 
 class When<R, E, I, A, O> {
   constructor(
-    readonly guard: (input: I) => Effect.Effect<R, E, Option.Option<A>>,
+    readonly guard: (input: I) => Effect.Effect<Option.Option<A>, E, R>,
     readonly onMatch: (value: RefSubject.RefSubject<never, never, A>) => Fx.Fx<R, E, O>
   ) {}
 }
@@ -125,8 +125,8 @@ class Matched<R, E, I, A, O> {
   constructor(
     readonly when: When<R, E, I, A, O>,
     readonly ref: RefSubject.RefSubject<never, never, A>,
-    readonly fiber: Fiber.Fiber<never, unknown>,
-    readonly interrupt: Effect.Effect<never, never, void>
+    readonly fiber: Fiber.Fiber<unknown>,
+    readonly interrupt: Effect.Effect<void>
   ) {}
 }
 

package/src/Pull.ts

@@ -19,14 +19,14 @@ import type { Sink } from "./Sink.js"
  * An Effect which can be used to pull values of a Stream.
  * @since 1.18.0
  */
-export interface Pull<out R, out E, out A> extends Effect.Effect<R, Option.Option<E>, Chunk.Chunk<A>> {}
+export interface Pull<out R, out E, out A> extends Effect.Effect<Chunk.Chunk<A>, Option.Option<E>, R> {}
 
 function schedulePull<R, E, A, R2, R3>(
   pull: Pull<R, E, A>,
-  f: (effect: Effect.Effect<R | R3, never, unknown>) => Effect.Effect<R2, never, unknown>,
+  f: (effect: Effect.Effect<unknown, never, R | R3>) => Effect.Effect<unknown, never, R2>,
   sink: Sink<R3, E, A>
-): Effect.Effect<R2, never, void> {
-  return Effect.asyncEffect((resume) =>
+): Effect.Effect<void, never, R2> {
+  return Effect.asyncEffect<void, never, never, void, never, R2>((resume) =>
     pull.pipe(
       Effect.matchCauseEffect({
         onFailure: (cause: Cause.Cause<Option.Option<E>>) =>
@@ -56,18 +56,18 @@ export const schedule: {
   <R2, R3, E, A>(
     schedule: Schedule.Schedule<R2, unknown, unknown>,
     sink: Sink<R3, E, A>
-  ): <R>(pull: Pull<R, E, A>) => Effect.Effect<R | R2 | R3, never, unknown>
+  ): <R>(pull: Pull<R, E, A>) => Effect.Effect<unknown, never, R | R2 | R3>
 
   <R, E, A, R2, R3>(
     pull: Pull<R, E, A>,
     schedule: Schedule.Schedule<R2, unknown, unknown>,
     sink: Sink<R3, E, A>
-  ): Effect.Effect<R | R2 | R3, never, unknown>
+  ): Effect.Effect<unknown, never, R | R2 | R3>
 } = dual(3, function schedule<R, E, A, R2, R3>(
   pull: Pull<R, E, A>,
   schedule: Schedule.Schedule<R2, unknown, unknown>,
   sink: Sink<R3, E, A>
-): Effect.Effect<R | R2 | R3, never, void> {
+): Effect.Effect<void, never, R | R2 | R3> {
   return schedulePull(pull, Effect.schedule(schedule), sink)
 })
 
@@ -80,17 +80,17 @@ export const repeat: {
   <R2, R3, E, A>(
     schedule: Schedule.Schedule<R2, unknown, unknown>,
     sink: Sink<R3, E, A>
-  ): <R>(pull: Pull<R, E, A>) => Effect.Effect<R | R2 | R3, never, unknown>
+  ): <R>(pull: Pull<R, E, A>) => Effect.Effect<unknown, never, R | R2 | R3>
 
   <R, E, A, R2, R3>(
     pull: Pull<R, E, A>,
     schedule: Schedule.Schedule<R2, unknown, unknown>,
     sink: Sink<R3, E, A>
-  ): Effect.Effect<R | R2 | R3, never, unknown>
+  ): Effect.Effect<unknown, never, R | R2 | R3>
 } = dual(3, function repeat<R, E, A, R2, R3>(
   pull: Pull<R, E, A>,
   schedule: Schedule.Schedule<R2, unknown, unknown>,
   sink: Sink<R3, E, A>
-): Effect.Effect<R | R2 | R3, never, void> {
+): Effect.Effect<void, never, R | R2 | R3> {
   return schedulePull(pull, Effect.repeat(schedule), sink)
 })

package/src/Push.ts

@@ -53,15 +53,15 @@ class PushImpl<R, E, A, R2, E2, B> extends FxBase<R2, E2, B> implements Push<R,
     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<R3, E2, B>): 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,16 +99,16 @@ export const mapInput: {
  */
 export const mapInputEffect: {
   <C, R3, E, A>(
-    f: (c: C) => Effect.Effect<R3, E, A>
+    f: (c: C) => Effect.Effect<A, E, R3>
   ): <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>
+    f: (c: C) => Effect.Effect<A, E, R3>
   ): 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>
+  f: (c: C) => Effect.Effect<A, E, R3>
 ): Push<R | R3, E, C, R2, E2, B> {
   return make(
     Sink.mapEffect(push, f),
@@ -138,17 +138,17 @@ 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>(
+  <A, R3, E>(f: (a: A) => Effect.Effect<boolean, E, R3>): <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>
+    f: (a: A) => Effect.Effect<boolean, E, R3>
   ): 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>
+  f: (a: A) => Effect.Effect<boolean, E, R3>
 ): Push<R | R3, E, A, R2, E2, B> {
   return make(
     Sink.filterEffect<R | R3, E, A>(push, f),
@@ -178,16 +178,16 @@ 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>(
+  <C, R3, E, A>(f: (c: C) => Effect.Effect<Option.Option<A>, E, R3>): <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>>
+    f: (c: C) => Effect.Effect<Option.Option<A>, E, R3>
   ): 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>>
+  f: (c: C) => Effect.Effect<Option.Option<A>, E, R3>
 ): Push<R | R3, E, C, R2, E2, B> {
   return make(
     Sink.filterMapEffect(push, f),
@@ -215,16 +215,16 @@ 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>(
+  <B, R3, E3, C>(f: (b: B) => Effect.Effect<C, E3, R3>): <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>
+    f: (b: B) => Effect.Effect<C, E3, R3>
   ): 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>
+  f: (b: B) => Effect.Effect<C, E3, R3>
 ): Push<R, E, A, R2 | R3, E2 | E3, C> {
   return make(
     push,
@@ -252,16 +252,16 @@ 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>(
+  <B, R3, E3>(f: (b: B) => Effect.Effect<boolean, E3, R3>): <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>
+    f: (b: B) => Effect.Effect<boolean, E3, R3>
   ): 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>
+  f: (b: B) => Effect.Effect<boolean, E3, R3>
 ): Push<R, E, A, R2 | R3, E2 | E3, B> {
   return make(
     push,
@@ -291,16 +291,16 @@ 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>(
+  <B, R3, E3, C>(f: (b: B) => Effect.Effect<Option.Option<C>, E3, R3>): <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>>
+    f: (b: B) => Effect.Effect<Option.Option<C>, E3, R3>
   ): 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>>
+  f: (b: B) => Effect.Effect<Option.Option<C>, E3, R3>
 ): Push<R, E, A, R2 | R3, E2 | E3, C> {
   return make(
     push,
@@ -333,16 +333,16 @@ 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>(
+  <B, R3, E3, C>(f: (b: B) => Effect.Effect<C, E3, R3>): <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>
+    f: (b: B) => Effect.Effect<C, E3, R3>
   ): 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>
+  f: (b: B) => Effect.Effect<C, E3, R3>
 ): Push<R, E, A, R2 | R3 | Scope.Scope, E2 | E3, C> {
   return make(
     push,
@@ -375,16 +375,16 @@ 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>(
+  <B, R3, E3, C>(f: (b: B) => Effect.Effect<C, E3, R3>): <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>
+    f: (b: B) => Effect.Effect<C, E3, R3>
   ): 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>
+  f: (b: B) => Effect.Effect<C, E3, R3>
 ): Push<R, E, A, R2 | R3 | Scope.Scope, E2 | E3, C> {
   return make(
     push,
@@ -417,16 +417,16 @@ 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>(
+  <B, R3, E3, C>(f: (b: B) => Effect.Effect<C, E3, R3>): <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>
+    f: (b: B) => Effect.Effect<C, E3, R3>
   ): 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>
+  f: (b: B) => Effect.Effect<C, E3, R3>
 ): Push<R, E, A, R2 | R3 | Scope.Scope, E2 | E3, C> {
   return make(
     push,
@@ -459,16 +459,16 @@ 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>(
+  <B, R3, E3, C>(f: (b: B) => Effect.Effect<C, E3, R3>): <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>
+    f: (b: B) => Effect.Effect<C, E3, R3>
   ): 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>
+  f: (b: B) => Effect.Effect<C, E3, R3>
 ): Push<R, E, A, R2 | R3 | Scope.Scope, E2 | E3, C> {
   return make(
     push,