@typed/fx 1.5.9 → 1.6.2

package/src/internal/context/serviceWithEffect.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/src/internal/error/absolve.ts

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

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

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

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