@typed/fx 1.32.0 → 2.0.0-beta.0

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,36 @@
+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";
+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* Effect.makeSemaphore(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* 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;

package/src/Fx/combinators/genScoped.ts

@@ -0,0 +1,24 @@
+import * as Effect from "effect/Effect";
+import type * as Scope from "effect/Scope";
+import type { Fx } from "../Fx.js";
+import { unwrapScoped } from "./unwrapScoped.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 a scoped Fx using a generator function.
+ *
+ * Similar to `gen`, but also handles resource management via Scope.
+ *
+ * @param f - The generator function.
+ * @returns An `Fx` representing the result of the generator.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const genScoped = <Yield extends Effect.Yieldable<any, any, any, any>, A, E, R>(
+  f: () => Generator<Yield, Fx<A, E, R>, any>,
+): Fx<A, E | _YE<Yield>, Exclude<R | _YS<Yield>, Scope.Scope>> =>
+  unwrapScoped(Effect.gen(f)) as any;

package/src/Fx/combinators/index.ts

@@ -0,0 +1,51 @@
+export * from "./catch.js";
+export * from "./causes.js";
+export * from "./compact.js";
+export * from "./continueWith.js";
+export * from "./ensuring.js";
+export * from "./exhaustLatestMap.js";
+export * from "./exhaustLatestMapEffect.js";
+export * from "./exhaustMap.js";
+export * from "./exhaustMapEffect.js";
+export * from "./exit.js";
+export * from "./filter.js";
+export * from "./filterEffect.js";
+export * from "./filterMap.js";
+export * from "./filterMapEffect.js";
+export * from "./filterMapLoop.js";
+export * from "./filterMapLoopCause.js";
+export * from "./filterMapLoopCauseEffect.js";
+export * from "./filterMapLoopEffect.js";
+export * from "./flatMap.js";
+export * from "./flatMapConcurrently.js";
+export * from "./flatMapConcurrentlyEffect.js";
+export * from "./flatMapEffect.js";
+export * from "./flip.js";
+export * from "./gen.js";
+export * from "./genScoped.js";
+export * from "./keyed.js";
+export * from "./loop.js";
+export * from "./loopCause.js";
+export * from "./loopCauseEffect.js";
+export * from "./loopEffect.js";
+export * from "./map.js";
+export * from "./mapEffect.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 "./skip.js";
+export * from "./skipRepeats.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 "./tapEffect.js";
+export * from "./tuple.js";
+export * from "./unwrap.js";
+export * from "./unwrapScoped.js";
+export * from "./when.js";