@typed/fx 1.6.2 → 1.8.0

package/src/internal/logging/logTraceCauseMessage.ts

@@ -1,16 +0,0 @@
-import { dualWithTrace } from '@effect/data/Debug'
-
-import type { Fx } from '@typed/fx/internal/Fx'
-import { fromEffect } from '@typed/fx/internal/conversion/fromEffect'
-import type { Cause } from '@typed/fx/internal/externals'
-import { Effect } from '@typed/fx/internal/externals'
-
-export const logTraceCauseMessage: {
-  <E>(message: string, cause: Cause.Cause<E>): Fx<never, never, void>
-  <E>(cause: Cause.Cause<E>): (message: string) => Fx<never, never, void>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <E>(message: string, cause: Cause.Cause<E>) =>
-      fromEffect(Effect.logTraceCauseMessage(message, cause)).traced(trace),
-)

package/src/internal/logging/logWarning.ts

@@ -1,9 +0,0 @@
-import { methodWithTrace } from '@effect/data/Debug'
-
-import type { Fx } from '@typed/fx/internal/Fx'
-import { fromEffect } from '@typed/fx/internal/conversion/fromEffect'
-import { Effect } from '@typed/fx/internal/externals'
-
-export const logWarning: (message: string) => Fx<never, never, void> = methodWithTrace(
-  (trace) => (message: string) => fromEffect(Effect.logWarning(message)).traced(trace),
-)

package/src/internal/logging/logWarningCause.ts

@@ -1,13 +0,0 @@
-import { methodWithTrace } from '@effect/data/Debug'
-
-import type { Fx } from '@typed/fx/internal/Fx'
-import { fromEffect } from '@typed/fx/internal/conversion/fromEffect'
-import type { Cause } from '@typed/fx/internal/externals'
-import { Effect } from '@typed/fx/internal/externals'
-
-export const logWarningCause: <E>(cause: Cause.Cause<E>) => Fx<never, never, void> =
-  methodWithTrace(
-    (trace) =>
-      <E>(cause: Cause.Cause<E>) =>
-        fromEffect(Effect.logWarningCause(cause)).traced(trace),
-  )

package/src/internal/logging/logWarningCauseMessage.ts

@@ -1,16 +0,0 @@
-import { dualWithTrace } from '@effect/data/Debug'
-
-import type { Fx } from '@typed/fx/internal/Fx'
-import { fromEffect } from '@typed/fx/internal/conversion/fromEffect'
-import type { Cause } from '@typed/fx/internal/externals'
-import { Effect } from '@typed/fx/internal/externals'
-
-export const logWarningCauseMessage: {
-  <E>(message: string, cause: Cause.Cause<E>): Fx<never, never, void>
-  <E>(cause: Cause.Cause<E>): (message: string) => Fx<never, never, void>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <E>(message: string, cause: Cause.Cause<E>) =>
-      fromEffect(Effect.logWarningCauseMessage(message, cause)).traced(trace),
-)

package/src/internal/metric/index.ts

@@ -1,4 +0,0 @@
-export * from './tagged.js'
-export * from './taggedWithLabels.js'
-export * from './taggedWithLabelSet.js'
-export * from './withMetric.js'

package/src/internal/metric/tagged.ts

@@ -1,14 +0,0 @@
-import { dualWithTrace } from '@effect/data/Debug'
-
-import type { Fx } from '@typed/fx/internal/Fx'
-import { Effect } from '@typed/fx/internal/externals'
-
-export const tagged: {
-  (key: string, value: string): <R, E, A>(self: Fx<R, E, A>) => Fx<R, E, A>
-  <R, E, A>(self: Fx<R, E, A>, key: string, value: string): Fx<R, E, A>
-} = dualWithTrace(
-  3,
-  (trace) =>
-    <R, E, A>(self: Fx<R, E, A>, key: string, value: string) =>
-      self.transform(Effect.tagged(key, value)).traced(trace),
-)

package/src/internal/metric/taggedWithLabelSet.ts

