@typed/fx 1.6.2 → 1.8.0

package/src/internal/context/serviceWithEffect.ts

@@ -1,22 +0,0 @@
-import type { Trace } from '@effect/data/Debug'
-
-import type { Fx } from '@typed/fx/internal/Fx'
-import { fromEffect } from '@typed/fx/internal/conversion/fromEffect'
-import type { Context } from '@typed/fx/internal/externals'
-import { Debug, Effect } from '@typed/fx/internal/externals'
-
-export const serviceWithEffect: {
-  <I, A, R2, E2, B>(tag: Context.Tag<I, A>, f: (a: A) => Effect.Effect<R2, E2, B>): Fx<
-    R2 | I,
-    E2,
-    B
-  >
-  <A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>): <I>(
-    tag: Context.Tag<I, A>,
-  ) => Fx<R2 | I, E2, B>
-} = Debug.dualWithTrace(
-  2,
-  (trace: Trace) =>
-    <I, A, R2, E2, B>(tag: Context.Tag<I, A>, f: (a: A) => Effect.Effect<R2, E2, B>) =>
-      fromEffect(Effect.flatMap(tag, f)).traced(trace),
-)

package/src/internal/context/serviceWithFx.ts

@@ -1,26 +0,0 @@
-import { BaseFx } from '@typed/fx/internal/BaseFx'
-import type { Fx, Sink } from '@typed/fx/internal/Fx'
-import type { Context, Scope } from '@typed/fx/internal/externals'
-import { Debug, Effect } from '@typed/fx/internal/externals'
-
-export const serviceWithFx: {
-  <I, A, R2, E2, B>(tag: Context.Tag<I, A>, f: (a: A) => Fx<R2, E2, B>): Fx<R2 | I, E2, B>
-  <I, A, R2, E2, B>(f: (a: A) => Fx<R2, E2, B>): (tag: Context.Tag<I, A>) => Fx<R2 | I, E2, B>
-} = Debug.dualWithTrace(
-  2,
-  (trace) =>
-    <I, A, R2, E2, B>(tag: Context.Tag<I, A>, f: (a: A) => Fx<R2, E2, B>) =>
-      new ServiceWithFx(tag, f).traced(trace),
-)
-
-export class ServiceWithFx<I, A, R, E, B> extends BaseFx<R | I, E, B> {
-  readonly name = 'ServiceWithFx' as const
-
-  constructor(readonly tag: Context.Tag<I, A>, readonly f: (a: A) => Fx<R, E, B>) {
-    super()
-  }
-
-  run(sink: Sink<E, B>): Effect.Effect<R | I | Scope.Scope, never, unknown> {
-    return Effect.flatMap(this.tag, (a) => this.f(a).run(sink))
-  }
-}

package/src/internal/context/updateService.ts

@@ -1,21 +0,0 @@
-import type { Tag } from '@effect/data/Context'
-import { dualWithTrace } from '@effect/data/Debug'
-
-import type { Fx } from '@typed/fx/internal/Fx'
-import { Effect } from '@typed/fx/internal/externals'
-
-export const updateService: {
-  <R, I, E, A, S>(fx: Fx<R | I, E, A>, service: Tag<I, S>, f: (service: S) => S): Fx<R | I, E, A>
-  <I, S>(service: Tag<I, S>, f: (service: S) => S): <R, E, A>(
-    fx: Fx<R | I, E, A>,
-  ) => Fx<R | I, E, A>
-} = dualWithTrace(
-  3,
-  (trace) =>
-    <R, I, E, A, S>(
-      fx: Fx<R | I, E, A>,
-      service: Tag<I, S>,
-      f: (service: S) => S,
-    ): Fx<R | I, E, A> =>
-      fx.transform(Effect.updateService(service, f)).traced(trace),
-)

package/src/internal/conversion/either.ts

@@ -1,34 +0,0 @@
-import { methodWithTrace } from '@effect/data/Debug'
-import * as Either from '@effect/data/Either'
-import { pipe } from '@effect/data/Function'
-
-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 either: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, never, Either.Either<E, A>> =
-  methodWithTrace((trace) => (fx) => new EitherFx(fx).traced(trace))
-
-export class EitherFx<R, E, A> extends BaseFx<R, never, Either.Either<E, A>> {
-  readonly name = 'Either'
-
-  constructor(readonly fx: Fx<R, E, A>) {
-    super()
-  }
-
-  run(sink: Sink<never, Either.Either<E, A>>): Effect.Effect<R | Scope.Scope, never, unknown> {
-    return this.fx.run(
-      Sink(
-        (a) => pipe(a, Either.right, sink.event),
-        (e) =>
-          Either.match(
-            Cause.failureOrCause(e),
-            (e) => pipe(e, Either.left, sink.event),
-            sink.error,
-          ),
-        sink.end,
-      ),
-    )
-  }
-}

