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

package/src/Fx/combinators/catch.ts

@@ -1,421 +0,0 @@
-import type * as Arr from "effect/Array";
-import * as Cause from "effect/Cause";
-import { dual } from "effect/Function";
-import * as Result from "effect/Result";
-import type { ExcludeTag, ExtractTag, NoInfer, Tags } from "effect/Types";
-import { make as makeSink } from "../../Sink/Sink.js";
-import { make } from "../constructors/make.js";
-import type { Fx } from "../Fx.js";
-
-const hasTag = (u: unknown): u is { readonly _tag: string } =>
-  typeof u === "object" &&
-  u !== null &&
-  "_tag" in u &&
-  typeof (u as Record<string, unknown>)["_tag"] === "string";
-
-const matchesTag = <E, K extends string>(
-  tag: K | Arr.NonEmptyReadonlyArray<K>,
-  error: E,
-): error is ExtractTag<E, K> => {
-  if (!hasTag(error)) return false;
-  if (typeof tag === "string") return error._tag === tag;
-  return tag.some((t) => t === error._tag);
-};
-
-/**
- * Recovers from a typed failure of an Fx by switching to a fallback Fx.
- *
- * Mirrors `Effect.catch` / `Effect.catchAll` (catches `Cause.Fail` only).
- *
- * @since 1.0.0
- * @category combinators
- */
-export const catch_: {
-  <E, A2, E2, R2>(f: (e: E) => Fx<A2, E2, R2>): <A, R>(self: Fx<A, E, R>) => Fx<A | A2, E2, R | R2>;
-
-  <A, E, R, A2, E2, R2>(self: Fx<A, E, R>, f: (e: E) => Fx<A2, E2, R2>): Fx<A | A2, E2, R | R2>;
-} = dual(
-  2,
-  <A, E, R, A2, E2, R2>(self: Fx<A, E, R>, f: (e: E) => Fx<A2, E2, R2>): Fx<A | A2, E2, R | R2> =>
-    make<A | A2, E2, R | R2>((sink) =>
-      self.run(
-        makeSink((cause) => {
-          const result = Cause.findFail(cause);
-          if (Result.isFailure(result)) {
-            return sink.onFailure(result.failure);
-          }
-          return f(result.success.error).run(sink);
-        }, sink.onSuccess),
-      ),
-    ),
-);
-
-export { catch_ as catch };
-
-/**
- * An alias for {@link catch}.
- *
- * @since 1.0.0
- * @category combinators
- */
-export const catchAll = catch_;
-
-/**
- * Recovers from *any* failure cause of an Fx (including defects and interrupts)
- * by switching to a fallback Fx.
- *
- * Mirrors `Effect.catchCause`.
- *
- * @since 1.0.0
- * @category combinators
- */
-export const catchCause: {
-  <E, A2, E2, R2>(
-    f: (cause: Cause.Cause<E>) => Fx<A2, E2, R2>,
-  ): <A, R>(self: Fx<A, E, R>) => Fx<A | A2, E2, R | R2>;
-
-  <A, E, R, A2, E2, R2>(
-    self: Fx<A, E, R>,
-    f: (cause: Cause.Cause<E>) => Fx<A2, E2, R2>,
-  ): Fx<A | A2, E2, R | R2>;
-} = dual(
-  2,
-  <A, E, R, A2, E2, R2>(
-    self: Fx<A, E, R>,
-    f: (cause: Cause.Cause<E>) => Fx<A2, E2, R2>,
-  ): Fx<A | A2, E2, R | R2> =>
-    make<A | A2, E2, R | R2>((sink) =>
-      self.run(makeSink((cause) => f(cause).run(sink), sink.onSuccess)),
-    ),
-);
-
-/**
- * Recovers from a typed failure by matching on the `_tag` field of the error.
- *
- * Mirrors `Effect.catchTag`.
- *
- * @since 1.0.0
- * @category combinators
- */
-export const catchTag: {
-  <const K extends Tags<E> | Arr.NonEmptyReadonlyArray<Tags<E>>, E, A2, E2, R2>(
-    k: K,
-    f: (
-      e: ExtractTag<NoInfer<E>, K extends Arr.NonEmptyReadonlyArray<string> ? K[number] : K>,
-    ) => Fx<A2, E2, R2>,
-  ): <A, R>(
-    self: Fx<A, E, R>,
-  ) => Fx<
-    A | A2,
-    E2 | ExcludeTag<E, K extends Arr.NonEmptyReadonlyArray<string> ? K[number] : K>,
-    R | R2
-  >;
-
-  <A, E, R, const K extends Tags<E> | Arr.NonEmptyReadonlyArray<Tags<E>>, A2, E2, R2>(
-    self: Fx<A, E, R>,
-    k: K,
-    f: (
-      e: ExtractTag<E, K extends Arr.NonEmptyReadonlyArray<string> ? K[number] : K>,
-    ) => Fx<A2, E2, R2>,
-  ): Fx<
-    A | A2,
-    E2 | ExcludeTag<E, K extends Arr.NonEmptyReadonlyArray<string> ? K[number] : K>,
-    R | R2
-  >;
-} = dual(
-  3,
-  <A, E, R, const K extends Tags<E> | Arr.NonEmptyReadonlyArray<Tags<E>>, A2, E2, R2>(
-    self: Fx<A, E, R>,
-    k: K,
-    f: (
-      e: ExtractTag<E, K extends Arr.NonEmptyReadonlyArray<string> ? K[number] : K>,
-    ) => Fx<A2, E2, R2>,
-  ): Fx<
-    A | A2,
-    E2 | ExcludeTag<E, K extends Arr.NonEmptyReadonlyArray<string> ? K[number] : K>,
-    R | R2
-  > =>
-    make<
-      A | A2,
-      E2 | ExcludeTag<E, K extends Arr.NonEmptyReadonlyArray<string> ? K[number] : K>,
-      R | R2
-    >((sink) =>
-      self.run(
-        makeSink((cause) => {
-          const result = Cause.findFail(cause);
-          if (Result.isFailure(result)) {
-            return sink.onFailure(result.failure);
-          } else if (matchesTag(k, result.success.error)) {
-            return f(
-              result.success.error as ExtractTag<
-                E,
-                K extends Arr.NonEmptyReadonlyArray<string> ? K[number] : K
-              >,
-            ).run(sink);
-          } else {
-            return sink.onFailure(
-              cause as Cause.Cause<
-                E2 | ExcludeTag<E, K extends Arr.NonEmptyReadonlyArray<string> ? K[number] : K>
-              >,
-            );
-          }
-        }, sink.onSuccess),
-      ),
-    ),
-);
-
-/**
- * Recovers from a typed failure when a predicate holds, by switching to a fallback Fx.
- * Only applies to `Cause.Fail`; defects and interrupts are not caught.
- *
- * Mirrors `Effect.catchIf`.
- *
- * @since 1.0.0
- * @category combinators
- */
-export const catchIf: {
-  <E, A2, E2, R2>(
-    predicate: (e: E) => boolean,
-    f: (e: E) => Fx<A2, E2, R2>,
-  ): <A, R>(self: Fx<A, E, R>) => Fx<A | A2, E | E2, R | R2>;
-
-  <A, E, R, A2, E2, R2>(
-    self: Fx<A, E, R>,
-    predicate: (e: E) => boolean,
-    f: (e: E) => Fx<A2, E2, R2>,
-  ): Fx<A | A2, E | E2, R | R2>;
-} = dual(
-  3,
-  <A, E, R, A2, E2, R2>(
-    self: Fx<A, E, R>,
-    predicate: (e: E) => boolean,
-    f: (e: E) => Fx<A2, E2, R2>,
-  ): Fx<A | A2, E | E2, R | R2> =>
-    make<A | A2, E | E2, R | R2>((sink) =>
-      self.run(
-        makeSink((cause) => {
-          const result = Cause.findFail(cause);
-          if (Result.isFailure(result)) {
-            return sink.onFailure(result.failure);
-          }
-          const error = result.success.error;
-          if (predicate(error)) {
-            return f(error).run(sink);
-          }
-          return sink.onFailure(cause);
-        }, sink.onSuccess),
-      ),
-    ),
-);
-
-/**
- * Recovers from a failure cause when a predicate on the cause holds,
- * by switching to a fallback Fx.
- *
- * Mirrors `Effect.catchCauseIf`.
- *
- * @since 1.0.0
- * @category combinators
- */
-export const catchCauseIf: {
-  <E, A2, E2, R2>(
-    predicate: (cause: Cause.Cause<E>) => boolean,
-    f: (cause: Cause.Cause<E>) => Fx<A2, E2, R2>,
-  ): <A, R>(self: Fx<A, E, R>) => Fx<A | A2, E | E2, R | R2>;
-
-  <A, E, R, A2, E2, R2>(
-    self: Fx<A, E, R>,
-    predicate: (cause: Cause.Cause<E>) => boolean,
-    f: (cause: Cause.Cause<E>) => Fx<A2, E2, R2>,
-  ): Fx<A | A2, E | E2, R | R2>;
-} = dual(
-  3,
-  <A, E, R, A2, E2, R2>(
-    self: Fx<A, E, R>,
-    predicate: (cause: Cause.Cause<E>) => boolean,
-    f: (cause: Cause.Cause<E>) => Fx<A2, E2, R2>,
-  ): Fx<A | A2, E | E2, R | R2> =>
-    make<A | A2, E | E2, R | R2>((sink) =>
-      self.run(
-        makeSink(
-          (cause) => (predicate(cause) ? f(cause).run(sink) : sink.onFailure(cause)),
-          sink.onSuccess,
-        ),
-      ),
-    ),
-);
-
-type TaggedCase<E> = {
-  [K in Extract<E, { _tag: string }>["_tag"]]+?: (
-    error: Extract<E, { _tag: K }>,
-  ) => Fx<unknown, unknown, unknown>;
-};
-
-/**
- * Recovers from typed failures by matching on the `_tag` field with multiple handlers at once.
- *
- * Mirrors `Effect.catchTags`.
- *
- * @since 1.0.0
- * @category combinators
- */
-export const catchTags: {
-  <E, Cases extends TaggedCase<E>>(
-    cases: Cases,
-  ): <A, R>(
-    self: Fx<A, E, R>,
-  ) => Fx<
-    | A
-    | {
-        [K in keyof Cases]: Cases[K] extends (e: unknown) => Fx<infer A2, unknown, unknown>
-          ? A2
-          : never;
-      }[keyof Cases],
-    | Exclude<E, { _tag: keyof Cases }>
-    | {
-        [K in keyof Cases]: Cases[K] extends (e: unknown) => Fx<unknown, infer E2, unknown>
-          ? E2
-          : never;
-      }[keyof Cases],
-    | R
-    | {
-        [K in keyof Cases]: Cases[K] extends (e: unknown) => Fx<unknown, unknown, infer R2>
-          ? R2
-          : never;
-      }[keyof Cases]
-  >;
-
-  <A, E, R, Cases extends TaggedCase<E>>(
-    self: Fx<A, E, R>,
-    cases: Cases,
-  ): Fx<
-    | A
-    | {
-        [K in keyof Cases]: Cases[K] extends (e: unknown) => Fx<infer A2, unknown, unknown>
-          ? A2
-          : never;
-      }[keyof Cases],
-    | Exclude<E, { _tag: keyof Cases }>
-    | {
-        [K in keyof Cases]: Cases[K] extends (e: unknown) => Fx<unknown, infer E2, unknown>
-          ? E2
-          : never;
-      }[keyof Cases],
-    | R
-    | {
-        [K in keyof Cases]: Cases[K] extends (e: unknown) => Fx<unknown, unknown, infer R2>
-          ? R2
-          : never;
-      }[keyof Cases]
-  >;
-} = dual(
-  2,
-  <A, E, R, Cases extends TaggedCase<E>>(
-    self: Fx<A, E, R>,
-    cases: Cases,
-  ): Fx<
-    | A
-    | {
-        [K in keyof Cases]: Cases[K] extends (e: unknown) => Fx<infer A2, unknown, unknown>
-          ? A2
-          : never;
-      }[keyof Cases],
-    | Exclude<E, { _tag: keyof Cases }>
-    | {
-        [K in keyof Cases]: Cases[K] extends (e: unknown) => Fx<unknown, infer E2, unknown>
-          ? E2
-          : never;
-      }[keyof Cases],
-    | R
-    | {
-        [K in keyof Cases]: Cases[K] extends (e: unknown) => Fx<unknown, unknown, infer R2>
-          ? R2
-          : never;
-      }[keyof Cases]
-  > =>
-    make<
-      | A
-      | {
-          [K in keyof Cases]: Cases[K] extends (e: unknown) => Fx<infer A2, unknown, unknown>
-            ? A2
-            : never;
-        }[keyof Cases],
-      | Exclude<E, { _tag: keyof Cases }>
-      | {
-          [K in keyof Cases]: Cases[K] extends (e: unknown) => Fx<unknown, infer E2, unknown>
-            ? E2
-            : never;
-        }[keyof Cases],
-      | R
-      | {
-          [K in keyof Cases]: Cases[K] extends (e: unknown) => Fx<unknown, unknown, infer R2>
-            ? R2
-            : never;
-        }[keyof Cases]
-    >((sink) =>
-      self.run(
-        makeSink(
-          (cause) => {
-            const result = Cause.findFail(cause);
-            if (Result.isFailure(result)) {
-              return sink.onFailure(result.failure);
-            }
-            const error = result.success.error as E;
-            if (!hasTag(error)) {
-              return sink.onFailure(
-                cause as Cause.Cause<
-                  | Exclude<E, { _tag: keyof Cases }>
-                  | {
-                      [K in keyof Cases]: Cases[K] extends (
-                        e: unknown,
-                      ) => Fx<unknown, infer E2, unknown>
-                        ? E2
-                        : never;
-                    }[keyof Cases]
-                >,
-              );
-            }
-            const tag = (error as { _tag: string })._tag;
-            const handler = (cases as Record<
-              string,
-              (e: unknown) => Fx<unknown, unknown, unknown>
-            >)[tag];
-            if (handler !== undefined) {
-              return handler(error).run(
-                sink as import("../../Sink/Sink.js").Sink<
-                  unknown,
-                  unknown,
-                  import("../../Sink/Sink.js").Context<typeof sink>
-                >,
-              );
-            }
-            return sink.onFailure(
-              cause as Cause.Cause<
-                | Exclude<E, { _tag: keyof Cases }>
-                | {
-                    [K in keyof Cases]: Cases[K] extends (
-                      e: unknown,
-                    ) => Fx<unknown, infer E2, unknown>
-                      ? E2
-                      : never;
-                  }[keyof Cases]
-              >,
-            );
-          },
-          sink.onSuccess,
-        ),
-      ) as import("effect/Effect").Effect<
-        unknown,
-        never,
-        | R
-        | {
-            [K in keyof Cases]: Cases[K] extends (
-              e: unknown,
-            ) => Fx<unknown, unknown, infer R2>
-              ? R2
-              : never;
-          }[keyof Cases]
-        | import("../../Sink/Sink.js").Context<typeof sink>
-      >,
-    ),
-);