@@ -1,16 +0,0 @@
-import { dualWithTrace } from '@effect/data/Debug'
-import type * as HashSet from '@effect/data/HashSet'
-import type * as MetricLabel from '@effect/io/Metric/Label'
-
-import type { Fx } from '@typed/fx/internal/Fx'
-import { Effect } from '@typed/fx/internal/externals'
-
-export const taggedWithLabelSet: {
-  (labels: HashSet.HashSet<MetricLabel.MetricLabel>): <R, E, A>(self: Fx<R, E, A>) => Fx<R, E, A>
-  <R, E, A>(self: Fx<R, E, A>, labels: HashSet.HashSet<MetricLabel.MetricLabel>): Fx<R, E, A>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <R, E, A>(self: Fx<R, E, A>, labels: HashSet.HashSet<MetricLabel.MetricLabel>) =>
-      self.transform(Effect.taggedWithLabelSet(labels)).traced(trace),
-)

package/src/internal/metric/taggedWithLabels.ts

@@ -1,15 +0,0 @@
-import { dualWithTrace } from '@effect/data/Debug'
-import type * as MetricLabel from '@effect/io/Metric/Label'
-
-import type { Fx } from '@typed/fx/internal/Fx'
-import { Effect } from '@typed/fx/internal/externals'
-
-export const taggedWithLabels: {
-  (labels: Iterable<MetricLabel.MetricLabel>): <R, E, A>(self: Fx<R, E, A>) => Fx<R, E, A>
-  <R, E, A>(self: Fx<R, E, A>, labels: Iterable<MetricLabel.MetricLabel>): Fx<R, E, A>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <R, E, A>(self: Fx<R, E, A>, labels: Iterable<MetricLabel.MetricLabel>) =>
-      self.transform(Effect.taggedWithLabels(labels)).traced(trace),
-)

package/src/internal/metric/withMetric.ts

@@ -1,37 +0,0 @@
-import { dualWithTrace } from '@effect/data/Debug'
-import type * as Metric from '@effect/io/Metric'
-
-import { BaseFx } from '@typed/fx/internal/BaseFx'
-import type { Fx } from '@typed/fx/internal/Fx'
-import { Sink } from '@typed/fx/internal/Fx'
-import { Effect, pipe } from '@typed/fx/internal/externals'
-
-export const withMetric: {
-  <Type, In, Out>(metric: Metric.Metric<Type, In, Out>): <R, E, A extends In>(
-    self: Fx<R, E, A>,
-  ) => Fx<R, E, A>
-  <R, E, A extends In, Type, In, Out>(self: Fx<R, E, A>, metric: Metric.Metric<Type, In, Out>): Fx<
-    R,
-    E,
-    A
-  >
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <R, E, A extends In, Type, In, Out>(self: Fx<R, E, A>, metric: Metric.Metric<Type, In, Out>) =>
-      new WithMetricFx(self, metric).traced(trace),
-)
-
-class WithMetricFx<R, E, A extends In, Type, In, Out> extends BaseFx<R, E, A> {
-  readonly name = 'WithMetric'
-
-  constructor(readonly self: Fx<R, E, A>, readonly metric: Metric.Metric<Type, In, Out>) {
-    super()
-  }
-
-  run(sink: Sink<E, A>) {
-    return this.self.run(
-      Sink((a) => pipe(sink.event(a), Effect.as(a), this.metric), sink.error, sink.end),
-    )
-  }
-}

package/src/internal/operator/continueWith.ts