package/src/internal/conversion/fromArray.ts

@@ -1,31 +0,0 @@
-import { methodWithTrace } from '@effect/data/Debug'
-import * as Effect from '@effect/io/Effect'
-
-import { Scope } from '../externals.js'
-
-import { BaseFx } from '@typed/fx/internal/BaseFx'
-import type { Fx, Sink } from '@typed/fx/internal/Fx'
-
-export const fromArray: <const T extends ReadonlyArray<any>>(
-  array: T,
-) => Fx<never, never, T[number]> = methodWithTrace(
-  (trace) =>
-    <const T extends ReadonlyArray<any>>(array: T): Fx<never, never, T[number]> =>
-      new FromArrayFx(array).traced(trace),
-)
-
-export class FromArrayFx<T extends ReadonlyArray<any>> extends BaseFx<never, never, T[number]> {
-  readonly name = 'FromArray' as const
-
-  constructor(readonly array: T) {
-    super()
-  }
-
-  run(sink: Sink<never, T[number]>): Effect.Effect<Scope.Scope, never, unknown> {
-    return Effect.matchCauseEffect(
-      Effect.forEachDiscard(this.array, sink.event),
-      sink.error,
-      sink.end,
-    )
-  }
-}

package/src/internal/conversion/fromEffect.ts

@@ -1,51 +0,0 @@
-import { methodWithTrace } from '@effect/data/Debug'
-import { pipe } from '@effect/data/Function'
-import * as Effect from '@effect/io/Effect'
-import type { Scope } from '@effect/io/Scope'
-
-import { BaseFx } from '@typed/fx/internal/BaseFx'
-import type { Fx, Sink } from '@typed/fx/internal/Fx'
-
-/**
- * Construct a Fx from an Effect.
- * @since 1.0.0
- * @category Constructor
- */
-export const fromEffect: <Services = never, Errors = never, Output = unknown>(
-  effect: Effect.Effect<Services, Errors, Output>,
-) => Fx<Exclude<Services, Scope>, Errors, Output> = methodWithTrace(
-  (trace) =>
-    <Services, Errors, Output>(
-      effect: Effect.Effect<Services, Errors, Output>,
-    ): Fx<Exclude<Services, Scope>, Errors, Output> =>
-      new FromEffect(effect).traced(trace),
-)
-
-export class FromEffect<Services, Errors, Output> extends BaseFx<
-  Exclude<Services, Scope>,
-  Errors,
-  Output
-> {
-  readonly name = 'FromEffect' as const
-
-  constructor(readonly effect: Effect.Effect<Services, Errors, Output>) {
-    super()
-  }
-
-  run(sink: Sink<Errors, Output>): Effect.Effect<Exclude<Services, Scope> | Scope, never, unknown> {
-    return Effect.matchCauseEffect(this.effect, sink.error, (a) =>
-      pipe(sink.event(a), Effect.flatMap(sink.end)),
-    ) as any
-  }
-}
-
-/**
- * Type guard for FromEffect.
- * @since 1.0.0
- * @category Type Guard
- */
-export function isFromEffect<Services, Errors, Output>(
-  fx: Fx<Services, Errors, Output>,
-): fx is FromEffect<Services, Errors, Output> {
-  return fx instanceof FromEffect
-}

package/src/internal/conversion/fromEither.ts

@@ -1,10 +0,0 @@
-import { methodWithTrace } from '@effect/data/Debug'
-import type { Either } from '@effect/data/Either'
-import * as Effect from '@effect/io/Effect'
-
-import type { Fx } from '@typed/fx/internal/Fx'
-import { fromEffect } from '@typed/fx/internal/conversion/fromEffect'
-
-export const fromEither: <E, A>(either: Either<E, A>) => Fx<never, E, A> = methodWithTrace(
-  (trace) => (either) => fromEffect(Effect.fromEither(either)).traced(trace),
-)

package/src/internal/conversion/fromEitherCause.ts

