@typed/fx 1.5.9 → 1.6.2

package/src/internal/error/catch.ts

@@ -0,0 +1,74 @@
+import { dualWithTrace } from '@effect/data/Debug'
+
+import { BaseFx } from '@typed/fx/internal/BaseFx'
+import { Sink } from '@typed/fx/internal/Fx'
+import type { Fx } from '@typed/fx/internal/Fx'
+import type { Context, Scope } from '@typed/fx/internal/externals'
+import { Cause, Effect, Either, pipe } from '@typed/fx/internal/externals'
+
+const catch_: {
+  <R, E, A, N extends keyof E, K extends E[N] & string, R2, E2, B>(
+    fx: Fx<R, E, A>,
+    tag: N,
+    k: K,
+    f: (e: Extract<E, { readonly [_ in N]: K }>) => Fx<R2, E2, B>,
+  ): Fx<R | R2, E | E2, A | B>
+  <E, N extends keyof E, K extends E[N] & string, R2, E2, B>(
+    tag: N,
+    k: K,
+    f: (e: Extract<E, { readonly [_ in N]: K }>) => Fx<R2, E2, B>,
+  ): <R, A>(fx: Fx<R, E, A>) => Fx<R2 | R, E | E2, B | A>
+} = dualWithTrace<any, any>(
+  4,
+  (trace) =>
+    <R, E, A, N extends keyof E, K extends E[N] & string, R2, E2, B>(
+      fx: Fx<R, E, A>,
+      tag: N,
+      k: K,
+      f: (e: Extract<E, { readonly [_ in N]: K }>) => Fx<R2, E2, B>,
+    ): Fx<R | R2, E | E2, A | B> =>
+      new CatchFx(fx, tag, k, f).traced(trace),
+)
+
+export { catch_ as catch }
+
+export class CatchFx<R, E, A, N extends keyof E, K extends E[N] & string, R2, E2, B> extends BaseFx<
+  R | R2,
+  E | E2,
+  A | B
+> {
+  readonly name = 'Catch' as const
+
+  constructor(
+    readonly fx: Fx<R, E, A>,
+    readonly tag: N,
+    readonly k: K,
+    readonly f: (e: Extract<E, { readonly [_ in N]: K }>) => Fx<R2, E2, B>,
+  ) {
+    super()
+  }
+
+  run(sink: Sink<E | E2, A | B>): Effect.Effect<R | R2 | Scope.Scope, never, unknown> {
+    return Effect.contextWithEffect((ctx: Context.Context<R | R2 | Scope.Scope>) =>
+      this.fx.run(
+        Sink(
+          sink.event,
+          (cause) =>
+            pipe(
+              cause,
+              Cause.failureOrCause,
+              Either.match(
+                (e) => (this.isExpectedError(e) ? this.f(e).run(sink) : sink.error(cause)),
+                sink.error,
+              ),
+              Effect.provideContext(ctx),
+            ),
+          sink.end,
+        ),
+      ),
+    )
+  }
+
+  isExpectedError = (e: E): e is Extract<E, { readonly [_ in N]: K }> =>
+    typeof e === 'object' && e !== null && this.tag in e && e[this.tag] === this.k
+}

package/src/internal/error/catchAll.ts

