@typed/fx 1.22.2 → 1.24.0

package/src/internal/core.ts

@@ -63,56 +63,55 @@ const UNBOUNDED = { concurrency: "unbounded" } as const
 // TODO: expose FxBase and FxEffectBase
 
 export function make<A>(
-  run: (sink: Sink.Sink<never, never, A>) => Effect.Effect<never, never, unknown>
-): Fx<never, never, A>
-export function make<E, A>(run: (sink: Sink.Sink<never, E, A>) => Effect.Effect<never, never, unknown>): Fx<never, E, A>
-export function make<R, E, A>(run: (sink: Sink.Sink<never, E, A>) => Effect.Effect<R, never, unknown>): Fx<R, E, A>
-export function make<R, E, A>(run: (sink: Sink.Sink<never, E, A>) => Effect.Effect<R, never, unknown>): Fx<R, E, A> {
+  run: (sink: Sink.Sink<A>) => Effect.Effect<unknown>
+): Fx<A>
+export function make<A, E>(run: (sink: Sink.Sink<A, E>) => Effect.Effect<unknown>): Fx<A, E>
+export function make<A, E, R>(run: (sink: Sink.Sink<A, E>) => Effect.Effect<unknown, never, R>): Fx<A, E, R>
+export function make<A, E, R>(run: (sink: Sink.Sink<A, E>) => Effect.Effect<unknown, never, R>): Fx<A, E, R> {
   return new Make(run)
 }
 