@@ -1,10 +0,0 @@
-import { methodWithTrace } from '@effect/data/Debug'
-import type { Either } from '@effect/data/Either'
-import type { Cause } from '@effect/io/Cause'
-import * as Effect from '@effect/io/Effect'
-
-import type { Fx } from '@typed/fx/internal/Fx'
-import { fromEffect } from '@typed/fx/internal/conversion/fromEffect'
-
-export const fromEitherCause: <E, A>(either: Either<Cause<E>, A>) => Fx<never, E, A> =
-  methodWithTrace((trace) => (either) => fromEffect(Effect.fromEitherCause(either)).traced(trace))

package/src/internal/conversion/fromEmitter.ts

@@ -1,49 +0,0 @@
-import * as Runtime from '@effect/io/Runtime'
-
-import { BaseFx } from '@typed/fx/internal/BaseFx'
-import type { Fx, Sink } from '@typed/fx/internal/Fx'
-import { withRefCounter } from '@typed/fx/internal/RefCounter'
-import type { Cause, Scope } from '@typed/fx/internal/externals'
-import { Effect } from '@typed/fx/internal/externals'
-
-export interface Emitter<E, A> {
-  readonly event: (a: A) => void
-  readonly error: (e: Cause.Cause<E>) => void
-  readonly end: () => void
-}
-
-export function fromEmitter<E, A, R = never, E2 = never>(
-  emitter: (sink: Emitter<E, A>) => Effect.Effect<R | Scope.Scope, E2, unknown>,
-): Fx<Exclude<R, Scope.Scope>, E | E2, A> {
-  return new FromEmitterFx(emitter)
-}
-
-export class FromEmitterFx<E, A, R, E2> extends BaseFx<Exclude<R, Scope.Scope>, E | E2, A> {
-  readonly name = 'FromEmitter' as const
-
-  constructor(readonly f: (sink: Emitter<E, A>) => Effect.Effect<R | Scope.Scope, E2, unknown>) {
-    super()
-  }
-
-  run(sink: Sink<E | E2, A>) {
-    const { f } = this
-
-    return withRefCounter(
-      1,
-      (counter) =>
-        Effect.gen(function* ($) {
-          const runtime = yield* $(Effect.runtime<R | Scope.Scope>())
-          const fork = Runtime.runFork(runtime)
-          const error = (e: Cause.Cause<E | E2>) => Effect.zipLeft(sink.error(e), counter.decrement)
-          const emitter: Emitter<E, A> = {
-            event: (a) => fork(sink.event(a)),
-            error: (e) => fork(error(e)),
-            end: () => fork(counter.decrement),
-          }
-
-          yield* $(Effect.catchAllCause(f(emitter), error))
-        }),
-      sink.end,
-    ) as Effect.Effect<Exclude<R, Scope.Scope> | Scope.Scope, never, unknown>
-  }
-}

package/src/internal/conversion/fromFiber.ts

@@ -1,12 +0,0 @@
-import { methodWithTrace } from '@effect/data/Debug'
-import * as Effect from '@effect/io/Effect'
-import type { Fiber } from '@effect/io/Fiber'
-
-import type { Fx } from '@typed/fx/internal/Fx'
-import { fromEffect } from '@typed/fx/internal/conversion/fromEffect'
-
-export const fromFiber: <Errors, Output>(
-  fiber: Fiber<Errors, Output>,
-) => Fx<never, Errors, Output> = methodWithTrace(
-  (trace) => (fiber) => fromEffect(Effect.fromFiber(fiber)).traced(trace),
-)

package/src/internal/conversion/fromFiberEffect.ts

@@ -1,12 +0,0 @@
-import { methodWithTrace } from '@effect/data/Debug'
-import * as Effect from '@effect/io/Effect'
-import type { Fiber } from '@effect/io/Fiber'
-
-import type { Fx } from '@typed/fx/internal/Fx'
-import { fromEffect } from '@typed/fx/internal/conversion/fromEffect'
-
-export const fromFiberEffect: <Services, Errors, Output>(
-  fiber: Effect.Effect<Services, Errors, Fiber<Errors, Output>>,
-) => Fx<Services, Errors, Output> = methodWithTrace(
-  (trace) => (fiber) => fromEffect(Effect.fromFiberEffect(fiber)).traced(trace),
-)

package/src/internal/conversion/fromFxEffect.ts

