@typed/fx 1.32.0 → 2.0.0-beta.1

package/dist/Fx/combinators/ensuring.js

@@ -0,0 +1,13 @@
+import * as Effect from "effect/Effect";
+import { dual } from "effect/Function";
+import { make } from "../constructors/make.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 = dual(2, (self, finalizer) => make((sink) => self.run(sink).pipe(Effect.ensuring(finalizer))));

package/dist/Fx/combinators/exhaustLatestMap.d.ts

@@ -0,0 +1,15 @@
+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 declare const exhaustLatestMap: FlatMapLike;
+//# sourceMappingURL=exhaustLatestMap.d.ts.map

package/dist/Fx/combinators/exhaustLatestMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exhaustLatestMap.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/exhaustLatestMap.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEhD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gBAAgB,EAAE,WAmD9B,CAAC"}

package/dist/Fx/combinators/exhaustLatestMap.js

@@ -0,0 +1,48 @@
+import * as Effect from "effect/Effect";
+import * as Fiber from "effect/Fiber";
+import { dual } from "effect/Function";
+import { make as makeSink } from "../../Sink/Sink.js";
+import { make } from "../constructors/make.js";
+import { extendScope } from "../internal/scope.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 = dual(2, (self, f) => {
+    return make(Effect.fn(function* (sink) {
+        let runningFiber = undefined;
+        let nextEffectToFork = undefined;
+        const scope = yield* Effect.scope;
+        const fork = (effect) => Effect.forkIn(effect.pipe(Effect.ensuring(Effect.zip(resetRunningFiber, runNext))), scope);
+        const resetRunningFiber = Effect.sync(() => (runningFiber = undefined));
+        const runNext = 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) {
+            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);
+    }, extendScope));
+});

package/dist/Fx/combinators/exhaustLatestMapEffect.d.ts

@@ -0,0 +1,13 @@
+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 declare const exhaustLatestMapEffect: FlatMapEffectLike;
+//# sourceMappingURL=exhaustLatestMapEffect.d.ts.map

package/dist/Fx/combinators/exhaustLatestMapEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exhaustLatestMapEffect.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/exhaustLatestMapEffect.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAE5D;;;;;;;;;GASG;AACH,eAAO,MAAM,sBAAsB,EAAE,iBAMpC,CAAC"}

package/dist/Fx/combinators/exhaustLatestMapEffect.js

@@ -0,0 +1,14 @@
+import { dual, flow } from "effect/Function";
+import { fromEffect } from "../constructors/fromEffect.js";
+import { exhaustLatestMap } from "./exhaustLatestMap.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 = dual(2, (self, f) => exhaustLatestMap(self, flow(f, fromEffect)));

package/dist/Fx/combinators/exhaustMap.d.ts

@@ -0,0 +1,11 @@
+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 declare const exhaustMap: FlatMapLike;
+//# sourceMappingURL=exhaustMap.d.ts.map

package/dist/Fx/combinators/exhaustMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exhaustMap.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/exhaustMap.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEhD;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU,EAAE,WAiBxB,CAAC"}

package/dist/Fx/combinators/exhaustMap.js

@@ -0,0 +1,19 @@
+import * as Effect from "effect/Effect";
+import * as FiberHandle from "effect/FiberHandle";
+import { dual } from "effect/Function";
+import { make as makeSink } from "../../Sink/Sink.js";
+import { make } from "../constructors/make.js";
+import { extendScope } from "../internal/scope.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 = dual(2, (self, f) => make(Effect.fn(function* (sink) {
+    const handle = yield* FiberHandle.make();
+    yield* self.run(makeSink(sink.onFailure, (a) => FiberHandle.run(handle, f(a).run(sink), { onlyIfMissing: true })));
+    yield* FiberHandle.awaitEmpty(handle);
+}, extendScope)));

package/dist/Fx/combinators/exhaustMapEffect.d.ts

@@ -0,0 +1,11 @@
+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 declare const exhaustMapEffect: FlatMapEffectLike;
+//# sourceMappingURL=exhaustMapEffect.d.ts.map

package/dist/Fx/combinators/exhaustMapEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exhaustMapEffect.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/exhaustMapEffect.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAE5D;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,EAAE,iBAM9B,CAAC"}

package/dist/Fx/combinators/exhaustMapEffect.js

