@typed/fx 1.5.9 → 1.6.2

package/src/internal/operator/tapCause.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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