@@ -1,30 +0,0 @@
-import { methodWithTrace } from '@effect/data/Debug'
-import { type Effect, matchCauseEffect, uninterruptible } from '@effect/io/Effect'
-
-import { BaseFx } from '@typed/fx/internal/BaseFx'
-import type { Fx, Sink } from '@typed/fx/internal/Fx'
-import type { Scope } from '@typed/fx/internal/externals'
-
-export const fromFxEffect: <R, E, R2 = never, E2 = never, A = unknown>(
-  effect: Effect<R, E, Fx<R2, E2, A>>,
-) => Fx<Exclude<R, Scope.Scope> | R2, E | E2, A> = methodWithTrace(
-  (trace) =>
-    <R, E, R2 = never, E2 = never, A = unknown>(effect: Effect<R, E, Fx<R2, E2, A>>) =>
-      new FromFxEffect(effect).traced(trace),
-)
-
-export class FromFxEffect<R, E, R2, E2, A> extends BaseFx<Exclude<R, Scope.Scope> | R2, E | E2, A> {
-  readonly name = 'FromFxEffect' as const
-
-  constructor(readonly effect: Effect<R, E, Fx<R2, E2, A>>) {
-    super()
-  }
-
-  /**
-   * @macro traced
-   */
-  run(sink: Sink<E | E2, A>): Effect<Exclude<R, Scope.Scope> | Scope.Scope, never, unknown> {
-    // Ensure this.effect is uninterruptible, to ensure it can add any necessary resources to the Scope
-    return matchCauseEffect(uninterruptible(this.effect), sink.error, (fx) => fx.run(sink)) as any
-  }
-}

package/src/internal/conversion/fromOption.ts

@@ -1,10 +0,0 @@
-import { methodWithTrace } from '@effect/data/Debug'
-import type { Option } from '@effect/data/Option'
-import * as Effect from '@effect/io/Effect'
-
-import type { Fx } from '@typed/fx/internal/Fx'
-import { fromEffect } from '@typed/fx/internal/conversion/fromEffect'
-
-export const fromOption: <A>(option: Option<A>) => Fx<never, Option<never>, A> = methodWithTrace(
-  (trace) => (option) => fromEffect(Effect.fromOption(option)).traced(trace),
-)

package/src/internal/conversion/getOrFail.ts

@@ -1,14 +0,0 @@
-import { methodWithTrace } from '@effect/data/Debug'
-import type { NoSuchElementException } from '@effect/io/Cause'
-
-import type { Fx } from '@typed/fx/internal/Fx'
-import { fromEffect } from '@typed/fx/internal/conversion/fromEffect'
-import type { Option } from '@typed/fx/internal/externals'
-import { Effect } from '@typed/fx/internal/externals'
-
-export const getOrFail: <A>(option: Option.Option<A>) => Fx<never, NoSuchElementException, A> =
-  methodWithTrace(
-    (trace) =>
-      <A>(option: Option.Option<A>): Fx<never, NoSuchElementException, A> =>
-        fromEffect(Effect.getOrFail(option).traced(trace)),
-  )

package/src/internal/conversion/getOrFailDiscard.ts

@@ -1,13 +0,0 @@
-import { methodWithTrace } from '@effect/data/Debug'
-
-import type { Fx } from '@typed/fx/internal/Fx'
-import { fromEffect } from '@typed/fx/internal/conversion/fromEffect'
-import type { Option } from '@typed/fx/internal/externals'
-import { Effect } from '@typed/fx/internal/externals'
-
-export const getOrFailDiscard: <A>(option: Option.Option<A>) => Fx<never, void, A> =
-  methodWithTrace(
-    (trace) =>
-      <A>(option: Option.Option<A>): Fx<never, void, A> =>
-        fromEffect(Effect.getOrFailDiscard(option).traced(trace)),
-  )

package/src/internal/conversion/getOrFailWith.ts

@@ -1,16 +0,0 @@
-import { dualWithTrace } from '@effect/data/Debug'
-
-import type { Fx } from '@typed/fx/internal/Fx'
-import { fromEffect } from '@typed/fx/internal/conversion/fromEffect'
-import type { Option } from '@typed/fx/internal/externals'
-import { Effect } from '@typed/fx/internal/externals'
-
-export const getOrFailWith: {
-  <A, E>(option: Option.Option<A>, f: () => E): Fx<never, E, A>
-  <E>(f: () => E): <A>(option: Option.Option<A>) => Fx<never, E, A>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <A, E>(option: Option.Option<A>, f: () => E): Fx<never, E, A> =>
-      fromEffect(Effect.getOrFailWith(option, f).traced(trace)),
-)

