@typed/fx 1.6.2 → 1.8.0

package/src/internal/operator/filterMapEffect.ts

@@ -1,106 +0,0 @@
-import { dualWithTrace } from '@effect/data/Debug'
-
-import { BaseFx } from '@typed/fx/internal/BaseFx'
-import type { Fx } from '@typed/fx/internal/Fx'
-import { Sink } from '@typed/fx/internal/Fx'
-import type { Context, Scope } from '@typed/fx/internal/externals'
-import { Effect, Option } from '@typed/fx/internal/externals'
-
-export const filterMapEffect: {
-  <R, E, A, R2, E2, B>(self: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, Option.Option<B>>): Fx<
-    R | R2,
-    E | E2,
-    B
-  >
-
-  <A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, Option.Option<B>>): <R, E>(
-    self: Fx<R, E, A>,
-  ) => Fx<R | R2, E | E2, B>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <R, E, A, R2, E2, B>(
-      self: Fx<R, E, A>,
-      f: (a: A) => Effect.Effect<R2, E2, Option.Option<B>>,
-    ): Fx<R | R2, E | E2, B> =>
-      new FilterMapEffectFx(self, f).traced(trace),
-)
-
-export const filterEffect: {
-  <R, E, A, R2, E2>(self: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, boolean>): Fx<
-    R | R2,
-    E | E2,
-    A
-  >
-
-  <A, R2, E2>(f: (a: A) => Effect.Effect<R2, E2, boolean>): <R, E>(
-    self: Fx<R, E, A>,
-  ) => Fx<R | R2, E | E2, A>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <R, E, A, R2, E2>(
-      self: Fx<R, E, A>,
-      f: (a: A) => Effect.Effect<R2, E2, boolean>,
-    ): Fx<R | R2, E | E2, A> =>
-      filterMapEffect(self, (a) =>
-        Effect.map(f(a), (b) => (b ? Option.some(a) : Option.none())),
-      ).traced(trace),
-)
-
-export const filterNotEffect: {
-  <R, E, A, R2, E2>(self: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, boolean>): Fx<
-    R | R2,
-    E | E2,
-    A
-  >
-
-  <A, R2, E2>(f: (a: A) => Effect.Effect<R2, E2, boolean>): <R, E>(
-    self: Fx<R, E, A>,
-  ) => Fx<R | R2, E | E2, A>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <R, E, A, R2, E2>(
-      self: Fx<R, E, A>,
-      f: (a: A) => Effect.Effect<R2, E2, boolean>,
-    ): Fx<R | R2, E | E2, A> =>
-      filterMapEffect(self, (a) =>
-        Effect.map(f(a), (b) => (b ? Option.none() : Option.some(a))),
-      ).traced(trace),
-)
-
-export class FilterMapEffectFx<R, E, A, R2, E2, B> extends BaseFx<R | R2, E | E2, B> {
-  readonly name = 'FilterMapEffect' as const
-
-  constructor(
-    readonly fx: Fx<R, E, A>,
-    readonly f: (a: A) => Effect.Effect<R2, E2, Option.Option<B>>,
-  ) {
-    super()
-  }
-
-  run(sink: Sink<E | E2, B>): Effect.Effect<R | R2 | Scope.Scope, never, unknown> {
-    return Effect.contextWithEffect((ctx: Context.Context<R | R2 | Scope.Scope>) => {
-      const lock = Effect.unsafeMakeSemaphore(1).withPermits(1)
-
-      return this.fx.run(
-        Sink(
-          (a) =>
-            lock(
-              Effect.provideContext(
-                Effect.matchCauseEffect(
-                  this.f(a),
-                  sink.error,
-                  Option.match(Effect.unit, sink.event),
-                ),
-                ctx,
-              ),
-            ),
-          sink.error,
-          sink.end,
-        ),
-      )
-    })
-  }
-}

package/src/internal/operator/flatMap.ts