@@ -0,0 +1,40 @@
+import { dualWithTrace } from '@effect/data/Debug'
+import { pipe } from '@effect/data/Function'
+
+import { fromEffect } from '../conversion/fromEffect.js'
+
+import type { Fx } from '@typed/fx/internal/Fx'
+import { failCause } from '@typed/fx/internal/constructor/index'
+import { catchAllCause } from '@typed/fx/internal/error/catchAllCause'
+import { Cause, Either, Effect } from '@typed/fx/internal/externals'
+
+export const catchAll: {
+  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (e: E) => Fx<R2, E2, B>): Fx<R | R2, E2, A | B>
+  <E, R2, E2, B>(f: (e: E) => Fx<R2, E2, B>): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2, A | B>
+} = dualWithTrace(
+  2,
+  (trace) =>
+    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (e: E) => Fx<R2, E2, B>): Fx<R | R2, E2, A | B> =>
+      catchAllCause(fx, (cause) =>
+        pipe(cause, Cause.failureOrCause, Either.match(f, failCause)).traced(trace),
+      ),
+)
+
+export const catchAllEffect: {
+  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (e: E) => Effect.Effect<R2, E2, B>): Fx<
+    R | R2,
+    E2,
+    A | B
+  >
+  <E, R2, E2, B>(f: (e: E) => Effect.Effect<R2, E2, B>): <R, A>(
+    fx: Fx<R, E, A>,
+  ) => Fx<R | R2, E2, A | B>
+} = dualWithTrace(
+  2,
+  (trace) =>
+    <R, E, A, R2, E2, B>(
+      fx: Fx<R, E, A>,
+      f: (e: E) => Effect.Effect<R2, E2, B>,
+    ): Fx<R | R2, E2, A | B> =>
+      catchAll(fx, (e) => fromEffect(f(e))).traced(trace),
+)

package/src/internal/error/catchAllCause.ts

@@ -0,0 +1,77 @@
+import { dualWithTrace } from '@effect/data/Debug'
+
+import { fromEffect } from '../conversion/fromEffect.js'
+
+import { BaseFx } from '@typed/fx/internal/BaseFx'
+import { Sink } from '@typed/fx/internal/Fx'
+import type { Fx } from '@typed/fx/internal/Fx'
+import { withRefCounter } from '@typed/fx/internal/RefCounter'
+import type { Cause, Context, Scope } from '@typed/fx/internal/externals'
+import { Effect, pipe } from '@typed/fx/internal/externals'
+
+export const catchAllCause: {
+  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>): Fx<
+    R | R2,
+    E2,
+    A | B
+  >
+  <E, R2, E2, B>(f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>): <R, A>(
+    fx: Fx<R, E, A>,
+  ) => Fx<R | R2, E2, A | B>
+} = dualWithTrace(
+  2,
+  (trace) =>
+    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>) =>
+      new CatchAllCauseFx(fx, f).traced(trace),
+)
+
+export const catchAllCauseEffect: {
+  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, B>): Fx<
+    R | R2,
+    E2,
+    A | B
+  >
+  <E, R2, E2, B>(f: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, B>): <R, A>(
+    fx: Fx<R, E, A>,
+  ) => Fx<R | R2, E2, A | B>
+} = dualWithTrace(
+  2,
+  (trace) =>
+    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, B>) =>
+      new CatchAllCauseFx(fx, (a) => fromEffect(f(a))).traced(trace),
+)
+
+export class CatchAllCauseFx<R, E, A, R2, E2, B> extends BaseFx<R | R2, E2, A | B> {
+  readonly name = 'CatchAllCause' as const
+
+  constructor(readonly fx: Fx<R, E, A>, readonly f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>) {
+    super()
+  }
+
+  run(sink: Sink<E | E2, A | B>): Effect.Effect<R | R2 | Scope.Scope, never, unknown> {
+    return Effect.contextWithEffect((context: Context.Context<R | R2 | Scope.Scope>) =>
+      withRefCounter(
+        1,
+        (counter) =>
+          pipe(
+            this.fx.run(
+              Sink(
+                sink.event,
+                (cause) =>
+                  pipe(
+                    counter.increment,
+                    Effect.zipRight(counter.refCounted(this.f(cause), sink, Effect.unit)),
+                    Effect.forkScoped,
+                    Effect.provideContext(context),
+                  ),
+                Effect.unit,
+              ),
+            ),
+            // Allow the Effect completion to single completion
+            Effect.zipLeft(counter.decrement),
+          ),
+        sink.end,
+      ),
+    )
+  }
+}

package/src/internal/error/catchAllDefect.ts