package/src/internal/conversion/index.ts

@@ -1,13 +0,0 @@
-export * from './either.js'
-export * from './fromArray.js'
-export * from './fromEffect.js'
-export * from './fromEither.js'
-export * from './fromEitherCause.js'
-export * from './fromEmitter.js'
-export * from './fromFiber.js'
-export * from './fromFiberEffect.js'
-export * from './fromFxEffect.js'
-export * from './fromOption.js'
-export * from './getOrFail.js'
-export * from './getOrFailDiscard.js'
-export * from './getOrFailWith.js'

package/src/internal/do/Do.ts

@@ -1,4 +0,0 @@
-import type { Fx } from '@typed/fx/internal/Fx'
-import { succeed } from '@typed/fx/internal/constructor/succeed'
-
-export const Do: Fx.Succeed<Readonly<Record<never, never>>> = succeed({})

package/src/internal/do/bind.ts

@@ -1,57 +0,0 @@
-import { dualWithTrace } from '@effect/data/Debug'
-
-import { Effect, Scope } from '../externals.js'
-
-import { BaseFx } from '@typed/fx/internal/BaseFx'
-import type { Fx, Sink } from '@typed/fx/internal/Fx'
-import { flatMap } from '@typed/fx/internal/operator/flatMap'
-import { map } from '@typed/fx/internal/operator/map'
-
-export const bind: {
-  <R, E, N extends string, K, R2, E2, A>(
-    self: Fx<R, E, K>,
-    tag: Exclude<N, keyof K>,
-    f: (_: K) => Fx<R2, E2, A>,
-  ): Fx<R | R2, E | E2, MergeObjects<K, { readonly [_ in N]: A }>>
-
-  <N extends string, K, R2, E2, A>(tag: Exclude<N, keyof K>, f: (_: K) => Fx<R2, E2, A>): <R, E>(
-    self: Fx<R, E, K>,
-  ) => Fx<R | R2, E | E2, MergeObjects<K, { readonly [_ in N]: A }>>
-} = dualWithTrace(
-  3,
-  (trace) =>
-    <R, E, N extends string, K, R2, E2, A>(
-      self: Fx<R, E, K>,
-      tag: Exclude<N, keyof K>,
-      f: (_: K) => Fx<R2, E2, A>,
-    ) =>
-      new BindFx(self, tag, f).traced(trace),
-)
-
-type MergeObjects<T, U> = {
-  readonly [K in keyof T | keyof U]: K extends keyof T ? T[K] : K extends keyof U ? U[K] : never
-}
-
-export class BindFx<R, E, N extends string, K, R2, E2, A> extends BaseFx<
-  R | R2,
-  E | E2,
-  MergeObjects<K, { readonly [_ in N]: A }>
-> {
-  readonly name = 'Bind'
-
-  constructor(
-    readonly self: Fx<R, E, K>,
-    readonly tag: Exclude<N, keyof K>,
-    readonly f: (_: K) => Fx<R2, E2, A>,
-  ) {
-    super()
-  }
-
-  run(
-    sink: Sink<E | E2, MergeObjects<K, { readonly [_ in N]: A }>>,
-  ): Effect.Effect<R | R2 | Scope.Scope, never, unknown> {
-    return flatMap(this.self, (k) => map(this.f(k), (a) => ({ ...k, [this.tag]: a } as any))).run(
-      sink,
-    )
-  }
-}

package/src/internal/do/bindValue.ts

