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

package/src/Fx/combinators/exhaustLatestMap.ts

@@ -1,74 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Fiber from "effect/Fiber";
-import { dual } from "effect/Function";
-import type * as Scope from "effect/Scope";
-import { make as makeSink, type Sink } 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, but only runs one inner Fx at a time.
- * If a new element arrives while an inner Fx is running, the new element is buffered (overwriting any previously buffered value).
- * When the current inner Fx completes, the latest buffered Fx is run.
- *
- * This is useful for scenarios where you want to ignore intermediate values but ensure the latest value is eventually processed.
- *
- * @param f - A function that maps an element `A` to a new `Fx<B>`.
- * @returns An `Fx` that emits values from the inner streams.
- * @since 1.0.0
- * @category combinators
- */
-export const exhaustLatestMap: 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> => {
-    return make<B, E | E2, R | R2 | Scope.Scope>(
-      Effect.fn(function* <RSink>(sink: Sink<B, E | E2, RSink>) {
-        let runningFiber: Fiber.Fiber<unknown, never> | undefined = undefined;
-        let nextEffectToFork: Effect.Effect<unknown, never, R2 | RSink> | undefined = undefined;
-
-        const scope = yield* Effect.scope;
-
-        const fork = (
-          effect: Effect.Effect<unknown, never, R2 | RSink>,
-        ): Effect.Effect<Fiber.Fiber<unknown, never>, never, RSink | R2> =>
-          Effect.forkIn(
-            effect.pipe(Effect.ensuring(Effect.zip(resetRunningFiber, runNext))),
-            scope,
-          );
-
-        const resetRunningFiber: Effect.Effect<void, never, never> = Effect.sync(
-          () => (runningFiber = undefined),
-        );
-
-        const runNext: Effect.Effect<void, never, R2 | RSink> = Effect.gen(function* () {
-          if (nextEffectToFork !== undefined) {
-            const eff = nextEffectToFork;
-            nextEffectToFork = undefined;
-            yield* exhaustLatestFork(eff);
-            // Ensure we don't close the scope until the last fiber completes
-            if (runningFiber !== undefined) yield* Fiber.join(runningFiber);
-          }
-        });
-
-        const exhaustLatestFork = Effect.fn(function* (
-          eff: Effect.Effect<void, never, R2 | RSink>,
-        ) {
-          if (runningFiber === undefined) {
-            runningFiber = yield* fork(eff);
-          } else {
-            nextEffectToFork = eff;
-          }
-        });
-
-        yield* self.run(makeSink(sink.onFailure, (a) => exhaustLatestFork(f(a).run(sink))));
-
-        if (runningFiber !== undefined) yield* Fiber.join(runningFiber as Fiber.Fiber<void, never>);
-      }, extendScope),
-    );
-  },
-);

package/src/Fx/combinators/exhaustLatestMapEffect.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 { exhaustLatestMap } from "./exhaustLatestMap.js";
-import type { FlatMapEffectLike } from "./flatMapEffect.js";
-
-/**
- * Maps each element of an Fx to an Effect, but only runs one effect at a time.
- * If a new element arrives while an effect is running, the new element is buffered (overwriting any previously buffered value).
- * When the current effect completes, the latest buffered effect is run.
- *
- * @param f - A function that maps an element `A` to an `Effect<B>`.
- * @returns An `Fx` that emits the results of the effects.
- * @since 1.0.0
- * @category combinators
- */
-export const exhaustLatestMapEffect: 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> => exhaustLatestMap(self, flow(f, fromEffect)),
-);

package/src/Fx/combinators/exhaustMap.ts

