change RuntimeFiber type parameters order from RuntimeFiber<E, A>… (

#2055)

.changeset/twelve-goats-impress.md

@@ -0,0 +1,5 @@
+---
+"effect": minor
+---
+
+change `RuntimeFiber` type parameters order from `RuntimeFiber<E, A>` to `RuntimeFiber<A, E = never>`

packages/effect/mod.sh

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

packages/effect/mod.ts

@@ -8,7 +8,8 @@ const enabled = {
   swapDeferredParams: false,
   swapTDeferredParams: false,
   swapTakeParams: false,
-  swapFiberParams: true,
+  swapFiberParams: false,
+  swapRuntimeFiberParams: true,
   cleanupSTM: false,
   cleanupEffect: false,
   cleanupStream: false,
@@ -93,6 +94,7 @@ const swapDeferredParams = swapParamsEA("Deferred")
 const swapTDeferredParams = swapParamsEA("TDeferred")
 const swapTakeParams = swapParamsEA("Take")
 const swapFiberParams = swapParamsEA("Fiber")
+const swapRuntimeFiberParams = swapParamsEA("FiberRuntime")
 
 const swapSTMParams = swapParamsREA("STM")
 const swapSTMGenParams = swapParamsREA("STMGen")
@@ -144,6 +146,9 @@ export default function transformer(file: cs.FileInfo, api: cs.API) {
     if (enabled.swapFiberParams) {
       swapFiberParams(ast)
     }
+    if (enabled.swapRuntimeFiberParams) {
+      swapRuntimeFiberParams(ast)
+    }
     if (enabled.cleanupEffect) {
       cleanupEffect(ast)
     }

packages/effect/src/Effect.ts

@@ -2609,7 +2609,7 @@ export const fiberIdWith: <A, E, R>(f: (descriptor: FiberId.Runtime) => Effect<A
  * @since 2.0.0
  * @category supervision & fibers
  */
-export const fork: <A, E, R>(self: Effect<A, E, R>) => Effect<Fiber.RuntimeFiber<E, A>, never, R> = fiberRuntime.fork
+export const fork: <A, E, R>(self: Effect<A, E, R>) => Effect<Fiber.RuntimeFiber<A, E>, never, R> = fiberRuntime.fork
 
 /**
  * Forks the effect into a new fiber attached to the global scope. Because the
@@ -2619,7 +2619,7 @@ export const fork: <A, E, R>(self: Effect<A, E, R>) => Effect<Fiber.RuntimeFiber
  * @since 2.0.0
  * @category supervision & fibers
  */
-export const forkDaemon: <A, E, R>(self: Effect<A, E, R>) => Effect<Fiber.RuntimeFiber<E, A>, never, R> =
+export const forkDaemon: <A, E, R>(self: Effect<A, E, R>) => Effect<Fiber.RuntimeFiber<A, E>, never, R> =
   fiberRuntime.forkDaemon
 
 /**
@@ -2657,8 +2657,8 @@ export const forkAll: {
  * @category supervision & fibers
  */
 export const forkIn: {
-  (scope: Scope.Scope): <A, E, R>(self: Effect<A, E, R>) => Effect<Fiber.RuntimeFiber<E, A>, never, R>
-  <A, E, R>(self: Effect<A, E, R>, scope: Scope.Scope): Effect<Fiber.RuntimeFiber<E, A>, never, R>
+  (scope: Scope.Scope): <A, E, R>(self: Effect<A, E, R>) => Effect<Fiber.RuntimeFiber<A, E>, never, R>
+  <A, E, R>(self: Effect<A, E, R>, scope: Scope.Scope): Effect<Fiber.RuntimeFiber<A, E>, never, R>
 } = circular.forkIn
 
 /**
@@ -2667,7 +2667,7 @@ export const forkIn: {
  * @since 2.0.0
  * @category supervision & fibers
  */
-export const forkScoped: <A, E, R>(self: Effect<A, E, R>) => Effect<Fiber.RuntimeFiber<E, A>, never, Scope.Scope | R> =
+export const forkScoped: <A, E, R>(self: Effect<A, E, R>) => Effect<Fiber.RuntimeFiber<A, E>, never, Scope.Scope | R> =
   circular.forkScoped
 
 /**
@@ -2679,11 +2679,11 @@ export const forkScoped: <A, E, R>(self: Effect<A, E, R>) => Effect<Fiber.Runtim
 export const forkWithErrorHandler: {
   <E, X>(
     handler: (e: E) => Effect<X>
-  ): <R, A>(self: Effect<A, E, R>) => Effect<Fiber.RuntimeFiber<E, A>, never, R>
+  ): <R, A>(self: Effect<A, E, R>) => Effect<Fiber.RuntimeFiber<A, E>, never, R>
   <R, E, A, X>(
     self: Effect<A, E, R>,
     handler: (e: E) => Effect<X>
-  ): Effect<Fiber.RuntimeFiber<E, A>, never, R>
+  ): Effect<Fiber.RuntimeFiber<A, E>, never, R>
 } = fiberRuntime.forkWithErrorHandler
 
 /**
@@ -4087,11 +4087,11 @@ export const schedule: {
 export const scheduleForked: {
   <R2, Out>(
     schedule: Schedule.Schedule<R2, unknown, Out>
-  ): <A, E, R>(self: Effect<A, E, R>) => Effect<Scope.Scope | R2 | R, never, Fiber.RuntimeFiber<E, Out>>
+  ): <A, E, R>(self: Effect<A, E, R>) => Effect<Scope.Scope | R2 | R, never, Fiber.RuntimeFiber<Out, E>>
   <R, E, A, R2, Out>(
     self: Effect<A, E, R>,
     schedule: Schedule.Schedule<R2, unknown, Out>
-  ): Effect<Scope.Scope | R | R2, never, Fiber.RuntimeFiber<E, Out>>
+  ): Effect<Scope.Scope | R | R2, never, Fiber.RuntimeFiber<Out, E>>
 } = circular.scheduleForked
 
 /**
@@ -4706,7 +4706,7 @@ export const makeSemaphore: (permits: number) => Effect<Semaphore> = circular.ma
 export const runFork: <E, A>(
   effect: Effect<A, E>,
   options?: Runtime.RunForkOptions
-) => Fiber.RuntimeFiber<E, A> = _runtime.unsafeForkEffect
+) => Fiber.RuntimeFiber<A, E> = _runtime.unsafeForkEffect
 
 /**
  * @since 2.0.0

packages/effect/src/Fiber.ts

@@ -101,7 +101,7 @@ export interface Fiber<out A, out E = never> extends Fiber.Variance<A, E>, Pipea
  * @since 2.0.0
  * @category models
  */
-export interface RuntimeFiber<out E, out A> extends Fiber<A, E>, Fiber.RuntimeVariance<E, A> {
+export interface RuntimeFiber<out A, out E = never> extends Fiber<A, E>, Fiber.RuntimeVariance<A, E> {
   /**
    * Reads the current number of ops that have occurred since the last yield
    */
@@ -165,7 +165,7 @@ export declare namespace Fiber {
    * @since 2.0.0
    * @category models
    */
-  export type Runtime<E, A> = RuntimeFiber<E, A>
+  export type Runtime<A, E = never> = RuntimeFiber<A, E>
 
   /**
    * @since 2.0.0
@@ -181,10 +181,10 @@ export declare namespace Fiber {
   /**
    * @since 2.0.0
    */
-  export interface RuntimeVariance<out E, out A> {
+  export interface RuntimeVariance<out A, out E> {
     readonly [RuntimeFiberTypeId]: {
-      readonly _E: Types.Covariant<E>
       readonly _A: Types.Covariant<A>
+      readonly _E: Types.Covariant<E>
     }
   }
 
@@ -246,7 +246,7 @@ export const isFiber: (u: unknown) => u is Fiber<unknown, unknown> = internal.is
  * @since 2.0.0
  * @category refinements
  */
-export const isRuntimeFiber: <A, E>(self: Fiber<A, E>) => self is RuntimeFiber<E, A> = internal.isRuntimeFiber
+export const isRuntimeFiber: <A, E>(self: Fiber<A, E>) => self is RuntimeFiber<A, E> = internal.isRuntimeFiber
 
 /**
  * The identity of the fiber.
@@ -306,7 +306,7 @@ export const done: <A, E>(exit: Exit.Exit<A, E>) => Fiber<A, E> = internal.done
  * @since 2.0.0
  * @category destructors
  */
-export const dump: <A, E>(self: RuntimeFiber<E, A>) => Effect.Effect<Fiber.Dump> = internal.dump
+export const dump: <A, E>(self: RuntimeFiber<A, E>) => Effect.Effect<Fiber.Dump> = internal.dump
 
 /**
  * @since 2.0.0
@@ -497,14 +497,14 @@ export const match: {
   <A, E, Z>(
     options: {
       readonly onFiber: (fiber: Fiber<A, E>) => Z
-      readonly onRuntimeFiber: (fiber: RuntimeFiber<E, A>) => Z
+      readonly onRuntimeFiber: (fiber: RuntimeFiber<A, E>) => Z
     }
   ): (self: Fiber<A, E>) => Z
   <A, E, Z>(
     self: Fiber<A, E>,
     options: {
       readonly onFiber: (fiber: Fiber<A, E>) => Z
-      readonly onRuntimeFiber: (fiber: RuntimeFiber<E, A>) => Z
+      readonly onRuntimeFiber: (fiber: RuntimeFiber<A, E>) => Z
     }
   ): Z
 } = internal.match
@@ -558,7 +558,7 @@ export const poll: <A, E>(self: Fiber<A, E>) => Effect.Effect<Option.Option<Exit
  * @since 2.0.0
  * @category destructors
  */
-export const pretty: <A, E>(self: RuntimeFiber<E, A>) => Effect.Effect<string> = internal.pretty
+export const pretty: <A, E>(self: RuntimeFiber<A, E>) => Effect.Effect<string> = internal.pretty
 
 /**
  * Returns a chunk containing all root fibers.
@@ -592,7 +592,7 @@ export const scoped: <A, E>(self: Fiber<A, E>) => Effect.Effect<Fiber<A, E>, nev
  * @since 2.0.0
  * @category getters
  */
-export const status: <A, E>(self: RuntimeFiber<E, A>) => Effect.Effect<FiberStatus.FiberStatus> = internal.status
+export const status: <A, E>(self: RuntimeFiber<A, E>) => Effect.Effect<FiberStatus.FiberStatus> = internal.status
 
 /**
  * Returns a fiber that has already succeeded with the specified value.

packages/effect/src/FiberMap.ts

@@ -32,10 +32,10 @@ export type TypeId = typeof TypeId
  * @categories models
  */
 export interface FiberMap<K, E = unknown, A = unknown>
-  extends Pipeable, Inspectable.Inspectable, Iterable<[K, Fiber.RuntimeFiber<E, A>]>
+  extends Pipeable, Inspectable.Inspectable, Iterable<[K, Fiber.RuntimeFiber<A, E>]>
 {
   readonly [TypeId]: TypeId
-  readonly backing: MutableHashMap.MutableHashMap<K, Fiber.RuntimeFiber<E, A>>
+  readonly backing: MutableHashMap.MutableHashMap<K, Fiber.RuntimeFiber<A, E>>
 }
 
 /**
@@ -111,7 +111,7 @@ export const makeRuntime = <R, K, E = unknown, A = unknown>(): Effect.Effect<
     key: K,
     effect: Effect.Effect<XA, XE, R>,
     options?: Runtime.RunForkOptions | undefined
-  ) => Fiber.RuntimeFiber<XE, XA>,
+  ) => Fiber.RuntimeFiber<XA, XE>,
   never,
   Scope.Scope | R
 > =>
@@ -130,25 +130,25 @@ export const makeRuntime = <R, K, E = unknown, A = unknown>(): Effect.Effect<
 export const unsafeSet: {
   <K, E, A, XE extends E, XA extends A>(
     key: K,
-    fiber: Fiber.RuntimeFiber<XE, XA>,
+    fiber: Fiber.RuntimeFiber<XA, XE>,
     interruptAs?: FiberId.FiberId
   ): (self: FiberMap<K, E, A>) => void
   <K, E, A, XE extends E, XA extends A>(
     self: FiberMap<K, E, A>,
     key: K,
-    fiber: Fiber.RuntimeFiber<XE, XA>,
+    fiber: Fiber.RuntimeFiber<XA, XE>,
     interruptAs?: FiberId.FiberId
   ): void
 } = dual<
   <K, E, A, XE extends E, XA extends A>(
     key: K,
-    fiber: Fiber.RuntimeFiber<XE, XA>,
+    fiber: Fiber.RuntimeFiber<XA, XE>,
     interruptAs?: FiberId.FiberId
   ) => (self: FiberMap<K, E, A>) => void,
   <K, E, A, XE extends E, XA extends A>(
     self: FiberMap<K, E, A>,
     key: K,
-    fiber: Fiber.RuntimeFiber<XE, XA>,
+    fiber: Fiber.RuntimeFiber<XA, XE>,
     interruptAs?: FiberId.FiberId
   ) => void
 >((args) => isFiberMap(args[0]), (self, key, fiber, interruptAs) => {
@@ -178,22 +178,22 @@ export const unsafeSet: {
 export const set: {
   <K, E, A, XE extends E, XA extends A>(
     key: K,
-    fiber: Fiber.RuntimeFiber<XE, XA>
+    fiber: Fiber.RuntimeFiber<XA, XE>
   ): (self: FiberMap<K, E, A>) => Effect.Effect<void>
   <K, E, A, XE extends E, XA extends A>(
     self: FiberMap<K, E, A>,
     key: K,
-    fiber: Fiber.RuntimeFiber<XE, XA>
+    fiber: Fiber.RuntimeFiber<XA, XE>
   ): Effect.Effect<void>
 } = dual<
   <K, E, A, XE extends E, XA extends A>(
     key: K,
-    fiber: Fiber.RuntimeFiber<XE, XA>
+    fiber: Fiber.RuntimeFiber<XA, XE>
   ) => (self: FiberMap<K, E, A>) => Effect.Effect<void>,
   <K, E, A, XE extends E, XA extends A>(
     self: FiberMap<K, E, A>,
     key: K,
-    fiber: Fiber.RuntimeFiber<XE, XA>
+    fiber: Fiber.RuntimeFiber<XA, XE>
   ) => Effect.Effect<void>
 >(3, (self, key, fiber) =>
   Effect.fiberIdWith(
@@ -207,16 +207,16 @@ export const set: {
  * @categories combinators
  */
 export const unsafeGet: {
-  <K>(key: K): <E, A>(self: FiberMap<K, E, A>) => Option.Option<Fiber.RuntimeFiber<E, A>>
-  <K, E, A>(self: FiberMap<K, E, A>, key: K): Option.Option<Fiber.RuntimeFiber<E, A>>
+  <K>(key: K): <E, A>(self: FiberMap<K, E, A>) => Option.Option<Fiber.RuntimeFiber<A, E>>
+  <K, E, A>(self: FiberMap<K, E, A>, key: K): Option.Option<Fiber.RuntimeFiber<A, E>>
 } = dual<
   <K>(
     key: K
-  ) => <E, A>(self: FiberMap<K, E, A>) => Option.Option<Fiber.RuntimeFiber<E, A>>,
+  ) => <E, A>(self: FiberMap<K, E, A>) => Option.Option<Fiber.RuntimeFiber<A, E>>,
   <K, E, A>(
     self: FiberMap<K, E, A>,
     key: K
-  ) => Option.Option<Fiber.RuntimeFiber<E, A>>
+  ) => Option.Option<Fiber.RuntimeFiber<A, E>>
 >(2, (self, key) => MutableHashMap.get(self.backing, key))
 
 /**
@@ -226,16 +226,16 @@ export const unsafeGet: {
  * @categories combinators
  */
 export const get: {
-  <K>(key: K): <E, A>(self: FiberMap<K, E, A>) => Effect.Effect<Fiber.RuntimeFiber<E, A>, NoSuchElementException>
-  <K, E, A>(self: FiberMap<K, E, A>, key: K): Effect.Effect<Fiber.RuntimeFiber<E, A>, NoSuchElementException>
+  <K>(key: K): <E, A>(self: FiberMap<K, E, A>) => Effect.Effect<Fiber.RuntimeFiber<A, E>, NoSuchElementException>
+  <K, E, A>(self: FiberMap<K, E, A>, key: K): Effect.Effect<Fiber.RuntimeFiber<A, E>, NoSuchElementException>
 } = dual<
   <K>(
     key: K
-  ) => <E, A>(self: FiberMap<K, E, A>) => Effect.Effect<Fiber.RuntimeFiber<E, A>, NoSuchElementException>,
+  ) => <E, A>(self: FiberMap<K, E, A>) => Effect.Effect<Fiber.RuntimeFiber<A, E>, NoSuchElementException>,
   <K, E, A>(
     self: FiberMap<K, E, A>,
     key: K
-  ) => Effect.Effect<Fiber.RuntimeFiber<E, A>, NoSuchElementException>
+  ) => Effect.Effect<Fiber.RuntimeFiber<A, E>, NoSuchElementException>
 >(2, (self, key) => Effect.suspend(() => MutableHashMap.get(self.backing, key)))
 
 /**
@@ -290,12 +290,12 @@ export const run: {
     key: K
   ): <R, XE extends E, XA extends A>(
     effect: Effect.Effect<XA, XE, R>
-  ) => Effect.Effect<Fiber.RuntimeFiber<XE, XA>, never, R>
+  ) => Effect.Effect<Fiber.RuntimeFiber<XA, XE>, never, R>
   <K, E, A, R, XE extends E, XA extends A>(
     self: FiberMap<K, E, A>,
     key: K,
     effect: Effect.Effect<XA, XE, R>
-  ): Effect.Effect<Fiber.RuntimeFiber<XE, XA>, never, R>
+  ): Effect.Effect<Fiber.RuntimeFiber<XA, XE>, never, R>
 } = function() {
   if (arguments.length === 2) {
     const self = arguments[0] as FiberMap<any>
@@ -349,7 +349,7 @@ export const runtime: <K, E, A>(
     key: K,
     effect: Effect.Effect<XA, XE, R>,
     options?: Runtime.RunForkOptions | undefined
-  ) => Fiber.RuntimeFiber<XE, XA>,
+  ) => Fiber.RuntimeFiber<XA, XE>,
   never,
   R
 > = <K, E, A>(self: FiberMap<K, E, A>) => <R>() =>