@@ -1,50 +0,0 @@
-import { dualWithTrace } from '@effect/data/Debug'
-
-import { Effect, Scope } from '../externals.js'
-
-import { BaseFx } from '@typed/fx/internal/BaseFx'
-import type { Fx, Sink } from '@typed/fx/internal/Fx'
-import { map } from '@typed/fx/internal/operator/map'
-
-export const bindValue: {
-  <R, E, N extends string, K, A>(self: Fx<R, E, K>, tag: Exclude<N, keyof K>, f: (_: K) => A): Fx<
-    R,
-    E,
-    MergeObjects<K, { readonly [_ in N]: A }>
-  >
-
-  <N extends string, K, A>(tag: Exclude<N, keyof K>, f: (_: K) => A): <R, E>(
-    self: Fx<R, E, K>,
-  ) => Fx<R, E, MergeObjects<K, { readonly [_ in N]: A }>>
-} = dualWithTrace(
-  3,
-  (trace) =>
-    <R, E, N extends string, K, A>(self: Fx<R, E, K>, tag: Exclude<N, keyof K>, f: (_: K) => A) =>
-      new BindValueFx(self, tag, f).traced(trace),
-)
-
-type MergeObjects<T, U> = {
-  readonly [K in keyof T | keyof U]: K extends keyof T ? T[K] : K extends keyof U ? U[K] : never
-}
-
-export class BindValueFx<R, E, N extends string, K, A> extends BaseFx<
-  R,
-  E,
-  MergeObjects<K, { readonly [_ in N]: A }>
-> {
-  readonly name = 'Bind'
-
-  constructor(
-    readonly self: Fx<R, E, K>,
-    readonly tag: Exclude<N, keyof K>,
-    readonly f: (_: K) => A,
-  ) {
-    super()
-  }
-
-  run(
-    sink: Sink<E, MergeObjects<K, { readonly [_ in N]: A }>>,
-  ): Effect.Effect<R | Scope.Scope, never, unknown> {
-    return map(this.self, (k) => ({ ...k, [this.tag]: this.f(k) } as any)).run(sink)
-  }
-}

package/src/internal/do/index.ts

@@ -1,3 +0,0 @@
-export * from './bind.js'
-export * from './bindValue.js'
-export * from './Do.js'

package/src/internal/error/absolve.ts

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

package/src/internal/error/absolveWith.ts

@@ -1,34 +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, Either, Scope, flow } from '@typed/fx/internal/externals'
-
-export const absolveWith: {
-  <R, E, A, E2, B>(fx: Fx<R, E, A>, f: (e: A) => Either.Either<E2, B>): Fx<R, E | E2, B>
-  <A, E2, B>(f: (e: A) => Either.Either<E2, B>): <R, E>(fx: Fx<R, E, A>) => Fx<R, E | E2, B>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <R, E, A, E2, B>(fx: Fx<R, E, A>, f: (e: A) => Either.Either<E2, B>) =>
-      new AbsolveWithFx(fx, f).traced(trace),
-)
-
-export class AbsolveWithFx<R, E, A, E2, B> extends BaseFx<R, E | E2, B> {
-  readonly name = 'AbsolveWith' as const
-
-  constructor(readonly fx: Fx<R, E, A>, readonly f: (e: A) => Either.Either<E2, B>) {
-    super()
-  }
-
-  run(sink: Sink<E | E2, B>): Effect.Effect<R | Scope.Scope, never, unknown> {
-    return this.fx.run(
-      Sink(
-        (a) => Either.match(this.f(a), flow(Cause.fail, sink.error), sink.event),
-        sink.error,
-        sink.end,
-      ),
-    )
-  }
-}

package/src/internal/error/absorb.ts

@@ -1,6 +0,0 @@
-import { identity } from '@effect/data/Function'
-
-import type { Fx } from '@typed/fx/internal/Fx'
-import { absorbWith } from '@typed/fx/internal/error/absorbWith'
-
-export const absorb: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, unknown, A> = absorbWith(identity)

package/src/internal/error/absorbWith.ts

@@ -1,36 +0,0 @@
-import { dualWithTrace } 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 absorbWith: {
-  <R, E, A>(fx: Fx<R, E, A>, f: (e: E) => unknown): Fx<R, unknown, A>
-  <E>(f: (e: E) => unknown): <R, A>(fx: Fx<R, E, A>) => Fx<R, unknown, A>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <R, E, A>(fx: Fx<R, E, A>, f: (e: E) => unknown): Fx<R, unknown, A> =>
-      new AbsorbWithFx(fx, f).traced(trace),
-)
-
-export class AbsorbWithFx<R, E, A> extends BaseFx<R, unknown, A> {
-  readonly name = 'AbsorbWith'
-
-  constructor(readonly fx: Fx<R, E, A>, readonly f: (e: E) => unknown) {
-    super()
-  }
-
-  run(sink: Sink<unknown, A>): Effect.Effect<R | Scope.Scope, never, unknown> {
-    return this.fx.run(
-      Sink(
-        sink.event,
-        (cause) => sink.error(Cause.fail(Cause.squashWith(cause, this.f))),
-        sink.end,
-      ),
-    )
-  }
-}