@typed/fx 2.0.0-beta.0 → 2.0.0-beta.10

package/src/Fx/combinators/mergeOrdered.ts

@@ -1,123 +0,0 @@
-import * as Cause from "effect/Cause";
-import * as Deferred from "effect/Deferred";
-import * as Effect from "effect/Effect";
-import * as Exit from "effect/Exit";
-import * as Sink from "../../Sink/Sink.js";
-import { make } from "../constructors/make.js";
-import type { Fx } from "../Fx.js";
-
-/**
- * Merges multiple Fx streams concurrently but emits values in the order of the input streams.
- *
- * This ensures that values from the first Fx are emitted before values from the second Fx, and so on.
- * Values from later streams are buffered until earlier streams complete or emit their values (depending on semantics, but usually this means strictly ordered emission).
- *
- * @param fx - The Fx streams to merge.
- * @returns An `Fx` that emits values in order.
- * @since 1.0.0
- * @category combinators
- */
-export function mergeOrdered<FX extends ReadonlyArray<Fx<any, any, any>>>(
-  ...fx: FX
-): Fx<Fx.Success<FX[number]>, Fx.Error<FX[number]>, Fx.Services<FX[number]>> {
-  return make<Fx.Success<FX[number]>, Fx.Error<FX[number]>, Fx.Services<FX[number]>>(
-    Effect.fn(function* (sink) {
-      const { makeSink, onEnd } = withBuffers(fx.length, sink);
-
-      yield* Effect.forEach(fx, (fx, i) => Effect.onExit(fx.run(makeSink(i)), () => onEnd(i)), {
-        concurrency: "unbounded",
-        discard: true,
-      });
-    }),
-  );
-}
-
-function withBuffers<A, E, R>(size: number, sink: Sink.Sink<A, E, R>) {
-  const buffers = indexedBuffers(size, sink);
-  const onSuccess = (index: number, value: A) => buffers.get(index)!.onSuccess(value);
-  const onEnd = (index: number) => buffers.get(index)!.onEnd;
-
-  const makeSink = (index: number) =>
-    Sink.make<A, E, R>(
-      (cause) => (Cause.hasInterruptsOnly(cause) ? onEnd(index) : sink.onFailure(cause)),
-      (value) => onSuccess(index, value),
-    );
-
-  return {
-    onSuccess,
-    onEnd,
-    makeSink,
-  } as const;
-}
-
-function indexedBuffers<A, E, R>(size: number, sink: Sink.Sink<A, E, R>) {
-  const buffers = new Map<number, ReturnType<typeof IndexedBuffer<A, E, R>>>();
-
-  const last = size - 1;
-  for (let i = 0; i < size; i++) {
-    const deferred = Deferred.makeUnsafe<void>();
-    const state = {
-      ready: i === 0,
-      deferred,
-    };
-
-    // First should start immediately
-    if (i === 0) {
-      Deferred.doneUnsafe(deferred, Exit.void);
-    }
-
-    buffers.set(
-      i,
-      IndexedBuffer(
-        state,
-        sink,
-        i === last
-          ? Effect.void
-          : Effect.suspend(() => {
-              const next = buffers.get(i + 1)!;
-              next.state.ready = true;
-              return Deferred.done(next.state.deferred, Exit.void);
-            }),
-      ),
-    );
-  }
-
-  return buffers;
-}
-
-function IndexedBuffer<A, E, R>(
-  state: {
-    ready: boolean;
-    deferred: Deferred.Deferred<void>;
-  },
-  sink: Sink.Sink<A, E, R>,
-  onDone: Effect.Effect<void>,
-) {
-  let buffer: Array<A> = [];
-
-  const onSuccess = (value: A) => {
-    if (state.ready) {
-      if (buffer.length === 0) return sink.onSuccess(value);
-      buffer.push(value);
-      const effect = Effect.forEach(buffer, sink.onSuccess);
-      buffer = [];
-      return effect;
-    } else {
-      buffer.push(value);
-      return Effect.void;
-    }
-  };
-
-  const onEnd = Effect.flatMap(Deferred.await(state.deferred), () => {
-    if (buffer.length === 0) return onDone;
-    const effect = Effect.forEach(buffer, sink.onSuccess);
-    buffer = [];
-    return Effect.ensuring(effect, onDone);
-  });
-
-  return {
-    state,
-    onSuccess,
-    onEnd,
-  };
-}