@@ -0,0 +1,33 @@
+import { dualWithTrace } from '@effect/data/Debug'
+
+import type { Fx } from '@typed/fx/internal/Fx'
+import { failCause } from '@typed/fx/internal/constructor/failCause'
+import { catchAllCause } from '@typed/fx/internal/error/catchAllCause'
+import { Cause, Chunk, Option, pipe } from '@typed/fx/internal/externals'
+
+export const catchAllDefect: {
+  <R, E, A, R2, E2, B>(self: Fx<R, E, A>, f: (defect: unknown) => Fx<R2, E2, B>): Fx<
+    R | R2,
+    E | E2,
+    A | B
+  >
+  <R2, E2, B>(f: (defect: unknown) => Fx<R2, E2, B>): <R, E, A>(
+    self: Fx<R, E, A>,
+  ) => Fx<R | R2, E | E2, A | B>
+} = dualWithTrace(
+  2,
+  (trace) =>
+    <R, E, A, R2, E2, B>(
+      self: Fx<R, E, A>,
+      f: (defect: unknown) => Fx<R2, E2, B>,
+    ): Fx<R | R2, E | E2, A | B> =>
+      catchAllCause(
+        self,
+        (cause): Fx<R2, E | E2, B> =>
+          pipe(
+            Cause.defects(cause),
+            Chunk.head,
+            Option.match(() => failCause(cause), f),
+          ),
+      ).traced(trace),
+)

package/src/internal/error/catchSome.ts

@@ -0,0 +1,25 @@
+import { dualWithTrace } from '@effect/data/Debug'
+import * as Option from '@effect/data/Option'
+
+import type { Fx } from '@typed/fx/internal/Fx'
+import { fail } from '@typed/fx/internal/constructor/fail'
+import { catchAll } from '@typed/fx/internal/error/catchAll'
+
+export const catchSome: {
+  <R, E, A, R2, E2, B>(self: Fx<R, E, A>, f: (error: E) => Option.Option<Fx<R2, E2, B>>): Fx<
+    R | R2,
+    E | E2,
+    A | B
+  >
+
+  <E, R2, E2, B>(f: (error: E) => Option.Option<Fx<R2, E2, B>>): <R, A>(
+    self: Fx<R, E, A>,
+  ) => Fx<R | R2, E | E2, A | B>
+} = dualWithTrace(
+  2,
+  (trace) =>
+    <R, E, A, R2, E2, B>(self: Fx<R, E, A>, f: (error: E) => Option.Option<Fx<R2, E2, B>>) =>
+      catchAll(self, (error) =>
+        Option.getOrElse(f(error), (): Fx<R2, E | E2, B> => fail(error)),
+      ).traced(trace),
+)

package/src/internal/error/catchSomeCause.ts

@@ -0,0 +1,31 @@
+import { dualWithTrace } from '@effect/data/Debug'
+import { pipe } from '@effect/data/Function'
+import * as Option from '@effect/data/Option'
+import type { Cause } from '@effect/io/Cause'
+
+import type { Fx } from '@typed/fx/internal/Fx'
+import { failCause } from '@typed/fx/internal/constructor/failCause'
+import { catchAllCause } from '@typed/fx/internal/error/catchAllCause'
+
+export const catchSomeCause: {
+  <R, E, A, R2, E2, B>(self: Fx<R, E, A>, f: (cause: Cause<E>) => Option.Option<Fx<R2, E2, B>>): Fx<
+    R | R2,
+    E | E2,
+    A | B
+  >
+
+  <E, R2, E2, B>(f: (cause: Cause<E>) => Option.Option<Fx<R2, E2, B>>): <R, A>(
+    self: Fx<R, E, A>,
+  ) => Fx<R | R2, E | E2, A | B>
+} = dualWithTrace(
+  2,
+  (trace) =>
+    <R, E, A, R2, E2, B>(self: Fx<R, E, A>, f: (cause: Cause<E>) => Option.Option<Fx<R2, E2, B>>) =>
+      catchAllCause(self, (cause) =>
+        pipe(
+          cause,
+          f,
+          Option.getOrElse((): Fx<R2, E | E2, B> => failCause(cause)),
+        ),
+      ).traced(trace),
+)

