effect 2.3.8 → 2.4.0

package/src/internal/stm/tArray.ts

@@ -39,18 +39,18 @@ export const collectFirst = dual<
 
 /** @internal */
 export const collectFirstSTM = dual<
-  <A, R, E, B>(
+  <A, B, E, R>(
     pf: (a: A) => Option.Option<STM.STM<B, E, R>>
   ) => (
     self: TArray.TArray<A>
   ) => STM.STM<Option.Option<B>, E, R>,
-  <A, R, E, B>(
+  <A, B, E, R>(
     self: TArray.TArray<A>,
     pf: (a: A) => Option.Option<STM.STM<B, E, R>>
   ) => STM.STM<Option.Option<B>, E, R>
 >(
   2,
-  <A, R, E, B>(self: TArray.TArray<A>, pf: (a: A) => Option.Option<STM.STM<B, E, R>>) =>
+  <A, B, E, R>(self: TArray.TArray<A>, pf: (a: A) => Option.Option<STM.STM<B, E, R>>) =>
     core.withSTMRuntime((runtime) => {
       let index = 0
       let result: Option.Option<STM.STM<B, E, R>> = Option.none()

package/src/internal/stm/tDeferred.ts

@@ -27,7 +27,7 @@ const tDeferredVariance = {
 /** @internal */
 class TDeferredImpl<in out A, in out E = never> implements TDeferred.TDeferred<A, E> {
   readonly [TDeferredTypeId] = tDeferredVariance
-  constructor(readonly ref: TRef.TRef<Option.Option<Either.Either<E, A>>>) {}
+  constructor(readonly ref: TRef.TRef<Option.Option<Either.Either<A, E>>>) {}
 }
 
 /** @internal */
@@ -41,8 +41,8 @@ export const _await = <A, E>(self: TDeferred.TDeferred<A, E>): STM.STM<A, E> =>
 
 /** @internal */
 export const done = dual<
-  <E, A>(either: Either.Either<E, A>) => (self: TDeferred.TDeferred<A, E>) => STM.STM<boolean>,
-  <A, E>(self: TDeferred.TDeferred<A, E>, either: Either.Either<E, A>) => STM.STM<boolean>
+  <A, E>(either: Either.Either<A, E>) => (self: TDeferred.TDeferred<A, E>) => STM.STM<boolean>,
+  <A, E>(self: TDeferred.TDeferred<A, E>, either: Either.Either<A, E>) => STM.STM<boolean>
 >(2, (self, either) =>
   core.flatMap(
     tRef.get(self.ref),
@@ -65,14 +65,14 @@ export const fail = dual<
 /** @internal */
 export const make = <A, E = never>(): STM.STM<TDeferred.TDeferred<A, E>> =>
   core.map(
-    tRef.make<Option.Option<Either.Either<E, A>>>(Option.none()),
+    tRef.make<Option.Option<Either.Either<A, E>>>(Option.none()),
     (ref) => new TDeferredImpl(ref)
   )
 
 /** @internal */
 export const poll = <A, E>(
   self: TDeferred.TDeferred<A, E>
-): STM.STM<Option.Option<Either.Either<E, A>>> => tRef.get(self.ref)
+): STM.STM<Option.Option<Either.Either<A, E>>> => tRef.get(self.ref)
 
 /** @internal */
 export const succeed = dual<

package/src/internal/stm/tMap.ts

@@ -114,14 +114,14 @@ export const find = dual<
 
 /** @internal */
 export const findSTM = dual<
-  <K, V, R, E, A>(
+  <K, V, A, E, R>(
     f: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>
   ) => (self: TMap.TMap<K, V>) => STM.STM<Option.Option<A>, E, R>,
-  <K, V, R, E, A>(
+  <K, V, A, E, R>(
     self: TMap.TMap<K, V>,
     f: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>
   ) => STM.STM<Option.Option<A>, E, R>
->(2, <K, V, R, E, A>(
+>(2, <K, V, A, E, R>(
   self: TMap.TMap<K, V>,
   f: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>
 ) =>
@@ -156,14 +156,14 @@ export const findAll = dual<
 
 /** @internal */
 export const findAllSTM = dual<
-  <K, V, R, E, A>(
+  <K, V, A, E, R>(
     pf: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>
   ) => (self: TMap.TMap<K, V>) => STM.STM<Array<A>, E, R>,
-  <K, V, R, E, A>(
+  <K, V, A, E, R>(
     self: TMap.TMap<K, V>,
     pf: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>
   ) => STM.STM<Array<A>, E, R>
->(2, <K, V, R, E, A>(
+>(2, <K, V, A, E, R>(
   self: TMap.TMap<K, V>,
   pf: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>
 ) =>
@@ -181,8 +181,8 @@ export const findAllSTM = dual<
 
 /** @internal */
 export const forEach = dual<
-  <K, V, R, E, _>(f: (key: K, value: V) => STM.STM<_, E, R>) => (self: TMap.TMap<K, V>) => STM.STM<void, E, R>,
-  <K, V, R, E, _>(self: TMap.TMap<K, V>, f: (key: K, value: V) => STM.STM<_, E, R>) => STM.STM<void, E, R>
+  <K, V, X, E, R>(f: (key: K, value: V) => STM.STM<X, E, R>) => (self: TMap.TMap<K, V>) => STM.STM<void, E, R>,
+  <K, V, X, E, R>(self: TMap.TMap<K, V>, f: (key: K, value: V) => STM.STM<X, E, R>) => STM.STM<void, E, R>
 >(2, (self, f) =>
   reduceSTM(
     self,
@@ -553,10 +553,10 @@ export const takeFirst = dual<
 
 /** @internal */
 export const takeFirstSTM = dual<
-  <K, V, R, E, A>(
+  <K, V, A, E, R>(
     pf: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>
   ) => (self: TMap.TMap<K, V>) => STM.STM<A, E, R>,
-  <K, V, R, E, A>(self: TMap.TMap<K, V>, pf: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>) => STM.STM<A, E, R>
+  <K, V, A, E, R>(self: TMap.TMap<K, V>, pf: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>) => STM.STM<A, E, R>
 >(2, (self, pf) =>
   pipe(
     findSTM(self, (key, value) => core.map(pf(key, value), (a) => [key, a] as const)),
@@ -618,14 +618,14 @@ export const takeSome = dual<
 
 /** @internal */
 export const takeSomeSTM = dual<
-  <K, V, R, E, A>(
+  <K, V, A, E, R>(
     pf: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>
   ) => (self: TMap.TMap<K, V>) => STM.STM<RA.NonEmptyArray<A>, E, R>,
-  <K, V, R, E, A>(
+  <K, V, A, E, R>(
     self: TMap.TMap<K, V>,
     pf: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>
   ) => STM.STM<RA.NonEmptyArray<A>, E, R>
->(2, <K, V, R, E, A>(
+>(2, <K, V, A, E, R>(
   self: TMap.TMap<K, V>,
   pf: (key: K, value: V) => STM.STM<A, Option.Option<E>, R>
 ) =>

package/src/internal/stm/tSet.ts

@@ -191,8 +191,8 @@ export const takeFirst = dual<
 
 /** @internal */
 export const takeFirstSTM = dual<
-  <A, R, E, B>(pf: (a: A) => STM.STM<B, Option.Option<E>, R>) => (self: TSet.TSet<A>) => STM.STM<B, E, R>,
-  <A, R, E, B>(self: TSet.TSet<A>, pf: (a: A) => STM.STM<B, Option.Option<E>, R>) => STM.STM<B, E, R>
+  <A, B, E, R>(pf: (a: A) => STM.STM<B, Option.Option<E>, R>) => (self: TSet.TSet<A>) => STM.STM<B, E, R>,
+  <A, B, E, R>(self: TSet.TSet<A>, pf: (a: A) => STM.STM<B, Option.Option<E>, R>) => STM.STM<B, E, R>
 >(2, (self, pf) => tMap.takeFirstSTM(self.tMap, (key) => pf(key)))
 
 /** @internal */
@@ -203,10 +203,10 @@ export const takeSome = dual<
 
 /** @internal */
 export const takeSomeSTM = dual<
-  <A, R, E, B>(
+  <A, B, E, R>(
     pf: (a: A) => STM.STM<B, Option.Option<E>, R>
   ) => (self: TSet.TSet<A>) => STM.STM<RA.NonEmptyArray<B>, E, R>,
-  <A, R, E, B>(
+  <A, B, E, R>(
     self: TSet.TSet<A>,
     pf: (a: A) => STM.STM<B, Option.Option<E>, R>
   ) => STM.STM<RA.NonEmptyArray<B>, E, R>