@typed/fx 1.6.2 → 1.8.0

package/src/internal/error/orElseSucceed.ts

@@ -1,29 +0,0 @@
-import { dualWithTrace } from '@effect/data/Debug'
-
-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 orElseSucceed: {
-  <R, E, A, A2>(fx: Fx<R, E, A>, orFail: () => A2): Fx<R, E, A | A2>
-  <A2>(orFail: () => A2): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A | A2>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <R, E, A, A2>(fx: Fx<R, E, A>, orSucceed: () => A2) =>
-      new OrElseSucceedFx(fx, orSucceed).traced(trace),
-)
-
-export class OrElseSucceedFx<R, E, A, A2> extends BaseFx<R, E, A | A2> {
-  readonly name = 'OrElseSucceed' as const
-
-  constructor(readonly fx: Fx<R, E, A>, readonly orSucceed: () => A2) {
-    super()
-  }
-
-  run(sink: Sink<E, A | A2>): Effect.Effect<R | Scope.Scope, never, unknown> {
-    return this.fx.run(Sink(sink.event, () => sink.event(this.orSucceed()), sink.end))
-  }
-}

package/src/internal/error/tryOrElse.ts

@@ -1,59 +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 tryOrElse: {
-  <R, E, A, R2, E2, B, R3, E3, C>(
-    self: Fx<R, E, A>,
-    onFail: () => Fx<R2, E2, B>,
-    onSuccess: (a: A) => Fx<R3, E3, C>,
-  ): Fx<R | R2 | R3, E | E2 | E3, B | C>
-
-  <R2, E2, B, A, R3, E3, C>(onFail: () => Fx<R2, E2, B>, onSuccess: (a: A) => Fx<R3, E3, C>): <
-    R,
-    E,
-  >(
-    self: Fx<R, E, A>,
-  ) => Fx<R | R2 | R3, E | E2 | E3, B | C>
-} = dualWithTrace(
-  3,
-  (trace) =>
-    <R, E, A, R2, E2, B, R3, E3, C>(
-      self: Fx<R, E, A>,
-      onFail: () => Fx<R2, E2, B>,
-      onSuccess: (a: A) => Fx<R3, E3, C>,
-    ) =>
-      new TryOrElseFx(self, onFail, onSuccess).traced(trace),
-)
-
-export class TryOrElseFx<R, E, A, R2, E2, B, R3, E3, C> extends BaseFx<
-  R | R2 | R3,
-  E | E2 | E3,
-  B | C
-> {
-  readonly name = 'TryOrElse' as const
-
-  constructor(
-    readonly self: Fx<R, E, A>,
-    readonly onFail: () => Fx<R2, E2, B>,
-    readonly onSuccess: (a: A) => Fx<R3, E3, C>,
-  ) {
-    super()
-  }
-
-  run(sink: Sink<E | E2 | E3, B | C>) {
-    return Effect.contextWithEffect((ctx: Context.Context<R | R2 | R3 | Scope.Scope>) =>
-      this.self.run(
-        Sink(
-          (a) => Effect.provideContext(this.onSuccess(a).run(sink), ctx),
-          () => Effect.provideContext(this.onFail().run(sink), ctx),
-          sink.end,
-        ),
-      ),
-    )
-  }
-}

package/src/internal/getters/index.ts

@@ -1,6 +0,0 @@
-export * from './left.js'
-export * from './right.js'
-export * from './some.js'
-export * from './unleft.js'
-export * from './unright.js'
-export * from './unsome.js'

package/src/internal/getters/left.ts

