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

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/skipWhile.ts

@@ -1,100 +0,0 @@
-import * as Effect from "effect/Effect";
-import { dual } from "effect/Function";
-import * as Ref from "effect/Ref";
-import { make as makeFx } from "../constructors/make.js";
-import type { Fx } from "../Fx.js";
-import { make as makeSink } from "../../Sink/Sink.js";
-
-/**
- * Skips elements from an Fx while a predicate returns true.
- * Emits from the first element for which the predicate returns false (including that element) and all following elements.
- *
- * @param predicate - The predicate function.
- * @returns An `Fx` that emits once the predicate first fails.
- * @since 1.0.0
- * @category combinators
- */
-export const skipWhile: {
-  <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) =>
-      Effect.gen(function* () {
-        const skippingRef = yield* Ref.make(true);
-        const skipSink = makeSink(sink.onFailure, (a: A) =>
-          Effect.gen(function* () {
-            const skipping = yield* Ref.get(skippingRef);
-            if (skipping) {
-              if (predicate(a)) return;
-              yield* Ref.set(skippingRef, false);
-            }
-            return yield* sink.onSuccess(a);
-          }),
-        );
-        return yield* fx.run(skipSink);
-      }),
-    ),
-);
-
-/**
- * Skips elements from an Fx while an effectful predicate returns true.
- * Emits from the first element for which the predicate effect succeeds with false (including that element) and all following elements.
- *
- * @param predicate - Effectful predicate function.
- * @returns An `Fx` that emits once the predicate first fails.
- * @since 1.0.0
- * @category combinators
- */
-export const skipWhileEffect: {
-  <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> =>
-    makeFx<A, E | E2, R | R2>((sink) =>
-      Effect.gen(function* () {
-        const skippingRef = yield* Ref.make(true);
-        const skipSink = makeSink(sink.onFailure, (a: A) =>
-          Effect.matchCauseEffect(predicate(a), {
-            onFailure: sink.onFailure,
-            onSuccess: (ok) =>
-              Effect.gen(function* () {
-                const skipping = yield* Ref.get(skippingRef);
-                if (skipping) {
-                  if (ok) return;
-                  yield* Ref.set(skippingRef, false);
-                }
-                return yield* sink.onSuccess(a);
-              }),
-          }),
-        );
-        return yield* fx.run(skipSink);
-      }),
-    ),
-);
-
-/**
- * Alias of `skipWhile` for Effect parity (`dropWhile` naming).
- *
- * @since 1.0.0
- * @category combinators
- */
-export const dropWhile = skipWhile;
-
-/**
- * Alias of `skipWhileEffect` for Effect parity (`dropWhileEffect` naming).
- *
- * @since 1.0.0
- * @category combinators
- */
-export const dropWhileEffect = skipWhileEffect;

package/src/Fx/combinators/slice.ts

@@ -1,55 +0,0 @@
-import * as Effect from "effect/Effect";
-import { dual } from "effect/Function";
-import * as sinkCore from "../../Sink/combinators.js";
-import { make } from "../constructors/make.js";
-import type { Fx } from "../Fx.js";
-import { unwrap } from "./unwrap.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))),
-);
-
-/**
- * Slices an Fx with bounds produced by an Effect.
- *
- * @param bounds - Effect that produces slice bounds.
- * @returns An `Fx` representing the slice.
- * @since 1.0.0
- * @category combinators
- */
-export const sliceEffect: {
-  <E2, R2>(
-    bounds: Effect.Effect<Bounds, E2, R2>,
-  ): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E | E2, R | R2>;
-  <A, E, R, E2, R2>(fx: Fx<A, E, R>, bounds: Effect.Effect<Bounds, E2, R2>): Fx<A, E | E2, R | R2>;
-} = dual(
-  2,
-  <A, E, R, E2, R2>(
-    fx: Fx<A, E, R>,
-    bounds: Effect.Effect<Bounds, E2, R2>,
-  ): Fx<A, E | E2, R | R2> => unwrap(Effect.map(bounds, (b) => slice(fx, b))),
-);

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,38 +0,0 @@
-import * as Effect from "effect/Effect";
-import { dual } from "effect/Function";
-import type { Fx } from "../Fx.js";
-import { slice } from "./slice.js";
-import { unwrap } from "./unwrap.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 }));
-
-/**
- * Takes the first `n` elements where `n` is produced by an Effect.
- *
- * @param count - Effect that produces the number of elements to take.
- * @returns An `Fx` that emits at most `n` elements.
- * @since 1.0.0
- * @category combinators
- */
-export const takeEffect: {
-  <E2, R2>(
-    count: Effect.Effect<number, E2, R2>,
-  ): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E | E2, R | R2>;
-  <A, E, R, E2, R2>(fx: Fx<A, E, R>, count: Effect.Effect<number, E2, R2>): Fx<A, E | E2, R | R2>;
-} = dual(
-  2,
-  <A, E, R, E2, R2>(fx: Fx<A, E, R>, count: Effect.Effect<number, E2, R2>): Fx<A, E | E2, R | R2> =>
-    unwrap(Effect.map(count, (n) => take(fx, n))),
-);