@@ -1,71 +0,0 @@
-import type { Context } from '@effect/data/Context'
-import { dualWithTrace } from '@effect/data/Debug'
-import { identity, pipe } from '@effect/data/Function'
-import * as Effect from '@effect/io/Effect'
-import type { Scope } from '@effect/io/Scope'
-
-import { BaseFx } from '@typed/fx/internal/BaseFx'
-import type { Fx } from '@typed/fx/internal/Fx'
-import { Sink } from '@typed/fx/internal/Fx'
-import { withRefCounter } from '@typed/fx/internal/RefCounter'
-import { fromEffect } from '@typed/fx/internal/conversion/fromEffect'
-
-export const flatMap: {
-  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Fx<R2, E2, B>): Fx<
-    Exclude<R, Scope> | Exclude<R2, Scope>,
-    E | E2,
-    B
-  >
-
-  <A, R2, E2, B>(f: (a: A) => Fx<R2, E2, B>): <R, E>(
-    fx: Fx<R, E, A>,
-  ) => Fx<Exclude<R, Scope> | Exclude<R2, Scope>, E | E2, B>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Fx<R2, E2, B>) =>
-      FlatMapFx.make(fx, f).traced(trace),
-)
-
-export const flatten: <R, E, R2, E2, A>(fx: Fx<R, E, Fx<R2, E2, A>>) => Fx<R | R2, E | E2, A> =
-  flatMap(identity)
-
-export const flatMapEffect =
-  <A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>) =>
-  <R, E>(fx: Fx<R, E, A>) =>
-    FlatMapFx.make(fx, (a) => fromEffect(f(a)))
-
-class FlatMapFx<R, E, A, R2, E2, B> extends BaseFx<R | R2, E | E2, B> {
-  readonly name = 'FlatMap' as const
-
-  constructor(readonly fx: Fx<R, E, A>, readonly f: (a: A) => Fx<R2, E2, B>) {
-    super()
-  }
-
-  run(sink: Sink<E | E2, B>): Effect.Effect<R | R2 | Scope, never, unknown> {
-    return Effect.contextWithEffect((context: Context<R | R2 | Scope>) =>
-      withRefCounter(
-        // Start with 1 to account for the outer Fx
-        1,
-        (counter) =>
-          this.fx.run(
-            Sink(
-              (a) =>
-                pipe(
-                  counter.increment,
-                  Effect.zipRight(counter.refCounted(this.f(a), sink, Effect.unit)),
-                  Effect.forkScoped,
-                  Effect.provideContext(context),
-                ),
-              sink.error,
-              () => Effect.provideContext(counter.decrement, context),
-            ),
-          ),
-        sink.end,
-      ),
-    )
-  }
-
-  static make = <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Fx<R2, E2, B>) =>
-    new FlatMapFx(fx, f)
-}

package/src/internal/operator/flatMapCause.ts

@@ -1,56 +0,0 @@
-import { dualWithTrace } from '@effect/data/Debug'
-import { pipe } from '@effect/data/Function'
-
-import { BaseFx } from '@typed/fx/internal/BaseFx'
-import type { Fx } from '@typed/fx/internal/Fx'
-import { Sink } from '@typed/fx/internal/Fx'
-import { withRefCounter } from '@typed/fx/internal/RefCounter'
-import type { Cause, Context, Scope } from '@typed/fx/internal/externals'
-import { Effect } from '@typed/fx/internal/externals'
-
-export const flatMapCause: {
-  <E, R2, E2, B>(f: (e: Cause.Cause<E>) => Fx<R2, E2, B>): <R, A>(
-    self: Fx<R, E, A>,
-  ) => Fx<R | R2, E | E2, A | B>
-  <R, E, A, R2, E2, B>(self: Fx<R, E, A>, f: (e: Cause.Cause<E>) => Fx<R2, E2, B>): Fx<
-    R | R2,
-    E | E2,
-    A | B
-  >
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <R, E, A, R2, E2, B>(self: Fx<R, E, A>, f: (e: Cause.Cause<E>) => Fx<R2, E2, B>) =>
-      new FlatMapCauseFx(self, f).traced(trace),
-)
-
-export class FlatMapCauseFx<R, E, A, R2, E2, B> extends BaseFx<R | R2, E | E2, A | B> {
-  readonly name = 'FlatMapCause' as const
-
-  constructor(readonly self: Fx<R, E, A>, readonly f: (e: Cause.Cause<E>) => Fx<R2, E2, B>) {
-    super()
-  }
-
-  run(sink: Sink<E | E2, A | B>): Effect.Effect<R | R2 | Scope.Scope, never, unknown> {
-    return Effect.contextWithEffect((ctx: Context.Context<R | R2 | Scope.Scope>) =>
-      withRefCounter(
-        1,
-        (counter) =>
-          this.self.run(
-            Sink(
-              sink.event,
-              (cause) =>
-                pipe(
-                  counter.increment,
-                  Effect.flatMap(() => counter.refCounted(this.f(cause), sink, Effect.unit)),
-                  Effect.forkScoped,
-                  Effect.provideContext(ctx),
-                ),
-              () => Effect.provideContext(counter.decrement, ctx),
-            ),
-          ),
-        sink.end,
-      ),
-    )
-  }
-}

