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

package/src/Fx/combinators/catch.ts

@@ -163,3 +163,259 @@ export const catchTag: {
       ),
     ),
 );
+
+/**
+ * Recovers from a typed failure when a predicate holds, by switching to a fallback Fx.
+ * Only applies to `Cause.Fail`; defects and interrupts are not caught.
+ *
+ * Mirrors `Effect.catchIf`.
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export const catchIf: {
+  <E, A2, E2, R2>(
+    predicate: (e: E) => boolean,
+    f: (e: E) => Fx<A2, E2, R2>,
+  ): <A, R>(self: Fx<A, E, R>) => Fx<A | A2, E | E2, R | R2>;
+
+  <A, E, R, A2, E2, R2>(
+    self: Fx<A, E, R>,
+    predicate: (e: E) => boolean,
+    f: (e: E) => Fx<A2, E2, R2>,
+  ): Fx<A | A2, E | E2, R | R2>;
+} = dual(
+  3,
+  <A, E, R, A2, E2, R2>(
+    self: Fx<A, E, R>,
+    predicate: (e: E) => boolean,
+    f: (e: E) => Fx<A2, E2, R2>,
+  ): Fx<A | A2, E | E2, R | R2> =>
+    make<A | A2, E | E2, R | R2>((sink) =>
+      self.run(
+        makeSink((cause) => {
+          const result = Cause.findFail(cause);
+          if (Result.isFailure(result)) {
+            return sink.onFailure(result.failure);
+          }
+          const error = result.success.error;
+          if (predicate(error)) {
+            return f(error).run(sink);
+          }
+          return sink.onFailure(cause);
+        }, sink.onSuccess),
+      ),
+    ),
+);
+
+/**
+ * Recovers from a failure cause when a predicate on the cause holds,
+ * by switching to a fallback Fx.
+ *
+ * Mirrors `Effect.catchCauseIf`.
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export const catchCauseIf: {
+  <E, A2, E2, R2>(
+    predicate: (cause: Cause.Cause<E>) => boolean,
+    f: (cause: Cause.Cause<E>) => Fx<A2, E2, R2>,
+  ): <A, R>(self: Fx<A, E, R>) => Fx<A | A2, E | E2, R | R2>;
+
+  <A, E, R, A2, E2, R2>(
+    self: Fx<A, E, R>,
+    predicate: (cause: Cause.Cause<E>) => boolean,
+    f: (cause: Cause.Cause<E>) => Fx<A2, E2, R2>,
+  ): Fx<A | A2, E | E2, R | R2>;
+} = dual(
+  3,
+  <A, E, R, A2, E2, R2>(
+    self: Fx<A, E, R>,
+    predicate: (cause: Cause.Cause<E>) => boolean,
+    f: (cause: Cause.Cause<E>) => Fx<A2, E2, R2>,
+  ): Fx<A | A2, E | E2, R | R2> =>
+    make<A | A2, E | E2, R | R2>((sink) =>
+      self.run(
+        makeSink(
+          (cause) => (predicate(cause) ? f(cause).run(sink) : sink.onFailure(cause)),
+          sink.onSuccess,
+        ),
+      ),
+    ),
+);
+
+type TaggedCase<E> = {
+  [K in Extract<E, { _tag: string }>["_tag"]]+?: (
+    error: Extract<E, { _tag: K }>,
+  ) => Fx<unknown, unknown, unknown>;
+};
+
+/**
+ * Recovers from typed failures by matching on the `_tag` field with multiple handlers at once.
+ *
+ * Mirrors `Effect.catchTags`.
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export const catchTags: {
+  <E, Cases extends TaggedCase<E>>(
+    cases: Cases,
+  ): <A, R>(
+    self: Fx<A, E, R>,
+  ) => Fx<
+    | A
+    | {
+        [K in keyof Cases]: Cases[K] extends (e: unknown) => Fx<infer A2, unknown, unknown>
+          ? A2
+          : never;
+      }[keyof Cases],
+    | Exclude<E, { _tag: keyof Cases }>
+    | {
+        [K in keyof Cases]: Cases[K] extends (e: unknown) => Fx<unknown, infer E2, unknown>
+          ? E2
+          : never;
+      }[keyof Cases],
+    | R
+    | {
+        [K in keyof Cases]: Cases[K] extends (e: unknown) => Fx<unknown, unknown, infer R2>
+          ? R2
+          : never;
+      }[keyof Cases]
+  >;
+
+  <A, E, R, Cases extends TaggedCase<E>>(
+    self: Fx<A, E, R>,
+    cases: Cases,
+  ): Fx<
+    | A
+    | {
+        [K in keyof Cases]: Cases[K] extends (e: unknown) => Fx<infer A2, unknown, unknown>
+          ? A2
+          : never;
+      }[keyof Cases],
+    | Exclude<E, { _tag: keyof Cases }>
+    | {
+        [K in keyof Cases]: Cases[K] extends (e: unknown) => Fx<unknown, infer E2, unknown>
+          ? E2
+          : never;
+      }[keyof Cases],
+    | R
+    | {
+        [K in keyof Cases]: Cases[K] extends (e: unknown) => Fx<unknown, unknown, infer R2>
+          ? R2
+          : never;
+      }[keyof Cases]
+  >;
+} = dual(
+  2,
+  <A, E, R, Cases extends TaggedCase<E>>(
+    self: Fx<A, E, R>,
+    cases: Cases,
+  ): Fx<
+    | A
+    | {
+        [K in keyof Cases]: Cases[K] extends (e: unknown) => Fx<infer A2, unknown, unknown>
+          ? A2
+          : never;
+      }[keyof Cases],
+    | Exclude<E, { _tag: keyof Cases }>
+    | {
+        [K in keyof Cases]: Cases[K] extends (e: unknown) => Fx<unknown, infer E2, unknown>
+          ? E2
+          : never;
+      }[keyof Cases],
+    | R
+    | {
+        [K in keyof Cases]: Cases[K] extends (e: unknown) => Fx<unknown, unknown, infer R2>
+          ? R2
+          : never;
+      }[keyof Cases]
+  > =>
+    make<
+      | A
+      | {
+          [K in keyof Cases]: Cases[K] extends (e: unknown) => Fx<infer A2, unknown, unknown>
+            ? A2
+            : never;
+        }[keyof Cases],
+      | Exclude<E, { _tag: keyof Cases }>
+      | {
+          [K in keyof Cases]: Cases[K] extends (e: unknown) => Fx<unknown, infer E2, unknown>
+            ? E2
+            : never;
+        }[keyof Cases],
+      | R
+      | {
+          [K in keyof Cases]: Cases[K] extends (e: unknown) => Fx<unknown, unknown, infer R2>
+            ? R2
+            : never;
+        }[keyof Cases]
+    >((sink) =>
+      self.run(
+        makeSink(
+          (cause) => {
+            const result = Cause.findFail(cause);
+            if (Result.isFailure(result)) {
+              return sink.onFailure(result.failure);
+            }
+            const error = result.success.error as E;
+            if (!hasTag(error)) {
+              return sink.onFailure(
+                cause as Cause.Cause<
+                  | Exclude<E, { _tag: keyof Cases }>
+                  | {
+                      [K in keyof Cases]: Cases[K] extends (
+                        e: unknown,
+                      ) => Fx<unknown, infer E2, unknown>
+                        ? E2
+                        : never;
+                    }[keyof Cases]
+                >,
+              );
+            }
+            const tag = (error as { _tag: string })._tag;
+            const handler = (cases as Record<
+              string,
+              (e: unknown) => Fx<unknown, unknown, unknown>
+            >)[tag];
+            if (handler !== undefined) {
+              return handler(error).run(
+                sink as import("../../Sink/Sink.js").Sink<
+                  unknown,
+                  unknown,
+                  import("../../Sink/Sink.js").Context<typeof sink>
+                >,
+              );
+            }
+            return sink.onFailure(
+              cause as Cause.Cause<
+                | Exclude<E, { _tag: keyof Cases }>
+                | {
+                    [K in keyof Cases]: Cases[K] extends (
+                      e: unknown,
+                    ) => Fx<unknown, infer E2, unknown>
+                      ? E2
+                      : never;
+                  }[keyof Cases]
+              >,
+            );
+          },
+          sink.onSuccess,
+        ),
+      ) as import("effect/Effect").Effect<
+        unknown,
+        never,
+        | R
+        | {
+            [K in keyof Cases]: Cases[K] extends (
+              e: unknown,
+            ) => Fx<unknown, unknown, infer R2>
+              ? R2
+              : never;
+          }[keyof Cases]
+        | import("../../Sink/Sink.js").Context<typeof sink>
+      >,
+    ),
+);

package/src/Fx/combinators/changesWithEffect.ts

@@ -0,0 +1,66 @@
+import * as Effect from "effect/Effect";
+import { dual } from "effect/Function";
+import * as Option from "effect/Option";
+import * as sinkCore from "../../Sink/combinators.js";
+import { make as makeSink } from "../../Sink/Sink.js";
+import { make } from "../constructors/make.js";
+import type { Fx } from "../Fx.js";
+
+/**
+ * Drops consecutive elements that are considered equal by an effectful predicate.
+ * When the effect returns `true`, the element is skipped; when `false`, it is emitted.
+ *
+ * This is the effectful variant of `skipRepeatsWith`: instead of a pure
+ * `Equivalence<A>`, you supply `(prev, next) => Effect<boolean>` where `true`
+ * means "equal" (skip) and `false` means "changed" (emit).
+ *
+ * @param f - Effectful function: `(prev, next) => Effect<boolean>`. Return `true` to skip (treat as duplicate), `false` to emit.
+ * @returns An `Fx` with consecutive "equal" elements removed.
+ * @since 1.0.0
+ * @category combinators
+ */
+export const changesWithEffect: {
+  <A, E2, R2>(
+    f: (prev: A, next: A) => Effect.Effect<boolean, E2, R2>,
+  ): <E, R>(fx: Fx<A, E | E2, R>) => Fx<A, E | E2, R | R2>;
+
+  <A, E, R, E2, R2>(
+    fx: Fx<A, E | E2, R>,
+    f: (prev: A, next: A) => Effect.Effect<boolean, E2, R2>,
+  ): Fx<A, E | E2, R | R2>;
+} = dual(
+  2,
+  <A, E, R, E2, R2>(
+    fx: Fx<A, E | E2, R>,
+    f: (prev: A, next: A) => Effect.Effect<boolean, E2, R2>,
+  ): Fx<A, E | E2, R | R2> =>
+    make<A, E | E2, R | R2>((sink) =>
+      sinkCore.withStateSemaphore(sink, Option.none<A>() as Option.Option<A>, (s) =>
+        fx.run(
+          makeSink(s.onFailure, (a2) =>
+            Effect.matchCauseEffect(
+              Effect.flatMap(s.get, (state) =>
+                Option.match(state, {
+                  onNone: () =>
+                    Effect.flatMap(s.onSuccess(a2), () =>
+                      s.updateEffect(() => Effect.succeed(Option.some(a2))),
+                    ),
+                  onSome: (prev) =>
+                    Effect.matchCauseEffect(f(prev, a2), {
+                      onFailure: (cause) => s.onFailure(cause),
+                      onSuccess: (equal) =>
+                        equal
+                          ? s.updateEffect(() => Effect.succeed(Option.some(prev)))
+                          : Effect.flatMap(s.onSuccess(a2), () =>
+                              s.updateEffect(() => Effect.succeed(Option.some(a2))),
+                            ),
+                    }),
+                }),
+              ),
+              { onFailure: (cause) => s.onFailure(cause), onSuccess: () => Effect.void },
+            ),
+          ),
+        ),
+      ),
+    ),
+);

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));
+  }
+}