package/src/Fx/combinators/causes.ts

@@ -1,23 +0,0 @@
-import type * as Cause from "effect/Cause";
-import * as Exit from "effect/Exit";
-import * as Option from "effect/Option";
-import type { Fx } from "../Fx.js";
-import { exit } from "./exit.js";
-import { filterMap } from "./filterMap.js";
-
-/**
- * Emits only the failure causes from an Fx, discarding successful values.
- *
- * @param fx - The `Fx` stream.
- * @returns An `Fx` emitting `Cause<E>`.
- * @since 1.0.0
- * @category combinators
- */
-export const causes = <A, E, R>(fx: Fx<A, E, R>): Fx<Cause.Cause<E>, never, R> =>
-  filterMap(
-    exit(fx),
-    Exit.match({
-      onFailure: Option.some,
-      onSuccess: Option.none,
-    }),
-  );

package/src/Fx/combinators/changesWithEffect.ts

@@ -1,66 +0,0 @@
-import * as Effect from "effect/Effect";
-import { dual } from "effect/Function";
-import * as Option from "effect/Option";
-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 consecutive elements that are considered equal by an effectful predicate.
- * When the effect returns `true`, the element is skipped; when `false`, it is emitted.
- *
- * This is the effectful variant of `skipRepeatsWith`: instead of a pure
- * `Equivalence<A>`, you supply `(prev, next) => Effect<boolean>` where `true`
- * means "equal" (skip) and `false` means "changed" (emit).
- *
- * @param f - Effectful function: `(prev, next) => Effect<boolean>`. Return `true` to skip (treat as duplicate), `false` to emit.
- * @returns An `Fx` with consecutive "equal" elements removed.
- * @since 1.0.0
- * @category combinators
- */
-export const changesWithEffect: {
-  <A, E2, R2>(
-    f: (prev: A, next: A) => Effect.Effect<boolean, E2, R2>,
-  ): <E, R>(fx: Fx<A, E | E2, R>) => Fx<A, E | E2, R | R2>;
-
-  <A, E, R, E2, R2>(
-    fx: Fx<A, E | E2, R>,
-    f: (prev: A, next: A) => Effect.Effect<boolean, E2, R2>,
-  ): Fx<A, E | E2, R | R2>;
-} = dual(
-  2,
-  <A, E, R, E2, R2>(
-    fx: Fx<A, E | E2, R>,
-    f: (prev: A, next: A) => Effect.Effect<boolean, E2, R2>,
-  ): Fx<A, E | E2, R | R2> =>
-    make<A, E | E2, R | R2>((sink) =>
-      sinkCore.withStateSemaphore(sink, Option.none<A>() as Option.Option<A>, (s) =>
-        fx.run(
-          makeSink(s.onFailure, (a2) =>
-            Effect.matchCauseEffect(
-              Effect.flatMap(s.get, (state) =>
-                Option.match(state, {
-                  onNone: () =>
-                    Effect.flatMap(s.onSuccess(a2), () =>
-                      s.updateEffect(() => Effect.succeed(Option.some(a2))),
-                    ),
-                  onSome: (prev) =>
-                    Effect.matchCauseEffect(f(prev, a2), {
-                      onFailure: (cause) => s.onFailure(cause),
-                      onSuccess: (equal) =>
-                        equal
-                          ? s.updateEffect(() => Effect.succeed(Option.some(prev)))
-                          : Effect.flatMap(s.onSuccess(a2), () =>
-                              s.updateEffect(() => Effect.succeed(Option.some(a2))),
-                            ),
-                    }),
-                }),
-              ),
-              { onFailure: (cause) => s.onFailure(cause), onSuccess: () => Effect.void },
-            ),
-          ),
-        ),
-      ),
-    ),
-);

