@effect/platform 0.53.12 → 0.53.14

package/src/Http/Router.ts

@@ -16,7 +16,6 @@ import type * as App from "./App.js"
 import type * as Method from "./Method.js"
 import type * as Error from "./ServerError.js"
 import type * as ServerRequest from "./ServerRequest.js"
-import type * as ServerResponse from "./ServerResponse.js"
 
 /**
  * @since 1.0.0
@@ -99,11 +98,7 @@ export declare namespace Route {
   /**
    * @since 1.0.0
    */
-  export type Handler<E, R> = Effect.Effect<
-    ServerResponse.ServerResponse,
-    E,
-    R | RouteContext | ServerRequest.ServerRequest | ServerRequest.ParsedSearchParams
-  >
+  export type Handler<E, R> = App.Default<E, R | RouteContext | ServerRequest.ParsedSearchParams>
 }
 
 /**
@@ -246,8 +241,8 @@ export const makeRoute: <E, R>(
  * @category combinators
  */
 export const prefixAll: {
-  (prefix: PathInput): <R, E>(self: Router<E, R>) => Router<E, R>
-  <R, E>(self: Router<E, R>, prefix: PathInput): Router<E, R>
+  (prefix: PathInput): <E, R>(self: Router<E, R>) => Router<E, R>
+  <E, R>(self: Router<E, R>, prefix: PathInput): Router<E, R>
 } = internal.prefixAll
 
 /**
@@ -255,10 +250,10 @@ export const prefixAll: {
  * @category combinators
  */
 export const concat: {
-  <R1, E1>(that: Router<E1, R1>): <R, E>(
+  <R1, E1>(that: Router<E1, R1>): <E, R>(
     self: Router<E, R>
   ) => Router<E1 | E, R1 | R>
-  <R, E, R1, E1>(self: Router<E, R>, that: Router<E1, R1>): Router<
+  <E, R, R1, E1>(self: Router<E, R>, that: Router<E1, R1>): Router<
     E | E1,
     R | R1
   >
@@ -269,8 +264,8 @@ export const concat: {
  * @category routing
  */
 export const mount: {
-  <R1, E1>(path: `/${string}`, that: Router<E1, R1>): <R, E>(self: Router<E, R>) => Router<E1 | E, R1 | R>
-  <R, E, R1, E1>(self: Router<E, R>, path: `/${string}`, that: Router<E1, R1>): Router<E | E1, R | R1>
+  <R1, E1>(path: `/${string}`, that: Router<E1, R1>): <E, R>(self: Router<E, R>) => Router<E1 | E, R1 | R>
+  <E, R, E1, R1>(self: Router<E, R>, path: `/${string}`, that: Router<E1, R1>): Router<E | E1, R | R1>
 } = internal.mount
 
 /**
@@ -282,14 +277,14 @@ export const mountApp: {
     path: `/${string}`,
     that: App.Default<E1, R1>,
     options?: { readonly includePrefix?: boolean | undefined } | undefined
-  ): <R, E>(
+  ): <E, R>(
     self: Router<E, R>
   ) => Router<
     E1 | E,
     | Router.ExcludeProvided<R1>
     | Router.ExcludeProvided<R>
   >
-  <R, E, R1, E1>(
+  <E, R, E1, R1>(
     self: Router<E, R>,
     path: `/${string}`,
     that: App.Default<E1, R1>,
@@ -312,10 +307,10 @@ export const route: (
     path: PathInput,
     handler: Route.Handler<E1, R1>,
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
-  ): <R, E>(
+  ): <E, R>(
     self: Router<E, R>
   ) => Router<E1 | E, R | Exclude<R1, ServerRequest.ServerRequest | RouteContext | Scope.Scope>>
-  <R, E, R1, E1>(
+  <E, R, E1, R1>(
     self: Router<E, R>,
     path: PathInput,
     handler: Route.Handler<E1, R1>,
@@ -332,13 +327,13 @@ export const all: {
     path: PathInput,
     handler: Route.Handler<E1, R1>,
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
-  ): <R, E>(
+  ): <E, R>(
     self: Router<E, R>
   ) => Router<
     E1 | E,
     R | Router.ExcludeProvided<R1>
   >
-  <R, E, R1, E1>(
+  <E, R, E1, R1>(
     self: Router<E, R>,
     path: PathInput,
     handler: Route.Handler<E1, R1>,
@@ -358,10 +353,10 @@ export const get: {
     path: PathInput,
     handler: Route.Handler<E1, R1>,
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
-  ): <R, E>(
+  ): <E, R>(
     self: Router<E, R>
   ) => Router<E1 | E, R | Router.ExcludeProvided<R1>>
-  <R, E, R1, E1>(
+  <E, R, E1, R1>(
     self: Router<E, R>,
     path: PathInput,
     handler: Route.Handler<E1, R1>,
@@ -378,10 +373,10 @@ export const post: {
     path: PathInput,
     handler: Route.Handler<E1, R1>,
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
-  ): <R, E>(
+  ): <E, R>(
     self: Router<E, R>
   ) => Router<E1 | E, R | Router.ExcludeProvided<R1>>
-  <R, E, R1, E1>(
+  <E, R, E1, R1>(
     self: Router<E, R>,
     path: PathInput,
     handler: Route.Handler<E1, R1>,
@@ -398,10 +393,10 @@ export const patch: {
     path: PathInput,
     handler: Route.Handler<E1, R1>,
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
-  ): <R, E>(
+  ): <E, R>(
     self: Router<E, R>
   ) => Router<E1 | E, R | Router.ExcludeProvided<R1>>
-  <R, E, R1, E1>(
+  <E, R, E1, R1>(
     self: Router<E, R>,
     path: PathInput,
     handler: Route.Handler<E1, R1>,
@@ -418,10 +413,10 @@ export const put: {
     path: PathInput,
     handler: Route.Handler<E1, R1>,
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
-  ): <R, E>(
+  ): <E, R>(
     self: Router<E, R>
   ) => Router<E1 | E, R | Router.ExcludeProvided<R1>>
-  <R, E, R1, E1>(
+  <E, R, E1, R1>(
     self: Router<E, R>,
     path: PathInput,
     handler: Route.Handler<E1, R1>,
@@ -438,10 +433,10 @@ export const del: {
     path: PathInput,
     handler: Route.Handler<E1, R1>,
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
-  ): <R, E>(
+  ): <E, R>(
     self: Router<E, R>
   ) => Router<E1 | E, R | Router.ExcludeProvided<R1>>
-  <R, E, R1, E1>(
+  <E, R, E1, R1>(
     self: Router<E, R>,
     path: PathInput,
     handler: Route.Handler<E1, R1>,
@@ -458,10 +453,10 @@ export const head: {
     path: PathInput,
     handler: Route.Handler<E1, R1>,
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
-  ): <R, E>(
+  ): <E, R>(
     self: Router<E, R>
   ) => Router<E1 | E, R | Router.ExcludeProvided<R1>>
-  <R, E, R1, E1>(
+  <E, R, E1, R1>(
     self: Router<E, R>,
     path: PathInput,
     handler: Route.Handler<E1, R1>,
@@ -478,10 +473,10 @@ export const options: {
     path: PathInput,
     handler: Route.Handler<E1, R1>,
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
-  ): <R, E>(
+  ): <E, R>(
     self: Router<E, R>
   ) => Router<E1 | E, R | Router.ExcludeProvided<R1>>
-  <R, E, R1, E1>(
+  <E, R, E1, R1>(
     self: Router<E, R>,
     path: PathInput,
     handler: Route.Handler<E1, R1>,
@@ -511,7 +506,7 @@ export const catchAll: {
   <E, E2, R2>(
     f: (e: E) => Route.Handler<E2, R2>
   ): <R>(self: Router<E, R>) => Router<E2, R | Router.ExcludeProvided<R2>>
-  <R, E, E2, R2>(
+  <E, R, E2, R2>(
     self: Router<E, R>,
     f: (e: E) => Route.Handler<E2, R2>
   ): Router<E2, R | Router.ExcludeProvided<R2>>
@@ -525,7 +520,7 @@ export const catchAllCause: {
   <E, E2, R2>(
     f: (e: Cause.Cause<E>) => Route.Handler<E2, R2>
   ): <R>(self: Router<E, R>) => Router<E2, R | Router.ExcludeProvided<R2>>
-  <R, E, E2, R2>(
+  <E, R, E2, R2>(
     self: Router<E, R>,
     f: (e: Cause.Cause<E>) => Route.Handler<E2, R2>
   ): Router<E2, R | Router.ExcludeProvided<R2>>
@@ -542,7 +537,7 @@ export const catchTag: {
   ): <R>(
     self: Router<E, R>
   ) => Router<E1 | Exclude<E, { _tag: K }>, R | Router.ExcludeProvided<R1>>
-  <R, E, K extends E extends { _tag: string } ? E["_tag"] : never, E1, R1>(
+  <E, R, K extends E extends { _tag: string } ? E["_tag"] : never, E1, R1>(
     self: Router<E, R>,
     k: K,
     f: (e: Extract<E, { _tag: K }>) => Route.Handler<E1, R1>
@@ -606,8 +601,8 @@ export const provideService: {
   <T extends Context.Tag<any, any>>(
     tag: T,
     service: Context.Tag.Service<T>
-  ): <R, E>(self: Router<E, R>) => Router<E, Exclude<R, Context.Tag.Identifier<T>>>
-  <R, E, T extends Context.Tag<any, any>>(
+  ): <E, R>(self: Router<E, R>) => Router<E, Exclude<R, Context.Tag.Identifier<T>>>
+  <E, R, T extends Context.Tag<any, any>>(
     self: Router<E, R>,
     tag: T,
     service: Context.Tag.Service<T>
@@ -622,14 +617,14 @@ export const provideServiceEffect: {
   <T extends Context.Tag<any, any>, R1, E1>(
     tag: T,
     effect: Effect.Effect<Context.Tag.Service<T>, E1, R1>
-  ): <R, E>(
+  ): <E, R>(
     self: Router<E, R>
   ) => Router<
     E1 | E,
     | Exclude<R, Context.Tag.Identifier<T>>
     | Exclude<Router.ExcludeProvided<R1>, Context.Tag.Identifier<T>>
   >
-  <R, E, T extends Context.Tag<any, any>, R1, E1>(
+  <E, R, T extends Context.Tag<any, any>, R1, E1>(
     self: Router<E, R>,
     tag: T,
     effect: Effect.Effect<Context.Tag.Service<T>, E1, R1>

package/src/Http/Server.ts

@@ -29,12 +29,12 @@ export type TypeId = typeof TypeId
 export interface Server {
   readonly [TypeId]: TypeId
   readonly serve: {
-    <R, E>(httpApp: App.Default<E, R>): Effect.Effect<
+    <E, R>(httpApp: App.Default<E, R>): Effect.Effect<
       void,
       never,
       Exclude<R, ServerRequest.ServerRequest> | Scope.Scope
     >
-    <R, E, App extends App.Default<any, any>>(
+    <E, R, App extends App.Default<any, any>>(
       httpApp: App.Default<E, R>,
       middleware: Middleware.Middleware.Applied<App, E, R>
     ): Effect.Effect<
@@ -104,10 +104,10 @@ export const make: (
  * @category accessors
  */
 export const serve: {
-  (): <R, E>(
+  (): <E, R>(
     httpApp: App.Default<E, R>
   ) => Layer.Layer<never, never, Server | Exclude<R, ServerRequest.ServerRequest | Scope.Scope>>
-  <R, E, App extends App.Default<any, any>>(
+  <E, R, App extends App.Default<any, any>>(
     middleware: Middleware.Middleware.Applied<App, E, R>
   ): (
     httpApp: App.Default<E, R>
@@ -116,10 +116,10 @@ export const serve: {
     never,
     Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest | Scope.Scope>
   >
-  <R, E>(
+  <E, R>(
     httpApp: App.Default<E, R>
   ): Layer.Layer<never, never, Server | Exclude<R, ServerRequest.ServerRequest | Scope.Scope>>
-  <R, E, App extends App.Default<any, any>>(
+  <E, R, App extends App.Default<any, any>>(
     httpApp: App.Default<E, R>,
     middleware: Middleware.Middleware.Applied<App, E, R>
   ): Layer.Layer<never, never, Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest | Scope.Scope>>
@@ -130,10 +130,10 @@ export const serve: {
  * @category accessors
  */
 export const serveEffect: {
-  (): <R, E>(
+  (): <E, R>(
     httpApp: App.Default<E, R>
   ) => Effect.Effect<void, never, Scope.Scope | Server | Exclude<R, ServerRequest.ServerRequest>>
-  <R, E, App extends App.Default<any, any>>(
+  <E, R, App extends App.Default<any, any>>(
     middleware: Middleware.Middleware.Applied<App, E, R>
   ): (
     httpApp: App.Default<E, R>
@@ -142,10 +142,10 @@ export const serveEffect: {
     never,
     Scope.Scope | Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest>
   >
-  <R, E>(
+  <E, R>(
     httpApp: App.Default<E, R>
   ): Effect.Effect<void, never, Scope.Scope | Server | Exclude<R, ServerRequest.ServerRequest>>
-  <R, E, App extends App.Default<any, any>>(
+  <E, R, App extends App.Default<any, any>>(
     httpApp: App.Default<E, R>,
     middleware: Middleware.Middleware.Applied<App, E, R>
   ): Effect.Effect<void, never, Scope.Scope | Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest>>
@@ -161,7 +161,7 @@ export const formatAddress: (address: Address) => string = internal.formatAddres
  * @since 1.0.0
  * @category address
  */
-export const addressWith: <R, E, A>(
+export const addressWith: <A, E, R>(
   effect: (address: Address) => Effect.Effect<A, E, R>
 ) => Effect.Effect<A, E, Server | R> = internal.addressWith
 
@@ -169,7 +169,7 @@ export const addressWith: <R, E, A>(
  * @since 1.0.0
  * @category address
  */
-export const addressFormattedWith: <R, E, A>(
+export const addressFormattedWith: <A, E, R>(
   effect: (address: string) => Effect.Effect<A, E, R>
 ) => Effect.Effect<A, E, Server | R> = internal.addressFormattedWith
 
@@ -183,5 +183,5 @@ export const logAddress: Effect.Effect<void, never, Server> = internal.logAddres
  * @since 1.0.0
  * @category address
  */
-export const withLogAddress: <R, E, A>(layer: Layer.Layer<A, E, R>) => Layer.Layer<A, E, R | Exclude<Server, A>> =
+export const withLogAddress: <A, E, R>(layer: Layer.Layer<A, E, R>) => Layer.Layer<A, E, R | Exclude<Server, A>> =
   internal.withLogAddress

package/src/Socket.ts

@@ -46,10 +46,10 @@ export const Socket: Context.Tag<Socket, Socket> = Context.GenericTag<Socket>(
  */
 export interface Socket {
   readonly [TypeId]: TypeId
-  readonly run: <R, E, _>(
+  readonly run: <_, E, R>(
     handler: (_: Uint8Array) => Effect.Effect<_, E, R>
   ) => Effect.Effect<void, SocketError | E, R>
-  readonly runRaw: <R, E, _>(
+  readonly runRaw: <_, E, R>(
     handler: (_: string | Uint8Array) => Effect.Effect<_, E, R>
   ) => Effect.Effect<void, SocketError | E, R>
   readonly writer: Effect.Effect<
@@ -337,7 +337,7 @@ export const fromWebSocket = <R>(
     ))
     const acquireContext = yield* Effect.context<Exclude<R, Scope.Scope>>()
 
-    const runRaw = <R, E, _>(handler: (_: string | Uint8Array) => Effect.Effect<_, E, R>) =>
+    const runRaw = <_, E, R>(handler: (_: string | Uint8Array) => Effect.Effect<_, E, R>) =>
       Effect.gen(function*(_) {
         const scope = yield* Effect.scope
         const ws = yield* (acquire.pipe(
@@ -433,7 +433,7 @@ export const fromWebSocket = <R>(
       )
 
     const encoder = new TextEncoder()
-    const run = <R, E, _>(handler: (_: Uint8Array) => Effect.Effect<_, E, R>) =>
+    const run = <_, E, R>(handler: (_: Uint8Array) => Effect.Effect<_, E, R>) =>
       runRaw((data) =>
         typeof data === "string"
           ? handler(encoder.encode(data))

package/src/WorkerRunner.ts

@@ -95,7 +95,7 @@ export declare namespace Runner {
  * @since 1.0.0
  * @category constructors
  */
-export const make: <I, R, E, O>(
+export const make: <I, E, R, O>(
   process: (request: I) => Stream.Stream<O, E, R> | Effect.Effect<O, E, R>,
   options?: Runner.Options<I, O, E> | undefined
 ) => Effect.Effect<void, WorkerError, Scope.Scope | R | PlatformRunner> = internal.make
@@ -104,7 +104,7 @@ export const make: <I, R, E, O>(
  * @since 1.0.0
  * @category layers
  */
-export const layer: <I, R, E, O>(
+export const layer: <I, E, R, O>(
   process: (request: I) => Stream.Stream<O, E, R> | Effect.Effect<O, E, R>,
   options?: Runner.Options<I, O, E> | undefined
 ) => Layer.Layer<never, WorkerError, R | PlatformRunner> = internal.layer

package/src/internal/http/client.ts

@@ -45,8 +45,8 @@ export const currentTracerDisabledWhen = globalValue(
 export const withTracerDisabledWhen = dual<
   (
     predicate: Predicate.Predicate<ClientRequest.ClientRequest>
-  ) => <R, E, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
-  <R, E, A>(
+  ) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E, R>(
     effect: Effect.Effect<A, E, R>,
     predicate: Predicate.Predicate<ClientRequest.ClientRequest>
   ) => Effect.Effect<A, E, R>
@@ -62,8 +62,8 @@ export const currentTracerPropagation = globalValue(
 export const withTracerPropagation = dual<
   (
     enabled: boolean
-  ) => <R, E, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
-  <R, E, A>(
+  ) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E, R>(
     effect: Effect.Effect<A, E, R>,
     enabled: boolean
   ) => Effect.Effect<A, E, R>
@@ -79,8 +79,8 @@ export const currentFetchOptions = globalValue(
 export const withFetchOptions = dual<
   (
     options: RequestInit
-  ) => <R, E, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
-  <R, E, A>(
+  ) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E, R>(
     effect: Effect.Effect<A, E, R>,
     options: RequestInit
   ) => Effect.Effect<A, E, R>
@@ -96,7 +96,7 @@ const clientProto = {
 const isClient = (u: unknown): u is Client.Client<unknown, unknown, unknown> => Predicate.hasProperty(u, TypeId)
 
 /** @internal */
-export const make = <A, E, R, R2, E2>(
+export const make = <E2, R2, A, E, R>(
   execute: (
     request: Effect.Effect<ClientRequest.ClientRequest, E2, R2>
   ) => Effect.Effect<A, E, R>,
@@ -236,13 +236,13 @@ export const fetch: Client.Client.Default = makeDefault((request, url, signal, f
 
 /** @internal */
 export const transform = dual<
-  <A, E, R, R1, E1, A1>(
+  <A, E, R, A1, E1, R1>(
     f: (
       effect: Effect.Effect<A, E, R>,
       request: ClientRequest.ClientRequest
     ) => Effect.Effect<A1, E1, R1>
   ) => (self: Client.Client<A, E, R>) => Client.Client<A1, E | E1, R | R1>,
-  <A, E, R, R1, E1, A1>(
+  <A, E, R, A1, E1, R1>(
     self: Client.Client<A, E, R>,
     f: (
       effect: Effect.Effect<A, E, R>,
@@ -305,10 +305,10 @@ export const layer = Layer.succeed(tag, fetch)
 
 /** @internal */
 export const transformResponse = dual<
-  <A, E, R, R1, E1, A1>(
+  <A, E, R, A1, E1, R1>(
     f: (effect: Effect.Effect<A, E, R>) => Effect.Effect<A1, E1, R1>
   ) => (self: Client.Client<A, E, R>) => Client.Client<A1, E1, R1>,
-  <A, E, R, R1, E1, A1>(
+  <A, E, R, A1, E1, R1>(
     self: Client.Client<A, E, R>,
     f: (effect: Effect.Effect<A, E, R>) => Effect.Effect<A1, E1, R1>
   ) => Client.Client<A1, E1, R1>
@@ -316,7 +316,7 @@ export const transformResponse = dual<
 
 /** @internal */
 export const catchTag: {
-  <K extends E extends { _tag: string } ? E["_tag"] : never, E, R1, E1, A1>(
+  <K extends E extends { _tag: string } ? E["_tag"] : never, E, A1, E1, R1>(
     tag: K,
     f: (e: Extract<E, { _tag: K }>) => Effect.Effect<A1, E1, R1>
   ): <A, R>(
@@ -327,9 +327,9 @@ export const catchTag: {
     E,
     A,
     K extends E extends { _tag: string } ? E["_tag"] : never,
+    A1,
     R1,
-    E1,
-    A1
+    E1
   >(
     self: Client.Client<A, E, R>,
     tag: K,
@@ -494,16 +494,16 @@ export const catchTags: {
 
 /** @internal */
 export const catchAll: {
-  <E, R2, E2, A2>(
+  <E, A2, E2, R2>(
     f: (e: E) => Effect.Effect<A2, E2, R2>
   ): <A, R>(self: Client.Client<A, E, R>) => Client.Client<A2 | A, E2, R | R2>
-  <A, E, R, R2, E2, A2>(
+  <A, E, R, A2, E2, R2>(
     self: Client.Client<A, E, R>,
     f: (e: E) => Effect.Effect<A2, E2, R2>
   ): Client.Client<A2 | A, E2, R | R2>
 } = dual(
   2,
-  <A, E, R, R2, E2, A2>(
+  <A, E, R, A2, E2, R2>(
     self: Client.Client<A, E, R>,
     f: (e: E) => Effect.Effect<A2, E2, R2>
   ): Client.Client<A2 | A, E2, R | R2> => transformResponse(self, Effect.catchAll(f))
@@ -511,13 +511,13 @@ export const catchAll: {
 
 /** @internal */
 export const filterOrElse = dual<
-  <A, R2, E2, B>(
+  <A, B, E2, R2>(
     f: Predicate.Predicate<A>,
     orElse: (a: A) => Effect.Effect<B, E2, R2>
   ) => <E, R>(
     self: Client.Client<A, E, R>
   ) => Client.Client<A | B, E2 | E, R2 | R>,
-  <A, E, R, R2, E2, B>(
+  <A, E, R, B, E2, R2>(
     self: Client.Client<A, E, R>,
     f: Predicate.Predicate<A>,
     orElse: (a: A) => Effect.Effect<B, E2, R2>
@@ -550,10 +550,10 @@ export const map = dual<
 
 /** @internal */
 export const mapEffect = dual<
-  <A, R2, E2, B>(
+  <A, B, E2, R2>(
     f: (a: A) => Effect.Effect<B, E2, R2>
   ) => <E, R>(self: Client.Client<A, E, R>) => Client.Client<B, E | E2, R | R2>,
-  <A, E, R, R2, E2, B>(
+  <A, E, R, B, E2, R2>(
     self: Client.Client<A, E, R>,
     f: (a: A) => Effect.Effect<B, E2, R2>
   ) => Client.Client<B, E | E2, R | R2>
@@ -566,10 +566,10 @@ export const scoped = <A, E, R>(
 
 /** @internal */
 export const mapEffectScoped = dual<
-  <A, R2, E2, B>(
+  <A, B, E2, R2>(
     f: (a: A) => Effect.Effect<B, E2, R2>
   ) => <E, R>(self: Client.Client<A, E, R>) => Client.Client<B, E | E2, Exclude<R | R2, Scope.Scope>>,
-  <A, E, R, R2, E2, B>(
+  <A, E, R, B, E2, R2>(
     self: Client.Client<A, E, R>,
     f: (a: A) => Effect.Effect<B, E2, R2>
   ) => Client.Client<B, E | E2, Exclude<R | R2, Scope.Scope>>
@@ -588,14 +588,14 @@ export const mapRequest = dual<
 
 /** @internal */
 export const mapRequestEffect = dual<
-  <R2, E2>(
+  <E2, R2>(
     f: (
       a: ClientRequest.ClientRequest
     ) => Effect.Effect<ClientRequest.ClientRequest, E2, R2>
   ) => <A, E, R>(
     self: Client.Client<A, E, R>
   ) => Client.Client<A, E | E2, R | R2>,
-  <A, E, R, R2, E2>(
+  <A, E, R, E2, R2>(
     self: Client.Client<A, E, R>,
     f: (
       a: ClientRequest.ClientRequest
@@ -616,14 +616,14 @@ export const mapInputRequest = dual<
 
 /** @internal */
 export const mapInputRequestEffect = dual<
-  <R2, E2>(
+  <E2, R2>(
     f: (
       a: ClientRequest.ClientRequest
     ) => Effect.Effect<ClientRequest.ClientRequest, E2, R2>
   ) => <A, E, R>(
     self: Client.Client<A, E, R>
   ) => Client.Client<A, E | E2, R | R2>,
-  <A, E, R, R2, E2>(
+  <A, E, R, E2, R2>(
     self: Client.Client<A, E, R>,
     f: (
       a: ClientRequest.ClientRequest
@@ -694,10 +694,10 @@ export const schemaFunction = dual<
 
 /** @internal */
 export const tap = dual<
-  <A, R2, E2, _>(
+  <A, _, E2, R2>(
     f: (a: A) => Effect.Effect<_, E2, R2>
   ) => <E, R>(self: Client.Client<A, E, R>) => Client.Client<A, E | E2, R | R2>,
-  <A, E, R, R2, E2, _>(
+  <A, E, R, _, E2, R2>(
     self: Client.Client<A, E, R>,
     f: (a: A) => Effect.Effect<_, E2, R2>
   ) => Client.Client<A, E | E2, R | R2>
@@ -705,12 +705,12 @@ export const tap = dual<
 
 /** @internal */
 export const tapRequest = dual<
-  <R2, E2, _>(
+  <_, E2, R2>(
     f: (a: ClientRequest.ClientRequest) => Effect.Effect<_, E2, R2>
   ) => <A, E, R>(
     self: Client.Client<A, E, R>
   ) => Client.Client<A, E | E2, R | R2>,
-  <A, E, R, R2, E2, _>(
+  <A, E, R, _, E2, R2>(
     self: Client.Client<A, E, R>,
     f: (a: ClientRequest.ClientRequest) => Effect.Effect<_, E2, R2>
   ) => Client.Client<A, E | E2, R | R2>

package/src/internal/http/middleware.ts

@@ -24,7 +24,7 @@ export const loggerDisabled = globalValue(
 )
 
 /** @internal */
-export const withLoggerDisabled = <R, E, A>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
+export const withLoggerDisabled = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
   Effect.zipRight(
     FiberRef.set(loggerDisabled, true),
     self
@@ -40,8 +40,8 @@ export const currentTracerDisabledWhen = globalValue(
 export const withTracerDisabledWhen = dual<
   (
     predicate: Predicate.Predicate<ServerRequest.ServerRequest>
-  ) => <R, E, A>(layer: Layer.Layer<A, E, R>) => Layer.Layer<A, E, R>,
-  <R, E, A>(
+  ) => <A, E, R>(layer: Layer.Layer<A, E, R>) => Layer.Layer<A, E, R>,
+  <A, E, R>(
     layer: Layer.Layer<A, E, R>,
     predicate: Predicate.Predicate<ServerRequest.ServerRequest>
   ) => Layer.Layer<A, E, R>
@@ -51,8 +51,8 @@ export const withTracerDisabledWhen = dual<
 export const withTracerDisabledWhenEffect = dual<
   (
     predicate: Predicate.Predicate<ServerRequest.ServerRequest>
-  ) => <R, E, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
-  <R, E, A>(
+  ) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E, R>(
     effect: Effect.Effect<A, E, R>,
     predicate: Predicate.Predicate<ServerRequest.ServerRequest>
   ) => Effect.Effect<A, E, R>
@@ -62,8 +62,8 @@ export const withTracerDisabledWhenEffect = dual<
 export const withTracerDisabledForUrls = dual<
   (
     urls: ReadonlyArray<string>
-  ) => <R, E, A>(layer: Layer.Layer<A, E, R>) => Layer.Layer<A, E, R>,
-  <R, E, A>(
+  ) => <A, E, R>(layer: Layer.Layer<A, E, R>) => Layer.Layer<A, E, R>,
+  <A, E, R>(
     layer: Layer.Layer<A, E, R>,
     urls: ReadonlyArray<string>
   ) => Layer.Layer<A, E, R>