@@ -1,35 +0,0 @@
-import { BaseFx } from '@typed/fx/internal/BaseFx'
-import { Sink } from '@typed/fx/internal/Fx'
-import type { Fx } from '@typed/fx/internal/Fx'
-import { Cause, Either, Effect, Scope, pipe } from '@typed/fx/internal/externals'
-
-export function left<R, E, A, B>(
-  self: Fx<R, E, Either.Either<A, B>>,
-): Fx<R, Either.Either<E, B>, A> {
-  return new LeftFx(self)
-}
-
-export default class LeftFx<R, E, A, B> extends BaseFx<R, Either.Either<E, B>, A> {
-  readonly name = 'Left'
-
-  constructor(readonly self: Fx<R, E, Either.Either<A, B>>) {
-    super()
-  }
-
-  run(sink: Sink<Either.Either<E, B>, A>): Effect.Effect<R | Scope.Scope, never, unknown> {
-    return this.self.run(
-      Sink(
-        (e) =>
-          pipe(
-            e,
-            Either.match(
-              (b) => sink.event(b),
-              (a) => sink.error(Cause.fail(Either.right(a))),
-            ),
-          ),
-        (cause) => sink.error(Cause.map(cause, Either.left)),
-        sink.end,
-      ),
-    )
-  }
-}

package/src/internal/getters/right.ts

@@ -1,35 +0,0 @@
-import { BaseFx } from '@typed/fx/internal/BaseFx'
-import { Sink } from '@typed/fx/internal/Fx'
-import type { Fx } from '@typed/fx/internal/Fx'
-import { Cause, Either, pipe, Effect, Scope } from '@typed/fx/internal/externals'
-
-export function right<R, E, A, B>(
-  self: Fx<R, E, Either.Either<A, B>>,
-): Fx<R, Either.Either<A, E>, B> {
-  return new RightFx(self)
-}
-
-export class RightFx<R, E, A, B> extends BaseFx<R, Either.Either<A, E>, B> {
-  readonly name = 'Right'
-
-  constructor(readonly self: Fx<R, E, Either.Either<A, B>>) {
-    super()
-  }
-
-  run(sink: Sink<Either.Either<A, E>, B>): Effect.Effect<R | Scope.Scope, never, unknown> {
-    return this.self.run(
-      Sink(
-        (e) =>
-          pipe(
-            e,
-            Either.match(
-              (a) => sink.error(Cause.fail(Either.left(a))),
-              (b) => sink.event(b),
-            ),
-          ),
-        (cause) => sink.error(Cause.map(cause, Either.right)),
-        () => sink.end(),
-      ),
-    )
-  }
-}

package/src/internal/getters/some.ts

@@ -1,33 +0,0 @@
-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, Option, pipe } from '@typed/fx/internal/externals'
-
-export function some<R, E, A>(self: Fx<R, E, Option.Option<A>>): Fx<R, Option.Option<E>, A> {
-  return new SomeFx(self)
-}
-
-export class SomeFx<R, E, A> extends BaseFx<R, Option.Option<E>, A> {
-  readonly name = 'Some'
-
-  constructor(readonly self: Fx<R, E, Option.Option<A>>) {
-    super()
-  }
-
-  run(sink: Sink<Option.Option<E>, A>): Effect.Effect<R | Scope.Scope, never, unknown> {
-    return this.self.run(
-      Sink(
-        (o) =>
-          pipe(
-            o,
-            Option.match(
-              () => sink.error(Cause.fail(Option.none())),
-              (a) => sink.event(a),
-            ),
-          ),
-        (cause) => sink.error(Cause.map(cause, Option.some)),
-        () => sink.end(),
-      ),
-    )
-  }
-}

package/src/internal/getters/unleft.ts

