@typed/fx 1.32.0 → 2.0.0-beta.1

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

@@ -0,0 +1,23 @@
+import * as Cause from "effect/Cause";
+import * as Result from "effect/Result";
+import type { Fx } from "../Fx.js";
+/**
+ * Materializes success and failure of an Fx as `Result` values.
+ *
+ * - **Success**: each emitted value is wrapped as `Result.succeed(value)`.
+ * - **Failure**: any failure (including typed error, defect, and interrupt) is
+ *   materialized as `Result.fail(cause)`. The output error type is `Cause<E>`,
+ *   so defects and interrupts are explicitly represented in the `Result` and
+ *   the resulting Fx has error type `never`.
+ *
+ * The resulting Fx never fails at the stream level; all outcomes are emitted as
+ * `Result<A, Cause<E>>`. Consumers can use `Result.match` or `Result.isSuccess` /
+ * `Result.isFailure` to handle success vs failure (including defect/interrupt).
+ *
+ * @param fx - The `Fx` stream.
+ * @returns An `Fx` emitting `Result<A, Cause<E>>`.
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const result: <A, E, R>(fx: Fx<A, E, R>) => Fx<Result.Result<A, Cause.Cause<E>>, never, R>;
+//# sourceMappingURL=result.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"result.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/result.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AACtC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAGxC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAEnC;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,MAAM,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAG,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CACL,CAAC"}

package/dist/Fx/combinators/result.js

@@ -0,0 +1,32 @@
+import * as Result from "effect/Result";
+import { make } from "../constructors/make.js";
+/**
+ * Materializes success and failure of an Fx as `Result` values.
+ *
+ * - **Success**: each emitted value is wrapped as `Result.succeed(value)`.
+ * - **Failure**: any failure (including typed error, defect, and interrupt) is
+ *   materialized as `Result.fail(cause)`. The output error type is `Cause<E>`,
+ *   so defects and interrupts are explicitly represented in the `Result` and
+ *   the resulting Fx has error type `never`.
+ *
+ * The resulting Fx never fails at the stream level; all outcomes are emitted as
+ * `Result<A, Cause<E>>`. Consumers can use `Result.match` or `Result.isSuccess` /
+ * `Result.isFailure` to handle success vs failure (including defect/interrupt).
+ *
+ * @param fx - The `Fx` stream.
+ * @returns An `Fx` emitting `Result<A, Cause<E>>`.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const result = (fx) => make((sink) => fx.run(new ResultSink(sink)));
+class ResultSink {
+    sink;
+    onSuccess;
+    onFailure;
+    constructor(sink) {
+        this.sink = sink;
+        const s = sink;
+        this.onSuccess = (value) => s.onSuccess(Result.succeed(value));
+        this.onFailure = (cause) => s.onSuccess(Result.fail(cause));
+    }
+}

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

@@ -0,0 +1,33 @@
+import * as Effect from "effect/Effect";
+import type { Fx } from "../Fx.js";
+/**
+ * Scans the stream with a pure function, emitting the accumulated state after each element.
+ * Emits the initial value first, then for each input `a` emits `f(state, a)` and updates state.
+ *
+ * Semantics align with Effect Stream's `scan`: output is `initial`, `f(initial, a1)`, `f(..., a2)`, ...
+ *
+ * @param initial - Initial state (first value emitted).
+ * @param f - Reducer `(state, value) => nextState`.
+ * @returns An `Fx` that emits the accumulated state at each step.
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const scan: {
+    <S, A>(initial: S, f: (s: S, a: A) => S): <E, R>(fx: Fx<A, E, R>) => Fx<S, E, R>;
+    <A, E, R, S>(fx: Fx<A, E, R>, initial: S, f: (s: S, a: A) => S): Fx<S, E, R>;
+};
+/**
+ * Scans the stream with an effectful function, emitting the accumulated state after each element.
+ * Emits the initial value first, then for each input `a` runs `f(state, a)` and emits the resulting state.
+ *
+ * @param initial - Initial state (first value emitted).
+ * @param f - Effectful reducer `(state, value) => Effect<nextState>`.
+ * @returns An `Fx` that emits the accumulated state at each step.
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const scanEffect: {
+    <S, A, E2, R2>(initial: S, f: (s: S, a: A) => Effect.Effect<S, E2, R2>): <E, R>(fx: Fx<A, E, R>) => Fx<S, E | E2, R | R2>;
+    <A, E, R, S, E2, R2>(fx: Fx<A, E, R>, initial: S, f: (s: S, a: A) => Effect.Effect<S, E2, R2>): Fx<S, E | E2, R | R2>;
+};
+//# sourceMappingURL=scan.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scan.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/scan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAIxC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAGnC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,IAAI,EAAE;IACjB,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IACjF,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;CAe9E,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,UAAU,EAAE;IACvB,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EACX,OAAO,EAAE,CAAC,EACV,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,GAC1C,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;IACpD,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EACjB,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EACf,OAAO,EAAE,CAAC,EACV,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,GAC1C,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;CAwB1B,CAAC"}

package/dist/Fx/combinators/scan.js

@@ -0,0 +1,38 @@
+import * as Effect from "effect/Effect";
+import { dual, pipe } from "effect/Function";
+import { loop as sinkLoop, loopEffect as sinkLoopEffect } from "../../Sink/combinators.js";
+import { make } from "../constructors/make.js";
+/**
+ * Scans the stream with a pure function, emitting the accumulated state after each element.
+ * Emits the initial value first, then for each input `a` emits `f(state, a)` and updates state.
+ *
+ * Semantics align with Effect Stream's `scan`: output is `initial`, `f(initial, a1)`, `f(..., a2)`, ...
+ *
+ * @param initial - Initial state (first value emitted).
+ * @param f - Reducer `(state, value) => nextState`.
+ * @returns An `Fx` that emits the accumulated state at each step.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const scan = dual(3, (fx, initial, f) => make((sink) => Effect.gen(function* () {
+    yield* sink.onSuccess(initial);
+    yield* fx.run(sinkLoop(sink, initial, (s, a) => {
+        const next = f(s, a);
+        return [next, next];
+    }));
+})));
+/**
+ * Scans the stream with an effectful function, emitting the accumulated state after each element.
+ * Emits the initial value first, then for each input `a` runs `f(state, a)` and emits the resulting state.
+ *
+ * @param initial - Initial state (first value emitted).
+ * @param f - Effectful reducer `(state, value) => Effect<nextState>`.
+ * @returns An `Fx` that emits the accumulated state at each step.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const scanEffect = dual(3, (fx, initial, f) => make((sink) => Effect.gen(function* () {
+    const services = yield* Effect.services();
+    yield* sink.onSuccess(initial);
+    yield* fx.run(sinkLoopEffect(sink, initial, (s, a) => pipe(f(s, a), Effect.catchCause((cause) => sink.onFailure(cause).pipe(Effect.as(s))), Effect.map((next) => [next, next]), Effect.provideServices(services))));
+})));

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

@@ -0,0 +1,27 @@
+import * as Effect from "effect/Effect";
+import type { Fx } from "../Fx.js";
+/**
+ * Skips the first `n` elements of an Fx.
+ *
+ * @param n - The number of elements to skip.
+ * @returns An `Fx` that emits values after the first `n` elements.
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const skip: {
+    (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>;
+};
+/**
+ * Skips the first `n` elements where `n` is produced by an Effect.
+ *
+ * @param count - Effect that produces the number of elements to skip.
+ * @returns An `Fx` that emits values after the first `n` elements.
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const skipEffect: {
+    <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>;
+};
+//# sourceMappingURL=skip.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skip.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/skip.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAInC;;;;;;;GAOG;AACH,eAAO,MAAM,IAAI,EAAE;IACjB,CAAC,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAEvD,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;CAIpD,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU,EAAE;IACvB,CAAC,EAAE,EAAE,EAAE,EACL,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,CAAC,GACnC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;IACvD,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;CAKjG,CAAC"}

package/dist/Fx/combinators/skip.js

@@ -0,0 +1,22 @@
+import * as Effect from "effect/Effect";
+import { dual } from "effect/Function";
+import { slice } from "./slice.js";
+import { unwrap } from "./unwrap.js";
+/**
+ * Skips the first `n` elements of an Fx.
+ *
+ * @param n - The number of elements to skip.
+ * @returns An `Fx` that emits values after the first `n` elements.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const skip = dual(2, (fx, n) => slice(fx, { skip: n, take: Infinity }));
+/**
+ * Skips the first `n` elements where `n` is produced by an Effect.
+ *
+ * @param count - Effect that produces the number of elements to skip.
+ * @returns An `Fx` that emits values after the first `n` elements.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const skipEffect = dual(2, (fx, count) => unwrap(Effect.map(count, (n) => skip(fx, n))));

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

@@ -0,0 +1,11 @@
+import type { Fx } from "../Fx.js";
+/**
+ * Drops elements that are equal to the previous element using standard equality.
+ *
+ * @param fx - The `Fx` stream.
+ * @returns An `Fx` with consecutive duplicates removed.
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const skipRepeats: <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>;
+//# sourceMappingURL=skipRepeats.d.ts.map

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

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

package/dist/Fx/combinators/skipRepeats.js

@@ -0,0 +1,12 @@
+import { equals } from "effect/Equal";
+import { skipRepeatsWith } from "./skipRepeatsWith.js";
+const skipRepeats_ = skipRepeatsWith(equals);
+/**
+ * Drops elements that are equal to the previous element using standard equality.
+ *
+ * @param fx - The `Fx` stream.
+ * @returns An `Fx` with consecutive duplicates removed.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const skipRepeats = skipRepeats_;

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"skipRepeatsWith.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/skipRepeatsWith.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,WAAW,MAAM,oBAAoB,CAAC;AAMvD,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAEnC;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,GACzB,CAAC,EAAE,IAAI,WAAW,CAAC,WAAW,CAAC,CAAC,CAAC,MACjC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAoBhC,CAAC"}

package/dist/Fx/combinators/skipRepeatsWith.js

@@ -0,0 +1,20 @@
+import * as Effect from "effect/Effect";
+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";
+/**
+ * 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 = (Eq) => (fx) => make((sink) => sinkCore.withState(sink, Option.none(), (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/dist/Fx/combinators/skipWhile.d.ts

@@ -0,0 +1,49 @@
+import * as Effect from "effect/Effect";
+import type { Fx } from "../Fx.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 declare 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>;
+};
+/**
+ * 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 declare 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>;
+};
+/**
+ * Alias of `skipWhile` for Effect parity (`dropWhile` naming).
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const dropWhile: {
+    <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>;
+};
+/**
+ * Alias of `skipWhileEffect` for Effect parity (`dropWhileEffect` naming).
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const dropWhileEffect: {
+    <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>;
+};
+//# sourceMappingURL=skipWhile.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skipWhile.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/skipWhile.ts"],"names":[],"mappings":"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"}

package/dist/Fx/combinators/skipWhile.js

@@ -0,0 +1,66 @@
+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 { 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 = dual(2, (fx, predicate) => makeFx((sink) => Effect.gen(function* () {
+    const skippingRef = yield* Ref.make(true);
+    const skipSink = makeSink(sink.onFailure, (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 = dual(2, (fx, predicate) => makeFx((sink) => Effect.gen(function* () {
+    const skippingRef = yield* Ref.make(true);
+    const skipSink = makeSink(sink.onFailure, (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/dist/Fx/combinators/slice.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"slice.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/slice.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAIxC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAGnC;;;;GAIG;AACH,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,KAAK,EAAE;IAClB,CAAC,MAAM,EAAE,MAAM,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAE5D,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;CAKzD,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,EAAE;IACxB,CAAC,EAAE,EAAE,EAAE,EACL,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,CAAC,GACpC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;IACvD,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;CAOlG,CAAC"}

package/dist/Fx/combinators/slice.js

@@ -0,0 +1,23 @@
+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 { unwrap } from "./unwrap.js";
+/**
+ * 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 = dual(2, (fx, bounds) => make((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 = dual(2, (fx, bounds) => unwrap(Effect.map(bounds, (b) => slice(fx, b))));

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"switchMap.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/switchMap.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEhD;;;;;;;;;GASG;AACH,eAAO,MAAM,SAAS,EAAE,WAgCvB,CAAC"}

package/dist/Fx/combinators/switchMap.js

@@ -0,0 +1,33 @@
+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 { extendScope } from "../internal/scope.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 = dual(2, (self, f) => make(Effect.fn(function* (sink) {
+    const ctx = yield* Effect.services();
+    const scope = ServiceMap.get(ctx, Scope.Scope);
+    const fiberRef = yield* SyncronizedRef.make(null);
+    const next = (value) => Effect.forkIn(Effect.provideServices(f(value).run(sink), ctx), scope, {
+        startImmediately: false,
+        uninterruptible: false,
+    });
+    yield* self.run(makeSink(sink.onFailure, (value) => 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/dist/Fx/combinators/switchMapEffect.d.ts

@@ -0,0 +1,13 @@
+import type { FlatMapEffectLike } from "./flatMapEffect.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 declare const switchMapEffect: FlatMapEffectLike;
+//# sourceMappingURL=switchMapEffect.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"switchMapEffect.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/switchMapEffect.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAG5D;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,EAAE,iBAM7B,CAAC"}

package/dist/Fx/combinators/switchMapEffect.js

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"take.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/take.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAInC;;;;;;;GAOG;AACH,eAAO,MAAM,IAAI,EAAE;IACjB,CAAC,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAEvD,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;CAC6C,CAAC;AAEnG;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU,EAAE;IACvB,CAAC,EAAE,EAAE,EAAE,EACL,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,CAAC,GACnC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;IACvD,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;CAKjG,CAAC"}

package/dist/Fx/combinators/take.js

@@ -0,0 +1,22 @@
+import * as Effect from "effect/Effect";
+import { dual } from "effect/Function";
+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 = dual(2, (fx, n) => 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 = dual(2, (fx, count) => unwrap(Effect.map(count, (n) => take(fx, n))));

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

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