package/src/internal/error/catchTag.ts

@@ -0,0 +1,17 @@
+import { dualWithTrace } from '@effect/data/Debug'
+
+import type { Fx } from '@typed/fx/internal/Fx'
+import { catchTags } from '@typed/fx/internal/error/catchTags'
+
+export const catchTag: {
+  <R, E extends { readonly _tag: string }, A, K extends E['_tag'] & string, R1, E1, A1>(
+    self: Fx<R, E, A>,
+    k: K,
+    f: (e: Extract<E, { readonly _tag: K[number] }>) => Fx<R1, E1, A1>,
+  ): Fx<R | R1, E1 | Exclude<E, { readonly _tag: K[number] }>, A | A1>
+
+  <E extends { readonly _tag: string }, K extends E['_tag'] & string, R1, E1, A1>(
+    k: K,
+    f: (e: Extract<E, { readonly _tag: K[number] }>) => Fx<R1, E1, A1>,
+  ): <R, A>(self: Fx<R, E, A>) => Fx<R | R1, E1 | Exclude<E, { readonly _tag: K[number] }>, A | A1>
+} = dualWithTrace(3, (trace) => (self, k, f) => catchTags(self, [k], f).traced(trace))

package/src/internal/error/catchTags.ts

@@ -0,0 +1,60 @@
+import { dualWithTrace } from '@effect/data/Debug'
+
+import type { Fx } from '@typed/fx/internal/Fx'
+import { fail } from '@typed/fx/internal/constructor/fail'
+import { catchAll } from '@typed/fx/internal/error/catchAll'
+
+export const catchTags: {
+  <
+    R,
+    E extends { readonly _tag: string },
+    A,
+    const K extends ReadonlyArray<E['_tag'] & string>,
+    R1,
+    E1,
+    A1,
+  >(
+    self: Fx<R, E, A>,
+    k: K,
+    f: (e: Extract<E, { readonly _tag: K[number] }>) => Fx<R1, E1, A1>,
+  ): Fx<R | R1, E1 | Exclude<E, { readonly _tag: K[number] }>, A | A1>
+
+  <
+    E extends { readonly _tag: string },
+    const K extends ReadonlyArray<E['_tag'] & string>,
+    R1,
+    E1,
+    A1,
+  >(
+    k: K,
+    f: (e: Extract<E, { readonly _tag: K[number] }>) => Fx<R1, E1, A1>,
+  ): <R, A>(self: Fx<R, E, A>) => Fx<R | R1, E1 | Exclude<E, { readonly _tag: K[number] }>, A | A1>
+} = dualWithTrace(
+  3,
+  (trace) =>
+    <
+      R,
+      E extends { readonly _tag: string },
+      A,
+      const K extends ReadonlyArray<E['_tag'] & string>,
+      R1,
+      E1,
+      A1,
+    >(
+      self: Fx<R, E, A>,
+      k: K,
+      f: (e: Extract<E, { readonly _tag: K[number] }>) => Fx<R1, E1, A1>,
+    ): Fx<R | R1, E1 | Exclude<E, { readonly _tag: K[number] }>, A | A1> => {
+      const keys = new Set(k)
+      const isTaggedError = (error: E): error is Extract<E, { readonly _tag: K[number] }> =>
+        isObject(error) && '_tag' in error && keys.has(error._tag)
+
+      return catchAll(
+        self,
+        (e): Fx<R1, Exclude<E, { readonly _tag: K[number] }> | E1, A1> =>
+          isTaggedError(e) ? f(e) : fail(e as Exclude<E, { readonly _tag: K[number] }>),
+      ).traced(trace)
+    },
+)
+
+const isObject = (value: unknown): value is object => typeof value === 'object' && value !== null

package/src/internal/error/cause.ts