package/src/Fx/combinators/onError.ts

@@ -1,40 +0,0 @@
-import type * as Cause from "effect/Cause";
-import * as Effect from "effect/Effect";
-import { dual } from "effect/Function";
-import { make as makeSink } from "../../Sink/Sink.js";
-import { make } from "../constructors/make.js";
-import type { Fx } from "../Fx.js";
-
-/**
- * Adds an `Effect.onError`-style finalizer to an `Fx`.
- *
- * The cleanup is run only if the stream fails (including defects / interrupts
- * carried in the `Cause`).
- *
- * @since 1.0.0
- * @category combinators
- */
-export const onError: {
-  <E, X, R2>(
-    cleanup: (cause: Cause.Cause<E>) => Effect.Effect<X, never, R2>,
-  ): <A, R>(self: Fx<A, E, R>) => Fx<A, E, R | R2>;
-
-  <A, E, R, X, R2>(
-    self: Fx<A, E, R>,
-    cleanup: (cause: Cause.Cause<E>) => Effect.Effect<X, never, R2>,
-  ): Fx<A, E, R | R2>;
-} = dual(
-  2,
-  <A, E, R, X, R2>(
-    self: Fx<A, E, R>,
-    cleanup: (cause: Cause.Cause<E>) => Effect.Effect<X, never, R2>,
-  ): Fx<A, E, R | R2> =>
-    make<A, E, R | R2>((sink) =>
-      self.run(
-        makeSink(
-          (cause) => Effect.flatMap(sink.onFailure(cause), () => Effect.ignore(cleanup(cause))),
-          sink.onSuccess,
-        ),
-      ),
-    ),
-);

package/src/Fx/combinators/onExit.ts

@@ -1,82 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Exit from "effect/Exit";
-import { dual } from "effect/Function";
-import * as Option from "effect/Option";
-import * as Ref from "effect/Ref";
-import { make as makeSink } from "../../Sink/Sink.js";
-import { make } from "../constructors/make.js";
-import type { Fx } from "../Fx.js";
-
-const toFinalizer =
-  <A, E, XE, XR>(f: (exit: Exit.Exit<A, E>) => void | Effect.Effect<void, XE, XR>) =>
-  (exit: Exit.Exit<A, E>): Effect.Effect<void, XE, XR> => {
-    const x = f(exit);
-    return Effect.isEffect(x) ? x : Effect.void;
-  };
-
-/**
- * Adds an `Effect.onExit`-style finalizer to an `Fx`.
- *
- * The finalizer is run when the `Fx` terminates (success, failure, or interruption).
- *
- * @since 1.0.0
- * @category combinators
- */
-export const onExit: {
-  <A, E, XE = never, XR = never>(
-    f: (exit: Exit.Exit<void, E>) => void | Effect.Effect<void, XE, XR>,
-  ): <R>(self: Fx<A, E, R>) => Fx<A, E | XE, R | XR>;
-
-  <A, E, R, XE = never, XR = never>(
-    self: Fx<A, E, R>,
-    f: (exit: Exit.Exit<void, E>) => void | Effect.Effect<void, XE, XR>,
-  ): Fx<A, E | XE, R | XR>;
-} = dual(
-  2,
-  <A, E, R, XE, XR>(
-    self: Fx<A, E, R>,
-    f: (exit: Exit.Exit<void, E>) => void | Effect.Effect<void, XE, XR>,
-  ): Fx<A, E | XE, R | XR> =>
-    make<A, E | XE, R | XR>(
-      Effect.fnUntraced(function* (sink) {
-        const finalizer = toFinalizer(f);
-        const observed = yield* Ref.make(Option.none<Exit.Exit<void, E>>());
-
-        const recordExit = (exit: Exit.Exit<void, E>) =>
-          Ref.modify(observed, (current) =>
-            Option.isNone(current)
-              ? ([true, Option.some(exit)] as const)
-              : ([false, current] as const),
-          ).pipe(Effect.asVoid);
-
-        const runFinalizer = (exit: Exit.Exit<void, E>, allowReportFailure: boolean) =>
-          Effect.matchCauseEffect(finalizer(exit), {
-            onFailure: (cause) => (allowReportFailure ? sink.onFailure(cause) : Effect.void),
-            onSuccess: () => Effect.void,
-          });
-
-        return yield* self
-          .run(
-            makeSink(
-              (cause) =>
-                Effect.flatMap(recordExit(Exit.failCause(cause)), () => sink.onFailure(cause)),
-              sink.onSuccess,
-            ),
-          )
-          .pipe(
-            Effect.onExit((runExit) =>
-              Effect.flatMap(Ref.get(observed), (maybe) =>
-                Option.match(maybe, {
-                  onSome: (exit) => runFinalizer(exit, false),
-                  onNone: () =>
-                    Exit.match(runExit, {
-                      onFailure: (cause) => runFinalizer(Exit.failCause(cause), false),
-                      onSuccess: () => runFinalizer(Exit.succeed<void>(undefined), true),
-                    }),
-                }),
-              ),
-            ),
-          );
-      }),
-    ),
-);

