effect 2.2.5 → 2.3.0

package/src/internal/subscriptionRef.ts

@@ -37,7 +37,7 @@ class SubscriptionRefImpl<in out A> implements SubscriptionRef.SubscriptionRef<A
   pipe() {
     return pipeArguments(this, arguments)
   }
-  get changes(): Stream<never, never, A> {
+  get changes(): Stream<A> {
     return pipe(
       Ref.get(this.ref),
       Effect.flatMap((a) =>
@@ -54,10 +54,10 @@ class SubscriptionRefImpl<in out A> implements SubscriptionRef.SubscriptionRef<A
       stream.unwrapScoped
     )
   }
-  modify<B>(f: (a: A) => readonly [B, A]): Effect.Effect<never, never, B> {
+  modify<B>(f: (a: A) => readonly [B, A]): Effect.Effect<B> {
     return this.modifyEffect((a) => Effect.succeed(f(a)))
   }
-  modifyEffect<R, E, B>(f: (a: A) => Effect.Effect<R, E, readonly [B, A]>): Effect.Effect<R, E, B> {
+  modifyEffect<B, E, R>(f: (a: A) => Effect.Effect<readonly [B, A], E, R>): Effect.Effect<B, E, R> {
     return pipe(
       Ref.get(this.ref),
       Effect.flatMap(f),
@@ -74,10 +74,10 @@ class SubscriptionRefImpl<in out A> implements SubscriptionRef.SubscriptionRef<A
 }
 
 /** @internal */
-export const get = <A>(self: SubscriptionRef.SubscriptionRef<A>): Effect.Effect<never, never, A> => Ref.get(self.ref)
+export const get = <A>(self: SubscriptionRef.SubscriptionRef<A>): Effect.Effect<A> => Ref.get(self.ref)
 
 /** @internal */
-export const make = <A>(value: A): Effect.Effect<never, never, SubscriptionRef.SubscriptionRef<A>> =>
+export const make = <A>(value: A): Effect.Effect<SubscriptionRef.SubscriptionRef<A>> =>
   pipe(
     Effect.all([
       PubSub.unbounded<A>(),
@@ -89,41 +89,41 @@ export const make = <A>(value: A): Effect.Effect<never, never, SubscriptionRef.S
 
 /** @internal */
 export const modify = dual<
-  <A, B>(f: (a: A) => readonly [B, A]) => (self: SubscriptionRef.SubscriptionRef<A>) => Effect.Effect<never, never, B>,
+  <A, B>(f: (a: A) => readonly [B, A]) => (self: SubscriptionRef.SubscriptionRef<A>) => Effect.Effect<B>,
   <A, B>(
     self: SubscriptionRef.SubscriptionRef<A>,
     f: (a: A) => readonly [B, A]
-  ) => Effect.Effect<never, never, B>
+  ) => Effect.Effect<B>
 >(2, <A, B>(
   self: SubscriptionRef.SubscriptionRef<A>,
   f: (a: A) => readonly [B, A]
-): Effect.Effect<never, never, B> => self.modify(f))
+): Effect.Effect<B> => self.modify(f))
 
 /** @internal */
 export const modifyEffect = dual<
   <A, R, E, B>(
-    f: (a: A) => Effect.Effect<R, E, readonly [B, A]>
-  ) => (self: SubscriptionRef.SubscriptionRef<A>) => Effect.Effect<R, E, B>,
+    f: (a: A) => Effect.Effect<readonly [B, A], E, R>
+  ) => (self: SubscriptionRef.SubscriptionRef<A>) => Effect.Effect<B, E, R>,
   <A, R, E, B>(
     self: SubscriptionRef.SubscriptionRef<A>,
-    f: (a: A) => Effect.Effect<R, E, readonly [B, A]>
-  ) => Effect.Effect<R, E, B>
+    f: (a: A) => Effect.Effect<readonly [B, A], E, R>
+  ) => Effect.Effect<B, E, R>
 >(2, <A, R, E, B>(
   self: SubscriptionRef.SubscriptionRef<A>,
-  f: (a: A) => Effect.Effect<R, E, readonly [B, A]>
-): Effect.Effect<R, E, B> => self.modifyEffect(f))
+  f: (a: A) => Effect.Effect<readonly [B, A], E, R>
+): Effect.Effect<B, E, R> => self.modifyEffect(f))
 
 /** @internal */
 export const set = dual<
-  <A>(value: A) => (self: SubscriptionRef.SubscriptionRef<A>) => Effect.Effect<never, never, void>,
+  <A>(value: A) => (self: SubscriptionRef.SubscriptionRef<A>) => Effect.Effect<void>,
   <A>(
     self: SubscriptionRef.SubscriptionRef<A>,
     value: A
-  ) => Effect.Effect<never, never, void>
+  ) => Effect.Effect<void>
 >(2, <A>(
   self: SubscriptionRef.SubscriptionRef<A>,
   value: A
-): Effect.Effect<never, never, void> =>
+): Effect.Effect<void> =>
   pipe(
     Ref.set(self.ref, value),
     Effect.zipLeft(PubSub.publish(self.pubsub, value)),

package/src/internal/supervisor.ts

@@ -31,36 +31,36 @@ export class ProxySupervisor<out T> implements Supervisor.Supervisor<T> {
 
   constructor(
     readonly underlying: Supervisor.Supervisor<any>,
-    readonly value0: Effect.Effect<never, never, T>
+    readonly value0: Effect.Effect<T>
   ) {
   }
 
-  get value(): Effect.Effect<never, never, T> {
+  get value(): Effect.Effect<T> {
     return this.value0
   }
 
-  onStart<R, E, A>(
+  onStart<A, E, R>(
     context: Context.Context<R>,
-    effect: Effect.Effect<R, E, A>,
+    effect: Effect.Effect<A, E, R>,
     parent: Option.Option<Fiber.RuntimeFiber<any, any>>,
-    fiber: Fiber.RuntimeFiber<E, A>
+    fiber: Fiber.RuntimeFiber<A, E>
   ): void {
     this.underlying.onStart(context, effect, parent, fiber)
   }
 
-  onEnd<E, A>(value: Exit.Exit<E, A>, fiber: Fiber.RuntimeFiber<E, A>): void {
+  onEnd<A, E>(value: Exit.Exit<A, E>, fiber: Fiber.RuntimeFiber<A, E>): void {
     this.underlying.onEnd(value, fiber)
   }
 
-  onEffect<E, A>(fiber: Fiber.RuntimeFiber<E, A>, effect: Effect.Effect<any, any, any>): void {
+  onEffect<A, E>(fiber: Fiber.RuntimeFiber<A, E>, effect: Effect.Effect<any, any, any>): void {
     this.underlying.onEffect(fiber, effect)
   }
 
-  onSuspend<E, A>(fiber: Fiber.RuntimeFiber<E, A>): void {
+  onSuspend<A, E>(fiber: Fiber.RuntimeFiber<A, E>): void {
     this.underlying.onSuspend(fiber)
   }
 
-  onResume<E, A>(fiber: Fiber.RuntimeFiber<E, A>): void {
+  onResume<A, E>(fiber: Fiber.RuntimeFiber<A, E>): void {
     this.underlying.onResume(fiber)
   }
 
@@ -84,36 +84,36 @@ export class Zip<out T0, out T1> implements Supervisor.Supervisor<readonly [T0,
   ) {
   }
 
-  get value(): Effect.Effect<never, never, [T0, T1]> {
+  get value(): Effect.Effect<[T0, T1]> {
     return core.zip(this.left.value, this.right.value)
   }
 
-  onStart<R, E, A>(
+  onStart<A, E, R>(
     context: Context.Context<R>,
-    effect: Effect.Effect<R, E, A>,
+    effect: Effect.Effect<A, E, R>,
     parent: Option.Option<Fiber.RuntimeFiber<any, any>>,
-    fiber: Fiber.RuntimeFiber<E, A>
+    fiber: Fiber.RuntimeFiber<A, E>
   ): void {
     this.left.onStart(context, effect, parent, fiber)
     this.right.onStart(context, effect, parent, fiber)
   }
 
-  onEnd<E, A>(value: Exit.Exit<E, A>, fiber: Fiber.RuntimeFiber<E, A>): void {
+  onEnd<A, E>(value: Exit.Exit<A, E>, fiber: Fiber.RuntimeFiber<A, E>): void {
     this.left.onEnd(value, fiber)
     this.right.onEnd(value, fiber)
   }
 
-  onEffect<E, A>(fiber: Fiber.RuntimeFiber<E, A>, effect: Effect.Effect<any, any, any>): void {
+  onEffect<A, E>(fiber: Fiber.RuntimeFiber<A, E>, effect: Effect.Effect<any, any, any>): void {
     this.left.onEffect(fiber, effect)
     this.right.onEffect(fiber, effect)
   }
 
-  onSuspend<E, A>(fiber: Fiber.RuntimeFiber<E, A>): void {
+  onSuspend<A, E>(fiber: Fiber.RuntimeFiber<A, E>): void {
     this.left.onSuspend(fiber)
     this.right.onSuspend(fiber)
   }
 
-  onResume<E, A>(fiber: Fiber.RuntimeFiber<E, A>): void {
+  onResume<A, E>(fiber: Fiber.RuntimeFiber<A, E>): void {
     this.left.onResume(fiber)
     this.right.onResume(fiber)
   }
@@ -137,32 +137,32 @@ export class Track implements Supervisor.Supervisor<Array<Fiber.RuntimeFiber<any
 
   readonly fibers: Set<Fiber.RuntimeFiber<any, any>> = new Set()
 
-  get value(): Effect.Effect<never, never, Array<Fiber.RuntimeFiber<any, any>>> {
+  get value(): Effect.Effect<Array<Fiber.RuntimeFiber<any, any>>> {
     return core.sync(() => Array.from(this.fibers))
   }
 
-  onStart<R, E, A>(
+  onStart<A, E, R>(
     _context: Context.Context<R>,
-    _effect: Effect.Effect<R, E, A>,
+    _effect: Effect.Effect<A, E, R>,
     _parent: Option.Option<Fiber.RuntimeFiber<any, any>>,
-    fiber: Fiber.RuntimeFiber<E, A>
+    fiber: Fiber.RuntimeFiber<A, E>
   ): void {
     this.fibers.add(fiber)
   }
 
-  onEnd<E, A>(_value: Exit.Exit<E, A>, fiber: Fiber.RuntimeFiber<E, A>): void {
+  onEnd<A, E>(_value: Exit.Exit<A, E>, fiber: Fiber.RuntimeFiber<A, E>): void {
     this.fibers.delete(fiber)
   }
 
-  onEffect<E, A>(_fiber: Fiber.RuntimeFiber<E, A>, _effect: Effect.Effect<any, any, any>): void {
+  onEffect<A, E>(_fiber: Fiber.RuntimeFiber<A, E>, _effect: Effect.Effect<any, any, any>): void {
     //
   }
 
-  onSuspend<E, A>(_fiber: Fiber.RuntimeFiber<E, A>): void {
+  onSuspend<A, E>(_fiber: Fiber.RuntimeFiber<A, E>): void {
     //
   }
 
-  onResume<E, A>(_fiber: Fiber.RuntimeFiber<E, A>): void {
+  onResume<A, E>(_fiber: Fiber.RuntimeFiber<A, E>): void {
     //
   }
 
@@ -176,7 +176,7 @@ export class Track implements Supervisor.Supervisor<Array<Fiber.RuntimeFiber<any
     return new Zip(this, right)
   }
 
-  onRun<E, A, X>(execution: () => X, _fiber: Fiber.RuntimeFiber<E, A>): X {
+  onRun<E, A, X>(execution: () => X, _fiber: Fiber.RuntimeFiber<A, E>): X {
     return execution()
   }
 }
@@ -185,35 +185,35 @@ export class Track implements Supervisor.Supervisor<Array<Fiber.RuntimeFiber<any
 export class Const<out T> implements Supervisor.Supervisor<T> {
   readonly [SupervisorTypeId] = supervisorVariance
 
-  constructor(readonly effect: Effect.Effect<never, never, T>) {
+  constructor(readonly effect: Effect.Effect<T>) {
   }
 
-  get value(): Effect.Effect<never, never, T> {
+  get value(): Effect.Effect<T> {
     return this.effect
   }
 
-  onStart<R, E, A>(
+  onStart<A, E, R>(
     _context: Context.Context<R>,
-    _effect: Effect.Effect<R, E, A>,
+    _effect: Effect.Effect<A, E, R>,
     _parent: Option.Option<Fiber.RuntimeFiber<any, any>>,
-    _fiber: Fiber.RuntimeFiber<E, A>
+    _fiber: Fiber.RuntimeFiber<A, E>
   ): void {
     //
   }
 
-  onEnd<E, A>(_value: Exit.Exit<E, A>, _fiber: Fiber.RuntimeFiber<E, A>): void {
+  onEnd<A, E>(_value: Exit.Exit<A, E>, _fiber: Fiber.RuntimeFiber<A, E>): void {
     //
   }
 
-  onEffect<E, A>(_fiber: Fiber.RuntimeFiber<E, A>, _effect: Effect.Effect<any, any, any>): void {
+  onEffect<A, E>(_fiber: Fiber.RuntimeFiber<A, E>, _effect: Effect.Effect<any, any, any>): void {
     //
   }
 
-  onSuspend<E, A>(_fiber: Fiber.RuntimeFiber<E, A>): void {
+  onSuspend<A, E>(_fiber: Fiber.RuntimeFiber<A, E>): void {
     //
   }
 
-  onResume<E, A>(_fiber: Fiber.RuntimeFiber<E, A>): void {
+  onResume<A, E>(_fiber: Fiber.RuntimeFiber<A, E>): void {
     //
   }
 
@@ -225,7 +225,7 @@ export class Const<out T> implements Supervisor.Supervisor<T> {
     return new Zip(this, right)
   }
 
-  onRun<E, A, X>(execution: () => X, _fiber: Fiber.RuntimeFiber<E, A>): X {
+  onRun<E, A, X>(execution: () => X, _fiber: Fiber.RuntimeFiber<A, E>): X {
     return execution()
   }
 }
@@ -236,32 +236,32 @@ class FibersIn implements Supervisor.Supervisor<SortedSet.SortedSet<Fiber.Runtim
   constructor(readonly ref: MutableRef.MutableRef<SortedSet.SortedSet<Fiber.RuntimeFiber<any, any>>>) {
   }
 
-  get value(): Effect.Effect<never, never, SortedSet.SortedSet<Fiber.RuntimeFiber<any, any>>> {
+  get value(): Effect.Effect<SortedSet.SortedSet<Fiber.RuntimeFiber<any, any>>> {
     return core.sync(() => MutableRef.get(this.ref))
   }
 
-  onStart<R, E, A>(
+  onStart<A, E, R>(
     _context: Context.Context<R>,
-    _effect: Effect.Effect<R, E, A>,
+    _effect: Effect.Effect<A, E, R>,
     _parent: Option.Option<Fiber.RuntimeFiber<any, any>>,
-    fiber: Fiber.RuntimeFiber<E, A>
+    fiber: Fiber.RuntimeFiber<A, E>
   ): void {
     pipe(this.ref, MutableRef.set(pipe(MutableRef.get(this.ref), SortedSet.add(fiber))))
   }
 
-  onEnd<E, A>(_value: Exit.Exit<E, A>, fiber: Fiber.RuntimeFiber<E, A>): void {
+  onEnd<A, E>(_value: Exit.Exit<A, E>, fiber: Fiber.RuntimeFiber<A, E>): void {
     pipe(this.ref, MutableRef.set(pipe(MutableRef.get(this.ref), SortedSet.remove(fiber))))
   }
 
-  onEffect<E, A>(_fiber: Fiber.RuntimeFiber<E, A>, _effect: Effect.Effect<any, any, any>): void {
+  onEffect<A, E>(_fiber: Fiber.RuntimeFiber<A, E>, _effect: Effect.Effect<any, any, any>): void {
     //
   }
 
-  onSuspend<E, A>(_fiber: Fiber.RuntimeFiber<E, A>): void {
+  onSuspend<A, E>(_fiber: Fiber.RuntimeFiber<A, E>): void {
     //
   }
 
-  onResume<E, A>(_fiber: Fiber.RuntimeFiber<E, A>): void {
+  onResume<A, E>(_fiber: Fiber.RuntimeFiber<A, E>): void {
     //
   }
 
@@ -275,7 +275,7 @@ class FibersIn implements Supervisor.Supervisor<SortedSet.SortedSet<Fiber.Runtim
     return new Zip(this, right)
   }
 
-  onRun<E, A, X>(execution: () => X, _fiber: Fiber.RuntimeFiber<E, A>): X {
+  onRun<E, A, X>(execution: () => X, _fiber: Fiber.RuntimeFiber<A, E>): X {
     return execution()
   }
 }
@@ -286,14 +286,10 @@ export const unsafeTrack = (): Supervisor.Supervisor<Array<Fiber.RuntimeFiber<an
 }
 
 /** @internal */
-export const track: Effect.Effect<
-  never,
-  never,
-  Supervisor.Supervisor<Array<Fiber.RuntimeFiber<any, any>>>
-> = core.sync(unsafeTrack)
+export const track: Effect.Effect<Supervisor.Supervisor<Array<Fiber.RuntimeFiber<any, any>>>> = core.sync(unsafeTrack)
 
 /** @internal */
-export const fromEffect = <A>(effect: Effect.Effect<never, never, A>): Supervisor.Supervisor<A> => {
+export const fromEffect = <A>(effect: Effect.Effect<A>): Supervisor.Supervisor<A> => {
   return new Const(effect)
 }
 
@@ -303,8 +299,5 @@ export const none = globalValue("effect/Supervisor/none", () => fromEffect(core.
 /** @internal */
 export const fibersIn = (
   ref: MutableRef.MutableRef<SortedSet.SortedSet<Fiber.RuntimeFiber<any, any>>>
-): Effect.Effect<
-  never,
-  never,
-  Supervisor.Supervisor<SortedSet.SortedSet<Fiber.RuntimeFiber<any, any>>>
-> => core.sync(() => new FibersIn(ref))
+): Effect.Effect<Supervisor.Supervisor<SortedSet.SortedSet<Fiber.RuntimeFiber<any, any>>>> =>
+  core.sync(() => new FibersIn(ref))

package/src/internal/synchronizedRef.ts

@@ -7,8 +7,8 @@ import * as _ref from "./ref.js"
 
 /** @internal */
 export const getAndUpdateEffect = dual<
-  <A, R, E>(f: (a: A) => Effect.Effect<R, E, A>) => (self: Synchronized.SynchronizedRef<A>) => Effect.Effect<R, E, A>,
-  <A, R, E>(self: Synchronized.SynchronizedRef<A>, f: (a: A) => Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
+  <A, R, E>(f: (a: A) => Effect.Effect<A, E, R>) => (self: Synchronized.SynchronizedRef<A>) => Effect.Effect<A, E, R>,
+  <A, R, E>(self: Synchronized.SynchronizedRef<A>, f: (a: A) => Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
 >(2, (self, f) =>
   self.modifyEffect(
     (value) => core.map(f(value), (result) => [value, result] as const)
@@ -17,12 +17,12 @@ export const getAndUpdateEffect = dual<
 /** @internal */
 export const getAndUpdateSomeEffect = dual<
   <A, R, E>(
-    pf: (a: A) => Option.Option<Effect.Effect<R, E, A>>
-  ) => (self: Synchronized.SynchronizedRef<A>) => Effect.Effect<R, E, A>,
+    pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>
+  ) => (self: Synchronized.SynchronizedRef<A>) => Effect.Effect<A, E, R>,
   <A, R, E>(
     self: Synchronized.SynchronizedRef<A>,
-    pf: (a: A) => Option.Option<Effect.Effect<R, E, A>>
-  ) => Effect.Effect<R, E, A>
+    pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>
+  ) => Effect.Effect<A, E, R>
 >(2, (self, pf) =>
   self.modifyEffect((value) => {
     const result = pf(value)
@@ -38,32 +38,32 @@ export const getAndUpdateSomeEffect = dual<
 
 /** @internal */
 export const modify = dual<
-  <A, B>(f: (a: A) => readonly [B, A]) => (self: Synchronized.SynchronizedRef<A>) => Effect.Effect<never, never, B>,
-  <A, B>(self: Synchronized.SynchronizedRef<A>, f: (a: A) => readonly [B, A]) => Effect.Effect<never, never, B>
+  <A, B>(f: (a: A) => readonly [B, A]) => (self: Synchronized.SynchronizedRef<A>) => Effect.Effect<B>,
+  <A, B>(self: Synchronized.SynchronizedRef<A>, f: (a: A) => readonly [B, A]) => Effect.Effect<B>
 >(2, (self, f) => self.modify(f))
 
 /** @internal */
 export const modifyEffect = dual<
-  <A, R, E, B>(
-    f: (a: A) => Effect.Effect<R, E, readonly [B, A]>
-  ) => (self: Synchronized.SynchronizedRef<A>) => Effect.Effect<R, E, B>,
-  <A, R, E, B>(
+  <A, B, E, R>(
+    f: (a: A) => Effect.Effect<readonly [B, A], E, R>
+  ) => (self: Synchronized.SynchronizedRef<A>) => Effect.Effect<B, E, R>,
+  <A, B, E, R>(
     self: Synchronized.SynchronizedRef<A>,
-    f: (a: A) => Effect.Effect<R, E, readonly [B, A]>
-  ) => Effect.Effect<R, E, B>
+    f: (a: A) => Effect.Effect<readonly [B, A], E, R>
+  ) => Effect.Effect<B, E, R>
 >(2, (self, f) => self.modifyEffect(f))
 
 /** @internal */
 export const modifySomeEffect = dual<
   <A, B, R, E>(
     fallback: B,
-    pf: (a: A) => Option.Option<Effect.Effect<R, E, readonly [B, A]>>
-  ) => (self: Synchronized.SynchronizedRef<A>) => Effect.Effect<R, E, B>,
+    pf: (a: A) => Option.Option<Effect.Effect<readonly [B, A], E, R>>
+  ) => (self: Synchronized.SynchronizedRef<A>) => Effect.Effect<B, E, R>,
   <A, B, R, E>(
     self: Synchronized.SynchronizedRef<A>,
     fallback: B,
-    pf: (a: A) => Option.Option<Effect.Effect<R, E, readonly [B, A]>>
-  ) => Effect.Effect<R, E, B>
+    pf: (a: A) => Option.Option<Effect.Effect<readonly [B, A], E, R>>
+  ) => Effect.Effect<B, E, R>
 >(3, (self, fallback, pf) =>
   self.modifyEffect(
     (value) => pipe(pf(value), Option.getOrElse(() => core.succeed([fallback, value] as const)))
@@ -72,9 +72,9 @@ export const modifySomeEffect = dual<
 /** @internal */
 export const updateEffect = dual<
   <A, R, E>(
-    f: (a: A) => Effect.Effect<R, E, A>
-  ) => (self: Synchronized.SynchronizedRef<A>) => Effect.Effect<R, E, void>,
-  <A, R, E>(self: Synchronized.SynchronizedRef<A>, f: (a: A) => Effect.Effect<R, E, A>) => Effect.Effect<R, E, void>
+    f: (a: A) => Effect.Effect<A, E, R>
+  ) => (self: Synchronized.SynchronizedRef<A>) => Effect.Effect<void, E, R>,
+  <A, R, E>(self: Synchronized.SynchronizedRef<A>, f: (a: A) => Effect.Effect<A, E, R>) => Effect.Effect<void, E, R>
 >(2, (self, f) =>
   self.modifyEffect((value) =>
     core.map(
@@ -85,8 +85,8 @@ export const updateEffect = dual<
 
 /** @internal */
 export const updateAndGetEffect = dual<
-  <A, R, E>(f: (a: A) => Effect.Effect<R, E, A>) => (self: Synchronized.SynchronizedRef<A>) => Effect.Effect<R, E, A>,
-  <A, R, E>(self: Synchronized.SynchronizedRef<A>, f: (a: A) => Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
+  <A, R, E>(f: (a: A) => Effect.Effect<A, E, R>) => (self: Synchronized.SynchronizedRef<A>) => Effect.Effect<A, E, R>,
+  <A, R, E>(self: Synchronized.SynchronizedRef<A>, f: (a: A) => Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
 >(2, (self, f) =>
   self.modifyEffect(
     (value) => core.map(f(value), (result) => [result, result] as const)
@@ -95,12 +95,12 @@ export const updateAndGetEffect = dual<
 /** @internal */
 export const updateSomeEffect = dual<
   <A, R, E>(
-    pf: (a: A) => Option.Option<Effect.Effect<R, E, A>>
-  ) => (self: Synchronized.SynchronizedRef<A>) => Effect.Effect<R, E, void>,
+    pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>
+  ) => (self: Synchronized.SynchronizedRef<A>) => Effect.Effect<void, E, R>,
   <A, R, E>(
     self: Synchronized.SynchronizedRef<A>,
-    pf: (a: A) => Option.Option<Effect.Effect<R, E, A>>
-  ) => Effect.Effect<R, E, void>
+    pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>
+  ) => Effect.Effect<void, E, R>
 >(2, (self, pf) =>
   self.modifyEffect((value) => {
     const result = pf(value)