@typed/fx 1.6.2 → 1.8.0

package/src/internal/operator/tapCause.ts

@@ -1,50 +0,0 @@
-import { dualWithTrace } from '@effect/data/Debug'
-import type { Scope } from '@effect/io/Scope'
-
-import { BaseFx } from '@typed/fx/internal/BaseFx'
-import type { Fx } from '@typed/fx/internal/Fx'
-import { Sink } from '@typed/fx/internal/Fx'
-import type { Context } from '@typed/fx/internal/externals'
-import { Cause, Effect, pipe } from '@typed/fx/internal/externals'
-
-export const tapCause: {
-  <R, E, A, R2, E2, B>(
-    self: Fx<R, E, A>,
-    f: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, B>,
-  ): Fx<R | R2, E | E2, A>
-
-  <E, R2, E2, B>(f: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, B>): <R, A>(
-    self: Fx<R, E, A>,
-  ) => Fx<R | R2, E | E2, A>
-} = dualWithTrace(2, (trace) => (self, f) => new TapCauseFx(self, f).traced(trace))
-
-export class TapCauseFx<R, E, A, R2, E2, B> extends BaseFx<R | R2, E | E2, A> {
-  readonly name = 'TapCause' as const
-
-  constructor(
-    readonly self: Fx<R, E, A>,
-    readonly f: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, B>,
-  ) {
-    super()
-  }
-
-  run(sink: Sink<E | E2, A>): Effect.Effect<R | R2 | Scope, never, unknown> {
-    return Effect.contextWithEffect((ctx: Context.Context<R | R2 | Scope>) =>
-      this.self.run(
-        Sink(
-          sink.event,
-          (cause) =>
-            pipe(
-              this.f(cause),
-              Effect.matchCauseEffect(
-                (cause2) => sink.error(Cause.sequential(cause, cause2)),
-                () => sink.error(cause),
-              ),
-              Effect.provideContext(ctx),
-            ),
-          sink.end,
-        ),
-      ),
-    )
-  }
-}

package/src/internal/operator/tapDefect.ts

@@ -1,19 +0,0 @@
-import { pipe } from '@effect/data/Function'
-
-import type { Fx } from '@typed/fx/internal/Fx'
-import { Cause, Chunk, Effect, Option } from '@typed/fx/internal/externals'
-import { tapCause } from '@typed/fx/internal/operator/tapCause'
-
-export function tapDefect<R2, E2, B>(f: (defect: unknown) => Effect.Effect<R2, E2, B>) {
-  return <R, E, A>(fx: Fx<R, E, A>): Fx<R | R2, E | E2, A | B> =>
-    pipe(
-      fx,
-      tapCause(
-        (cause): Effect.Effect<R2, E | E2, B> =>
-          pipe(
-            Chunk.get(Cause.defects(cause), 0),
-            Option.match(() => Effect.failCause(cause), f),
-          ),
-      ),
-    )
-}

package/src/internal/operator/tapEither.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 } from '@typed/fx/internal/externals'
-import { Effect, Either } from '@typed/fx/internal/externals'
-
-export const tapEither: {
-  <A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>): <R, E, E3>(
-    self: Fx<R, E, Either.Either<E3, A>>,
-  ) => Fx<R | R2, E | E3, Either.Either<E3, A>>
-
-  <R, E, E2, A, R2, E3, B>(
-    self: Fx<R, E, Either.Either<E2, A>>,
-    f: (a: A) => Effect.Effect<R2, E3, B>,
-  ): Fx<R | R2, E | E3, Either.Either<E2, A>>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <R, E, E2, A, R2, E3, B>(
-      self: Fx<R, E, Either.Either<E2, A>>,
-      f: (a: A) => Effect.Effect<R2, E3, B>,
-    ) =>
-      new TapEitherFx(self, f).traced(trace),
-)
-
-export const tapEitherSync: {
-  <A, B>(f: (a: A) => B): <R, E, E2>(
-    self: Fx<R, E, Either.Either<E2, A>>,
-  ) => Fx<R, E, Either.Either<E2, A>>
-  <R, E, E2, A, B>(self: Fx<R, E, Either.Either<E2, A>>, f: (a: A) => B): Fx<
-    R,
-    E,
-    Either.Either<E2, A>
-  >
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <R, E, E2, A, B>(self: Fx<R, E, Either.Either<E2, A>>, f: (a: A) => B) =>
-      new TapEitherFx(self, (a) => Effect.sync(() => f(a))).traced(trace),
-)
-
-class TapEitherFx<R, E, E2, A, R2, E3, B> extends BaseFx<R | R2, E | E3, Either.Either<E2, A>> {
-  readonly name = 'TapEither' as const
-
-  constructor(
-    readonly self: Fx<R, E, Either.Either<E2, A>>,
-    readonly f: (a: A) => Effect.Effect<R2, E3, B>,
-  ) {
-    super()
-  }
-
-  run(sink: Sink<E | E3, Either.Either<E2, A>>) {
-    return Effect.contextWithEffect((ctx: Context.Context<R | R2>) =>
-      this.self.run(
-        Sink(
-          (either) => {
-            if (Either.isRight(either)) {
-              return Effect.provideContext(
-                Effect.matchCauseEffect(this.f(either.right), sink.error, () => sink.event(either)),
-                ctx,
-              )
-            } else {
-              return sink.event(either)
-            }
-          },
-          sink.error,
-          sink.end,
-        ),
-      ),
-    )
-  }
-}