@@ -0,0 +1,12 @@
+import { dual, flow } from "effect/Function";
+import { fromEffect } from "../constructors/fromEffect.js";
+import { exhaustMap } from "./exhaustMap.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 = dual(2, (self, f) => exhaustMap(self, flow(f, fromEffect)));

package/dist/Fx/combinators/exit.d.ts

@@ -0,0 +1,12 @@
+import type * as Exit from "effect/Exit";
+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 declare const exit: <A, E, R>(fx: Fx<A, E, R>) => Fx<Exit.Exit<A, E>, never, R>;
+//# sourceMappingURL=exit.d.ts.map

package/dist/Fx/combinators/exit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exit.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/exit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,IAAI,MAAM,aAAa,CAAC;AAGzC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAEnC;;;;;;;GAOG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAG,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CACJ,CAAC"}

package/dist/Fx/combinators/exit.js

@@ -0,0 +1,11 @@
+import * as sinkCore from "../../Sink/combinators.js";
+import { make } from "../constructors/make.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 = (fx) => make((sink) => fx.run(sinkCore.exit(sink)));

package/dist/Fx/combinators/filter.d.ts

@@ -0,0 +1,14 @@
+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 declare 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>;
+};
+//# sourceMappingURL=filter.d.ts.map

package/dist/Fx/combinators/filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/filter.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAEnC;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM,EAAE;IACnB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAEpE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;CAKjE,CAAC"}

package/dist/Fx/combinators/filter.js

@@ -0,0 +1,12 @@
+import { dual } from "effect/Function";
+import * as sinkCore from "../../Sink/combinators.js";
+import { make } from "../constructors/make.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 = dual(2, (self, f) => make((sink) => self.run(sinkCore.filter(sink, f))));

package/dist/Fx/combinators/filterEffect.d.ts

@@ -0,0 +1,15 @@
+import type * as Effect from "effect/Effect";
+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 declare 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>;
+};
+//# sourceMappingURL=filterEffect.d.ts.map

package/dist/Fx/combinators/filterEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filterEffect.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/filterEffect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAC;AAI7C,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAEnC;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY,EAAE;IACzB,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EACR,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,EAAE,EAAE,EAAE,CAAC,GAC1C,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;IAE3D,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EACd,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,EACtB,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,EAAE,EAAE,EAAE,CAAC,GAC1C,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;CAQ1B,CAAC"}

package/dist/Fx/combinators/filterEffect.js

@@ -0,0 +1,12 @@
+import { dual } from "effect/Function";
+import * as sinkCore from "../../Sink/combinators.js";
+import { make } from "../constructors/make.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 = dual(2, (self, f) => make((sink) => self.run(sinkCore.filterEffect(f)(sink))));

package/dist/Fx/combinators/filterMap.d.ts

@@ -0,0 +1,15 @@
+import type * as Option from "effect/Option";
+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 declare 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>;
+};
+//# sourceMappingURL=filterMap.d.ts.map

package/dist/Fx/combinators/filterMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filterMap.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/filterMap.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAC;AAG7C,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAEnC;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS,EAAE;IACtB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAEhF,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;CAK7E,CAAC"}

package/dist/Fx/combinators/filterMap.js

@@ -0,0 +1,12 @@
+import { dual } from "effect/Function";
+import * as sinkCore from "../../Sink/combinators.js";
+import { make } from "../constructors/make.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 = dual(2, (self, f) => make((sink) => self.run(sinkCore.filterMap(sink, f))));

package/dist/Fx/combinators/filterMapEffect.d.ts

@@ -0,0 +1,16 @@
+import type * as Effect from "effect/Effect";
+import type * as Option from "effect/Option";
+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 declare 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>;
+};
+//# sourceMappingURL=filterMapEffect.d.ts.map

package/dist/Fx/combinators/filterMapEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filterMapEffect.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/filterMapEffect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAC;AAE7C,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAC;AAG7C,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAEnC;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,EAAE;IAC5B,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EACX,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,GACnD,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;IAE3D,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EACjB,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,EACtB,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,GACnD,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;CAQ1B,CAAC"}

package/dist/Fx/combinators/filterMapEffect.js

