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

package/src/Fx/combinators/dropUntil.ts

@@ -0,0 +1,47 @@
+import * as Effect from "effect/Effect";
+import { dual } from "effect/Function";
+import type { Fx } from "../Fx.js";
+import { skipWhile, skipWhileEffect } from "./skipWhile.js";
+
+/**
+ * Drops elements from an Fx until a predicate returns true.
+ * Emits from the first element for which the predicate returns true (including that element) and all following elements.
+ *
+ * @param predicate - The predicate function.
+ * @returns An `Fx` that emits once the predicate first matches.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const dropUntil: {
+  <A>(predicate: (a: A) => boolean): <E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>;
+  <A, E, R>(fx: Fx<A, E, R>, predicate: (a: A) => boolean): Fx<A, E, R>;
+} = dual(
+  2,
+  <A, E, R>(fx: Fx<A, E, R>, predicate: (a: A) => boolean): Fx<A, E, R> =>
+    skipWhile(fx, (a) => !predicate(a)),
+);
+
+/**
+ * Drops elements from an Fx until an effectful predicate returns true.
+ * Emits from the first element for which the predicate effect succeeds with true (including that element) and all following elements.
+ *
+ * @param predicate - Effectful predicate function.
+ * @returns An `Fx` that emits once the predicate first matches.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const dropUntilEffect: {
+  <A, E2, R2>(
+    predicate: (a: A) => Effect.Effect<boolean, E2, R2>,
+  ): <E, R>(fx: Fx<A, E, R>) => Fx<A, E | E2, R | R2>;
+  <A, E, R, E2, R2>(
+    fx: Fx<A, E, R>,
+    predicate: (a: A) => Effect.Effect<boolean, E2, R2>,
+  ): Fx<A, E | E2, R | R2>;
+} = dual(
+  2,
+  <A, E, R, E2, R2>(
+    fx: Fx<A, E, R>,
+    predicate: (a: A) => Effect.Effect<boolean, E2, R2>,
+  ): Fx<A, E | E2, R | R2> => skipWhileEffect(fx, (a) => Effect.map(predicate(a), (b) => !b)),
+);

package/src/Fx/combinators/flatMapConcurrently.ts

@@ -1,5 +1,6 @@
 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";
@@ -26,10 +27,12 @@ export const flatMapConcurrently: FlatMapLike<[concurrency: number]> = dual(
   ): Fx<B, E | E2, R | R2 | Scope.Scope> =>
     make<B, E | E2, R | R2 | Scope.Scope>(
       Effect.fn(function* (sink) {
-        const semaphore = yield* Effect.makeSemaphore(concurrency);
+        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(f(a).run(sink)))));
+        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/index.ts

@@ -1,7 +1,10 @@
 export * from "./catch.js";
+export * from "./changesWithEffect.js";
 export * from "./causes.js";
 export * from "./compact.js";
 export * from "./continueWith.js";
+export * from "./dropUntil.js";
+export * from "./additive.js";
 export * from "./ensuring.js";
 export * from "./exhaustLatestMap.js";
 export * from "./exhaustLatestMapEffect.js";
@@ -29,23 +32,30 @@ export * from "./loopCause.js";
 export * from "./loopCauseEffect.js";
 export * from "./loopEffect.js";
 export * from "./map.js";
+export * from "./mapBoth.js";
 export * from "./mapEffect.js";
+export * from "./mapError.js";
 export * from "./mergeAll.js";
 export * from "./mergeOrdered.js";
 export * from "./onError.js";
 export * from "./onExit.js";
 export * from "./onInterrupt.js";
 export * from "./provide.js";
+export * from "./result.js";
+export * from "./scan.js";
 export * from "./skip.js";
 export * from "./skipRepeats.js";
+export * from "./skipWhile.js";
 export * from "./skipRepeatsWith.js";
 export * from "./slice.js";
 export * from "./switchMap.js";
 export * from "./switchMapEffect.js";
 export * from "./take.js";
 export * from "./takeUntil.js";
+export * from "./takeWhile.js";
 export * from "./tapEffect.js";
 export * from "./tuple.js";
 export * from "./unwrap.js";
 export * from "./unwrapScoped.js";
 export * from "./when.js";
+export * from "./zip.js";

package/src/Fx/combinators/keyed.ts

@@ -37,7 +37,7 @@ export interface KeyedOptions<A, B, C, E2, R2> {
   /**
    * Optional debounce duration for emission.
    */