package/src/internal/operator/tapError.ts

@@ -1,31 +0,0 @@
-import { dualWithTrace } from '@effect/data/Debug'
-import { pipe } from '@effect/data/Function'
-
-import type { Fx } from '@typed/fx/internal/Fx'
-import { Cause, Effect, Either } from '@typed/fx/internal/externals'
-import { tapCause } from '@typed/fx/internal/operator/tapCause'
-
-export const tapError: {
-  <E, R2, E2, B>(f: (error: E) => Effect.Effect<R2, E2, B>): <R, A>(
-    self: Fx<R, E, A>,
-  ) => Fx<R | R2, E | E2, A>
-
-  <R, E, A, R2, E2, B>(self: Fx<R, E, A>, f: (error: E) => Effect.Effect<R2, E2, B>): Fx<
-    R | R2,
-    E | E2,
-    A
-  >
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <R, E, A, R2, E2, B>(self: Fx<R, E, A>, f: (error: E) => Effect.Effect<R2, E2, B>) =>
-      tapCause(
-        self,
-        (cause): Effect.Effect<R2, E | E2, B> =>
-          pipe(
-            cause,
-            Cause.failureOrCause,
-            Either.match(f, () => Effect.failCause(cause)),
-          ),
-      ).traced(trace),
-)

package/src/internal/operator/tapSome.ts

@@ -1,76 +0,0 @@
-import type { Context } from '@effect/data/Context'
-import { dualWithTrace } 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 { Sink } from '@typed/fx/internal/Fx'
-import type { Fx } from '@typed/fx/internal/Fx'
-import { Option } from '@typed/fx/internal/externals'
-
-export const tapSome: {
-  <A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>): <R, E>(
-    fx: Fx<R, E, Option.Option<A>>,
-  ) => Fx<R | R2, E | E2, A>
-  <R, E, A, R2, E2, B>(fx: Fx<R, E, Option.Option<A>>, f: (a: A) => Effect.Effect<R2, E2, B>): Fx<
-    R | R2,
-    E | E2,
-    A
-  >
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <R, E, A, R2, E2, B>(fx: Fx<R, E, Option.Option<A>>, f: (a: A) => Effect.Effect<R2, E2, B>) =>
-      TapSomeFx.make(fx, f).traced(trace),
-)
-
-export const tapSomeSync: {
-  <R, E, A, B>(fx: Fx<R, E, Option.Option<A>>, f: (a: A) => B): Fx<R, E, Option.Option<A>>
-  <A, B>(f: (a: A) => B): <R, E>(fx: Fx<R, E, Option.Option<A>>) => Fx<R, E, Option.Option<A>>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <R, E, A, B>(fx: Fx<R, E, Option.Option<A>>, f: (a: A) => B) =>
-      TapSomeFx.make(fx, (a) => Effect.sync(() => f(a))).traced(trace),
-)
-
-class TapSomeFx<R, E, A, R2, E2, B> extends BaseFx<R | R2, E | E2, Option.Option<A>> {
-  readonly name = 'TapSome' as const
-
-  constructor(
-    readonly fx: Fx<R, E, Option.Option<A>>,
-    readonly f: (a: A) => Effect.Effect<R2, E2, B>,
-  ) {
-    super()
-  }
-
-  run(sink: Sink<E | E2, Option.Option<A>>): Effect.Effect<R | R2 | Scope, never, unknown> {
-    return Effect.contextWithEffect((context: Context<R | R2 | Scope>) =>
-      this.fx.run(
-        Sink(
-          (a) =>
-            pipe(
-              a,
-              Option.match(
-                () => sink.event(a),
-                (a) =>
-                  pipe(
-                    Effect.as(this.f(a), Option.some(a)),
-                    Effect.matchCauseEffect(sink.error, sink.event),
-                    Effect.provideContext(context),
-                  ),
-              ),
-            ),
-          sink.error,
-          sink.end,
-        ),
-      ),
-    )
-  }
-
-  static make = <R, E, A, R2, E2, B>(
-    fx: Fx<R, E, Option.Option<A>>,
-    f: (a: A) => Effect.Effect<R2, E2, B>,
-  ) => new TapSomeFx(fx, f)
-}