package/src/internal/operator/flatMapConcurrently.ts

@@ -1,44 +0,0 @@
-import { dualWithTrace } from '@effect/data/Debug'
-
-import type { Fx } from '@typed/fx/internal/Fx'
-import { suspend } from '@typed/fx/internal/constructor/suspend'
-import { Effect } from '@typed/fx/internal/externals'
-import { withPermit } from '@typed/fx/internal/locking/withPermit'
-import { flatMap } from '@typed/fx/internal/operator/flatMap'
-
-export const flatMapConcurrently: {
-  <R, E, A, R2, E2, B>(self: Fx<R, E, A>, concurrency: number, f: (value: A) => Fx<R2, E2, B>): Fx<
-    R | R2,
-    E | E2,
-    B
-  >
-  <A, R2, E2, B>(concurrency: number, f: (value: A) => Fx<R2, E2, B>): <R, E>(
-    self: Fx<R, E, A>,
-  ) => Fx<R | R2, E | E2, B>
-} = dualWithTrace(
-  3,
-  (trace) =>
-    <R, E, A, R2, E2, B>(
-      self: Fx<R, E, A>,
-      concurrency: number,
-      f: (value: A) => Fx<R2, E2, B>,
-    ): Fx<R | R2, E | E2, B> =>
-      suspend(() => {
-        const semaphore = Effect.unsafeMakeSemaphore(concurrency)
-
-        return flatMap(self, (a) => withPermit(f(a), semaphore))
-      }).traced(trace),
-)
-
-export const concatMap: {
-  <R, E, A, R2, E2, B>(self: Fx<R, E, A>, f: (value: A) => Fx<R2, E2, B>): Fx<R | R2, E | E2, B>
-  <A, R2, E2, B>(f: (value: A) => Fx<R2, E2, B>): <R, E>(self: Fx<R, E, A>) => Fx<R | R2, E | E2, B>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <R, E, A, R2, E2, B>(
-      self: Fx<R, E, A>,
-      f: (value: A) => Fx<R2, E2, B>,
-    ): Fx<R | R2, E | E2, B> =>
-      flatMapConcurrently(self, 1, f).traced(trace),
-)

package/src/internal/operator/flip.ts

@@ -1,38 +0,0 @@
-import { methodWithTrace } from '@effect/data/Debug'
-import { pipe } from '@effect/data/Function'
-
-import { BaseFx } from '@typed/fx/internal/BaseFx'
-import type { Fx } from '@typed/fx/internal/Fx'
-import { Sink } from '@typed/fx/internal/Fx'
-import { Cause, Either, Effect, Scope } from '@typed/fx/internal/externals'
-
-export const flip: <R, E, A>(self: Fx<R, E, A>) => Fx<R, A, E> = methodWithTrace(
-  (trace) =>
-    <R, E, A>(self: Fx<R, E, A>) =>
-      new FlipFx(self).traced(trace),
-)
-
-export class FlipFx<R, E, A> extends BaseFx<R, A, E> {
-  readonly name = 'Flip'
-
-  constructor(readonly self: Fx<R, E, A>) {
-    super()
-  }
-
-  run(sink: Sink<A, E>): Effect.Effect<R | Scope.Scope, never, unknown> {
-    return this.self.run(
-      Sink(
-        (value) => sink.error(Cause.fail(value)),
-        (cause) =>
-          pipe(
-            Cause.failureOrCause(cause),
-            Either.match(
-              (failure) => sink.event(failure),
-              (cause) => sink.error(cause),
-            ),
-          ),
-        sink.end,
-      ),
-    )
-  }
-}

package/src/internal/operator/hold.ts