@@ -1,36 +0,0 @@
-import { dual } 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 type { Context } from '@typed/fx/internal/externals'
-
-export const continueWith: {
-  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: () => Fx<R2, E2, B>): Fx<R | R2, E | E2, A | B>
-
-  <R2, E2, B>(f: () => Fx<R2, E2, B>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A | B>
-} = dual(
-  2,
-  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: () => Fx<R2, E2, B>): Fx<R | R2, E | E2, A | B> =>
-    new ContinueWithFx(fx, f),
-)
-
-export class ContinueWithFx<R, E, A, R2, E2, B> extends BaseFx<R | R2, E | E2, A | B> {
-  readonly name = 'ContinueWith'
-
-  constructor(readonly fx: Fx<R, E, A>, readonly f: () => Fx<R2, E2, B>) {
-    super()
-  }
-
-  run(sink: Sink<E | E2, A | B>): Effect.Effect<R | R2 | Scope, never, void> {
-    return Effect.contextWithEffect((ctx: Context.Context<R | R2 | Scope>) =>
-      this.fx.run(
-        Sink(sink.event, sink.error, () =>
-          Effect.suspend(() => Effect.provideContext(this.f().run(sink), ctx)),
-        ),
-      ),
-    )
-  }
-}

package/src/internal/operator/debounce.ts

@@ -1,69 +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 { withRefCounter } from '@typed/fx/internal/RefCounter'
-import type { Duration } from '@typed/fx/internal/externals'
-import { Cause, Effect, Fiber, pipe, Scope } from '@typed/fx/internal/externals'
-
-export const debounce: {
-  <R, E, A>(self: Fx<R, E, A>, duration: Duration.Duration): Fx<R, E, A>
-  (duration: Duration.Duration): <R, E, A>(self: Fx<R, E, A>) => Fx<R, E, A>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <R, E, A>(self: Fx<R, E, A>, duration: Duration.Duration): Fx<R, E, A> =>
-      new DebounceFx(self, duration).traced(trace),
-)
-
-export class DebounceFx<R, E, A> extends BaseFx<R, E, A> {
-  readonly name = 'Debounce' as const
-
-  constructor(readonly self: Fx<R, E, A>, readonly duration: Duration.Duration) {
-    super()
-  }
-
-  run(sink: Sink<E, A>): Effect.Effect<R | Scope.Scope, never, unknown> {
-    return withRefCounter(
-      1,
-      (counter, scope) => {
-        let scheduledFiber: Fiber.RuntimeFiber<never, unknown> | undefined
-
-        return this.self.run(
-          Sink(
-            (a: A) =>
-              Effect.suspend(() =>
-                pipe(
-                  scheduledFiber ? Fiber.interrupt(scheduledFiber) : counter.increment,
-                  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-                  Effect.flatMap((_: unknown) =>
-                    pipe(
-                      sink.event(a),
-                      Effect.delay(this.duration),
-                      Effect.interruptible,
-                      Effect.zipRight(counter.decrement),
-                      Effect.uninterruptible,
-                      Effect.onError((cause) =>
-                        Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
-                      ),
-                      Effect.forkScoped,
-                      Effect.tap((fiber) =>
-                        Effect.sync(() => {
-                          scheduledFiber = fiber
-                        }),
-                      ),
-                      Effect.provideService(Scope.Scope, scope),
-                    ),
-                  ),
-                ),
-              ),
-            sink.error,
-            () => Effect.provideService(counter.decrement, Scope.Scope, scope),
-          ),
-        )
-      },
-      sink.end,
-    )
-  }
-}

package/src/internal/operator/delay.ts

@@ -1,33 +0,0 @@
-import { dualWithTrace } from '@effect/data/Debug'
-import type { Duration } from '@effect/data/Duration'
-import * as Effect from '@effect/io/Effect'
-
-import { Scope } from '../externals.js'
-
-import { BaseFx } from '@typed/fx/internal/BaseFx'
-import type { Fx } from '@typed/fx/internal/Fx'
-import { Sink } from '@typed/fx/internal/Fx'
-
-export const delay: {
-  <R, E, A>(fx: Fx<R, E, A>, duration: Duration): Fx<R, E, A>
-  (duration: Duration): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <R, E, A>(fx: Fx<R, E, A>, duration: Duration): Fx<R, E, A> =>
-      new DelayFx(fx, duration).traced(trace),
-)
-
-export class DelayFx<R, E, A> extends BaseFx<R, E, A> {
-  readonly name = 'Delay' as const
-
-  constructor(readonly fx: Fx<R, E, A>, readonly duration: Duration) {
-    super()
-  }
-
-  run(sink: Sink<E, A>): Effect.Effect<R | Scope.Scope, never, unknown> {
-    return this.fx.run(
-      Sink((a) => Effect.delay(sink.event(a), this.duration), sink.error, sink.end),
-    )
-  }
-}

