@typed/fx 1.22.2 → 1.23.0

package/src/internal/effect-loop-operator.ts

@@ -12,12 +12,12 @@ export type EffectLoopOperator<B = any, A = any, R = any, E = any, C = any> =
 export interface LoopEffectOperator<B, A, R, E, C> {
   readonly _tag: "LoopEffect"
   readonly seed: B
-  readonly f: (acc: B, a: A) => Effect.Effect<R, E, readonly [C, B]>
+  readonly f: (acc: B, a: A) => Effect.Effect<readonly [C, B], E, R>
 }
 
 export function LoopEffectOperator<const B, A, R, E, C>(
   seed: B,
-  f: (acc: B, a: A) => Effect.Effect<R, E, readonly [C, B]>
+  f: (acc: B, a: A) => Effect.Effect<readonly [C, B], E, R>
 ): LoopEffectOperator<B, A, R, E, C> {
   return { _tag: "LoopEffect", seed, f }
 }
@@ -25,12 +25,12 @@ export function LoopEffectOperator<const B, A, R, E, C>(
 export interface FilterMapLoopEffectOperator<B, A, R, E, C> {
   readonly _tag: "FilterMapLoopEffect"
   readonly seed: B
-  readonly f: (acc: B, a: A) => Effect.Effect<R, E, readonly [Option.Option<C>, B]>
+  readonly f: (acc: B, a: A) => Effect.Effect<readonly [Option.Option<C>, B], E, R>
 }
 
 export function FilterMapLoopEffectOperator<const B, A, R, E, C>(
   seed: B,
-  f: (acc: B, a: A) => Effect.Effect<R, E, readonly [Option.Option<C>, B]>
+  f: (acc: B, a: A) => Effect.Effect<readonly [Option.Option<C>, B], E, R>
 ): FilterMapLoopEffectOperator<B, A, R, E, C> {
   return { _tag: "FilterMapLoopEffect", seed, f }
 }

package/src/internal/effect-operator.ts

@@ -15,41 +15,41 @@ export type EffectOperator =
 
 export interface MapEffect<A, R2, E2, B> {
   readonly _tag: "MapEffect"
-  readonly f: (a: A) => Effect.Effect<R2, E2, B>
+  readonly f: (a: A) => Effect.Effect<B, E2, R2>
 }
 
-export const MapEffect = <A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>): MapEffect<A, R2, E2, B> => ({
+export const MapEffect = <A, R2, E2, B>(f: (a: A) => Effect.Effect<B, E2, R2>): MapEffect<A, R2, E2, B> => ({
   _tag: "MapEffect",
   f
 })
 
 export interface TapEffect<A, R2, E2, B> {
   readonly _tag: "TapEffect"
-  readonly f: (a: A) => Effect.Effect<R2, E2, B>
+  readonly f: (a: A) => Effect.Effect<B, E2, R2>
 }
 
-export const TapEffect = <A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>): TapEffect<A, R2, E2, B> => ({
+export const TapEffect = <A, R2, E2, B>(f: (a: A) => Effect.Effect<B, E2, R2>): TapEffect<A, R2, E2, B> => ({
   _tag: "TapEffect",
   f
 })
 
 export interface FilterEffect<A, R2, E2> {
   readonly _tag: "FilterEffect"
-  readonly f: (a: A) => Effect.Effect<R2, E2, boolean>
+  readonly f: (a: A) => Effect.Effect<boolean, E2, R2>
 }
 
-export const FilterEffect = <A, R2, E2>(f: (a: A) => Effect.Effect<R2, E2, boolean>): FilterEffect<A, R2, E2> => ({
+export const FilterEffect = <A, R2, E2>(f: (a: A) => Effect.Effect<boolean, E2, R2>): FilterEffect<A, R2, E2> => ({
   _tag: "FilterEffect",
   f
 })
 
 export interface FilterMapEffect<A, R2, E2, B> {
   readonly _tag: "FilterMapEffect"
-  readonly f: (a: A) => Effect.Effect<R2, E2, Option.Option<B>>
+  readonly f: (a: A) => Effect.Effect<Option.Option<B>, E2, R2>
 }
 
 export const FilterMapEffect = <A, R2, E2, B>(
-  f: (a: A) => Effect.Effect<R2, E2, Option.Option<B>>
+  f: (a: A) => Effect.Effect<Option.Option<B>, E2, R2>
 ): FilterMapEffect<A, R2, E2, B> => ({ _tag: "FilterMapEffect", f })
 
 type EffectOperatorFusionMap = {
@@ -255,8 +255,8 @@ export function compileCauseEffectOperatorSink<R>(
 
 export function compileEffectLoop<B, A, R2, E2, C>(
   operator: EffectOperator,
-  loop: (b: B, a: A) => Effect.Effect<R2, E2, readonly [C, B]>
-): (b: B, i: any) => Effect.Effect<R2, E2, Option.Option<readonly [C, B]>> {
+  loop: (b: B, a: A) => Effect.Effect<readonly [C, B], E2, R2>
+): (b: B, i: any) => Effect.Effect<Option.Option<readonly [C, B]>, E2, R2> {
   return matchEffectOperator(operator, {
     MapEffect: (op) => (b, i) => Effect.map(Effect.flatMap(op.f(i), (a) => loop(b, a)), Option.some),
     TapEffect: (op) => (b, i) => Effect.map(Effect.flatMap(op.f(i), () => loop(b, i)), Option.some),
@@ -275,8 +275,8 @@ export function compileEffectLoop<B, A, R2, E2, C>(
 
 export function compileEffectReducer<B, A, R2, E2>(
   operator: EffectOperator,
-  loop: (b: B, a: A) => Effect.Effect<R2, E2, B>
-): (b: B, i: any) => Effect.Effect<R2, E2, Option.Option<B>> {
+  loop: (b: B, a: A) => Effect.Effect<B, E2, R2>
+): (b: B, i: any) => Effect.Effect<Option.Option<B>, E2, R2> {
   return matchEffectOperator(operator, {
     MapEffect: (op) => (b, i) => Effect.map(Effect.flatMap(op.f(i), (a) => loop(b, a)), Option.some),
     TapEffect: (op) => (b, i) => Effect.map(Effect.flatMap(op.f(i), () => loop(b, i)), Option.some),
@@ -298,7 +298,7 @@ export function runSyncReduce<A, B, R2, E2>(
   op: EffectOperator,
   seed: B,
   f: (acc: B, a: any) => B
-): Effect.Effect<R2, E2, B> {
+): Effect.Effect<B, E2, R2> {
   return matchEffectOperator(op, {
     MapEffect: (op) => SyncProducer.runReduceEffect(producer, seed, (acc, a) => Effect.map(op.f(a), (b) => f(acc, b))),
     TapEffect: (op) => SyncProducer.runReduceEffect(producer, seed, (acc, a) => Effect.map(op.f(a), () => f(acc, a))),

package/src/internal/effect-producer.ts

@@ -10,21 +10,21 @@ export type EffectProducer<R = any, E = any, A = any> =
 
 export interface FromEffect<R, E, A> {
   readonly _tag: "FromEffect"
-  readonly source: Effect.Effect<R, E, A>
+  readonly source: Effect.Effect<A, E, R>
 }
 
-export function FromEffect<R, E, A>(source: Effect.Effect<R, E, A>): FromEffect<R, E, A> {
+export function FromEffect<R, E, A>(source: Effect.Effect<A, E, R>): FromEffect<R, E, A> {
   return { _tag: "FromEffect", source }
 }
 
 export interface FromScheduled<R, E, I, O> {
   readonly _tag: "FromScheduled"
-  readonly input: Effect.Effect<R, E, I>
+  readonly input: Effect.Effect<I, E, R>
   readonly schedule: Schedule.Schedule<R, I, O>
 }
 
 export function FromScheduled<R, E, R2, I, O>(
-  input: Effect.Effect<R, E, I>,
+  input: Effect.Effect<I, E, R>,
   schedule: Schedule.Schedule<R2, I, O>
 ): FromScheduled<R | R2, E, I, O> {
   return { _tag: "FromScheduled", schedule, input }
@@ -32,12 +32,12 @@ export function FromScheduled<R, E, R2, I, O>(
 
 export interface Scheduled<R, E, A, O> {
   readonly _tag: "Scheduled"
-  readonly input: Effect.Effect<R, E, A>
+  readonly input: Effect.Effect<A, E, R>
   readonly schedule: Schedule.Schedule<R, unknown, O>
 }
 
 export function Scheduled<R, E, A, R2, O>(
-  input: Effect.Effect<R, E, A>,
+  input: Effect.Effect<A, E, R>,
   schedule: Schedule.Schedule<R2, unknown, O>
 ): Scheduled<R | R2, E, A, O> {
   return { _tag: "Scheduled", schedule, input }
@@ -46,7 +46,7 @@ export function Scheduled<R, E, A, R2, O>(
 export function runSink<R, E, A, R2>(
   producer: EffectProducer<R, E, A>,
   sink: Sink.Sink<R2, E, A>
-): Effect.Effect<R | R2, never, unknown> {
+): Effect.Effect<unknown, never, R | R2> {
   switch (producer._tag) {
     case "FromEffect":
       return Effect.matchCauseEffect(producer.source, sink)
@@ -60,7 +60,7 @@ export function runSink<R, E, A, R2>(
 function runFromScheduled<R, E, I, O, R2>(
   scheduled: FromScheduled<R, E, I, O>,
   sink: Sink.Sink<R2, E, O>
-): Effect.Effect<R | R2, never, unknown> {
+): Effect.Effect<unknown, never, R | R2> {
   return Effect.catchAllCause(
     Effect.flatMap(
       scheduled.input,
@@ -73,7 +73,7 @@ function runFromScheduled<R, E, I, O, R2>(
 function runSchedule<R, E, A, O, R2>(
   scheduled: Scheduled<R, E, A, O>,
   sink: Sink.Sink<R2, E, A>
-): Effect.Effect<R | R2, never, unknown> {
+): Effect.Effect<unknown, never, R | R2> {
   return Effect.catchAllCause(
     Effect.schedule(Effect.matchCauseEffect(scheduled.input, sink), scheduled.schedule),
     sink.onFailure
@@ -82,8 +82,8 @@ function runSchedule<R, E, A, O, R2>(
 
 export function runEffect<R, E, A, R2, E2, B>(
   producer: EffectProducer<R, E, A>,
-  f: (a: A) => Effect.Effect<R2, E2, B>
-): Effect.Effect<R | R2, E | E2, unknown> {
+  f: (a: A) => Effect.Effect<B, E2, R2>
+): Effect.Effect<unknown, E | E2, R | R2> {
   switch (producer._tag) {
     case "FromEffect":
       return Effect.flatMap(producer.source, f)
@@ -91,7 +91,7 @@ export function runEffect<R, E, A, R2, E2, B>(
       return Effect.flatMap(
         producer.input,
         (i) =>
-          Effect.asyncEffect<never, E | E2, unknown, R | R2, never, unknown>((resume) => {
+          Effect.asyncEffect<unknown, E | E2, never, unknown, never, R | R2>((resume) => {
             const onFailure = (cause: Cause.Cause<E | E2>) => Effect.succeed(resume(Effect.failCause(cause)))
 
             return Effect.matchCauseEffect(
@@ -115,8 +115,8 @@ export function runEffect<R, E, A, R2, E2, B>(
 export function runReduceEffect<R, E, A, R2, E2, B>(
   producer: EffectProducer<R, E, A>,
   initial: B,
-  f: (b: B, a: A) => Effect.Effect<R2, E2, B>
-): Effect.Effect<R | R2, E | E2, B> {
+  f: (b: B, a: A) => Effect.Effect<B, E2, R2>
+): Effect.Effect<B, E | E2, R | R2> {
   return Effect.suspend(() => {
     let acc = initial
 

package/src/internal/helpers.ts

@@ -21,7 +21,7 @@ export function withBuffers<R, E, A>(size: number, sink: Sink.Sink<R, E, A>) {
   const finished = new Set<number>()
   let currentIndex = 0
 
-  const drainBuffer = (index: number): Effect.Effect<R, never, void> => {
+  const drainBuffer = (index: number): Effect.Effect<void, never, R> => {
     const effect = Effect.forEach(buffers[index], sink.onSuccess)
     buffers[index] = []
 
@@ -63,13 +63,13 @@ export function withBuffers<R, E, A>(size: number, sink: Sink.Sink<R, E, A>) {
 }
 
 export const withScope = <R, E, A>(
-  f: (scope: Scope.CloseableScope) => Effect.Effect<R, E, A>,
+  f: (scope: Scope.CloseableScope) => Effect.Effect<A, E, R>,
   executionStrategy: ExecutionStrategy.ExecutionStrategy
-): Effect.Effect<R | Scope.Scope, E, A> =>
+): Effect.Effect<A, E, R | Scope.Scope> =>
   Effect.acquireUseRelease(Effect.scopeWith((scope) => Scope.fork(scope, executionStrategy)), f, Scope.close)
 
 export const getExitEquivalence = <E, A>(A: Equivalence.Equivalence<A>) =>
-  Equivalence.make<Exit.Exit<E, A>>((a, b) => {
+  Equivalence.make<Exit.Exit<A, E>>((a, b) => {
     if (a._tag === "Failure") {
       return b._tag === "Failure" && Equal.equals(a.cause, b.cause)
     } else {
@@ -78,15 +78,15 @@ export const getExitEquivalence = <E, A>(A: Equivalence.Equivalence<A>) =>
   })
 
 export function withScopedFork<R, E, A>(
-  f: (fork: ScopedFork, scope: Scope.CloseableScope) => Effect.Effect<R, E, A>,
+  f: (fork: ScopedFork, scope: Scope.CloseableScope) => Effect.Effect<A, E, R>,
   executionStrategy: ExecutionStrategy.ExecutionStrategy
-): Effect.Effect<R | Scope.Scope, E, A> {
+): Effect.Effect<A, E, R | Scope.Scope> {
   return withScope((scope) => f(makeForkInScope(scope), scope), executionStrategy)
 }
 
 export function makeForkInScope(scope: Scope.Scope) {
-  return <R, E, A>(effect: Effect.Effect<R, E, A>) =>
-    matchEffectPrimitive<R, E, A, Effect.Effect<R, never, Fiber.Fiber<E, A>>>(effect, {
+  return <R, E, A>(effect: Effect.Effect<A, E, R>) =>
+    matchEffectPrimitive<R, E, A, Effect.Effect<Fiber.Fiber<A, E>, never, R>>(effect, {
       Success: (a) => Effect.succeed(Fiber.succeed(a)),
       Failure: (cause) => Effect.succeed(Fiber.failCause(cause)),
       Sync: (f) =>
@@ -106,13 +106,13 @@ export function makeForkInScope(scope: Scope.Scope) {
 }
 
 export function withSwitchFork<R, E, A>(
-  f: (fork: FxFork, scope: Scope.CloseableScope) => Effect.Effect<R, E, A>,
+  f: (fork: FxFork, scope: Scope.CloseableScope) => Effect.Effect<A, E, R>,
   executionStrategy: ExecutionStrategy.ExecutionStrategy
 ) {
   return withScopedFork(
     (fork, scope) =>
       Effect.flatMap(
-        SynchronizedRef.make<Fiber.Fiber<never, unknown>>(Fiber.unit),
+        SynchronizedRef.make<Fiber.Fiber<unknown>>(Fiber.unit),
         (ref) => runSwitchFork(ref, fork, scope, f)
       ),
     executionStrategy
@@ -120,10 +120,10 @@ export function withSwitchFork<R, E, A>(
 }
 
 export function runSwitchFork<R, E, A>(
-  ref: SynchronizedRef.SynchronizedRef<Fiber.Fiber<never, unknown>>,
+  ref: SynchronizedRef.SynchronizedRef<Fiber.Fiber<unknown>>,
   fork: ScopedFork,
   scope: Scope.CloseableScope,
-  f: (fork: FxFork, scope: Scope.CloseableScope) => Effect.Effect<R, E, A>
+  f: (fork: FxFork, scope: Scope.CloseableScope) => Effect.Effect<A, E, R>
 ) {
   return Effect.zipRight(
     f(
@@ -143,12 +143,12 @@ export function runSwitchFork<R, E, A>(
 }
 
 export function withExhaustFork<R, E, A>(
-  f: (fork: FxFork, scope: Scope.Scope) => Effect.Effect<R, E, A>,
+  f: (fork: FxFork, scope: Scope.Scope) => Effect.Effect<A, E, R>,
   executionStrategy: ExecutionStrategy.ExecutionStrategy
 ) {
   return withScopedFork((fork, scope) => {
     return Effect.flatMap(
-      SynchronizedRef.make<Fiber.Fiber<never, void> | null>(null),
+      SynchronizedRef.make<Fiber.Fiber<void> | null>(null),
       (ref) =>
         Effect.flatMap(
           f((effect) =>
@@ -171,14 +171,14 @@ export function withExhaustFork<R, E, A>(
 }
 
 export function withExhaustLatestFork<R, E, A>(
-  f: (exhaustLatestFork: FxFork, scope: Scope.Scope) => Effect.Effect<R, E, A>,
+  f: (exhaustLatestFork: FxFork, scope: Scope.Scope) => Effect.Effect<A, E, R>,
   executionStrategy: ExecutionStrategy.ExecutionStrategy
 ) {
   return withScopedFork((fork, scope) =>
     Effect.flatMap(
       Effect.zip(
-        Ref.make<Fiber.Fiber<never, void> | void>(undefined),
-        Ref.make<Option.Option<Effect.Effect<any, never, void>>>(Option.none())
+        Ref.make<Fiber.Fiber<void> | void>(undefined),
+        Ref.make<Option.Option<Effect.Effect<void, never, any>>>(Option.none())
       ),
       ([ref, nextEffect]) => {
         const reset = Ref.set(ref, undefined)
@@ -188,7 +188,7 @@ export function withExhaustLatestFork<R, E, A>(
 
         // Run the next value that's be saved for replay if it exists
 
-        const runNext: Effect.Effect<any, never, void> = Effect.flatMap(
+        const runNext: Effect.Effect<void, never, any> = Effect.flatMap(
           Ref.get(nextEffect),
           (next) => {
             if (Option.isNone(next)) {
@@ -206,7 +206,7 @@ export function withExhaustLatestFork<R, E, A>(
           }
         )
 
-        const exhaustLatestFork = <R2>(eff: Effect.Effect<R2, never, void>) =>
+        const exhaustLatestFork = <R2>(eff: Effect.Effect<void, never, R2>) =>
           Effect.flatMap(Ref.get(ref), (currentFiber) =>
             currentFiber
               ? Ref.set(nextEffect, Option.some(eff))
@@ -226,11 +226,11 @@ export function withExhaustLatestFork<R, E, A>(
 }
 
 export function withUnboundedFork<R, E, A>(
-  f: (fork: FxFork, scope: Scope.Scope) => Effect.Effect<R, E, A>
+  f: (fork: FxFork, scope: Scope.Scope) => Effect.Effect<A, E, R>
 ) {
   return Effect.scopeWith((scope) =>
     Effect.flatMap(
-      FiberSet.make<never, void>(),
+      FiberSet.make<void, never>(),
       (set) =>
         Effect.flatMap(
           f((effect) => FiberSet.run(set, effect), scope),
@@ -242,12 +242,12 @@ export function withUnboundedFork<R, E, A>(
 
 export function withBoundedFork(capacity: number) {
   return <R, E, A>(
-    f: (fork: FxFork, scope: Scope.Scope) => Effect.Effect<R, E, A>,
+    f: (fork: FxFork, scope: Scope.Scope) => Effect.Effect<A, E, R>,
     executionStrategy: ExecutionStrategy.ExecutionStrategy
   ) => {
     return withScopedFork((fork, scope) =>
       Effect.flatMap(
-        Ref.make<Set<Fiber.Fiber<never, void>>>(new Set()).pipe(Effect.zip(Effect.makeSemaphore(capacity))),
+        Ref.make<Set<Fiber.Fiber<void>>>(new Set()).pipe(Effect.zip(Effect.makeSemaphore(capacity))),
         ([ref, semaphore]) =>
           Effect.flatMap(
             f((effect) =>
@@ -272,9 +272,9 @@ export function withBoundedFork(capacity: number) {
 export function withFlattenStrategy(
   strategy: FlattenStrategy
 ): <R, E, A>(
-  f: (fork: FxFork, scope: Scope.Scope) => Effect.Effect<R, E, A>,
+  f: (fork: FxFork, scope: Scope.Scope) => Effect.Effect<A, E, R>,
   executionStrategy: ExecutionStrategy.ExecutionStrategy
-) => Effect.Effect<R | Scope.Scope, E, void> {
+) => Effect.Effect<void, E, R | Scope.Scope> {
   switch (strategy._tag) {
     case "Bounded":
       return withBoundedFork(strategy.capacity)
@@ -290,7 +290,7 @@ export function withFlattenStrategy(
 }
 
 export function matchEffectPrimitive<R, E, A, Z>(
-  effect: Effect.Effect<R, E, A>,
+  effect: Effect.Effect<A, E, R>,
   matchers: {
     Success: (a: A) => Z
     Failure: (e: Cause.Cause<E>) => Z
@@ -299,7 +299,7 @@ export function matchEffectPrimitive<R, E, A, Z>(
     Right: (a: A) => Z
     Some: (a: A) => Z
     None: (e: E) => Z
-    Otherwise: (effect: Effect.Effect<R, E, A>) => Z
+    Otherwise: (effect: Effect.Effect<A, E, R>) => Z
   }
 ): Z {
   const eff = effect as any
@@ -341,7 +341,7 @@ export function adjustTime(input: Duration.DurationInput = 1) {
 
 export function tupleSink<R, E, A extends ReadonlyArray<any>, R2, E2, B>(
   sink: Sink.Sink<R, E, A>,
-  f: (sink: (index: number, value: A[number]) => Effect.Effect<R, never, unknown>) => Effect.Effect<R2, E2, B>,
+  f: (sink: (index: number, value: A[number]) => Effect.Effect<unknown, never, R>) => Effect.Effect<B, E2, R2>,
   expected: number
 ) {
   return Effect.suspend(() => {
@@ -362,13 +362,13 @@ export function tupleSink<R, E, A extends ReadonlyArray<any>, R2, E2, B>(
 }
 
 export function withDebounceFork<R, E, A>(
-  f: (fork: FxFork, scope: Scope.Scope) => Effect.Effect<R, E, A>,
+  f: (fork: FxFork, scope: Scope.Scope) => Effect.Effect<A, E, R>,
   duration: Duration.DurationInput
-): Effect.Effect<R | Scope.Scope, E, unknown> {
+): Effect.Effect<unknown, E, R | Scope.Scope> {
   return withScopedFork(
     (fork, scope) =>
       Effect.flatMap(
-        SynchronizedRef.make(Option.none<Fiber.Fiber<never, void>>()),
+        SynchronizedRef.make(Option.none<Fiber.Fiber<void>>()),
         (ref) =>
           Effect.flatMap(
             f(
@@ -418,7 +418,7 @@ export class RingBuffer<A> {
   }
 
   forEach<R2, E2, B>(
-    f: (a: A, i: number) => Effect.Effect<R2, E2, B>
+    f: (a: A, i: number) => Effect.Effect<B, E2, R2>
   ) {
     switch (this._size) {
       case 0:
@@ -450,16 +450,16 @@ export class RingBuffer<A> {
 }
 
 export function awaitScopeClose(scope: Scope.Scope) {
-  return Effect.asyncEffect<never, never, unknown, never, never, void>((cb) =>
+  return Effect.asyncEffect<unknown, never, never, void, never, never>((cb) =>
     Scope.addFinalizerExit(scope, () => Effect.sync(() => cb(Effect.unit)))
   )
 }
 
-export class MulticastEffect<R, E, A> extends Effectable.Class<R, E, A> {
-  private _fiber: Fiber.Fiber<E, A> | null = null
+export class MulticastEffect<R, E, A> extends Effectable.Class<A, E, R> {
+  private _fiber: Fiber.Fiber<A, E> | null = null
 
   constructor(
-    readonly effect: Effect.Effect<R, E, A>
+    readonly effect: Effect.Effect<A, E, R>
   ) {
     super()
   }

package/src/internal/keyed.ts

@@ -20,7 +20,7 @@ type StateContext<A, C> = {
   output: C
 }
 
-const StateContext = Context.Tag<StateContext<any, any>>()
+const StateContext = Context.GenericTag<StateContext<any, any>>("@services/StateContext")
 
 class Keyed<R, E, A, B extends PropertyKey, R2, E2, C> extends FxBase<R | R2 | Scope.Scope, E | E2, ReadonlyArray<C>>
   implements Fx<R | R2 | Scope.Scope, E | E2, ReadonlyArray<C>>
@@ -127,7 +127,7 @@ class KeyedEntry<A, C> {
     public index: number,
     public output: Option.Option<C>,
     public readonly ref: RefSubject.RefSubject<never, never, A>,
-    public readonly interrupt: Effect.Effect<never, never, void>
+    public readonly interrupt: Effect.Effect<void>
   ) {}
 }
 
@@ -160,7 +160,7 @@ function addValue<A, B extends PropertyKey, C, R2, E2, E, R3, D>(
   parentScope: Scope.Scope,
   options: KeyedOptions<A, B, R2, E2, C>,
   sink: Sink.Sink<R2 | R3, E | E2, ReadonlyArray<C>>,
-  scheduleNextEmit: Effect.Effect<R3, never, D>
+  scheduleNextEmit: Effect.Effect<D, never, R3>
 ) {
   return Effect.gen(function*(_) {
     const value = values[patch.index]

package/src/internal/protos.ts

@@ -15,24 +15,24 @@ const Variance: Fx.Variance<never, never, never> = {
 export abstract class FxBase<R, E, A> implements Fx<R, E, A> {
   readonly [TypeId]: Fx.Variance<R, E, A> = Variance
 
-  abstract run<R2>(sink: Sink<R2, E, A>): Effect.Effect<R | R2, never, unknown>
+  abstract run<R2>(sink: Sink<R2, E, A>): Effect.Effect<unknown, never, R | R2>
 
   pipe() {
     return pipeArguments(this, arguments)
   }
 }
 
-export abstract class FxEffectBase<R, E, A, R2, E2, B> extends Effectable.StructuralClass<R2, E2, B>
-  implements Fx<R, E, A>, Effect.Effect<R2, E2, B>
+export abstract class FxEffectBase<R, E, A, R2, E2, B> extends Effectable.StructuralClass<B, E2, R2>
+  implements Fx<R, E, A>, Effect.Effect<B, E2, R2>
 {
   readonly [TypeId]: Fx.Variance<R, E, A> = Variance
 
-  abstract run<R3>(sink: Sink<R3, E, A>): Effect.Effect<R | R3, never, unknown>
+  abstract run<R3>(sink: Sink<R3, E, A>): Effect.Effect<unknown, never, R | R3>
 
-  abstract toEffect(): Effect.Effect<R2, E2, B>
+  abstract toEffect(): Effect.Effect<B, E2, R2>
 
-  protected _effect: Effect.Effect<R2, E2, B> | undefined
-  commit(): Effect.Effect<R2, E2, B> {
+  protected _effect: Effect.Effect<B, E2, R2> | undefined
+  commit(): Effect.Effect<B, E2, R2> {
     if (this._effect === undefined) {
       return (this._effect = this.toEffect())
     } else {
@@ -41,13 +41,13 @@ export abstract class FxEffectBase<R, E, A, R2, E2, B> extends Effectable.Struct
   }
 }
 
-export abstract class EffectBase<R, E, A> extends Effectable.StructuralClass<R, E, A>
-  implements Effect.Effect<R, E, A>
+export abstract class EffectBase<R, E, A> extends Effectable.StructuralClass<A, E, R>
+  implements Effect.Effect<A, E, R>
 {
-  abstract toEffect(): Effect.Effect<R, E, A>
+  abstract toEffect(): Effect.Effect<A, E, R>
 
-  private _effect: Effect.Effect<R, E, A> | undefined
-  commit(): Effect.Effect<R, E, A> {
+  private _effect: Effect.Effect<A, E, R> | undefined
+  commit(): Effect.Effect<A, E, R> {
     if (this._effect === undefined) {
       return (this._effect = this.toEffect())
     } else {

package/src/internal/provide.ts

@@ -25,10 +25,10 @@ export const ProvideContext = <A>(i0: Context.Context<A>): ProvideContext<A> =>
 
 export interface ProvideLayer<R, E, A> {
   readonly _tag: "ProvideLayer"
-  readonly i0: Layer.Layer<R, E, A>
+  readonly i0: Layer.Layer<A, E, R>
 }
 
-export const ProvideLayer = <R, E, A>(i0: Layer.Layer<R, E, A>): ProvideLayer<R, E, A> => ({
+export const ProvideLayer = <R, E, A>(i0: Layer.Layer<A, E, R>): ProvideLayer<R, E, A> => ({
   _tag: "ProvideLayer",
   i0
 })
@@ -48,12 +48,12 @@ export const ProvideService = <I, S>(i0: Context.Tag<I, S>, i1: S): ProvideServi
 export interface ProvideServiceEffect<R, E, I, S> {
   readonly _tag: "ProvideServiceEffect"
   readonly i0: Context.Tag<I, S>
-  readonly i1: Effect.Effect<R, E, S>
+  readonly i1: Effect.Effect<S, E, R>
 }
 
 export const ProvideServiceEffect = <R, E, I, S>(
   i0: Context.Tag<I, S>,
-  i1: Effect.Effect<R, E, S>
+  i1: Effect.Effect<S, E, R>
 ): ProvideServiceEffect<R, E, I, S> => ({
   _tag: "ProvideServiceEffect",
   i0,
@@ -75,9 +75,9 @@ export function matchProvide<R = never, E = never, A = never, B = never>(
   matchers: {
     readonly ProvideContext: (i0: Context.Context<A>) => B
     readonly ProvideRuntime: (i0: Runtime.Runtime<A>) => B
-    readonly ProvideLayer: (i0: Layer.Layer<R, E, A>) => B
+    readonly ProvideLayer: (i0: Layer.Layer<A, E, R>) => B
     readonly ProvideService: (tag: Context.Tag<A, any>, service: any) => B
-    readonly ProvideServiceEffect: (tag: Context.Tag<A, any>, service: Effect.Effect<R, E, any>) => B
+    readonly ProvideServiceEffect: (tag: Context.Tag<A, any>, service: Effect.Effect<any, E, R>) => B
   }
 ): B {
   return matchers[self._tag](self.i0 as any, (self as any).i1)
@@ -97,7 +97,7 @@ export function buildWithScope<R, E, A>(
   return Layer.buildWithScope(toLayer(provide), scope)
 }
 
-export function toLayer<R, E, A>(provide: Provide<R, E, A>): Layer.Layer<R, E, A> {
+export function toLayer<R, E, A>(provide: Provide<R, E, A>): Layer.Layer<A, E, R> {
   switch (provide._tag) {
     case "ProvideContext":
       return Layer.succeedContext(provide.i0)
@@ -113,13 +113,13 @@ export function toLayer<R, E, A>(provide: Provide<R, E, A>): Layer.Layer<R, E, A
 }
 
 export function provideToEffect<R, E, A, R2 = never, E2 = never, S = never>(
-  effect: Effect.Effect<R, E, A>,
+  effect: Effect.Effect<A, E, R>,
   provide: Provide<R2, E2, S>
-): Effect.Effect<Exclude<R, S> | R2, E | E2, A> {
+): Effect.Effect<A, E | E2, Exclude<R, S> | R2> {
   return Effect.provide(effect, toLayer(provide))
 }
 
-export function runtimeToLayer<R>(runtime: Runtime.Runtime<R>): Layer.Layer<never, never, R> {
+export function runtimeToLayer<R>(runtime: Runtime.Runtime<R>): Layer.Layer<R> {
   // Calculate patch
   const patchRefs = FiberRefsPatch.diff(Runtime.defaultRuntime.fiberRefs, runtime.fiberRefs)
   const patchFlags = RuntimeFlags.diff(Runtime.defaultRuntime.runtimeFlags, runtime.runtimeFlags)

package/src/internal/share.ts

@@ -30,7 +30,7 @@ class RefCounter {
 }
 
 export class Share<R, E, A, R2> extends FxBase<R | R2 | Scope.Scope, E, A> {
-  _FxFiber: MutableRef.MutableRef<Option.Option<Fiber.Fiber<never, unknown>>> = MutableRef.make(Option.none())
+  _FxFiber: MutableRef.MutableRef<Option.Option<Fiber.Fiber<unknown>>> = MutableRef.make(Option.none())
   _RefCount = new RefCounter()
 
   constructor(
@@ -40,7 +40,7 @@ export class Share<R, E, A, R2> extends FxBase<R | R2 | Scope.Scope, E, A> {
     super()
   }
 
-  run<R3>(sink: Sink<R3, E, A>): Effect.Effect<R | R2 | R3 | Scope.Scope, never, unknown> {
+  run<R3>(sink: Sink<R3, E, A>): Effect.Effect<unknown, never, R | R2 | R3 | Scope.Scope> {
     return withScopedFork(
       (fork) =>
         Effect.flatMap(
@@ -53,7 +53,7 @@ export class Share<R, E, A, R2> extends FxBase<R | R2 | Scope.Scope, E, A> {
     )
   }
 
-  private initialize(): Effect.Effect<R | R2, never, unknown> {
+  private initialize(): Effect.Effect<unknown, never, R | R2> {
     return Effect.suspend(() => {
       if (this._RefCount.increment() === 1) {
         return this.i0.run(this.i1).pipe(
@@ -80,7 +80,7 @@ export class Share<R, E, A, R2> extends FxBase<R | R2 | Scope.Scope, E, A> {
     })
   }
 
-  private interrupt(): Effect.Effect<R | R2, never, void> {
+  private interrupt(): Effect.Effect<void, never, R | R2> {
     return Effect.suspend(() => {
       const fiber = Option.getOrNull(MutableRef.getAndSet(this._FxFiber, Option.none()))