package/src/Fx/combinators/onInterrupt.ts

@@ -1,87 +0,0 @@
-import * as Cause from "effect/Cause";
-import * as Effect from "effect/Effect";
-import { dual } from "effect/Function";
-import * as Option from "effect/Option";
-import * as Ref from "effect/Ref";
-import { make as makeSink } from "../../Sink/Sink.js";
-import { make } from "../constructors/make.js";
-import type { Fx } from "../Fx.js";
-
-const toFinalizer =
-  <XE, XR>(
-    f:
-      | Effect.Effect<void, XE, XR>
-      | ((interruptors: ReadonlySet<number>) => Effect.Effect<void, XE, XR>),
-  ) =>
-  (interruptors: ReadonlySet<number>) =>
-    typeof f === "function" ? f(interruptors) : f;
-
-/**
- * Adds an `Effect.onInterrupt`-style finalizer to an `Fx`.
- *
- * The finalizer is run only when the stream is interrupted (either via an
- * interrupt cause or by interrupting the running fiber).
- *
- * @since 1.0.0
- * @category combinators
- */
-export const onInterrupt: {
-  <XE, XR>(
-    finalizer:
-      | Effect.Effect<void, XE, XR>
-      | ((interruptors: ReadonlySet<number>) => Effect.Effect<void, XE, XR>),
-  ): <A, E, R>(self: Fx<A, E, R>) => Fx<A, E | XE, R | XR>;
-
-  <A, E, R, XE, XR>(
-    self: Fx<A, E, R>,
-    finalizer:
-      | Effect.Effect<void, XE, XR>
-      | ((interruptors: ReadonlySet<number>) => Effect.Effect<void, XE, XR>),
-  ): Fx<A, E | XE, R | XR>;
-} = dual(
-  2,
-  <A, E, R, XE, XR>(
-    self: Fx<A, E, R>,
-    finalizer_:
-      | Effect.Effect<void, XE, XR>
-      | ((interruptors: ReadonlySet<number>) => Effect.Effect<void, XE, XR>),
-  ): Fx<A, E | XE, R | XR> =>
-    make<A, E | XE, R | XR>(
-      Effect.fnUntraced(function* (sink) {
-        const finalizer = toFinalizer(finalizer_);
-        const interrupted = yield* Ref.make(Option.none<ReadonlySet<number>>());
-
-        const record = (ids: ReadonlySet<number>) =>
-          Ref.modify(interrupted, (current) =>
-            Option.isNone(current)
-              ? ([true, Option.some(ids)] as const)
-              : ([false, current] as const),
-          );
-
-        const runFinalizer = (ids: ReadonlySet<number>) =>
-          Effect.flatMap(record(ids), (first) =>
-            first
-              ? Effect.matchCauseEffect(finalizer(ids), {
-                  onFailure: () => Effect.void,
-                  onSuccess: () => Effect.void,
-                })
-              : Effect.void,
-          );
-
-        return yield* self
-          .run(
-            makeSink(
-              (cause) =>
-                Cause.hasInterruptsOnly(cause)
-                  ? Effect.matchCauseEffect(finalizer(Cause.interruptors(cause)), {
-                      onFailure: (cause2) => sink.onFailure(Cause.combine(cause, cause2)),
-                      onSuccess: () => sink.onFailure(cause),
-                    })
-                  : sink.onFailure(cause),
-              sink.onSuccess,
-            ),
-          )
-          .pipe(Effect.onInterrupt((ids) => runFinalizer(ids)));
-      }),
-    ),
-);

package/src/Fx/combinators/provide.ts