@@ -1,38 +0,0 @@
-import { BaseFx } from '@typed/fx/internal/BaseFx'
-import { Sink } from '@typed/fx/internal/Fx'
-import type { Fx } from '@typed/fx/internal/Fx'
-import { Cause, Either, Effect, pipe, Scope } from '@typed/fx/internal/externals'
-
-export function unleft<R, E, A, B>(
-  self: Fx<R, Either.Either<E, B>, A>,
-): Fx<R, E, Either.Either<A, B>> {
-  return new UnleftFx(self)
-}
-
-export class UnleftFx<R, E, A, B> extends BaseFx<R, E, Either.Either<A, B>> {
-  readonly name = 'Unleft'
-
-  constructor(readonly self: Fx<R, Either.Either<E, B>, A>) {
-    super()
-  }
-
-  run(sink: Sink<E, Either.Either<A, B>>): Effect.Effect<R | Scope.Scope, never, unknown> {
-    return this.self.run(
-      Sink(
-        (a) => sink.event(Either.left(a)),
-        (cause) =>
-          pipe(
-            Cause.failureOrCause(cause),
-            Either.match(
-              Either.match(
-                (e) => sink.error(Cause.fail(e)),
-                (b) => sink.event(Either.right(b)),
-              ),
-              sink.error,
-            ),
-          ),
-        sink.end,
-      ),
-    )
-  }
-}

package/src/internal/getters/unright.ts

@@ -1,38 +0,0 @@
-import { BaseFx } from '@typed/fx/internal/BaseFx'
-import type { Fx } from '@typed/fx/internal/Fx'
-import { Sink } from '@typed/fx/internal/Fx'
-import { Cause, Either, Effect, pipe, Scope } from '@typed/fx/internal/externals'
-
-export function unright<R, E, A, B>(
-  fx: Fx<R, Either.Either<A, E>, B>,
-): Fx<R, E, Either.Either<A, B>> {
-  return new UnrightFx(fx)
-}
-
-export class UnrightFx<R, E, A, B> extends BaseFx<R, E, Either.Either<A, B>> {
-  readonly name = 'Unright'
-
-  constructor(readonly self: Fx<R, Either.Either<A, E>, B>) {
-    super()
-  }
-
-  run(sink: Sink<E, Either.Either<A, B>>): Effect.Effect<R | Scope.Scope, never, unknown> {
-    return this.self.run(
-      Sink(
-        (b) => sink.event(Either.right(b)),
-        (cause) =>
-          pipe(
-            Cause.failureOrCause(cause),
-            Either.match(
-              Either.match(
-                (a) => sink.event(Either.left(a)),
-                (e) => sink.error(Cause.fail(e)),
-              ),
-              sink.error,
-            ),
-          ),
-        sink.end,
-      ),
-    )
-  }
-}

package/src/internal/getters/unsome.ts

@@ -1,37 +0,0 @@
-import { BaseFx } from '@typed/fx/internal/BaseFx'
-import type { Fx } from '@typed/fx/internal/Fx'
-import { Sink } from '@typed/fx/internal/Fx'
-import { Cause, Either, Effect, Option, Scope, pipe } from '@typed/fx/internal/externals'
-
-export function unsome<R, E, A>(fx: Fx<R, Option.Option<E>, A>): Fx<R, E, Option.Option<A>> {
-  return new UnsomeFx(fx)
-}
-
-export class UnsomeFx<R, E, A> extends BaseFx<R, E, Option.Option<A>> {
-  readonly name = 'Unsome'
-
-  constructor(readonly self: Fx<R, Option.Option<E>, A>) {
-    super()
-  }
-
-  run(sink: Sink<E, Option.Option<A>>): Effect.Effect<R | Scope.Scope, never, unknown> {
-    return this.self.run(
-      Sink(
-        (a) => sink.event(Option.some(a)),
-        (cause) =>
-          pipe(
-            cause,
-            Cause.failureOrCause,
-            Either.match(
-              Option.match(
-                () => sink.event(Option.none()),
-                (e) => sink.error(Cause.fail(e)),
-              ),
-              sink.error,
-            ),
-          ),
-        sink.end,
-      ),
-    )
-  }
-}

package/src/internal/locking/index.ts

@@ -1,2 +0,0 @@
-export * from './withPermit.js'
-export * from './withPermits.js'

package/src/internal/locking/withPermit.ts