@@ -1,36 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as FiberHandle from "effect/FiberHandle";
-import { dual } from "effect/Function";
-import type * as Scope from "effect/Scope";
-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, ignoring new elements until the current inner Fx completes.
- *
- * @param f - A function that maps an element `A` to a new `Fx<B>`.
- * @returns An `Fx` that emits values from the active inner stream.
- * @since 1.0.0
- * @category combinators
- */
-export const exhaustMap: 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 handle = yield* FiberHandle.make<void, never>();
-        yield* self.run(
-          makeSink(sink.onFailure, (a) =>
-            FiberHandle.run(handle, f(a).run(sink), { onlyIfMissing: true }),
-          ),
-        );
-        yield* FiberHandle.awaitEmpty(handle);
-      }, extendScope),
-    ),
-);

package/src/Fx/combinators/exhaustMapEffect.ts

@@ -1,23 +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 { exhaustMap } from "./exhaustMap.js";
-import type { FlatMapEffectLike } from "./flatMapEffect.js";
-
-/**
- * Maps each element of an Fx to an Effect, ignoring new elements until the current effect completes.
- *
- * @param f - A function that maps an element `A` to an `Effect<B>`.
- * @returns An `Fx` that emits the results of the active effect.
- * @since 1.0.0
- * @category combinators
- */
-export const exhaustMapEffect: 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> => exhaustMap(self, flow(f, fromEffect)),
-);

package/src/Fx/combinators/exit.ts

@@ -1,15 +0,0 @@
-import type * as Exit from "effect/Exit";
-import * as sinkCore from "../../Sink/combinators.js";
-import { make } from "../constructors/make.js";
-import type { Fx } from "../Fx.js";
-
-/**
- * Materializes the success and failure of an Fx into `Exit` values.
- *
- * @param fx - The `Fx` stream.
- * @returns An `Fx` emitting `Exit<A, E>`.
- * @since 1.0.0
- * @category combinators
- */
-export const exit = <A, E, R>(fx: Fx<A, E, R>): Fx<Exit.Exit<A, E>, never, R> =>
-  make<Exit.Exit<A, E>, never, R>((sink) => fx.run(sinkCore.exit(sink)));

package/src/Fx/combinators/filter.ts

@@ -1,22 +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";
-
-/**
- * Filters elements of an Fx using a predicate function.
- *
- * @param f - A predicate function.
- * @returns An `Fx` that emits only the elements for which `f` returns `true`.
- * @since 1.0.0
- * @category combinators
- */
-export const filter: {
-  <A>(f: (a: A) => boolean): <E, R>(self: Fx<A, E, R>) => Fx<A, E, R>;
-
-  <A, E, R>(self: Fx<A, E, R>, f: (a: A) => boolean): Fx<A, E, R>;
-} = dual(
-  2,
-  <A, E, R>(self: Fx<A, E, R>, f: (a: A) => boolean): Fx<A, E, R> =>
-    make<A, E, R>((sink) => self.run(sinkCore.filter(sink, f))),
-);

package/src/Fx/combinators/filterEffect.ts

@@ -1,31 +0,0 @@
-import type * 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";
-
-/**
- * Filters elements of an Fx using an effectful predicate function.
- *
- * @param f - An effectful predicate function.
- * @returns An `Fx` that emits only the elements for which `f` returns `true`.
- * @since 1.0.0
- * @category combinators
- */
-export const filterEffect: {
-  <A, E2, R2>(
-    f: (a: A) => Effect.Effect<boolean, E2, R2>,
-  ): <E, R>(self: Fx<A, E | E2, R>) => Fx<A, E | E2, R | R2>;
-
-  <A, E, R, E2, R2>(
-    self: Fx<A, E | E2, R>,
-    f: (a: A) => Effect.Effect<boolean, E2, R2>,
-  ): Fx<A, E | E2, R | R2>;
-} = dual(
-  2,
-  <A, E, R, E2, R2>(
-    self: Fx<A, E, R>,
-    f: (a: A) => Effect.Effect<boolean, E2, R2>,
-  ): Fx<A, E | E2, R | R2> =>
-    make<A, E | E2, R | R2>((sink) => self.run(sinkCore.filterEffect(f)(sink))),
-);

package/src/Fx/combinators/filterMap.ts