@@ -1,62 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Exit from "effect/Exit";
-import { dual } from "effect/Function";
-import * as Layer from "effect/Layer";
-import * as Scope from "effect/Scope";
-import type * as ServiceMap from "effect/ServiceMap";
-import { make } from "../constructors/make.js";
-import type { Fx } from "../Fx.js";
-
-/**
- * Provides context to an Fx from a Layer.
- *
- * The context is provided to the entire Fx stream, including any effects run
- * during its execution. The context is scoped to the lifetime of the stream.
- *
- * @param layer - The Layer to provide.
- * @returns An `Fx` with the required context provided.
- * @since 1.0.0
- * @category combinators
- */
-export const provide: {
-  <R2, E2 = never, R3 = never>(
-    layer: Layer.Layer<R2, E2, R3>,
-  ): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E | E2, Exclude<R, R2> | R3>;
-
-  <A, E, R, R2, E2 = never, R3 = never>(
-    fx: Fx<A, E, R>,
-    layer: Layer.Layer<R2, E2, R3>,
-  ): Fx<A, E | E2, Exclude<R, R2> | R3>;
-} = dual(
-  2,
-  <A, E, R, R2, E2 = never, R3 = never>(
-    fx: Fx<A, E, R>,
-    layer: Layer.Layer<R2, E2, R3>,
-  ): Fx<A, E | E2, Exclude<R, R2> | R3> =>
-    make<A, E | E2, Exclude<R, R2> | R3>(
-      Effect.fnUntraced(function* (sink) {
-        const scope = yield* Scope.make();
-        const servicesExit = yield* layer.pipe(Layer.buildWithScope(scope), Effect.exit);
-
-        if (Exit.isFailure(servicesExit)) {
-          yield* Scope.close(scope, servicesExit);
-          return yield* sink.onFailure(servicesExit.cause);
-        }
-
-        return yield* fx.run(sink).pipe(
-          Effect.provideServices(servicesExit.value),
-          Effect.onExit((exit) => Scope.close(scope, exit)),
-        );
-      }),
-    ),
-);
-
-export const provideServices: {
-  <R2>(services: ServiceMap.ServiceMap<R2>): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, Exclude<R, R2>>;
-
-  <A, E, R, R2>(fx: Fx<A, E, R>, services: ServiceMap.ServiceMap<R2>): Fx<A, E, Exclude<R, R2>>;
-} = dual(
-  2,
-  <A, E, R, R2>(fx: Fx<A, E, R>, services: ServiceMap.ServiceMap<R2>): Fx<A, E, Exclude<R, R2>> =>
-    provide(fx, Layer.succeedServices(services)),
-);

package/src/Fx/combinators/skip.ts

@@ -1,20 +0,0 @@
-import { dual } from "effect/Function";
-import type { Fx } from "../Fx.js";
-import { slice } from "./slice.js";
-
-/**
- * Skips the first `n` elements of an Fx.
- *
- * @param n - The number of elements to skip.
- * @returns An `Fx` that emits values after the first `n` elements.
- * @since 1.0.0
- * @category combinators
- */
-export const skip: {
-  (n: number): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>;
-
-  <A, E, R>(fx: Fx<A, E, R>, n: number): Fx<A, E, R>;
-} = dual(
-  2,
-  <A, E, R>(fx: Fx<A, E, R>, n: number): Fx<A, E, R> => slice(fx, { skip: n, take: Infinity }),
-);

package/src/Fx/combinators/skipRepeats.ts

@@ -1,15 +0,0 @@
-import { equals } from "effect/Equal";
-import type { Fx } from "../Fx.js";
-import { skipRepeatsWith } from "./skipRepeatsWith.js";
-
-const skipRepeats_ = skipRepeatsWith<any>(equals);
-
-/**
- * Drops elements that are equal to the previous element using standard equality.
- *
- * @param fx - The `Fx` stream.
- * @returns An `Fx` with consecutive duplicates removed.
- * @since 1.0.0
- * @category combinators
- */
-export const skipRepeats: <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R> = skipRepeats_;

package/src/Fx/combinators/skipRepeatsWith.ts