package/src/Fx/combinators/compact.ts

@@ -1,15 +0,0 @@
-import type * as Option from "effect/Option";
-import * as sinkCore from "../../Sink/combinators.js";
-import { make } from "../constructors/make.js";
-import type { Fx } from "../Fx.js";
-
-/**
- * Compacts an Fx of Options, discarding `None` values and unwrapping `Some` values.
- *
- * @param self - An `Fx` emitting `Option<A>`.
- * @returns An `Fx` emitting `A`.
- * @since 1.0.0
- * @category combinators
- */
-export const compact = <A, E, R>(self: Fx<Option.Option<A>, E, R>): Fx<A, E, R> =>
-  make<A, E, R>((sink) => self.run(sinkCore.compact(sink)));

package/src/Fx/combinators/continueWith.ts

@@ -1,78 +0,0 @@
-import * as Effect from "effect/Effect";
-import { dual } from "effect/Function";
-import { make } from "../constructors/make.js";
-import { succeed } from "../constructors/succeed.js";
-import type { Fx } from "../Fx.js";
-
-/**
- * continues an Fx with another Fx after the first one completes.
- *
- * @param f - A function that returns the next Fx to run.
- * @returns An `Fx` that emits values from the first Fx, then from the second Fx.
- * @since 1.0.0
- * @category combinators
- */
-export const continueWith: {
-  <B, E2, R2>(f: () => Fx<B, E2, R2>): <A, E, R>(fx: Fx<A, E, R>) => Fx<A | B, E | E2, R | R2>;
-
-  <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: () => Fx<B, E2, R2>): Fx<A | B, E | E2, R | R2>;
-} = dual(
-  2,
-  <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: () => Fx<B, E2, R2>): Fx<A | B, E | E2, R | R2> =>
-    make<A | B, E | E2, R | R2>((sink) => Effect.flatMap(fx.run(sink), () => f().run(sink))),
-);
-
-/**
- * Appends a value to the end of an Fx.
- *
- * @param value - The value to append.
- * @returns An `Fx` that emits values from the input Fx, then the appended value.
- * @since 1.0.0
- * @category combinators
- */
-export const append: {
-  <B>(value: B): <A, E, R>(fx: Fx<A, E, R>) => Fx<A | B, E, R>;
-
-  <A, E, R, B>(fx: Fx<A, E, R>, value: B): Fx<A | B, E, R>;
-} = dual(
-  2,
-  <A, E, R, B>(fx: Fx<A, E, R>, value: B): Fx<A | B, E, R> =>
-    continueWith(fx, () => succeed(value)),
-);
-
-/**
- * Prepends a value to the beginning of an Fx.
- *
- * @param value - The value to prepend.
- * @returns An `Fx` that emits the prepended value, then values from the input Fx.
- * @since 1.0.0
- * @category combinators
- */
-export const prepend: {
-  <B>(value: B): <A, E, R>(fx: Fx<A, E, R>) => Fx<B | A, E, R>;
-
-  <A, E, R, B>(fx: Fx<A, E, R>, value: B): Fx<B | A, E, R>;
-} = dual(
-  2,
-  <A, E, R, B>(fx: Fx<A, E, R>, value: B): Fx<B | A, E, R> =>
-    continueWith(succeed(value), () => fx),
-);
-
-/**
- * Wraps an Fx with a start and end value.
- *
- * @param before - The value to emit before the Fx starts.
- * @param after - The value to emit after the Fx completes.
- * @returns An `Fx` that emits `before`, then values from the input Fx, then `after`.
- * @since 1.0.0
- * @category combinators
- */
-export const delimit: {
-  <B, C>(before: B, after: C): <A, E, R>(fx: Fx<A, E, R>) => Fx<A | B | C, E, R>;
-
-  <A, E, R, B, C>(fx: Fx<A, E, R>, before: B, after: C): Fx<A | B | C, E, R>;
-} = dual(
-  3,
-  <A, E, R, B, C>(fx: Fx<A, E, R>, before: B, after: C): Fx<A | B | C, E, R> =>
-    fx.pipe(prepend(before), append(after)),
-);