package/src/internal/operator/throttle.ts

@@ -1,37 +0,0 @@
-import type { Fx } from '@typed/fx/internal/Fx'
-import { suspend } from '@typed/fx/internal/constructor/suspend'
-import { Effect, pipe } from '@typed/fx/internal/externals'
-import type { Duration, Fiber } from '@typed/fx/internal/externals'
-import { filterEffect } from '@typed/fx/internal/operator/filterMapEffect'
-
-export function throttle<R, E, A>(self: Fx<R, E, A>, duration: Duration.Duration): Fx<R, E, A> {
-  return suspend(() => {
-    let scheduledFiber: Fiber.RuntimeFiber<never, unknown> | undefined
-
-    const shouldThrottle = Effect.gen(function* ($) {
-      if (scheduledFiber) {
-        return false
-      }
-
-      scheduledFiber = yield* $(
-        pipe(
-          Effect.unit(),
-          Effect.delay(duration),
-          Effect.tap(() =>
-            Effect.sync(() => {
-              scheduledFiber = undefined
-            }),
-          ),
-          Effect.forkScoped,
-        ),
-      )
-
-      return true
-    })
-
-    return pipe(
-      self,
-      filterEffect(() => shouldThrottle),
-    )
-  })
-}

package/src/internal/operator/traced.ts

@@ -1,9 +0,0 @@
-import type { Trace } from '@effect/data/Debug'
-import { dual } from '@effect/data/Function'
-
-import type { Fx } from '@typed/fx/internal/Fx'
-
-export const traced: {
-  <R, E, A>(fx: Fx<R, E, A>, trace: Trace): Fx<R, E, A>
-  (trace: Trace): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
-} = dual(2, <R, E, A>(fx: Fx<R, E, A>, trace: Trace): Fx<R, E, A> => fx.traced(trace))

package/src/internal/operator/unrefineWith.ts

@@ -1,66 +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 { Option, Scope } from '@typed/fx/internal/externals'
-import { Effect, identity, pipe } from '@typed/fx/internal/externals'
-
-export const unrefineWith: {
-  <E2, E, E3>(f: (defect: unknown) => Option.Option<E2>, g: (e: E) => E3): <R, A>(
-    self: Fx<R, E, A>,
-  ) => Fx<R, E2 | E3, A>
-  <R, E, A, E2, E3>(
-    self: Fx<R, E, A>,
-    f: (defect: unknown) => Option.Option<E2>,
-    g: (e: E) => E3,
-  ): Fx<R, E2 | E3, A>
-} = dualWithTrace(
-  3,
-  (trace) =>
-    function unrefineWith<R, E, A, E2, E3>(
-      self: Fx<R, E, A>,
-      f: (defect: unknown) => Option.Option<E2>,
-      g: (e: E) => E3,
-    ): Fx<R, E2 | E3, A> {
-      return new UnrefineWithFx(self, f, g).traced(trace)
-    },
-)
-
-export const unrefine: {
-  <E2, E>(f: (defect: unknown) => Option.Option<E2>): <R, A>(self: Fx<R, E, A>) => Fx<R, E | E2, A>
-
-  <R, E, A, E2>(self: Fx<R, E, A>, f: (defect: unknown) => Option.Option<E2>): Fx<R, E | E2, A>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <R, E, A, E2>(self: Fx<R, E, A>, f: (defect: unknown) => Option.Option<E2>) =>
-      unrefineWith(self, f, identity).traced(trace),
-)
-
-class UnrefineWithFx<R, E, A, E2, E3> extends BaseFx<R, E2 | E3, A> {
-  readonly name = 'UnrefineWith'
-
-  constructor(
-    readonly self: Fx<R, E, A>,
-    readonly f: (defect: unknown) => Option.Option<E2>,
-    readonly g: (e: E) => E3,
-  ) {
-    super()
-  }
-
-  run(sink: Sink<E2 | E3, A>): Effect.Effect<R | Scope.Scope, never, unknown> {
-    return this.self.run(
-      Sink(
-        sink.event,
-        (cause) =>
-          pipe(
-            Effect.failCause(cause),
-            Effect.unrefineWith(this.f, this.g),
-            Effect.catchAllCause(sink.error),
-          ),
-        sink.end,
-      ),
-    )
-  }
-}