package/src/internal/operator/ensuring.ts

@@ -1,36 +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 ensuring: {
-  <R, E, A, R2, E2, B>(self: Fx<R, E, A>, finalizer: Effect.Effect<R2, E2, B>): Fx<
-    R | R2,
-    E | E2,
-    A
-  >
-  <R2, E2, B>(finalizer: Effect.Effect<R2, E2, B>): <R, E, A>(
-    self: Fx<R, E, A>,
-  ) => Fx<R | R2, E | E2, A>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <R, E, A, R2, E2, B>(self: Fx<R, E, A>, finalizer: Effect.Effect<R2, E2, B>) =>
-      new EnsuringFx(self, finalizer).traced(trace),
-)
-
-export class EnsuringFx<R, E, A, R2, E2, B> extends BaseFx<R | R2, E | E2, A> {
-  readonly name = 'Ensuring'
-
-  constructor(readonly self: Fx<R, E, A>, readonly finalizer: Effect.Effect<R2, E2, B>) {
-    super()
-  }
-
-  run(sink: Sink<E | E2, A>): Effect.Effect<R | R2 | Scope.Scope, never, unknown> {
-    return Effect.flatMap(
-      Effect.addFinalizer(() => Effect.catchAllCause(this.finalizer, sink.error)),
-      () => this.self.run(sink),
-    )
-  }
-}

package/src/internal/operator/exhaustMap.ts

@@ -1,94 +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 { fromEffect } from '@typed/fx/internal/conversion/fromEffect'
-import type { Context, Fiber, Scope } from '@typed/fx/internal/externals'
-import { Effect, Synchronized } from '@typed/fx/internal/externals'
-
-export const exhaustMap: {
-  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Fx<R2, E2, B>): Fx<R | R2, E | E2, B>
-  <A, R2, E2, B>(f: (a: A) => Fx<R2, E2, B>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, B>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Fx<R2, E2, B>): Fx<R | R2, E | E2, B> =>
-      new ExhaustMapFx(fx, f).traced(trace),
-)
-
-export const exhaust = <R, E, R2, E2, A>(fx: Fx<R, E, Fx<R2, E2, A>>): Fx<R | R2, E | E2, A> =>
-  exhaustMap(fx, (a) => a)
-
-export const exhaustMapEffect: {
-  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, B>): Fx<
-    R | R2,
-    E | E2,
-    B
-  >
-
-  <A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>): <R, E>(
-    fx: Fx<R, E, A>,
-  ) => Fx<R | R2, E | E2, B>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <R, E, A, R2, E2, B>(
-      fx: Fx<R, E, A>,
-      f: (a: A) => Effect.Effect<R2, E2, B>,
-    ): Fx<R | R2, E | E2, B> =>
-      exhaustMap(fx, (a) => fromEffect(f(a))).traced(trace),
-)
-
-export class ExhaustMapFx<R, E, A, R2, E2, B> extends BaseFx<R | R2, E | E2, B> {
-  readonly name = 'ExhaustMap' 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.Scope, never, unknown> {
-    return Effect.contextWithEffect((ctx: Context.Context<R | R2 | Scope.Scope>) =>
-      pipe(
-        Synchronized.make<Fiber.Fiber<never, unknown> | null>(null),
-        Effect.flatMap((fiberRef) => {
-          const resetRef = pipe(
-            fiberRef,
-            Synchronized.set<Fiber.Fiber<never, unknown> | null>(null),
-          )
-
-          return withRefCounter(
-            1,
-            (counter) =>
-              this.fx.run(
-                Sink(
-                  (a) =>
-                    pipe(
-                      fiberRef,
-                      Synchronized.updateEffect((fiber) =>
-                        fiber
-                          ? Effect.succeed(fiber)
-                          : pipe(
-                              counter.increment,
-                              Effect.flatMap(() =>
-                                Effect.forkScoped(
-                                  counter.refCounted(this.f(a), sink, () => resetRef),
-                                ),
-                              ),
-                            ),
-                      ),
-                      Effect.provideContext(ctx),
-                    ),
-                  sink.error,
-                  () => Effect.provideContext(counter.decrement, ctx),
-                ),
-              ),
-            sink.end,
-          )
-        }),
-      ),
-    )
-  }
-}

