@typed/fx 1.6.2 → 1.8.0

package/src/internal/error/catch.ts

@@ -1,74 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,77 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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,
-        ),
-      ),
-    )
-  }
-}