package/src/internal/operator/unsandbox.ts

@@ -1,30 +0,0 @@
-import { methodWithTrace } 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, Either, pipe, Scope } from '@typed/fx/internal/externals'
-
-export const unsandbox: <R, E, A>(fx: Fx<R, Cause.Cause<E>, A>) => Fx<R, E, A> = methodWithTrace(
-  (trace) =>
-    <R, E, A>(fx: Fx<R, Cause.Cause<E>, A>) =>
-      new UnsandboxFx(fx).traced(trace),
-)
-
-export class UnsandboxFx<R, E, A> extends BaseFx<R, E, A> {
-  readonly name = 'Unsandbox'
-
-  constructor(readonly fx: Fx<R, Cause.Cause<E>, A>) {
-    super()
-  }
-
-  run(sink: Sink<E, A>): Effect.Effect<R | Scope.Scope, never, unknown> {
-    return this.fx.run(
-      Sink(
-        sink.event,
-        (cause) => pipe(cause, Cause.failureOrCause, Either.match(sink.error, sink.error)),
-        sink.end,
-      ),
-    )
-  }
-}

package/src/internal/operator/zipItems.ts

@@ -1,70 +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, Scope } from '@typed/fx/internal/externals'
-
-export const zipItemsWith: {
-  <R, E, A, B, C>(self: Fx<R, E, A>, items: Iterable<B>, f: (a: A, b: B) => C): Fx<R, E, C>
-  <A, B, C>(items: Iterable<B>, f: (a: A, b: B) => C): <R, E>(self: Fx<R, E, A>) => Fx<R, E, C>
-} = dualWithTrace(
-  3,
-  (trace) =>
-    <R, E, A, B, C>(self: Fx<R, E, A>, items: Iterable<B>, f: (a: A, b: B) => C) =>
-      new ZipItemsWithFx(self, items, f).traced(trace),
-)
-
-export const zipItems: {
-  <R, E, A, B>(self: Fx<R, E, A>, items: Iterable<B>): Fx<R, E, readonly [A, B]>
-  <B>(items: Iterable<B>): <R, E, A>(self: Fx<R, E, A>) => Fx<R, E, readonly [A, B]>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <R, E, A, B>(self: Fx<R, E, A>, items: Iterable<B>) =>
-      zipItemsWith(self, items, (a, b) => [a, b] as const).traced(trace),
-)
-
-export const withItems: {
-  <R, E, A, B>(self: Fx<R, E, A>, items: Iterable<B>): Fx<R, E, B>
-  <B>(items: Iterable<B>): <R, E, A>(self: Fx<R, E, A>) => Fx<R, E, B>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <R, E, A, B>(self: Fx<R, E, A>, items: Iterable<B>) =>
-      zipItemsWith(self, items, (_, b) => b).traced(trace),
-)
-
-export class ZipItemsWithFx<R, E, A, B, C> extends BaseFx<R, E, C> {
-  readonly name = 'ZipItemsWith' as const
-
-  constructor(
-    readonly self: Fx<R, E, A>,
-    readonly items: Iterable<B>,
-    readonly f: (a: A, b: B) => C,
-  ) {
-    super()
-  }
-
-  run(sink: Sink<E, C>): Effect.Effect<R | Scope.Scope, never, unknown> {
-    return Effect.suspend(() => {
-      const iterator = this.items[Symbol.iterator]()
-
-      return this.self.run(
-        Sink(
-          (a) => {
-            const next = iterator.next()
-
-            if (next.done) {
-              return sink.end()
-            }
-
-            return sink.event(this.f(a, next.value))
-          },
-          sink.error,
-          sink.end,
-        ),
-      )
-    })
-  }
-}