package/src/internal/operator/exhaustMapLatest.ts

@@ -1,117 +0,0 @@
-import { dualWithTrace } from '@effect/data/Debug'
-import { pipe } from '@effect/data/Function'
-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'
-import type { Context, Fiber } from '@typed/fx/internal/externals'
-import { Effect, Synchronized as Ref } from '@typed/fx/internal/externals'
-
-export const exhaustMapLatest: {
-  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Fx<R2, E2, B>): Fx<R | R2, E | E2, B>
-  <A, R2, E2, B>(f: (a: A) => Fx<R2, E2, B>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, B>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Fx<R2, E2, B>): Fx<R | R2, E | E2, B> =>
-      new ExhaustMapLatestFx(fx, f).traced(trace),
-)
-
-export const exhaustLatest = <R, E, R2, E2, A>(
-  fx: Fx<R, E, Fx<R2, E2, A>>,
-): Fx<R | R2, E | E2, A> => exhaustMapLatest(fx, (a) => a)
-
-export const exhaustMapLatestEffect: {
-  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, B>): Fx<
-    R | R2,
-    E | E2,
-    B
-  >
-
-  <A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>): <R, E>(
-    fx: Fx<R, E, A>,
-  ) => Fx<R | R2, E | E2, B>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <R, E, A, R2, E2, B>(
-      fx: Fx<R, E, A>,
-      f: (a: A) => Effect.Effect<R2, E2, B>,
-    ): Fx<R | R2, E | E2, B> =>
-      exhaustMapLatest(fx, (a) => fromEffect(f(a))).traced(trace),
-)
-
-export class ExhaustMapLatestFx<R, E, A, R2, E2, B> extends BaseFx<R | R2, E | E2, B> {
-  readonly name = 'ExhaustMapLatest' 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((ctx: Context.Context<R | R2 | Scope>) =>
-      pipe(
-        Ref.make<Fiber.RuntimeFiber<never, unknown> | null>(null),
-        Effect.zip(Ref.make<Fx<R2, E2, B> | null>(null)),
-        Effect.flatMap(([fiberRef, nextFxRef]) => {
-          return withRefCounter(
-            1,
-            (counter) => {
-              const resetRef = pipe(fiberRef, Ref.set<Fiber.Fiber<never, unknown> | null>(null))
-
-              const runNextFx: Effect.Effect<R2 | Scope, never, void> = pipe(
-                nextFxRef,
-                Ref.getAndSet<Fx<R2, E2, B> | null>(null),
-                Effect.flatMap((fx) =>
-                  fx
-                    ? pipe(
-                        fiberRef,
-                        Ref.updateEffect(() => runFx(fx)),
-                      )
-                    : counter.decrement,
-                ),
-              )
-
-              const runFx = (
-                fx: Fx<R2, E2, B>,
-              ): Effect.Effect<R2 | Scope, never, Fiber.RuntimeFiber<never, unknown> | null> =>
-                pipe(
-                  counter.refCounted(fx, sink, () => resetRef),
-                  Effect.zipLeft(runNextFx),
-                  Effect.forkScoped,
-                )
-
-              return this.fx.run(
-                Sink(
-                  (a) =>
-                    pipe(
-                      fiberRef,
-                      Ref.updateEffect((fiber) =>
-                        fiber
-                          ? pipe(
-                              nextFxRef,
-                              Ref.set<Fx<R2, E2, B> | null>(this.f(a)),
-                              Effect.as(fiber),
-                            )
-                          : pipe(
-                              counter.increment,
-                              Effect.flatMap(() => runFx(this.f(a))),
-                            ),
-                      ),
-                      Effect.provideContext(ctx),
-                    ),
-                  sink.error,
-                  () => Effect.provideContext(counter.decrement, ctx),
-                ),
-              )
-            },
-            sink.end,
-          )
-        }),
-      ),
-    )
-  }
-}