@@ -1,158 +0,0 @@
-import { dualWithTrace, methodWithTrace } from '@effect/data/Debug'
-import { pipe } from '@effect/data/Function'
-import * as Option from '@effect/data/Option'
-import type * as Cause from '@effect/io/Cause'
-import * as Effect from '@effect/io/Effect'
-import * as Fiber from '@effect/io/Fiber'
-import type { Scope } from '@effect/io/Scope'
-
-import { MulticastFx } from './multicast.js'
-
-import type { Fx, Sink } from '@typed/fx/internal/Fx'
-import { Mutable } from '@typed/fx/internal/Mutable'
-import { asap } from '@typed/fx/internal/RefCounter'
-
-export const hold: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A> = methodWithTrace(
-  (trace) =>
-    <R, E, A>(fx: Fx<R, E, A>) =>
-      new HoldFx(fx, Mutable(Option.none()), 'Hold', false).traced(trace),
-)
-
-export const hold_: {
-  <R, E, A>(fx: Fx<R, E, A>, value: Mutable<Option.Option<A>>): Fx<R, E, A>
-  <A>(value: Mutable<Option.Option<A>>): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, A>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <R, E, A>(fx: Fx<R, E, A>, value: Mutable<Option.Option<A>>): Fx<R, E, A> =>
-      new HoldFx(fx, value, 'Hold', false).traced(trace),
-)
-
-export class HoldFx<R, E, A, Tag extends string>
-  extends MulticastFx<R, E, A, Tag>
-  implements Fx<R, E, A>
-{
-  protected pendingSinks: Array<readonly [Sink<E, A>, Array<A>]> = []
-  protected scheduledFiber: Fiber.RuntimeFiber<any, any> | undefined = undefined
-
-  constructor(
-    readonly fx: Fx<R, E, A>,
-    readonly current: Mutable<Option.Option<A>>,
-    readonly tag: Tag,
-    readonly sync: boolean,
-  ) {
-    super(fx, tag, sync)
-
-    this.event = this.event.bind(this)
-    this.error = this.error.bind(this)
-    this.end = this.end.bind(this)
-  }
-
-  run(sink: Sink<E, A>): Effect.Effect<Scope | R, never, void> {
-    return Effect.suspend(() => {
-      if (Option.isSome(this.current.get())) {
-        return pipe(
-          this.scheduleFlush(sink),
-          Effect.flatMap(() => super.run(sink)),
-        )
-      }
-
-      return super.run(sink)
-    })
-  }
-
-  event(a: A) {
-    return Effect.suspend(() => {
-      this.addValue(a)
-
-      return pipe(
-        this.flushPending(),
-        Effect.flatMap(() => super.event(a)),
-      )
-    })
-  }
-
-  error(cause: Cause.Cause<E>) {
-    return Effect.suspend(() =>
-      pipe(
-        this.flushPending(),
-        Effect.flatMap(() => super.error(cause)),
-      ),
-    )
-  }
-
-  end() {
-    return Effect.suspend(() =>
-      pipe(
-        this.flushPending(),
-        Effect.flatMap(() => super.end()),
-      ),
-    )
-  }
-
-  protected scheduleFlush(sink: Sink<E, A>) {
-    return Effect.suspend(() => {
-      this.pendingSinks.push([
-        sink,
-        pipe(
-          this.current.get(),
-          Option.match(
-            () => [],
-            (a) => [a],
-          ),
-        ),
-      ])
-
-      const interrupt = this.scheduledFiber
-        ? Fiber.interruptFork(this.scheduledFiber)
-        : Effect.unit()
-
-      this.scheduledFiber = undefined
-
-      return pipe(
-        interrupt,
-        Effect.flatMap(() => this.flushPending()),
-        this.sync ? Effect.forkScoped : Effect.scheduleForked(asap),
-        Effect.tap((f) =>
-          Effect.sync(() => {
-            this.scheduledFiber = f
-          }),
-        ),
-      )
-    })
-  }
-
-  protected flushPending() {
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    const that = this
-
-    if (this.pendingSinks.length === 0) {
-      return Effect.unit()
-    }
-
-    const pendingSinks = this.pendingSinks
-
-    this.pendingSinks = []
-
-    return Effect.gen(function* ($) {
-      for (const [sink, events] of pendingSinks) {
-        const observer = that.findObserver(sink)
-
-        if (!observer) continue
-
-        for (const event of events) {
-          yield* $(that.runEvent(event, observer))
-        }
-      }
-    })
-  }
-
-  protected findObserver(sink: Sink<E, A>) {
-    return this.observers.find((x) => x.sink === sink)
-  }
-
-  protected addValue(a: A) {
-    this.current.set(Option.some(a))
-    this.pendingSinks.forEach(([, events]) => events.push(a))
-  }
-}

