@typed/fx 1.22.2 → 1.24.0

package/src/internal/effect-loop-operator.ts

@@ -12,12 +12,12 @@ export type EffectLoopOperator<B = any, A = any, R = any, E = any, C = any> =
 export interface LoopEffectOperator<B, A, R, E, C> {
   readonly _tag: "LoopEffect"
   readonly seed: B
-  readonly f: (acc: B, a: A) => Effect.Effect<R, E, readonly [C, B]>
+  readonly f: (acc: B, a: A) => Effect.Effect<readonly [C, B], E, R>
 }
 
 export function LoopEffectOperator<const B, A, R, E, C>(
   seed: B,
-  f: (acc: B, a: A) => Effect.Effect<R, E, readonly [C, B]>
+  f: (acc: B, a: A) => Effect.Effect<readonly [C, B], E, R>
 ): LoopEffectOperator<B, A, R, E, C> {
   return { _tag: "LoopEffect", seed, f }
 }
@@ -25,17 +25,17 @@ export function LoopEffectOperator<const B, A, R, E, C>(
 export interface FilterMapLoopEffectOperator<B, A, R, E, C> {
   readonly _tag: "FilterMapLoopEffect"
   readonly seed: B
-  readonly f: (acc: B, a: A) => Effect.Effect<R, E, readonly [Option.Option<C>, B]>
+  readonly f: (acc: B, a: A) => Effect.Effect<readonly [Option.Option<C>, B], E, R>
 }
 
 export function FilterMapLoopEffectOperator<const B, A, R, E, C>(
   seed: B,
-  f: (acc: B, a: A) => Effect.Effect<R, E, readonly [Option.Option<C>, B]>
+  f: (acc: B, a: A) => Effect.Effect<readonly [Option.Option<C>, B], E, R>
 ): FilterMapLoopEffectOperator<B, A, R, E, C> {
   return { _tag: "FilterMapLoopEffect", seed, f }
 }
 
-export function compileLoopEffectOperatorSink<R>(operator: EffectLoopOperator, sink: Sink.Sink<R, any, any>) {
+export function compileLoopEffectOperatorSink<R>(operator: EffectLoopOperator, sink: Sink.Sink<any, any, R>) {
   return matchEffectLoopOperator(operator, {
     LoopEffect: (op) => Sink.loopEffect(sink, op.seed, op.f),
     FilterMapLoopEffect: (op) => Sink.filterMapLoopEffect(sink, op.seed, op.f)
@@ -457,8 +457,8 @@ export function matchEffectLoopOperator<A, B, R, E, C, D>(
 
 export function compileCauseLoopEffectOperatorSinkCause<R>(
   operator: EffectLoopOperator,
-  sink: Sink.Sink<R, any, any>
-): Sink.Sink<R, any, any> {
+  sink: Sink.Sink<any, any, R>
+): Sink.Sink<any, any, R> {
   return matchEffectLoopOperator(operator, {
     LoopEffect: (op) => Sink.loopCauseEffect(sink, op.seed, op.f),
     FilterMapLoopEffect: (op) => Sink.filterMapLoopCauseEffect(sink, op.seed, op.f)

package/src/internal/effect-operator.ts

@@ -13,44 +13,44 @@ export type EffectOperator =
   | FilterEffect<any, any, any>
   | FilterMapEffect<any, any, any, any>
 
-export interface MapEffect<A, R2, E2, B> {
+export interface MapEffect<A, B, E2, R2> {
   readonly _tag: "MapEffect"
-  readonly f: (a: A) => Effect.Effect<R2, E2, B>
+  readonly f: (a: A) => Effect.Effect<B, E2, R2>
 }
 
-export const MapEffect = <A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>): MapEffect<A, R2, E2, B> => ({
+export const MapEffect = <A, B, E2, R2>(f: (a: A) => Effect.Effect<B, E2, R2>): MapEffect<A, B, E2, R2> => ({
   _tag: "MapEffect",
   f
 })
 
-export interface TapEffect<A, R2, E2, B> {
+export interface TapEffect<A, B, E2, R2> {
   readonly _tag: "TapEffect"
-  readonly f: (a: A) => Effect.Effect<R2, E2, B>
+  readonly f: (a: A) => Effect.Effect<B, E2, R2>
 }
 
-export const TapEffect = <A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>): TapEffect<A, R2, E2, B> => ({
+export const TapEffect = <A, B, E2, R2>(f: (a: A) => Effect.Effect<B, E2, R2>): TapEffect<A, B, E2, R2> => ({
   _tag: "TapEffect",
   f
 })
 
 export interface FilterEffect<A, R2, E2> {
   readonly _tag: "FilterEffect"
-  readonly f: (a: A) => Effect.Effect<R2, E2, boolean>
+  readonly f: (a: A) => Effect.Effect<boolean, E2, R2>
 }
 
-export const FilterEffect = <A, R2, E2>(f: (a: A) => Effect.Effect<R2, E2, boolean>): FilterEffect<A, R2, E2> => ({
+export const FilterEffect = <A, R2, E2>(f: (a: A) => Effect.Effect<boolean, E2, R2>): FilterEffect<A, R2, E2> => ({
   _tag: "FilterEffect",
   f
 })
 
-export interface FilterMapEffect<A, R2, E2, B> {
+export interface FilterMapEffect<A, B, E2, R2> {
   readonly _tag: "FilterMapEffect"
-  readonly f: (a: A) => Effect.Effect<R2, E2, Option.Option<B>>
+  readonly f: (a: A) => Effect.Effect<Option.Option<B>, E2, R2>
 }
 
-export const FilterMapEffect = <A, R2, E2, B>(
-  f: (a: A) => Effect.Effect<R2, E2, Option.Option<B>>
-): FilterMapEffect<A, R2, E2, B> => ({ _tag: "FilterMapEffect", f })
+export const FilterMapEffect = <A, B, E2, R2>(
+  f: (a: A) => Effect.Effect<Option.Option<B>, E2, R2>
+): FilterMapEffect<A, B, E2, R2> => ({ _tag: "FilterMapEffect", f })
 
 type EffectOperatorFusionMap = {
   readonly [K in EffectOperator["_tag"]]: {
@@ -190,8 +190,8 @@ export function matchEffectOperator<A, B, C, D>(
 
 export function compileEffectOperatorSink<R>(
   operator: EffectOperator,
-  sink: Sink.Sink<R, any, any>
-): Sink.Sink<R, any, any> {
+  sink: Sink.Sink<any, any, R>
+): Sink.Sink<any, any, R> {
   return matchEffectOperator(operator, {
     MapEffect: (op) => Sink.mapEffect(sink, op.f),
     FilterEffect: (op) => Sink.filterEffect(sink, op.f),
@@ -202,8 +202,8 @@ export function compileEffectOperatorSink<R>(
 
 export function compileCauseEffectOperatorSink<R>(
   operator: EffectOperator,
-  sink: Sink.Sink<R, any, any>
-): Sink.Sink<R, any, any> {
+  sink: Sink.Sink<any, any, R>
+): Sink.Sink<any, any, R> {
   return matchEffectOperator(operator, {
     MapEffect: (op) =>
       Sink.make(
@@ -253,10 +253,10 @@ export function compileCauseEffectOperatorSink<R>(
   })
 }
 
-export function compileEffectLoop<B, A, R2, E2, C>(
+export function compileEffectLoop<B, A, C, E2, R2>(
   operator: EffectOperator,
-  loop: (b: B, a: A) => Effect.Effect<R2, E2, readonly [C, B]>
-): (b: B, i: any) => Effect.Effect<R2, E2, Option.Option<readonly [C, B]>> {
+  loop: (b: B, a: A) => Effect.Effect<readonly [C, B], E2, R2>
+): (b: B, i: any) => Effect.Effect<Option.Option<readonly [C, B]>, E2, R2> {
   return matchEffectOperator(operator, {
     MapEffect: (op) => (b, i) => Effect.map(Effect.flatMap(op.f(i), (a) => loop(b, a)), Option.some),
     TapEffect: (op) => (b, i) => Effect.map(Effect.flatMap(op.f(i), () => loop(b, i)), Option.some),
@@ -275,8 +275,8 @@ export function compileEffectLoop<B, A, R2, E2, C>(
 
 export function compileEffectReducer<B, A, R2, E2>(
   operator: EffectOperator,
-  loop: (b: B, a: A) => Effect.Effect<R2, E2, B>
-): (b: B, i: any) => Effect.Effect<R2, E2, Option.Option<B>> {
+  loop: (b: B, a: A) => Effect.Effect<B, E2, R2>
+): (b: B, i: any) => Effect.Effect<Option.Option<B>, E2, R2> {
   return matchEffectOperator(operator, {
     MapEffect: (op) => (b, i) => Effect.map(Effect.flatMap(op.f(i), (a) => loop(b, a)), Option.some),
     TapEffect: (op) => (b, i) => Effect.map(Effect.flatMap(op.f(i), () => loop(b, i)), Option.some),
@@ -298,7 +298,7 @@ export function runSyncReduce<A, B, R2, E2>(
   op: EffectOperator,
   seed: B,
   f: (acc: B, a: any) => B
-): Effect.Effect<R2, E2, B> {
+): Effect.Effect<B, E2, R2> {
   return matchEffectOperator(op, {
     MapEffect: (op) => SyncProducer.runReduceEffect(producer, seed, (acc, a) => Effect.map(op.f(a), (b) => f(acc, b))),
     TapEffect: (op) => SyncProducer.runReduceEffect(producer, seed, (acc, a) => Effect.map(op.f(a), () => f(acc, a))),

package/src/internal/effect-producer.ts

@@ -3,50 +3,50 @@ import * as Effect from "effect/Effect"
 import * as Schedule from "effect/Schedule"
 import type * as Sink from "../Sink.js"
 
-export type EffectProducer<R = any, E = any, A = any> =
-  | FromEffect<R, E, A>
-  | FromScheduled<R, E, any, A>
-  | Scheduled<R, E, A, any>
+export type EffectProducer<A = any, E = any, R = any> =
+  | FromEffect<A, E, R>
+  | FromScheduled<any, E, R, A>
+  | Scheduled<A, E, R, any>
 
-export interface FromEffect<R, E, A> {
+export interface FromEffect<A, E, R> {
   readonly _tag: "FromEffect"
-  readonly source: Effect.Effect<R, E, A>
+  readonly source: Effect.Effect<A, E, R>
 }
 
-export function FromEffect<R, E, A>(source: Effect.Effect<R, E, A>): FromEffect<R, E, A> {
+export function FromEffect<A, E, R>(source: Effect.Effect<A, E, R>): FromEffect<A, E, R> {
   return { _tag: "FromEffect", source }
 }
 
-export interface FromScheduled<R, E, I, O> {
+export interface FromScheduled<I, E, R, O> {
   readonly _tag: "FromScheduled"
-  readonly input: Effect.Effect<R, E, I>
+  readonly input: Effect.Effect<I, E, R>
   readonly schedule: Schedule.Schedule<R, I, O>
 }
 
-export function FromScheduled<R, E, R2, I, O>(
-  input: Effect.Effect<R, E, I>,
+export function FromScheduled<I, E, R, R2, O>(
+  input: Effect.Effect<I, E, R>,
   schedule: Schedule.Schedule<R2, I, O>
-): FromScheduled<R | R2, E, I, O> {
+): FromScheduled<I, E, R | R2, O> {
   return { _tag: "FromScheduled", schedule, input }
 }
 
-export interface Scheduled<R, E, A, O> {
+export interface Scheduled<A, E, R, O> {
   readonly _tag: "Scheduled"
-  readonly input: Effect.Effect<R, E, A>
+  readonly input: Effect.Effect<A, E, R>
   readonly schedule: Schedule.Schedule<R, unknown, O>
 }
 
-export function Scheduled<R, E, A, R2, O>(
-  input: Effect.Effect<R, E, A>,
+export function Scheduled<A, E, R, R2, O>(
+  input: Effect.Effect<A, E, R>,
   schedule: Schedule.Schedule<R2, unknown, O>
-): Scheduled<R | R2, E, A, O> {
+): Scheduled<A, E, R | R2, O> {
   return { _tag: "Scheduled", schedule, input }
 }
 
-export function runSink<R, E, A, R2>(
-  producer: EffectProducer<R, E, A>,
-  sink: Sink.Sink<R2, E, A>
-): Effect.Effect<R | R2, never, unknown> {
+export function runSink<A, E, R, R2>(
+  producer: EffectProducer<A, E, R>,
+  sink: Sink.Sink<A, E, R2>
+): Effect.Effect<unknown, never, R | R2> {
   switch (producer._tag) {
     case "FromEffect":
       return Effect.matchCauseEffect(producer.source, sink)
@@ -57,10 +57,10 @@ export function runSink<R, E, A, R2>(
   }
 }
 
-function runFromScheduled<R, E, I, O, R2>(
-  scheduled: FromScheduled<R, E, I, O>,
-  sink: Sink.Sink<R2, E, O>
-): Effect.Effect<R | R2, never, unknown> {
+function runFromScheduled<I, E, R, O, R2>(
+  scheduled: FromScheduled<I, E, R, O>,
+  sink: Sink.Sink<O, E, R2>
+): Effect.Effect<unknown, never, R | R2> {
   return Effect.catchAllCause(
     Effect.flatMap(
       scheduled.input,
@@ -70,20 +70,20 @@ function runFromScheduled<R, E, I, O, R2>(
   )
 }
 
-function runSchedule<R, E, A, O, R2>(
-  scheduled: Scheduled<R, E, A, O>,
-  sink: Sink.Sink<R2, E, A>
-): Effect.Effect<R | R2, never, unknown> {
+function runSchedule<A, E, R, O, R2>(
+  scheduled: Scheduled<A, E, R, O>,
+  sink: Sink.Sink<A, E, R2>
+): Effect.Effect<unknown, never, R | R2> {
   return Effect.catchAllCause(
     Effect.schedule(Effect.matchCauseEffect(scheduled.input, sink), scheduled.schedule),
     sink.onFailure
   )
 }
 
-export function runEffect<R, E, A, R2, E2, B>(
-  producer: EffectProducer<R, E, A>,
-  f: (a: A) => Effect.Effect<R2, E2, B>
-): Effect.Effect<R | R2, E | E2, unknown> {
+export function runEffect<A, E, R, B, E2, R2>(
+  producer: EffectProducer<A, E, R>,
+  f: (a: A) => Effect.Effect<B, E2, R2>
+): Effect.Effect<unknown, E | E2, R | R2> {
   switch (producer._tag) {
     case "FromEffect":
       return Effect.flatMap(producer.source, f)
@@ -91,7 +91,7 @@ export function runEffect<R, E, A, R2, E2, B>(
       return Effect.flatMap(
         producer.input,
         (i) =>
-          Effect.asyncEffect<never, E | E2, unknown, R | R2, never, unknown>((resume) => {
+          Effect.asyncEffect<unknown, E | E2, never, unknown, never, R | R2>((resume) => {
             const onFailure = (cause: Cause.Cause<E | E2>) => Effect.succeed(resume(Effect.failCause(cause)))
 
             return Effect.matchCauseEffect(
@@ -112,11 +112,11 @@ export function runEffect<R, E, A, R2, E2, B>(
   }
 }
 
-export function runReduceEffect<R, E, A, R2, E2, B>(
-  producer: EffectProducer<R, E, A>,
+export function runReduceEffect<A, E, R, B, E2, R2>(
+  producer: EffectProducer<A, E, R>,
   initial: B,
-  f: (b: B, a: A) => Effect.Effect<R2, E2, B>
-): Effect.Effect<R | R2, E | E2, B> {
+  f: (b: B, a: A) => Effect.Effect<B, E2, R2>
+): Effect.Effect<B, E | E2, R | R2> {
   return Effect.suspend(() => {
     let acc = initial
 

package/src/internal/helpers.ts

@@ -16,12 +16,12 @@ import * as TestClock from "effect/TestClock"
 import type { FlattenStrategy, FxFork, ScopedFork } from "../Fx.js"
 import type * as Sink from "../Sink.js"
 
-export function withBuffers<R, E, A>(size: number, sink: Sink.Sink<R, E, A>) {
+export function withBuffers<A, E, R>(size: number, sink: Sink.Sink<A, E, R>) {
   const buffers: Array<Array<A>> = Array.from({ length: size }, () => [])
   const finished = new Set<number>()
   let currentIndex = 0
 
-  const drainBuffer = (index: number): Effect.Effect<R, never, void> => {
+  const drainBuffer = (index: number): Effect.Effect<void, never, R> => {
     const effect = Effect.forEach(buffers[index], sink.onSuccess)
     buffers[index] = []
 
@@ -62,14 +62,14 @@ export function withBuffers<R, E, A>(size: number, sink: Sink.Sink<R, E, A>) {
   } as const
 }
 
-export const withScope = <R, E, A>(
-  f: (scope: Scope.CloseableScope) => Effect.Effect<R, E, A>,
+export const withScope = <A, E, R>(
+  f: (scope: Scope.CloseableScope) => Effect.Effect<A, E, R>,
   executionStrategy: ExecutionStrategy.ExecutionStrategy
-): Effect.Effect<R | Scope.Scope, E, A> =>
+): Effect.Effect<A, E, R | Scope.Scope> =>
   Effect.acquireUseRelease(Effect.scopeWith((scope) => Scope.fork(scope, executionStrategy)), f, Scope.close)
 
 export const getExitEquivalence = <E, A>(A: Equivalence.Equivalence<A>) =>
-  Equivalence.make<Exit.Exit<E, A>>((a, b) => {
+  Equivalence.make<Exit.Exit<A, E>>((a, b) => {
     if (a._tag === "Failure") {
       return b._tag === "Failure" && Equal.equals(a.cause, b.cause)
     } else {
@@ -77,16 +77,16 @@ export const getExitEquivalence = <E, A>(A: Equivalence.Equivalence<A>) =>
     }
   })
 
-export function withScopedFork<R, E, A>(
-  f: (fork: ScopedFork, scope: Scope.CloseableScope) => Effect.Effect<R, E, A>,
+export function withScopedFork<A, E, R>(
+  f: (fork: ScopedFork, scope: Scope.CloseableScope) => Effect.Effect<A, E, R>,
   executionStrategy: ExecutionStrategy.ExecutionStrategy
-): Effect.Effect<R | Scope.Scope, E, A> {
+): Effect.Effect<A, E, R | Scope.Scope> {
   return withScope((scope) => f(makeForkInScope(scope), scope), executionStrategy)
 }
 
 export function makeForkInScope(scope: Scope.Scope) {
-  return <R, E, A>(effect: Effect.Effect<R, E, A>) =>
-    matchEffectPrimitive<R, E, A, Effect.Effect<R, never, Fiber.Fiber<E, A>>>(effect, {
+  return <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+    matchEffectPrimitive<A, E, R, Effect.Effect<Fiber.Fiber<A, E>, never, R>>(effect, {
       Success: (a) => Effect.succeed(Fiber.succeed(a)),
       Failure: (cause) => Effect.succeed(Fiber.failCause(cause)),
       Sync: (f) =>
@@ -105,25 +105,25 @@ export function makeForkInScope(scope: Scope.Scope) {
     })
 }
 
-export function withSwitchFork<R, E, A>(
-  f: (fork: FxFork, scope: Scope.CloseableScope) => Effect.Effect<R, E, A>,
+export function withSwitchFork<A, E, R>(
+  f: (fork: FxFork, scope: Scope.CloseableScope) => Effect.Effect<A, E, R>,
   executionStrategy: ExecutionStrategy.ExecutionStrategy
 ) {
   return withScopedFork(
     (fork, scope) =>
       Effect.flatMap(
-        SynchronizedRef.make<Fiber.Fiber<never, unknown>>(Fiber.unit),
+        SynchronizedRef.make<Fiber.Fiber<unknown>>(Fiber.unit),
         (ref) => runSwitchFork(ref, fork, scope, f)
       ),
     executionStrategy
   )
 }
 
-export function runSwitchFork<R, E, A>(
-  ref: SynchronizedRef.SynchronizedRef<Fiber.Fiber<never, unknown>>,
+export function runSwitchFork<A, E, R>(
+  ref: SynchronizedRef.SynchronizedRef<Fiber.Fiber<unknown>>,
   fork: ScopedFork,
   scope: Scope.CloseableScope,
-  f: (fork: FxFork, scope: Scope.CloseableScope) => Effect.Effect<R, E, A>
+  f: (fork: FxFork, scope: Scope.CloseableScope) => Effect.Effect<A, E, R>
 ) {
   return Effect.zipRight(
     f(
@@ -142,13 +142,13 @@ export function runSwitchFork<R, E, A>(
   )
 }
 
-export function withExhaustFork<R, E, A>(
-  f: (fork: FxFork, scope: Scope.Scope) => Effect.Effect<R, E, A>,
+export function withExhaustFork<A, E, R>(
+  f: (fork: FxFork, scope: Scope.Scope) => Effect.Effect<A, E, R>,
   executionStrategy: ExecutionStrategy.ExecutionStrategy
 ) {
   return withScopedFork((fork, scope) => {
     return Effect.flatMap(
-      SynchronizedRef.make<Fiber.Fiber<never, void> | null>(null),
+      SynchronizedRef.make<Fiber.Fiber<void> | null>(null),
       (ref) =>
         Effect.flatMap(
           f((effect) =>
@@ -170,15 +170,15 @@ export function withExhaustFork<R, E, A>(
   }, executionStrategy)
 }
 
-export function withExhaustLatestFork<R, E, A>(
-  f: (exhaustLatestFork: FxFork, scope: Scope.Scope) => Effect.Effect<R, E, A>,
+export function withExhaustLatestFork<A, E, R>(
+  f: (exhaustLatestFork: FxFork, scope: Scope.Scope) => Effect.Effect<A, E, R>,
   executionStrategy: ExecutionStrategy.ExecutionStrategy
 ) {
   return withScopedFork((fork, scope) =>
     Effect.flatMap(
       Effect.zip(
-        Ref.make<Fiber.Fiber<never, void> | void>(undefined),
-        Ref.make<Option.Option<Effect.Effect<any, never, void>>>(Option.none())
+        Ref.make<Fiber.Fiber<void> | void>(undefined),
+        Ref.make<Option.Option<Effect.Effect<void, never, any>>>(Option.none())
       ),
       ([ref, nextEffect]) => {
         const reset = Ref.set(ref, undefined)
@@ -188,7 +188,7 @@ export function withExhaustLatestFork<R, E, A>(
 
         // Run the next value that's be saved for replay if it exists
 
-        const runNext: Effect.Effect<any, never, void> = Effect.flatMap(
+        const runNext: Effect.Effect<void, never, any> = Effect.flatMap(
           Ref.get(nextEffect),
           (next) => {
             if (Option.isNone(next)) {
@@ -206,7 +206,7 @@ export function withExhaustLatestFork<R, E, A>(
           }
         )
 
-        const exhaustLatestFork = <R2>(eff: Effect.Effect<R2, never, void>) =>
+        const exhaustLatestFork = <R2>(eff: Effect.Effect<void, never, R2>) =>
           Effect.flatMap(Ref.get(ref), (currentFiber) =>
             currentFiber
               ? Ref.set(nextEffect, Option.some(eff))
@@ -225,12 +225,12 @@ export function withExhaustLatestFork<R, E, A>(
     ), executionStrategy)
 }
 
-export function withUnboundedFork<R, E, A>(
-  f: (fork: FxFork, scope: Scope.Scope) => Effect.Effect<R, E, A>
+export function withUnboundedFork<A, E, R>(
+  f: (fork: FxFork, scope: Scope.Scope) => Effect.Effect<A, E, R>
 ) {
   return Effect.scopeWith((scope) =>
     Effect.flatMap(
-      FiberSet.make<never, void>(),
+      FiberSet.make<void, never>(),
       (set) =>
         Effect.flatMap(
           f((effect) => FiberSet.run(set, effect), scope),
@@ -241,13 +241,13 @@ export function withUnboundedFork<R, E, A>(
 }
 
 export function withBoundedFork(capacity: number) {
-  return <R, E, A>(
-    f: (fork: FxFork, scope: Scope.Scope) => Effect.Effect<R, E, A>,
+  return <A, E, R>(
+    f: (fork: FxFork, scope: Scope.Scope) => Effect.Effect<A, E, R>,
     executionStrategy: ExecutionStrategy.ExecutionStrategy
   ) => {
     return withScopedFork((fork, scope) =>
       Effect.flatMap(
-        Ref.make<Set<Fiber.Fiber<never, void>>>(new Set()).pipe(Effect.zip(Effect.makeSemaphore(capacity))),
+        Ref.make<Set<Fiber.Fiber<void>>>(new Set()).pipe(Effect.zip(Effect.makeSemaphore(capacity))),
         ([ref, semaphore]) =>
           Effect.flatMap(
             f((effect) =>
@@ -271,10 +271,10 @@ export function withBoundedFork(capacity: number) {
 
 export function withFlattenStrategy(
   strategy: FlattenStrategy
-): <R, E, A>(
-  f: (fork: FxFork, scope: Scope.Scope) => Effect.Effect<R, E, A>,
+): <A, E, R>(
+  f: (fork: FxFork, scope: Scope.Scope) => Effect.Effect<A, E, R>,
   executionStrategy: ExecutionStrategy.ExecutionStrategy
-) => Effect.Effect<R | Scope.Scope, E, void> {
+) => Effect.Effect<void, E, R | Scope.Scope> {
   switch (strategy._tag) {
     case "Bounded":
       return withBoundedFork(strategy.capacity)
@@ -289,8 +289,8 @@ export function withFlattenStrategy(
   }
 }
 
-export function matchEffectPrimitive<R, E, A, Z>(
-  effect: Effect.Effect<R, E, A>,
+export function matchEffectPrimitive<A, E, R, Z>(
+  effect: Effect.Effect<A, E, R>,
   matchers: {
     Success: (a: A) => Z
     Failure: (e: Cause.Cause<E>) => Z
@@ -299,7 +299,7 @@ export function matchEffectPrimitive<R, E, A, Z>(
     Right: (a: A) => Z
     Some: (a: A) => Z
     None: (e: E) => Z
-    Otherwise: (effect: Effect.Effect<R, E, A>) => Z
+    Otherwise: (effect: Effect.Effect<A, E, R>) => Z
   }
 ): Z {
   const eff = effect as any
@@ -339,9 +339,9 @@ export function adjustTime(input: Duration.DurationInput = 1) {
   )
 }
 
-export function tupleSink<R, E, A extends ReadonlyArray<any>, R2, E2, B>(
-  sink: Sink.Sink<R, E, A>,
-  f: (sink: (index: number, value: A[number]) => Effect.Effect<R, never, unknown>) => Effect.Effect<R2, E2, B>,
+export function tupleSink<A extends ReadonlyArray<any>, E, R, B, E2, R2>(
+  sink: Sink.Sink<A, E, R>,
+  f: (sink: (index: number, value: A[number]) => Effect.Effect<unknown, never, R>) => Effect.Effect<B, E2, R2>,
   expected: number
 ) {
   return Effect.suspend(() => {
@@ -361,14 +361,14 @@ export function tupleSink<R, E, A extends ReadonlyArray<any>, R2, E2, B>(
   })
 }
 
-export function withDebounceFork<R, E, A>(
-  f: (fork: FxFork, scope: Scope.Scope) => Effect.Effect<R, E, A>,
+export function withDebounceFork<A, E, R>(
+  f: (fork: FxFork, scope: Scope.Scope) => Effect.Effect<A, E, R>,
   duration: Duration.DurationInput
-): Effect.Effect<R | Scope.Scope, E, unknown> {
+): Effect.Effect<unknown, E, R | Scope.Scope> {
   return withScopedFork(
     (fork, scope) =>
       Effect.flatMap(
-        SynchronizedRef.make(Option.none<Fiber.Fiber<never, void>>()),
+        SynchronizedRef.make(Option.none<Fiber.Fiber<void>>()),
         (ref) =>
           Effect.flatMap(
             f(
@@ -417,8 +417,8 @@ export class RingBuffer<A> {
     }
   }
 
-  forEach<R2, E2, B>(
-    f: (a: A, i: number) => Effect.Effect<R2, E2, B>
+  forEach<B, E2, R2>(
+    f: (a: A, i: number) => Effect.Effect<B, E2, R2>
   ) {
     switch (this._size) {
       case 0:
@@ -450,16 +450,16 @@ export class RingBuffer<A> {
 }
 
 export function awaitScopeClose(scope: Scope.Scope) {
-  return Effect.asyncEffect<never, never, unknown, never, never, void>((cb) =>
+  return Effect.asyncEffect<unknown, never, never, void, never, never>((cb) =>
     Scope.addFinalizerExit(scope, () => Effect.sync(() => cb(Effect.unit)))
   )
 }
 
-export class MulticastEffect<R, E, A> extends Effectable.Class<R, E, A> {
-  private _fiber: Fiber.Fiber<E, A> | null = null
+export class MulticastEffect<A, E, R> extends Effectable.Class<A, E, R> {
+  private _fiber: Fiber.Fiber<A, E> | null = null
 
   constructor(
-    readonly effect: Effect.Effect<R, E, A>
+    readonly effect: Effect.Effect<A, E, R>
   ) {
     super()
   }

package/src/internal/keyed.ts

@@ -8,10 +8,10 @@ import { diffIterator } from "./diff.js"
 import { withDebounceFork } from "./helpers.js"
 import { FxBase } from "./protos.js"
 
-export function keyed<R, E, A, B extends PropertyKey, R2, E2, C>(
-  fx: Fx<R, E, ReadonlyArray<A>>,
-  options: KeyedOptions<A, B, R2, E2, C>
-): Fx<R | R2 | Scope.Scope, E | E2, ReadonlyArray<C>> {
+export function keyed<A, E, R, B extends PropertyKey, C, E2, R2>(
+  fx: Fx<ReadonlyArray<A>, E, R>,
+  options: KeyedOptions<A, B, C, E2, R2>
+): Fx<ReadonlyArray<C>, E | E2, R | R2 | Scope.Scope> {
   return new Keyed(fx, options)
 }
 
@@ -20,19 +20,19 @@ type StateContext<A, C> = {
   output: C
 }
 
-const StateContext = Context.Tag<StateContext<any, any>>()
+const StateContext = Context.GenericTag<StateContext<any, any>>("@services/StateContext")
 
-class Keyed<R, E, A, B extends PropertyKey, R2, E2, C> extends FxBase<R | R2 | Scope.Scope, E | E2, ReadonlyArray<C>>
-  implements Fx<R | R2 | Scope.Scope, E | E2, ReadonlyArray<C>>
+class Keyed<A, E, R, B extends PropertyKey, C, E2, R2> extends FxBase<ReadonlyArray<C>, E | E2, R | R2 | Scope.Scope>
+  implements Fx<ReadonlyArray<C>, E | E2, R | R2 | Scope.Scope>
 {
   constructor(
-    readonly fx: Fx<R, E, ReadonlyArray<A>>,
-    readonly options: KeyedOptions<A, B, R2, E2, C>
+    readonly fx: Fx<ReadonlyArray<A>, E, R>,
+    readonly options: KeyedOptions<A, B, C, E2, R2>
   ) {
     super()
   }
 
-  run<R3>(sink: Sink.Sink<R3, E | E2, ReadonlyArray<C>>) {
+  run<R3>(sink: Sink.Sink<ReadonlyArray<C>, E | E2, R3>) {
     return Effect.fiberIdWith((id) => runKeyed(this.fx, this.options, sink, id))
   }
 }
@@ -51,12 +51,12 @@ function emptyKeyedState<A, B extends PropertyKey, C>(): KeyedState<A, B, C> {
   }
 }
 
-function runKeyed<R, E, A, B extends PropertyKey, R2, E2, C, R3>(
-  fx: Fx<R, E, ReadonlyArray<A>>,
-  options: KeyedOptions<A, B, R2, E2, C>,
-  sink: Sink.Sink<R3, E | E2, ReadonlyArray<C>>,
+function runKeyed<A, E, R, B extends PropertyKey, C, E2, R2, R3>(
+  fx: Fx<ReadonlyArray<A>, E, R>,
+  options: KeyedOptions<A, B, C, E2, R2>,
+  sink: Sink.Sink<ReadonlyArray<C>, E | E2, R3>,
   id: FiberId.FiberId
-) {
+): Effect.Effect<unknown, never, Scope.Scope | R | R2 | R3> {
   return withDebounceFork(
     (forkDebounce, parentScope) => {
       const state = emptyKeyedState<A, B, C>()
@@ -126,8 +126,8 @@ class KeyedEntry<A, C> {
     public value: A,
     public index: number,
     public output: Option.Option<C>,
-    public readonly ref: RefSubject.RefSubject<never, never, A>,
-    public readonly interrupt: Effect.Effect<never, never, void>
+    public readonly ref: RefSubject.RefSubject<A>,
+    public readonly interrupt: Effect.Effect<void>
   ) {}
 }
 
@@ -158,14 +158,14 @@ function addValue<A, B extends PropertyKey, C, R2, E2, E, R3, D>(
   patch: Add<A, B>,
   id: FiberId.FiberId,
   parentScope: Scope.Scope,
-  options: KeyedOptions<A, B, R2, E2, C>,
-  sink: Sink.Sink<R2 | R3, E | E2, ReadonlyArray<C>>,
-  scheduleNextEmit: Effect.Effect<R3, never, D>
+  options: KeyedOptions<A, B, C, E2, R2>,
+  sink: Sink.Sink<ReadonlyArray<C>, E | E2, R2 | R3>,
+  scheduleNextEmit: Effect.Effect<D, never, R3>
 ) {
   return Effect.gen(function*(_) {
     const value = values[patch.index]
     const childScope = yield* _(Scope.fork(parentScope, ExecutionStrategy.sequential))
-    const ref: RefSubject.RefSubject<never, never, A> = yield* _(RefSubject.unsafeMake<never, A>({
+    const ref: RefSubject.RefSubject<A> = yield* _(RefSubject.unsafeMake<never, A>({
       initial: Effect.sync(() => entry.value),
       initialValue: value,
       scope: childScope,