@@ -1,23 +0,0 @@
-import { dual } from "effect/Function";
-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";
-
-/**
- * Maps and filters elements of an Fx in a single operation.
- *
- * @param f - A function that returns an `Option` for each element.
- * @returns An `Fx` that emits values for which `f` returns `Some`.
- * @since 1.0.0
- * @category combinators
- */
-export const filterMap: {
-  <A, B>(f: (a: A) => Option.Option<B>): <E, R>(self: Fx<A, E, R>) => Fx<B, E, R>;
-
-  <A, E, R, B>(self: Fx<A, E, R>, f: (a: A) => Option.Option<B>): Fx<B, E, R>;
-} = dual(
-  2,
-  <A, E, R, B>(self: Fx<A, E, R>, f: (a: A) => Option.Option<B>): Fx<B, E, R> =>
-    make<B, E, R>((sink) => self.run(sinkCore.filterMap(sink, f))),
-);

package/src/Fx/combinators/filterMapEffect.ts

@@ -1,32 +0,0 @@
-import type * as Effect from "effect/Effect";
-import { dual } from "effect/Function";
-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";
-
-/**
- * Maps and filters elements of an Fx using an effectful function.
- *
- * @param f - An effectful function that returns an `Option` for each element.
- * @returns An `Fx` that emits values for which `f` returns `Some`.
- * @since 1.0.0
- * @category combinators
- */
-export const filterMapEffect: {
-  <A, B, E2, R2>(
-    f: (a: A) => Effect.Effect<Option.Option<B>, E2, R2>,
-  ): <E, R>(self: Fx<A, E | E2, R>) => Fx<B, E | E2, R | R2>;
-
-  <A, E, R, B, E2, R2>(
-    self: Fx<A, E | E2, R>,
-    f: (a: A) => Effect.Effect<Option.Option<B>, E2, R2>,
-  ): Fx<B, E | E2, R | R2>;
-} = dual(
-  2,
-  <A, E, R, B, E2, R2>(
-    self: Fx<A, E, R>,
-    f: (a: A) => Effect.Effect<Option.Option<B>, E2, R2>,
-  ): Fx<B, E | E2, R | R2> =>
-    make<B, E | E2, R | R2>((sink) => self.run(sinkCore.filterMapEffect(f)(sink))),
-);

package/src/Fx/combinators/filterMapLoop.ts

@@ -1,35 +0,0 @@
-import { dual } from "effect/Function";
-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";
-
-/**
- * Loops over an Fx with an accumulator, producing an optional new value for each element.
- * If the function returns `None`, the element is filtered out.
- *
- * @param seed - The initial state.
- * @param f - The loop function returning `Option<C>` and the new state.
- * @returns An `Fx` emitting the transformed values.
- * @since 1.0.0
- * @category combinators
- */
-export const filterMapLoop: {
-  <B, A, C>(
-    seed: B,
-    f: (acc: B, a: A) => readonly [Option.Option<C>, B],
-  ): <E, R>(self: Fx<A, E, R>) => Fx<C, E, R>;
-
-  <A, E, R, B, C>(
-    self: Fx<A, E, R>,
-    seed: B,
-    f: (acc: B, a: A) => readonly [Option.Option<C>, B],
-  ): Fx<C, E, R>;
-} = dual(
-  3,
-  <A, E, R, B, C>(
-    self: Fx<A, E, R>,
-    seed: B,
-    f: (acc: B, a: A) => readonly [Option.Option<C>, B],
-  ): Fx<C, E, R> => make<C, E, R>((sink) => self.run(sinkCore.filterMapLoop(sink, seed, f))),
-);

package/src/Fx/combinators/filterMapLoopCause.ts