package/src/internal/operator/index.ts

@@ -1,53 +0,0 @@
-export * from './continueWith.js'
-export * from './debounce.js'
-export * from './delay.js'
-export * from './ensuring.js'
-export * from './exhaustMap.js'
-export * from './exhaustMapLatest.js'
-export * from './filterMap.js'
-export * from './filterMapEffect.js'
-export * from './flatMap.js'
-export * from './flatMapCause.js'
-export * from './flatMapConcurrently.js'
-export * from './flip.js'
-export * from './hold.js'
-export * from './map.js'
-export * from './mapAccum.js'
-export * from './mapBoth.js'
-export * from './mapCause.js'
-export * from './mapEither.js'
-export * from './mapError.js'
-export * from './mapSome.js'
-export * from './merge.js'
-export * from './mergeRace.js'
-export * from './multicast.js'
-export * from './onDone.js'
-export * from './onDoneCause.js'
-export * from './onError.js'
-export * from './onErrorCause.js'
-export * from './onExit.js'
-export * from './onInterrupt.js'
-export * from './onNonInterruptCause.js'
-export * from './option.js'
-export * from './race.js'
-export * from './sandbox.js'
-export * from './scan.js'
-export * from './scanEffect.js'
-export * from './separate.js'
-export * from './skipRepeats.js'
-export * from './snapshot.js'
-export * from './startWith.js'
-export * from './summarized.js'
-export * from './supervised.js'
-export * from './switchMap.js'
-export * from './tap.js'
-export * from './tapCause.js'
-export * from './tapDefect.js'
-export * from './tapEither.js'
-export * from './tapError.js'
-export * from './tapSome.js'
-export * from './throttle.js'
-export * from './traced.js'
-export * from './unrefineWith.js'
-export * from './unsandbox.js'
-export * from './zipItems.js'

package/src/internal/operator/map.ts

@@ -1,42 +0,0 @@
-import { dualWithTrace } from '@effect/data/Debug'
-
-import { Effect, Scope } from '../externals.js'
-
-import { BaseFx } from '@typed/fx/internal/BaseFx'
-import { Sink } from '@typed/fx/internal/Fx'
-import type { Fx } from '@typed/fx/internal/Fx'
-
-export const map: {
-  <R, E, A, B>(fx: Fx<R, E, A>, f: (a: A) => B): Fx<R, E, B>
-  <A, B>(f: (a: A) => B): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, B>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <R, E, A, B>(fx: Fx<R, E, A>, f: (a: A) => B) =>
-      MapFx.make(fx, f).traced(trace),
-)
-
-export class MapFx<R, E, A, B> extends BaseFx<R, E, B> {
-  readonly name = 'Map' as const
-
-  constructor(readonly fx: Fx<R, E, A>, readonly f: (a: A) => B) {
-    super()
-  }
-
-  run(sink: Sink<E, B>): Effect.Effect<R | Scope.Scope, never, unknown> {
-    return this.fx.run(Sink((a) => sink.event(this.f(a)), sink.error, sink.end))
-  }
-
-  static make<R, E, A, B>(fx: Fx<R, E, A>, f: (a: A) => B): Fx<R, E, B> {
-    // Covariant fusion
-    if (isMap(fx)) {
-      return new MapFx(fx.fx, (a) => f(fx.f(a)))
-    }
-
-    return new MapFx(fx, f)
-  }
-}
-
-export function isMap<R, E, A>(fx: Fx<R, E, A>): fx is MapFx<R, E, unknown, A> {
-  return fx instanceof MapFx
-}

package/src/internal/operator/mapAccum.ts