@@ -1,40 +0,0 @@
-import * as Effect from "effect/Effect";
-import type * as Equivalence from "effect/Equivalence";
-import * as Option from "effect/Option";
-import * as Ref from "effect/Ref";
-import * as sinkCore from "../../Sink/combinators.js";
-import { make as makeSink } from "../../Sink/Sink.js";
-import { make } from "../constructors/make.js";
-import type { Fx } from "../Fx.js";
-
-/**
- * Drops elements that are equal to the previous element using a custom equivalence function.
- *
- * @param Eq - The equivalence function to use.
- * @returns An `Fx` with consecutive duplicates removed.
- * @since 1.0.0
- * @category combinators
- */
-export const skipRepeatsWith =
-  <A>(Eq: Equivalence.Equivalence<A>) =>
-  <E, R>(fx: Fx<A, E, R>): Fx<A, E, R> =>
-    make<A, E, R>((sink) =>
-      sinkCore.withState(sink, Option.none<A>(), (sink) =>
-        fx.run(
-          makeSink(sink.onFailure, (a2) =>
-            Effect.flatten(
-              Ref.modify(
-                sink.state,
-                Option.match({
-                  onNone: () => [sink.onSuccess(a2), Option.some(a2)],
-                  onSome: (a) =>
-                    Eq(a, a2)
-                      ? [Effect.void, Option.some(a)]
-                      : [sink.onSuccess(a2), Option.some(a2)],
-                }),
-              ),
-            ),
-          ),
-        ),
-      ),
-    );

package/src/Fx/combinators/slice.ts

@@ -1,32 +0,0 @@
-import { dual } from "effect/Function";
-import * as sinkCore from "../../Sink/combinators.js";
-import { make } from "../constructors/make.js";
-import type { Fx } from "../Fx.js";
-
-/**
- * Defines the bounds for slicing an Fx stream.
- * @since 1.0.0
- * @category models
- */
-export interface Bounds {
-  readonly skip: number;
-  readonly take: number;
-}
-
-/**
- * Slices an Fx by skipping a number of elements and then taking a number of elements.
- *
- * @param bounds - The `Bounds` specifying how many elements to skip and take.
- * @returns An `Fx` representing the slice.
- * @since 1.0.0
- * @category combinators
- */
-export const slice: {
-  (bounds: Bounds): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>;
-
-  <A, E, R>(fx: Fx<A, E, R>, bounds: Bounds): Fx<A, E, R>;
-} = dual(
-  2,
-  <A, E, R>(fx: Fx<A, E, R>, bounds: Bounds): Fx<A, E, R> =>
-    make<A, E, R>((sink) => sinkCore.slice(sink, bounds, (sink) => fx.run(sink))),
-);

package/src/Fx/combinators/switchMap.ts

@@ -1,55 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Fiber from "effect/Fiber";
-import { dual } from "effect/Function";
-import * as Scope from "effect/Scope";
-import * as ServiceMap from "effect/ServiceMap";
-import * as SyncronizedRef from "effect/SynchronizedRef";
-import { make as makeSink } from "../../Sink/Sink.js";
-import { make } from "../constructors/make.js";
-import type { Fx } from "../Fx.js";
-import { extendScope } from "../internal/scope.js";
-import type { FlatMapLike } from "./flatMap.js";
-
-/**
- * Maps each element of an Fx to a new Fx, and switches to the latest inner Fx.
- *
- * When a new element is emitted, the previous inner Fx is cancelled.
- *
- * @param f - A function that maps an element `A` to a new `Fx<B>`.
- * @returns An `Fx` that emits values from the latest inner stream.
- * @since 1.0.0
- * @category combinators
- */
-export const switchMap: FlatMapLike = dual(
-  2,
-  <A, E, R, B, E2, R2>(
-    self: Fx<A, E, R>,
-    f: (a: A) => Fx<B, E2, R2>,
-  ): Fx<B, E | E2, R | R2 | Scope.Scope> =>
-    make<B, E | E2, R | R2 | Scope.Scope>(
-      Effect.fn(function* (sink) {
-        const ctx = yield* Effect.services<R2 | Scope.Scope>();
-        const scope = ServiceMap.get(ctx, Scope.Scope);
-        const fiberRef = yield* SyncronizedRef.make<Fiber.Fiber<unknown, never> | null>(null);
-
-        const next = (value: A) =>
-          Effect.forkIn(Effect.provideServices(f(value).run(sink), ctx), scope, {
-            startImmediately: false,
-            uninterruptible: false,
-          });
-
-        yield* self.run(
-          makeSink(sink.onFailure, (value: A) =>
-            SyncronizedRef.updateEffect(fiberRef, (fiber) =>
-              fiber ? Fiber.interrupt(fiber).pipe(Effect.flatMap(() => next(value))) : next(value),
-            ),
-          ),
-        );
-
-        const fiber = yield* SyncronizedRef.get(fiberRef);
-        if (fiber) {
-          yield* Fiber.join(fiber);
-        }
-      }, extendScope),
-    ),
-);