package/src/Fx/combinators/takeUntil.ts

@@ -1,88 +0,0 @@
-import * as Effect from "effect/Effect";
-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);
-        }),
-      ),
-    ),
-  );
-});
-
-/**
- * Takes elements from an Fx until an effectful predicate returns true.
- * The element that satisfies the predicate is not included in the output.
- *
- * @param predicate - Effectful predicate function.
- * @returns An `Fx` that completes when the predicate matches.
- * @since 1.0.0
- * @category combinators
- */
-export const takeUntilEffect: {
-  <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> =>
-    makeFx<A, E | E2, R | R2>((sink) =>
-      combinators.withEarlyExit(sink, (sink) =>
-        fx.run(
-          makeSink(sink.onFailure, (a) =>
-            Effect.matchCauseEffect(predicate(a), {
-              onFailure: sink.onFailure,
-              onSuccess: (matches) => (matches ? sink.earlyExit : 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))),
-);

package/src/Fx/combinators/takeWhile.ts

@@ -1,47 +0,0 @@
-import * as Effect from "effect/Effect";
-import { dual } from "effect/Function";
-import type { Fx } from "../Fx.js";
-import { takeUntil, takeUntilEffect } from "./takeUntil.js";
-
-/**
- * Takes elements from an Fx while a predicate returns true.
- * Stops at the first element for which the predicate returns false; that element is not included.
- *
- * @param predicate - The predicate function.
- * @returns An `Fx` that emits while the predicate holds.
- * @since 1.0.0
- * @category combinators
- */
-export const takeWhile: {
-  <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> =>
-    takeUntil(fx, (a) => !predicate(a)),
-);
-
-/**
- * Takes elements from an Fx while an effectful predicate returns true.
- * Stops at the first element for which the predicate effect succeeds with false; that element is not included.
- *
- * @param predicate - Effectful predicate function.
- * @returns An `Fx` that emits while the predicate holds.
- * @since 1.0.0
- * @category combinators
- */
-export const takeWhileEffect: {
-  <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> => takeUntilEffect(fx, (a) => Effect.map(predicate(a), (b) => !b)),
-);

package/src/Fx/combinators/tapEffect.ts

@@ -1,39 +0,0 @@
-import * as Effect from "effect/Effect";
-import { dual } from "effect/Function";
-import * as sinkCore from "../../Sink/combinators.js";
-import { make } from "../constructors/make.js";
-import type { Fx } from "../Fx.js";
-
-/**
- * Performs an effect for each element of the Fx, without changing the elements.
- *
- * @param f - An effectful function to apply to each element.
- * @returns An `Fx` that emits the original elements.
- * @since 1.0.0
- * @category combinators
- */
-export const tap: {
-  <A, E2 = never, R2 = never>(
-    f: (a: A) => void | Effect.Effect<unknown, E2, R2>,
-  ): <E, R>(self: Fx<A, E | E2, R>) => Fx<A, E | E2, R | R2>;
-
-  <A, E, R, E2 = never, R2 = never>(
-    self: Fx<A, E | E2, R>,
-    f: (a: A) => void | Effect.Effect<unknown, E2, R2>,
-  ): Fx<A, E | E2, R | R2>;
-} = dual(
-  2,
-  <A, E, R, E2, R2>(
-    self: Fx<A, E, R>,
-    f: (a: A) => void | Effect.Effect<unknown, E2, R2>,
-  ): Fx<A, E | E2, R | R2> =>
-    make<A, E | E2, R | R2>((sink) =>
-      self.run(
-        sinkCore.tapEffect(sink, (a) => {
-          const x = f(a);
-          if (Effect.isEffect(x)) return x;
-          return Effect.void;
-        }),
-      ),
-    ),
-);

package/src/Fx/combinators/tuple.ts

@@ -1,79 +0,0 @@
-import * as Effect from "effect/Effect";
-import { make as makeSink } from "../../Sink/Sink.js";
-import { make } from "../constructors/make.js";
-import { succeed } from "../constructors/succeed.js";
-import type { Fx } from "../Fx.js";
-import { map } from "./map.js";
-
-/**
- * Combines multiple Fx streams into a single Fx that emits a tuple of the latest values from each stream.
- * The resulting Fx waits for all input streams to emit at least once before emitting the first tuple.
- * Afterwards, it emits a new tuple whenever any input stream emits a new value.
- *
- * @param fxs - The Fx streams to combine.
- * @returns An `Fx` emitting tuples of values.
- * @since 1.0.0
- * @category combinators
- */
-export function tuple<FX extends ReadonlyArray<Fx<any, any, any>>>(
-  ...fxs: FX
-): Fx<
-  { readonly [K in keyof FX]: Fx.Success<FX[K]> },
-  Fx.Error<FX[number]>,
-  Fx.Services<FX[number]>
-> {
-  if (fxs.length === 0) return succeed([] as { readonly [K in keyof FX]: Fx.Success<FX[K]> });
-  if (fxs.length === 1) return fxs[0];
-
-  type Result = { readonly [K in keyof FX]: Fx.Success<FX[K]> };
-  return make(
-    Effect.fn(function* (sink) {
-      const len = fxs.length;
-      // oxlint-disable-next-line unicorn/no-new-array
-      const result: Array<Fx.Success<FX[number]>> = new Array(len);
-      const filled = new Set<number>();
-
-      return yield* Effect.forEach(
-        fxs,
-        (fx, i) =>
-          fx.run(
-            makeSink(
-              sink.onFailure,
-              Effect.fn(function* (value) {
-                result[i] = value;
-                filled.add(i);
-                if (filled.size === len) {
-                  yield* sink.onSuccess(result as Result);
-                }
-              }),
-            ),
-          ),
-        { concurrency: "unbounded", discard: true },
-      );
-    }),
-  );
-}
-
-/**
- * Combines a record of Fx streams into a single Fx that emits a record of the latest values.
- * Similar to `tuple`, but for objects.
- *
- * @param fxs - A record of Fx streams.
- * @returns An `Fx` emitting records of values.
- * @since 1.0.0
- * @category combinators
- */
-export function struct<FXS extends Readonly<Record<string, Fx<any, any, any>>>>(
-  fxs: FXS,
-): Fx<
-  { readonly [K in keyof FXS]: Fx.Success<FXS[K]> },
-  Fx.Error<FXS[keyof FXS]>,
-  Fx.Services<FXS[keyof FXS]>
-> {
-  return map(
-    tuple(...Object.entries(fxs).map(([key, fx]) => map(fx, (value) => [key, value] as const))),
-    Object.fromEntries as (entries: ReadonlyArray<readonly [string, any]>) => {
-      readonly [K in keyof FXS]: Fx.Success<FXS[K]>;
-    },
-  );
-}

package/src/Fx/combinators/unwrap.ts

@@ -1,21 +0,0 @@
-import * as Effect from "effect/Effect";
-import { make } from "../constructors/make.js";
-import type { Fx } from "../Fx.js";
-
-/**
- * Unwraps an Effect that produces an Fx into a single Fx.
- *
- * @param effect - An `Effect` that produces an `Fx`.
- * @returns An `Fx` that runs the effect and then the produced Fx.
- * @since 1.0.0
- * @category combinators
- */
-export const unwrap = <A, E, R, E2, R2>(
-  effect: Effect.Effect<Fx<A, E, R>, E2, R2>,
-): Fx<A, E | E2, R | R2> =>
-  make<A, E | E2, R | R2>((sink) =>
-    Effect.matchCauseEffect(effect, {
-      onFailure: (cause) => sink.onFailure(cause),
-      onSuccess: (fx) => fx.run(sink),
-    }),
-  );

package/src/Fx/combinators/unwrapScoped.ts

@@ -1,26 +0,0 @@
-import * as Effect from "effect/Effect";
-import type * as Scope from "effect/Scope";
-import { make } from "../constructors/make.js";
-import type { Fx } from "../Fx.js";
-
-/**
- * Unwraps an Effect that produces an Fx into a single Fx, managing the scope of the effect.
- *
- * The scope of the effect is closed when the Fx completes or is interrupted.
- *
- * @param effect - An `Effect` that produces an `Fx`.
- * @returns An `Fx` that runs the effect and then the produced Fx.
- * @since 1.0.0
- * @category combinators
- */
-export const unwrapScoped = <A, E, R, E2, R2>(
-  effect: Effect.Effect<Fx<A, E, R>, E2, R2 | Scope.Scope>,
-): Fx<A, E | E2, Exclude<R | R2, Scope.Scope>> =>
-  make<A, E | E2, Exclude<R | R2, Scope.Scope>>((sink) =>
-    Effect.scoped(
-      Effect.matchCauseEffect(effect, {
-        onFailure: (cause) => sink.onFailure(cause),
-        onSuccess: (fx) => fx.run(sink),
-      }),
-    ),
-  );

package/src/Fx/combinators/when.ts

@@ -1,64 +0,0 @@
-import { dual } from "effect/Function";
-import type { Scope } from "effect/Scope";
-import { succeed } from "../constructors/succeed.js";
-import type { Fx } from "../Fx.js";
-import { switchMap } from "./switchMap.js";
-
-/**
- * Conditionally runs one of two Fx streams based on the boolean value emitted by the condition stream.
- *
- * @param condition - An `Fx` emitting booleans.
- * @param matchers - An object containing `onTrue` and `onFalse` Fx streams.
- * @returns An `Fx` that switches between `onTrue` and `onFalse` based on the condition.
- * @since 1.0.0
- * @category combinators
- */
-const if_: {
-  <B, E2, R2, C, E3, R3>(matchers: {
-    onTrue: Fx<B, E2, R2>;
-    onFalse: Fx<C, E3, R3>;
-  }): <E, R>(condition: Fx<boolean, E, R>) => Fx<B | C, E | E2 | E3, R | R2 | R3 | Scope>;
-
-  <E, R, B, E2, R2, C, E3, R3>(
-    condition: Fx<boolean, E, R>,
-    matchers: {
-      onTrue: Fx<B, E2, R2>;
-      onFalse: Fx<C, E3, R3>;
-    },
-  ): Fx<B | C, E | E2 | E3, R | R2 | R3 | Scope>;
-} = dual(
-  2,
-  <E, R, B, E2, R2, C, E3, R3>(
-    condition: Fx<boolean, E, R>,
-    matchers: {
-      onTrue: Fx<B, E2, R2>;
-      onFalse: Fx<C, E3, R3>;
-    },
-  ): Fx<B | C, E | E2 | E3, R | R2 | R3 | Scope> => {
-    return switchMap(
-      condition,
-      (pass): Fx<B | C, E2 | E3, R2 | R3> => (pass ? matchers.onTrue : matchers.onFalse),
-    );
-  },
-);
-
-export { if_ as if };
-
-/**
- * Conditionally emits one of two values based on the boolean value emitted by the condition stream.
- *
- * @param condition - An `Fx` emitting booleans.
- * @param matchers - An object containing `onTrue` and `onFalse` values.
- * @returns An `Fx` that emits the matched value.
- * @since 1.0.0
- * @category combinators
- */
-export const when = <E, R, B, C>(
-  condition: Fx<boolean, E, R>,
-  matchers: {
-    onTrue: B;
-    onFalse: C;
-  },
-): Fx<B | C, E, R | Scope> => {
-  return if_(condition, { onTrue: succeed(matchers.onTrue), onFalse: succeed(matchers.onFalse) });
-};