@@ -1,54 +0,0 @@
-import { dualWithTrace } from '@effect/data/Debug'
-
-import { BaseFx } from '@typed/fx/internal/BaseFx'
-import type { Fx, Sink } from '@typed/fx/internal/Fx'
-import { Effect, Scope } from '@typed/fx/internal/externals'
-
-export const mapAccum: {
-  <R, E, A, B, C>(fx: Fx<R, E, A>, initial: B, f: (acc: B, a: A) => readonly [C, B]): Fx<R, E, C>
-  <A, B, C>(initial: B, f: (acc: B, a: A) => readonly [C, B]): <R, E>(
-    fx: Fx<R, E, A>,
-  ) => Fx<R, E, C>
-} = dualWithTrace(
-  3,
-  (trace) =>
-    <R, E, A, B, C>(fx: Fx<R, E, A>, initial: B, f: (acc: B, a: A) => readonly [C, B]) =>
-      new MapAccumFx(fx, initial, f).traced(trace),
-)
-
-export class MapAccumFx<R, E, A, B, C> extends BaseFx<R, E, C> {
-  readonly name = 'MapAccum'
-
-  constructor(
-    readonly fx: Fx<R, E, A>,
-    readonly initial: B,
-    readonly f: (acc: B, a: A) => readonly [C, B],
-  ) {
-    super()
-  }
-
-  run(sink: Sink<E, C>): Effect.Effect<R | Scope.Scope, never, unknown> {
-    return Effect.suspend(() => this.fx.run(new MapAccumSink(sink, this.initial, this.f)))
-  }
-}
-
-export class MapAccumSink<E, A, B, C> implements Sink<E, A> {
-  protected acc: B = this.initial
-
-  constructor(
-    readonly sink: Sink<E, C>,
-    readonly initial: B,
-    readonly f: (acc: B, a: A) => readonly [C, B],
-  ) {}
-
-  event(value: A) {
-    return Effect.suspend(() => {
-      const [c, b] = this.f(this.acc, value)
-      this.acc = b
-      return this.sink.event(c)
-    })
-  }
-
-  error: Sink<E, A>['error'] = this.sink.error
-  end = this.sink.end
-}

package/src/internal/operator/mapBoth.ts

@@ -1,57 +0,0 @@
-import { dualWithTrace } from '@effect/data/Debug'
-
-import { BaseFx } from '@typed/fx/internal/BaseFx'
-import { Sink } from '@typed/fx/internal/Fx'
-import type { Fx } from '@typed/fx/internal/Fx'
-import { Effect, Cause, Scope } from '@typed/fx/internal/externals'
-import { isMap } from '@typed/fx/internal/operator/map'
-
-export const mapBoth: {
-  <R, E, E2, A, B>(fx: Fx<R, E, A>, f: (a: E) => E2, g: (a: A) => B): Fx<R, E2, B>
-  <E, E2, A, B>(f: (a: E) => E2, g: (a: A) => B): <R>(fx: Fx<R, E, A>) => Fx<R, E2, B>
-} = dualWithTrace(
-  3,
-  (trace) =>
-    <R, E, E2, A, B>(fx: Fx<R, E, A>, f: (a: E) => E2, g: (a: A) => B) =>
-      MapBothFx.make(fx, f, g).traced(trace),
-)
-
-export class MapBothFx<R, E, E2, A, B> extends BaseFx<R, E2, B> {
-  readonly name = 'MapBoth' as const
-
-  constructor(readonly fx: Fx<R, E, A>, readonly f: (a: E) => E2, readonly g: (a: A) => B) {
-    super()
-  }
-
-  run(sink: Sink<E2, B>): Effect.Effect<R | Scope.Scope, never, unknown> {
-    return this.fx.run(
-      Sink(
-        (a) => sink.event(this.g(a)),
-        (e) => sink.error(Cause.map(e, this.f)),
-        sink.end,
-      ),
-    )
-  }
-
-  static make<R, E, E2, A, B>(fx: Fx<R, E, A>, f: (e: E) => E2, g: (a: A) => B): Fx<R, E2, B> {
-    // Covariant fusion
-    if (isMap(fx)) {
-      return new MapBothFx(fx.fx, f, (a) => g(fx.f(a)))
-    }
-
-    // Bicovariant fusion
-    if (isBimap(fx)) {
-      return new MapBothFx(
-        fx.fx,
-        (e) => f(fx.f(e)),
-        (a) => g(fx.g(a)),
-      )
-    }
-
-    return new MapBothFx(fx, f, g)
-  }
-}
-
-export function isBimap<R, E, A>(fx: Fx<R, E, A>): fx is MapBothFx<R, unknown, E, unknown, A> {
-  return fx instanceof MapBothFx
-}