@effect/platform 0.53.12 → 0.53.14

package/src/internal/http/multipart.ts

@@ -60,8 +60,8 @@ export const maxParts: FiberRef.FiberRef<Option.Option<number>> = globalValue(
 
 /** @internal */
 export const withMaxParts = dual<
-  (count: Option.Option<number>) => <R, E, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
-  <R, E, A>(effect: Effect.Effect<A, E, R>, count: Option.Option<number>) => Effect.Effect<A, E, R>
+  (count: Option.Option<number>) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E, R>(effect: Effect.Effect<A, E, R>, count: Option.Option<number>) => Effect.Effect<A, E, R>
 >(2, (effect, count) => Effect.locally(effect, maxParts, count))
 
 /** @internal */
@@ -72,8 +72,8 @@ export const maxFieldSize: FiberRef.FiberRef<FileSystem.Size> = globalValue(
 
 /** @internal */
 export const withMaxFieldSize = dual<
-  (size: FileSystem.SizeInput) => <R, E, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
-  <R, E, A>(effect: Effect.Effect<A, E, R>, size: FileSystem.SizeInput) => Effect.Effect<A, E, R>
+  (size: FileSystem.SizeInput) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E, R>(effect: Effect.Effect<A, E, R>, size: FileSystem.SizeInput) => Effect.Effect<A, E, R>
 >(2, (effect, size) => Effect.locally(effect, maxFieldSize, FileSystem.Size(size)))
 
 /** @internal */
@@ -84,8 +84,8 @@ export const maxFileSize: FiberRef.FiberRef<Option.Option<FileSystem.Size>> = gl
 
 /** @internal */
 export const withMaxFileSize = dual<
-  (size: Option.Option<FileSystem.SizeInput>) => <R, E, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
-  <R, E, A>(effect: Effect.Effect<A, E, R>, size: Option.Option<FileSystem.SizeInput>) => Effect.Effect<A, E, R>
+  (size: Option.Option<FileSystem.SizeInput>) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E, R>(effect: Effect.Effect<A, E, R>, size: Option.Option<FileSystem.SizeInput>) => Effect.Effect<A, E, R>
 >(2, (effect, size) => Effect.locally(effect, maxFileSize, Option.map(size, FileSystem.Size)))
 
 /** @internal */
@@ -96,8 +96,8 @@ export const fieldMimeTypes: FiberRef.FiberRef<Chunk.Chunk<string>> = globalValu
 
 /** @internal */
 export const withFieldMimeTypes = dual<
-  (mimeTypes: ReadonlyArray<string>) => <R, E, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
-  <R, E, A>(effect: Effect.Effect<A, E, R>, mimeTypes: ReadonlyArray<string>) => Effect.Effect<A, E, R>
+  (mimeTypes: ReadonlyArray<string>) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E, R>(effect: Effect.Effect<A, E, R>, mimeTypes: ReadonlyArray<string>) => Effect.Effect<A, E, R>
 >(2, (effect, mimeTypes) => Effect.locally(effect, fieldMimeTypes, Chunk.fromIterable(mimeTypes)))
 
 /** @internal */

package/src/internal/http/multiplex.ts

@@ -68,7 +68,7 @@ class MultiplexImpl<E = never, R = never>
 export const empty: Multiplex.Multiplex<never> = new MultiplexImpl([])
 
 /** @internal */
-export const make = <R, E>(
+export const make = <E, R>(
   apps: Iterable<
     readonly [predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<boolean, E, R>, app: App.Default<E, R>]
   >
@@ -76,11 +76,11 @@ export const make = <R, E>(
 
 /** @internal */
 export const add = dual<
-  <R2, E2, R3, E3>(
+  <E2, R2, E3, R3>(
     predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<boolean, E2, R2>,
     app: App.Default<E3, R3>
-  ) => <R, E>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2 | E3, R | R2 | R3>,
-  <R, E, R2, E2, R3, E3>(
+  ) => <E, R>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2 | E3, R | R2 | R3>,
+  <E, R, E2, R2, E3, R3>(
     self: Multiplex.Multiplex<E, R>,
     predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<boolean, E2, R2>,
     app: App.Default<E3, R3>
@@ -96,12 +96,12 @@ export const add = dual<
 
 /** @internal */
 export const headerExact = dual<
-  <R2, E2>(
+  <E2, R2>(
     header: string,
     value: string,
     app: App.Default<E2, R2>
-  ) => <R, E>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
-  <R, E, R2, E2>(
+  ) => <E, R>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
+  <E, R, E2, R2>(
     self: Multiplex.Multiplex<E, R>,
     header: string,
     value: string,
@@ -118,12 +118,12 @@ export const headerExact = dual<
 
 /** @internal */
 export const headerRegex = dual<
-  <R2, E2>(
+  <E2, R2>(
     header: string,
     regex: RegExp,
     app: App.Default<E2, R2>
-  ) => <R, E>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
-  <R, E, R2, E2>(
+  ) => <E, R>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
+  <E, R, E2, R2>(
     self: Multiplex.Multiplex<E, R>,
     header: string,
     regex: RegExp,
@@ -140,12 +140,12 @@ export const headerRegex = dual<
 
 /** @internal */
 export const headerStartsWith = dual<
-  <R2, E2>(
+  <E2, R2>(
     header: string,
     prefix: string,
     app: App.Default<E2, R2>
-  ) => <R, E>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
-  <R, E, R2, E2>(
+  ) => <E, R>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
+  <E, R, E2, R2>(
     self: Multiplex.Multiplex<E, R>,
     header: string,
     prefix: string,
@@ -162,12 +162,12 @@ export const headerStartsWith = dual<
 
 /** @internal */
 export const headerEndsWith = dual<
-  <R2, E2>(
+  <E2, R2>(
     header: string,
     suffix: string,
     app: App.Default<E2, R2>
-  ) => <R, E>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
-  <R, E, R2, E2>(
+  ) => <E, R>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
+  <E, R, E2, R2>(
     self: Multiplex.Multiplex<E, R>,
     header: string,
     suffix: string,
@@ -184,11 +184,11 @@ export const headerEndsWith = dual<
 
 /** @internal */
 export const hostRegex = dual<
-  <R2, E2>(
+  <E2, R2>(
     regex: RegExp,
     app: App.Default<E2, R2>
-  ) => <R, E>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
-  <R, E, R2, E2>(
+  ) => <E, R>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
+  <E, R, E2, R2>(
     self: Multiplex.Multiplex<E, R>,
     regex: RegExp,
     app: App.Default<E2, R2>
@@ -197,11 +197,11 @@ export const hostRegex = dual<
 
 /** @internal */
 export const hostStartsWith = dual<
-  <R2, E2>(
+  <E2, R2>(
     prefix: string,
     app: App.Default<E2, R2>
-  ) => <R, E>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
-  <R, E, R2, E2>(
+  ) => <E, R>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
+  <E, R, E2, R2>(
     self: Multiplex.Multiplex<E, R>,
     prefix: string,
     app: App.Default<E2, R2>
@@ -210,11 +210,11 @@ export const hostStartsWith = dual<
 
 /** @internal */
 export const hostEndsWith = dual<
-  <R2, E2>(
+  <E2, R2>(
     suffix: string,
     app: App.Default<E2, R2>
-  ) => <R, E>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
-  <R, E, R2, E2>(
+  ) => <E, R>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
+  <E, R, E2, R2>(
     self: Multiplex.Multiplex<E, R>,
     suffix: string,
     app: App.Default<E2, R2>
@@ -223,11 +223,11 @@ export const hostEndsWith = dual<
 
 /** @internal */
 export const hostExact = dual<
-  <R2, E2>(
+  <E2, R2>(
     host: string,
     app: App.Default<E2, R2>
-  ) => <R, E>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
-  <R, E, R2, E2>(
+  ) => <E, R>(self: Multiplex.Multiplex<E, R>) => Multiplex.Multiplex<E | E2, R | R2>,
+  <E, R, E2, R2>(
     self: Multiplex.Multiplex<E, R>,
     host: string,
     app: App.Default<E2, R2>

package/src/internal/http/router.ts

@@ -180,7 +180,7 @@ class RouterImpl<E = never, R = never> extends Effectable.StructuralClass<
   }
 }
 
-const toHttpApp = <R, E>(
+const toHttpApp = <E, R>(
   self: Router.Router<E, R>
 ): App.Default<E | Error.RouteNotFound, R> => {
   const router = FindMyWay.make<Router.Route<E, R>>()
@@ -331,8 +331,8 @@ export const makeRoute = <E, R>(
 
 /** @internal */
 export const concat = dual<
-  <R1, E1>(that: Router.Router<E1, R1>) => <R, E>(self: Router.Router<E, R>) => Router.Router<E | E1, R | R1>,
-  <R, E, R1, E1>(self: Router.Router<E, R>, that: Router.Router<E1, R1>) => Router.Router<E | E1, R | R1>
+  <R1, E1>(that: Router.Router<E1, R1>) => <E, R>(self: Router.Router<E, R>) => Router.Router<E | E1, R | R1>,
+  <E, R, E1, R1>(self: Router.Router<E, R>, that: Router.Router<E1, R1>) => Router.Router<E | E1, R | R1>
 >(2, (self, that) => new RouterImpl(Chunk.appendAll(self.routes, that.routes) as any, self.mounts))
 
 const removeTrailingSlash = (
@@ -341,8 +341,8 @@ const removeTrailingSlash = (
 
 /** @internal */
 export const prefixAll = dual<
-  (prefix: Router.PathInput) => <R, E>(self: Router.Router<E, R>) => Router.Router<E, R>,
-  <R, E>(self: Router.Router<E, R>, prefix: Router.PathInput) => Router.Router<E, R>
+  (prefix: Router.PathInput) => <E, R>(self: Router.Router<E, R>) => Router.Router<E, R>,
+  <E, R>(self: Router.Router<E, R>, prefix: Router.PathInput) => Router.Router<E, R>
 >(
   2,
   (self, prefix) => {
@@ -369,8 +369,8 @@ export const mount = dual<
   <R1, E1>(
     path: `/${string}`,
     that: Router.Router<E1, R1>
-  ) => <R, E>(self: Router.Router<E, R>) => Router.Router<E | E1, R | R1>,
-  <R, E, R1, E1>(
+  ) => <E, R>(self: Router.Router<E, R>) => Router.Router<E | E1, R | R1>,
+  <E, R, E1, R1>(
     self: Router.Router<E, R>,
     path: `/${string}`,
     that: Router.Router<E1, R1>
@@ -388,10 +388,10 @@ export const mountApp = dual<
     options?: {
       readonly includePrefix?: boolean | undefined
     } | undefined
-  ) => <R, E>(
+  ) => <E, R>(
     self: Router.Router<E, R>
   ) => Router.Router<E | E1, R | Router.Router.ExcludeProvided<R1>>,
-  <R, E, R1, E1>(
+  <E, R, E1, R1>(
     self: Router.Router<E, R>,
     path: `/${string}`,
     that: App.Default<E1, R1>,
@@ -401,7 +401,7 @@ export const mountApp = dual<
   ) => Router.Router<E | E1, R | Router.Router.ExcludeProvided<R1>>
 >(
   (args) => Predicate.hasProperty(args[0], TypeId),
-  <R, E, R1, E1>(
+  <E, R, E1, R1>(
     self: Router.Router<E, R>,
     path: `/${string}`,
     that: App.Default<E1, R1>,
@@ -420,10 +420,10 @@ export const route = (method: Method.Method | "*"): {
     options?: {
       readonly uninterruptible?: boolean | undefined
     } | undefined
-  ): <R, E>(
+  ): <E, R>(
     self: Router.Router<E, R>
   ) => Router.Router<E1 | E, R | Router.Router.ExcludeProvided<R1>>
-  <R, E, R1, E1>(
+  <E, R, E1, R1>(
     self: Router.Router<E, R>,
     path: Router.PathInput,
     handler: Router.Route.Handler<E1, R1>,
@@ -436,10 +436,10 @@ export const route = (method: Method.Method | "*"): {
     <R1, E1>(
       path: Router.PathInput,
       handler: Router.Route.Handler<R1, E1>
-    ) => <R, E>(
+    ) => <E, R>(
       self: Router.Router<E, R>
     ) => Router.Router<E | E1, R | Router.Router.ExcludeProvided<R1>>,
-    <R, E, R1, E1>(
+    <E, R, E1, R1>(
       self: Router.Router<E, R>,
       path: Router.PathInput,
       handler: Router.Route.Handler<E1, R1>,
@@ -512,7 +512,7 @@ export const catchAll = dual<
   <E, E2, R2>(
     f: (e: E) => Router.Route.Handler<E2, R2>
   ) => <R>(self: Router.Router<E, R>) => Router.Router<E2, R | Router.Router.ExcludeProvided<R2>>,
-  <R, E, E2, R2>(
+  <E, R, E2, R2>(
     self: Router.Router<E, R>,
     f: (e: E) => Router.Route.Handler<E2, R2>
   ) => Router.Router<E2, R | Router.Router.ExcludeProvided<R2>>
@@ -523,7 +523,7 @@ export const catchAllCause = dual<
   <E, E2, R2>(
     f: (e: Cause.Cause<E>) => Router.Route.Handler<E2, R2>
   ) => <R>(self: Router.Router<E, R>) => Router.Router<E2, R | Router.Router.ExcludeProvided<R2>>,
-  <R, E, E2, R2>(
+  <E, R, E2, R2>(
     self: Router.Router<E, R>,
     f: (e: Cause.Cause<E>) => Router.Route.Handler<E2, R2>
   ) => Router.Router<E2, R | Router.Router.ExcludeProvided<R2>>
@@ -537,7 +537,7 @@ export const catchTag = dual<
   ) => <R>(
     self: Router.Router<E, R>
   ) => Router.Router<Exclude<E, { _tag: K }> | E1, R | Router.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.Router<E, R>,
     k: K,
     f: (e: Extract<E, { _tag: K }>) => Router.Route.Handler<E1, R1>
@@ -594,15 +594,15 @@ export const provideService = dual<
   <T extends Context.Tag<any, any>>(
     tag: T,
     service: Context.Tag.Service<T>
-  ) => <R, E>(
+  ) => <E, R>(
     self: Router.Router<E, R>
   ) => Router.Router<E, Exclude<R, Context.Tag.Identifier<T>>>,
-  <R, E, T extends Context.Tag<any, any>>(
+  <E, R, T extends Context.Tag<any, any>>(
     self: Router.Router<E, R>,
     tag: T,
     service: Context.Tag.Service<T>
   ) => Router.Router<E, Exclude<R, Context.Tag.Identifier<T>>>
->(3, <R, E, T extends Context.Tag<any, any>>(
+>(3, <E, R, T extends Context.Tag<any, any>>(
   self: Router.Router<E, R>,
   tag: T,
   service: Context.Tag.Service<T>
@@ -613,7 +613,7 @@ export const provideServiceEffect = dual<
   <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.Router<E, R>
   ) => Router.Router<
     E | E1,
@@ -622,7 +622,7 @@ export const provideServiceEffect = dual<
       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.Router<E, R>,
     tag: T,
     effect: Effect.Effect<Context.Tag.Service<T>, E1, R1>
@@ -633,7 +633,7 @@ export const provideServiceEffect = dual<
       Context.Tag.Identifier<T>
     >
   >
->(3, <R, E, T extends Context.Tag<any, any>, R1, E1>(
+>(3, <E, R, T extends Context.Tag<any, any>, R1, E1>(
   self: Router.Router<E, R>,
   tag: T,
   effect: Effect.Effect<Context.Tag.Service<T>, E1, R1>

package/src/internal/http/server.ts

@@ -35,10 +35,10 @@ export const make = (
 /** @internal */
 export const serve = dual<
   {
-    (): <R, E>(
+    (): <E, R>(
       httpApp: App.Default<E, R>
     ) => Layer.Layer<never, never, Server.Server | Exclude<R, ServerRequest.ServerRequest | Scope.Scope>>
-    <R, E, App extends App.Default<any, any>>(middleware: Middleware.Middleware.Applied<App, E, R>): (
+    <E, R, App extends App.Default<any, any>>(middleware: Middleware.Middleware.Applied<App, E, R>): (
       httpApp: App.Default<E, R>
     ) => Layer.Layer<
       never,
@@ -47,10 +47,10 @@ export const serve = dual<
     >
   },
   {
-    <R, E>(
+    <E, R>(
       httpApp: App.Default<E, R>
     ): Layer.Layer<never, never, Server.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<
@@ -61,7 +61,7 @@ export const serve = dual<
   }
 >(
   (args) => Effect.isEffect(args[0]),
-  <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<
@@ -80,14 +80,14 @@ export const serve = dual<
 /** @internal */
 export const serveEffect = dual<
   {
-    (): <R, E>(
+    (): <E, R>(
       httpApp: App.Default<E, R>
     ) => Effect.Effect<
       void,
       never,
       Server.Server | Scope.Scope | Exclude<R, ServerRequest.ServerRequest>
     >
-    <R, E, App extends App.Default<any, any>>(middleware: Middleware.Middleware.Applied<App, E, R>): (
+    <E, R, App extends App.Default<any, any>>(middleware: Middleware.Middleware.Applied<App, E, R>): (
       httpApp: App.Default<E, R>
     ) => Effect.Effect<
       void,
@@ -96,10 +96,10 @@ export const serveEffect = dual<
     >
   },
   {
-    <R, E>(
+    <E, R>(
       httpApp: App.Default<E, R>
     ): Effect.Effect<void, never, Server.Server | Scope.Scope | 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<
@@ -110,7 +110,7 @@ export const serveEffect = dual<
   }
 >(
   (args) => Effect.isEffect(args[0]),
-  (<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<
@@ -135,7 +135,7 @@ export const formatAddress = (address: Server.Address): string => {
 }
 
 /** @internal */
-export const addressWith = <R, E, A>(
+export const addressWith = <A, E, R>(
   effect: (address: Server.Address) => Effect.Effect<A, E, R>
 ): Effect.Effect<A, E, Server.Server | R> =>
   Effect.flatMap(
@@ -144,7 +144,7 @@ export const addressWith = <R, E, A>(
   )
 
 /** @internal */
-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.Server | R> =>
   Effect.flatMap(
@@ -158,7 +158,7 @@ export const logAddress: Effect.Effect<void, never, Server.Server> = addressForm
 )
 
 /** @internal */
-export const withLogAddress = <R, E, A>(
+export const withLogAddress = <A, E, R>(
   layer: Layer.Layer<A, E, R>
 ): Layer.Layer<A, E, R | Exclude<Server.Server, A>> =>
   Layer.effectDiscard(logAddress).pipe(

package/src/internal/workerRunner.ts

@@ -30,7 +30,7 @@ export const PlatformRunner = Context.GenericTag<WorkerRunner.PlatformRunner>(
 )
 
 /** @internal */
-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?: WorkerRunner.Runner.Options<I, O, E>
 ) =>
@@ -172,7 +172,7 @@ export const make = <I, R, E, O>(
   })
 
 /** @internal */
-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?: WorkerRunner.Runner.Options<I, O, E>
 ): Layer.Layer<never, WorkerError, WorkerRunner.PlatformRunner | R> => Layer.scopedDiscard(make(process, options))