effect 2.3.8 → 2.4.0

package/src/internal/sink.ts

@@ -308,8 +308,7 @@ export const collectAllWhileWith: {
   }
 )
 
-/** @internal */
-const collectAllWhileWithLoop = <R, E, In, L extends In, Z, S>(
+const collectAllWhileWithLoop = <Z, In, L extends In, E, R, S>(
   self: Sink.Sink<Z, In, L, E, R>,
   leftoversRef: Ref.Ref<Chunk.Chunk<In>>,
   upstreamDoneRef: Ref.Ref<boolean>,
@@ -474,12 +473,12 @@ export const dimap = dual<
 
 /** @internal */
 export const dimapEffect = dual<
-  <In0, R2, E2, In, A, R3, E3, A2>(
+  <In0, In, E2, R2, A, A2, E3, R3>(
     options: {
       readonly onInput: (input: In0) => Effect.Effect<In, E2, R2>
       readonly onDone: (a: A) => Effect.Effect<A2, E3, R3>
     }
-  ) => <R, E, L>(self: Sink.Sink<A, In, L, E, R>) => Sink.Sink<A2, In0, L, E2 | E3 | E, R2 | R3 | R>,
+  ) => <L, E, R>(self: Sink.Sink<A, In, L, E, R>) => Sink.Sink<A2, In0, L, E2 | E3 | E, R2 | R3 | R>,
   <A, In, L, E, R, In0, E2, R2, A2, E3, R3>(
     self: Sink.Sink<A, In, L, E, R>,
     options: {
@@ -527,7 +526,7 @@ export const dimapChunksEffect = dual<
       readonly onInput: (chunk: Chunk.Chunk<In0>) => Effect.Effect<Chunk.Chunk<In>, E2, R2>
       readonly onDone: (a: A) => Effect.Effect<A2, E3, R3>
     }
-  ) => <R, E, L>(self: Sink.Sink<A, In, L, E, R>) => Sink.Sink<A2, In0, L, E2 | E3 | E, R2 | R3 | R>,
+  ) => <L, E, R>(self: Sink.Sink<A, In, L, E, R>) => Sink.Sink<A2, In0, L, E2 | E3 | E, R2 | R3 | R>,
   <A, In, L, E, R, In0, E2, R2, A2, E3, R3>(
     self: Sink.Sink<A, In, L, E, R>,
     options: {
@@ -655,12 +654,12 @@ const dropWhileEffectReader = <In, R, E>(
 
 /** @internal */
 export const ensuring = dual<
-  <_, R2>(
-    finalizer: Effect.Effect<_, never, R2>
+  <X, R2>(
+    finalizer: Effect.Effect<X, never, R2>
   ) => <A, In, L, E, R>(self: Sink.Sink<A, In, L, E, R>) => Sink.Sink<A, In, L, E, R2 | R>,
-  <A, In, L, E, R, _, R2>(
+  <A, In, L, E, R, X, R2>(
     self: Sink.Sink<A, In, L, E, R>,
-    finalizer: Effect.Effect<_, never, R2>
+    finalizer: Effect.Effect<X, never, R2>
   ) => Sink.Sink<A, In, L, E, R2 | R>
 >(
   2,
@@ -669,12 +668,12 @@ export const ensuring = dual<
 
 /** @internal */
 export const ensuringWith = dual<
-  <A, E, _, R2>(
-    finalizer: (exit: Exit.Exit<A, E>) => Effect.Effect<_, never, R2>
+  <A, E, X, R2>(
+    finalizer: (exit: Exit.Exit<A, E>) => Effect.Effect<X, never, R2>
   ) => <In, L, R>(self: Sink.Sink<A, In, L, E, R>) => Sink.Sink<A, In, L, E, R2 | R>,
-  <A, In, L, E, R, _, R2>(
+  <A, In, L, E, R, X, R2>(
     self: Sink.Sink<A, In, L, E, R>,
-    finalizer: (exit: Exit.Exit<A, E>) => Effect.Effect<_, never, R2>
+    finalizer: (exit: Exit.Exit<A, E>) => Effect.Effect<X, never, R2>
   ) => Sink.Sink<A, In, L, E, R2 | R>
 >(
   2,
@@ -1245,8 +1244,7 @@ export const foldWeightedEffect = <S, In, E, R, E2, R2>(
     decompose: (input) => Effect.succeed(Chunk.of(input))
   })
 
-/** @internal */
-const foldWeightedDecomposeEffectLoop = <S, In, R, E, R2, E2, R3, E3>(
+const foldWeightedDecomposeEffectLoop = <S, In, E, R, E2, R2, E3, R3>(
   s: S,
   max: number,
   costFn: (s: S, input: In) => Effect.Effect<number, E, R>,
@@ -1274,7 +1272,7 @@ const foldWeightedDecomposeEffectLoop = <S, In, R, E, R2, E2, R3, E3>(
   })
 
 /** @internal */
-const foldWeightedDecomposeEffectFold = <S, In, R, E, R2, E2, R3, E3>(
+const foldWeightedDecomposeEffectFold = <S, In, E, R, E2, R2, E3, R3>(
   s: S,
   max: number,
   costFn: (s: S, input: In) => Effect.Effect<number, E, R>,
@@ -1343,7 +1341,7 @@ export const flatMap = dual<
 )
 
 /** @internal */
-export const forEach = <In, _, E, R>(f: (input: In) => Effect.Effect<_, E, R>): Sink.Sink<void, In, never, E, R> => {
+export const forEach = <In, X, E, R>(f: (input: In) => Effect.Effect<X, E, R>): Sink.Sink<void, In, never, E, R> => {
   const process: Channel.Channel<never, Chunk.Chunk<In>, E, E, void, unknown, R> = core.readWithCause({
     onInput: (input: Chunk.Chunk<In>) =>
       pipe(core.fromEffect(Effect.forEach(input, (v) => f(v), { discard: true })), core.flatMap(() => process)),
@@ -1354,8 +1352,8 @@ export const forEach = <In, _, E, R>(f: (input: In) => Effect.Effect<_, E, R>):
 }
 
 /** @internal */
-export const forEachChunk = <In, _, E, R>(
-  f: (input: Chunk.Chunk<In>) => Effect.Effect<_, E, R>
+export const forEachChunk = <In, X, E, R>(
+  f: (input: Chunk.Chunk<In>) => Effect.Effect<X, E, R>
 ): Sink.Sink<void, In, never, E, R> => {
   const process: Channel.Channel<never, Chunk.Chunk<In>, E, E, void, unknown, R> = core.readWithCause({
     onInput: (input: Chunk.Chunk<In>) => pipe(core.fromEffect(f(input)), core.flatMap(() => process)),
@@ -1433,19 +1431,19 @@ export const fromPubSub = <In>(
 ): Sink.Sink<void, In> => fromQueue(pubsub, options)
 
 /** @internal */
-export const fromPush = <In, E, A, L, R>(
+export const fromPush = <In, L0, R0, L, R>(
   push: Effect.Effect<
-    (_: Option.Option<Chunk.Chunk<In>>) => Effect.Effect<void, readonly [Either.Either<E, A>, Chunk.Chunk<L>], R>,
+    (_: Option.Option<Chunk.Chunk<In>>) => Effect.Effect<void, readonly [Either.Either<R0, L0>, Chunk.Chunk<L>], R>,
     never,
     R
   >
-): Sink.Sink<A, In, L, E, Exclude<R, Scope.Scope>> =>
+): Sink.Sink<R0, In, L, L0, Exclude<R, Scope.Scope>> =>
   new SinkImpl(channel.unwrapScoped(pipe(push, Effect.map(fromPushPull))))
 
-const fromPushPull = <R, E, In, L, Z>(
+const fromPushPull = <In, Z, E, L, R>(
   push: (
     option: Option.Option<Chunk.Chunk<In>>
-  ) => Effect.Effect<void, readonly [Either.Either<E, Z>, Chunk.Chunk<L>], R>
+  ) => Effect.Effect<void, readonly [Either.Either<Z, E>, Chunk.Chunk<L>], R>
 ): Channel.Channel<Chunk.Chunk<L>, Chunk.Chunk<In>, E, never, Z, unknown, R> =>
   core.readWith({
     onInput: (input: Chunk.Chunk<In>) =>
@@ -1590,7 +1588,7 @@ export const provideContext = dual<
 export const race = dual<
   <R1, E1, In1, L1, A1>(
     that: Sink.Sink<A1, In1, L1, E1, R1>
-  ) => <R, E, In, L, A>(self: Sink.Sink<A, In, L, E, R>) => Sink.Sink<A1 | A, In & In1, L1 | L, E1 | E, R1 | R>,
+  ) => <A, In, L, E, R>(self: Sink.Sink<A, In, L, E, R>) => Sink.Sink<A1 | A, In & In1, L1 | L, E1 | E, R1 | R>,
   <A, In, L, E, R, A1, In1, L1, E1, R1>(
     self: Sink.Sink<A, In, L, E, R>,
     that: Sink.Sink<A1, In1, L1, E1, R1>
@@ -1609,14 +1607,14 @@ export const raceBoth = dual<
     }
   ) => <A, In, L, E, R>(
     self: Sink.Sink<A, In, L, E, R>
-  ) => Sink.Sink<Either.Either<A, A1>, In & In1, L1 | L, E1 | E, R1 | R>,
+  ) => Sink.Sink<Either.Either<A1, A>, In & In1, L1 | L, E1 | E, R1 | R>,
   <A, In, L, E, R, A1, In1, L1, E1, R1>(
     self: Sink.Sink<A, In, L, E, R>,
     that: Sink.Sink<A1, In1, L1, E1, R1>,
     options?: {
       readonly capacity?: number | undefined
     }
-  ) => Sink.Sink<Either.Either<A, A1>, In & In1, L1 | L, E1 | E, R1 | R>
+  ) => Sink.Sink<Either.Either<A1, A>, In & In1, L1 | L, E1 | E, R1 | R>
 >(
   (args) => isSink(args[1]),
   (self, that, options) =>
@@ -1660,7 +1658,7 @@ export const raceWith = dual<
   ): Sink.Sink<A3 | A4, In & In2, L2 | L, E2 | E, R2 | R> => {
     const scoped = Effect.gen(function*($) {
       const pubsub = yield* $(
-        PubSub.bounded<Either.Either<Exit.Exit<unknown>, Chunk.Chunk<In & In2>>>(options?.capacity ?? 16)
+        PubSub.bounded<Either.Either<Chunk.Chunk<In & In2>, Exit.Exit<unknown>>>(options?.capacity ?? 16)
       )
       const channel1 = yield* $(channel.fromPubSubScoped(pubsub))
       const channel2 = yield* $(channel.fromPubSubScoped(pubsub))
@@ -1907,7 +1905,7 @@ export const take = <In>(n: number): Sink.Sink<Chunk.Chunk<In>, In, In> =>
   )
 
 /** @internal */
-export const toChannel = <R, E, In, L, A>(
+export const toChannel = <A, In, L, E, R>(
   self: Sink.Sink<A, In, L, E, R>
 ): Channel.Channel<Chunk.Chunk<L>, Chunk.Chunk<In>, E, never, A, unknown, R> =>
   Effect.isEffect(self) ?

package/src/internal/stm/core.ts

@@ -414,7 +414,7 @@ export const contextWith = <R0, R>(f: (environment: Context.Context<R0>) => R):
   map(context<R0>(), f)
 
 /** @internal */
-export const contextWithSTM = <R0, R, E, A>(
+export const contextWithSTM = <R0, A, E, R>(
   f: (environment: Context.Context<R0>) => STM.STM<A, E, R>
 ): STM.STM<A, E, R0 | R> => flatMap(context<R0>(), f)
 
@@ -579,12 +579,12 @@ export class STMDriver<in out R, out E, out A> {
 
 /** @internal */
 export const catchAll = dual<
-  <E, R1, E1, B>(
+  <E, B, E1, R1>(
     f: (e: E) => STM.STM<B, E1, R1>
-  ) => <R, A>(
+  ) => <A, R>(
     self: STM.STM<A, E, R>
   ) => STM.STM<B | A, E1, R1 | R>,
-  <R, A, E, R1, E1, B>(
+  <A, E, R, B, E1, R1>(
     self: STM.STM<A, E, R>,
     f: (e: E) => STM.STM<B, E1, R1>
   ) => STM.STM<B | A, E1, R1 | R>
@@ -634,7 +634,7 @@ export const effect = <R, A>(
 /** @internal */
 export const ensuring = dual<
   <R1, B>(finalizer: STM.STM<B, never, R1>) => <A, E, R>(self: STM.STM<A, E, R>) => STM.STM<A, E, R1 | R>,
-  <R, E, A, R1, B>(self: STM.STM<A, E, R>, finalizer: STM.STM<B, never, R1>) => STM.STM<A, E, R1 | R>
+  <A, E, R, R1, B>(self: STM.STM<A, E, R>, finalizer: STM.STM<B, never, R1>) => STM.STM<A, E, R1 | R>
 >(2, (self, finalizer) =>
   matchSTM(self, {
     onFailure: (e) => zipRight(finalizer, fail(e)),
@@ -653,8 +653,8 @@ export const failSync = <E>(evaluate: LazyArg<E>): STM.STM<never, E> => {
 
 /** @internal */
 export const flatMap = dual<
-  <A, R1, E1, A2>(f: (a: A) => STM.STM<A2, E1, R1>) => <R, E>(self: STM.STM<A, E, R>) => STM.STM<A2, E1 | E, R1 | R>,
-  <R, E, A, R1, E1, A2>(self: STM.STM<A, E, R>, f: (a: A) => STM.STM<A2, E1, R1>) => STM.STM<A2, E1 | E, R1 | R>
+  <A, A2, E1, R1>(f: (a: A) => STM.STM<A2, E1, R1>) => <E, R>(self: STM.STM<A, E, R>) => STM.STM<A2, E1 | E, R1 | R>,
+  <A, E, R, A2, E1, R1>(self: STM.STM<A, E, R>, f: (a: A) => STM.STM<A2, E1, R1>) => STM.STM<A2, E1 | E, R1 | R>
 >(2, (self, f) => {
   const stm = new STMPrimitive(OpCodes.OP_ON_SUCCESS)
   stm.i1 = self
@@ -664,20 +664,20 @@ export const flatMap = dual<
 
 /** @internal */
 export const matchSTM = dual<
-  <E, R1, E1, A1, A, R2, E2, A2>(
+  <E, A1, E1, R1, A, A2, E2, R2>(
     options: {
       readonly onFailure: (e: E) => STM.STM<A1, E1, R1>
       readonly onSuccess: (a: A) => STM.STM<A2, E2, R2>
     }
   ) => <R>(self: STM.STM<A, E, R>) => STM.STM<A1 | A2, E1 | E2, R1 | R2 | R>,
-  <R, E, R1, E1, A1, A, R2, E2, A2>(
+  <A, E, R, A1, E1, R1, A2, E2, R2>(
     self: STM.STM<A, E, R>,
     options: {
       readonly onFailure: (e: E) => STM.STM<A1, E1, R1>
       readonly onSuccess: (a: A) => STM.STM<A2, E2, R2>
     }
   ) => STM.STM<A1 | A2, E1 | E2, R1 | R2 | R>
->(2, <R, E, R1, E1, A1, A, R2, E2, A2>(
+>(2, <A, E, R, A1, E1, R1, A2, E2, R2>(
   self: STM.STM<A, E, R>,
   { onFailure, onSuccess }: {
     readonly onFailure: (e: E) => STM.STM<A1, E1, R1>
@@ -725,18 +725,18 @@ export const interruptAs = (fiberId: FiberId.FiberId): STM.STM<never> => {
 
 /** @internal */
 export const map = dual<
-  <A, B>(f: (a: A) => B) => <R, E>(self: STM.STM<A, E, R>) => STM.STM<B, E, R>,
-  <R, E, A, B>(self: STM.STM<A, E, R>, f: (a: A) => B) => STM.STM<B, E, R>
+  <A, B>(f: (a: A) => B) => <E, R>(self: STM.STM<A, E, R>) => STM.STM<B, E, R>,
+  <A, E, R, B>(self: STM.STM<A, E, R>, f: (a: A) => B) => STM.STM<B, E, R>
 >(2, (self, f) => pipe(self, flatMap((a) => sync(() => f(a)))))
 
 /** @internal */
 export const orTry = dual<
-  <R1, E1, A1>(
+  <A1, E1, R1>(
     that: LazyArg<STM.STM<A1, E1, R1>>
   ) => <A, E, R>(
     self: STM.STM<A, E, R>
   ) => STM.STM<A1 | A, E1 | E, R1 | R>,
-  <R, E, A, R1, E1, A1>(
+  <A, E, R, A1, E1, R1>(
     self: STM.STM<A, E, R>,
     that: LazyArg<STM.STM<A1, E1, R1>>
   ) => STM.STM<A1 | A, E1 | E, R1 | R>
@@ -766,12 +766,12 @@ export const sync = <A>(evaluate: () => A): STM.STM<A> => {
 
 /** @internal */
 export const zip = dual<
-  <R1, E1, A1>(
+  <A1, E1, R1>(
     that: STM.STM<A1, E1, R1>
   ) => <A, E, R>(
     self: STM.STM<A, E, R>
   ) => STM.STM<[A, A1], E1 | E, R1 | R>,
-  <R, E, A, R1, E1, A1>(
+  <A, E, R, A1, E1, R1>(
     self: STM.STM<A, E, R>,
     that: STM.STM<A1, E1, R1>
   ) => STM.STM<[A, A1], E1 | E, R1 | R>
@@ -779,25 +779,25 @@ export const zip = dual<
 
 /** @internal */
 export const zipLeft = dual<
-  <R1, E1, A1>(that: STM.STM<A1, E1, R1>) => <A, E, R>(self: STM.STM<A, E, R>) => STM.STM<A, E1 | E, R1 | R>,
-  <R, E, A, R1, E1, A1>(self: STM.STM<A, E, R>, that: STM.STM<A1, E1, R1>) => STM.STM<A, E1 | E, R1 | R>
+  <A1, E1, R1>(that: STM.STM<A1, E1, R1>) => <A, E, R>(self: STM.STM<A, E, R>) => STM.STM<A, E1 | E, R1 | R>,
+  <A, E, R, A1, E1, R1>(self: STM.STM<A, E, R>, that: STM.STM<A1, E1, R1>) => STM.STM<A, E1 | E, R1 | R>
 >(2, (self, that) => pipe(self, flatMap((a) => pipe(that, map(() => a)))))
 
 /** @internal */
 export const zipRight = dual<
-  <R1, E1, A1>(that: STM.STM<A1, E1, R1>) => <A, E, R>(self: STM.STM<A, E, R>) => STM.STM<A1, E1 | E, R1 | R>,
-  <R, E, A, R1, E1, A1>(self: STM.STM<A, E, R>, that: STM.STM<A1, E1, R1>) => STM.STM<A1, E1 | E, R1 | R>
+  <A1, E1, R1>(that: STM.STM<A1, E1, R1>) => <A, E, R>(self: STM.STM<A, E, R>) => STM.STM<A1, E1 | E, R1 | R>,
+  <A, E, R, A1, E1, R1>(self: STM.STM<A, E, R>, that: STM.STM<A1, E1, R1>) => STM.STM<A1, E1 | E, R1 | R>
 >(2, (self, that) => pipe(self, flatMap(() => that)))
 
 /** @internal */
 export const zipWith = dual<
-  <R1, E1, A1, A, A2>(
+  <A1, E1, R1, A, A2>(
     that: STM.STM<A1, E1, R1>,
     f: (a: A, b: A1) => A2
-  ) => <R, E>(
+  ) => <E, R>(
     self: STM.STM<A, E, R>
   ) => STM.STM<A2, E1 | E, R1 | R>,
-  <R, E, R1, E1, A1, A, A2>(
+  <A, E, R, A1, E1, R1, A2>(
     self: STM.STM<A, E, R>,
     that: STM.STM<A1, E1, R1>,
     f: (a: A, b: A1) => A2