@@ -1,15 +0,0 @@
-import { dualWithTrace } from '@effect/data/Debug'
-import type { Semaphore } from '@effect/io/Effect'
-
-import type { Fx } from '@typed/fx/internal/Fx'
-import { WithPermitsFx } from '@typed/fx/internal/locking/withPermits'
-
-export const withPermit: {
-  <R, E, A>(fx: Fx<R, E, A>, semaphore: Semaphore): Fx<R, E, A>
-  (semaphore: Semaphore): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <R, E, A>(fx: Fx<R, E, A>, semaphore: Semaphore): Fx<R, E, A> =>
-      new WithPermitsFx(fx, semaphore, 1).traced(trace),
-)

package/src/internal/locking/withPermits.ts

@@ -1,43 +0,0 @@
-import { dualWithTrace } from '@effect/data/Debug'
-import { pipe } from '@effect/data/Function'
-import type { Semaphore } from '@effect/io/Effect'
-
-import { BaseFx } from '@typed/fx/internal/BaseFx'
-import { Sink } from '@typed/fx/internal/Fx'
-import type { Fx } from '@typed/fx/internal/Fx'
-import { Effect, Scope } from '@typed/fx/internal/externals'
-
-export const withPermits: {
-  <R, E, A>(fx: Fx<R, E, A>, semaphore: Semaphore, permits: number): Fx<R, E, A>
-  (semaphore: Semaphore, permits: number): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
-} = dualWithTrace(
-  3,
-  (trace) =>
-    <R, E, A>(fx: Fx<R, E, A>, semaphore: Semaphore, permits: number): Fx<R, E, A> =>
-      new WithPermitsFx(fx, semaphore, permits).traced(trace),
-)
-
-export class WithPermitsFx<R, E, A> extends BaseFx<R, E, A> {
-  readonly name = `WithPermits(${this.permits})`
-
-  constructor(readonly fx: Fx<R, E, A>, readonly semaphore: Semaphore, readonly permits: number) {
-    super()
-  }
-
-  run(sink: Sink<E, A>): Effect.Effect<R | Scope.Scope, never, unknown> {
-    const andRelease = Effect.zipLeft(this.semaphore.release(this.permits))
-
-    return pipe(
-      this.semaphore.take(this.permits),
-      Effect.flatMap(() =>
-        this.fx.run(
-          Sink(
-            sink.event,
-            (cause) => pipe(sink.error(cause), andRelease),
-            () => pipe(sink.end(), andRelease),
-          ),
-        ),
-      ),
-    )
-  }
-}

package/src/internal/logging/index.ts

@@ -1,22 +0,0 @@
-export * from './log.js'
-export * from './logAnnotate.js'
-export * from './logAnnotations.js'
-export * from './logDebug.js'
-export * from './logDebugCause.js'
-export * from './logDebugCauseMessage.js'
-export * from './logError.js'
-export * from './logErrorCause.js'
-export * from './logErrorCauseMessage.js'
-export * from './logFatal.js'
-export * from './logFatalCause.js'
-export * from './logFatalCauseMessage.js'
-export * from './logInfo.js'
-export * from './logInfoCause.js'
-export * from './logInfoCauseMessage.js'
-export * from './logSpan.js'
-export * from './logTrace.js'
-export * from './logTraceCause.js'
-export * from './logTraceCauseMessage.js'
-export * from './logWarning.js'
-export * from './logWarningCause.js'
-export * from './logWarningCauseMessage.js'

package/src/internal/logging/log.ts

@@ -1,9 +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 { Effect } from '@typed/fx/internal/externals'
-
-export const log: (message: string) => Fx<never, never, void> = methodWithTrace(
-  (trace) => (message: string) => fromEffect(Effect.log(message)).traced(trace),
-)

package/src/internal/logging/logAnnotate.ts