@@ -0,0 +1,12 @@
+import { dual } from "effect/Function";
+import * as sinkCore from "../../Sink/combinators.js";
+import { make } from "../constructors/make.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 = dual(2, (self, f) => make((sink) => self.run(sinkCore.filterMapEffect(f)(sink))));

package/dist/Fx/combinators/filterMapLoop.d.ts

@@ -0,0 +1,17 @@
+import type * as Option from "effect/Option";
+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 declare 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>;
+};
+//# sourceMappingURL=filterMapLoop.d.ts.map

package/dist/Fx/combinators/filterMapLoop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filterMapLoop.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/filterMapLoop.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAC;AAG7C,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAEnC;;;;;;;;;GASG;AACH,eAAO,MAAM,aAAa,EAAE;IAC1B,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EACN,IAAI,EAAE,CAAC,EACP,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,GAClD,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAE5C,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EACZ,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EACjB,IAAI,EAAE,CAAC,EACP,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,GAClD,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;CAQhB,CAAC"}

package/dist/Fx/combinators/filterMapLoop.js

@@ -0,0 +1,14 @@
+import { dual } from "effect/Function";
+import * as sinkCore from "../../Sink/combinators.js";
+import { make } from "../constructors/make.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 = dual(3, (self, seed, f) => make((sink) => self.run(sinkCore.filterMapLoop(sink, seed, f))));

package/dist/Fx/combinators/filterMapLoopCause.d.ts

@@ -0,0 +1,18 @@
+import type * as Cause from "effect/Cause";
+import type * as Option from "effect/Option";
+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 declare 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>;
+};
+//# sourceMappingURL=filterMapLoopCause.d.ts.map

package/dist/Fx/combinators/filterMapLoopCause.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filterMapLoopCause.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/filterMapLoopCause.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAC;AAE3C,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAC;AAG7C,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAEnC;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB,EAAE;IAC/B,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EACN,IAAI,EAAE,CAAC,EACP,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,GAC5E,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAE5C,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EACZ,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EACjB,IAAI,EAAE,CAAC,EACP,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,GAC5E,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;CAQhB,CAAC"}

package/dist/Fx/combinators/filterMapLoopCause.js

@@ -0,0 +1,14 @@
+import { dual } from "effect/Function";
+import * as sinkCore from "../../Sink/combinators.js";
+import { make } from "../constructors/make.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 = dual(3, (self, seed, f) => make((sink) => self.run(sinkCore.filterMapLoopCause(sink, seed, f))));

package/dist/Fx/combinators/filterMapLoopCauseEffect.d.ts

@@ -0,0 +1,18 @@
+import type * as Cause from "effect/Cause";
+import type * as Effect from "effect/Effect";
+import type * as Option from "effect/Option";
+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 declare 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>;
+};
+//# sourceMappingURL=filterMapLoopCauseEffect.d.ts.map

package/dist/Fx/combinators/filterMapLoopCauseEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filterMapLoopCauseEffect.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/filterMapLoopCauseEffect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAC;AAC3C,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAC;AAE7C,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAC;AAG7C,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAEnC;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB,EAAE;IACrC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EACd,IAAI,EAAE,CAAC,EACP,CAAC,EAAE,CACD,GAAG,EAAE,CAAC,EACN,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,KACd,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,GACtE,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;IAE3D,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAChB,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EACjB,IAAI,EAAE,CAAC,EACP,CAAC,EAAE,CACD,GAAG,EAAE,CAAC,EACN,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,KACd,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,GACrE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;CAYrB,CAAC"}

package/dist/Fx/combinators/filterMapLoopCauseEffect.js

@@ -0,0 +1,13 @@
+import { dual } from "effect/Function";
+import * as sinkCore from "../../Sink/combinators.js";
+import { make } from "../constructors/make.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 = dual(3, (self, seed, f) => make((sink) => self.run(sinkCore.filterMapLoopCauseEffect(sink, seed, f))));

package/dist/Fx/combinators/filterMapLoopEffect.d.ts

@@ -0,0 +1,17 @@
+import type * as Effect from "effect/Effect";
+import type * as Option from "effect/Option";
+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 declare 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>;
+};
+//# sourceMappingURL=filterMapLoopEffect.d.ts.map