package/src/Fx/combinators/switchMapEffect.ts

@@ -1,25 +0,0 @@
-import type * as Effect from "effect/Effect";
-import { dual, flow } from "effect/Function";
-import type * as Scope from "effect/Scope";
-import { fromEffect } from "../constructors/fromEffect.js";
-import type { Fx } from "../Fx.js";
-import type { FlatMapEffectLike } from "./flatMapEffect.js";
-import { switchMap } from "./switchMap.js";
-
-/**
- * Maps each element of an Fx to an Effect, and switches to the latest effect.
- *
- * When a new element is emitted, the previous effect is cancelled.
- *
- * @param f - A function that maps an element `A` to an `Effect<B>`.
- * @returns An `Fx` that emits the results of the latest effect.
- * @since 1.0.0
- * @category combinators
- */
-export const switchMapEffect: FlatMapEffectLike = dual(
-  2,
-  <A, E, R, B, E2, R2>(
-    self: Fx<A, E, R>,
-    f: (a: A) => Effect.Effect<B, E2, R2>,
-  ): Fx<B, E | E2, R | R2 | Scope.Scope> => switchMap(self, flow(f, fromEffect)),
-);

package/src/Fx/combinators/take.ts

@@ -1,17 +0,0 @@
-import { dual } from "effect/Function";
-import type { Fx } from "../Fx.js";
-import { slice } from "./slice.js";
-
-/**
- * Takes the first `n` elements from an Fx and then completes.
- *
- * @param n - The number of elements to take.
- * @returns An `Fx` that emits at most `n` elements.
- * @since 1.0.0
- * @category combinators
- */
-export const take: {
-  (n: number): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>;
-
-  <A, E, R>(fx: Fx<A, E, R>, n: number): Fx<A, E, R>;
-} = dual(2, <A, E, R>(fx: Fx<A, E, R>, n: number): Fx<A, E, R> => slice(fx, { skip: 0, take: n }));

package/src/Fx/combinators/takeUntil.ts

@@ -1,50 +0,0 @@
-import { dual } from "effect/Function";
-import * as combinators from "../../Sink/combinators.js";
-import { make as makeSink } from "../../Sink/Sink.js";
-import { make as makeFx } from "../constructors/make.js";
-import type { Fx } from "../Fx.js";
-
-/**
- * Takes elements from an Fx until a predicate returns true.
- * The element that satisfies the predicate is not included in the output.
- *
- * @param predicate - The predicate function.
- * @returns An `Fx` that completes when the predicate matches.
- * @since 1.0.0
- * @category combinators
- */
-export const takeUntil: {
-  <A>(predicate: (a: A) => boolean): <E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>;
-  <A, E, R>(fx: Fx<A, E, R>, predicate: (a: A) => boolean): Fx<A, E, R>;
-} = dual(2, <A, E, R>(fx: Fx<A, E, R>, predicate: (a: A) => boolean): Fx<A, E, R> => {
-  return makeFx<A, E, R>((sink) =>
-    combinators.withEarlyExit(sink, (sink) =>
-      fx.run(
-        makeSink(sink.onFailure, (a) => {
-          if (predicate(a)) {
-            return sink.earlyExit;
-          }
-          return sink.onSuccess(a);
-        }),
-      ),
-    ),
-  );
-});
-
-/**
- * Drops elements from an Fx after a predicate returns true.
- * The element that satisfies the predicate is included in the output.
- *
- * @param predicate - The predicate function.
- * @returns An `Fx` that stops emitting when the predicate matches.
- * @since 1.0.0
- * @category combinators
- */
-export const dropAfter: {
-  <A>(predicate: (a: A) => boolean): <E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>;
-  <A, E, R>(fx: Fx<A, E, R>, predicate: (a: A) => boolean): Fx<A, E, R>;
-} = dual(
-  2,
-  <A, E, R>(fx: Fx<A, E, R>, predicate: (a: A) => boolean): Fx<A, E, R> =>
-    makeFx<A, E, R>((sink) => combinators.dropAfter(sink, predicate, (sink) => fx.run(sink))),
-);