@@ -0,0 +1,30 @@
+import { methodWithTrace } from '@effect/data/Debug'
+import * as Cause from '@effect/io/Cause'
+
+import { Effect, Scope } from '../externals.js'
+
+import { BaseFx } from '@typed/fx/internal/BaseFx'
+import { Sink } from '@typed/fx/internal/Fx'
+import type { Fx } from '@typed/fx/internal/Fx'
+
+export const cause: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, never, Cause.Cause<E>> = methodWithTrace(
+  (trace) => (fx) => new CauseFx(fx).traced(trace),
+)
+
+export class CauseFx<R, E, A> extends BaseFx<R, never, Cause.Cause<E>> {
+  readonly name = 'Cause'
+
+  constructor(readonly fx: Fx<R, E, A>) {
+    super()
+  }
+
+  run(sink: Sink<never, Cause.Cause<E>>): Effect.Effect<R | Scope.Scope, never, unknown> {
+    return this.fx.run(
+      Sink(
+        () => sink.event(Cause.empty),
+        (e) => sink.event(e),
+        sink.end,
+      ),
+    )
+  }
+}

package/src/internal/error/exit.ts

@@ -0,0 +1,31 @@
+import { methodWithTrace } from '@effect/data/Debug'
+import { pipe } from '@effect/data/Function'
+import * as Exit from '@effect/io/Exit'
+
+import { Effect, Scope } from '../externals.js'
+
+import { BaseFx } from '@typed/fx/internal/BaseFx'
+import { Sink } from '@typed/fx/internal/Fx'
+import type { Fx } from '@typed/fx/internal/Fx'
+
+export const exit: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, never, Exit.Exit<E, A>> = methodWithTrace(
+  (trace) => (fx) => new ExitFx(fx).traced(trace),
+)
+
+export class ExitFx<R, E, A> extends BaseFx<R, never, Exit.Exit<E, A>> {
+  readonly name = 'Exit'
+
+  constructor(readonly fx: Fx<R, E, A>) {
+    super()
+  }
+
+  run(sink: Sink<never, Exit.Exit<E, A>>): Effect.Effect<R | Scope.Scope, never, unknown> {
+    return this.fx.run(
+      Sink(
+        (a) => pipe(a, Exit.succeed, sink.event),
+        (e) => pipe(e, Exit.failCause, sink.event),
+        sink.end,
+      ),
+    )
+  }
+}

package/src/internal/error/index.ts

@@ -0,0 +1,22 @@
+export * from './absolve.js'
+export * from './absolveWith.js'
+export * from './absorb.js'
+export * from './absorbWith.js'
+export * from './catch.js'
+export * from './catchAll.js'
+export * from './catchAllCause.js'
+export * from './catchAllDefect.js'
+export * from './catchSome.js'
+export * from './catchSomeCause.js'
+export * from './catchTag.js'
+export * from './catchTags.js'
+export * from './cause.js'
+export * from './exit.js'
+export * from './orDie.js'
+export * from './orDieWith.js'
+export * from './orElse.js'
+export * from './orElseEither.js'
+export * from './orElseFail.js'
+export * from './orElseOptional.js'
+export * from './orElseSucceed.js'
+export * from './tryOrElse.js'

package/src/internal/error/orDie.ts

@@ -0,0 +1,7 @@
+import { identity } from '@effect/data/Function'
+
+import { orDieWith } from './orDieWith.js'
+
+import type { Fx } from '@typed/fx/internal/Fx'
+
+export const orDie = <R, E, A>(fx: Fx<R, E, A>): Fx<R, never, A> => orDieWith(fx, identity)

package/src/internal/error/orDieWith.ts

