@typed/fx 1.13.0 → 1.15.0

package/src/keyed.ts

@@ -4,11 +4,13 @@ import * as ReadonlyArray from '@effect/data/ReadonlyArray'
 import * as Cause from '@effect/io/Cause'
 import * as Effect from '@effect/io/Effect'
 import * as Fiber from '@effect/io/Fiber'
+import * as Scope from '@effect/io/Scope'
 
 import { Fx, Sink } from './Fx.js'
-import { RefSubject } from './RefSubject.js'
+import { RefSubject, makeRef } from './RefSubject.js'
 import { Subject, makeHoldSubject } from './Subject.js'
 import { ScopedFork, withScopedFork } from './helpers.js'
+import { skipRepeats } from './skipRepeats.js'
 
 export function keyed<R, E, A, R2, E2, B, C>(
   fx: Fx<R, E, readonly A[]>,
@@ -16,13 +18,13 @@ export function keyed<R, E, A, R2, E2, B, C>(
   getKey: (a: A) => C,
 ): Fx<R | R2, E | E2, readonly B[]> {
   return Fx(<R3>(sink: Sink<R3, E | E2, readonly B[]>) =>
-    withScopedFork((fork) =>
+    withScopedFork((fork, scope) =>
       Effect.gen(function* ($) {
         const state = createKeyedState<A, B, C>()
         const emit = emitWhenReady(state, getKey)
 
         // Let output emit to the sink, it is closes by the surrounding scope
-        yield* $(fork(state.output.run(sink)))
+        yield* $(fork(skipRepeats(state.output).run(sink)))
 
         // Listen to the input and update the state
         yield* $(
@@ -35,6 +37,7 @@ export function keyed<R, E, A, R2, E2, B, C>(
                   getKey,
                   f,
                   fork,
+                  scope,
                   emit,
                   error: sink.error,
                 }),
@@ -78,6 +81,7 @@ function updateState<A, B, C, R2, E2, R3>({
   updated,
   f,
   fork,
+  scope,
   emit,
   error,
   getKey,
@@ -86,31 +90,42 @@ function updateState<A, B, C, R2, E2, R3>({
   updated: readonly A[]
   f: (fx: RefSubject<never, A>) => Fx<R2, E2, B>
   fork: ScopedFork
+  scope: Scope.Scope
   emit: Effect.Effect<never, never, void>
   error: (e: Cause.Cause<E2>) => Effect.Effect<R3, never, void>
   getKey: (a: A) => C
 }) {
-  return Effect.gen(function* ($) {
-    const { added, removed, unchanged } = diffValues(state, updated, getKey)
-
-    // Remove values that are no longer in the stream
-    yield* $(Effect.forEachDiscard(removed, (key) => removeValue(state, key)))
-
-    // Update values that are still in the stream
-    yield* $(Effect.forEachParDiscard(unchanged, (value) => updateValue(state, value, getKey)))
-
-    // Add values that are new to the stream
-    yield* $(
-      Effect.forEachParDiscard(added, (value) =>
-        addValue({ state, value, f, fork, emit, error, getKey }),
-      ),
-    )
-
-    // If nothing was added, emit the current values
-    if (added.length === 0) {
-      yield* $(emit)
-    }
-  })
+  return Effect.provideService(
+    Effect.gen(function* ($) {
+      const { added, removed, unchanged } = diffValues(state, updated, getKey)
+
+      // Remove values that are no longer in the stream
+      yield* $(Effect.forEach(removed, (key) => removeValue(state, key), { discard: true }))
+
+      // Update values that are still in the stream
+      yield* $(
+        Effect.forEach(unchanged, (value) => updateValue(state, value, getKey), {
+          concurrency: 'unbounded',
+          discard: true,
+        }),
+      )
+
+      // Add values that are new to the stream
+      yield* $(
+        Effect.forEach(added, (value) => addValue({ state, value, f, fork, emit, error, getKey }), {
+          concurrency: 'unbounded',
+          discard: true,
+        }),
+      )
+
+      // If nothing was added, emit the current values
+      if (added.length === 0) {
+        yield* $(emit)
+      }
+    }),
+    Scope.Scope,
+    scope,
+  )
 }
 
 function diffValues<A, B, C>(
@@ -186,7 +201,7 @@ function addValue<A, B, C, R2, E2, R3>({
 }) {
   return Effect.gen(function* ($) {
     const key = getKey(value)
-    const subject = RefSubject.unsafeMake<never, A>(Effect.succeed(value))
+    const subject = yield* $(makeRef<never, never, A>(Effect.succeed(value)))
     const fx = f(subject)
     const fiber = yield* $(
       fork(
@@ -223,7 +238,7 @@ function emitWhenReady<A, B, C>(state: KeyedState<A, B, C>, getKey: (a: A) => C)
   return Effect.suspend(() => {
     // Fast path: if we don't have enough values, don't emit
     if (MutableHashMap.size(state.values) !== state.previous.length) {
-      return Effect.unit()
+      return Effect.unit
     }
 
     const values = ReadonlyArray.filterMap(state.previous, (value) =>
@@ -235,10 +250,12 @@ function emitWhenReady<A, B, C>(state: KeyedState<A, B, C>, getKey: (a: A) => C)
       return state.output.event(values)
     }
 
-    return Effect.unit()
+    return Effect.unit
   })
 }
 
 function endAll<A, B, C>(state: KeyedState<A, B, C>) {
-  return Effect.forEachParDiscard(state.subjects, ([, subject]) => subject.end())
+  return Effect.forEach(state.subjects, ([, subject]) => subject.end(), {
+    concurrency: 'unbounded',
+  })
 }

package/src/mergeAll.ts

@@ -10,12 +10,15 @@ export function mergeAll<FXS extends ReadonlyArray<Fx<any, any, any>>>(
   ...fxs: FXS
 ): Fx<Fx.ResourcesOf<FXS[number]>, Fx.ErrorsOf<FXS[number]>, Fx.OutputOf<FXS[number]>> {
   return Fx((sink) =>
-    Effect.forEachParDiscard(fxs, (fx) =>
-      fx.run(
-        Sink(sink.event, (cause) =>
-          Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
+    Effect.forEach(
+      fxs,
+      (fx) =>
+        fx.run(
+          Sink(sink.event, (cause) =>
+            Cause.isInterruptedOnly(cause) ? Effect.unit : sink.error(cause),
+          ),
         ),
-      ),
+      { concurrency: 'unbounded', discard: true },
     ),
   )
 }

package/src/mergeBufferConcurrently.test.ts

@@ -0,0 +1,37 @@
+import { millis } from '@effect/data/Duration'
+import { describe } from 'vitest'
+
+import { at } from './at.js'
+import { fromArray } from './fromArray.js'
+import { mergeAll } from './mergeAll.js'
+import { mergeBufferConcurrently } from './mergeBufferConcurrently.js'
+import { testCollectAll } from './test-utils.js'
+
+describe(__filename, () => {
+  describe(mergeBufferConcurrently.name, () => {
+    testCollectAll(
+      'buffers values until the previous stream completes',
+      mergeBufferConcurrently(
+        at(1, millis(50)),
+        mergeAll(at(2, millis(0)), at(3, millis(20)), at(4, millis(40))),
+      ),
+      [1, 2, 3, 4],
+    )
+
+    testCollectAll(
+      'emits immediately if previous stream has ended',
+      mergeBufferConcurrently(
+        at(1, millis(0)),
+        mergeAll(at(2, millis(5)), at(3, millis(10)), at(4, millis(20))),
+        mergeAll(at(5, millis(0)), at(6, millis(5)), at(7, millis(10))),
+      ),
+      [1, 2, 3, 4, 5, 6, 7],
+    )
+
+    testCollectAll(
+      'merges multiple synchronous streams',
+      mergeBufferConcurrently(fromArray([1, 2, 3]), fromArray([4, 5, 6])),
+      [1, 2, 3, 4, 5, 6],
+    )
+  })
+})

package/src/mergeBufferConcurrently.ts

@@ -0,0 +1,105 @@
+import * as Chunk from '@effect/data/Chunk'
+import * as Effect from '@effect/io/Effect'
+
+import { Fx, Sink } from './Fx.js'
+import { empty } from './empty.js'
+
+/**
+ * Merges n Fx concurrently, emitting the values in order of the streams are provided.
+ * For example, Fx at index 0 will emit all of its values first, when it completes, Fx at index 1 will emit all of its values, and so on.
+ * When there is asynchrony, the indexes which are not yet ready are buffered.
+ */
+export function mergeBufferConcurrently<FXS extends Fx.TupleAny>(
+  ...fxs: FXS
+): Fx<Fx.ResourcesOf<FXS[number]>, Fx.ErrorsOf<FXS[number]>, Fx.OutputOf<FXS[number]>> {
+  if (fxs.length === 0) return empty()
+  if (fxs.length === 1) return fxs[0]
+
+  return Fx(<R2>(sink: Sink<R2, Fx.ErrorsOf<FXS[number]>, Fx.OutputOf<FXS[number]>>) =>
+    Effect.suspend(() => {
+      type O = Fx.OutputOf<FXS[number]>
+
+      const finished = new Map<number, Chunk.Chunk<O>>()
+      let currentIndex = 0
+
+      function onFinished(index: number, buffer: Chunk.Chunk<O>): Effect.Effect<R2, never, void> {
+        if (currentIndex < index) {
+          // If the current index is behind, buffer the value
+          return Effect.sync(() => {
+            finished.set(index, buffer)
+          })
+        }
+
+        if (Chunk.size(buffer) === 0) {
+          return next(index)
+        }
+
+        return Effect.flatMap(Effect.all(Chunk.map(buffer, sink.event)), () => next(index))
+      }
+
+      function next(index: number): Effect.Effect<R2, never, void> {
+        finished.delete(index)
+
+        const nextIndex = ++currentIndex
+
+        if (finished.has(nextIndex)) {
+          return onFinished(nextIndex, finished.get(nextIndex) as Chunk.Chunk<O>)
+        }
+
+        return Effect.unit
+      }
+
+      return Effect.asUnit(
+        Effect.all(
+          fxs.map((fx, index) =>
+            Effect.suspend(() => {
+              if (index === currentIndex) return Effect.flatMap(fx.run(sink), () => next(index))
+
+              let buffer: Chunk.Chunk<O> = Chunk.empty()
+              let isEmitting = false
+
+              return Effect.flatMap(
+                fx.run(
+                  Sink(
+                    (o) =>
+                      Effect.suspend(
+                        Effect.unifiedFn(() => {
+                          // The current index is emitting now
+                          if (isEmitting) {
+                            return sink.event(o)
+                          }
+
+                          // This index is ready to emit values
+                          if (index === currentIndex) {
+                            if (Chunk.size(buffer) === 0) return sink.event(o)
+
+                            // Drain the current buffer first
+                            const toEmit = Chunk.append(buffer, o)
+                            // Clear the buffer
+                            buffer = Chunk.empty()
+                            // Fast-path for remaining values
+                            isEmitting = true
+
+                            // Emit the values
+                            return Effect.all(Chunk.map(toEmit, sink.event))
+                          }
+
+                          // Otherwise, buffer the value
+                          buffer = Chunk.append(buffer, o)
+
+                          return Effect.unit
+                        }),
+                      ),
+                    sink.error,
+                  ),
+                ),
+                () => (isEmitting ? next(index) : onFinished(index, buffer)),
+              )
+            }),
+          ),
+          { concurrency: 'unbounded' },
+        ),
+      )
+    }),
+  )
+}

package/src/mergeConcurrently.test.ts

@@ -0,0 +1,20 @@
+import { millis } from '@effect/data/Duration'
+import { describe } from 'vitest'
+
+import { at } from './at.js'
+import { mergeAll } from './mergeAll.js'
+import { mergeConcurrently } from './mergeConcurrently.js'
+import { testCollectAll } from './test-utils.js'
+
+describe(__filename, () => {
+  describe(mergeConcurrently.name, () => {
+    testCollectAll(
+      'merges multiple streams together taking 1 value from each in order, but always the latest value from each stream',
+      mergeConcurrently(
+        at(1, millis(100)),
+        mergeAll(at(2, millis(0)), at(3, millis(30)), at(4, millis(60))),
+      ),
+      [1, 4],
+    )
+  })
+})

package/src/mergeConcurrently.ts

@@ -0,0 +1,57 @@
+import * as Effect from '@effect/io/Effect'
+import * as Fiber from '@effect/io/Fiber'
+
+import { Fx, Sink } from './Fx.js'
+import { empty } from './empty.js'
+
+export function mergeConcurrently<FXS extends ReadonlyArray<Fx<any, any, any>>>(
+  ...fxs: FXS
+): Fx<Fx.ResourcesOf<FXS[number]>, Fx.ErrorsOf<FXS[number]>, Fx.OutputOf<FXS[number]>> {
+  if (fxs.length === 0) return empty()
+  if (fxs.length === 1) return fxs[0]
+
+  return Fx(<R2>(sink: Sink<R2, Fx.ErrorsOf<FXS[number]>, Fx.OutputOf<FXS[number]>>) =>
+    Effect.gen(function* ($) {
+      let currentIndex = 0
+      const values = new Map<number, Fx.OutputOf<FXS[number]>>()
+      const fibers: Fiber.Fiber<never, void>[] = []
+
+      for (let i = 0; i < fxs.length; ++i) {
+        fibers[i] = yield* $(
+          Effect.fork(fxs[i].run(Sink((value) => onValue(i, value), sink.error))),
+        )
+      }
+
+      function emit(index: number): Effect.Effect<R2, never, void> {
+        if (index === currentIndex && values.has(index)) {
+          return Effect.gen(function* ($) {
+            // Send this value to the sink
+            yield* $(sink.event(values.get(index) as Fx.OutputOf<FXS[number]>))
+
+            // Interrupt the underlying Fiber
+            yield* $(Fiber.interruptFork(fibers[index]))
+
+            const next = ++currentIndex
+
+            // If there's a value for the next index, emit it
+            if (values.has(next)) {
+              yield* $(emit(next))
+            }
+          })
+        }
+
+        return Effect.unit
+      }
+
+      function onValue(index: number, value: Fx.OutputOf<FXS[number]>) {
+        return Effect.suspend(() => {
+          values.set(index, value)
+
+          return emit(index)
+        })
+      }
+
+      yield* $(Fiber.joinAll(fibers))
+    }),
+  )
+}

package/src/multicast.ts

@@ -1,11 +1,10 @@
 import type * as Context from '@effect/data/Context'
-import type { Trace } from '@effect/data/Debug'
 import { identity } from '@effect/data/Function'
 import type * as Cause from '@effect/io/Cause'
 import * as Effect from '@effect/io/Effect'
 import * as Fiber from '@effect/io/Fiber'
 
-import { FxTypeId, Traced } from './Fx.js'
+import { FxTypeId } from './Fx.js'
 import type { Fx, Sink } from './Fx.js'
 
 export function multicast<R, E, A>(fx: Fx<R, E, A>): Fx<R, E, A> {
@@ -24,8 +23,10 @@ export class MulticastFx<R, E, A> implements Fx<R, E, A>, Sink<never, E, A> {
     _A: identity,
   }
 
-  protected observers: Array<MulticastObserver<any, E, A>> = []
-  protected fiber: Fiber.RuntimeFiber<never, void> | undefined
+  /**@internal */
+  public observers: Array<MulticastObserver<any, E, A>> = []
+  /**@internal */
+  public fiber: Fiber.RuntimeFiber<never, void> | undefined
 
   constructor(readonly fx: Fx<R, E, A>) {
     this.run = this.run.bind(this)
@@ -39,40 +40,47 @@ export class MulticastFx<R, E, A> implements Fx<R, E, A>, Sink<never, E, A> {
     // eslint-disable-next-line @typescript-eslint/no-this-alias
     const that = this
 
-    return Effect.gen(function* ($) {
-      const context = yield* $(Effect.context<R2>())
-      const observer: MulticastObserver<R2, E, A> = { sink, context }
+    return Effect.flatMap(Effect.context<R2>(), (context) =>
+      Effect.suspend(() => {
+        const observer: MulticastObserver<R2, E, A> = { sink, context }
 
-      if (observers.push(observer) === 1) {
-        that.fiber = yield* $(Effect.forkDaemon(that.fx.run(that)))
-      }
+        const effects: Array<Effect.Effect<R, never, void>> = []
 
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      yield* $(Effect.ensuring(Fiber.await(that.fiber!), that.removeSink(sink)))
-    })
-  }
+        if (observers.push(observer) === 1) {
+          effects.push(
+            Effect.tap(Effect.forkDaemon(that.fx.run(that)), (fiber) =>
+              Effect.sync(() => (that.fiber = fiber)),
+            ),
+          )
+        }
 
-  readonly addTrace = (trace: Trace): Fx<R, E, A> => {
-    return Traced<R, E, A>(this.fx, trace)
+        effects.push(
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          Effect.suspend(() => Effect.ensuring(Fiber.await(that.fiber!), that.removeSink(sink))),
+        )
+
+        return Effect.all(effects)
+      }),
+    )
   }
 
   event(a: A) {
     if (this.observers.length === 0) {
-      return Effect.unit()
+      return Effect.unit
     }
 
     return Effect.suspend(() =>
-      Effect.forEachDiscard(this.observers.slice(0), (observer) => this.runEvent(observer, a)),
+      Effect.forEach(this.observers.slice(0), (observer) => this.runEvent(observer, a)),
     )
   }
 
   error(cause: Cause.Cause<E>) {
     if (this.observers.length === 0) {
-      return Effect.unit()
+      return Effect.unit
     }
 
     return Effect.suspend(() =>
-      Effect.forEachDiscard(this.observers.slice(0), (observer) => this.runError(observer, cause)),
+      Effect.forEach(this.observers.slice(0), (observer) => this.runError(observer, cause)),
     )
   }
 
@@ -94,7 +102,7 @@ export class MulticastFx<R, E, A> implements Fx<R, E, A>, Sink<never, E, A> {
     return Effect.suspend(() => {
       const { observers } = this
 
-      if (observers.length === 0) return Effect.unit()
+      if (observers.length === 0) return Effect.unit
 
       const index = observers.findIndex((o) => o.sink === sink)
 
@@ -111,7 +119,7 @@ export class MulticastFx<R, E, A> implements Fx<R, E, A>, Sink<never, E, A> {
         }
       }
 
-      return Effect.unit()
+      return Effect.unit
     })
   }
 }

package/src/never.ts

@@ -3,5 +3,5 @@ import * as Effect from '@effect/io/Effect'
 import { Fx } from './Fx.js'
 
 export function never<E = never, A = never>(): Fx<never, E, A> {
-  return Fx<never, E, A>(() => Effect.never())
+  return Fx<never, E, A>(() => Effect.never)
 }

package/src/observe.ts

@@ -11,22 +11,31 @@ export function observe<R, E, A, R2, E2>(
   fx: Fx<R, E, A>,
   f: (a: A) => Effect.Effect<R2, E2, void>,
 ): Effect.Effect<R | R2 | Scope, E | E2, void> {
-  return Effect.gen(function* ($) {
-    const deferred = yield* $(Deferred.make<E | E2, void>())
+  return Effect.flatMap(Deferred.make<E | E2, void>(), (deferred) => {
     const error = (cause: Cause.Cause<E | E2>) => Deferred.failCause(deferred, cause)
     const end = () => Deferred.succeed(deferred, undefined)
 
-    const fiber = yield* $(
+    return Effect.flatMap(
       Effect.forkScoped(
         Effect.flatMap(fx.run(Sink((a: A) => Effect.catchAllCause(f(a), error), error)), end),
       ),
+      (fiber) => Effect.flatMap(Deferred.await(deferred), () => Fiber.interruptFork(fiber)),
     )
-
-    yield* $(Deferred.await(deferred))
-    yield* $(Fiber.interruptFork(fiber))
   })
 }
 
 export function drain<R, E, A>(fx: Fx<R, E, A>): Effect.Effect<R | Scope, E, void> {
-  return observe(fx, () => Effect.unit())
+  return observe(fx, Effect.unit as any)
+}
+
+export function forkScoped<R, E, A>(
+  fx: Fx<R, E, A>,
+): Effect.Effect<R | Scope, never, Fiber.RuntimeFiber<E, void>> {
+  return Effect.forkScoped(drain(fx))
+}
+
+export function fork<R, E, A>(
+  fx: Fx<R, E, A>,
+): Effect.Effect<R | Scope, never, Fiber.RuntimeFiber<E, void>> {
+  return Effect.fork(drain(fx))
 }

package/src/onExit.ts

@@ -0,0 +1,13 @@
+import * as Effect from '@effect/io/Effect'
+import * as Exit from '@effect/io/Exit'
+
+import { Fx } from './Fx.js'
+
+export function onExit<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (exit: Exit.Exit<E, void>) => Effect.Effect<R2, E2, B>,
+): Fx<R | R2, E | E2, A> {
+  return Fx((sink) =>
+    Effect.onExit(fx.run(sink), (exit) => Effect.catchAllCause(f(exit), sink.error)),
+  )
+}

package/src/orElse.ts

@@ -0,0 +1,16 @@
+import * as Cause from '@effect/io/Cause'
+import * as Effect from '@effect/io/Effect'
+
+import { Fx } from './Fx.js'
+import { observe } from './observe.js'
+
+export function orElse<R, E, A, R2, E2, B>(
+  self: Fx<R, E, A>,
+  that: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
+): Fx<R | R2, E2, A | B> {
+  return Fx((sink) =>
+    Effect.catchAllCause(Effect.scoped(observe(self, sink.event)), (cause) =>
+      that(cause).run(sink),
+    ),
+  )
+}

package/src/promise.ts

@@ -26,14 +26,14 @@ export function tryCatchPromise<A, E>(
   f: () => Promise<A>,
   g: (error: unknown) => E,
 ): Fx<never, E, A> {
-  return fromEffect(Effect.tryCatchPromise(f, g))
+  return fromEffect(Effect.tryPromise({ try: f, catch: g }))
 }
 
 export function tryCatchPromiseInterrupt<A, E>(
   f: (signal: AbortSignal) => Promise<A>,
   g: (error: unknown) => E,
 ): Fx<never, E, A> {
-  return fromEffect(Effect.tryCatchPromiseInterrupt(f, g))
+  return fromEffect(Effect.tryPromiseInterrupt({ try: f, catch: g }))
 }
 
 export function promiseFx<R, E, A>(f: () => Promise<Fx<R, E, A>>): Fx<R, E, A> {
@@ -60,12 +60,12 @@ export function tryCatchPromiseFx<R, E, A, E2>(
   f: () => Promise<Fx<R, E, A>>,
   g: (error: unknown) => E2,
 ): Fx<R, E | E2, A> {
-  return fromFxEffect(Effect.tryCatchPromise(f, g))
+  return fromFxEffect(Effect.tryPromise({ try: f, catch: g }))
 }
 
 export function tryCatchPromiseInterruptFx<R, E, A, E2>(
   f: (signal: AbortSignal) => Promise<Fx<R, E, A>>,
   g: (error: unknown) => E2,
 ): Fx<R, E | E2, A> {
-  return fromFxEffect(Effect.tryCatchPromiseInterrupt(f, g))
+  return fromFxEffect(Effect.tryPromiseInterrupt({ try: f, catch: g }))
 }

package/src/provide.ts

@@ -12,7 +12,7 @@ export function provideContext<R, E, A>(
 ): Fx<never, E, A> {
   return Fx(
     <R2>(sink: Sink<R2, E, A>): Effect.Effect<R2, never, void> =>
-      Effect.contramapContext(fx.run(sink), (ctx) => Context.merge(ctx, context)),
+      Effect.mapInputContext(fx.run(sink), (ctx) => Context.merge(ctx, context)),
   )
 }
 
@@ -22,7 +22,7 @@ export function provideSomeContext<R, E, A, R2>(
 ): Fx<Exclude<R, R2>, E, A> {
   return Fx(
     <R3>(sink: Sink<R3, E, A>): Effect.Effect<Exclude<R, R2> | R3, never, void> =>
-      Effect.contramapContext(fx.run(sink), (ctx) =>
+      Effect.mapInputContext(fx.run(sink), (ctx) =>
         Context.merge(ctx as Context.Context<R | R3>, context),
       ),
   )
@@ -57,11 +57,13 @@ export function provideServiceEffect<R, E, A, I, S, R2, E2>(
 ): Fx<Exclude<R, I> | R2, E | E2, A> {
   return Fx(
     <R3>(sink: Sink<R3, E | E2, A>): Effect.Effect<Exclude<R, I> | R2 | R3, never, void> =>
-      Effect.matchCauseEffect(service, sink.error, (s) =>
-        Effect.contramapContext(fx.run(sink), (ctx) =>
-          Context.merge(ctx as Context.Context<R | R2 | R3>, Context.make(tag, s)),
-        ),
-      ),
+      Effect.matchCauseEffect(service, {
+        onFailure: sink.error,
+        onSuccess: (s) =>
+          Effect.mapInputContext(fx.run(sink), (ctx) =>
+            Context.merge(ctx as Context.Context<R | R2 | R3>, Context.make(tag, s)),
+          ),
+      }),
   )
 }