@@ -1,36 +0,0 @@
-import type * as Cause from "effect/Cause";
-import { dual } from "effect/Function";
-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";
-
-/**
- * Loops over the failure causes of an Fx with an accumulator, potentially transforming or filtering them.
- * This allows for complex error handling logic that maintains state across failures.
- *
- * @param seed - The initial state.
- * @param f - The loop function for causes.
- * @returns An `Fx` with transformed errors.
- * @since 1.0.0
- * @category combinators
- */
-export const filterMapLoopCause: {
-  <B, A, C>(
-    seed: B,
-    f: (acc: B, a: Cause.Cause<A>) => readonly [Option.Option<Cause.Cause<C>>, B],
-  ): <E, R>(self: Fx<A, E, R>) => Fx<A, C, R>;
-
-  <A, E, R, B, C>(
-    self: Fx<A, E, R>,
-    seed: B,
-    f: (acc: B, a: Cause.Cause<E>) => readonly [Option.Option<Cause.Cause<C>>, B],
-  ): Fx<A, C, R>;
-} = dual(
-  3,
-  <A, E, R, B, C>(
-    self: Fx<A, E, R>,
-    seed: B,
-    f: (acc: B, a: Cause.Cause<E>) => readonly [Option.Option<Cause.Cause<C>>, B],
-  ): Fx<A, C, R> => make<A, C, R>((sink) => self.run(sinkCore.filterMapLoopCause(sink, seed, f))),
-);

package/src/Fx/combinators/filterMapLoopCauseEffect.ts

@@ -1,46 +0,0 @@
-import type * as Cause from "effect/Cause";
-import type * as Effect from "effect/Effect";
-import { dual } from "effect/Function";
-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";
-
-/**
- * Effectfully loops over the failure causes of an Fx with an accumulator.
- *
- * @param seed - The initial state.
- * @param f - The effectful loop function for causes.
- * @returns An `Fx` with transformed errors.
- * @since 1.0.0
- * @category combinators
- */
-export const filterMapLoopCauseEffect: {
-  <B, A, E2, R2, C>(
-    seed: B,
-    f: (
-      acc: B,
-      a: Cause.Cause<A>,
-    ) => Effect.Effect<readonly [Option.Option<Cause.Cause<C>>, B], E2, R2>,
-  ): <E, R>(self: Fx<A, E | E2, R>) => Fx<A, C | E2, R | R2>;
-
-  <A, E, R, B, R2, C>(
-    self: Fx<A, E, R>,
-    seed: B,
-    f: (
-      acc: B,
-      a: Cause.Cause<E>,
-    ) => Effect.Effect<readonly [Option.Option<Cause.Cause<C>>, B], C, R2>,
-  ): Fx<A, C, R | R2>;
-} = dual(
-  3,
-  <A, E, R, B, R2, C>(
-    self: Fx<A, E, R>,
-    seed: B,
-    f: (
-      acc: B,
-      a: Cause.Cause<E>,
-    ) => Effect.Effect<readonly [Option.Option<Cause.Cause<C>>, B], C, R2>,
-  ): Fx<A, C, R | R2> =>
-    make<A, C, R | R2>((sink) => self.run(sinkCore.filterMapLoopCauseEffect(sink, seed, f))),
-);

package/src/Fx/combinators/filterMapLoopEffect.ts

@@ -1,36 +0,0 @@
-import type * as Effect from "effect/Effect";
-import { dual } from "effect/Function";
-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";
-
-/**
- * Effectfully loops over an Fx with an accumulator, producing an optional new value.
- *
- * @param seed - The initial state.
- * @param f - The effectful loop function.
- * @returns An `Fx` emitting the transformed values.
- * @since 1.0.0
- * @category combinators
- */
-export const filterMapLoopEffect: {
-  <B, A, E2, R2, C>(
-    seed: B,
-    f: (acc: B, a: A) => Effect.Effect<readonly [Option.Option<C>, B], E2, R2>,
-  ): <E, R>(self: Fx<A, E | E2, R>) => Fx<C, E | E2, R | R2>;
-
-  <A, E, R, B, R2, C>(
-    self: Fx<A, E, R>,
-    seed: B,
-    f: (acc: B, a: A) => Effect.Effect<readonly [Option.Option<C>, B], E, R2>,
-  ): Fx<C, E, R | R2>;
-} = dual(
-  3,
-  <A, E, R, B, R2, C>(
-    self: Fx<A, E, R>,
-    seed: B,
-    f: (acc: B, a: A) => Effect.Effect<readonly [Option.Option<C>, B], E, R2>,
-  ): Fx<C, E, R | R2> =>
-    make<C, E, R | R2>((sink) => self.run(sinkCore.filterMapLoopEffect(sink, seed, f))),
-);