@@ -1,14 +0,0 @@
-import { dualWithTrace } from '@effect/data/Debug'
-
-import type { Fx } from '@typed/fx/internal/Fx'
-import { Effect } from '@typed/fx/internal/externals'
-
-export const logAnnotate: {
-  <R, E, A>(fx: Fx<R, E, A>, k: string, value: string): Fx<R, E, A>
-  (k: string, value: string): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
-} = dualWithTrace(
-  3,
-  (trace) =>
-    <R, E, A>(fx: Fx<R, E, A>, k: string, value: string): Fx<R, E, A> =>
-      fx.transform(Effect.logAnnotate(k, value)).traced(trace),
-)

package/src/internal/logging/logAnnotations.ts

@@ -1,9 +0,0 @@
-import { methodWithTrace } from '@effect/data/Debug'
-import type * as HashMap from '@effect/data/HashMap'
-
-import type { Fx } from '@typed/fx/internal/Fx'
-import { fromEffect } from '@typed/fx/internal/conversion/fromEffect'
-import { Effect } from '@typed/fx/internal/externals'
-
-export const logAnnotations: (_: void) => Fx<never, never, HashMap.HashMap<string, string>> =
-  methodWithTrace((trace) => () => fromEffect(Effect.logAnnotations()).traced(trace))

package/src/internal/logging/logDebug.ts

@@ -1,9 +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 { Effect } from '@typed/fx/internal/externals'
-
-export const logDebug: (message: string) => Fx<never, never, void> = methodWithTrace(
-  (trace) => (message: string) => fromEffect(Effect.logDebug(message)).traced(trace),
-)

package/src/internal/logging/logDebugCause.ts

@@ -1,12 +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 { Cause } from '@typed/fx/internal/externals'
-import { Effect } from '@typed/fx/internal/externals'
-
-export const logDebugCause: <E>(cause: Cause.Cause<E>) => Fx<never, never, void> = methodWithTrace(
-  (trace) =>
-    <E>(cause: Cause.Cause<E>) =>
-      fromEffect(Effect.logDebugCause(cause)).traced(trace),
-)

package/src/internal/logging/logDebugCauseMessage.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 { Cause } from '@typed/fx/internal/externals'
-import { Effect } from '@typed/fx/internal/externals'
-
-export const logDebugCauseMessage: {
-  <E>(message: string, cause: Cause.Cause<E>): Fx<never, never, void>
-  <E>(cause: Cause.Cause<E>): (message: string) => Fx<never, never, void>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <E>(message: string, cause: Cause.Cause<E>) =>
-      fromEffect(Effect.logDebugCauseMessage(message, cause)).traced(trace),
-)

package/src/internal/logging/logError.ts

@@ -1,9 +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 { Effect } from '@typed/fx/internal/externals'
-
-export const logError: (message: string) => Fx<never, never, void> = methodWithTrace(
-  (trace) => (message: string) => fromEffect(Effect.logError(message)).traced(trace),
-)

package/src/internal/logging/logErrorCause.ts

@@ -1,12 +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 { Cause } from '@typed/fx/internal/externals'
-import { Effect } from '@typed/fx/internal/externals'
-
-export const logErrorCause: <E>(cause: Cause.Cause<E>) => Fx<never, never, void> = methodWithTrace(
-  (trace) =>
-    <E>(cause: Cause.Cause<E>) =>
-      fromEffect(Effect.logErrorCause(cause)).traced(trace),
-)

package/src/internal/logging/logErrorCauseMessage.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 { Cause } from '@typed/fx/internal/externals'
-import { Effect } from '@typed/fx/internal/externals'
-
-export const logErrorCauseMessage: {
-  <E>(message: string, cause: Cause.Cause<E>): Fx<never, never, void>
-  <E>(cause: Cause.Cause<E>): (message: string) => Fx<never, never, void>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <E>(message: string, cause: Cause.Cause<E>) =>
-      fromEffect(Effect.logErrorCauseMessage(message, cause)).traced(trace),
-)

package/src/internal/logging/logFatal.ts

@@ -1,9 +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 { Effect } from '@typed/fx/internal/externals'
-
-export const logFatal: (message: string) => Fx<never, never, void> = methodWithTrace(
-  (trace) => (message: string) => fromEffect(Effect.logFatal(message)).traced(trace),
-)