package/src/Fx/combinators/dropUntil.ts

@@ -1,47 +0,0 @@
-import * as Effect from "effect/Effect";
-import { dual } from "effect/Function";
-import type { Fx } from "../Fx.js";
-import { skipWhile, skipWhileEffect } from "./skipWhile.js";
-
-/**
- * Drops elements from an Fx until a predicate returns true.
- * Emits from the first element for which the predicate returns true (including that element) and all following elements.
- *
- * @param predicate - The predicate function.
- * @returns An `Fx` that emits once the predicate first matches.
- * @since 1.0.0
- * @category combinators
- */
-export const dropUntil: {
-  <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> =>
-    skipWhile(fx, (a) => !predicate(a)),
-);
-
-/**
- * Drops elements from an Fx until an effectful predicate returns true.
- * Emits from the first element for which the predicate effect succeeds with true (including that element) and all following elements.
- *
- * @param predicate - Effectful predicate function.
- * @returns An `Fx` that emits once the predicate first matches.
- * @since 1.0.0
- * @category combinators
- */
-export const dropUntilEffect: {
-  <A, E2, R2>(
-    predicate: (a: A) => Effect.Effect<boolean, E2, R2>,
-  ): <E, R>(fx: Fx<A, E, R>) => Fx<A, E | E2, R | R2>;
-  <A, E, R, E2, R2>(
-    fx: Fx<A, E, R>,
-    predicate: (a: A) => Effect.Effect<boolean, E2, R2>,
-  ): Fx<A, E | E2, R | R2>;
-} = dual(
-  2,
-  <A, E, R, E2, R2>(
-    fx: Fx<A, E, R>,
-    predicate: (a: A) => Effect.Effect<boolean, E2, R2>,
-  ): Fx<A, E | E2, R | R2> => skipWhileEffect(fx, (a) => Effect.map(predicate(a), (b) => !b)),
-);

package/src/Fx/combinators/ensuring.ts

@@ -1,23 +0,0 @@
-import * as Effect from "effect/Effect";
-import { dual } from "effect/Function";
-import { make } from "../constructors/make.js";
-import type { Fx } from "../Fx.js";
-
-/**
- * Adds an `Effect.ensuring`-style finalizer to an `Fx`.
- *
- * The finalizer is guaranteed to run when the stream terminates (success,
- * failure, or interruption).
- *
- * @since 1.0.0
- * @category combinators
- */
-export const ensuring: {
-  <R2>(finalizer: Effect.Effect<void, never, R2>): <A, E, R>(self: Fx<A, E, R>) => Fx<A, E, R | R2>;
-
-  <A, E, R, R2>(self: Fx<A, E, R>, finalizer: Effect.Effect<void, never, R2>): Fx<A, E, R | R2>;
-} = dual(
-  2,
-  <A, E, R, R2>(self: Fx<A, E, R>, finalizer: Effect.Effect<void, never, R2>): Fx<A, E, R | R2> =>
-    make<A, E, R | R2>((sink) => self.run(sink).pipe(Effect.ensuring(finalizer))),
-);