package/src/Fx/combinators/flatMap.ts

@@ -1,51 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as FiberSet from "effect/FiberSet";
-import { dual } from "effect/Function";
-import type * as Scope from "effect/Scope";
-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";
-
-/**
- * Type definition for flatMap functions to support variable arguments.
- * @since 1.0.0
- * @category types
- */
-export type FlatMapLike<Args extends ReadonlyArray<any> = []> = {
-  <A, B, E2, R2>(
-    f: (a: A) => Fx<B, E2, R2>,
-    ...args: Args
-  ): <E, R>(self: Fx<A, E, R>) => Fx<B, E | E2, R | R2 | Scope.Scope>;
-
-  <A, E, R, B, E2, R2>(
-    self: Fx<A, E, R>,
-    f: (a: A) => Fx<B, E2, R2>,
-    ...args: Args
-  ): Fx<B, E | E2, R | R2 | Scope.Scope>;
-};
-
-/**
- * Maps each element of an Fx to a new Fx, and merges the results.
- *
- * The inner Fx streams are run concurrently. This is equivalent to `mergeMap` in RxJS.
- *
- * @param f - A function that maps an element `A` to a new `Fx<B>`.
- * @returns An `Fx` that emits values from all inner streams.
- * @since 1.0.0
- * @category combinators
- */
-export const flatMap: 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 set = yield* FiberSet.make<void, never>();
-        yield* self.run(makeSink(sink.onFailure, (a) => FiberSet.run(set, f(a).run(sink))));
-        yield* FiberSet.awaitEmpty(set);
-      }, extendScope),
-    ),
-);

package/src/Fx/combinators/flatMapConcurrently.ts

@@ -1,39 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as FiberSet from "effect/FiberSet";
-import * as Semaphore from "effect/Semaphore";
-import { dual } from "effect/Function";
-import type * as Scope from "effect/Scope";
-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, running them concurrently with a limit.
- *
- * @param f - A function that maps an element `A` to a new `Fx<B>`.
- * @param concurrency - The maximum number of concurrent inner streams.
- * @returns An `Fx` that emits values from the inner streams.
- * @since 1.0.0
- * @category combinators
- */
-export const flatMapConcurrently: FlatMapLike<[concurrency: number]> = dual(
-  3,
-  <A, E, R, B, E2, R2>(
-    self: Fx<A, E, R>,
-    f: (a: A) => Fx<B, E2, R2>,
-    concurrency: number,
-  ): Fx<B, E | E2, R | R2 | Scope.Scope> =>
-    make<B, E | E2, R | R2 | Scope.Scope>(
-      Effect.fn(function* (sink) {
-        const semaphore = yield* Semaphore.make(concurrency);
-        const lock = semaphore.withPermits(1);
-        const set = yield* FiberSet.make<void, never>();
-        yield* self.run(
-          makeSink(sink.onFailure, (a) => FiberSet.run(set, lock(Effect.asVoid(f(a).run(sink))))),
-        );
-        yield* FiberSet.awaitEmpty(set);
-      }, extendScope),
-    ),
-);

package/src/Fx/combinators/flatMapConcurrentlyEffect.ts