@@ -0,0 +1,34 @@
+import { dualWithTrace } from '@effect/data/Debug'
+
+import { BaseFx } from '@typed/fx/internal/BaseFx'
+import type { Fx } from '@typed/fx/internal/Fx'
+import { Sink } from '@typed/fx/internal/Fx'
+import { Cause, Effect, Scope } from '@typed/fx/internal/externals'
+
+export const orDieWith: {
+  <R, E, A>(self: Fx<R, E, A>, f: (error: E) => unknown): Fx<R, never, A>
+  <E>(f: (error: E) => unknown): <R, A>(self: Fx<R, E, A>) => Fx<R, never, A>
+} = dualWithTrace(
+  2,
+  (trace) =>
+    <R, E, A>(self: Fx<R, E, A>, f: (error: E) => unknown): Fx<R, never, A> =>
+      new OrDieWithFx(self, f).traced(trace),
+)
+
+class OrDieWithFx<R, E, A> extends BaseFx<R, never, A> {
+  readonly name = 'OrDieWithFx' as const
+
+  constructor(readonly self: Fx<R, E, A>, readonly f: (error: E) => unknown) {
+    super()
+  }
+
+  run(sink: Sink<never, A>): Effect.Effect<R | Scope.Scope, never, unknown> {
+    return this.self.run(
+      Sink(
+        sink.event,
+        (cause) => sink.error(Cause.flatMap(cause, (e) => Cause.die(this.f(e)))),
+        sink.end,
+      ),
+    )
+  }
+}

package/src/internal/error/orElse.ts

@@ -0,0 +1,35 @@
+import { dualWithTrace } from '@effect/data/Debug'
+
+import { BaseFx } from '@typed/fx/internal/BaseFx'
+import { Sink } from '@typed/fx/internal/Fx'
+import type { Fx } from '@typed/fx/internal/Fx'
+import type { Context, Scope } from '@typed/fx/internal/externals'
+import { Effect } from '@typed/fx/internal/externals'
+
+export const orElse: {
+  <R, E, A, R1, E1, A1>(self: Fx<R, E, A>, that: () => Fx<R1, E1, A1>): Fx<R | R1, E | E1, A | A1>
+  <R1, E1, A1>(that: () => Fx<R1, E1, A1>): <R, E, A>(
+    self: Fx<R, E, A>,
+  ) => Fx<R | R1, E | E1, A | A1>
+} = dualWithTrace(
+  2,
+  (trace) =>
+    <R, E, A, R1, E1, A1>(self: Fx<R, E, A>, that: () => Fx<R1, E1, A1>) =>
+      new OrElseFx(self, that).traced(trace),
+)
+
+class OrElseFx<R, E, A, R1, E1, A1> extends BaseFx<R | R1, E | E1, A | A1> {
+  readonly name = 'OrElse' as const
+
+  constructor(readonly self: Fx<R, E, A>, readonly that: () => Fx<R1, E1, A1>) {
+    super()
+  }
+
+  run(sink: Sink<E | E1, A | A1>) {
+    return Effect.contextWithEffect((ctx: Context.Context<R1 | Scope.Scope>) =>
+      this.self.run(
+        Sink(sink.event, () => Effect.provideContext(this.that().run(sink), ctx), sink.end),
+      ),
+    )
+  }
+}

package/src/internal/error/orElseEither.ts

@@ -0,0 +1,45 @@
+import { dualWithTrace } from '@effect/data/Debug'
+
+import { BaseFx } from '@typed/fx/internal/BaseFx'
+import { Sink } from '@typed/fx/internal/Fx'
+import type { Fx } from '@typed/fx/internal/Fx'
+import type { Context, Scope } from '@typed/fx/internal/externals'
+import { Effect, Either } from '@typed/fx/internal/externals'
+
+export const orElseEither: {
+  <R, E, A, R1, E1, A1>(self: Fx<R, E, A>, that: () => Fx<R1, E1, Either.Either<A, A1>>): Fx<
+    R | R1,
+    E | E1,
+    Either.Either<A, A1>
+  >
+  <R1, E1, A, A1>(that: () => Fx<R1, E1, Either.Either<A, A1>>): <R, E>(
+    self: Fx<R, E, A>,
+  ) => Fx<R | R1, E | E1, Either.Either<A, A1>>
+} = dualWithTrace(
+  2,
+  (trace) =>
+    <R, E, A, R1, E1, A1>(self: Fx<R, E, A>, that: () => Fx<R1, E1, Either.Either<A, A1>>) =>
+      new OrElseEitherFx(self, that).traced(trace),
+)
+
+class OrElseEitherFx<R, E, A, R1, E1, A1> extends BaseFx<R | R1, E | E1, Either.Either<A, A1>> {
+  readonly name = 'OrElseEither' as const
+
+  constructor(readonly self: Fx<R, E, A>, readonly that: () => Fx<R1, E1, Either.Either<A, A1>>) {
+    super()
+  }
+
+  run(
+    sink: Sink<E | E1, Either.Either<A, A1>>,
+  ): Effect.Effect<R | R1 | Scope.Scope, never, unknown> {
+    return Effect.contextWithEffect((ctx: Context.Context<R1 | Scope.Scope>) =>
+      this.self.run(
+        Sink(
+          (a) => sink.event(Either.left(a)),
+          () => Effect.provideContext(this.that().run(sink), ctx),
+          sink.end,
+        ),
+      ),
+    )
+  }
+}