-class Make<R, E, A> extends FxBase<R, E, A> {
-  constructor(readonly _run: Fx<R, E, A>["run"]) {
+class Make<A, E, R> extends FxBase<A, E, R> {
+  constructor(readonly _run: Fx<A, E, R>["run"]) {
     super()
   }
 
-  run<R2>(sink: Sink.Sink<R2, E, A>): Effect.Effect<R | R2, never, unknown> {
+  run<R2>(sink: Sink.Sink<A, E, R2>): Effect.Effect<unknown, never, R | R2> {
     return Effect.contextWithEffect((ctx) => this._run(Sink.provide(sink, ctx)))
   }
 }
 
-class Producer<A> extends FxBase<never, never, A> {
+class Producer<A> extends FxBase<A, never, never> {
   constructor(readonly i0: SyncProducer.SyncProducer<A>) {
     super()
   }
 
-  run<R2>(sink: Sink.Sink<R2, never, A>): Effect.Effect<R2, never, unknown> {
+  run<R2>(sink: Sink.Sink<A, never, R2>): Effect.Effect<unknown, never, R2> {
     return SyncProducer.runSink(this.i0, sink)
   }
 }
 /**
  * @internal
  */
-export function isProducer<R, E, A>(fx: Fx<R, E, A>): fx is Producer<A> {
+export function isProducer<A, E, R>(fx: Fx<A, E, R>): fx is Producer<A> {
   return fx.constructor === Producer
 }
 
-export const succeed = <A>(value: A): Fx<never, never, A> => new Producer(SyncProducer.Success(value))
+export const succeed = <A>(value: A): Fx<A> => new Producer(SyncProducer.Success(value))
 
-export const fromSync = <A>(f: () => A): Fx<never, never, A> => new Producer(SyncProducer.FromSync(f))
+export const fromSync = <A>(f: () => A): Fx<A> => new Producer(SyncProducer.FromSync(f))
 
-export const fromArray = <const A extends ReadonlyArray<any>>(array: A): Fx<never, never, A[number]> =>
+export const fromArray = <const A extends ReadonlyArray<any>>(array: A): Fx<A[number]> =>
   new Producer(SyncProducer.FromArray(array))
 
-export const fromIterable = <A>(iterable: Iterable<A>): Fx<never, never, A> =>
-  new Producer(SyncProducer.FromIterable(iterable))
+export const fromIterable = <A>(iterable: Iterable<A>): Fx<A> => new Producer(SyncProducer.FromIterable(iterable))
 
-class ProducerEffect<R, E, A> extends FxBase<R, E, A> {
-  constructor(readonly i0: EffectProducer.EffectProducer<R, E, A>) {
+class ProducerEffect<A, E, R> extends FxBase<A, E, R> {
+  constructor(readonly i0: EffectProducer.EffectProducer<A, E, R>) {
     super()
   }
 
-  run<R2>(sink: Sink.Sink<R2, E, A>): Effect.Effect<R | R2, never, unknown> {
+  run<R2>(sink: Sink.Sink<A, E, R2>): Effect.Effect<unknown, never, R | R2> {
     return EffectProducer.runSink(this.i0, sink)
   }
 }
@@ -120,12 +119,12 @@ class ProducerEffect<R, E, A> extends FxBase<R, E, A> {
 /**
  * @internal
  */
-export function isProducerEffect<R, E, A>(fx: Fx<R, E, A>): fx is ProducerEffect<R, E, A> {
+export function isProducerEffect<A, E, R>(fx: Fx<A, E, R>): fx is ProducerEffect<A, E, R> {
   return fx.constructor === ProducerEffect
 }
 
-export const fromEffect = <R, E, A>(effect: Effect.Effect<R, E, A>): Fx<R, E, A> =>
-  matchEffectPrimitive<R, E, A, Fx<R, E, A>>(effect, {
+export const fromEffect = <A, E, R>(effect: Effect.Effect<A, E, R>): Fx<A, E, R> =>
+  matchEffectPrimitive<A, E, R, Fx<A, E, R>>(effect, {
     // Match over Effect primitives and return Fx primitives to allow fusion to take place
     Success: succeed,
     Failure: failCause,
@@ -138,21 +137,21 @@ export const fromEffect = <R, E, A>(effect: Effect.Effect<R, E, A>): Fx<R, E, A>
   })
 
 export const fromScheduled = <R, E, I, R2, O>(
-  input: Effect.Effect<R, E, I>,
+  input: Effect.Effect<I, E, R>,
   schedule: Schedule.Schedule<R2, I, O>
-): Fx<R | R2, E, O> => new ProducerEffect(EffectProducer.FromScheduled(input, schedule))
+): Fx<O, E, R | R2> => new ProducerEffect(EffectProducer.FromScheduled(input, schedule))
 
-export const schedule = <R, E, A, R2, O>(
-  input: Effect.Effect<R, E, A>,
+export const schedule = <A, E, R, R2, O>(
+  input: Effect.Effect<A, E, R>,
   schedule: Schedule.Schedule<R2, unknown, O>
-): Fx<R | R2, E, A> => new ProducerEffect(EffectProducer.Scheduled(input, schedule))
+): Fx<A, E, R | R2> => new ProducerEffect(EffectProducer.Scheduled(input, schedule))
 
 class FailCause<E> extends FxBase<never, E, never> {
   constructor(readonly i0: Cause.Cause<E>) {
     super()
   }
 
-  run<R2>(sink: Sink.Sink<R2, E, never>): Effect.Effect<R2, never, unknown> {
+  run<R2>(sink: Sink.Sink<never, E, R2>): Effect.Effect<unknown, never, R2> {
     return sink.onFailure(this.i0)
   }
 }
@@ -160,26 +159,26 @@ class FailCause<E> extends FxBase<never, E, never> {
 /**
  * @internal
  */
-export function isFailCause<R, E, A>(fx: Fx<R, E, A>): fx is FailCause<E> {
+export function isFailCause<A, E, R>(fx: Fx<A, E, R>): fx is FailCause<E> {
   return fx.constructor === FailCause
 }
 
-export const failCause = <E>(cause: Cause.Cause<E>): Fx<never, E, never> => new FailCause(cause)
+export const failCause = <E>(cause: Cause.Cause<E>): Fx<never, E> => new FailCause(cause)
 
-export const fail = <E>(error: E): Fx<never, E, never> => failCause(Cause.fail(error))
+export const fail = <E>(error: E): Fx<never, E> => failCause(Cause.fail(error))
 
-export const die = (error: unknown): Fx<never, never, never> => failCause(Cause.die(error))
+export const die = (error: unknown): Fx<never> => failCause(Cause.die(error))
 
-class Transformer<R, E, A> extends FxBase<R, E, A> {
-  constructor(readonly i0: Fx<R, E, any>, readonly i1: Op.Operator) {
+class Transformer<A, E, R> extends FxBase<A, E, R> {
+  constructor(readonly i0: Fx<any, E, R>, readonly i1: Op.Operator) {
     super()
   }
 
-  run<R2>(sink: Sink.Sink<R2, E, A>): Effect.Effect<R | R2, never, unknown> {
+  run<R2>(sink: Sink.Sink<A, E, R2>): Effect.Effect<unknown, never, R | R2> {
     return this.i0.run(Op.compileOperatorSink(this.i1, sink))
   }
 
-  static make<R, E, A, R2, E2, B>(fx: Fx<R, E, A>, operator: Op.Operator): Fx<R | R2, E | E2, B> {
+  static make<A, E, R, B, E2, R2>(fx: Fx<A, E, R>, operator: Op.Operator): Fx<B, E | E2, R | R2> {
     if (isEmpty(fx) || isNever(fx)) return fx
     else if (isProducer(fx)) {
       return new ProducerSyncTransformer(fx.i0, operator)
@@ -198,7 +197,7 @@ class Transformer<R, E, A> extends FxBase<R, E, A> {
     } else if (isFailCause(fx)) {
       return fx
     } else {
-      return new Transformer<R, E, B>(fx, operator)
+      return new Transformer<B, E, R>(fx, operator)
     }
   }
 }
@@ -206,16 +205,16 @@ class Transformer<R, E, A> extends FxBase<R, E, A> {
 /**
  * @internal
  */
-export function isTransformer<R, E, A>(fx: Fx<R, E, A>): fx is Transformer<R, E, A> {
+export function isTransformer<A, E, R>(fx: Fx<A, E, R>): fx is Transformer<A, E, R> {
   return fx.constructor === Transformer
 }
 
-class ProducerSyncTransformer<R, E, A> extends FxBase<R, E, A> implements Fx<R, E, A> {
+class ProducerSyncTransformer<A, E, R> extends FxBase<A, E, R> implements Fx<A, E, R> {
   constructor(readonly i0: SyncProducer.SyncProducer<any>, readonly i1: Op.Operator) {
     super()
   }
 
-  run<R2>(sink: Sink.Sink<R2, E, A>): Effect.Effect<R | R2, never, unknown> {
+  run<R2>(sink: Sink.Sink<A, E, R2>): Effect.Effect<unknown, never, R | R2> {
     return SyncProducer.runSink(this.i0, Op.compileOperatorSink(this.i1, sink))
   }
 }
@@ -223,80 +222,80 @@ class ProducerSyncTransformer<R, E, A> extends FxBase<R, E, A> implements Fx<R,
 /**
  * @internal
  */
-export function isProducerSyncTransformer<R, E, A>(fx: Fx<R, E, A>): fx is ProducerSyncTransformer<R, E, A> {
+export function isProducerSyncTransformer<A, E, R>(fx: Fx<A, E, R>): fx is ProducerSyncTransformer<A, E, R> {
   return fx.constructor === ProducerSyncTransformer
 }
 
-export const map = <R, E, A, B>(fx: Fx<R, E, A>, f: (a: A) => B): Fx<R, E, B> => Transformer.make(fx, SyncOp.Map(f))
+export const map = <A, E, R, B>(fx: Fx<A, E, R>, f: (a: A) => B): Fx<B, E, R> => Transformer.make(fx, SyncOp.Map(f))
 
-export const filter = <R, E, A>(fx: Fx<R, E, A>, f: Predicate.Predicate<A>): Fx<R, E, A> =>
+export const filter = <A, E, R>(fx: Fx<A, E, R>, f: Predicate.Predicate<A>): Fx<A, E, R> =>
   Transformer.make(fx, SyncOp.Filter(f))
 
-export const filterMap = <R, E, A, B>(fx: Fx<R, E, A>, f: (a: A) => Option.Option<B>): Fx<R, E, B> =>
+export const filterMap = <A, E, R, B>(fx: Fx<A, E, R>, f: (a: A) => Option.Option<B>): Fx<B, E, R> =>
   Transformer.make(fx, SyncOp.FilterMap(f))
 
-export const mapEffect = <R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (a: A) => Effect.Effect<R2, E2, B>
-): Fx<R | R2, E | E2, B> => Transformer.make(fx, EffectOp.MapEffect(f))
+export const mapEffect = <A, E, R, B, E2, R2>(
+  fx: Fx<A, E, R>,
+  f: (a: A) => Effect.Effect<B, E2, R2>
+): Fx<B, E | E2, R | R2> => Transformer.make(fx, EffectOp.MapEffect(f))
 
-export const filterMapEffect = <R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (a: A) => Effect.Effect<R2, E2, Option.Option<B>>
-): Fx<R | R2, E | E2, B> => Transformer.make(fx, EffectOp.FilterMapEffect(f))
+export const filterMapEffect = <A, E, R, B, E2, R2>(
+  fx: Fx<A, E, R>,
+  f: (a: A) => Effect.Effect<Option.Option<B>, E2, R2>
+): Fx<B, E | E2, R | R2> => Transformer.make(fx, EffectOp.FilterMapEffect(f))
 
-export const filterEffect = <R, E, A, R2, E2>(
-  fx: Fx<R, E, A>,
-  f: (a: A) => Effect.Effect<R2, E2, boolean>
-): Fx<R | R2, E | E2, A> => Transformer.make(fx, EffectOp.FilterEffect(f))
+export const filterEffect = <A, E, R, R2, E2>(
+  fx: Fx<A, E, R>,
+  f: (a: A) => Effect.Effect<boolean, E2, R2>
+): Fx<A, E | E2, R | R2> => Transformer.make(fx, EffectOp.FilterEffect(f))
 
-export const tapEffect = <R, E, A, R2, E2>(
-  fx: Fx<R, E, A>,
-  f: (a: A) => Effect.Effect<R2, E2, unknown>
-): Fx<R | R2, E | E2, A> => Transformer.make(fx, EffectOp.TapEffect(f))
+export const tapEffect = <A, E, R, R2, E2>(
+  fx: Fx<A, E, R>,
+  f: (a: A) => Effect.Effect<unknown, E2, R2>
+): Fx<A, E | E2, R | R2> => Transformer.make(fx, EffectOp.TapEffect(f))
 
-export const loop = <R, E, A, B, C>(fx: Fx<R, E, A>, seed: B, f: (acc: B, a: A) => readonly [C, B]): Fx<R, E, C> =>
+export const loop = <A, E, R, B, C>(fx: Fx<A, E, R>, seed: B, f: (acc: B, a: A) => readonly [C, B]): Fx<C, E, R> =>
   Transformer.make(fx, SyncLoopOp.LoopOperator(seed, f))
 
-export const withPrevious = <R, E, A>(fx: Fx<R, E, A>): Fx<R, E, readonly [Option.Option<A>, A]> =>
+export const withPrevious = <A, E, R>(fx: Fx<A, E, R>): Fx<readonly [Option.Option<A>, A], E, R> =>
   loop(fx, Option.none<A>(), (acc, a) => [[acc, a], Option.some(a)] as const)
 
-export const filterMapLoop = <R, E, A, B, C>(
-  fx: Fx<R, E, A>,
+export const filterMapLoop = <A, E, R, B, C>(
+  fx: Fx<A, E, R>,
   seed: B,
   f: (acc: B, a: A) => readonly [Option.Option<C>, B]
-): Fx<R, E, C> => Transformer.make(fx, SyncLoopOp.FilterMapLoopOperator(seed, f))
+): Fx<C, E, R> => Transformer.make(fx, SyncLoopOp.FilterMapLoopOperator(seed, f))
 
-export const loopEffect = <R, E, A, R2, E2, B, C>(
-  fx: Fx<R, E, A>,
+export const loopEffect = <A, E, R, B, E2, R2, C>(
+  fx: Fx<A, E, R>,
   seed: B,
-  f: (acc: B, a: A) => Effect.Effect<R2, E2, readonly [C, B]>
-): Fx<R | R2, E | E2, C> => Transformer.make(fx, EffectLoopOp.LoopEffectOperator(seed, f))
+  f: (acc: B, a: A) => Effect.Effect<readonly [C, B], E2, R2>
+): Fx<C, E | E2, R | R2> => Transformer.make(fx, EffectLoopOp.LoopEffectOperator(seed, f))
 
-export const filterMapLoopEffect = <R, E, A, R2, E2, B, C>(
-  fx: Fx<R, E, A>,
+export const filterMapLoopEffect = <A, E, R, B, E2, R2, C>(
+  fx: Fx<A, E, R>,
   seed: B,
-  f: (acc: B, a: A) => Effect.Effect<R2, E2, readonly [Option.Option<C>, B]>
-): Fx<R | R2, E | E2, C> => Transformer.make(fx, EffectLoopOp.FilterMapLoopEffectOperator(seed, f))
+  f: (acc: B, a: A) => Effect.Effect<readonly [Option.Option<C>, B], E2, R2>
+): Fx<C, E | E2, R | R2> => Transformer.make(fx, EffectLoopOp.FilterMapLoopEffectOperator(seed, f))
 
-export const observe = <R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (a: A) => Effect.Effect<R2, E2, B>
-): Effect.Effect<R | R2, E | E2, void> => Observe.make(fx, f)
+export const observe = <A, E, R, B, E2, R2>(
+  fx: Fx<A, E, R>,
+  f: (a: A) => Effect.Effect<B, E2, R2>
+): Effect.Effect<void, E | E2, R | R2> => Observe.make(fx, f)
 
 const constUnit = () => Effect.unit
 
-export const drain = <R, E, A>(fx: Fx<R, E, A>): Effect.Effect<R, E, void> => Observe.make(fx, constUnit)
+export const drain = <A, E, R>(fx: Fx<A, E, R>): Effect.Effect<void, E, R> => Observe.make(fx, constUnit)
 
-class Observe<R, E, A, R2, E2, B> extends EffectBase<R | R2, E | E2, void> {
+class Observe<A, E, R, B, E2, R2> extends EffectBase<void, E | E2, R | R2> {
   constructor(
-    readonly i0: Fx<R, E, A>,
-    readonly i1: (a: A) => Effect.Effect<R2, E2, B>
+    readonly i0: Fx<A, E, R>,
+    readonly i1: (a: A) => Effect.Effect<B, E2, R2>
   ) {
     super()
   }
 
-  toEffect(): Effect.Effect<R | R2, E | E2, void> {
+  toEffect(): Effect.Effect<void, E | E2, R | R2> {
     return Effect.asyncEffect((resume) => {
       const { i0: fx, i1: f } = this
       const onFailure = (cause: Cause.Cause<E | E2>) => Effect.sync(() => resume(Effect.failCause(cause)))
@@ -308,10 +307,10 @@ class Observe<R, E, A, R2, E2, B> extends EffectBase<R | R2, E | E2, void> {
     })
   }
 
-  static make<R, E, A, R2, E2, B>(
-    fx: Fx<R, E, A>,
-    f: (a: A) => Effect.Effect<R2, E2, B>
-  ): Effect.Effect<R | R2, E | E2, void> {
+  static make<A, E, R, B, E2, R2>(
+    fx: Fx<A, E, R>,
+    f: (a: A) => Effect.Effect<B, E2, R2>
+  ): Effect.Effect<void, E | E2, R | R2> {
     if (isEmpty(fx)) {
       return Effect.unit
     } else if (isNever(fx)) {
@@ -320,9 +319,9 @@ class Observe<R, E, A, R2, E2, B> extends EffectBase<R | R2, E | E2, void> {
       return SyncProducer.runEffect(fx.i0, f)
     } else if (isProducerSyncTransformer(fx)) {
       return Op.matchOperator(fx.i1, {
-        SyncOperator: (op): Effect.Effect<R | R2, E | E2, void> =>
+        SyncOperator: (op): Effect.Effect<void, E | E2, R | R2> =>
           SyncOp.matchSyncOperator(op, {
-            Map: (op): Effect.Effect<R | R2, E | E2, void> =>
+            Map: (op): Effect.Effect<void, E | E2, R | R2> =>
               SyncProducer.effectOnce(() => SyncProducer.runEffect(fx.i0, (a) => f(op.f(a)))),
             Filter: (op) =>
               SyncProducer.effectOnce(() =>
@@ -338,7 +337,7 @@ class Observe<R, E, A, R2, E2, B> extends EffectBase<R | R2, E | E2, void> {
           }),
         EffectOperator: (op) =>
           EffectOp.matchEffectOperator(op, {
-            MapEffect: (op): Effect.Effect<R | R2, E | E2, void> =>
+            MapEffect: (op): Effect.Effect<void, E | E2, R | R2> =>
               SyncProducer.runEffect(fx.i0, (a) => Effect.flatMap(op.f(a), f)),
             FilterMapEffect: (op) =>
               SyncProducer.runEffect(fx.i0, (a) =>
@@ -394,9 +393,9 @@ class Observe<R, E, A, R2, E2, B> extends EffectBase<R | R2, E | E2, void> {
       return EffectProducer.runEffect(fx.i0, f)
     } else if (isProducerEffectTransformer(fx)) {
       return Op.matchOperator(fx.i1, {
-        SyncOperator: (op): Effect.Effect<R | R2, E | E2, void> =>
+        SyncOperator: (op): Effect.Effect<void, E | E2, R | R2> =>
           SyncOp.matchSyncOperator(op, {
-            Map: (op): Effect.Effect<R | R2, E | E2, void> =>
+            Map: (op): Effect.Effect<void, E | E2, R | R2> =>
               SyncProducer.effectOnce(() => EffectProducer.runEffect(fx.i0, (a) => f(op.f(a)))),
             Filter: (op) =>
               SyncProducer.effectOnce(() =>
@@ -412,7 +411,7 @@ class Observe<R, E, A, R2, E2, B> extends EffectBase<R | R2, E | E2, void> {
           }),
         EffectOperator: (op) =>
           EffectOp.matchEffectOperator(op, {
-            MapEffect: (op): Effect.Effect<R | R2, E | E2, void> =>
+            MapEffect: (op): Effect.Effect<void, E | E2, R | R2> =>
               EffectProducer.runEffect(fx.i0, (a) => Effect.flatMap(op.f(a), f)),
             FilterMapEffect: (op) =>
               EffectProducer.runEffect(fx.i0, (a) =>
@@ -472,15 +471,15 @@ class Observe<R, E, A, R2, E2, B> extends EffectBase<R | R2, E | E2, void> {
   }
 }
 
-export const reduce = <R, E, A, B>(fx: Fx<R, E, A>, seed: B, f: (acc: B, a: A) => B): Effect.Effect<R, E, B> =>
+export const reduce = <A, E, R, B>(fx: Fx<A, E, R>, seed: B, f: (acc: B, a: A) => B): Effect.Effect<B, E, R> =>
   Reduce.make(fx, seed, f)
 
-class Reduce<R, E, A, B> extends EffectBase<R, E, B> {
-  constructor(readonly i0: Fx<R, E, A>, readonly i1: B, readonly i2: (acc: B, a: A) => B) {
+class Reduce<A, E, R, B> extends EffectBase<B, E, R> {
+  constructor(readonly i0: Fx<A, E, R>, readonly i1: B, readonly i2: (acc: B, a: A) => B) {
     super()
   }
 
-  toEffect(): Effect.Effect<R, E, B> {
+  toEffect(): Effect.Effect<B, E, R> {
     return Effect.suspend(() => {
       let acc = this.i1
 
@@ -491,7 +490,7 @@ class Reduce<R, E, A, B> extends EffectBase<R, E, B> {
     })
   }
 
-  static make<R, E, A, B>(fx: Fx<R, E, A>, seed: B, f: (acc: B, a: A) => B) {
+  static make<A, E, R, B>(fx: Fx<A, E, R>, seed: B, f: (acc: B, a: A) => B) {
     // TODO: optimize Effect trasformers
 
     if (isEmpty(fx)) return Effect.succeed(seed)
@@ -557,7 +556,7 @@ class Reduce<R, E, A, B> extends EffectBase<R, E, B> {
   }
 }
 
-export const toReadonlyArray = <R, E, A>(fx: Fx<R, E, A>): Effect.Effect<R, E, ReadonlyArray<A>> =>
+export const toReadonlyArray = <A, E, R>(fx: Fx<A, E, R>): Effect.Effect<ReadonlyArray<A>, E, R> =>
   Effect.suspend(() => {
     const init = [] as Array<A>
     return Reduce.make(fx, init, (acc, a) => {
@@ -566,23 +565,23 @@ export const toReadonlyArray = <R, E, A>(fx: Fx<R, E, A>): Effect.Effect<R, E, R
     })
   })
 
-export const slice = <R, E, A>(fx: Fx<R, E, A>, drop: number, take: number): Fx<R, E, A> =>
+export const slice = <A, E, R>(fx: Fx<A, E, R>, drop: number, take: number): Fx<A, E, R> =>
   Slice.make(fx, boundsFrom(drop, take))
 
-export const take = <R, E, A>(fx: Fx<R, E, A>, n: number): Fx<R, E, A> => slice(fx, 0, n)
+export const take = <A, E, R>(fx: Fx<A, E, R>, n: number): Fx<A, E, R> => slice(fx, 0, n)
 
-export const drop = <R, E, A>(fx: Fx<R, E, A>, n: number): Fx<R, E, A> => slice(fx, n, Infinity)
+export const drop = <A, E, R>(fx: Fx<A, E, R>, n: number): Fx<A, E, R> => slice(fx, n, Infinity)
 
-class Slice<R, E, A> extends FxBase<R, E, A> {
-  constructor(readonly i0: Fx<R, E, A>, readonly i1: Bounds) {
+class Slice<A, E, R> extends FxBase<A, E, R> {
+  constructor(readonly i0: Fx<A, E, R>, readonly i1: Bounds) {
     super()
   }
 
-  run<R2>(sink: Sink.Sink<R2, E, A>): Effect.Effect<R | R2, never, unknown> {
+  run<R2>(sink: Sink.Sink<A, E, R2>): Effect.Effect<unknown, never, R | R2> {
     return Sink.slice(sink, this.i1, (s) => this.i0.run(s))
   }
 
-  static make<R, E, A>(fx: Fx<R, E, A>, bounds: Bounds): Fx<R, E, A> {
+  static make<A, E, R>(fx: Fx<A, E, R>, bounds: Bounds): Fx<A, E, R> {
     if (isNilBounds(bounds)) return empty
     if (isInfiniteBounds(bounds)) return fx
 
@@ -600,14 +599,14 @@ class Slice<R, E, A> extends FxBase<R, E, A> {
 /**
  * @internal
  */
-export function isSlice<R, E, A>(fx: Fx<R, E, A>): fx is Slice<R, E, A> {
+export function isSlice<A, E, R>(fx: Fx<A, E, R>): fx is Slice<A, E, R> {
   return fx.constructor === Slice
 }
 
-export function skipRepeatsWith<R, E, A>(
-  fx: Fx<R, E, A>,
+export function skipRepeatsWith<A, E, R>(
+  fx: Fx<A, E, R>,
   eq: Equivalence.Equivalence<A>
-): Fx<R, E, A> {
+): Fx<A, E, R> {
   return filterMapLoop(fx, Option.none<A>(), (previous, a) => {
     if (Option.isSome(previous) && eq(a, previous.value)) {
       return [Option.none<A>(), Option.some<A>(a)] as const
@@ -617,18 +616,18 @@ export function skipRepeatsWith<R, E, A>(
   })
 }
 
-export function skipRepeats<R, E, A>(
-  fx: Fx<R, E, A>
-): Fx<R, E, A> {
+export function skipRepeats<A, E, R>(
+  fx: Fx<A, E, R>
+): Fx<A, E, R> {
   return skipRepeatsWith(fx, Equal.equals)
 }
 
-class ProducerEffectTransformer<R, E, A, R2, E2, B> extends FxBase<R | R2, E | E2, B> {
-  constructor(readonly i0: EffectProducer.EffectProducer<R, E, A>, readonly i1: Op.Operator) {
+class ProducerEffectTransformer<A, E, R, B, E2, R2> extends FxBase<B, E | E2, R | R2> {
+  constructor(readonly i0: EffectProducer.EffectProducer<A, E, R>, readonly i1: Op.Operator) {
     super()
   }
 
-  run<R3>(sink: Sink.Sink<R3, E | E2, B>): Effect.Effect<R | R2 | R3, never, unknown> {
+  run<R3>(sink: Sink.Sink<B, E | E2, R3>): Effect.Effect<unknown, never, R | R2 | R3> {
     return EffectProducer.runSink(this.i0, Op.compileOperatorSink(this.i1, sink))
   }
 }
@@ -636,14 +635,14 @@ class ProducerEffectTransformer<R, E, A, R2, E2, B> extends FxBase<R | R2, E | E
 /**
  * @internal
  */
-export function isProducerEffectTransformer<R, E, A>(
-  fx: Fx<R, E, A>
-): fx is ProducerEffectTransformer<R, E, any, R, E, A> {
+export function isProducerEffectTransformer<A, E, R>(
+  fx: Fx<A, E, R>
+): fx is ProducerEffectTransformer<A, E, R, A, E, R> {
   return fx.constructor === ProducerEffectTransformer
 }
 
 class Empty extends FxBase<never, never, never> {
-  run<R2>(): Effect.Effect<R2, never, unknown> {
+  run<R2>(): Effect.Effect<unknown, never, R2> {
     return Effect.unit
   }
 }
@@ -651,14 +650,14 @@ class Empty extends FxBase<never, never, never> {
 /**
  * @internal
  */
-export function isEmpty<R, E, A>(fx: Fx<R, E, A>): fx is Empty {
+export function isEmpty<A, E, R>(fx: Fx<A, E, R>): fx is Empty {
   return fx.constructor === Empty
 }
 
-export const empty: Fx<never, never, never> = new Empty()
+export const empty: Fx<never> = new Empty()
 
 class Never extends FxBase<never, never, never> {
-  run<R2>(): Effect.Effect<R2, never, unknown> {
+  run<R2>(): Effect.Effect<unknown, never, R2> {
     return Effect.never
   }
 }
@@ -666,43 +665,43 @@ class Never extends FxBase<never, never, never> {
 /**
  * @internal
  */
-export function isNever<R, E, A>(fx: Fx<R, E, A>): fx is Never {
+export function isNever<A, E, R>(fx: Fx<A, E, R>): fx is Never {
   return fx.constructor === Never
 }
 
-export const never: Fx<never, never, never> = new Never()
+export const never: Fx<never> = new Never()
 
-export function padWith<R, E, A, B, C>(
-  fx: Fx<R, E, A>,
+export function padWith<A, E, R, B, C>(
+  fx: Fx<A, E, R>,
   start: Iterable<B>,
   end: Iterable<C>
-): Fx<R, E, A | B | C> {
+): Fx<A | B | C, E, R> {
   return new PadWith(fx, start, end)
 }
 
-export function prependAll<R, E, A, B>(
-  fx: Fx<R, E, A>,
+export function prependAll<A, E, R, B>(
+  fx: Fx<A, E, R>,
   start: Iterable<B>
-): Fx<R, E, A | B> {
+): Fx<A | B, E, R> {
   return new PadWith(fx, start, [])
 }
 
-export function appendAll<R, E, A, C>(
-  fx: Fx<R, E, A>,
+export function appendAll<A, E, R, C>(
+  fx: Fx<A, E, R>,
   end: Iterable<C>
-): Fx<R, E, A | C> {
+): Fx<A | C, E, R> {
   return new PadWith(fx, [], end)
 }
 
-export function prepend<R, E, A, B>(fx: Fx<R, E, A>, start: B): Fx<R, E, A | B> {
+export function prepend<A, E, R, B>(fx: Fx<A, E, R>, start: B): Fx<A | B, E, R> {
   return new PadWith(fx, [start], [])
 }
 
-export function append<R, E, A, C>(fx: Fx<R, E, A>, end: C): Fx<R, E, A | C> {
-  return new PadWith<R, E, A, never, C>(fx, [], [end])
+export function append<A, E, R, C>(fx: Fx<A, E, R>, end: C): Fx<A | C, E, R> {
+  return new PadWith<A, E, R, never, C>(fx, [], [end])
 }
 
-export function scan<R, E, A, B>(fx: Fx<R, E, A>, seed: B, f: (b: B, a: A) => B): Fx<R, E, B> {
+export function scan<A, E, R, B>(fx: Fx<A, E, R>, seed: B, f: (b: B, a: A) => B): Fx<B, E, R> {
   return prepend(
     loop(fx, seed, (b, a) => {
       const b2 = f(b, a)
@@ -713,17 +712,17 @@ export function scan<R, E, A, B>(fx: Fx<R, E, A>, seed: B, f: (b: B, a: A) => B)
 }
 
 class PadWith<
-  R,
-  E,
   A,
+  E,
+  R,
   B,
   C
-> extends FxBase<R, E, A | B | C> {
-  constructor(readonly i0: Fx<R, E, A>, readonly i1: Iterable<B>, readonly i2: Iterable<C>) {
+> extends FxBase<A | B | C, E, R> {
+  constructor(readonly i0: Fx<A, E, R>, readonly i1: Iterable<B>, readonly i2: Iterable<C>) {
     super()
   }
 
-  run<R2>(sink: Sink.Sink<R2, E, A | B | C>): Effect.Effect<R | R2, never, unknown> {
+  run<R2>(sink: Sink.Sink<A | B | C, E, R2>): Effect.Effect<unknown, never, R | R2> {
     const onSuccess = (a: A | B | C) => sink.onSuccess(a)
 
     return Effect.forEach(this.i1, onSuccess, DISCARD).pipe(
@@ -732,11 +731,11 @@ class PadWith<
     )
   }
 
-  static make<R, E, A, B, C>(
-    fx: Fx<R, E, A>,
+  static make<A, E, R, B, C>(
+    fx: Fx<A, E, R>,
     start: Iterable<B>,
     end: Iterable<C>
-  ): Fx<R, E, A | B | C> {
+  ): Fx<A | B | C, E, R> {
     if (isEmpty(fx) || isNever(fx)) return fx
     else if (isPadWith(fx)) {
       return new PadWith(fx.i0, concat(start, fx.i1), concat(fx.i2, end))
@@ -758,74 +757,74 @@ function concat<A, B>(a: Iterable<A>, b: Iterable<B>): Iterable<A | B> {
 /**
  * @internal
  */
-export function isPadWith<R, E, A>(
-  fx: Fx<R, E, A>
-): fx is PadWith<R, E, A, A, A> {
+export function isPadWith<A, E, R>(
+  fx: Fx<A, E, R>
+): fx is PadWith<A, E, R, A, A> {
   return fx.constructor === PadWith
 }
 
-export function flatMapWithStrategy<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (a: A) => Fx<R2, E2, B>,
+export function flatMapWithStrategy<A, E, R, B, E2, R2>(
+  fx: Fx<A, E, R>,
+  f: (a: A) => Fx<B, E2, R2>,
   strategy: FlattenStrategy,
   executionStrategy: ExecutionStrategy.ExecutionStrategy = ExecutionStrategy.sequential
-): Fx<R | R2 | Scope.Scope, E | E2, B> {
+): Fx<B, E | E2, R | R2 | Scope.Scope> {
   return FlatMapWithStrategy.make(fx, f, strategy, executionStrategy)
 }
 
-export function switchMap<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (a: A) => Fx<R2, E2, B>,
+export function switchMap<A, E, R, B, E2, R2>(
+  fx: Fx<A, E, R>,
+  f: (a: A) => Fx<B, E2, R2>,
   executionStrategy?: ExecutionStrategy.ExecutionStrategy
-): Fx<R | R2 | Scope.Scope, E | E2, B> {
+): Fx<B, E | E2, R | R2 | Scope.Scope> {
   return flatMapWithStrategy(fx, f, Switch, executionStrategy)
 }
 
-export function switchMapEffect<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (a: A) => Effect.Effect<R2, E2, B>,
+export function switchMapEffect<A, E, R, B, E2, R2>(
+  fx: Fx<A, E, R>,
+  f: (a: A) => Effect.Effect<B, E2, R2>,
   executionStrategy?: ExecutionStrategy.ExecutionStrategy
-): Fx<R | R2 | Scope.Scope, E | E2, B> {
+): Fx<B, E | E2, R | R2 | Scope.Scope> {
   return switchMap(fx, (a) => fromEffect(f(a)), executionStrategy)
 }
 
-export function exhaustMap<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (a: A) => Fx<R2, E2, B>,
+export function exhaustMap<A, E, R, B, E2, R2>(
+  fx: Fx<A, E, R>,
+  f: (a: A) => Fx<B, E2, R2>,
   executionStrategy?: ExecutionStrategy.ExecutionStrategy
-): Fx<R | R2 | Scope.Scope, E | E2, B> {
+): Fx<B, E | E2, R | R2 | Scope.Scope> {
   return flatMapWithStrategy(fx, f, Exhaust, executionStrategy)
 }
 
-export function exhaustMapEffect<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (a: A) => Effect.Effect<R2, E2, B>,
+export function exhaustMapEffect<A, E, R, B, E2, R2>(
+  fx: Fx<A, E, R>,
+  f: (a: A) => Effect.Effect<B, E2, R2>,
   executionStrategy?: ExecutionStrategy.ExecutionStrategy
-): Fx<R | R2 | Scope.Scope, E | E2, B> {
+): Fx<B, E | E2, R | R2 | Scope.Scope> {
   return exhaustMap(fx, (a) => fromEffect(f(a)), executionStrategy)
 }
 
-export function exhaustMapLatest<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (a: A) => Fx<R2, E2, B>,
+export function exhaustMapLatest<A, E, R, B, E2, R2>(
+  fx: Fx<A, E, R>,
+  f: (a: A) => Fx<B, E2, R2>,
   executionStrategy?: ExecutionStrategy.ExecutionStrategy
-): Fx<R | R2 | Scope.Scope, E | E2, B> {
+): Fx<B, E | E2, R | R2 | Scope.Scope> {
   return flatMapWithStrategy(fx, f, ExhaustLatest, executionStrategy)
 }
 
-export function exhaustMapLatestEffect<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (a: A) => Effect.Effect<R2, E2, B>,
+export function exhaustMapLatestEffect<A, E, R, B, E2, R2>(
+  fx: Fx<A, E, R>,
+  f: (a: A) => Effect.Effect<B, E2, R2>,
   executionStrategy?: ExecutionStrategy.ExecutionStrategy
-): Fx<R | R2 | Scope.Scope, E | E2, B> {
+): Fx<B, E | E2, R | R2 | Scope.Scope> {
   return exhaustMapLatest(fx, (a) => fromEffect(f(a)), executionStrategy)
 }
 
-export function exhaustFilterMapLatestEffect<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (a: A) => Effect.Effect<R2, E2, Option.Option<B>>,
+export function exhaustFilterMapLatestEffect<A, E, R, B, E2, R2>(
+  fx: Fx<A, E, R>,
+  f: (a: A) => Effect.Effect<Option.Option<B>, E2, R2>,
   executionStrategy?: ExecutionStrategy.ExecutionStrategy
-): Fx<R | R2 | Scope.Scope, E | E2, B> {
+): Fx<B, E | E2, R | R2 | Scope.Scope> {
   return exhaustMapLatest(fx, (a) =>
     fromFxEffect(Effect.map(
       f(a),
@@ -836,67 +835,67 @@ export function exhaustFilterMapLatestEffect<R, E, A, R2, E2, B>(
     )), executionStrategy)
 }
 
-export function flatMapConcurrently<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (a: A) => Fx<R2, E2, B>,
+export function flatMapConcurrently<A, E, R, B, E2, R2>(
+  fx: Fx<A, E, R>,
+  f: (a: A) => Fx<B, E2, R2>,
   capacity: number,
   executionStrategy?: ExecutionStrategy.ExecutionStrategy
-): Fx<R | R2 | Scope.Scope, E | E2, B> {
+): Fx<B, E | E2, R | R2 | Scope.Scope> {
   return flatMapWithStrategy(fx, f, Bounded(capacity), executionStrategy)
 }
 
-export function concatMap<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (a: A) => Fx<R2, E2, B>,
+export function concatMap<A, E, R, B, E2, R2>(
+  fx: Fx<A, E, R>,
+  f: (a: A) => Fx<B, E2, R2>,
   executionStrategy?: ExecutionStrategy.ExecutionStrategy
-): Fx<R | R2 | Scope.Scope, E | E2, B> {
+): Fx<B, E | E2, R | R2 | Scope.Scope> {
   return flatMapConcurrently(fx, f, 1, executionStrategy)
 }
 
-export function flatMapConcurrentlyEffect<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (a: A) => Effect.Effect<R2, E2, B>,
+export function flatMapConcurrentlyEffect<A, E, R, B, E2, R2>(
+  fx: Fx<A, E, R>,
+  f: (a: A) => Effect.Effect<B, E2, R2>,
   capacity: number,
   executionStrategy?: ExecutionStrategy.ExecutionStrategy
-): Fx<R | R2 | Scope.Scope, E | E2, B> {
+): Fx<B, E | E2, R | R2 | Scope.Scope> {
   return flatMapConcurrently(fx, (a) => fromEffect(f(a)), capacity, executionStrategy)
 }
 
-export function flatMap<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (a: A) => Fx<R2, E2, B>,
+export function flatMap<A, E, R, B, E2, R2>(
+  fx: Fx<A, E, R>,
+  f: (a: A) => Fx<B, E2, R2>,
   executionStrategy?: ExecutionStrategy.ExecutionStrategy
-): Fx<R | R2 | Scope.Scope, E | E2, B> {
+): Fx<B, E | E2, R | R2 | Scope.Scope> {
   return flatMapWithStrategy(fx, f, Unbounded, executionStrategy)
 }
 
-export function flatMapEffect<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (a: A) => Effect.Effect<R2, E2, B>,
+export function flatMapEffect<A, E, R, B, E2, R2>(
+  fx: Fx<A, E, R>,
+  f: (a: A) => Effect.Effect<B, E2, R2>,
   executionStrategy?: ExecutionStrategy.ExecutionStrategy
-): Fx<R | R2 | Scope.Scope, E | E2, B> {
+): Fx<B, E | E2, R | R2 | Scope.Scope> {
   return flatMap(fx, (a) => fromEffect(f(a)), executionStrategy)
 }
 
 class FlatMapWithStrategy<
-  R,
-  E,
   A,
+  E,
+  R,
   R2,
   E2,
   B
-> extends FxBase<R | R2 | Scope.Scope, E | E2, B> {
-  private withFork: <R, E, A>(
+> extends FxBase<B, E | E2, R | R2 | Scope.Scope> {
+  private withFork: <A, E, R>(
     f: (
       fork: FxFork,
       scope: Scope.Scope
-    ) => Effect.Effect<R, E, A>,
+    ) => Effect.Effect<A, E, R>,
     executionStrategy: ExecutionStrategy.ExecutionStrategy
-  ) => Effect.Effect<Scope.Scope | R, E, void>
+  ) => Effect.Effect<void, E, Scope.Scope | R>
 
   constructor(
-    readonly i0: Fx<R, E, A>,
-    readonly i1: (a: A) => Fx<R2, E2, B>,
+    readonly i0: Fx<A, E, R>,
+    readonly i1: (a: A) => Fx<B, E2, R2>,
     readonly i2: FlattenStrategy,
     readonly i3: ExecutionStrategy.ExecutionStrategy
   ) {
@@ -905,7 +904,7 @@ class FlatMapWithStrategy<
     this.withFork = withFlattenStrategy(i2)
   }
 
-  run<R3>(sink: Sink.Sink<R3, E | E2, B>): Effect.Effect<R | R2 | R3 | Scope.Scope, never, unknown> {
+  run<R3>(sink: Sink.Sink<B, E | E2, R3>): Effect.Effect<unknown, never, R | R2 | R3 | Scope.Scope> {
     return this.withFork(
       (fork) =>
         Sink.withEarlyExit(sink, (sink) =>
@@ -919,9 +918,9 @@ class FlatMapWithStrategy<
     )
   }
 
-  static make<R, E, A, R2, E2, B>(
-    fx: Fx<R, E, A>,
-    f: (a: A) => Fx<R2, E2, B>,
+  static make<A, E, R, B, E2, R2>(
+    fx: Fx<A, E, R>,
+    f: (a: A) => Fx<B, E2, R2>,
     strategy: FlattenStrategy,
     executionStrategy: ExecutionStrategy.ExecutionStrategy
   ) {
@@ -958,9 +957,9 @@ class FlatMapWithStrategy<
   }
 }
 
-export function fromFxEffect<R, E, R2, E2, B>(
-  effect: Effect.Effect<R, E, Fx<R2, E2, B>>
-): Fx<R | R2, E | E2, B> {
+export function fromFxEffect<B, E, R, E2, R2>(
+  effect: Effect.Effect<Fx<B, E2, R2>, E, R>
+): Fx<B, E | E2, R | R2> {
   return new FromFxEffect(effect)
 }
 
@@ -970,12 +969,12 @@ class FromFxEffect<
   R2,
   E2,
   B
-> extends FxBase<R | R2, E | E2, B> {
-  constructor(readonly i0: Effect.Effect<R, E, Fx<R2, E2, B>>) {
+> extends FxBase<B, E | E2, R | R2> {
+  constructor(readonly i0: Effect.Effect<Fx<B, E2, R2>, E, R>) {
     super()
   }
 
-  run<R3>(sink: Sink.Sink<R3, E | E2, B>): Effect.Effect<R | R2 | R3, never, unknown> {
+  run<R3>(sink: Sink.Sink<B, E | E2, R3>): Effect.Effect<unknown, never, R | R2 | R3> {
     return Effect.matchCauseEffect(this.i0, {
       onFailure: (cause) => sink.onFailure(cause),
       onSuccess: (fx) => fx.run(sink)
@@ -986,9 +985,9 @@ class FromFxEffect<
 export function gen<Y extends Effect.EffectGen<any, any, any>, FX extends Fx<any, any, any>>(
   f: (_: Effect.Adapter) => Generator<Y, FX, any>
 ): Fx<
-  Effect.Effect.Context<Y["value"]> | Fx.Context<FX>,
+  Fx.Success<FX>,
   Effect.Effect.Error<Y["value"]> | Fx.Error<FX>,
-  Fx.Success<FX>
+  Effect.Effect.Context<Y["value"]> | Fx.Context<FX>
 > {
   return fromFxEffect(Effect.gen(f))
 }
@@ -996,40 +995,40 @@ export function gen<Y extends Effect.EffectGen<any, any, any>, FX extends Fx<any
 export function genScoped<Y extends Effect.EffectGen<any, any, any>, FX extends Fx<any, any, any>>(
   f: (_: Effect.Adapter) => Generator<Y, FX, any>
 ): Fx<
-  Exclude<Effect.Effect.Context<Y["value"]> | Fx.Context<FX>, Scope.Scope>,
+  Fx.Success<FX>,
   Effect.Effect.Error<Y["value"]> | Fx.Error<FX>,
-  Fx.Success<FX>
+  Exclude<Effect.Effect.Context<Y["value"]> | Fx.Context<FX>, Scope.Scope>
 > {
   return scoped(fromFxEffect(Effect.gen(f)))
 }
 
-export function continueWith<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: () => Fx<R2, E2, B>
-): Fx<R | R2, E | E2, A | B> {
+export function continueWith<A, E, R, B, E2, R2>(
+  fx: Fx<A, E, R>,
+  f: () => Fx<B, E2, R2>
+): Fx<A | B, E | E2, R | R2> {
   return ContinueWith.make(fx, f)
 }
 
 class ContinueWith<
-  R,
-  E,
   A,
+  E,
+  R,
   R2,
   E2,
   B
-> extends FxBase<R | R2, E | E2, A | B> {
-  constructor(readonly i0: Fx<R, E, A>, readonly i1: () => Fx<R2, E2, B>) {
+> extends FxBase<A | B, E | E2, R | R2> {
+  constructor(readonly i0: Fx<A, E, R>, readonly i1: () => Fx<B, E2, R2>) {
     super()
   }
 
-  run<R3>(sink: Sink.Sink<R3, E | E2, A | B>): Effect.Effect<R | R2 | R3, never, unknown> {
+  run<R3>(sink: Sink.Sink<A | B, E | E2, R3>): Effect.Effect<unknown, never, R | R2 | R3> {
     return Effect.flatMap(this.i0.run(sink), () => this.i1().run(sink))
   }
 
-  static make<R, E, A, R2, E2, B>(
-    fx: Fx<R, E, A>,
-    f: () => Fx<R2, E2, B>
-  ): Fx<R | R2, E | E2, A | B> {
+  static make<A, E, R, B, E2, R2>(
+    fx: Fx<A, E, R>,
+    f: () => Fx<B, E2, R2>
+  ): Fx<A | B, E | E2, R | R2> {
     if (isEmpty(fx)) return f()
     else if (isNever(fx)) return fx
     else if (isProducer(fx)) {
@@ -1045,33 +1044,33 @@ class ContinueWith<
   }
 }
 
-export function orElseCause<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>
-): Fx<R | R2, E2, A | B> {
+export function orElseCause<A, E, R, B, E2, R2>(
+  fx: Fx<A, E, R>,
+  f: (cause: Cause.Cause<E>) => Fx<B, E2, R2>
+): Fx<A | B, E2, R | R2> {
   return OrElseCause.make(fx, f)
 }
 
 class OrElseCause<
-  R,
-  E,
   A,
+  E,
+  R,
   R2,
   E2,
   B
-> extends FxBase<R | R2, E2, A | B> {
-  constructor(readonly i0: Fx<R, E, A>, readonly i1: (cause: Cause.Cause<E>) => Fx<R2, E2, B>) {
+> extends FxBase<A | B, E2, R | R2> {
+  constructor(readonly i0: Fx<A, E, R>, readonly i1: (cause: Cause.Cause<E>) => Fx<B, E2, R2>) {
     super()
   }
 
-  run<R3>(sink: Sink.Sink<R3, E | E2, A | B>): Effect.Effect<R | R2 | R3, never, unknown> {
+  run<R3>(sink: Sink.Sink<A | B, E | E2, R3>): Effect.Effect<unknown, never, R | R2 | R3> {
     return Effect.catchAllCause(observe(this.i0, sink.onSuccess), (cause) => this.i1(cause).run(sink))
   }
 
-  static make<R, E, A, R2, E2, B>(
-    fx: Fx<R, E, A>,
-    f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>
-  ): Fx<R | R2, E2, A | B> {
+  static make<A, E, R, B, E2, R2>(
+    fx: Fx<A, E, R>,
+    f: (cause: Cause.Cause<E>) => Fx<B, E2, R2>
+  ): Fx<A | B, E2, R | R2> {
     if (isEmpty(fx)) return fx
     else if (isNever(fx)) return fx
     else {
@@ -1080,28 +1079,28 @@ class OrElseCause<
   }
 }
 
-export function orElse<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (error: E) => Fx<R2, E2, B>
-): Fx<R | R2, E2, A | B> {
+export function orElse<A, E, R, B, E2, R2>(
+  fx: Fx<A, E, R>,
+  f: (error: E) => Fx<B, E2, R2>
+): Fx<A | B, E2, R | R2> {
   return OrElse.make(fx, f)
 }
 
 class OrElse<
-  R,
-  E,
   A,
+  E,
+  R,
   R2,
   E2,
   B
-> extends FxBase<R | R2, E2, A | B> {
-  constructor(readonly i0: Fx<R, E, A>, readonly i1: (error: E) => Fx<R2, E2, B>) {
+> extends FxBase<A | B, E2, R | R2> {
+  constructor(readonly i0: Fx<A, E, R>, readonly i1: (error: E) => Fx<B, E2, R2>) {
     super()
   }
 
-  run<R3>(sink: Sink.Sink<R3, E | E2, A | B>): Effect.Effect<R | R2 | R3, never, unknown> {
+  run<R3>(sink: Sink.Sink<A | B, E | E2, R3>): Effect.Effect<unknown, never, R | R2 | R3> {
     return Effect.catchAll(
-      Effect.asyncEffect<never, E, void, R | R2 | R3, never, unknown>((resume) =>
+      Effect.asyncEffect<unknown, E, never, void, never, R | R2 | R3>((resume) =>
         Effect.zipRight(
           this.i0.run(
             Sink.make(
@@ -1116,14 +1115,14 @@ class OrElse<
           Effect.sync(() => resume(Effect.unit))
         )
       ),
-      (error) => this.i1(error).run(sink)
+      (error: E) => this.i1(error).run(sink)
     )
   }
 
-  static make<R, E, A, R2, E2, B>(
-    fx: Fx<R, E, A>,
-    f: (error: E) => Fx<R2, E2, B>
-  ): Fx<R | R2, E2, A | B> {
+  static make<A, E, R, B, E2, R2>(
+    fx: Fx<A, E, R>,
+    f: (error: E) => Fx<B, E2, R2>
+  ): Fx<A | B, E2, R | R2> {
     if (isEmpty(fx)) return fx
     else if (isNever(fx)) return fx
     else {
@@ -1132,35 +1131,35 @@ class OrElse<
   }
 }
 
-export function suspend<R, E, A>(f: () => Fx<R, E, A>): Fx<R, E, A> {
+export function suspend<A, E, R>(f: () => Fx<A, E, R>): Fx<A, E, R> {
   return new Suspend(f)
 }
 
-class Suspend<R, E, A> extends FxBase<R, E, A> {
-  constructor(readonly i0: () => Fx<R, E, A>) {
+class Suspend<A, E, R> extends FxBase<A, E, R> {
+  constructor(readonly i0: () => Fx<A, E, R>) {
     super()
   }
 
-  run<R2>(sink: Sink.Sink<R2, E, A>): Effect.Effect<R | R2, never, unknown> {
+  run<R2>(sink: Sink.Sink<A, E, R2>): Effect.Effect<unknown, never, R | R2> {
     return this.i0().run(sink)
   }
 }
 
-function isSuspend<R, E, A>(fx: Fx<R, E, A>): fx is Suspend<R, E, A> {
+function isSuspend<A, E, R>(fx: Fx<A, E, R>): fx is Suspend<A, E, R> {
   return fx.constructor === Suspend
 }
 
-class SuspendedTransformer<R, E, A, R2, E2, B> extends FxBase<R | R2, E2, B> {
-  constructor(readonly i0: () => Fx<R, E, A>, readonly i1: Op.Operator) {
+class SuspendedTransformer<A, E, R, B, E2, R2> extends FxBase<B, E2, R | R2> {
+  constructor(readonly i0: () => Fx<A, E, R>, readonly i1: Op.Operator) {
     super()
   }
 
-  run<R3>(sink: Sink.Sink<R3, E2, B>): Effect.Effect<R | R2 | R3, never, unknown> {
+  run<R3>(sink: Sink.Sink<B, E2, R3>): Effect.Effect<unknown, never, R | R2 | R3> {
     return this.i0().run(Op.compileOperatorSink(this.i1, sink))
   }
 }
 
-function isSuspendedTransformer<R, E, A>(fx: Fx<R, E, A>): fx is SuspendedTransformer<R, E, A, any, any, any> {
+function isSuspendedTransformer<A, E, R>(fx: Fx<A, E, R>): fx is SuspendedTransformer<A, E, R, any, any, any> {
   return fx.constructor === SuspendedTransformer
 }
 
@@ -1168,59 +1167,59 @@ export function mergeWithStrategy<const FX extends ReadonlyArray<Fx<any, any, an
   fx: FX,
   stategy: MergeStrategy
 ): Fx<
-  Fx.Context<FX[number]>,
+  Fx.Success<FX[number]>,
   Fx.Error<FX[number]>,
-  Fx.Success<FX[number]>
+  Fx.Context<FX[number]>
 > {
   return MergeWithStrategy.make(fx, stategy)
 }
 
-export function merge<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  other: Fx<R2, E2, B>
-): Fx<R | R2, E | E2, A | B> {
+export function merge<A, E, R, B, E2, R2>(
+  fx: Fx<A, E, R>,
+  other: Fx<B, E2, R2>
+): Fx<A | B, E | E2, R | R2> {
   return mergeWithStrategy([fx, other], Unordered(2))
 }
 
 export function mergeAll<FX extends ReadonlyArray<Fx<any, any, any>>>(
   fx: FX
-): Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>> {
+): Fx<Fx.Success<FX[number]>, Fx.Error<FX[number]>, Fx.Context<FX[number]>> {
   return mergeWithStrategy(fx, Unordered(Infinity))
 }
 
 export function mergeOrdered<FX extends ReadonlyArray<Fx<any, any, any>>>(
   fx: FX
-): Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>> {
+): Fx<Fx.Success<FX[number]>, Fx.Error<FX[number]>, Fx.Context<FX[number]>> {
   return mergeOrderedConcurrently(fx, Infinity)
 }
 
 export function mergeOrderedConcurrently<FX extends ReadonlyArray<Fx<any, any, any>>>(
   fx: FX,
   concurrency: number
-): Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>> {
+): Fx<Fx.Success<FX[number]>, Fx.Error<FX[number]>, Fx.Context<FX[number]>> {
   return mergeWithStrategy(fx, Ordered(concurrency))
 }
 
 export function mergeSwitch<FX extends ReadonlyArray<Fx<any, any, any>>>(
   fx: FX
-): Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>> {
+): Fx<Fx.Success<FX[number]>, Fx.Error<FX[number]>, Fx.Context<FX[number]>> {
   return mergeWithStrategy(fx, Switch)
 }
 
 class MergeWithStrategy<
   const FX extends ReadonlyArray<Fx<any, any, any>>
 > extends FxBase<
-  Fx.Context<FX[number]>,
+  Fx.Success<FX[number]>,
   Fx.Error<FX[number]>,
-  Fx.Success<FX[number]>
+  Fx.Context<FX[number]>
 > {
   constructor(readonly i0: FX, readonly i1: MergeStrategy) {
     super()
   }
 
   run<R2>(
-    sink: Sink.Sink<R2, Fx.Error<FX[number]>, Fx.Success<FX[number]>>
-  ): Effect.Effect<Fx.Context<FX[number]> | R2, never, unknown> {
+    sink: Sink.Sink<Fx.Success<FX[number]>, Fx.Error<FX[number]>, R2>
+  ): Effect.Effect<unknown, never, Fx.Context<FX[number]> | R2> {
     switch (this.i1._tag) {
       case "Unordered":
         return runUnordered(this.i0, sink, this.i1.concurrency === Infinity ? "unbounded" : this.i1.concurrency)
@@ -1235,9 +1234,9 @@ class MergeWithStrategy<
     fx: FX,
     strategy: MergeStrategy
   ): Fx<
-    Fx.Context<FX[number]>,
+    Fx.Success<FX[number]>,
     Fx.Error<FX[number]>,
-    Fx.Success<FX[number]>
+    Fx.Context<FX[number]>
   > {
     if (fx.length === 0) return empty
     else if (fx.length === 1) return fx[0]
@@ -1250,9 +1249,9 @@ function runUnordered<
   R2
 >(
   fx: FX,
-  sink: Sink.Sink<R2, any, any>,
+  sink: Sink.Sink<any, any, R2>,
   concurrency: number | "unbounded"
-): Effect.Effect<R2 | Fx.Context<FX[number]>, never, unknown> {
+): Effect.Effect<unknown, never, R2 | Fx.Context<FX[number]>> {
   return Effect.forEach(fx, (fx) => fx.run(sink), { concurrency, discard: true })
 }
 
@@ -1261,9 +1260,9 @@ function runOrdered<
   R2
 >(
   fx: FX,
-  sink: Sink.Sink<R2, any, any>,
+  sink: Sink.Sink<any, any, R2>,
   concurrency: number | "unbounded"
-): Effect.Effect<R2 | Fx.Context<FX[number]>, never, unknown> {
+): Effect.Effect<unknown, never, R2 | Fx.Context<FX[number]>> {
   return Effect.suspend(
     () => {
       const buffers = withBuffers(fx.length, sink)
@@ -1292,35 +1291,35 @@ function runSwitch<
   R2
 >(
   fx: FX,
-  sink: Sink.Sink<R2, any, any>
-): Effect.Effect<R2 | Fx.Context<FX[number]>, never, unknown> {
+  sink: Sink.Sink<any, any, R2>
+): Effect.Effect<unknown, never, R2 | Fx.Context<FX[number]>> {
   return Effect.forEach(fx, (fx) => fx.run(sink), { concurrency: 1, discard: true })
 }
 
-export function takeWhile<R, E, A>(
-  fx: Fx<R, E, A>,
+export function takeWhile<A, E, R>(
+  fx: Fx<A, E, R>,
   f: Predicate.Predicate<A>
-): Fx<R, E, A> {
+): Fx<A, E, R> {
   return TakeWhile.make(fx, f)
 }
 
-export function takeUntil<R, E, A>(
-  fx: Fx<R, E, A>,
+export function takeUntil<A, E, R>(
+  fx: Fx<A, E, R>,
   f: Predicate.Predicate<A>
-): Fx<R, E, A> {
+): Fx<A, E, R> {
   return TakeWhile.make(fx, Predicate.not(f))
 }
 
-class TakeWhile<R, E, A> extends FxBase<R, E, A> {
-  constructor(readonly i0: Fx<R, E, A>, readonly i1: Predicate.Predicate<A>) {
+class TakeWhile<A, E, R> extends FxBase<A, E, R> {
+  constructor(readonly i0: Fx<A, E, R>, readonly i1: Predicate.Predicate<A>) {
     super()
   }
 
-  run<R2>(sink: Sink.Sink<R2, E, A>): Effect.Effect<R | R2, never, unknown> {
+  run<R2>(sink: Sink.Sink<A, E, R2>): Effect.Effect<unknown, never, R | R2> {
     return Sink.takeWhile(sink, this.i1, (s) => this.i0.run(s))
   }
 
-  static make<R, E, A>(fx: Fx<R, E, A>, predicate: Predicate.Predicate<A>): Fx<R, E, A> {
+  static make<A, E, R>(fx: Fx<A, E, R>, predicate: Predicate.Predicate<A>): Fx<A, E, R> {
     if (isEmpty(fx) || isNever(fx)) return fx
     else {
       return new TakeWhile(fx, predicate)
@@ -1328,30 +1327,30 @@ class TakeWhile<R, E, A> extends FxBase<R, E, A> {
   }
 }
 
-export function dropWhile<R, E, A>(
-  fx: Fx<R, E, A>,
+export function dropWhile<A, E, R>(
+  fx: Fx<A, E, R>,
   f: Predicate.Predicate<A>
-): Fx<R, E, A> {
+): Fx<A, E, R> {
   return DropUntil.make(fx, f)
 }
 
-export function dropUntil<R, E, A>(
-  fx: Fx<R, E, A>,
+export function dropUntil<A, E, R>(
+  fx: Fx<A, E, R>,
   f: Predicate.Predicate<A>
-): Fx<R, E, A> {
+): Fx<A, E, R> {
   return DropUntil.make(fx, Predicate.not(f))
 }
 
-class DropUntil<R, E, A> extends FxBase<R, E, A> {
-  constructor(readonly i0: Fx<R, E, A>, readonly i1: Predicate.Predicate<A>) {
+class DropUntil<A, E, R> extends FxBase<A, E, R> {
+  constructor(readonly i0: Fx<A, E, R>, readonly i1: Predicate.Predicate<A>) {
     super()
   }
 
-  run<R2>(sink: Sink.Sink<R2, E, A>): Effect.Effect<R | R2, never, unknown> {
+  run<R2>(sink: Sink.Sink<A, E, R2>): Effect.Effect<unknown, never, R | R2> {
     return this.i0.run(Sink.dropWhile(sink, this.i1))
   }
 
-  static make<R, E, A>(fx: Fx<R, E, A>, predicate: Predicate.Predicate<A>): Fx<R, E, A> {
+  static make<A, E, R>(fx: Fx<A, E, R>, predicate: Predicate.Predicate<A>): Fx<A, E, R> {
     if (isEmpty(fx) || isNever(fx)) return fx
     else {
       return new DropUntil(fx, predicate)
@@ -1359,23 +1358,23 @@ class DropUntil<R, E, A> extends FxBase<R, E, A> {
   }
 }
 
-export function dropAfter<R, E, A>(
-  fx: Fx<R, E, A>,
+export function dropAfter<A, E, R>(
+  fx: Fx<A, E, R>,
   f: Predicate.Predicate<A>
-): Fx<R, E, A> {
+): Fx<A, E, R> {
   return DropAfter.make(fx, f)
 }
 
-class DropAfter<R, E, A> extends FxBase<R, E, A> {
-  constructor(readonly i0: Fx<R, E, A>, readonly i1: Predicate.Predicate<A>) {
+class DropAfter<A, E, R> extends FxBase<A, E, R> {
+  constructor(readonly i0: Fx<A, E, R>, readonly i1: Predicate.Predicate<A>) {
     super()
   }
 
-  run<R2>(sink: Sink.Sink<R2, E, A>): Effect.Effect<R | R2, never, unknown> {
+  run<R2>(sink: Sink.Sink<A, E, R2>): Effect.Effect<unknown, never, R | R2> {
     return this.i0.run(Sink.dropAfter(sink, this.i1))
   }
 
-  static make<R, E, A>(fx: Fx<R, E, A>, predicate: Predicate.Predicate<A>): Fx<R, E, A> {
+  static make<A, E, R>(fx: Fx<A, E, R>, predicate: Predicate.Predicate<A>): Fx<A, E, R> {
     if (isEmpty(fx) || isNever(fx)) return fx
     else {
       return new DropAfter(fx, predicate)
@@ -1383,33 +1382,33 @@ class DropAfter<R, E, A> extends FxBase<R, E, A> {
   }
 }
 
-export function takeWhileEffect<R, E, A, R2, E2>(
-  fx: Fx<R, E, A>,
-  f: (a: A) => Effect.Effect<R2, E2, boolean>
-): Fx<R | R2, E | E2, A> {
+export function takeWhileEffect<A, E, R, R2, E2>(
+  fx: Fx<A, E, R>,
+  f: (a: A) => Effect.Effect<boolean, E2, R2>
+): Fx<A, E | E2, R | R2> {
   return TakeWhileEffect.make(fx, f)
 }
 
-export function takeUntilEffect<R, E, A, R2, E2>(
-  fx: Fx<R, E, A>,
-  f: (a: A) => Effect.Effect<R2, E2, boolean>
-): Fx<R | R2, E | E2, A> {
+export function takeUntilEffect<A, E, R, R2, E2>(
+  fx: Fx<A, E, R>,
+  f: (a: A) => Effect.Effect<boolean, E2, R2>
+): Fx<A, E | E2, R | R2> {
   return TakeWhileEffect.make(fx, (a) => Effect.map(f(a), Boolean.not))
 }
 
-class TakeWhileEffect<R, E, A, R2, E2> extends FxBase<R | R2, E | E2, A> {
-  constructor(readonly i0: Fx<R, E, A>, readonly i1: (a: A) => Effect.Effect<R2, E2, boolean>) {
+class TakeWhileEffect<A, E, R, R2, E2> extends FxBase<A, E | E2, R | R2> {
+  constructor(readonly i0: Fx<A, E, R>, readonly i1: (a: A) => Effect.Effect<boolean, E2, R2>) {
     super()
   }
 
-  run<R3>(sink: Sink.Sink<R3, E | E2, A>): Effect.Effect<R | R2 | R3, never, unknown> {
+  run<R3>(sink: Sink.Sink<A, E | E2, R3>): Effect.Effect<unknown, never, R | R2 | R3> {
     return Sink.takeWhileEffect(sink, this.i1, (s) => this.i0.run(s))
   }
 
-  static make<R, E, A, R2, E2>(
-    fx: Fx<R, E, A>,
-    f: (a: A) => Effect.Effect<R2, E2, boolean>
-  ): Fx<R | R2, E | E2, A> {
+  static make<A, E, R, R2, E2>(
+    fx: Fx<A, E, R>,
+    f: (a: A) => Effect.Effect<boolean, E2, R2>
+  ): Fx<A, E | E2, R | R2> {
     if (isEmpty(fx) || isNever(fx)) return fx
     else {
       return new TakeWhileEffect(fx, f)
@@ -1417,33 +1416,33 @@ class TakeWhileEffect<R, E, A, R2, E2> extends FxBase<R | R2, E | E2, A> {
   }
 }
 
-export function dropWhileEffect<R, E, A>(
-  fx: Fx<R, E, A>,
-  f: (a: A) => Effect.Effect<R, E, boolean>
-): Fx<R, E, A> {
+export function dropWhileEffect<A, E, R>(
+  fx: Fx<A, E, R>,
+  f: (a: A) => Effect.Effect<boolean, E, R>
+): Fx<A, E, R> {
   return DropWhileEffect.make(fx, f)
 }
 
-export function dropUntilEffect<R, E, A>(
-  fx: Fx<R, E, A>,
-  f: (a: A) => Effect.Effect<R, E, boolean>
-): Fx<R, E, A> {
+export function dropUntilEffect<A, E, R>(
+  fx: Fx<A, E, R>,
+  f: (a: A) => Effect.Effect<boolean, E, R>
+): Fx<A, E, R> {
   return DropWhileEffect.make(fx, (a) => Effect.map(f(a), Boolean.not))
 }
 
-class DropWhileEffect<R, E, A> extends FxBase<R, E, A> {
-  constructor(readonly i0: Fx<R, E, A>, readonly i1: (a: A) => Effect.Effect<R, E, boolean>) {
+class DropWhileEffect<A, E, R> extends FxBase<A, E, R> {
+  constructor(readonly i0: Fx<A, E, R>, readonly i1: (a: A) => Effect.Effect<boolean, E, R>) {
     super()
   }
 
-  run<R2>(sink: Sink.Sink<R2, E, A>): Effect.Effect<R | R2, never, unknown> {
+  run<R2>(sink: Sink.Sink<A, E, R2>): Effect.Effect<unknown, never, R | R2> {
     return this.i0.run(Sink.dropWhileEffect(sink, this.i1))
   }
 
-  static make<R, E, A>(
-    fx: Fx<R, E, A>,
-    f: (a: A) => Effect.Effect<R, E, boolean>
-  ): Fx<R, E, A> {
+  static make<A, E, R>(
+    fx: Fx<A, E, R>,
+    f: (a: A) => Effect.Effect<boolean, E, R>
+  ): Fx<A, E, R> {
     if (isEmpty(fx) || isNever(fx)) return fx
     else {
       return new DropWhileEffect(fx, f)
@@ -1451,26 +1450,26 @@ class DropWhileEffect<R, E, A> extends FxBase<R, E, A> {
   }
 }
 
-export function dropAfterEffect<R, E, A, R2, E2>(
-  fx: Fx<R, E, A>,
-  f: (a: A) => Effect.Effect<R2, E2, boolean>
-): Fx<R | R2, E | E2, A> {
+export function dropAfterEffect<A, E, R, R2, E2>(
+  fx: Fx<A, E, R>,
+  f: (a: A) => Effect.Effect<boolean, E2, R2>
+): Fx<A, E | E2, R | R2> {
   return DropAfterEffect.make(fx, f)
 }
 
-class DropAfterEffect<R, E, A, R2, E2> extends FxBase<R | R2, E | E2, A> {
-  constructor(readonly i0: Fx<R, E, A>, readonly i1: (a: A) => Effect.Effect<R2, E2, boolean>) {
+class DropAfterEffect<A, E, R, R2, E2> extends FxBase<A, E | E2, R | R2> {
+  constructor(readonly i0: Fx<A, E, R>, readonly i1: (a: A) => Effect.Effect<boolean, E2, R2>) {
     super()
   }
 
-  run<R3>(sink: Sink.Sink<R3, E | E2, A>): Effect.Effect<R | R2 | R3, never, unknown> {
+  run<R3>(sink: Sink.Sink<A, E | E2, R3>): Effect.Effect<unknown, never, R | R2 | R3> {
     return this.i0.run(Sink.dropAfterEffect(sink, this.i1))
   }
 
-  static make<R, E, A, R2, E2>(
-    fx: Fx<R, E, A>,
-    f: (a: A) => Effect.Effect<R2, E2, boolean>
-  ): Fx<R | R2, E | E2, A> {
+  static make<A, E, R, R2, E2>(
+    fx: Fx<A, E, R>,
+    f: (a: A) => Effect.Effect<boolean, E2, R2>
+  ): Fx<A, E | E2, R | R2> {
     if (isEmpty(fx) || isNever(fx)) return fx
     else {
       return new DropAfterEffect(fx, f)
@@ -1478,33 +1477,33 @@ class DropAfterEffect<R, E, A, R2, E2> extends FxBase<R | R2, E | E2, A> {
   }
 }
 
-export function during<R, E, A, R2, E2, R3, E3, B>(
-  fx: Fx<R, E, A>,
-  window: Fx<R2, E2, Fx<R3, E3, B>>
-): Fx<R | R2 | R3 | Scope.Scope, E | E2 | E3, A> {
+export function during<A, E, R, B, E2, R2, E3, R3>(
+  fx: Fx<A, E, R>,
+  window: Fx<Fx<B, E3, R3>, E2, R2>
+): Fx<A, E | E2 | E3, R | R2 | R3 | Scope.Scope> {
   return During.make(fx, window)
 }
 
-export function since<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  window: Fx<R2, E2, B>
-): Fx<R | R2 | Scope.Scope, E | E2, A> {
+export function since<A, E, R, B, E2, R2>(
+  fx: Fx<A, E, R>,
+  window: Fx<B, E2, R2>
+): Fx<A, E | E2, R | R2 | Scope.Scope> {
   return During.make(fx, map(window, () => never))
 }
 
-export function until<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  window: Fx<R2, E2, B>
-): Fx<R | R2 | Scope.Scope, E | E2, A> {
+export function until<A, E, R, B, E2, R2>(
+  fx: Fx<A, E, R>,
+  window: Fx<B, E2, R2>
+): Fx<A, E | E2, R | R2 | Scope.Scope> {
   return During.make(fx, succeed(window))
 }
 
-class During<R, E, A, R2, E2, R3, E3, B> extends FxBase<R | R2 | R3 | Scope.Scope, E | E2 | E3, A> {
-  constructor(readonly i0: Fx<R, E, A>, readonly i1: Fx<R2, E2, Fx<R3, E3, B>>) {
+class During<A, E, R, B, E2, R2, E3, R3> extends FxBase<A, E | E2 | E3, R | R2 | R3 | Scope.Scope> {
+  constructor(readonly i0: Fx<A, E, R>, readonly i1: Fx<Fx<B, E3, R3>, E2, R2>) {
     super()
   }
 
-  run<R4>(sink: Sink.Sink<R4, E | E2 | E3, A>): Effect.Effect<R | R2 | R3 | R4 | Scope.Scope, never, unknown> {
+  run<R4>(sink: Sink.Sink<A, E | E2 | E3, R4>): Effect.Effect<unknown, never, R | R2 | R3 | R4 | Scope.Scope> {
     return withScopedFork(
       (fork) =>
         Sink.withEarlyExit(sink, (s) => {
@@ -1538,10 +1537,10 @@ class During<R, E, A, R2, E2, R3, E3, B> extends FxBase<R | R2 | R3 | Scope.Scop
     )
   }
 
-  static make<R, E, A, R2, E2, R3, E3, B>(
-    fx: Fx<R, E, A>,
-    window: Fx<R2, E2, Fx<R3, E3, B>>
-  ): Fx<R | R2 | R3 | Scope.Scope, E | E2 | E3, A> {
+  static make<A, E, R, B, E2, R2, E3, R3>(
+    fx: Fx<A, E, R>,
+    window: Fx<Fx<B, E3, R3>, E2, R2>
+  ): Fx<A, E | E2 | E3, R | R2 | R3 | Scope.Scope> {
     if (isEmpty(fx) || isNever(fx)) return fx
     else {
       return new During(fx, window)
@@ -1549,160 +1548,160 @@ class During<R, E, A, R2, E2, R3, E3, B> extends FxBase<R | R2 | R3 | Scope.Scop
   }
 }
 
-export function middleware<R, E, A, R3>(
-  fx: Fx<R, E, A>,
-  effect: (effect: Effect.Effect<R, never, unknown>) => Effect.Effect<R3, never, unknown>,
-  sink?: (sink: Sink.Sink<never, E, A>) => Sink.Sink<R, E, A>
-): Fx<R3, E, A> {
+export function middleware<A, E, R, R3>(
+  fx: Fx<A, E, R>,
+  effect: (effect: Effect.Effect<unknown, never, R>) => Effect.Effect<unknown, never, R3>,
+  sink?: (sink: Sink.Sink<A, E>) => Sink.Sink<A, E, R>
+): Fx<A, E, R3> {
   return new Middleware(fx, effect, sink)
 }
 
-export function onExit<R, E, A, R2>(
-  fx: Fx<R, E, A>,
-  f: (exit: Exit.Exit<never, unknown>) => Effect.Effect<R2, never, unknown>
-): Fx<R | R2, E, A> {
+export function onExit<A, E, R, R2>(
+  fx: Fx<A, E, R>,
+  f: (exit: Exit.Exit<unknown>) => Effect.Effect<unknown, never, R2>
+): Fx<A, E, R | R2> {
   return middleware(fx, Effect.onExit(f))
 }
 
-export function onInterrupt<R, E, A, R2>(
-  fx: Fx<R, E, A>,
-  f: (interruptors: HashSet.HashSet<FiberId.FiberId>) => Effect.Effect<R2, never, unknown>
-): Fx<R | R2, E, A> {
+export function onInterrupt<A, E, R, R2>(
+  fx: Fx<A, E, R>,
+  f: (interruptors: HashSet.HashSet<FiberId.FiberId>) => Effect.Effect<unknown, never, R2>
+): Fx<A, E, R | R2> {
   return middleware(fx, Effect.onInterrupt(f))
 }
 
-export function onError<R, E, A, R2>(
-  fx: Fx<R, E, A>,
-  f: (cause: Cause.Cause<never>) => Effect.Effect<R2, never, unknown>
-): Fx<R | R2, E, A> {
+export function onError<A, E, R, R2>(
+  fx: Fx<A, E, R>,
+  f: (cause: Cause.Cause<never>) => Effect.Effect<unknown, never, R2>
+): Fx<A, E, R | R2> {
   return middleware(fx, Effect.onError(f))
 }
 
-export const scoped = <R, E, A>(fx: Fx<R, E, A>): Fx<Exclude<R, Scope.Scope>, E, A> => middleware(fx, Effect.scoped)
+export const scoped = <A, E, R>(fx: Fx<A, E, R>): Fx<A, E, Exclude<R, Scope.Scope>> => middleware(fx, Effect.scoped)
 
-export function annotateLogs<R, E, A>(
-  fx: Fx<R, E, A>,
+export function annotateLogs<A, E, R>(
+  fx: Fx<A, E, R>,
   key: string | Record<string, unknown>,
   value?: unknown
-): Fx<R, E, A> {
+): Fx<A, E, R> {
   return middleware(fx, (effect) => Effect.annotateLogs(effect, key as string, value as unknown))
 }
 
-export function annotateSpans<R, E, A>(
-  fx: Fx<R, E, A>,
+export function annotateSpans<A, E, R>(
+  fx: Fx<A, E, R>,
   key: string | Record<string, unknown>,
   value?: unknown
-): Fx<R, E, A> {
+): Fx<A, E, R> {
   return middleware(fx, (effect) => Effect.annotateSpans(effect, key as string, value as unknown))
 }
 
-export const interruptible = <R, E, A>(fx: Fx<R, E, A>): Fx<R, E, A> => middleware(fx, Effect.interruptible)
+export const interruptible = <A, E, R>(fx: Fx<A, E, R>): Fx<A, E, R> => middleware(fx, Effect.interruptible)
 
-export const uninterruptible = <R, E, A>(fx: Fx<R, E, A>): Fx<R, E, A> => middleware(fx, Effect.uninterruptible)
+export const uninterruptible = <A, E, R>(fx: Fx<A, E, R>): Fx<A, E, R> => middleware(fx, Effect.uninterruptible)
 
-export function locally<R, E, B, A>(
-  use: Fx<R, E, B>,
+export function locally<B, E, R, A>(
+  use: Fx<B, E, R>,
   self: FiberRef.FiberRef<A>,
   value: A
-): Fx<R, E, B> {
+): Fx<B, E, R> {
   return middleware(use, (effect) => Effect.locally(effect, self, value))
 }
 
-export function locallyWith<R, E, B, A>(
-  use: Fx<R, E, B>,
+export function locallyWith<B, E, R, A>(
+  use: Fx<B, E, R>,
   self: FiberRef.FiberRef<A>,
   f: (a: A) => A
-): Fx<R, E, B> {
+): Fx<B, E, R> {
   return middleware(use, (effect) => Effect.locallyWith(effect, self, f))
 }
 
-export function withTracerTiming<R, E, A>(
-  fx: Fx<R, E, A>,
+export function withTracerTiming<A, E, R>(
+  fx: Fx<A, E, R>,
   enabled: boolean
-): Fx<R, E, A> {
+): Fx<A, E, R> {
   return middleware(fx, (effect) => Effect.withTracerTiming(effect, enabled))
 }
 
-export function withConcurrency<R, E, A>(
-  fx: Fx<R, E, A>,
+export function withConcurrency<A, E, R>(
+  fx: Fx<A, E, R>,
   concurrency: number | "unbounded"
-): Fx<R, E, A> {
+): Fx<A, E, R> {
   return middleware(fx, (effect) => Effect.withConcurrency(effect, concurrency))
 }
 
-export function withConfigProvider<R, E, A>(
-  fx: Fx<R, E, A>,
+export function withConfigProvider<A, E, R>(
+  fx: Fx<A, E, R>,
   configProvider: ConfigProvider.ConfigProvider
-): Fx<R, E, A> {
+): Fx<A, E, R> {
   return middleware(fx, (effect) => Effect.withConfigProvider(effect, configProvider))
 }
 
-export function withLogSpan<R, E, A>(
-  fx: Fx<R, E, A>,
+export function withLogSpan<A, E, R>(
+  fx: Fx<A, E, R>,
   span: string
-): Fx<R, E, A> {
+): Fx<A, E, R> {
   return middleware(fx, (effect) => Effect.withLogSpan(effect, span))
 }
 
-export function withMaxOpsBeforeYield<R, E, A>(
-  fx: Fx<R, E, A>,
+export function withMaxOpsBeforeYield<A, E, R>(
+  fx: Fx<A, E, R>,
   maxOps: number
-): Fx<R, E, A> {
+): Fx<A, E, R> {
   return middleware(fx, (effect) => Effect.withMaxOpsBeforeYield(effect, maxOps))
 }
 
-export function withParentSpan<R, E, A>(
-  fx: Fx<R, E, A>,
+export function withParentSpan<A, E, R>(
+  fx: Fx<A, E, R>,
   parentSpan: Tracer.ParentSpan
-): Fx<R, E, A> {
+): Fx<A, E, R> {
   return middleware(fx, (effect) => Effect.withParentSpan(effect, parentSpan))
 }
 
-export function withRequestBatching<R, E, A>(
-  fx: Fx<R, E, A>,
+export function withRequestBatching<A, E, R>(
+  fx: Fx<A, E, R>,
   requestBatching: boolean
-): Fx<R, E, A> {
+): Fx<A, E, R> {
   return middleware(fx, (effect) => Effect.withRequestBatching(effect, requestBatching))
 }
 
-export function withRequestCache<R, E, A>(
-  fx: Fx<R, E, A>,
+export function withRequestCache<A, E, R>(
+  fx: Fx<A, E, R>,
   cache: Request.Cache
-): Fx<R, E, A> {
+): Fx<A, E, R> {
   return middleware(fx, (effect) => Effect.withRequestCache(effect, cache))
 }
 
-export function withRequestCaching<R, E, A>(
-  fx: Fx<R, E, A>,
+export function withRequestCaching<A, E, R>(
+  fx: Fx<A, E, R>,
   requestCaching: boolean
-): Fx<R, E, A> {
+): Fx<A, E, R> {
   return middleware(fx, (effect) => Effect.withRequestCaching(effect, requestCaching))
 }
 
-export function withScheduler<R, E, A>(
-  fx: Fx<R, E, A>,
+export function withScheduler<A, E, R>(
+  fx: Fx<A, E, R>,
   scheduler: Scheduler.Scheduler
-): Fx<R, E, A> {
+): Fx<A, E, R> {
   return middleware(fx, (effect) => Effect.withScheduler(effect, scheduler))
 }
 
-export function withTracer<R, E, A>(
-  fx: Fx<R, E, A>,
+export function withTracer<A, E, R>(
+  fx: Fx<A, E, R>,
   tracer: Tracer.Tracer
-): Fx<R, E, A> {
+): Fx<A, E, R> {
   return middleware(fx, (effect) => Effect.withTracer(effect, tracer))
 }
 
-class Middleware<R, E, A, R2> extends FxBase<R2, E, A> {
+class Middleware<A, E, R, R2> extends FxBase<A, E, R2> {
   constructor(
-    readonly i0: Fx<R, E, A>,
-    readonly i1: (effect: Effect.Effect<R, never, unknown>) => Effect.Effect<R2, never, unknown>,
-    readonly i2?: (sink: Sink.Sink<never, E, A>) => Sink.Sink<R, E, A>
+    readonly i0: Fx<A, E, R>,
+    readonly i1: (effect: Effect.Effect<unknown, never, R>) => Effect.Effect<unknown, never, R2>,
+    readonly i2?: (sink: Sink.Sink<A, E>) => Sink.Sink<A, E, R>
   ) {
     super()
   }
 
-  run<R3>(sink: Sink.Sink<R3, E, A>): Effect.Effect<R2 | R3, never, unknown> {
+  run<R3>(sink: Sink.Sink<A, E, R3>): Effect.Effect<unknown, never, R2 | R3> {
     return Effect.contextWithEffect((ctx) => {
       const s = Sink.provide(sink, ctx)
 
@@ -1711,24 +1710,24 @@ class Middleware<R, E, A, R2> extends FxBase<R2, E, A> {
   }
 }
 
-export function acquireUseRelease<R, E, A, R2, E2, B, R3, E3, C>(
-  acquire: Effect.Effect<R, E, A>,
-  use: (a: A) => Fx<R2, E2, B>,
-  release: (a: A, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<R3, E3, C>
-): Fx<R | R2 | R3, E | E2 | E3, B> {
+export function acquireUseRelease<A, E, R, B, E2, R2, C, E3, R3>(
+  acquire: Effect.Effect<A, E, R>,
+  use: (a: A) => Fx<B, E2, R2>,
+  release: (a: A, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<C, E3, R3>
+): Fx<B, E | E2 | E3, R | R2 | R3> {
   return new AcquireUseRelease(acquire, use, release)
 }
 
-class AcquireUseRelease<R, E, A, R2, E2, B, R3, E3, C> extends FxBase<R | R2 | R3, E | E2 | E3, B> {
+class AcquireUseRelease<A, E, R, B, E2, R2, C, E3, R3> extends FxBase<B, E | E2 | E3, R | R2 | R3> {
   constructor(
-    readonly acquire: Effect.Effect<R, E, A>,
-    readonly use: (a: A) => Fx<R2, E2, B>,
-    readonly release: (a: A, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<R3, E3, C>
+    readonly acquire: Effect.Effect<A, E, R>,
+    readonly use: (a: A) => Fx<B, E2, R2>,
+    readonly release: (a: A, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<C, E3, R3>
   ) {
     super()
   }
 
-  run<R4>(sink: Sink.Sink<R4, E | E2 | E3, B>): Effect.Effect<R | R2 | R3 | R4, never, unknown> {
+  run<R4>(sink: Sink.Sink<B, E | E2 | E3, R4>): Effect.Effect<unknown, never, R | R2 | R3 | R4> {
     return Effect.catchAllCause(
       Effect.acquireUseRelease(
         this.acquire,
@@ -1740,8 +1739,8 @@ class AcquireUseRelease<R, E, A, R2, E2, B, R3, E3, C> extends FxBase<R | R2 | R
   }
 }
 
-export function withSpan<R, E, A>(
-  self: Fx<R, E, A>,
+export function withSpan<A, E, R>(
+  self: Fx<A, E, R>,
   name: string,
   options: {
     readonly attributes?: Record<string, unknown>
@@ -1750,7 +1749,7 @@ export function withSpan<R, E, A>(
     readonly root?: boolean
     readonly context?: Context.Context<never>
   } = {}
-): Fx<R, E, A> {
+): Fx<A, E, R> {
   return acquireUseRelease(
     Effect.flatMap(
       Effect.optionFromOptional(Effect.currentSpan),
@@ -1766,58 +1765,58 @@ export function withSpan<R, E, A>(
   )
 }
 
-export function provideContext<R, E, A, R2>(
-  fx: Fx<R, E, A>,
+export function provideContext<A, E, R, R2>(
+  fx: Fx<A, E, R>,
   context: Context.Context<R2>
-): Fx<Exclude<R, R2>, E, A> {
+): Fx<A, E, Exclude<R, R2>> {
   return ProvideFx.make(fx, Provide.ProvideContext(context))
 }
 
-export function provideLayer<R, E, A, R2, E2, S>(
-  fx: Fx<R, E, A>,
-  layer: Layer.Layer<R2, E2, S>
-): Fx<R2 | Exclude<R, S>, E | E2, A> {
+export function provideLayer<A, E, R, S, E2, R2>(
+  fx: Fx<A, E, R>,
+  layer: Layer.Layer<S, E2, R2>
+): Fx<A, E | E2, R2 | Exclude<R, S>> {
   return ProvideFx.make(fx, Provide.ProvideLayer(layer))
 }
 
-export function provideRuntime<R, E, A, R2>(
-  fx: Fx<R, E, A>,
+export function provideRuntime<A, E, R, R2>(
+  fx: Fx<A, E, R>,
   runtime: Runtime.Runtime<R2>
-): Fx<Exclude<R, R2>, E, A> {
+): Fx<A, E, Exclude<R, R2>> {
   return ProvideFx.make(fx, Provide.ProvideRuntime(runtime))
 }
 
-export function provideService<R, E, A, I, S>(
-  fx: Fx<R, E, A>,
+export function provideService<A, E, R, I, S>(
+  fx: Fx<A, E, R>,
   service: Context.Tag<I, S>,
   instance: S
-): Fx<Exclude<R, I>, E, A> {
+): Fx<A, E, Exclude<R, I>> {
   return ProvideFx.make(fx, Provide.ProvideService(service, instance))
 }
 
-export function provideServiceEffect<R, E, A, I, S, R2, E2>(
-  fx: Fx<R, E, A>,
+export function provideServiceEffect<A, E, R, I, S, R2, E2>(
+  fx: Fx<A, E, R>,
   service: Context.Tag<I, S>,
-  instance: Effect.Effect<R2, E2, S>
-): Fx<Exclude<R, I> | R2, E | E2, A> {
+  instance: Effect.Effect<S, E2, R2>
+): Fx<A, E | E2, Exclude<R, I> | R2> {
   return ProvideFx.make(fx, Provide.ProvideServiceEffect(service, instance))
 }
 
-export function provide<R, E, A, R2 = never, E2 = never, S = never>(
-  fx: Fx<R, E, A>,
-  provide: Layer.Layer<R2, E2, S> | Context.Context<S> | Runtime.Runtime<S>
-): Fx<Exclude<R, S> | R2, E | E2, A> {
-  if (Layer.isLayer(provide)) return provideLayer(fx, provide as Layer.Layer<R2, E2, S>)
+export function provide<A, E, R, R2 = never, E2 = never, S = never>(
+  fx: Fx<A, E, R>,
+  provide: Layer.Layer<S, E2, R2> | Context.Context<S> | Runtime.Runtime<S>
+): Fx<A, E | E2, Exclude<R, S> | R2> {
+  if (Layer.isLayer(provide)) return provideLayer(fx, provide as Layer.Layer<S, E2, R2>)
   else if (Context.isContext(provide)) return provideContext(fx, provide as Context.Context<S>)
   else return provideRuntime(fx, provide as Runtime.Runtime<S>)
 }
 
-class ProvideFx<R, E, A, R2, E2, S> extends FxBase<R2 | Exclude<R, S>, E | E2, A> {
-  constructor(readonly i0: Fx<R, E, A>, readonly i1: Provide.Provide<R2, E2, S>) {
+class ProvideFx<A, E, R, S, E2, R2> extends FxBase<A, E | E2, R2 | Exclude<R, S>> {
+  constructor(readonly i0: Fx<A, E, R>, readonly i1: Provide.Provide<S, E2, R2>) {
     super()
   }
 
-  run<R3>(sink: Sink.Sink<R3, E | E2, A>): Effect.Effect<R2 | R3 | Exclude<R, S>, never, unknown> {
+  run<R3>(sink: Sink.Sink<A, E | E2, R3>): Effect.Effect<unknown, never, R2 | R3 | Exclude<R, S>> {
     return Effect.acquireUseRelease(
       Scope.make(),
       (scope) =>
@@ -1829,10 +1828,10 @@ class ProvideFx<R, E, A, R2, E2, S> extends FxBase<R2 | Exclude<R, S>, E | E2, A
     )
   }
 
-  static make<R, E, A, R2, E2, S>(
-    fx: Fx<R, E, A>,
-    provide: Provide.Provide<R2, E2, S>
-  ): Fx<Exclude<R, S> | R2, E | E2, A> {
+  static make<A, E, R, S, E2, R2>(
+    fx: Fx<A, E, R>,
+    provide: Provide.Provide<S, E2, R2>
+  ): Fx<A, E | E2, Exclude<R, S> | R2> {
     if (isEmpty(fx) || isNever(fx)) return fx
     else if (isProvideFx(fx)) {
       return new ProvideFx(fx.i0, Provide.merge(fx.i1, provide))
@@ -1842,35 +1841,35 @@ class ProvideFx<R, E, A, R2, E2, S> extends FxBase<R2 | Exclude<R, S>, E | E2, A
   }
 }
 
-function isProvideFx<R, E, A>(u: Fx<R, E, A>): u is ProvideFx<R, E, A, R, E, never> {
+function isProvideFx<A, E, R>(u: Fx<A, E, R>): u is ProvideFx<A, E, R, R, E, never> {
   return u.constructor === ProvideFx
 }
 
-export function mapCause<R, E, A, E2>(
-  fx: Fx<R, E, A>,
+export function mapCause<A, E, R, E2>(
+  fx: Fx<A, E, R>,
   f: (cause: Cause.Cause<E>) => Cause.Cause<E2>
-): Fx<R, E2, A> {
+): Fx<A, E2, R> {
   return new TransformerCause(fx, SyncOp.Map(f))
 }
 
-export function mapError<R, E, A, E2>(
-  fx: Fx<R, E, A>,
+export function mapError<A, E, R, E2>(
+  fx: Fx<A, E, R>,
   f: (e: E) => E2
-): Fx<R, E2, A> {
+): Fx<A, E2, R> {
   return mapCause(fx, Cause.map(f))
 }
 
-export function filterCause<R, E, A>(
-  fx: Fx<R, E, A>,
+export function filterCause<A, E, R>(
+  fx: Fx<A, E, R>,
   f: (cause: Cause.Cause<E>) => boolean
-): Fx<R, E, A> {
+): Fx<A, E, R> {
   return new TransformerCause(fx, SyncOp.Filter(f))
 }
 
-export function filterError<R, E, A>(
-  fx: Fx<R, E, A>,
+export function filterError<A, E, R>(
+  fx: Fx<A, E, R>,
   f: (e: E) => boolean
-): Fx<R, E, A> {
+): Fx<A, E, R> {
   return filterCause(fx, (cause) =>
     Option.match(Cause.failureOption(cause), {
       onNone: constTrue,
@@ -1878,17 +1877,17 @@ export function filterError<R, E, A>(
     }))
 }
 
-export function filterMapCause<R, E, A, E2>(
-  fx: Fx<R, E, A>,
+export function filterMapCause<A, E, R, E2>(
+  fx: Fx<A, E, R>,
   f: (cause: Cause.Cause<E>) => Option.Option<Cause.Cause<E2>>
-): Fx<R, E2, A> {
+): Fx<A, E2, R> {
   return new TransformerCause(fx, SyncOp.FilterMap(f))
 }
 
-export function filterMapError<R, E, A, E2>(
-  fx: Fx<R, E, A>,
+export function filterMapError<A, E, R, E2>(
+  fx: Fx<A, E, R>,
   f: (e: E) => Option.Option<E2>
-): Fx<R, E2, A> {
+): Fx<A, E2, R> {
   return filterMapCause(fx, (cause) =>
     Either.match(Cause.failureOrCause(cause), {
       onLeft: (e) => Option.map(f(e), Cause.fail),
@@ -1896,17 +1895,17 @@ export function filterMapError<R, E, A, E2>(
     }))
 }
 
-export function mapCauseEffect<R, E, A, R2, E2, E3>(
-  fx: Fx<R, E, A>,
-  f: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, Cause.Cause<E3>>
-): Fx<R | R2, E2 | E3, A> {
+export function mapCauseEffect<A, E, R, R2, E2, E3>(
+  fx: Fx<A, E, R>,
+  f: (cause: Cause.Cause<E>) => Effect.Effect<Cause.Cause<E3>, E2, R2>
+): Fx<A, E2 | E3, R | R2> {
   return new TransformerCause(fx, EffectOp.MapEffect(f))
 }
 
-export function mapErrorEffect<R, E, A, R2, E2, E3>(
-  fx: Fx<R, E, A>,
-  f: (e: E) => Effect.Effect<R2, E2, E3>
-): Fx<R | R2, E2 | E3, A> {
+export function mapErrorEffect<A, E, R, R2, E2, E3>(
+  fx: Fx<A, E, R>,
+  f: (e: E) => Effect.Effect<E3, E2, R2>
+): Fx<A, E2 | E3, R | R2> {
   return mapCauseEffect(fx, (cause) =>
     Either.match(Cause.failureOrCause(cause), {
       onLeft: (e) => Effect.map(f(e), Cause.fail),
@@ -1914,17 +1913,17 @@ export function mapErrorEffect<R, E, A, R2, E2, E3>(
     }))
 }
 
-export function filterCauseEffect<R, E, A, R2, E2>(
-  fx: Fx<R, E, A>,
-  f: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, boolean>
-): Fx<R | R2, E2, A> {
+export function filterCauseEffect<A, E, R, R2, E2>(
+  fx: Fx<A, E, R>,
+  f: (cause: Cause.Cause<E>) => Effect.Effect<boolean, E2, R2>
+): Fx<A, E2, R | R2> {
   return new TransformerCause(fx, EffectOp.FilterEffect(f))
 }
 
-export function filterErrorEffect<R, E, A, R2, E2>(
-  fx: Fx<R, E, A>,
-  f: (e: E) => Effect.Effect<R2, E2, boolean>
-): Fx<R | R2, E2, A> {
+export function filterErrorEffect<A, E, R, R2, E2>(
+  fx: Fx<A, E, R>,
+  f: (e: E) => Effect.Effect<boolean, E2, R2>
+): Fx<A, E2, R | R2> {
   return filterCauseEffect(fx, (cause) =>
     Either.match(Cause.failureOrCause(cause), {
       onLeft: f,
@@ -1932,17 +1931,17 @@ export function filterErrorEffect<R, E, A, R2, E2>(
     }))
 }
 
-export function filterMapCauseEffect<R, E, A, R2, E2, E3>(
-  fx: Fx<R, E, A>,
-  f: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, Option.Option<Cause.Cause<E3>>>
-): Fx<R | R2, E2 | E3, A> {
+export function filterMapCauseEffect<A, E, R, R2, E2, E3>(
+  fx: Fx<A, E, R>,
+  f: (cause: Cause.Cause<E>) => Effect.Effect<Option.Option<Cause.Cause<E3>>, E2, R2>
+): Fx<A, E2 | E3, R | R2> {
   return new TransformerCause(fx, EffectOp.FilterMapEffect(f))
 }
 
-export function filterMapErrorEffect<R, E, A, R2, E2, E3>(
-  fx: Fx<R, E, A>,
-  f: (e: E) => Effect.Effect<R2, E2, Option.Option<E3>>
-): Fx<R | R2, E2 | E3, A> {
+export function filterMapErrorEffect<A, E, R, R2, E2, E3>(
+  fx: Fx<A, E, R>,
+  f: (e: E) => Effect.Effect<Option.Option<E3>, E2, R2>
+): Fx<A, E2 | E3, R | R2> {
   return filterMapCauseEffect(fx, (cause) =>
     Either.match(Cause.failureOrCause(cause), {
       onLeft: (e) => Effect.map(f(e), Option.map(Cause.fail)),
@@ -1950,19 +1949,19 @@ export function filterMapErrorEffect<R, E, A, R2, E2, E3>(
     }))
 }
 
-export function loopCause<R, E, A, B, C>(
-  fx: Fx<R, E, A>,
+export function loopCause<A, E, R, B, C>(
+  fx: Fx<A, E, R>,
   seed: B,
   f: (b: B, cause: Cause.Cause<E>) => readonly [Cause.Cause<C>, B]
-): Fx<R, C, A> {
+): Fx<A, C, R> {
   return new TransformerCause(fx, SyncLoopOp.LoopOperator(seed, f))
 }
 
-export function loopError<R, E, A, B, C>(
-  fx: Fx<R, E, A>,
+export function loopError<A, E, R, B, C>(
+  fx: Fx<A, E, R>,
   seed: B,
   f: (b: B, e: E) => readonly [C, B]
-): Fx<R, C, A> {
+): Fx<A, C, R> {
   return loopCause(fx, seed, (b, cause) =>
     Either.match(Cause.failureOrCause(cause), {
       onLeft: (e) => {
@@ -1973,18 +1972,18 @@ export function loopError<R, E, A, B, C>(
     }))
 }
 
-export function loopCauseEffect<R, E, A, R2, E2, B, C>(
-  fx: Fx<R, E, A>,
+export function loopCauseEffect<A, E, R, B, E2, R2, C>(
+  fx: Fx<A, E, R>,
   seed: B,
-  f: (b: B, cause: Cause.Cause<E>) => Effect.Effect<R2, E2, readonly [Cause.Cause<C>, B]>
-): Fx<R | R2, E2 | C, A> {
+  f: (b: B, cause: Cause.Cause<E>) => Effect.Effect<readonly [Cause.Cause<C>, B], E2, R2>
+): Fx<A, E2 | C, R | R2> {
   return new TransformerCause(fx, EffectLoopOp.LoopEffectOperator(seed, f))
 }
 
-export function loopErrorEffect<R, E, A, R2, E2, B, C>(
-  fx: Fx<R, E, A>,
+export function loopErrorEffect<A, E, R, B, E2, R2, C>(
+  fx: Fx<A, E, R>,
   seed: B,
-  f: (b: B, e: E) => Effect.Effect<R2, E2, readonly [C, B]>
+  f: (b: B, e: E) => Effect.Effect<readonly [C, B], E2, R2>
 ) {
   return loopCauseEffect(fx, seed, (b, cause) =>
     Either.match(Cause.failureOrCause(cause), {
@@ -1993,16 +1992,16 @@ export function loopErrorEffect<R, E, A, R2, E2, B, C>(
     }))
 }
 
-export function filterMapLoopCause<R, E, A, B, C>(
-  fx: Fx<R, E, A>,
+export function filterMapLoopCause<A, E, R, B, C>(
+  fx: Fx<A, E, R>,
   seed: B,
   f: (b: B, cause: Cause.Cause<E>) => readonly [Option.Option<Cause.Cause<C>>, B]
-): Fx<R, C, A> {
+): Fx<A, C, R> {
   return new TransformerCause(fx, SyncLoopOp.FilterMapLoopOperator(seed, f))
 }
 
-export function filterMapLoopError<R, E, A, B, C>(
-  fx: Fx<R, E, A>,
+export function filterMapLoopError<A, E, R, B, C>(
+  fx: Fx<A, E, R>,
   seed: B,
   f: (b: B, e: E) => readonly [Option.Option<C>, B]
 ) {
@@ -2016,18 +2015,18 @@ export function filterMapLoopError<R, E, A, B, C>(
     }))
 }
 
-export function filterMapLoopCauseEffect<R, E, A, R2, E2, B, C>(
-  fx: Fx<R, E, A>,
+export function filterMapLoopCauseEffect<A, E, R, B, E2, R2, C>(
+  fx: Fx<A, E, R>,
   seed: B,
-  f: (b: B, cause: Cause.Cause<E>) => Effect.Effect<R2, E2, readonly [Option.Option<Cause.Cause<C>>, B]>
-): Fx<R | R2, E2 | C, A> {
+  f: (b: B, cause: Cause.Cause<E>) => Effect.Effect<readonly [Option.Option<Cause.Cause<C>>, B], E2, R2>
+): Fx<A, E2 | C, R | R2> {
   return new TransformerCause(fx, EffectLoopOp.FilterMapLoopEffectOperator(seed, f))
 }
 
-export function filterMapLoopErrorEffect<R, E, A, R2, E2, B, C>(
-  fx: Fx<R, E, A>,
+export function filterMapLoopErrorEffect<A, E, R, B, E2, R2, C>(
+  fx: Fx<A, E, R>,
   seed: B,
-  f: (b: B, e: E) => Effect.Effect<R2, E2, readonly [Option.Option<C>, B]>
+  f: (b: B, e: E) => Effect.Effect<readonly [Option.Option<C>, B], E2, R2>
 ) {
   return filterMapLoopCauseEffect(fx, seed, (b, cause) =>
     Either.match(Cause.failureOrCause(cause), {
@@ -2036,31 +2035,31 @@ export function filterMapLoopErrorEffect<R, E, A, R2, E2, B, C>(
     }))
 }
 
-class TransformerCause<R, E, A, R2, E2> extends FxBase<R | R2, E2, A> {
-  constructor(readonly i0: Fx<R, E, A>, readonly i1: Op.Operator) {
+class TransformerCause<A, E, R, R2, E2> extends FxBase<A, E2, R | R2> {
+  constructor(readonly i0: Fx<A, E, R>, readonly i1: Op.Operator) {
     super()
   }
 
-  run<R2>(sink: Sink.Sink<R2, E2, A>): Effect.Effect<R | R2, never, unknown> {
+  run<R2>(sink: Sink.Sink<A, E2, R2>): Effect.Effect<unknown, never, R | R2> {
     return this.i0.run(Op.compileOperatorSinkCause(this.i1, sink))
   }
 }
 
-export function flatMapCauseWithStrategy<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
+export function flatMapCauseWithStrategy<A, E, R, B, E2, R2>(
+  fx: Fx<A, E, R>,
+  f: (cause: Cause.Cause<E>) => Fx<B, E2, R2>,
   flattenStrategy: FlattenStrategy,
   executionStrategy: ExecutionStrategy.ExecutionStrategy = ExecutionStrategy.sequential
-): Fx<R | R2 | Scope.Scope, E2, A | B> {
+): Fx<A | B, E2, R | R2 | Scope.Scope> {
   return new FlatMapCauseWithStrategy(fx, f, flattenStrategy, executionStrategy)
 }
 
-export function flatMapErrorWithStrategy<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (e: E) => Fx<R2, E2, B>,
+export function flatMapErrorWithStrategy<A, E, R, B, E2, R2>(
+  fx: Fx<A, E, R>,
+  f: (e: E) => Fx<B, E2, R2>,
   flattenStrategy: FlattenStrategy,
   executionStrategy: ExecutionStrategy.ExecutionStrategy = ExecutionStrategy.sequential
-): Fx<R | R2 | Scope.Scope, E2, A | B> {
+): Fx<A | B, E2, R | R2 | Scope.Scope> {
   return flatMapCauseWithStrategy(
     fx,
     (cause) =>
@@ -2073,107 +2072,107 @@ export function flatMapErrorWithStrategy<R, E, A, R2, E2, B>(
   )
 }
 
-export function switchMapCause<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
+export function switchMapCause<A, E, R, B, E2, R2>(
+  fx: Fx<A, E, R>,
+  f: (cause: Cause.Cause<E>) => Fx<B, E2, R2>,
   executionStrategy?: ExecutionStrategy.ExecutionStrategy
-): Fx<R | R2 | Scope.Scope, E2, A | B> {
+): Fx<A | B, E2, R | R2 | Scope.Scope> {
   return flatMapCauseWithStrategy(fx, f, Switch, executionStrategy)
 }
 
-export function switchMapError<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (e: E) => Fx<R2, E2, B>,
+export function switchMapError<A, E, R, B, E2, R2>(
+  fx: Fx<A, E, R>,
+  f: (e: E) => Fx<B, E2, R2>,
   executionStrategy?: ExecutionStrategy.ExecutionStrategy
-): Fx<R | R2 | Scope.Scope, E2, A | B> {
+): Fx<A | B, E2, R | R2 | Scope.Scope> {
   return flatMapErrorWithStrategy(fx, f, Switch, executionStrategy)
 }
 
-export function flatMapCause<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
+export function flatMapCause<A, E, R, B, E2, R2>(
+  fx: Fx<A, E, R>,
+  f: (cause: Cause.Cause<E>) => Fx<B, E2, R2>,
   executionStrategy?: ExecutionStrategy.ExecutionStrategy
-): Fx<R | R2 | Scope.Scope, E2, A | B> {
+): Fx<A | B, E2, R | R2 | Scope.Scope> {
   return flatMapCauseWithStrategy(fx, f, Unbounded, executionStrategy)
 }
 
-export function flatMapError<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (e: E) => Fx<R2, E2, B>,
+export function flatMapError<A, E, R, B, E2, R2>(
+  fx: Fx<A, E, R>,
+  f: (e: E) => Fx<B, E2, R2>,
   executionStrategy?: ExecutionStrategy.ExecutionStrategy
-): Fx<R | R2 | Scope.Scope, E2, A | B> {
+): Fx<A | B, E2, R | R2 | Scope.Scope> {
   return flatMapErrorWithStrategy(fx, f, Unbounded, executionStrategy)
 }
 
-export function flatMapCauseConcurrently<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
+export function flatMapCauseConcurrently<A, E, R, B, E2, R2>(
+  fx: Fx<A, E, R>,
+  f: (cause: Cause.Cause<E>) => Fx<B, E2, R2>,
   concurrency: number,
   executionStrategy?: ExecutionStrategy.ExecutionStrategy
-): Fx<R | R2 | Scope.Scope, E2, A | B> {
+): Fx<A | B, E2, R | R2 | Scope.Scope> {
   return flatMapCauseWithStrategy(fx, f, Bounded(concurrency), executionStrategy)
 }
 
-export function flatMapErrorConcurrently<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (e: E) => Fx<R2, E2, B>,
+export function flatMapErrorConcurrently<A, E, R, B, E2, R2>(
+  fx: Fx<A, E, R>,
+  f: (e: E) => Fx<B, E2, R2>,
   concurrency: number,
   executionStrategy?: ExecutionStrategy.ExecutionStrategy
-): Fx<R | R2 | Scope.Scope, E2, A | B> {
+): Fx<A | B, E2, R | R2 | Scope.Scope> {
   return flatMapErrorWithStrategy(fx, f, Bounded(concurrency), executionStrategy)
 }
 
-export function exhaustMapCause<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
+export function exhaustMapCause<A, E, R, B, E2, R2>(
+  fx: Fx<A, E, R>,
+  f: (cause: Cause.Cause<E>) => Fx<B, E2, R2>,
   executionStrategy?: ExecutionStrategy.ExecutionStrategy
-): Fx<R | R2 | Scope.Scope, E2, A | B> {
+): Fx<A | B, E2, R | R2 | Scope.Scope> {
   return flatMapCauseWithStrategy(fx, f, Exhaust, executionStrategy)
 }
 
-export function exhaustMapError<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (e: E) => Fx<R2, E2, B>,
+export function exhaustMapError<A, E, R, B, E2, R2>(
+  fx: Fx<A, E, R>,
+  f: (e: E) => Fx<B, E2, R2>,
   executionStrategy?: ExecutionStrategy.ExecutionStrategy
-): Fx<R | R2 | Scope.Scope, E2, A | B> {
+): Fx<A | B, E2, R | R2 | Scope.Scope> {
   return flatMapErrorWithStrategy(fx, f, Exhaust, executionStrategy)
 }
 
-export function exhaustMapLatestCause<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
+export function exhaustMapLatestCause<A, E, R, B, E2, R2>(
+  fx: Fx<A, E, R>,
+  f: (cause: Cause.Cause<E>) => Fx<B, E2, R2>,
   executionStrategy?: ExecutionStrategy.ExecutionStrategy
-): Fx<R | R2 | Scope.Scope, E2, A | B> {
+): Fx<A | B, E2, R | R2 | Scope.Scope> {
   return flatMapCauseWithStrategy(fx, f, ExhaustLatest, executionStrategy)
 }
 
-export function exhaustMapLatestError<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (e: E) => Fx<R2, E2, B>,
+export function exhaustMapLatestError<A, E, R, B, E2, R2>(
+  fx: Fx<A, E, R>,
+  f: (e: E) => Fx<B, E2, R2>,
   executionStrategy?: ExecutionStrategy.ExecutionStrategy
-): Fx<R | R2 | Scope.Scope, E2, A | B> {
+): Fx<A | B, E2, R | R2 | Scope.Scope> {
   return flatMapErrorWithStrategy(fx, f, ExhaustLatest, executionStrategy)
 }
 
 class FlatMapCauseWithStrategy<
-  R,
-  E,
   A,
+  E,
+  R,
   R2,
   E2,
   B
-> extends FxBase<R | R2 | Scope.Scope, E2, A | B> {
-  private withFork: <R, E, A>(
+> extends FxBase<A | B, E2, R | R2 | Scope.Scope> {
+  private withFork: <A, E, R>(
     f: (
       fork: FxFork,
       scope: Scope.Scope
-    ) => Effect.Effect<R, E, A>,
+    ) => Effect.Effect<A, E, R>,
     executionStrategy: ExecutionStrategy.ExecutionStrategy
-  ) => Effect.Effect<Scope.Scope | R, E, void>
+  ) => Effect.Effect<void, E, Scope.Scope | R>
 
   constructor(
-    readonly i0: Fx<R, E, A>,
-    readonly i1: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
+    readonly i0: Fx<A, E, R>,
+    readonly i1: (cause: Cause.Cause<E>) => Fx<B, E2, R2>,
     readonly i2: FlattenStrategy,
     readonly i3: ExecutionStrategy.ExecutionStrategy
   ) {
@@ -2182,7 +2181,7 @@ class FlatMapCauseWithStrategy<
     this.withFork = withFlattenStrategy(this.i2)
   }
 
-  run<R3>(sink: Sink.Sink<R3, E | E2, A | B>): Effect.Effect<R | R2 | R3 | Scope.Scope, never, unknown> {
+  run<R3>(sink: Sink.Sink<A | B, E | E2, R3>): Effect.Effect<unknown, never, R | R2 | R3 | Scope.Scope> {
     return this.withFork(
       (fork) => this.i0.run(Sink.make((cause) => fork(this.i1(cause).run(sink)), (a) => sink.onSuccess(a))),
       this.i3
@@ -2191,28 +2190,28 @@ class FlatMapCauseWithStrategy<
 }
 
 class MatchWithStrategy<
-  R,
-  E,
   A,
+  E,
+  R,
   R2,
   E2,
   B,
   R3,
   E3,
   C
-> extends FxBase<R | R2 | R3 | Scope.Scope, E2 | E3, B | C> {
-  private withFork: <R, E, A>(
+> extends FxBase<B | C, E2 | E3, R | R2 | R3 | Scope.Scope> {
+  private withFork: <A, E, R>(
     f: (
       fork: FxFork,
       scope: Scope.Scope
-    ) => Effect.Effect<R, E, A>,
+    ) => Effect.Effect<A, E, R>,
     executionStrategy: ExecutionStrategy.ExecutionStrategy
-  ) => Effect.Effect<Scope.Scope | R, E, void>
+  ) => Effect.Effect<void, E, Scope.Scope | R>
 
   constructor(
-    readonly i0: Fx<R, E, A>,
-    readonly i1: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
-    readonly i2: (a: A) => Fx<R3, E3, C>,
+    readonly i0: Fx<A, E, R>,
+    readonly i1: (cause: Cause.Cause<E>) => Fx<B, E2, R2>,
+    readonly i2: (a: A) => Fx<C, E3, R3>,
     readonly i3: FlattenStrategy,
     readonly i4: ExecutionStrategy.ExecutionStrategy
   ) {
@@ -2221,7 +2220,7 @@ class MatchWithStrategy<
     this.withFork = withFlattenStrategy(this.i3)
   }
 
-  run<R4>(sink: Sink.Sink<R4, E2 | E3, B | C>): Effect.Effect<R | R2 | R3 | R4 | Scope.Scope, never, unknown> {
+  run<R4>(sink: Sink.Sink<B | C, E2 | E3, R4>): Effect.Effect<unknown, never, R | R2 | R3 | R4 | Scope.Scope> {
     return this.withFork(
       (fork) =>
         this.i0.run(Sink.make(
@@ -2233,17 +2232,17 @@ class MatchWithStrategy<
   }
 }
 
-export type MatchCauseOptions<E, A, R2, E2, B, R3, E3, C> = {
-  readonly onFailure: (cause: Cause.Cause<E>) => Fx<R2, E2, B>
-  readonly onSuccess: (a: A) => Fx<R3, E3, C>
+export type MatchCauseOptions<E, A, B, E2, R2, C, E3, R3> = {
+  readonly onFailure: (cause: Cause.Cause<E>) => Fx<B, E2, R2>
+  readonly onSuccess: (a: A) => Fx<C, E3, R3>
   readonly executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
 }
 
-export function matchCauseWithStrategy<R, E, A, R2, E2, B, R3, E3, C>(
-  fx: Fx<R, E, A>,
+export function matchCauseWithStrategy<A, E, R, B, E2, R2, C, E3, R3>(
+  fx: Fx<A, E, R>,
   flattenStrategy: FlattenStrategy,
-  opts: MatchCauseOptions<E, A, R2, E2, B, R3, E3, C>
-): Fx<R | R2 | R3 | Scope.Scope, E2 | E3, B | C> {
+  opts: MatchCauseOptions<E, A, B, E2, R2, C, E3, R3>
+): Fx<B | C, E2 | E3, R | R2 | R3 | Scope.Scope> {
   return new MatchWithStrategy(
     fx,
     opts.onFailure,
@@ -2253,17 +2252,17 @@ export function matchCauseWithStrategy<R, E, A, R2, E2, B, R3, E3, C>(
   )
 }
 
-export type MatchErrorOptions<E, A, R2, E2, B, R3, E3, C> = {
-  readonly onFailure: (e: E) => Fx<R2, E2, B>
-  readonly onSuccess: (a: A) => Fx<R3, E3, C>
+export type MatchErrorOptions<E, A, B, E2, R2, C, E3, R3> = {
+  readonly onFailure: (e: E) => Fx<B, E2, R2>
+  readonly onSuccess: (a: A) => Fx<C, E3, R3>
   readonly executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
 }
 
-export function matchErrorWithStrategy<R, E, A, R2, E2, B, R3, E3, C>(
-  fx: Fx<R, E, A>,
+export function matchErrorWithStrategy<A, E, R, B, E2, R2, C, E3, R3>(
+  fx: Fx<A, E, R>,
   flattenStrategy: FlattenStrategy,
-  { executionStrategy, onFailure, onSuccess }: MatchErrorOptions<E, A, R2, E2, B, R3, E3, C>
-): Fx<R | R2 | R3 | Scope.Scope, E2 | E3, B | C> {
+  { executionStrategy, onFailure, onSuccess }: MatchErrorOptions<E, A, B, E2, R2, C, E3, R3>
+): Fx<B | C, E2 | E3, R | R2 | R3 | Scope.Scope> {
   return new MatchWithStrategy(
     fx,
     (cause) =>
@@ -2277,74 +2276,74 @@ export function matchErrorWithStrategy<R, E, A, R2, E2, B, R3, E3, C>(
   )
 }
 
-export function matchCause<R, E, A, R2, E2, B, R3, E3, C>(
-  fx: Fx<R, E, A>,
-  opts: MatchCauseOptions<E, A, R2, E2, B, R3, E3, C>
+export function matchCause<A, E, R, B, E2, R2, C, E3, R3>(
+  fx: Fx<A, E, R>,
+  opts: MatchCauseOptions<E, A, B, E2, R2, C, E3, R3>
 ) {
   return matchCauseWithStrategy(fx, Unbounded, opts)
 }
 
-export function matchError<R, E, A, R2, E2, B, R3, E3, C>(
-  fx: Fx<R, E, A>,
-  opts: MatchErrorOptions<E, A, R2, E2, B, R3, E3, C>
+export function matchError<A, E, R, B, E2, R2, C, E3, R3>(
+  fx: Fx<A, E, R>,
+  opts: MatchErrorOptions<E, A, B, E2, R2, C, E3, R3>
 ) {
   return matchErrorWithStrategy(fx, Unbounded, opts)
 }
 
-export function matchCauseConcurrently<R, E, A, R2, E2, B, R3, E3, C>(
-  fx: Fx<R, E, A>,
+export function matchCauseConcurrently<A, E, R, B, E2, R2, C, E3, R3>(
+  fx: Fx<A, E, R>,
   concurrency: number,
-  opts: MatchCauseOptions<E, A, R2, E2, B, R3, E3, C>
+  opts: MatchCauseOptions<E, A, B, E2, R2, C, E3, R3>
 ) {
   return matchCauseWithStrategy(fx, Bounded(concurrency), opts)
 }
 
-export function matchErrorConcurrently<R, E, A, R2, E2, B, R3, E3, C>(
-  fx: Fx<R, E, A>,
+export function matchErrorConcurrently<A, E, R, B, E2, R2, C, E3, R3>(
+  fx: Fx<A, E, R>,
   concurrency: number,
-  opts: MatchErrorOptions<E, A, R2, E2, B, R3, E3, C>
+  opts: MatchErrorOptions<E, A, B, E2, R2, C, E3, R3>
 ) {
   return matchErrorWithStrategy(fx, Bounded(concurrency), opts)
 }
 
-export function switchMatchCause<R, E, A, R2, E2, B, R3, E3, C>(
-  fx: Fx<R, E, A>,
-  opts: MatchCauseOptions<E, A, R2, E2, B, R3, E3, C>
+export function switchMatchCause<A, E, R, B, E2, R2, C, E3, R3>(
+  fx: Fx<A, E, R>,
+  opts: MatchCauseOptions<E, A, B, E2, R2, C, E3, R3>
 ) {
   return matchCauseWithStrategy(fx, Switch, opts)
 }
 
-export function switchMatchError<R, E, A, R2, E2, B, R3, E3, C>(
-  fx: Fx<R, E, A>,
-  opts: MatchErrorOptions<E, A, R2, E2, B, R3, E3, C>
+export function switchMatchError<A, E, R, B, E2, R2, C, E3, R3>(
+  fx: Fx<A, E, R>,
+  opts: MatchErrorOptions<E, A, B, E2, R2, C, E3, R3>
 ) {
   return matchErrorWithStrategy(fx, Switch, opts)
 }
 
-export function exhaustMatchCause<R, E, A, R2, E2, B, R3, E3, C>(
-  fx: Fx<R, E, A>,
-  opts: MatchCauseOptions<E, A, R2, E2, B, R3, E3, C>
+export function exhaustMatchCause<A, E, R, B, E2, R2, C, E3, R3>(
+  fx: Fx<A, E, R>,
+  opts: MatchCauseOptions<E, A, B, E2, R2, C, E3, R3>
 ) {
   return matchCauseWithStrategy(fx, Exhaust, opts)
 }
 
-export function exhaustMatchError<R, E, A, R2, E2, B, R3, E3, C>(
-  fx: Fx<R, E, A>,
-  opts: MatchErrorOptions<E, A, R2, E2, B, R3, E3, C>
+export function exhaustMatchError<A, E, R, B, E2, R2, C, E3, R3>(
+  fx: Fx<A, E, R>,
+  opts: MatchErrorOptions<E, A, B, E2, R2, C, E3, R3>
 ) {
   return matchErrorWithStrategy(fx, Exhaust, opts)
 }
 
-export function exhaustMatchLatestCause<R, E, A, R2, E2, B, R3, E3, C>(
-  fx: Fx<R, E, A>,
-  opts: MatchCauseOptions<E, A, R2, E2, B, R3, E3, C>
+export function exhaustMatchLatestCause<A, E, R, B, E2, R2, C, E3, R3>(
+  fx: Fx<A, E, R>,
+  opts: MatchCauseOptions<E, A, B, E2, R2, C, E3, R3>
 ) {
   return matchCauseWithStrategy(fx, ExhaustLatest, opts)
 }
 
-export function exhaustMatchLatestError<R, E, A, R2, E2, B, R3, E3, C>(
-  fx: Fx<R, E, A>,
-  opts: MatchErrorOptions<E, A, R2, E2, B, R3, E3, C>
+export function exhaustMatchLatestError<A, E, R, B, E2, R2, C, E3, R3>(
+  fx: Fx<A, E, R>,
+  opts: MatchErrorOptions<E, A, B, E2, R2, C, E3, R3>
 ) {
   return matchErrorWithStrategy(fx, ExhaustLatest, opts)
 }
@@ -2352,29 +2351,29 @@ export function exhaustMatchLatestError<R, E, A, R2, E2, B, R3, E3, C>(
 export function tuple<const FX extends ReadonlyArray<Fx<any, any, any>>>(
   fx: FX
 ): Fx<
-  Fx.Context<FX[number]>,
-  Fx.Error<FX[number]>,
   {
     readonly [K in keyof FX]: Fx.Success<FX[K]>
-  }
+  },
+  Fx.Error<FX[number]>,
+  Fx.Context<FX[number]>
 > {
   return new Tuple(fx)
 }
 
 class Tuple<const FX extends ReadonlyArray<Fx<any, any, any>>> extends FxBase<
-  Fx.Context<FX[number]>,
-  Fx.Error<FX[number]>,
   {
     readonly [K in keyof FX]: Fx.Success<FX[K]>
-  }
+  },
+  Fx.Error<FX[number]>,
+  Fx.Context<FX[number]>
 > {
   constructor(readonly i0: FX) {
     super()
   }
 
   run<R2>(
-    sink: Sink.Sink<R2, Fx.Error<FX[number]>, { readonly [K in keyof FX]: Fx.Success<FX[K]> }>
-  ): Effect.Effect<Fx.Context<FX[number]> | R2, never, unknown> {
+    sink: Sink.Sink<{ readonly [K in keyof FX]: Fx.Success<FX[K]> }, Fx.Error<FX[number]>, R2>
+  ): Effect.Effect<unknown, never, Fx.Context<FX[number]> | R2> {
     return tupleSink(
       sink,
       (onSuccess) =>
@@ -2397,11 +2396,11 @@ class Tuple<const FX extends ReadonlyArray<Fx<any, any, any>>> extends FxBase<
 export function struct<const FX extends Readonly<Record<string, Fx<any, any, any>>>>(
   fx: FX
 ): Fx<
-  Fx.Context<FX[string]>,
-  Fx.Error<FX[string]>,
   {
     readonly [K in keyof FX]: Fx.Success<FX[K]>
-  }
+  },
+  Fx.Error<FX[string]>,
+  Fx.Context<FX[string]>
 > {
   const entries: ReadonlyArray<readonly [keyof FX, FX[keyof FX]]> = Object.entries(fx) as any
 
@@ -2410,57 +2409,45 @@ export function struct<const FX extends Readonly<Record<string, Fx<any, any, any
 
 export function all<const FX extends ReadonlyArray<Fx<any, any, any>>>(
   fx: FX
-): Fx<
-  Fx.Context<FX[number]>,
-  Fx.Error<FX[number]>,
-  { readonly [K in keyof FX]: Fx.Success<FX[K]> }
->
+): Fx<{ readonly [K in keyof FX]: Fx.Success<FX[K]> }, Fx.Error<FX[number]>, Fx.Context<FX[number]>>
 
 export function all<const FX extends Readonly<Record<string, Fx<any, any, any>>>>(
   fx: FX
-): Fx<
-  Fx.Context<FX[string]>,
-  Fx.Error<FX[string]>,
-  { readonly [K in keyof FX]: Fx.Success<FX[K]> }
->
+): Fx<{ readonly [K in keyof FX]: Fx.Success<FX[K]> }, Fx.Error<FX[string]>, Fx.Context<FX[string]>>
 
 export function all<const FX extends ReadonlyArray<Fx<any, any, any> | Readonly<Record<string, Fx<any, any, any>>>>>(
   fx: FX
-): Fx<
-  Fx.Context<FX[keyof FX]>,
-  Fx.Error<FX[keyof FX]>,
-  any
-> {
+): Fx<any, Fx.Error<FX[keyof FX]>, Fx.Context<FX[keyof FX]>> {
   if (Array.isArray(fx)) return tuple(fx)
   else return struct(fx as any) as any
 }
 
-export function exit<R, E, A>(
-  fx: Fx<R, E, A>
-): Fx<R, never, Exit.Exit<E, A>> {
+export function exit<A, E, R>(
+  fx: Fx<A, E, R>
+): Fx<Exit.Exit<A, E>, never, R> {
   return new ExitFx(fx)
 }
 
-class ExitFx<R, E, A> extends FxBase<R, never, Exit.Exit<E, A>> {
-  constructor(readonly i0: Fx<R, E, A>) {
+class ExitFx<A, E, R> extends FxBase<Exit.Exit<A, E>, never, R> {
+  constructor(readonly i0: Fx<A, E, R>) {
     super()
   }
 
-  run<R2>(sink: Sink.Sink<R2, never, Exit.Exit<E, A>>): Effect.Effect<R | R2, never, unknown> {
+  run<R2>(sink: Sink.Sink<Exit.Exit<A, E>, never, R2>): Effect.Effect<unknown, never, R | R2> {
     return this.i0.run(
       Sink.make((cause) => sink.onSuccess(Exit.failCause(cause)), (a) => sink.onSuccess(Exit.succeed(a)))
     )
   }
 }
 
-export function toEnqueue<R, E, A, R2 = never>(
-  fx: Fx<R, E, A>,
+export function toEnqueue<A, E, R, R2 = never>(
+  fx: Fx<A, E, R>,
   queue: Context.Enqueue<R2, A> | Queue.Enqueue<A>
 ) {
   return observe(fx, (a) => queue.offer(a))
 }
 
-export function debounce<R, E, A>(fx: Fx<R, E, A>, delay: Duration.DurationInput): Fx<R | Scope.Scope, E, A> {
+export function debounce<A, E, R>(fx: Fx<A, E, R>, delay: Duration.DurationInput): Fx<A, E, R | Scope.Scope> {
   return switchMapEffect(fx, (a) => Effect.as(Effect.sleep(delay), a))
 }
 
@@ -2468,27 +2455,27 @@ function emitAndSleep<A>(value: A, delay: Duration.DurationInput) {
   return make<A>((sink) => Effect.zipRight(sink.onSuccess(value), Effect.sleep(delay)))
 }
 
-export function throttle<R, E, A>(fx: Fx<R, E, A>, delay: Duration.DurationInput): Fx<R | Scope.Scope, E, A> {
+export function throttle<A, E, R>(fx: Fx<A, E, R>, delay: Duration.DurationInput): Fx<A, E, R | Scope.Scope> {
   return exhaustMap(fx, (a) => emitAndSleep(a, delay))
 }
 
-export function throttleLatest<R, E, A>(fx: Fx<R, E, A>, delay: Duration.DurationInput): Fx<R | Scope.Scope, E, A> {
+export function throttleLatest<A, E, R>(fx: Fx<A, E, R>, delay: Duration.DurationInput): Fx<A, E, R | Scope.Scope> {
   return exhaustMapLatest(fx, (a) => emitAndSleep(a, delay))
 }
 
-export function fromAsyncIterable<A>(iterable: AsyncIterable<A>): Fx<never, never, A> {
+export function fromAsyncIterable<A>(iterable: AsyncIterable<A>): Fx<A> {
   return new FromAsyncIterable(iterable)
 }
 
-class FromAsyncIterable<A> extends FxBase<never, never, A> {
+class FromAsyncIterable<A> extends FxBase<A, never, never> {
   constructor(readonly i0: AsyncIterable<A>) {
     super()
   }
 
-  run<R>(sink: Sink.Sink<R, never, A>): Effect.Effect<R, never, unknown> {
+  run<R>(sink: Sink.Sink<A, never, R>): Effect.Effect<unknown, never, R> {
     return Effect.asyncEffect((cb) => {
       const iterator = this.i0[Symbol.asyncIterator]()
-      const loop = (result: IteratorResult<A>): Effect.Effect<R, never, unknown> =>
+      const loop = (result: IteratorResult<A>): Effect.Effect<unknown, never, R> =>
         result.done
           ? Effect.sync(() => cb(Effect.unit))
           : Effect.zipRight(sink.onSuccess(result.value), Effect.flatMap(Effect.promise(() => iterator.next()), loop))
@@ -2501,26 +2488,26 @@ class FromAsyncIterable<A> extends FxBase<never, never, A> {
   }
 }
 
-export function findFirst<R, E, A>(fx: Fx<R, E, A>, predicate: Predicate.Predicate<A>): Effect.Effect<R, E, A> {
+export function findFirst<A, E, R>(fx: Fx<A, E, R>, predicate: Predicate.Predicate<A>): Effect.Effect<A, E, R> {
   return Effect.asyncEffect((cb) =>
     observe(fx, (a) => predicate(a) ? Effect.sync(() => cb(Effect.succeed(a))) : Effect.unit)
   )
 }
 
-export function first<R, E, A>(fx: Fx<R, E, A>): Effect.Effect<R, E, A> {
+export function first<A, E, R>(fx: Fx<A, E, R>): Effect.Effect<A, E, R> {
   return findFirst(fx, constTrue)
 }
 
-export function either<R, E, A>(fx: Fx<R, E, A>): Fx<R, never, Either.Either<E, A>> {
+export function either<A, E, R>(fx: Fx<A, E, R>): Fx<Either.Either<E, A>, never, R> {
   return new EitherFx(fx)
 }
 
-class EitherFx<R, E, A> extends FxBase<R, never, Either.Either<E, A>> {
-  constructor(readonly i0: Fx<R, E, A>) {
+class EitherFx<A, E, R> extends FxBase<Either.Either<E, A>, never, R> {
+  constructor(readonly i0: Fx<A, E, R>) {
     super()
   }
 
-  run<R2>(sink: Sink.Sink<R2, never, Either.Either<E, A>>): Effect.Effect<R | R2, never, unknown> {
+  run<R2>(sink: Sink.Sink<Either.Either<E, A>, never, R2>): Effect.Effect<unknown, never, R | R2> {
     return this.i0.run(
       Sink.make(
         (cause) =>
@@ -2534,26 +2521,26 @@ class EitherFx<R, E, A> extends FxBase<R, never, Either.Either<E, A>> {
   }
 }
 
-export function mergeFirst<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  that: Fx<R2, E2, B>
-): Fx<R | R2, E | E2, A> {
-  return merge(fx, filter(that, constFalse) as Fx<R2, E2, never>)
+export function mergeFirst<A, E, R, B, E2, R2>(
+  fx: Fx<A, E, R>,
+  that: Fx<B, E2, R2>
+): Fx<A, E | E2, R | R2> {
+  return merge(fx, filter(that, constFalse) as Fx<never, E2, R2>)
 }
 
-export function mergeRace<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  that: Fx<R2, E2, B>
-): Fx<R | R2, E | E2, A | B> {
+export function mergeRace<A, E, R, B, E2, R2>(
+  fx: Fx<A, E, R>,
+  that: Fx<B, E2, R2>
+): Fx<A | B, E | E2, R | R2> {
   return new MergeRace(fx, that)
 }
 
-class MergeRace<R, E, A, R2, E2, B> extends FxBase<R | R2, E | E2, A | B> {
-  constructor(readonly i0: Fx<R, E, A>, readonly i1: Fx<R2, E2, B>) {
+class MergeRace<A, E, R, B, E2, R2> extends FxBase<A | B, E | E2, R | R2> {
+  constructor(readonly i0: Fx<A, E, R>, readonly i1: Fx<B, E2, R2>) {
     super()
   }
 
-  run<R3>(sink: Sink.Sink<R3, E | E2, A | B>): Effect.Effect<R | R2 | R3, never, unknown> {
+  run<R3>(sink: Sink.Sink<A | B, E | E2, R3>): Effect.Effect<unknown, never, R | R2 | R3> {
     return Effect.gen(this, function*(_) {
       const fiber1 = yield* _(Effect.fork(this.i0.run(Sink.make(
         sink.onFailure,
@@ -2569,38 +2556,38 @@ class MergeRace<R, E, A, R2, E2, B> extends FxBase<R | R2, E | E2, A | B> {
 export function raceAll<const FX extends ReadonlyArray<Fx<any, any, any>>>(
   fx: FX
 ): Fx<
-  Fx.Context<FX[number]>,
+  Fx.Success<FX[number]>,
   Fx.Error<FX[number]>,
-  Fx.Success<FX[number]>
+  Fx.Context<FX[number]>
 > {
   return new RaceAll(fx)
 }
 
-export function race<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  that: Fx<R2, E2, B>
-): Fx<R | R2, E | E2, A | B> {
+export function race<A, E, R, B, E2, R2>(
+  fx: Fx<A, E, R>,
+  that: Fx<B, E2, R2>
+): Fx<A | B, E | E2, R | R2> {
   return raceAll([fx, that])
 }
 
 class RaceAll<const FX extends ReadonlyArray<Fx<any, any, any>>> extends FxBase<
-  Fx.Context<FX[number]>,
+  Fx.Success<FX[number]>,
   Fx.Error<FX[number]>,
-  Fx.Success<FX[number]>
+  Fx.Context<FX[number]>
 > {
   constructor(readonly i0: FX) {
     super()
   }
 
   run<R2>(
-    sink: Sink.Sink<R2, Fx.Error<FX[number]>, Fx.Success<FX[number]>>
-  ): Effect.Effect<Fx.Context<FX[number]> | R2, never, unknown> {
+    sink: Sink.Sink<Fx.Success<FX[number]>, Fx.Error<FX[number]>, R2>
+  ): Effect.Effect<unknown, never, Fx.Context<FX[number]> | R2> {
     return Effect.gen(this, function*(_) {
-      const winner = yield* _(Deferred.make<never, Fiber.RuntimeFiber<never, unknown>>())
-      const fibers: Array<Fiber.RuntimeFiber<never, unknown>> = []
+      const winner = yield* _(Deferred.make<Fiber.RuntimeFiber<unknown>>())
+      const fibers: Array<Fiber.RuntimeFiber<unknown>> = []
 
       for (const fx of this.i0) {
-        const fiber: Fiber.RuntimeFiber<never, unknown> = yield* _(Effect.fork(fx.run(Sink.make(
+        const fiber: Fiber.RuntimeFiber<unknown> = yield* _(Effect.fork(fx.run(Sink.make(
           sink.onFailure,
           (a) => Effect.flatMap(Deferred.succeed(winner, fiber), () => sink.onSuccess(a))
         ))))
@@ -2616,31 +2603,31 @@ class RaceAll<const FX extends ReadonlyArray<Fx<any, any, any>>> extends FxBase<
   }
 }
 
-export function snapshot<R, E, A, R2, E2, B, C>(
-  fx: Fx<R, E, A>,
-  sampled: Fx<R2, E2, B>,
+export function snapshot<A, E, R, B, E2, R2, C>(
+  fx: Fx<A, E, R>,
+  sampled: Fx<B, E2, R2>,
   f: (a: A, b: B) => C
-): Fx<R | R2, E | E2, C> {
+): Fx<C, E | E2, R | R2> {
   return new Snapshot(fx, sampled, f)
 }
 
-export function sample<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  sampled: Fx<R2, E2, B>
-): Fx<R | R2, E | E2, B> {
+export function sample<A, E, R, B, E2, R2>(
+  fx: Fx<A, E, R>,
+  sampled: Fx<B, E2, R2>
+): Fx<B, E | E2, R | R2> {
   return snapshot(fx, sampled, (_, b) => b)
 }
 
-class Snapshot<R, E, A, R2, E2, B, C> extends FxBase<R | R2, E | E2, C> {
+class Snapshot<A, E, R, B, E2, R2, C> extends FxBase<C, E | E2, R | R2> {
   constructor(
-    readonly i0: Fx<R, E, A>,
-    readonly i1: Fx<R2, E2, B>,
+    readonly i0: Fx<A, E, R>,
+    readonly i1: Fx<B, E2, R2>,
     readonly i2: (a: A, b: B) => C
   ) {
     super()
   }
 
-  run<R3>(sink: Sink.Sink<R3, E | E2, C>): Effect.Effect<R | R2 | R3, never, unknown> {
+  run<R3>(sink: Sink.Sink<C, E | E2, R3>): Effect.Effect<unknown, never, R | R2 | R3> {
     return Effect.flatMap(
       Ref.make(Option.none<B>()),
       (ref) =>
@@ -2665,24 +2652,24 @@ class Snapshot<R, E, A, R2, E2, B, C> extends FxBase<R | R2, E | E2, C> {
   }
 }
 
-export function snapshotEffect<R, E, A, R2, E2, B, R3, E3, C>(
-  fx: Fx<R, E, A>,
-  sampled: Fx<R2, E2, B>,
-  f: (a: A, b: B) => Effect.Effect<R3, E3, C>
-): Fx<R | R2 | R3, E | E2 | E3, C> {
+export function snapshotEffect<A, E, R, B, E2, R2, C, E3, R3>(
+  fx: Fx<A, E, R>,
+  sampled: Fx<B, E2, R2>,
+  f: (a: A, b: B) => Effect.Effect<C, E3, R3>
+): Fx<C, E | E2 | E3, R | R2 | R3> {
   return new SnapshotEffect(fx, sampled, f)
 }
 
-class SnapshotEffect<R, E, A, R2, E2, B, R3, E3, C> extends FxBase<R | R2 | R3, E | E2 | E3, C> {
+class SnapshotEffect<A, E, R, B, E2, R2, C, E3, R3> extends FxBase<C, E | E2 | E3, R | R2 | R3> {
   constructor(
-    readonly i0: Fx<R, E, A>,
-    readonly i1: Fx<R2, E2, B>,
-    readonly i2: (a: A, b: B) => Effect.Effect<R3, E3, C>
+    readonly i0: Fx<A, E, R>,
+    readonly i1: Fx<B, E2, R2>,
+    readonly i2: (a: A, b: B) => Effect.Effect<C, E3, R3>
   ) {
     super()
   }
 
-  run<R4>(sink: Sink.Sink<R4, E | E2 | E3, C>): Effect.Effect<R | R2 | R3 | R4, never, unknown> {
+  run<R4>(sink: Sink.Sink<C, E | E2 | E3, R4>): Effect.Effect<unknown, never, R | R2 | R3 | R4> {
     return Effect.flatMap(
       Ref.make(Option.none<B>()),
       (ref) =>
@@ -2710,38 +2697,38 @@ class SnapshotEffect<R, E, A, R2, E2, B, R3, E3, C> extends FxBase<R | R2 | R3,
   }
 }
 
-function if_<R, E, R2, E2, B, R3, E3, C>(
-  bool: Fx<R, E, boolean>,
+function if_<B, E, R, E2, R2, C, E3, R3>(
+  bool: Fx<boolean, E, R>,
   options: {
-    readonly onTrue: Fx<R2, E2, B>
-    readonly onFalse: Fx<R3, E3, C>
+    readonly onTrue: Fx<B, E2, R2>
+    readonly onFalse: Fx<C, E3, R3>
   }
-): Fx<R | R2 | R3 | Scope.Scope, E | E2 | E3, B | C> {
+): Fx<B | C, E | E2 | E3, R | R2 | R3 | Scope.Scope> {
   return switchMap(
     skipRepeatsWith(bool, boolean),
-    (b): Fx<R2 | R3, E2 | E3, B | C> => b ? options.onTrue : options.onFalse
+    (b): Fx<B | C, E2 | E3, R2 | R3> => b ? options.onTrue : options.onFalse
   )
 }
 
 export { if_ as if }
 
-export function when<R, E, B, C>(
-  bool: Fx<R, E, boolean>,
+export function when<B, E, R, C>(
+  bool: Fx<boolean, E, R>,
   options: {
     readonly onTrue: B
     readonly onFalse: C
   }
-): Fx<R | Scope.Scope, E, B | C> {
+): Fx<B | C, E, R | Scope.Scope> {
   return if_(bool, {
     onTrue: succeed(options.onTrue),
     onFalse: succeed(options.onFalse)
   })
 }
 
-export function mapBoth<R, E, A, B, C>(
-  fx: Fx<R, E, A>,
+export function mapBoth<A, E, R, B, C>(
+  fx: Fx<A, E, R>,
   f: (e: E) => B,
   g: (a: A) => C
-): Fx<R, B, C> {
+): Fx<C, B, R> {
   return map(mapError(fx, f), g)
 }