-  readonly debounce?: Duration.DurationInput;
+  readonly debounce?: Duration.Input;
 }
 
 /**
@@ -323,7 +323,7 @@ function withDebounceFork<A, E, R>(
     fork: <R>(effect: Effect.Effect<A, never, R>) => Effect.Effect<void, never, R>,
     scope: Scope.Scope,
   ) => Effect.Effect<A, E, R>,
-  duration: Duration.DurationInput,
+  duration: Duration.Input,
 ): Effect.Effect<unknown, E, R | Scope.Scope> {
   return withScopedFork(
     (fork, scope) =>

package/src/Fx/combinators/mapBoth.ts

@@ -0,0 +1,40 @@
+import * as Cause from "effect/Cause";
+import { dual } from "effect/Function";
+import { make as makeSink } from "../../Sink/Sink.js";
+import { make } from "../constructors/make.js";
+import type { Fx } from "../Fx.js";
+
+/**
+ * Transforms both the success and error channels of an Fx using the provided options.
+ *
+ * Mirrors `Effect.mapBoth`: `onSuccess` maps emitted values, `onFailure` maps the
+ * typed failure (via `Cause.map`); defects and interrupts are preserved.
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export const mapBoth: {
+  <E, E2, A, A2>(options: {
+    readonly onFailure: (e: E) => E2;
+    readonly onSuccess: (a: A) => A2;
+  }): <R>(self: Fx<A, E, R>) => Fx<A2, E2, R>;
+
+  <A, E, R, E2, A2>(
+    self: Fx<A, E, R>,
+    options: { readonly onFailure: (e: E) => E2; readonly onSuccess: (a: A) => A2 },
+  ): Fx<A2, E2, R>;
+} = dual(
+  2,
+  <A, E, R, E2, A2>(
+    self: Fx<A, E, R>,
+    options: { readonly onFailure: (e: E) => E2; readonly onSuccess: (a: A) => A2 },
+  ): Fx<A2, E2, R> =>
+    make<A2, E2, R>((sink) =>
+      self.run(
+        makeSink(
+          (cause) => sink.onFailure(Cause.map(cause, options.onFailure)),
+          (a) => sink.onSuccess(options.onSuccess(a)),
+        ),
+      ),
+    ),
+);

package/src/Fx/combinators/mapError.ts

@@ -0,0 +1,28 @@
+import * as Cause from "effect/Cause";
+import { dual } from "effect/Function";
+import { make as makeSink } from "../../Sink/Sink.js";
+import { make } from "../constructors/make.js";
+import type { Fx } from "../Fx.js";
+
+/**
+ * Transforms the error channel of an Fx using the provided function.
+ *
+ * Failures (Cause) are mapped via `Cause.map`, so only the typed failure (`Fail`)
+ * is transformed; defects and interrupts are preserved unchanged.
+ *
+ * Mirrors `Effect.mapError`.
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export const mapError: {
+  <E, E2>(f: (e: E) => E2): <A, R>(self: Fx<A, E, R>) => Fx<A, E2, R>;
+
+  <A, E, R, E2>(self: Fx<A, E, R>, f: (e: E) => E2): Fx<A, E2, R>;
+} = dual(
+  2,
+  <A, E, R, E2>(self: Fx<A, E, R>, f: (e: E) => E2): Fx<A, E2, R> =>
+    make<A, E2, R>((sink) =>
+      self.run(makeSink((cause) => sink.onFailure(Cause.map(cause, f)), sink.onSuccess)),
+    ),
+);

package/src/Fx/combinators/provide.ts

@@ -3,7 +3,7 @@ import * as Exit from "effect/Exit";
 import { dual } from "effect/Function";
 import * as Layer from "effect/Layer";
 import * as Scope from "effect/Scope";
-import type * as ServiceMap from "effect/ServiceMap";
+import * as ServiceMap from "effect/ServiceMap";
 import { make } from "../constructors/make.js";
 import type { Fx } from "../Fx.js";
 
@@ -60,3 +60,65 @@ export const provideServices: {
   <A, E, R, R2>(fx: Fx<A, E, R>, services: ServiceMap.ServiceMap<R2>): Fx<A, E, Exclude<R, R2>> =>
     provide(fx, Layer.succeedServices(services)),
 );
+
+/**
+ * Provides a single service to an Fx.
+ *
+ * Equivalent to `provideServices(fx, ServiceMap.make(tag, service))`. The service
+ * is available for the entire Fx stream, scoped to the stream lifetime.
+ *
+ * @param tag - The service tag (identifier).
+ * @param service - The service implementation.
+ * @returns An `Fx` with the required service provided.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const provideService: {
+  <Id, S>(
+    tag: ServiceMap.Service<Id, S>,
+    service: S,
+  ): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, Exclude<R, Id>>;
+  <A, E, R, Id, S>(
+    fx: Fx<A, E, R>,
+    tag: ServiceMap.Service<Id, S>,
+    service: S,
+  ): Fx<A, E, Exclude<R, Id>>;
+} = dual(
+  3,
+  <A, E, R, Id, S>(
+    fx: Fx<A, E, R>,
+    tag: ServiceMap.Service<Id, S>,
+    service: S,
+  ): Fx<A, E, Exclude<R, Id>> => provideServices(fx, ServiceMap.make(tag, service)),
+);
+
+/**
+ * Provides a single service to an Fx by running an effect that produces the service.
+ *
+ * The effect is run when the Fx is run; the resulting service is provided to the
+ * entire stream. Equivalent to `provide(fx, Layer.effect(tag, serviceEffect))`.
+ *
+ * @param tag - The service tag (identifier).
+ * @param serviceEffect - Effect that produces the service (may have its own requirements).
+ * @returns An `Fx` with the required service provided.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const provideServiceEffect: {
+  <Id, S, E2, R2>(
+    tag: ServiceMap.Service<Id, S>,
+    serviceEffect: Effect.Effect<S, E2, R2>,
+  ): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E | E2, Exclude<R, Id> | R2>;
+  <A, E, R, Id, S, E2, R2>(
+    fx: Fx<A, E, R>,
+    tag: ServiceMap.Service<Id, S>,
+    serviceEffect: Effect.Effect<S, E2, R2>,
+  ): Fx<A, E | E2, Exclude<R, Id> | R2>;
+} = dual(
+  3,
+  <A, E, R, Id, S, E2, R2>(
+    fx: Fx<A, E, R>,
+    tag: ServiceMap.Service<Id, S>,
+    serviceEffect: Effect.Effect<S, E2, R2>,
+  ): Fx<A, E | E2, Exclude<R, Id> | R2> => provide(fx, Layer.effect(tag, serviceEffect)),
+);

package/src/Fx/combinators/result.ts

@@ -0,0 +1,39 @@
+import * as Cause from "effect/Cause";
+import * as Result from "effect/Result";
+import type { Sink } from "../../Sink/Sink.js";
+import { make } from "../constructors/make.js";
+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 const result = <A, E, R>(fx: Fx<A, E, R>): Fx<Result.Result<A, Cause.Cause<E>>, never, R> =>
+  make<Result.Result<A, Cause.Cause<E>>, never, R>((sink) => fx.run(new ResultSink(sink)));
+
+class ResultSink<A, E, R> implements Sink<A, E, R> {
+  readonly sink: Sink<Result.Result<A, Cause.Cause<E>>, never, R>;
+  readonly onSuccess: (value: A) => import("effect/Effect").Effect<unknown, never, R>;
+  readonly onFailure: (cause: Cause.Cause<E>) => import("effect/Effect").Effect<unknown, never, R>;
+
+  constructor(sink: Sink<Result.Result<A, Cause.Cause<E>>, never, R>) {
+    this.sink = sink;
+    const s = sink;
+    this.onSuccess = (value) => s.onSuccess(Result.succeed(value));
+    this.onFailure = (cause) => s.onSuccess(Result.fail(cause));
+  }
+}

package/src/Fx/combinators/scan.ts

@@ -0,0 +1,82 @@
+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";
+import type { Fx } from "../Fx.js";
+import { Sink } from "../../Sink.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: {
+  <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>;
+} = dual(
+  3,
+  <A, E, R, S>(fx: Fx<A, E, R>, initial: S, f: (s: S, a: A) => S): Fx<S, E, R> =>
+    make<S, E, R>((sink) =>
+      Effect.gen(function* () {
+        yield* sink.onSuccess(initial);
+        yield* fx.run(
+          sinkLoop(sink, initial, (s, a) => {
+            const next = f(s, a);
+            return [next, next] as const;
+          }),
+        );
+      }),
+    ),
+);
+
+/**
+ * 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: {
+  <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>;
+} = dual(
+  3,
+  <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> =>
+    make<S, E | E2, R | R2>(<RSink>(sink: Sink<S, E | E2, RSink>) =>
+      Effect.gen(function* () {
+        const services = yield* Effect.services<R | R2 | RSink>();
+        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] as const),
+              Effect.provideServices(services),
+            ),
+          ),
+        );
+      }),
+    ),
+);

package/src/Fx/combinators/skip.ts

@@ -1,6 +1,8 @@
+import * as Effect from "effect/Effect";
 import { dual } from "effect/Function";
 import type { Fx } from "../Fx.js";
 import { slice } from "./slice.js";
+import { unwrap } from "./unwrap.js";
 
 /**
  * Skips the first `n` elements of an Fx.
@@ -18,3 +20,22 @@ export const skip: {
   2,
   <A, E, R>(fx: Fx<A, E, R>, n: number): Fx<A, E, R> => 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: {
+  <E2, R2>(
+    count: Effect.Effect<number, E2, R2>,
+  ): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E | E2, R | R2>;
+  <A, E, R, E2, R2>(fx: Fx<A, E, R>, count: Effect.Effect<number, E2, R2>): Fx<A, E | E2, R | R2>;
+} = dual(
+  2,
+  <A, E, R, E2, R2>(fx: Fx<A, E, R>, count: Effect.Effect<number, E2, R2>): Fx<A, E | E2, R | R2> =>
+    unwrap(Effect.map(count, (n) => skip(fx, n))),
+);

package/src/Fx/combinators/skipWhile.ts

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

package/src/Fx/combinators/slice.ts

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

package/src/Fx/combinators/take.ts

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

package/src/Fx/combinators/takeUntil.ts

@@ -1,3 +1,4 @@
+import * as Effect from "effect/Effect";
 import { dual } from "effect/Function";
 import * as combinators from "../../Sink/combinators.js";
 import { make as makeSink } from "../../Sink/Sink.js";
@@ -31,6 +32,43 @@ export const takeUntil: {
   );
 });
 
+/**
+ * Takes elements from an Fx until an effectful predicate returns true.
+ * The element that satisfies the predicate is not included in the output.
+ *
+ * @param predicate - Effectful predicate function.
+ * @returns An `Fx` that completes when the predicate matches.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const takeUntilEffect: {
+  <A, E2, R2>(
+    predicate: (a: A) => Effect.Effect<boolean, E2, R2>,
+  ): <E, R>(fx: Fx<A, E, R>) => Fx<A, E | E2, R | R2>;
+  <A, E, R, E2, R2>(
+    fx: Fx<A, E, R>,
+    predicate: (a: A) => Effect.Effect<boolean, E2, R2>,
+  ): Fx<A, E | E2, R | R2>;
+} = dual(
+  2,
+  <A, E, R, E2, R2>(
+    fx: Fx<A, E, R>,
+    predicate: (a: A) => Effect.Effect<boolean, E2, R2>,
+  ): Fx<A, E | E2, R | R2> =>
+    makeFx<A, E | E2, R | R2>((sink) =>
+      combinators.withEarlyExit(sink, (sink) =>
+        fx.run(
+          makeSink(sink.onFailure, (a) =>
+            Effect.matchCauseEffect(predicate(a), {
+              onFailure: sink.onFailure,
+              onSuccess: (matches) => (matches ? sink.earlyExit : sink.onSuccess(a)),
+            }),
+          ),
+        ),
+      ),
+    ),
+);
+
 /**
  * Drops elements from an Fx after a predicate returns true.
  * The element that satisfies the predicate is included in the output.