effect 2.3.8 → 2.4.1

package/src/internal/groupBy.ts

@@ -13,7 +13,7 @@ import * as Queue from "../Queue.js"
 import * as Ref from "../Ref.js"
 import type * as Stream from "../Stream.js"
 import type * as Take from "../Take.js"
-import type { NoInfer } from "../Types.js"
+import type { MergeRecord, NoInfer } from "../Types.js"
 import * as channel from "./channel.js"
 import * as channelExecutor from "./channel/channelExecutor.js"
 import * as core from "./core-stream.js"
@@ -45,14 +45,14 @@ export const isGroupBy = (u: unknown): u is GroupBy.GroupBy<unknown, unknown, un
 
 /** @internal */
 export const evaluate = dual<
-  <K, E, V, R2, E2, A>(
+  <K, V, E, A, E2, R2>(
     f: (key: K, stream: Stream.Stream<V, E>) => Stream.Stream<A, E2, R2>,
     options?: {
       readonly bufferSize?: number | undefined
     }
-  ) => <R>(self: GroupBy.GroupBy<R, E, K, V>) => Stream.Stream<A, E | E2, R2 | R>,
-  <R, K, E, V, R2, E2, A>(
-    self: GroupBy.GroupBy<R, E, K, V>,
+  ) => <R>(self: GroupBy.GroupBy<K, V, E, R>) => Stream.Stream<A, E | E2, R2 | R>,
+  <K, V, E, R, A, E2, R2>(
+    self: GroupBy.GroupBy<K, V, E, R>,
     f: (key: K, stream: Stream.Stream<V, E>) => Stream.Stream<A, E2, R2>,
     options?: {
       readonly bufferSize?: number | undefined
@@ -60,8 +60,8 @@ export const evaluate = dual<
   ) => Stream.Stream<A, E | E2, R2 | R>
 >(
   (args) => isGroupBy(args[0]),
-  <R, K, E, V, R2, E2, A>(
-    self: GroupBy.GroupBy<R, E, K, V>,
+  <K, V, E, R, A, E2, R2>(
+    self: GroupBy.GroupBy<K, V, E, R>,
     f: (key: K, stream: Stream.Stream<V, E>) => Stream.Stream<A, E2, R2>,
     options?: {
       readonly bufferSize?: number | undefined
@@ -76,9 +76,9 @@ export const evaluate = dual<
 
 /** @internal */
 export const filter = dual<
-  <K>(predicate: Predicate<NoInfer<K>>) => <R, E, V>(self: GroupBy.GroupBy<R, E, K, V>) => GroupBy.GroupBy<R, E, K, V>,
-  <R, E, V, K>(self: GroupBy.GroupBy<R, E, K, V>, predicate: Predicate<K>) => GroupBy.GroupBy<R, E, K, V>
->(2, <R, E, V, K>(self: GroupBy.GroupBy<R, E, K, V>, predicate: Predicate<K>): GroupBy.GroupBy<R, E, K, V> =>
+  <K>(predicate: Predicate<NoInfer<K>>) => <V, E, R>(self: GroupBy.GroupBy<K, V, E, R>) => GroupBy.GroupBy<K, V, E, R>,
+  <K, V, E, R>(self: GroupBy.GroupBy<K, V, E, R>, predicate: Predicate<K>) => GroupBy.GroupBy<K, V, E, R>
+>(2, <K, V, E, R>(self: GroupBy.GroupBy<K, V, E, R>, predicate: Predicate<K>): GroupBy.GroupBy<K, V, E, R> =>
   make(
     pipe(
       self.grouped,
@@ -93,9 +93,9 @@ export const filter = dual<
 
 /** @internal */
 export const first = dual<
-  (n: number) => <R, E, K, V>(self: GroupBy.GroupBy<R, E, K, V>) => GroupBy.GroupBy<R, E, K, V>,
-  <R, E, K, V>(self: GroupBy.GroupBy<R, E, K, V>, n: number) => GroupBy.GroupBy<R, E, K, V>
->(2, <R, E, K, V>(self: GroupBy.GroupBy<R, E, K, V>, n: number): GroupBy.GroupBy<R, E, K, V> =>
+  (n: number) => <K, V, E, R>(self: GroupBy.GroupBy<K, V, E, R>) => GroupBy.GroupBy<K, V, E, R>,
+  <K, V, E, R>(self: GroupBy.GroupBy<K, V, E, R>, n: number) => GroupBy.GroupBy<K, V, E, R>
+>(2, <K, V, E, R>(self: GroupBy.GroupBy<K, V, E, R>, n: number): GroupBy.GroupBy<K, V, E, R> =>
   make(
     pipe(
       stream.zipWithIndex(self.grouped),
@@ -112,9 +112,9 @@ export const first = dual<
   ))
 
 /** @internal */
-export const make = <R, E, K, V>(
+export const make = <K, V, E, R>(
   grouped: Stream.Stream<readonly [K, Queue.Dequeue<Take.Take<V, E>>], E, R>
-): GroupBy.GroupBy<R, E, K, V> => ({
+): GroupBy.GroupBy<K, V, E, R> => ({
   [GroupByTypeId]: groupByVariance,
   pipe() {
     return pipeArguments(this, arguments)
@@ -126,28 +126,28 @@ export const make = <R, E, K, V>(
 
 /** @internal */
 export const groupBy = dual<
-  <A, R2, E2, K, V>(
+  <A, K, V, E2, R2>(
     f: (a: A) => Effect.Effect<readonly [K, V], E2, R2>,
     options?: {
       readonly bufferSize?: number | undefined
     }
-  ) => <R, E>(self: Stream.Stream<A, E, R>) => GroupBy.GroupBy<R2 | R, E2 | E, K, V>,
-  <R, E, A, R2, E2, K, V>(
+  ) => <E, R>(self: Stream.Stream<A, E, R>) => GroupBy.GroupBy<K, V, E2 | E, R2 | R>,
+  <A, E, R, K, V, E2, R2>(
     self: Stream.Stream<A, E, R>,
     f: (a: A) => Effect.Effect<readonly [K, V], E2, R2>,
     options?: {
       readonly bufferSize?: number | undefined
     }
-  ) => GroupBy.GroupBy<R2 | R, E2 | E, K, V>
+  ) => GroupBy.GroupBy<K, V, E2 | E, R2 | R>
 >(
   (args) => stream.isStream(args[0]),
-  <R, E, A, R2, E2, K, V>(
+  <A, E, R, K, V, E2, R2>(
     self: Stream.Stream<A, E, R>,
     f: (a: A) => Effect.Effect<readonly [K, V], E2, R2>,
     options?: {
       readonly bufferSize?: number | undefined
     }
-  ): GroupBy.GroupBy<R | R2, E | E2, K, V> =>
+  ): GroupBy.GroupBy<K, V, E | E2, R | R2> =>
     make(
       stream.unwrapScoped(
         Effect.gen(function*($) {
@@ -209,23 +209,23 @@ export const groupBy = dual<
 /** @internal */
 export const mapEffectOptions = dual<
   {
-    <A, R2, E2, A2>(
+    <A, A2, E2, R2>(
       f: (a: A) => Effect.Effect<A2, E2, R2>,
       options?: {
         readonly concurrency?: number | "unbounded" | undefined
         readonly unordered?: boolean | undefined
       }
-    ): <R, E>(self: Stream.Stream<A, E, R>) => Stream.Stream<A2, E2 | E, R2 | R>
-    <A, R2, E2, A2, K>(
+    ): <E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<A2, E2 | E, R2 | R>
+    <A, A2, E2, R2, K>(
       f: (a: A) => Effect.Effect<A2, E2, R2>,
       options: {
         readonly key: (a: A) => K
         readonly bufferSize?: number | undefined
       }
-    ): <R, E>(self: Stream.Stream<A, E, R>) => Stream.Stream<A2, E2 | E, R2 | R>
+    ): <E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<A2, E2 | E, R2 | R>
   },
   {
-    <R, E, A, R2, E2, A2>(
+    <A, E, R, A2, E2, R2>(
       self: Stream.Stream<A, E, R>,
       f: (a: A) => Effect.Effect<A2, E2, R2>,
       options?: {
@@ -233,7 +233,7 @@ export const mapEffectOptions = dual<
         readonly unordered?: boolean | undefined
       }
     ): Stream.Stream<A2, E2 | E, R2 | R>
-    <R, E, A, R2, E2, A2, K>(
+    <A, E, R, A2, E2, R2, K>(
       self: Stream.Stream<A, E, R>,
       f: (a: A) => Effect.Effect<A2, E2, R2>,
       options: {
@@ -244,7 +244,7 @@ export const mapEffectOptions = dual<
   }
 >(
   (args) => typeof args[0] !== "function",
-  (<R, E, A, R2, E2, A2, K>(
+  (<A, E, R, A2, E2, R2, K>(
     self: Stream.Stream<A, E, R>,
     f: (a: A) => Effect.Effect<A2, E2, R2>,
     options?: {
@@ -274,19 +274,19 @@ export const mapEffectOptions = dual<
 
 /** @internal */
 export const bindEffect = dual<
-  <N extends string, K, R2, E2, A>(
+  <N extends string, K, A, E2, R2>(
     tag: Exclude<N, keyof K>,
     f: (_: K) => Effect.Effect<A, E2, R2>,
     options?: {
       readonly concurrency?: number | "unbounded" | undefined
       readonly bufferSize?: number | undefined
     }
-  ) => <R, E>(self: Stream.Stream<K, E, R>) => Stream.Stream<
-    Effect.MergeRecord<K, { [k in N]: A }>,
+  ) => <E, R>(self: Stream.Stream<K, E, R>) => Stream.Stream<
+    MergeRecord<K, { [k in N]: A }>,
     E | E2,
     R | R2
   >,
-  <R, E, N extends string, K, R2, E2, A>(
+  <K, E, R, N extends string, A, E2, R2>(
     self: Stream.Stream<K, E, R>,
     tag: Exclude<N, keyof K>,
     f: (_: K) => Effect.Effect<A, E2, R2>,
@@ -295,11 +295,11 @@ export const bindEffect = dual<
       readonly unordered?: boolean | undefined
     }
   ) => Stream.Stream<
-    Effect.MergeRecord<K, { [k in N]: A }>,
+    MergeRecord<K, { [k in N]: A }>,
     E | E2,
     R | R2
   >
->((args) => typeof args[0] !== "string", <R, E, N extends string, K, R2, E2, A>(
+>((args) => typeof args[0] !== "string", <K, E, R, N extends string, A, E2, R2>(
   self: Stream.Stream<K, E, R>,
   tag: Exclude<N, keyof K>,
   f: (_: K) => Effect.Effect<A, E2, R2>,
@@ -311,7 +311,7 @@ export const bindEffect = dual<
   mapEffectOptions(self, (k) =>
     Effect.map(
       f(k),
-      (a): Effect.MergeRecord<K, { [k in N]: A }> => ({ ...k, [tag]: a } as any)
+      (a): MergeRecord<K, { [k in N]: A }> => ({ ...k, [tag]: a } as any)
     ), options))
 
 const mapDequeue = <A, B>(dequeue: Queue.Dequeue<A>, f: (a: A) => B): Queue.Dequeue<B> => new MapDequeue(dequeue, f)
@@ -399,23 +399,23 @@ export const groupByKey = dual<
     options?: {
       readonly bufferSize?: number | undefined
     }
-  ) => <R, E>(self: Stream.Stream<A, E, R>) => GroupBy.GroupBy<R, E, K, A>,
-  <R, E, A, K>(
+  ) => <E, R>(self: Stream.Stream<A, E, R>) => GroupBy.GroupBy<K, A, E, R>,
+  <A, E, R, K>(
     self: Stream.Stream<A, E, R>,
     f: (a: A) => K,
     options?: {
       readonly bufferSize?: number | undefined
     }
-  ) => GroupBy.GroupBy<R, E, K, A>
+  ) => GroupBy.GroupBy<K, A, E, R>
 >(
   (args) => typeof args[0] !== "function",
-  <R, E, A, K>(
+  <A, E, R, K>(
     self: Stream.Stream<A, E, R>,
     f: (a: A) => K,
     options?: {
       readonly bufferSize?: number | undefined
     }
-  ): GroupBy.GroupBy<R, E, K, A> => {
+  ): GroupBy.GroupBy<K, A, E, R> => {
     const loop = (
       map: Map<K, Queue.Queue<Take.Take<A, E>>>,
       outerQueue: Queue.Queue<Take.Take<readonly [K, Queue.Queue<Take.Take<A, E>>], E>>

package/src/internal/layer/circular.ts

@@ -81,10 +81,10 @@ export const replaceLogger = dual<
 
 /** @internal */
 export const replaceLoggerEffect = dual<
-  <R, E, B>(
+  <B, E, R>(
     that: Effect.Effect<Logger.Logger<unknown, B>, E, R>
   ) => <A>(self: Logger.Logger<unknown, A>) => Layer.Layer<never, E, R>,
-  <A, R, E, B>(
+  <A, B, E, R>(
     self: Logger.Logger<unknown, A>,
     that: Effect.Effect<Logger.Logger<unknown, B>, E, R>
   ) => Layer.Layer<never, E, R>
@@ -92,10 +92,10 @@ export const replaceLoggerEffect = dual<
 
 /** @internal */
 export const replaceLoggerScoped = dual<
-  <R, E, B>(
+  <B, E, R>(
     that: Effect.Effect<Logger.Logger<unknown, B>, E, R>
   ) => <A>(self: Logger.Logger<unknown, A>) => Layer.Layer<never, E, Exclude<R, Scope>>,
-  <A, R, E, B>(
+  <A, B, E, R>(
     self: Logger.Logger<unknown, A>,
     that: Effect.Effect<Logger.Logger<unknown, B>, E, R>
   ) => Layer.Layer<never, E, Exclude<R, Scope>>

package/src/internal/layer.ts

@@ -504,10 +504,10 @@ export const failCauseSync = <E>(evaluate: LazyArg<Cause.Cause<E>>): Layer.Layer
 
 /** @internal */
 export const flatMap = dual<
-  <A, R2, E2, A2>(
+  <A, A2, E2, R2>(
     f: (context: Context.Context<A>) => Layer.Layer<A2, E2, R2>
-  ) => <R, E>(self: Layer.Layer<A, E, R>) => Layer.Layer<A2, E | E2, R | R2>,
-  <R, E, A, R2, E2, A2>(
+  ) => <E, R>(self: Layer.Layer<A, E, R>) => Layer.Layer<A2, E | E2, R | R2>,
+  <A, E, R, A2, E2, R2>(
     self: Layer.Layer<A, E, R>,
     f: (context: Context.Context<A>) => Layer.Layer<A2, E2, R2>
   ) => Layer.Layer<A2, E | E2, R | R2>
@@ -515,12 +515,12 @@ export const flatMap = dual<
 
 /** @internal */
 export const flatten = dual<
-  <R2, E2, A, I>(
+  <I, A, E2, R2>(
     tag: Context.Tag<I, Layer.Layer<A, E2, R2>>
-  ) => <R, E>(
+  ) => <E, R>(
     self: Layer.Layer<I, E, R>
   ) => Layer.Layer<A, E | E2, R | R2>,
-  <R, E, A, R2, E2, I>(
+  <I, E, R, A, E2, R2>(
     self: Layer.Layer<I, E, R>,
     tag: Context.Tag<I, Layer.Layer<A, E2, R2>>
   ) => Layer.Layer<A, E | E2, R | R2>
@@ -553,7 +553,7 @@ export const fromEffect = dual<
 })
 
 /** @internal */
-export const fromEffectDiscard = <_, E, R>(effect: Effect.Effect<_, E, R>) =>
+export const fromEffectDiscard = <X, E, R>(effect: Effect.Effect<X, E, R>) =>
   fromEffectContext(core.map(effect, () => Context.empty()))
 
 /** @internal */
@@ -569,7 +569,7 @@ export function fromEffectContext<A, E, R>(
 /** @internal */
 export const fiberRefLocally = dual<
   <X>(ref: FiberRef<X>, value: X) => <A, E, R>(self: Layer.Layer<A, E, R>) => Layer.Layer<A, E, R>,
-  <R, E, A, X>(self: Layer.Layer<A, E, R>, ref: FiberRef<X>, value: X) => Layer.Layer<A, E, R>
+  <A, E, R, X>(self: Layer.Layer<A, E, R>, ref: FiberRef<X>, value: X) => Layer.Layer<A, E, R>
 >(3, (self, ref, value) => locallyEffect(self, core.fiberRefLocally(ref, value)))
 
 /** @internal */
@@ -592,7 +592,7 @@ export const locallyEffect = dual<
 /** @internal */
 export const fiberRefLocallyWith = dual<
   <X>(ref: FiberRef<X>, value: (_: X) => X) => <A, E, R>(self: Layer.Layer<A, E, R>) => Layer.Layer<A, E, R>,
-  <R, E, A, X>(self: Layer.Layer<A, E, R>, ref: FiberRef<X>, value: (_: X) => X) => Layer.Layer<A, E, R>
+  <A, E, R, X>(self: Layer.Layer<A, E, R>, ref: FiberRef<X>, value: (_: X) => X) => Layer.Layer<A, E, R>
 >(3, (self, ref, value) => locallyEffect(self, core.fiberRefLocallyWith(ref, value)))
 
 /** @internal */
@@ -624,8 +624,8 @@ export const launch = <RIn, E, ROut>(self: Layer.Layer<ROut, E, RIn>): Effect.Ef
 export const map = dual<
   <A, B>(
     f: (context: Context.Context<A>) => Context.Context<B>
-  ) => <R, E>(self: Layer.Layer<A, E, R>) => Layer.Layer<B, E, R>,
-  <R, E, A, B>(
+  ) => <E, R>(self: Layer.Layer<A, E, R>) => Layer.Layer<B, E, R>,
+  <A, E, R, B>(
     self: Layer.Layer<A, E, R>,
     f: (context: Context.Context<A>) => Context.Context<B>
   ) => Layer.Layer<B, E, R>
@@ -633,19 +633,19 @@ export const map = dual<
 
 /** @internal */
 export const mapError = dual<
-  <E, E2>(f: (error: E) => E2) => <R, A>(self: Layer.Layer<A, E, R>) => Layer.Layer<A, E2, R>,
-  <R, E, A, E2>(self: Layer.Layer<A, E, R>, f: (error: E) => E2) => Layer.Layer<A, E2, R>
+  <E, E2>(f: (error: E) => E2) => <A, R>(self: Layer.Layer<A, E, R>) => Layer.Layer<A, E2, R>,
+  <A, E, R, E2>(self: Layer.Layer<A, E, R>, f: (error: E) => E2) => Layer.Layer<A, E2, R>
 >(2, (self, f) => catchAll(self, (error) => failSync(() => f(error))))
 
 /** @internal */
 export const matchCause = dual<
-  <E, A, R2, E2, A2, R3, E3, A3>(
+  <E, A2, E2, R2, A, A3, E3, R3>(
     options: {
       readonly onFailure: (cause: Cause.Cause<E>) => Layer.Layer<A2, E2, R2>
       readonly onSuccess: (context: Context.Context<A>) => Layer.Layer<A3, E3, R3>
     }
   ) => <R>(self: Layer.Layer<A, E, R>) => Layer.Layer<A2 & A3, E2 | E3, R | R2 | R3>,
-  <R, E, A, R2, E2, A2, R3, E3, A3>(
+  <A, E, R, A2, E2, R2, A3, E3, R3>(
     self: Layer.Layer<A, E, R>,
     options: {
       readonly onFailure: (cause: Cause.Cause<E>) => Layer.Layer<A2, E2, R2>
@@ -663,13 +663,13 @@ export const matchCause = dual<
 
 /** @internal */
 export const match = dual<
-  <E, R2, E2, A2, A, R3, E3, A3>(
+  <E, A2, E2, R2, A, A3, E3, R3>(
     options: {
       readonly onFailure: (error: E) => Layer.Layer<A2, E2, R2>
       readonly onSuccess: (context: Context.Context<A>) => Layer.Layer<A3, E3, R3>
     }
   ) => <R>(self: Layer.Layer<A, E, R>) => Layer.Layer<A2 & A3, E2 | E3, R | R2 | R3>,
-  <R, E, A, R2, E2, A2, R3, E3, A3>(
+  <A, E, R, A2, E2, R2, A3, E3, R3>(
     self: Layer.Layer<A, E, R>,
     options: {
       readonly onFailure: (error: E) => Layer.Layer<A2, E2, R2>
@@ -740,10 +740,10 @@ export const orDie = <A, E, R>(self: Layer.Layer<A, E, R>): Layer.Layer<A, never
 
 /** @internal */
 export const orElse = dual<
-  <R2, E2, A2>(
+  <A2, E2, R2>(
     that: LazyArg<Layer.Layer<A2, E2, R2>>
   ) => <A, E, R>(self: Layer.Layer<A, E, R>) => Layer.Layer<A & A2, E | E2, R | R2>,
-  <R, E, A, R2, E2, A2>(
+  <A, E, R, A2, E2, R2>(
     self: Layer.Layer<A, E, R>,
     that: LazyArg<Layer.Layer<A2, E2, R2>>
   ) => Layer.Layer<A & A2, E | E2, R | R2>
@@ -770,14 +770,14 @@ export const project = dual<
 
 /** @internal */
 export const retry = dual<
-  <RIn2, E, X>(
-    schedule: Schedule.Schedule<RIn2, E, X>
-  ) => <RIn, ROut>(
+  <X, E, RIn2>(
+    schedule: Schedule.Schedule<X, E, RIn2>
+  ) => <ROut, RIn>(
     self: Layer.Layer<ROut, E, RIn>
   ) => Layer.Layer<ROut, E, RIn | RIn2>,
-  <RIn, E, ROut, RIn2, X>(
+  <ROut, E, RIn, X, RIn2>(
     self: Layer.Layer<ROut, E, RIn>,
-    schedule: Schedule.Schedule<RIn2, E, X>
+    schedule: Schedule.Schedule<X, E, RIn2>
   ) => Layer.Layer<ROut, E, RIn | RIn2>
 >(2, (self, schedule) =>
   suspend(() => {
@@ -790,10 +790,9 @@ export const retry = dual<
     )
   }))
 
-/** @internal */
-const retryLoop = <RIn, E, ROut, RIn2, X>(
+const retryLoop = <ROut, E, RIn, X, RIn2>(
   self: Layer.Layer<ROut, E, RIn>,
-  schedule: Schedule.Schedule<RIn2, E, X>,
+  schedule: Schedule.Schedule<X, E, RIn2>,
   stateTag: Context.Tag<{ state: unknown }, { state: unknown }>,
   state: unknown
 ): Layer.Layer<ROut, E, RIn | RIn2> => {
@@ -808,9 +807,8 @@ const retryLoop = <RIn, E, ROut, RIn2, X>(
   )
 }
 
-/** @internal */
-const retryUpdate = <RIn, E, X>(
-  schedule: Schedule.Schedule<RIn, E, X>,
+const retryUpdate = <X, E, RIn>(
+  schedule: Schedule.Schedule<X, E, RIn>,
   stateTag: Context.Tag<{ state: unknown }, { state: unknown }>,
   error: E,
   state: unknown
@@ -840,10 +838,10 @@ const retryUpdate = <RIn, E, X>(
 export const scoped = dual<
   <T extends Context.Tag<any, any>>(
     tag: T
-  ) => <R, E>(
+  ) => <E, R>(
     effect: Effect.Effect<Context.Tag.Service<T>, E, R>
   ) => Layer.Layer<Context.Tag.Identifier<T>, E, Exclude<R, Scope.Scope>>,
-  <T extends Context.Tag<any, any>, R, E>(
+  <T extends Context.Tag<any, any>, E, R>(
     tag: T,
     effect: Effect.Effect<Context.Tag.Service<T>, E, R>
   ) => Layer.Layer<Context.Tag.Identifier<T>, E, Exclude<R, Scope.Scope>>
@@ -855,8 +853,8 @@ export const scoped = dual<
 })
 
 /** @internal */
-export const scopedDiscard = <_, E, R>(
-  effect: Effect.Effect<_, E, R>
+export const scopedDiscard = <X, E, R>(
+  effect: Effect.Effect<X, E, R>
 ): Layer.Layer<never, E, Exclude<R, Scope.Scope>> => scopedContext(pipe(effect, core.as(Context.empty())))
 
 /** @internal */
@@ -1054,11 +1052,11 @@ export const provideMerge = dual<
 
 /** @internal */
 export const zipWith = dual<
-  <R2, E2, B, A, C>(
+  <B, E2, R2, A, C>(
     that: Layer.Layer<B, E2, R2>,
     f: (a: Context.Context<A>, b: Context.Context<B>) => Context.Context<C>
-  ) => <R, E>(self: Layer.Layer<A, E, R>) => Layer.Layer<C, E | E2, R | R2>,
-  <R, E, R2, E2, B, A, C>(
+  ) => <E, R>(self: Layer.Layer<A, E, R>) => Layer.Layer<C, E | E2, R | R2>,
+  <A, E, R, B, E2, R2, C>(
     self: Layer.Layer<A, E, R>,
     that: Layer.Layer<B, E2, R2>,
     f: (a: Context.Context<A>, b: Context.Context<B>) => Context.Context<C>
@@ -1074,7 +1072,7 @@ export const zipWith = dual<
   }))
 
 /** @internal */
-export const unwrapEffect = <R, E, R1, E1, A>(
+export const unwrapEffect = <A, E1, R1, E, R>(
   self: Effect.Effect<Layer.Layer<A, E1, R1>, E, R>
 ): Layer.Layer<A, E | E1, R | R1> => {
   const tag = Context.GenericTag<Layer.Layer<A, E1, R1>>("effect/Layer/unwrapEffect/Layer.Layer<R1, E1, A>")
@@ -1082,7 +1080,7 @@ export const unwrapEffect = <R, E, R1, E1, A>(
 }
 
 /** @internal */
-export const unwrapScoped = <R, E, R1, E1, A>(
+export const unwrapScoped = <A, E1, R1, E, R>(
   self: Effect.Effect<Layer.Layer<A, E1, R1>, E, R>
 ): Layer.Layer<A, E | E1, R1 | Exclude<R, Scope.Scope>> => {
   const tag = Context.GenericTag<Layer.Layer<A, E1, R1>>("effect/Layer/unwrapScoped/Layer.Layer<R1, E1, A>")
@@ -1139,10 +1137,10 @@ export const withParentSpan = dual<
 // circular with Effect
 
 const provideSomeLayer = dual<
-  <R2, E2, A2>(
+  <A2, E2, R2>(
     layer: Layer.Layer<A2, E2, R2>
   ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | E2, R2 | Exclude<R, A2>>,
-  <R, E, A, R2, E2, A2>(
+  <A, E, R, A2, E2, R2>(
     self: Effect.Effect<A, E, R>,
     layer: Layer.Layer<A2, E2, R2>
   ) => Effect.Effect<A, E | E2, R2 | Exclude<R, A2>>
@@ -1188,9 +1186,9 @@ const provideSomeRuntime = dual<
 /** @internal */
 export const effect_provide = dual<
   {
-    <R2, E2, R3>(
-      layer: Layer.Layer<R3, E2, R2>
-    ): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | E2, R2 | Exclude<R, R3>>
+    <ROut, E2, RIn>(
+      layer: Layer.Layer<ROut, E2, RIn>
+    ): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | E2, RIn | Exclude<R, ROut>>
     <R2>(
       context: Context.Context<R2>
     ): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, R2>>
@@ -1199,28 +1197,28 @@ export const effect_provide = dual<
     ): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, R2>>
   },
   {
-    <A, E, R, R2, E2, R3>(
+    <A, E, R, ROut, E2, RIn>(
       self: Effect.Effect<A, E, R>,
-      layer: Layer.Layer<R3, E2, R2>
-    ): Effect.Effect<A, E | E2, R2 | Exclude<R, R3>>
-    <R, E, A, R2>(
+      layer: Layer.Layer<ROut, E2, RIn>
+    ): Effect.Effect<A, E | E2, RIn | Exclude<R, ROut>>
+    <A, E, R, R2>(
       self: Effect.Effect<A, E, R>,
       context: Context.Context<R2>
     ): Effect.Effect<A, E, Exclude<R, R2>>
-    <R, E, A, R2>(
+    <A, E, R, R2>(
       self: Effect.Effect<A, E, R>,
       runtime: Runtime.Runtime<R2>
     ): Effect.Effect<A, E, Exclude<R, R2>>
   }
 >(
   2,
-  <A, E, R, R2>(
+  <A, E, R, ROut>(
     self: Effect.Effect<A, E, R>,
-    source: Layer.Layer<R2, any, any> | Context.Context<R2> | Runtime.Runtime<R2>
-  ): Effect.Effect<any, any, Exclude<R, R2>> =>
+    source: Layer.Layer<ROut, any, any> | Context.Context<ROut> | Runtime.Runtime<ROut>
+  ): Effect.Effect<any, any, Exclude<R, ROut>> =>
     isLayer(source)
-      ? provideSomeLayer(self, source as Layer.Layer<R2, any, any>)
+      ? provideSomeLayer(self, source as Layer.Layer<ROut, any, any>)
       : Context.isContext(source)
       ? core.provideSomeContext(self, source)
-      : provideSomeRuntime(self, source as Runtime.Runtime<R2>)
+      : provideSomeRuntime(self, source as Runtime.Runtime<ROut>)
 )

package/src/internal/matcher.ts

@@ -87,7 +87,7 @@ const ValueMatcherProto: Omit<
 
 function makeValueMatcher<I, R, RA, A, Pr>(
   provided: Pr,
-  value: Either.Either<RA, Pr>
+  value: Either.Either<Pr, RA>
 ): ValueMatcher<I, R, RA, A, Pr> {
   const matcher = Object.create(ValueMatcherProto)
   matcher.provided = provided
@@ -514,8 +514,8 @@ export const orElseAbsurd = <I, R, RA, A, Pr>(
 /** @internal */
 export const either: <I, F, R, A, Pr>(
   self: Matcher<I, F, R, A, Pr>
-) => [Pr] extends [never] ? (input: I) => Either.Either<R, Unify<A>>
-  : Either.Either<R, Unify<A>> = (<I, R, RA, A>(self: Matcher<I, R, RA, A, I>) => {
+) => [Pr] extends [never] ? (input: I) => Either.Either<Unify<A>, R>
+  : Either.Either<Unify<A>, R> = (<I, R, RA, A>(self: Matcher<I, R, RA, A, I>) => {
     if (self._tag === "ValueMatcher") {
       return self.value
     }
@@ -523,7 +523,7 @@ export const either: <I, F, R, A, Pr>(
     const len = self.cases.length
     if (len === 1) {
       const _case = self.cases[0]
-      return (input: I): Either.Either<RA, A> => {
+      return (input: I): Either.Either<A, RA> => {
         if (_case._tag === "When" && _case.guard(input) === true) {
           return Either.right(_case.evaluate(input))
         } else if (_case._tag === "Not" && _case.guard(input) === false) {
@@ -532,7 +532,7 @@ export const either: <I, F, R, A, Pr>(
         return Either.left(input as any)
       }
     }
-    return (input: I): Either.Either<RA, A> => {
+    return (input: I): Either.Either<A, RA> => {
       for (let i = 0; i < len; i++) {
         const _case = self.cases[i]
         if (_case._tag === "When" && _case.guard(input) === true) {

package/src/internal/metric/polling.ts

@@ -64,14 +64,14 @@ export const collectAll = <R, E, Out>(
 
 /** @internal */
 export const launch = dual<
-  <R2, A2>(
-    schedule: Schedule.Schedule<R2, unknown, A2>
+  <A2, R2>(
+    schedule: Schedule.Schedule<A2, unknown, R2>
   ) => <Type, In, R, E, Out>(
     self: MetricPolling.MetricPolling<Type, In, R, E, Out>
   ) => Effect.Effect<Fiber.Fiber<A2, E>, never, R | R2 | Scope.Scope>,
-  <Type, In, R, E, Out, R2, A2>(
+  <Type, In, R, E, Out, A2, R2>(
     self: MetricPolling.MetricPolling<Type, In, R, E, Out>,
-    schedule: Schedule.Schedule<R2, unknown, A2>
+    schedule: Schedule.Schedule<A2, unknown, R2>
   ) => Effect.Effect<Fiber.Fiber<A2, E>, never, R | R2 | Scope.Scope>
 >(2, (self, schedule) =>
   pipe(
@@ -92,14 +92,14 @@ export const pollAndUpdate = <Type, In, R, E, Out>(
 
 /** @internal */
 export const retry = dual<
-  <R2, E, _>(
-    policy: Schedule.Schedule<R2, E, _>
+  <X, E, R2>(
+    policy: Schedule.Schedule<X, E, R2>
   ) => <Type, In, R, Out>(
     self: MetricPolling.MetricPolling<Type, In, R, E, Out>
   ) => MetricPolling.MetricPolling<Type, In, R | R2, E, Out>,
-  <Type, In, R, Out, R2, E, _>(
+  <Type, In, R, E, Out, X, R2>(
     self: MetricPolling.MetricPolling<Type, In, R, E, Out>,
-    policy: Schedule.Schedule<R2, E, _>
+    policy: Schedule.Schedule<X, E, R2>
   ) => MetricPolling.MetricPolling<Type, In, R | R2, E, Out>
 >(2, (self, policy) => ({
   [MetricPollingTypeId]: MetricPollingTypeId,

package/src/internal/metric.ts

@@ -425,12 +425,12 @@ export const trackDurationWith = dual<
 export const trackError = dual<
   <Type, In, Out>(
     metric: Metric.Metric<Type, In, Out>
-  ) => <R, E extends In, A>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
-  <R, E extends In, A, Type, In, Out>(
+  ) => <A, E extends In, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E extends In, R, Type, In, Out>(
     self: Effect.Effect<A, E, R>,
     metric: Metric.Metric<Type, In, Out>
   ) => Effect.Effect<A, E, R>
->(2, <R, E extends In, A, Type, In, Out>(
+>(2, <A, E extends In, R, Type, In, Out>(
   self: Effect.Effect<A, E, R>,
   metric: Metric.Metric<Type, In, Out>
 ) => trackErrorWith(self, metric, (a: In) => a))
@@ -440,13 +440,13 @@ export const trackErrorWith = dual<
   <Type, In, Out, In2>(
     metric: Metric.Metric<Type, In, Out>,
     f: (error: In2) => In
-  ) => <R, E extends In2, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
-  <R, E extends In2, A, Type, In, Out, In2>(
+  ) => <A, E extends In2, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E extends In2, R, Type, In, Out, In2>(
     self: Effect.Effect<A, E, R>,
     metric: Metric.Metric<Type, In, Out>,
     f: (error: In2) => In
   ) => Effect.Effect<A, E, R>
->(3, <R, E extends In2, A, Type, In, Out, In2>(
+>(3, <A, E extends In2, R, Type, In, Out, In2>(
   self: Effect.Effect<A, E, R>,
   metric: Metric.Metric<Type, In, Out>,
   f: (error: In2) => In