package/dist/Fx/combinators/filterMapLoopEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filterMapLoopEffect.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/filterMapLoopEffect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAC;AAE7C,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAC;AAG7C,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAEnC;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,EAAE;IAChC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EACd,IAAI,EAAE,CAAC,EACP,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,GACzE,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;IAE3D,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAChB,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EACjB,IAAI,EAAE,CAAC,EACP,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,GACxE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;CASrB,CAAC"}

package/dist/Fx/combinators/filterMapLoopEffect.js

@@ -0,0 +1,13 @@
+import { dual } from "effect/Function";
+import * as sinkCore from "../../Sink/combinators.js";
+import { make } from "../constructors/make.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 = dual(3, (self, seed, f) => make((sink) => self.run(sinkCore.filterMapLoopEffect(sink, seed, f))));

package/dist/Fx/combinators/flatMap.d.ts

@@ -0,0 +1,23 @@
+import type * as Scope from "effect/Scope";
+import type { Fx } from "../Fx.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 declare const flatMap: FlatMapLike;
+//# sourceMappingURL=flatMap.d.ts.map

package/dist/Fx/combinators/flatMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flatMap.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/flatMap.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAC;AAG3C,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAGnC;;;;GAIG;AACH,MAAM,MAAM,WAAW,CAAC,IAAI,SAAS,aAAa,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI;IAC9D,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EACX,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,EAC1B,GAAG,IAAI,EAAE,IAAI,GACZ,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC;IAEpE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EACjB,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EACjB,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,EAC1B,GAAG,IAAI,EAAE,IAAI,GACZ,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC;CACxC,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,OAAO,EAAE,WAarB,CAAC"}

package/dist/Fx/combinators/flatMap.js

@@ -0,0 +1,21 @@
+import * as Effect from "effect/Effect";
+import * as FiberSet from "effect/FiberSet";
+import { dual } from "effect/Function";
+import { make as makeSink } from "../../Sink/Sink.js";
+import { make } from "../constructors/make.js";
+import { extendScope } from "../internal/scope.js";
+/**
+ * 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 = dual(2, (self, f) => make(Effect.fn(function* (sink) {
+    const set = yield* FiberSet.make();
+    yield* self.run(makeSink(sink.onFailure, (a) => FiberSet.run(set, f(a).run(sink))));
+    yield* FiberSet.awaitEmpty(set);
+}, extendScope)));

package/dist/Fx/combinators/flatMapConcurrently.d.ts

@@ -0,0 +1,12 @@
+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 declare const flatMapConcurrently: FlatMapLike<[concurrency: number]>;
+//# sourceMappingURL=flatMapConcurrently.d.ts.map

package/dist/Fx/combinators/flatMapConcurrently.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flatMapConcurrently.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/flatMapConcurrently.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEhD;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,EAAE,WAAW,CAAC,CAAC,WAAW,EAAE,MAAM,CAAC,CAkBlE,CAAC"}

package/dist/Fx/combinators/flatMapConcurrently.js

@@ -0,0 +1,23 @@
+import * as Effect from "effect/Effect";
+import * as FiberSet from "effect/FiberSet";
+import * as Semaphore from "effect/Semaphore";
+import { dual } from "effect/Function";
+import { make as makeSink } from "../../Sink/Sink.js";
+import { make } from "../constructors/make.js";
+import { extendScope } from "../internal/scope.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 = dual(3, (self, f, concurrency) => make(Effect.fn(function* (sink) {
+    const semaphore = yield* Semaphore.make(concurrency);
+    const lock = semaphore.withPermits(1);
+    const set = yield* FiberSet.make();
+    yield* self.run(makeSink(sink.onFailure, (a) => FiberSet.run(set, lock(Effect.asVoid(f(a).run(sink))))));
+    yield* FiberSet.awaitEmpty(set);
+}, extendScope)));

package/dist/Fx/combinators/flatMapConcurrentlyEffect.d.ts

@@ -0,0 +1,12 @@
+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 declare const flatMapConcurrentlyEffect: FlatMapEffectLike<[concurrency: number]>;
+//# sourceMappingURL=flatMapConcurrentlyEffect.d.ts.map

package/dist/Fx/combinators/flatMapConcurrentlyEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flatMapConcurrentlyEffect.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/flatMapConcurrentlyEffect.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAE5D;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,EAAE,iBAAiB,CAAC,CAAC,WAAW,EAAE,MAAM,CAAC,CAQ9E,CAAC"}