package/src/internal/run/drain.ts

@@ -1,8 +0,0 @@
-import * as Effect from '@effect/io/Effect'
-
-import type { Fx } from '@typed/fx/internal/Fx'
-import { observe } from '@typed/fx/internal/run/observe'
-
-export const drain: <R, E, A>(fx: Fx<R, E, A>) => Effect.Effect<R, E, void> = observe(
-  Effect.unit,
-) as <R, E, A>(fx: Fx<R, E, A>) => Effect.Effect<R, E, void>

package/src/internal/run/effect.ts

@@ -1,27 +0,0 @@
-import { methodWithTrace } from '@effect/data/Debug'
-import * as Effect from '@effect/io/Effect'
-
-import { drain } from './drain.js'
-
-import { Fx } from '@typed/fx/internal/Fx'
-import { Scope } from '@typed/fx/internal/externals'
-
-export const forkDaemon: <R, E, A>(fx: Fx<R, E, A>) => Effect.Effect<R, E, unknown> =
-  methodWithTrace(
-    (trace) =>
-      <R, E, A>(fx: Fx<R, E, A>): Effect.Effect<R, E, unknown> =>
-        Effect.forkDaemon(drain(fx)).traced(trace),
-  )
-
-export const forkScoped: <R, E, A>(fx: Fx<R, E, A>) => Effect.Effect<R | Scope.Scope, E, unknown> =
-  methodWithTrace(
-    (trace) =>
-      <R, E, A>(fx: Fx<R, E, A>): Effect.Effect<R | Scope.Scope, E, unknown> =>
-        Effect.forkScoped(drain(fx)).traced(trace),
-  )
-
-export const fork: <R, E, A>(fx: Fx<R, E, A>) => Effect.Effect<R, E, unknown> = methodWithTrace(
-  (trace) =>
-    <R, E, A>(fx: Fx<R, E, A>): Effect.Effect<R, E, unknown> =>
-      Effect.fork(drain(fx)).traced(trace),
-)

package/src/internal/run/index.ts

@@ -1,7 +0,0 @@
-export * from './drain.js'
-export * from './effect.js'
-export * from './observe.js'
-export * from './reduce.js'
-export * from './reduceEffect.js'
-export * from './toChunk.js'
-export * from './toReadonlyArray.js'

package/src/internal/run/observe.ts

@@ -1,55 +0,0 @@
-import { dualWithTrace } from '@effect/data/Debug'
-import { pipe } from '@effect/data/Function'
-import type { Cause } from '@effect/io/Cause'
-import { isInterruptedOnly } from '@effect/io/Cause'
-import * as Deferred from '@effect/io/Deferred'
-import * as Effect from '@effect/io/Effect'
-import type { Scope } from '@effect/io/Scope'
-
-import type { Fx } from '@typed/fx/internal/Fx'
-import { Sink } from '@typed/fx/internal/Fx'
-
-export const observe: {
-  <R, E, A, R2, E2>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, unknown>): Effect.Effect<
-    R | R2,
-    E | E2,
-    void
-  >
-  <A, R2, E2>(f: (a: A) => Effect.Effect<R2, E2, unknown>): <R, E>(
-    fx: Fx<R, E, A>,
-  ) => Effect.Effect<R | R2, E | E2, void>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <R, E, A, R2, E2>(
-      fx: Fx<R, E, A>,
-      f: (a: A) => Effect.Effect<R2, E2, unknown>,
-    ): Effect.Effect<R | R2, E | E2, void> =>
-      Effect.scoped(observe_(fx, f)).traced(trace),
-)
-
-const observe_ = <R, E, A, R2, E2>(
-  fx: Fx<R, E, A>,
-  f: (a: A) => Effect.Effect<R2, E2, unknown>,
-): Effect.Effect<R | R2 | Scope, E | E2, void> =>
-  Effect.gen(function* ($) {
-    const context = yield* $(Effect.context<R | R2 | Scope>())
-    const deferred = yield* $(Deferred.make<E | E2, void>())
-    const end = Deferred.succeed(deferred, undefined)
-    const error = (cause: Cause<E | E2>) =>
-      isInterruptedOnly(cause) ? end : Deferred.failCause(deferred, cause)
-
-    yield* $(
-      Effect.forkScoped(
-        fx.run(
-          Sink(
-            (a) => pipe(a, f, Effect.catchAllCause(error), Effect.provideContext(context)),
-            error,
-            () => end,
-          ),
-        ),
-      ),
-    )
-
-    return yield* $(Deferred.await(deferred))
-  })