package/src/internal/operator/filterMap.ts

@@ -1,66 +0,0 @@
-import { dualWithTrace } from '@effect/data/Debug'
-import type { Predicate, Refinement } from '@effect/data/Predicate'
-
-import { BaseFx } from '@typed/fx/internal/BaseFx'
-import type { Fx } from '@typed/fx/internal/Fx'
-import { Sink } from '@typed/fx/internal/Fx'
-import { Effect, Option, Scope } from '@typed/fx/internal/externals'
-
-export const filterMap: {
-  <R, E, A, B>(self: Fx<R, E, A>, f: (a: A) => Option.Option<B>): Fx<R, E, B>
-  <A, B>(f: (a: A) => Option.Option<B>): <R, E>(self: Fx<R, E, A>) => Fx<R, E, B>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <R, E, A, B>(self: Fx<R, E, A>, f: (a: A) => Option.Option<B>): Fx<R, E, B> =>
-      new FilterMapFx(self, f).traced(trace),
-)
-
-export const filter: {
-  <R, E, A, B extends A>(self: Fx<R, E, A>, refinement: Refinement<A, B>): Fx<R, E, B>
-  <R, E, A>(self: Fx<R, E, A>, predicate: Predicate<A>): Fx<R, E, A>
-
-  <A, B extends A>(refinement: Refinement<A, B>): <R, E>(self: Fx<R, E, A>) => Fx<R, E, B>
-  <A>(predicate: Predicate<A>): <R, E>(self: Fx<R, E, A>) => Fx<R, E, A>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <R, E, A>(self: Fx<R, E, A>, predicate: Predicate<A>): Fx<R, E, A> =>
-      filterMap(self, (a) => (predicate(a) ? Option.some(a) : Option.none())).traced(trace),
-)
-
-export const filterNot: {
-  <R, E, A, B extends A>(self: Fx<R, E, A>, refinement: Refinement<A, B>): Fx<R, E, Exclude<A, B>>
-  <R, E, A>(self: Fx<R, E, A>, predicate: Predicate<A>): Fx<R, E, A>
-
-  <A, B extends A>(refinement: Refinement<A, B>): <R, E>(
-    self: Fx<R, E, A>,
-  ) => Fx<R, E, Exclude<A, B>>
-  <A>(predicate: Predicate<A>): <R, E>(self: Fx<R, E, A>) => Fx<R, E, A>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <R, E, A>(self: Fx<R, E, A>, predicate: Predicate<A>): Fx<R, E, A> =>
-      filterMap(self, (a) => (!predicate(a) ? Option.some(a) : Option.none())).traced(trace),
-)
-
-export const compact = <R, E, A>(self: Fx<R, E, Option.Option<A>>): Fx<R, E, A> =>
-  filterMap(self, (x) => x)
-
-export class FilterMapFx<R, E, A, B> extends BaseFx<R, E, B> {
-  readonly name = 'FilterMap' as const
-
-  constructor(readonly self: Fx<R, E, A>, readonly f: (a: A) => Option.Option<B>) {
-    super()
-  }
-
-  run(sink: Sink<E, B>): Effect.Effect<R | Scope.Scope, never, unknown> {
-    return this.self.run(
-      Sink((a) => Option.match(this.f(a), Effect.unit, sink.event), sink.error, sink.end),
-    )
-  }
-}
-
-export function isFilterMap<R, E, A>(fx: Fx<R, E, A>): fx is FilterMapFx<R, E, unknown, A> {
-  return fx instanceof FilterMapFx
-}