package/src/internal/error/orElseFail.ts

@@ -0,0 +1,28 @@
+import { dualWithTrace } from '@effect/data/Debug'
+
+import { BaseFx } from '@typed/fx/internal/BaseFx'
+import { Sink } from '@typed/fx/internal/Fx'
+import type { Fx } from '@typed/fx/internal/Fx'
+import { Cause, Effect, Scope } from '@typed/fx/internal/externals'
+
+export const orElseFail: {
+  <R, E, A, E2>(fx: Fx<R, E, A>, orFail: () => E2): Fx<R, E2, A>
+  <E2>(orFail: () => E2): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E2, A>
+} = dualWithTrace(
+  2,
+  (trace) =>
+    <R, E, A, E2>(fx: Fx<R, E, A>, orFail: () => E2) =>
+      new OrElseFailFx(fx, orFail).traced(trace),
+)
+
+export class OrElseFailFx<R, E, A, E2> extends BaseFx<R, E2, A> {
+  readonly name = 'OrElseFail' as const
+
+  constructor(readonly fx: Fx<R, E, A>, readonly orFail: () => E2) {
+    super()
+  }
+
+  run(sink: Sink<E2, A>): Effect.Effect<R | Scope.Scope, never, unknown> {
+    return this.fx.run(Sink(sink.event, () => sink.error(Cause.fail(this.orFail())), sink.end))
+  }
+}

package/src/internal/error/orElseOptional.ts

@@ -0,0 +1,46 @@
+import { dualWithTrace } from '@effect/data/Debug'
+
+import { BaseFx } from '@typed/fx/internal/BaseFx'
+import { Sink } from '@typed/fx/internal/Fx'
+import type { Fx } from '@typed/fx/internal/Fx'
+import { Effect } from '@typed/fx/internal/externals'
+import type { Context, Option, Scope } from '@typed/fx/internal/externals'
+
+export const orElseOptional = dualWithTrace(
+  2,
+  (trace) =>
+    <R, E, A, R1, E1, A1>(
+      self: Fx<R, Option.Option<E>, A>,
+      that: () => Fx<R1, Option.Option<E1>, A1>,
+    ) =>
+      new OrElseOptionalFx(self, that).traced(trace),
+)
+
+export class OrElseOptionalFx<R, E, A, R1, E1, A1> extends BaseFx<
+  R | R1,
+  Option.Option<E | E1>,
+  A | A1
+> {
+  readonly name = 'OrElseOptional' as const
+
+  constructor(
+    readonly self: Fx<R, Option.Option<E>, A>,
+    readonly that: () => Fx<R1, Option.Option<E1>, A1>,
+  ) {
+    super()
+  }
+
+  run(
+    sink: Sink<Option.Option<E | E1>, A | A1>,
+  ): Effect.Effect<R | R1 | Scope.Scope, never, unknown> {
+    return Effect.contextWithEffect((ctx: Context.Context<R1 | Scope.Scope>) =>
+      this.self.run(
+        Sink(
+          (a) => sink.event(a),
+          () => Effect.provideContext(this.that().run(sink), ctx),
+          sink.end,
+        ),
+      ),
+    )
+  }
+}