@typed/fx 1.32.0 → 2.0.0-beta.1

package/src/Fx/combinators/exhaustLatestMap.ts

@@ -0,0 +1,74 @@
+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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,46 @@
+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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,51 @@
+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

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,24 @@
+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;