package/src/internal/run/reduce.ts

@@ -1,20 +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 reduce: {
-  <R, E, A, B>(fx: Fx<R, E, A>, seed: B, f: (acc: B, a: A) => B): Effect.Effect<R, E, B>
-  <B, A>(seed: B, f: (acc: B, a: A) => B): <R, E>(fx: Fx<R, E, A>) => Effect.Effect<R, E, B>
-} = dualWithTrace(
-  3,
-  (trace) =>
-    <R, E, A, B>(fx: Fx<R, E, A>, seed: B, f: (acc: B, a: A) => B) =>
-      Effect.gen(function* ($) {
-        let acc = seed
-
-        yield* $(fx.observe((a) => Effect.sync(() => (acc = f(acc, a)))))
-
-        return acc
-      }).traced(trace),
-)

package/src/internal/run/reduceEffect.ts

@@ -1,29 +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 reduceEffect: {
-  <R, E, A, B, R2, E2>(
-    fx: Fx<R, E, A>,
-    seed: B,
-    f: (acc: B, a: A) => Effect.Effect<R2, E2, B>,
-  ): Effect.Effect<R | R2, E | E2, B>
-  <B, A, R2, E2>(seed: B, f: (acc: B, a: A) => Effect.Effect<R2, E2, B>): <R, E>(
-    fx: Fx<R, E, A>,
-  ) => Effect.Effect<R | R2, E | E2, B>
-} = dualWithTrace(
-  3,
-  (trace) =>
-    <R, E, A, B, R2, E2>(fx: Fx<R, E, A>, seed: B, f: (acc: B, a: A) => Effect.Effect<R2, E2, B>) =>
-      Effect.gen(function* ($) {
-        const lock = Effect.unsafeMakeSemaphore(1).withPermits(1)
-        let acc = seed
-
-        yield* $(
-          fx.observe((a) => lock(Effect.tap(f(acc, a), (b) => Effect.sync(() => (acc = b))))),
-        )
-
-        return acc
-      }).traced(trace),
-)

package/src/internal/run/toChunk.ts

@@ -1,13 +0,0 @@
-import { methodWithTrace } from '@effect/data/Debug'
-import type * as Effect from '@effect/io/Effect'
-
-import type { Fx } from '@typed/fx/internal/Fx'
-import { Chunk } from '@typed/fx/internal/externals'
-import { reduce } from '@typed/fx/internal/run/reduce'
-
-export const toChunk: <R, E, A>(fx: Fx<R, E, A>) => Effect.Effect<R, E, Chunk.Chunk<A>> =
-  methodWithTrace(
-    (trace) =>
-      <R, E, A>(fx: Fx<R, E, A>): Effect.Effect<R, E, Chunk.Chunk<A>> =>
-        reduce(fx, Chunk.empty<A>(), Chunk.append<A, A>).traced(trace),
-  )

package/src/internal/run/toReadonlyArray.ts

@@ -1,19 +0,0 @@
-import { methodWithTrace } from '@effect/data/Debug'
-import type * as Effect from '@effect/io/Effect'
-
-import type { Fx } from '@typed/fx/internal/Fx'
-import { reduce } from '@typed/fx/internal/run/reduce'
-
-export const toReadonlyArray: <R, E, A>(fx: Fx<R, E, A>) => Effect.Effect<R, E, ReadonlyArray<A>> =
-  methodWithTrace(
-    (trace) =>
-      <R, E, A>(fx: Fx<R, E, A>): Effect.Effect<R, E, ReadonlyArray<A>> =>
-        reduce(fx, [] as Array<A>, (xs, x) => {
-          xs.push(x)
-          return xs
-        }).traced(trace),
-  )
-
-export const toArray = toReadonlyArray as <R, E, A>(
-  fx: Fx<R, E, A>,
-) => Effect.Effect<R, E, Array<A>>

package/src/internal/slicing/index.ts

@@ -1,10 +0,0 @@
-export * from './since.js'
-export * from './skip.js'
-export * from './skipAfter.js'
-export * from './skipUntil.js'
-export * from './skipWhile.js'
-export * from './slice.js'
-export * from './take.js'
-export * from './takeUntil.js'
-export * from './takeWhile.js'
-export * from './until.js'