swap Schedule type parameters from `Schedule<out Env, in In, out Ou… (

#2155)

.changeset/chilled-paws-divide.md

@@ -0,0 +1,6 @@
+---
+"effect": minor
+---
+
+- swap `Schedule` type parameters from `Schedule<out Env, in In, out Out>` to `Schedule<out Out, in In = unknown, out R = never>`, closes #2154
+- swap `ScheduleDriver` type parameters from `ScheduleDriver<out Env, in In, out Out>` to `ScheduleDriver<out Out, in In = unknown, out R = never>`

packages/effect/mod.sh

@@ -1,5 +1,5 @@
 #!/bin/bash
-dirs=(../typeclass/src ../typeclass/test ../typeclass/dtslint)
+dirs=(../effect/src ../effect/test)
 for dir in ${dirs[@]};
 do
 echo Refactoring $dir

packages/effect/mod.ts

@@ -2,7 +2,8 @@ import type k from "ast-types/gen/kinds.js"
 import type cs from "jscodeshift"
 
 const enabled = {
-  swapEitherParams: true,
+  swapScheduleParams: true,
+  swapEitherParams: false,
   swapLayerParams: false,
   swapSTMParams: false,
   swapSTMGenParams: false,
@@ -148,12 +149,35 @@ const swapSTMParams = swapParamsREA("STM")
 const swapSTMGenParams = swapParamsREA("STMGen")
 const swapLayerParams = swapParamsREA("Layer")
 
+// from: Schedule<out Env, in In, out Out>
+// to: Schedule<out Out, in In = unknown, out Env = never>
+const swapScheduleParams = (ast: cs.ASTPath<cs.TSTypeReference>) => {
+  const is = filter(ast, "Schedule")
+  if (
+    is(ast.value.typeName) &&
+    ast.value.typeParameters &&
+    ast.value.typeParameters.params.length === 3
+  ) {
+    const params = ast.value.typeParameters.params
+    const newParams = [params[2], params[1], params[0]]
+    popNever(newParams)
+    popUnknown(newParams)
+    ast.value.typeParameters.params = newParams
+  }
+}
+
 const popNever = (params: Array<k.TSTypeKind>) => {
   if (params.length > 0 && params[params.length - 1].type === "TSNeverKeyword") {
     params.pop()
   }
 }
 
+const popUnknown = (params: Array<k.TSTypeKind>) => {
+  if (params.length > 0 && params[params.length - 1].type === "TSUnknownKeyword") {
+    params.pop()
+  }
+}
+
 export default function transformer(file: cs.FileInfo, api: cs.API) {
   const j = api.jscodeshift
   const root = j(file.source)
@@ -173,6 +197,9 @@ export default function transformer(file: cs.FileInfo, api: cs.API) {
   }
 
   forEveryTypeReference(root, (ast) => {
+    if (enabled.swapScheduleParams) {
+      swapScheduleParams(ast)
+    }
     if (enabled.swapEitherParams) {
       swapEitherParams(ast)
     }

packages/effect/src/Effect.ts

@@ -1737,13 +1737,13 @@ export declare namespace Retry {
    */
   export type Return<R, E, A, O extends Options<E>> = Effect<
     A,
-    | (O extends { schedule: Schedule.Schedule<infer _R, infer _I, infer _O> } ? E
+    | (O extends { schedule: Schedule.Schedule<infer _O, infer _I, infer _R> } ? E
       : O extends { until: Refinement<E, infer E2> } ? E2
       : E)
     | (O extends { while: (...args: Array<any>) => Effect<infer _A, infer E, infer _R> } ? E : never)
     | (O extends { until: (...args: Array<any>) => Effect<infer _A, infer E, infer _R> } ? E : never),
     | R
-    | (O extends { schedule: Schedule.Schedule<infer R, infer _I, infer _O> } ? R : never)
+    | (O extends { schedule: Schedule.Schedule<infer _O, infer _I, infer R> } ? R : never)
     | (O extends { while: (...args: Array<any>) => Effect<infer _A, infer _E, infer R> } ? R : never)
     | (O extends { until: (...args: Array<any>) => Effect<infer _A, infer _E, infer R> } ? R : never)
   > extends infer Z ? Z : never
@@ -1772,16 +1772,16 @@ export const retry: {
   ): <A, R>(
     self: Effect<A, E, R>
   ) => Retry.Return<R, E, A, O>
-  <R1, E, B>(
-    policy: Schedule.Schedule<R1, NoInfer<E>, B>
+  <B, E, R1>(
+    policy: Schedule.Schedule<B, NoInfer<E>, R1>
   ): <A, R>(self: Effect<A, E, R>) => Effect<A, E, R1 | R>
   <A, E, R, O extends Retry.Options<E>>(
     self: Effect<A, E, R>,
     options: O
   ): Retry.Return<R, E, A, O>
-  <R, E, A, R1, B>(
+  <A, E, R, B, R1>(
     self: Effect<A, E, R>,
-    policy: Schedule.Schedule<R1, E, B>
+    policy: Schedule.Schedule<B, E, R1>
   ): Effect<A, E, R1 | R>
 } = _schedule.retry_combined
 
@@ -1794,13 +1794,13 @@ export const retry: {
  * @category error handling
  */
 export const retryOrElse: {
-  <R1, E, A1, A2, E2, R2>(
-    policy: Schedule.Schedule<R1, NoInfer<E>, A1>,
+  <A1, E, R1, A2, E2, R2>(
+    policy: Schedule.Schedule<A1, NoInfer<E>, R1>,
     orElse: (e: NoInfer<E>, out: A1) => Effect<A2, E2, R2>
   ): <A, R>(self: Effect<A, E, R>) => Effect<A2 | A, E | E2, R1 | R2 | R>
   <A, E, R, A1, R1, A2, E2, R2>(
     self: Effect<A, E, R>,
-    policy: Schedule.Schedule<R1, NoInfer<E>, A1>,
+    policy: Schedule.Schedule<A1, NoInfer<E>, R1>,
     orElse: (e: NoInfer<E>, out: A1) => Effect<A2, E2, R2>
   ): Effect<A | A2, E | E2, R | R1 | R2>
 } = _schedule.retryOrElse_Effect
@@ -3936,14 +3936,14 @@ export declare namespace Repeat {
    * @category repetition / recursion
    */
   export type Return<R, E, A, O extends Options<A>> = Effect<
-    (O extends { schedule: Schedule.Schedule<infer _R, infer _I, infer Out> } ? Out
+    (O extends { schedule: Schedule.Schedule<infer Out, infer _I, infer _R> } ? Out
       : O extends { until: Refinement<A, infer B> } ? B
       : A),
     | E
     | (O extends { while: (...args: Array<any>) => Effect<infer _A, infer E, infer _R> } ? E : never)
     | (O extends { until: (...args: Array<any>) => Effect<infer _A, infer E, infer _R> } ? E : never),
     | R
-    | (O extends { schedule: Schedule.Schedule<infer R, infer _I, infer _O> } ? R : never)
+    | (O extends { schedule: Schedule.Schedule<infer _O, infer _I, infer R> } ? R : never)
     | (O extends { while: (...args: Array<any>) => Effect<infer _A, infer _E, infer R> } ? R : never)
     | (O extends { until: (...args: Array<any>) => Effect<infer _A, infer _E, infer R> } ? R : never)
   > extends infer Z ? Z : never
@@ -3971,19 +3971,19 @@ export declare namespace Repeat {
  * @category repetition / recursion
  */
 export const repeat: {
-  <A, O extends Repeat.Options<A>>(
+  <O extends Repeat.Options<A>, A>(
     options: O
   ): <E, R>(
     self: Effect<A, E, R>
   ) => Repeat.Return<R, E, A, O>
-  <R1, A, B>(
-    schedule: Schedule.Schedule<R1, A, B>
+  <B, A, R1>(
+    schedule: Schedule.Schedule<B, A, R1>
   ): <E, R>(self: Effect<A, E, R>) => Effect<B, E, R1 | R>
   <A, E, R, O extends Repeat.Options<A>>(
     self: Effect<A, E, R>,
     options: O
   ): Repeat.Return<R, E, A, O>
-  <A, E, R, R1, B>(self: Effect<A, E, R>, schedule: Schedule.Schedule<R1, A, B>): Effect<B, E, R | R1>
+  <A, E, R, B, R1>(self: Effect<A, E, R>, schedule: Schedule.Schedule<B, A, R1>): Effect<B, E, R | R1>
 } = _schedule.repeat_combined
 
 /**
@@ -4014,12 +4014,12 @@ export const repeatN: {
  */
 export const repeatOrElse: {
   <R2, A, B, E, E2, R3>(
-    schedule: Schedule.Schedule<R2, A, B>,
+    schedule: Schedule.Schedule<B, A, R2>,
     orElse: (error: E, option: Option.Option<B>) => Effect<B, E2, R3>
   ): <R>(self: Effect<A, E, R>) => Effect<B, E2, R2 | R3 | R>
   <A, E, R, R2, B, E2, R3>(
     self: Effect<A, E, R>,
-    schedule: Schedule.Schedule<R2, A, B>,
+    schedule: Schedule.Schedule<B, A, R2>,
     orElse: (error: E, option: Option.Option<B>) => Effect<B, E2, R3>
   ): Effect<B, E2, R | R2 | R3>
 } = _schedule.repeatOrElse_Effect
@@ -4034,8 +4034,8 @@ export const repeatOrElse: {
  * @category repetition / recursion
  */
 export const schedule: {
-  <R2, Out>(schedule: Schedule.Schedule<R2, unknown, Out>): <A, E, R>(self: Effect<A, E, R>) => Effect<Out, E, R2 | R>
-  <A, E, R, R2, Out>(self: Effect<A, E, R>, schedule: Schedule.Schedule<R2, unknown, Out>): Effect<Out, E, R | R2>
+  <R2, Out>(schedule: Schedule.Schedule<Out, unknown, R2>): <A, E, R>(self: Effect<A, E, R>) => Effect<Out, E, R2 | R>
+  <A, E, R, R2, Out>(self: Effect<A, E, R>, schedule: Schedule.Schedule<Out, unknown, R2>): Effect<Out, E, R | R2>
 } = _schedule.schedule_Effect
 
 /**
@@ -4046,12 +4046,12 @@ export const schedule: {
  * @category repetition / recursion
  */
 export const scheduleForked: {
-  <R2, Out>(
-    schedule: Schedule.Schedule<R2, unknown, Out>
+  <Out, R2>(
+    schedule: Schedule.Schedule<Out, unknown, R2>
   ): <A, E, R>(self: Effect<A, E, R>) => Effect<Fiber.RuntimeFiber<Out, E>, never, Scope.Scope | R2 | R>
-  <R, E, A, R2, Out>(
+  <A, E, R, Out, R2>(
     self: Effect<A, E, R>,
-    schedule: Schedule.Schedule<R2, unknown, Out>
+    schedule: Schedule.Schedule<Out, unknown, R2>
   ): Effect<Fiber.RuntimeFiber<Out, E>, never, Scope.Scope | R | R2>
 } = circular.scheduleForked
 
@@ -4065,12 +4065,12 @@ export const scheduleForked: {
 export const scheduleFrom: {
   <R2, In, Out>(
     initial: In,
-    schedule: Schedule.Schedule<R2, In, Out>
+    schedule: Schedule.Schedule<Out, In, R2>
   ): <E, R>(self: Effect<In, E, R>) => Effect<Out, E, R2 | R>
   <In, E, R, R2, Out>(
     self: Effect<In, E, R>,
     initial: In,
-    schedule: Schedule.Schedule<R2, In, Out>
+    schedule: Schedule.Schedule<Out, In, R2>
   ): Effect<Out, E, R | R2>
 } = _schedule.scheduleFrom_Effect
 

packages/effect/src/Layer.ts

@@ -597,12 +597,12 @@ export const fiberRefLocallyScopedWith: <A>(self: FiberRef<A>, value: (_: A) =>
  * @category retrying
  */
 export const retry: {
-  <RIn2, E, X>(
-    schedule: Schedule.Schedule<RIn2, E, X>
-  ): <RIn, ROut>(self: Layer<ROut, E, RIn>) => Layer<ROut, E, RIn2 | RIn>
-  <RIn, E, ROut, RIn2, X>(
+  <X, E, RIn2>(
+    schedule: Schedule.Schedule<X, E, RIn2>
+  ): <ROut, RIn>(self: Layer<ROut, E, RIn>) => Layer<ROut, E, RIn2 | RIn>
+  <ROut, E, RIn, X, RIn2>(
     self: Layer<ROut, E, RIn>,
-    schedule: Schedule.Schedule<RIn2, E, X>
+    schedule: Schedule.Schedule<X, E, RIn2>
   ): Layer<ROut, E, RIn | RIn2>
 } = internal.retry
 

packages/effect/src/MetricPolling.ts

@@ -70,14 +70,14 @@ export const collectAll: <R, E, Out>(
  * @category utils
  */
 export const launch: {
-  <R2, A2>(
-    schedule: Schedule.Schedule<R2, unknown, A2>
+  <A2, R2>(
+    schedule: Schedule.Schedule<A2, unknown, R2>
   ): <Type, In, R, E, Out>(
     self: MetricPolling<Type, In, R, E, Out>
-  ) => Effect.Effect<Fiber.Fiber<A2, E>, never, Scope.Scope | R2 | R>
-  <Type, In, R, E, Out, R2, A2>(
+  ) => Effect.Effect<Fiber.Fiber<A2, E>, never, R2 | R | Scope.Scope>
+  <Type, In, R, E, Out, A2, R2>(
     self: 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, Scope.Scope | R | R2>
 } = internal.launch
 
@@ -108,12 +108,12 @@ export const pollAndUpdate: <Type, In, R, E, Out>(
  * @category constructors
  */
 export const retry: {
-  <R2, E, _>(
-    policy: Schedule.Schedule<R2, E, _>
+  <_, E, R2>(
+    policy: Schedule.Schedule<_, E, R2>
   ): <Type, In, R, Out>(self: MetricPolling<Type, In, R, E, Out>) => MetricPolling<Type, In, R2 | R, E, Out>
-  <Type, In, R, Out, R2, E, _>(
+  <Type, In, R, E, Out, _, R2>(
     self: MetricPolling<Type, In, R, E, Out>,
-    policy: Schedule.Schedule<R2, E, _>
+    policy: Schedule.Schedule<_, E, R2>
   ): MetricPolling<Type, In, R | R2, E, Out>
 } = internal.retry
 

packages/effect/src/Reloadable.ts

@@ -62,11 +62,11 @@ export declare namespace Reloadable {
  * @since 2.0.0
  * @category constructors
  */
-export const auto: <Out extends Context.Tag<any, any>, In, E, R>(
+export const auto: <Out extends Context.Tag<any, any>, E, In, R>(
   tag: Out,
   options: {
     readonly layer: Layer.Layer<Context.Tag.Identifier<Out>, E, In>
-    readonly schedule: Schedule.Schedule<R, unknown, unknown>
+    readonly schedule: Schedule.Schedule<unknown, unknown, R>
   }
 ) => Layer.Layer<Reloadable<Context.Tag.Identifier<Out>>, E, In | R> = internal.auto
 
@@ -78,11 +78,11 @@ export const auto: <Out extends Context.Tag<any, any>, In, E, R>(
  * @since 2.0.0
  * @category constructors
  */
-export const autoFromConfig: <Out extends Context.Tag<any, any>, In, E, R>(
+export const autoFromConfig: <Out extends Context.Tag<any, any>, E, In, R>(
   tag: Out,
   options: {
     readonly layer: Layer.Layer<Context.Tag.Identifier<Out>, E, In>
-    readonly scheduleFromConfig: (context: Context.Context<In>) => Schedule.Schedule<R, unknown, unknown>
+    readonly scheduleFromConfig: (context: Context.Context<In>) => Schedule.Schedule<unknown, unknown, R>
   }
 ) => Layer.Layer<Reloadable<Context.Tag.Identifier<Out>>, E, In | R> = internal.autoFromConfig
 

packages/effect/src/Resource.ts

@@ -61,10 +61,10 @@ export declare namespace Resource {
  * @since 2.0.0
  * @category constructors
  */
-export const auto: <A, E, R, R2, Out>(
+export const auto: <A, E, R, Out, R2>(
   acquire: Effect.Effect<A, E, R>,
-  policy: Schedule.Schedule<R2, unknown, Out>
-) => Effect.Effect<Resource<A, E>, never, Scope.Scope | R | R2> = internal.auto
+  policy: Schedule.Schedule<Out, unknown, R2>
+) => Effect.Effect<Resource<A, E>, never, R | R2 | Scope.Scope> = internal.auto
 
 /**
  * Retrieves the current value stored in the cache.