@@ -1,26 +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 { flatMapConcurrently } from "./flatMapConcurrently.js";
-import type { FlatMapEffectLike } from "./flatMapEffect.js";
-
-/**
- * Maps each element of an Fx to an Effect, running them concurrently with a limit.
- *
- * @param f - A function that maps an element `A` to an `Effect<B>`.
- * @param concurrency - The maximum number of concurrent effects.
- * @returns An `Fx` that emits the results of the effects.
- * @since 1.0.0
- * @category combinators
- */
-export const flatMapConcurrentlyEffect: FlatMapEffectLike<[concurrency: number]> = dual(
-  3,
-  <A, E, R, B, E2, R2>(
-    self: Fx<A, E, R>,
-    f: (a: A) => Effect.Effect<B, E2, R2>,
-    concurrency: number,
-  ): Fx<B, E | E2, R | R2 | Scope.Scope> =>
-    flatMapConcurrently(self, flow(f, fromEffect), concurrency),
-);

package/src/Fx/combinators/flatMapEffect.ts

@@ -1,42 +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 { flatMap } from "./flatMap.js";
-
-/**
- * Type definition for flatMapEffect functions to support variable arguments.
- * @since 1.0.0
- * @category types
- */
-export type FlatMapEffectLike<Args extends ReadonlyArray<any> = []> = {
-  <A, B, E2, R2>(
-    f: (a: A) => Effect.Effect<B, E2, R2>,
-    ...args: Args
-  ): <E, R>(self: Fx<A, E, R>) => Fx<B, E | E2, R | R2 | Scope.Scope>;
-
-  <A, E, R, B, E2, R2>(
-    self: Fx<A, E, R>,
-    f: (a: A) => Effect.Effect<B, E2, R2>,
-    ...args: Args
-  ): Fx<B, E | E2, R | R2 | Scope.Scope>;
-};
-
-/**
- * Maps each element of an Fx to an Effect, and merges the results.
- *
- * The effects are run concurrently.
- *
- * @param f - A function that maps an element `A` to an `Effect<B>`.
- * @returns An `Fx` that emits the results of the effects.
- * @since 1.0.0
- * @category combinators
- */
-export const flatMapEffect: 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> => flatMap(self, flow(f, fromEffect)),
-);

package/src/Fx/combinators/flip.ts

@@ -1,14 +0,0 @@
-import * as sinkCore from "../../Sink/combinators.js";
-import { make } from "../constructors/make.js";
-import type { Fx } from "../Fx.js";
-
-/**
- * Flips the error and success channels of an Fx.
- *
- * @param fx - The `Fx` stream.
- * @returns An `Fx` where errors are successes and successes are errors.
- * @since 1.0.0
- * @category combinators
- */
-export const flip = <A, E, R>(fx: Fx<A, E, R>): Fx<E, A, R> =>
-  make<E, A, R>((sink) => fx.run(sinkCore.flip(sink)));

package/src/Fx/combinators/gen.ts

@@ -1,24 +0,0 @@
-import * as Effect from "effect/Effect";
-import type { Fx } from "../Fx.js";
-import { unwrap } from "./unwrap.js";
-
-/** Extract error type from Yieldable (Effect v4) */
-type _YE<Y> = Y extends Effect.Yieldable<any, any, infer E, any> ? E : never;
-/** Extract services type from Yieldable (Effect v4) */
-type _YS<Y> = Y extends Effect.Yieldable<any, any, any, infer R> ? R : never;
-
-/**
- * Creates an Fx using a generator function (Effect.gen style).
- *
- * This allows writing Fx code in a synchronous-looking style, using `yield*` to composition.
- * Note: The generator yields Effects, and the result is an Fx.
- *
- * @param f - The generator function.
- * @returns An `Fx` representing the result of the generator.
- * @since 1.0.0
- * @category combinators
- */
-export const gen = <Yield extends Effect.Yieldable<any, any, any, any>, Return extends Fx.Any>(
-  f: () => Generator<Yield, Return, any>,
-): Fx<Fx.Success<Return>, Fx.Error<Return> | _YE<Yield>, Fx.Services<Return> | _YS<Yield>> =>
-  unwrap(Effect.gen(f)) as any;