package/src/internal/logging/logFatalCause.ts

@@ -1,12 +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 { Cause } from '@typed/fx/internal/externals'
-import { Effect } from '@typed/fx/internal/externals'
-
-export const logFatalCause: <E>(cause: Cause.Cause<E>) => Fx<never, never, void> = methodWithTrace(
-  (trace) =>
-    <E>(cause: Cause.Cause<E>) =>
-      fromEffect(Effect.logFatalCause(cause)).traced(trace),
-)

package/src/internal/logging/logFatalCauseMessage.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 { Cause } from '@typed/fx/internal/externals'
-import { Effect } from '@typed/fx/internal/externals'
-
-export const logFatalCauseMessage: {
-  <E>(message: string, cause: Cause.Cause<E>): Fx<never, never, void>
-  <E>(cause: Cause.Cause<E>): (message: string) => Fx<never, never, void>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <E>(message: string, cause: Cause.Cause<E>) =>
-      fromEffect(Effect.logFatalCauseMessage(message, cause)).traced(trace),
-)

package/src/internal/logging/logInfo.ts

@@ -1,9 +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 { Effect } from '@typed/fx/internal/externals'
-
-export const logInfo: (message: string) => Fx<never, never, void> = methodWithTrace(
-  (trace) => (message: string) => fromEffect(Effect.logInfo(message)).traced(trace),
-)

package/src/internal/logging/logInfoCause.ts

@@ -1,12 +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 { Cause } from '@typed/fx/internal/externals'
-import { Effect } from '@typed/fx/internal/externals'
-
-export const logInfoCause: <E>(cause: Cause.Cause<E>) => Fx<never, never, void> = methodWithTrace(
-  (trace) =>
-    <E>(cause: Cause.Cause<E>) =>
-      fromEffect(Effect.logInfoCause(cause)).traced(trace),
-)

package/src/internal/logging/logInfoCauseMessage.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 { Cause } from '@typed/fx/internal/externals'
-import { Effect } from '@typed/fx/internal/externals'
-
-export const logInfoCauseMessage: {
-  <E>(message: string, cause: Cause.Cause<E>): Fx<never, never, void>
-  <E>(cause: Cause.Cause<E>): (message: string) => Fx<never, never, void>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <E>(message: string, cause: Cause.Cause<E>) =>
-      fromEffect(Effect.logInfoCauseMessage(message, cause)).traced(trace),
-)

package/src/internal/logging/logSpan.ts

@@ -1,14 +0,0 @@
-import { dualWithTrace } from '@effect/data/Debug'
-
-import type { Fx } from '@typed/fx/internal/Fx'
-import { Effect } from '@typed/fx/internal/externals'
-
-export const logSpan: {
-  <R, E, A>(fx: Fx<R, E, A>, span: string): Fx<R, E, A>
-  (span: string): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <R, E, A>(fx: Fx<R, E, A>, span: string): Fx<R, E, A> =>
-      fx.transform(Effect.logSpan(span)).traced(trace),
-)

package/src/internal/logging/logTrace.ts

@@ -1,9 +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 { Effect } from '@typed/fx/internal/externals'
-
-export const logTrace: (message: string) => Fx<never, never, void> = methodWithTrace(
-  (trace) => (message: string) => fromEffect(Effect.logTrace(message)).traced(trace),
-)

package/src/internal/logging/logTraceCause.ts

@@ -1,12 +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 { Cause } from '@typed/fx/internal/externals'
-import { Effect } from '@typed/fx/internal/externals'
-
-export const logTraceCause: <E>(cause: Cause.Cause<E>) => Fx<never, never, void> = methodWithTrace(
-  (trace) =>
-    <E>(cause: Cause.Cause<E>) =>
-      fromEffect(Effect.logTraceCause(cause)).traced(trace),
-)