change FiberSet type parameters order from FiberSet<E, A> to `Fib…

.changeset/funny-items-check.md

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

packages/effect/mod.sh

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

packages/effect/mod.ts

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

packages/effect/src/Deferred.ts

@@ -37,9 +37,9 @@ export type DeferredTypeId = typeof DeferredTypeId
  * @since 2.0.0
  * @category models
  */
-export interface Deferred<in out A, in out E = never> extends Deferred.Variance<E, A>, Pipeable {
+export interface Deferred<in out A, in out E = never> extends Deferred.Variance<A, E>, Pipeable {
   /** @internal */
-  readonly state: MutableRef.MutableRef<internal.State<E, A>>
+  readonly state: MutableRef.MutableRef<internal.State<A, E>>
   /** @internal */
   readonly blockingOn: FiberId.FiberId
 }
@@ -52,10 +52,10 @@ export declare namespace Deferred {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<in out E, in out A> {
+  export interface Variance<in out A, in out E> {
     readonly [DeferredTypeId]: {
-      readonly _E: Types.Invariant<E>
       readonly _A: Types.Invariant<A>
+      readonly _E: Types.Invariant<E>
     }
   }
 }

packages/effect/src/Effect.ts

@@ -2693,7 +2693,7 @@ export const forkWithErrorHandler: {
  * @since 2.0.0
  * @category supervision & fibers
  */
-export const fromFiber: <E, A>(fiber: Fiber.Fiber<A, E>) => Effect<A, E> = circular.fromFiber
+export const fromFiber: <A, E>(fiber: Fiber.Fiber<A, E>) => Effect<A, E> = circular.fromFiber
 
 /**
  * Creates an `Effect` value that represents the exit value of the specified
@@ -3319,7 +3319,7 @@ export const exit: <A, E, R>(self: Effect<A, E, R>) => Effect<Exit.Exit<A, E>, n
  * @category conversions
  */
 export const intoDeferred: {
-  <E, A>(deferred: Deferred.Deferred<A, E>): <R>(self: Effect<A, E, R>) => Effect<boolean, never, R>
+  <A, E>(deferred: Deferred.Deferred<A, E>): <R>(self: Effect<A, E, R>) => Effect<boolean, never, R>
   <A, E, R>(self: Effect<A, E, R>, deferred: Deferred.Deferred<A, E>): Effect<boolean, never, R>
 } = core.intoDeferred
 
@@ -4702,7 +4702,7 @@ export const makeSemaphore: (permits: number) => Effect<Semaphore> = circular.ma
  * @since 2.0.0
  * @category execution
  */
-export const runFork: <E, A>(
+export const runFork: <A, E>(
   effect: Effect<A, E>,
   options?: Runtime.RunForkOptions
 ) => Fiber.RuntimeFiber<A, E> = _runtime.unsafeForkEffect
@@ -4711,7 +4711,7 @@ export const runFork: <E, A>(
  * @since 2.0.0
  * @category execution
  */
-export const runCallback: <E, A>(
+export const runCallback: <A, E>(
   effect: Effect<A, E>,
   options?: Runtime.RunCallbackOptions<E, A> | undefined
 ) => Runtime.Cancel<E, A> = _runtime.unsafeRunEffect
@@ -4723,7 +4723,7 @@ export const runCallback: <E, A>(
  * @since 2.0.0
  * @category execution
  */
-export const runPromise: <E, A>(effect: Effect<A, E>) => Promise<A> = _runtime.unsafeRunPromiseEffect
+export const runPromise: <A, E>(effect: Effect<A, E>) => Promise<A> = _runtime.unsafeRunPromiseEffect
 
 /**
  * Runs an `Effect` workflow, returning a `Promise` which resolves with the
@@ -4732,20 +4732,20 @@ export const runPromise: <E, A>(effect: Effect<A, E>) => Promise<A> = _runtime.u
  * @since 2.0.0
  * @category execution
  */
-export const runPromiseExit: <E, A>(effect: Effect<A, E>) => Promise<Exit.Exit<A, E>> =
+export const runPromiseExit: <A, E>(effect: Effect<A, E>) => Promise<Exit.Exit<A, E>> =
   _runtime.unsafeRunPromiseExitEffect
 
 /**
  * @since 2.0.0
  * @category execution
  */
-export const runSync: <E, A>(effect: Effect<A, E>) => A = _runtime.unsafeRunSyncEffect
+export const runSync: <A, E>(effect: Effect<A, E>) => A = _runtime.unsafeRunSyncEffect
 
 /**
  * @since 2.0.0
  * @category execution
  */
-export const runSyncExit: <E, A>(effect: Effect<A, E>) => Exit.Exit<A, E> = _runtime.unsafeRunSyncExitEffect
+export const runSyncExit: <A, E>(effect: Effect<A, E>) => Exit.Exit<A, E> = _runtime.unsafeRunSyncExitEffect
 
 // -------------------------------------------------------------------------------------
 // zipping

packages/effect/src/FiberSet.ts

@@ -26,7 +26,9 @@ export type TypeId = typeof TypeId
  * @since 2.0.0
  * @categories models
  */
-export interface FiberSet<E, A> extends Pipeable, Inspectable.Inspectable, Iterable<Fiber.RuntimeFiber<A, E>> {
+export interface FiberSet<out A, out E = never>
+  extends Pipeable, Inspectable.Inspectable, Iterable<Fiber.RuntimeFiber<A, E>>
+{
   readonly [TypeId]: TypeId
   readonly backing: Set<Fiber.RuntimeFiber<A, E>>
 }
@@ -59,7 +61,7 @@ const Proto = {
   }
 }
 
-const unsafeMake = <E, A>(): FiberSet<E, A> => {
+const unsafeMake = <A, E>(): FiberSet<A, E> => {
   const self = Object.create(Proto)
   self.backing = new Set()
   return self
@@ -90,16 +92,16 @@ const unsafeMake = <E, A>(): FiberSet<E, A> => {
  * @since 2.0.0
  * @categories constructors
  */
-export const make = <E, A>(): Effect.Effect<FiberSet<E, A>, never, Scope.Scope> =>
-  Effect.acquireRelease(Effect.sync(() => unsafeMake<E, A>()), clear)
+export const make = <A, E = never>(): Effect.Effect<FiberSet<A, E>, never, Scope.Scope> =>
+  Effect.acquireRelease(Effect.sync(() => unsafeMake<A, E>()), clear)
 
 /**
  * Create an Effect run function that is backed by a FiberSet.
  *
  * @since 2.0.0
  * @categories constructors
  */
-export const makeRuntime = <A, E, R>(): Effect.Effect<
+export const makeRuntime = <A, E = never, R = never>(): Effect.Effect<
   <XE extends E, XA extends A>(
     effect: Effect.Effect<XA, XE, R>,
     options?: Runtime.RunForkOptions | undefined
@@ -108,7 +110,7 @@ export const makeRuntime = <A, E, R>(): Effect.Effect<
   Scope.Scope | R
 > =>
   Effect.flatMap(
-    make<E, A>(),
+    make<A, E>(),
     (self) => runtime(self)<R>()
   )
 
@@ -119,14 +121,14 @@ export const makeRuntime = <A, E, R>(): Effect.Effect<
  * @categories combinators
  */
 export const unsafeAdd: {
-  <E, A, XE extends E, XA extends A>(fiber: Fiber.RuntimeFiber<XA, XE>): (self: FiberSet<E, A>) => void
-  <E, A, XE extends E, XA extends A>(self: FiberSet<E, A>, fiber: Fiber.RuntimeFiber<XA, XE>): void
+  <A, E, XE extends E, XA extends A>(fiber: Fiber.RuntimeFiber<XA, XE>): (self: FiberSet<A, E>) => void
+  <A, E, XE extends E, XA extends A>(self: FiberSet<A, E>, fiber: Fiber.RuntimeFiber<XA, XE>): void
 } = dual<
-  <E, A, XE extends E, XA extends A>(
+  <A, E, XE extends E, XA extends A>(
     fiber: Fiber.RuntimeFiber<XA, XE>
-  ) => (self: FiberSet<E, A>) => void,
-  <E, A, XE extends E, XA extends A>(
-    self: FiberSet<E, A>,
+  ) => (self: FiberSet<A, E>) => void,
+  <A, E, XE extends E, XA extends A>(
+    self: FiberSet<A, E>,
     fiber: Fiber.RuntimeFiber<XA, XE>
   ) => void
 >(2, (self, fiber) => {
@@ -146,19 +148,19 @@ export const unsafeAdd: {
  * @categories combinators
  */
 export const add: {
-  <E, A, XE extends E, XA extends A>(
+  <A, E, XE extends E, XA extends A>(
     fiber: Fiber.RuntimeFiber<XA, XE>
-  ): (self: FiberSet<E, A>) => Effect.Effect<void>
-  <E, A, XE extends E, XA extends A>(
-    self: FiberSet<E, A>,
+  ): (self: FiberSet<A, E>) => Effect.Effect<void>
+  <A, E, XE extends E, XA extends A>(
+    self: FiberSet<A, E>,
     fiber: Fiber.RuntimeFiber<XA, XE>
   ): Effect.Effect<void>
 } = dual<
-  <E, A, XE extends E, XA extends A>(
+  <A, E, XE extends E, XA extends A>(
     fiber: Fiber.RuntimeFiber<XA, XE>
-  ) => (self: FiberSet<E, A>) => Effect.Effect<void>,
-  <E, A, XE extends E, XA extends A>(
-    self: FiberSet<E, A>,
+  ) => (self: FiberSet<A, E>) => Effect.Effect<void>,
+  <A, E, XE extends E, XA extends A>(
+    self: FiberSet<A, E>,
     fiber: Fiber.RuntimeFiber<XA, XE>
   ) => Effect.Effect<void>
 >(2, (self, fiber) => Effect.sync(() => unsafeAdd(self, fiber)))
@@ -167,7 +169,7 @@ export const add: {
  * @since 2.0.0
  * @categories combinators
  */
-export const clear = <E, A>(self: FiberSet<E, A>): Effect.Effect<void> =>
+export const clear = <A, E>(self: FiberSet<A, E>): Effect.Effect<void> =>
   Effect.zipRight(
     Effect.forEach(self.backing, (fiber) => Fiber.interrupt(fiber)),
     Effect.sync(() => {
@@ -183,11 +185,11 @@ export const clear = <E, A>(self: FiberSet<E, A>): Effect.Effect<void> =>
  * @categories combinators
  */
 export const run: {
-  <E, A>(self: FiberSet<E, A>): <R, XE extends E, XA extends A>(
+  <A, E>(self: FiberSet<A, E>): <R, XE extends E, XA extends A>(
     effect: Effect.Effect<XA, XE, R>
   ) => Effect.Effect<Fiber.RuntimeFiber<XA, XE>, never, R>
-  <E, A, R, XE extends E, XA extends A>(
-    self: FiberSet<E, A>,
+  <A, E, R, XE extends E, XA extends A>(
+    self: FiberSet<A, E>,
     effect: Effect.Effect<XA, XE, R>
   ): Effect.Effect<Fiber.RuntimeFiber<XA, XE>, never, R>
 } = function() {
@@ -232,16 +234,16 @@ export const run: {
  * @since 2.0.0
  * @categories combinators
  */
-export const runtime: <E, A>(
-  self: FiberSet<E, A>
-) => <R>() => Effect.Effect<
+export const runtime: <A, E = never>(
+  self: FiberSet<A, E>
+) => <R = never>() => Effect.Effect<
   <XE extends E, XA extends A>(
     effect: Effect.Effect<XA, XE, R>,
     options?: Runtime.RunForkOptions | undefined
   ) => Fiber.RuntimeFiber<XA, XE>,
   never,
   R
-> = <E, A>(self: FiberSet<E, A>) => <R>() =>
+> = <A, E>(self: FiberSet<A, E>) => <R>() =>
   Effect.map(
     Effect.runtime<R>(),
     (runtime) => {
@@ -261,4 +263,4 @@ export const runtime: <E, A>(
  * @since 2.0.0
  * @categories combinators
  */
-export const size = <E, A>(self: FiberSet<E, A>): Effect.Effect<number> => Effect.sync(() => self.backing.size)
+export const size = <A, E>(self: FiberSet<A, E>): Effect.Effect<number> => Effect.sync(() => self.backing.size)

packages/effect/src/Runtime.ts

@@ -71,7 +71,7 @@ export interface RunForkOptions {
  */
 export const runFork: <R>(
   runtime: Runtime<R>
-) => <E, A>(self: Effect.Effect<A, E, R>, options?: RunForkOptions) => Fiber.RuntimeFiber<A, E> = internal.unsafeFork
+) => <A, E>(self: Effect.Effect<A, E, R>, options?: RunForkOptions) => Fiber.RuntimeFiber<A, E> = internal.unsafeFork
 
 /**
  * Executes the effect synchronously returning the exit.
@@ -82,7 +82,7 @@ export const runFork: <R>(
  * @since 2.0.0
  * @category execution
  */
-export const runSyncExit: <R>(runtime: Runtime<R>) => <E, A>(effect: Effect.Effect<A, E, R>) => Exit.Exit<A, E> =
+export const runSyncExit: <R>(runtime: Runtime<R>) => <A, E>(effect: Effect.Effect<A, E, R>) => Exit.Exit<A, E> =
   internal.unsafeRunSyncExit
 
 /**
@@ -94,7 +94,7 @@ export const runSyncExit: <R>(runtime: Runtime<R>) => <E, A>(effect: Effect.Effe
  * @since 2.0.0
  * @category execution
  */
-export const runSync: <R>(runtime: Runtime<R>) => <E, A>(effect: Effect.Effect<A, E, R>) => A = internal.unsafeRunSync
+export const runSync: <R>(runtime: Runtime<R>) => <A, E>(effect: Effect.Effect<A, E, R>) => A = internal.unsafeRunSync
 
 /**
  * @since 2.0.0
@@ -133,7 +133,7 @@ export const runCallback: <R>(
  * @since 2.0.0
  * @category execution
  */
-export const runPromise: <R>(runtime: Runtime<R>) => <E, A>(effect: Effect.Effect<A, E, R>) => Promise<A> =
+export const runPromise: <R>(runtime: Runtime<R>) => <A, E>(effect: Effect.Effect<A, E, R>) => Promise<A> =
   internal.unsafeRunPromise
 
 /**
@@ -148,7 +148,7 @@ export const runPromise: <R>(runtime: Runtime<R>) => <E, A>(effect: Effect.Effec
  */
 export const runPromiseExit: <R>(
   runtime: Runtime<R>
-) => <E, A>(effect: Effect.Effect<A, E, R>) => Promise<Exit.Exit<A, E>> = internal.unsafeRunPromiseExit
+) => <A, E>(effect: Effect.Effect<A, E, R>) => Promise<Exit.Exit<A, E>> = internal.unsafeRunPromiseExit
 
 /**
  * @since 2.0.0

packages/effect/src/STM.ts

@@ -446,7 +446,7 @@ export const commitEither: <A, E, R>(self: STM<A, E, R>) => Effect.Effect<A, E,
  * @since 2.0.0
  * @category constructors
  */
-export const cond: <E, A>(predicate: LazyArg<boolean>, error: LazyArg<E>, result: LazyArg<A>) => STM<A, E> = stm.cond
+export const cond: <A, E>(predicate: LazyArg<boolean>, error: LazyArg<E>, result: LazyArg<A>) => STM<A, E> = stm.cond
 
 /**
  * Retrieves the environment inside an stm.
@@ -482,8 +482,8 @@ export const contextWithSTM: <R0, R, E, A>(
  * @category context
  */
 export const mapInputContext: {
-  <R0, R>(f: (context: Context.Context<R0>) => Context.Context<R>): <E, A>(self: STM<A, E, R>) => STM<A, E, R0>
-  <E, A, R0, R>(self: STM<A, E, R>, f: (context: Context.Context<R0>) => Context.Context<R>): STM<A, E, R0>
+  <R0, R>(f: (context: Context.Context<R0>) => Context.Context<R>): <A, E>(self: STM<A, E, R>) => STM<A, E, R0>
+  <A, E, R0, R>(self: STM<A, E, R>, f: (context: Context.Context<R0>) => Context.Context<R>): STM<A, E, R0>
 } = core.mapInputContext
 
 /**
@@ -1481,8 +1481,8 @@ export const partition: {
  * @category context
  */
 export const provideContext: {
-  <R>(env: Context.Context<R>): <E, A>(self: STM<A, E, R>) => STM<A, E>
-  <E, A, R>(self: STM<A, E, R>, env: Context.Context<R>): STM<A, E>
+  <R>(env: Context.Context<R>): <A, E>(self: STM<A, E, R>) => STM<A, E>
+  <A, E, R>(self: STM<A, E, R>, env: Context.Context<R>): STM<A, E>
 } = stm.provideContext
 
 /**