@typed/fx 0.0.6 → 0.0.9

package/src/reduce.ts

@@ -0,0 +1,81 @@
+import * as Effect from '@effect/core/io/Effect'
+import { makeRef } from '@effect/core/io/Ref'
+import { pipe } from '@fp-ts/data/Function'
+import * as Maybe from '@tsplus/stdlib/data/Maybe'
+
+import { Fx } from './Fx.js'
+import { Sink } from './Sink.js'
+import { FilterMapFx, MapFx } from './map.js'
+
+export function reduceFilterMap<R, E, A, E1, B>(seed: B, f: (b: B, a: A) => Maybe.Maybe<B>) {
+  return (fx: Fx<R, E, A, E1>): Effect.Effect<R, E1 | E, B> => {
+    return reduceFilterMap_(fx, seed, f)
+  }
+}
+
+export function reduce<B, A>(seed: B, f: (b: B, a: A) => B) {
+  return <R, E, E1>(fx: Fx<R, E, A, E1>): Effect.Effect<R, E | E1, B> => {
+    if (fx instanceof FilterMapFx) {
+      return pipe(
+        fx.fx,
+        reduceFilterMap(seed, (b, a) =>
+          pipe(
+            a,
+            fx.f,
+            Maybe.map((a2) => f(b, a2)),
+          ),
+        ),
+      )
+    }
+
+    if (fx instanceof MapFx) {
+      return pipe(
+        fx.fx,
+        reduce(seed, (b, a) => f(b, fx.f(a))),
+      )
+    }
+
+    return reduce_(fx, seed, f)
+  }
+}
+
+export function collectAll<R, E, A, E1>(
+  fx: Fx<R, E, A, E1>,
+): Effect.Effect<R, E | E1, readonly A[]> {
+  return reduce_(fx, [] as readonly A[], (b, a) => b.concat([a]))
+}
+
+function reduce_<R, E, A, E1, B>(fx: Fx<R, E, A, E1>, seed: B, f: (b: B, a: A) => B) {
+  return pipe(
+    makeRef<B>(() => seed),
+    Effect.flatMap((ref) =>
+      fx.run(Sink((a) => ref.update((b) => f(b, a)), Effect.failCause, ref.get)),
+    ),
+  )
+}
+
+function reduceFilterMap_<R, E, A, E1, B>(
+  fx: Fx<R, E, A, E1>,
+  seed: B,
+  f: (b: B, a: A) => Maybe.Maybe<B>,
+) {
+  return pipe(
+    makeRef<B>(() => seed),
+    Effect.flatMap((ref) =>
+      fx.run(
+        Sink(
+          (a) =>
+            ref.modify((b) => [
+              null,
+              pipe(
+                f(b, a),
+                Maybe.getOrElse(() => b),
+              ),
+            ]),
+          Effect.failCause,
+          ref.get,
+        ),
+      ),
+    ),
+  )
+}

package/src/scheduled.ts

@@ -0,0 +1,77 @@
+import * as Effect from '@effect/core/io/Effect'
+import * as Exit from '@effect/core/io/Exit'
+import * as Schedule from '@effect/core/io/Schedule'
+import { millis } from '@tsplus/stdlib/data/Duration'
+import { isRight } from '@tsplus/stdlib/data/Either'
+
+import { Fx } from './Fx.js'
+import { Sink } from './Sink.js'
+
+/**
+ * Schedules an Effect to run, emitting the result of the Effect to the sink.
+ */
+export function scheduled<S, R2, Out>(schedule: Schedule.Schedule<S, R2, any, Out>) {
+  return <R, E, A>(effect: Effect.Effect<R, E, A>): Fx<R | R2, E, A> =>
+    Fx(<R3, E3, B>(sink: Sink<E, A, R3, E3, B>) =>
+      Effect.gen(function* ($) {
+        const clock = yield* $(Effect.clock)
+
+        let now = yield* $(clock.currentTime)
+        let [s, , decision] = yield* $(schedule.step(now, undefined, schedule.initial))
+
+        while (decision._tag === 'Continue') {
+          yield* $(clock.sleep(millis((Schedule.Intervals.start(decision.intervals) - now) as any)))
+
+          const exit = yield* $(Effect.exit(effect))
+
+          if (Exit.isFailure(exit)) {
+            return yield* $(sink.error(exit.cause))
+          }
+
+          yield* $(sink.event(exit.value))
+
+          now = yield* $(clock.currentTime)
+          const [s2, , decision2] = yield* $(schedule.step(now, exit.value, s))
+
+          s = s2
+          decision = decision2
+        }
+
+        return yield* $(sink.end)
+      }),
+    )
+}
+
+/**
+ * Schedules an Effect to run, emitting the result of the Schedule to the sink.
+ *
+ * TODO: Needs a better name
+ */
+export function scheduledOut<S, R2, A, Out>(schedule: Schedule.Schedule<S, R2, A, Out>) {
+  return <R, E>(effect: Effect.Effect<R, E, A>): Fx<R | R2, E, Out> =>
+    Fx(<R3, E3, B>(sink: Sink<E, Out, R3, E3, B>) =>
+      Effect.gen(function* ($) {
+        const d = yield* $(Schedule.driver(schedule))
+
+        let inputExit = yield* $(Effect.exit(effect))
+
+        if (Exit.isFailure(inputExit)) {
+          return yield* $(sink.error(inputExit.cause))
+        }
+
+        let outputEither = yield* $(Effect.either(d.next(inputExit.value)))
+
+        while (isRight(outputEither)) {
+          inputExit = yield* $(Effect.exit(effect))
+
+          if (Exit.isFailure(inputExit)) {
+            return yield* $(sink.error(inputExit.cause))
+          }
+
+          outputEither = yield* $(Effect.either(d.next(inputExit.value)))
+        }
+
+        return yield* $(sink.end)
+      }),
+    )
+}

package/src/since.ts

@@ -0,0 +1,47 @@
+import * as Effect from '@effect/core/io/Effect'
+import { makeRef } from '@effect/core/io/Ref'
+import { flow, pipe } from '@fp-ts/data/Function'
+
+import { Fx } from './Fx.js'
+import { Sink } from './Sink.js'
+import { refCountDeferred } from './_internal.js'
+
+export function since<R2, E2, B, E3>(signal: Fx<R2, E2, B, E3>) {
+  return <R, E, A, E1>(fx: Fx<R, E, A, E1>): Fx<R | R2, E, A, E1 | E2 | E3> =>
+    Fx(<R4, E4, C>(sink: Sink<E, A, R4, E4, C>) =>
+      Effect.gen(function* ($) {
+        const ref = yield* $(makeRef(() => false))
+        const deferred = yield* $(refCountDeferred<E1 | E2 | E3 | E4, C>(true))
+
+        yield* $(
+          Effect.fork(
+            signal.run(
+              Sink(
+                () => ref.set(true),
+                flow(Effect.failCause, deferred.error),
+                deferred.endIfComplete(sink.end),
+              ),
+            ),
+          ),
+        )
+
+        yield* $(
+          Effect.fork(
+            fx.run(
+              Sink(
+                (a) =>
+                  pipe(
+                    ref.get,
+                    Effect.flatMap((started) => (started ? sink.event(a) : Effect.unit)),
+                  ),
+                flow(sink.error, deferred.error),
+                deferred.endIfComplete(sink.end),
+              ),
+            ),
+          ),
+        )
+
+        return yield* $(deferred.await)
+      }),
+    )
+}

package/src/skipRepeats.ts

@@ -0,0 +1,34 @@
+import * as Effect from '@effect/core/io/Effect'
+import { makeRef } from '@effect/core/io/Ref'
+import { pipe } from '@fp-ts/data/Function'
+import * as Maybe from '@tsplus/stdlib/data/Maybe'
+import { Equivalence } from '@tsplus/stdlib/prelude/Equivalence'
+
+import { Fx } from './Fx.js'
+import { Sink } from './Sink.js'
+
+export function skipRepeats<A>(E: Equivalence<A>) {
+  const equals = Maybe.getEquivalence(E).equals
+
+  return <R, E, E1>(fx: Fx<R, E, A, E1>): Fx<R, E, A, E1> =>
+    Fx((sink) =>
+      pipe(
+        makeRef<Maybe.Maybe<A>>(() => Maybe.none),
+        Effect.flatMap((ref) =>
+          fx.run(
+            Sink(
+              (a) =>
+                Effect.flatten(
+                  ref.modify((m) => [
+                    equals(m, Maybe.some(a)) ? Effect.unit : sink.event(a),
+                    Maybe.some(a),
+                  ]),
+                ),
+              sink.error,
+              sink.end,
+            ),
+          ),
+        ),
+      ),
+    )
+}

package/src/skipWhile.ts

@@ -0,0 +1,31 @@
+import * as Effect from '@effect/core/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+import { Predicate, not } from '@fp-ts/data/Predicate'
+
+import { Fx } from './Fx.js'
+
+export function skipWhile<A>(predicate: Predicate<A>) {
+  return <R, E, E1>(fx: Fx<R, E, A, E1>): Fx<R, E, A, E1> =>
+    Fx((sink) =>
+      Effect.suspendSucceed(() => {
+        let started = false
+
+        return fx.run({
+          ...sink,
+          event: (a) => {
+            if (!started && predicate(a)) {
+              return Effect.unit
+            }
+
+            started = true
+
+            return sink.event(a)
+          },
+        })
+      }),
+    )
+}
+
+export function skipUntil<A>(predicate: Predicate<A>) {
+  return <R, E, E1>(fx: Fx<R, E, A, E1>): Fx<R, E, A, E1> => pipe(fx, skipWhile(not(predicate)))
+}

package/src/slice.test.ts

@@ -0,0 +1,19 @@
+import { deepStrictEqual } from 'assert'
+
+import { unsafeRunPromise } from '@effect/core/io/Effect'
+
+import { from } from './from.js'
+import { collectAll } from './reduce.js'
+import { slice } from './slice.js'
+
+describe(import.meta.url, () => {
+  describe('slice', () => {
+    it('skips and takes a set amount of values', async () => {
+      const values = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+      const test = collectAll(slice(2, 4)(from(values)))
+      const events = await unsafeRunPromise(test)
+
+      deepStrictEqual(events, [3, 4, 5, 6])
+    })
+  })
+})

package/src/slice.ts

@@ -0,0 +1,53 @@
+import * as Effect from '@effect/core/io/Effect'
+import * as Exit from '@effect/core/io/Exit'
+import { pipe } from '@fp-ts/data/Function'
+
+import { Fx } from './Fx.js'
+import { Sink } from './Sink.js'
+import { deferredCallback } from './_internal.js'
+
+export function slice(skip: number, take: number) {
+  return <R, E, A, E1>(fx: Fx<R, E, A, E1>): Fx<R, E, A, E1> =>
+    Fx(<R2, E2, B>(sink: Sink<E, A, R2, E2, B>) =>
+      deferredCallback<E1 | E2, B, R | R2, E1 | E2>((cb) => {
+        let toSkip = skip
+        let toTake = take
+
+        return fx.run({
+          ...sink,
+          event: (a) => {
+            if (toSkip > 0) {
+              toSkip -= 1
+              return Effect.unit
+            }
+
+            if (toTake === 0) {
+              return Effect.unit
+            }
+
+            toTake -= 1
+
+            return pipe(
+              sink.event(a),
+              Effect.flatMap(() =>
+                toTake === 0
+                  ? pipe(
+                      sink.end,
+                      Effect.tap((b) => cb(Exit.succeed(b))),
+                    )
+                  : Effect.unit,
+              ),
+            )
+          },
+        })
+      }),
+    )
+}
+
+export function skip(skip: number) {
+  return slice(skip, Infinity)
+}
+
+export function take(take: number) {
+  return slice(0, take)
+}

package/src/snapshot.ts

@@ -0,0 +1,47 @@
+import * as Effect from '@effect/core/io/Effect'
+import * as Ref from '@effect/core/io/Ref'
+import { flow, pipe } from '@fp-ts/data/Function'
+import * as Maybe from '@tsplus/stdlib/data/Maybe'
+
+import { Fx } from './Fx.js'
+import { Sink } from './Sink.js'
+
+export function snapshot<R2, E2, B, E3, A, C>(sampled: Fx<R2, E2, B, E3>, f: (a: A, b: B) => C) {
+  return <R, E, E1>(sampler: Fx<R, E, A, E1>): Fx<R | R2, E | E2, C, E1 | E3> =>
+    Fx((sink) =>
+      Effect.gen(function* ($) {
+        const ref = yield* $(Ref.makeRef<Maybe.Maybe<B>>(() => Maybe.none))
+
+        yield* $(
+          Effect.fork(sampled.run(Sink(flow(Maybe.some, ref.set), Effect.failCause, Effect.unit))),
+        )
+
+        return yield* $(
+          sampler.run(
+            Sink(
+              (a) =>
+                pipe(
+                  ref.get,
+                  Effect.flatMap(
+                    Maybe.fold(
+                      () => Effect.unit,
+                      (b) => sink.event(f(a, b)),
+                    ),
+                  ),
+                ),
+              sink.error,
+              sink.end,
+            ),
+          ),
+        )
+      }),
+    )
+}
+
+export function sample<R2, E2, B, E3>(sampled: Fx<R2, E2, B, E3>) {
+  return <R, E, A, E1>(sampler: Fx<R, E, A, E1>): Fx<R | R2, E | E2, B, E1 | E3> =>
+    pipe(
+      sampler,
+      snapshot(sampled, (_, b) => b),
+    )
+}

package/src/suspendSucceed.ts

@@ -0,0 +1,7 @@
+import * as Effect from '@effect/core/io/Effect'
+
+import { Fx } from './Fx.js'
+
+export function suspendSucceed<R, E, A, E1>(f: () => Fx<R, E, A, E1>): Fx<R, E, A, E1> {
+  return Fx((sink) => Effect.suspendSucceed(() => f().run(sink)))
+}

package/src/switchMap.test.ts

@@ -0,0 +1,25 @@
+import { deepStrictEqual } from 'assert'
+
+import { unsafeRunPromise } from '@effect/core/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+import * as Duration from '@tsplus/stdlib/data/Duration'
+
+import { delay } from './delay.js'
+import { from } from './from.js'
+import { collectAll } from './reduce.js'
+import { switchMap } from './switchMap.js'
+
+describe(import.meta.url, () => {
+  describe('switchMap', () => {
+    it('chains the latest inner fx', async () => {
+      const values = [1, 2, 3]
+      const test = pipe(
+        from(values),
+        switchMap((x) => delay(Duration.millis(100))(from([x + 1, x + 2]))),
+      )
+      const events = await pipe(test, collectAll, unsafeRunPromise)
+
+      deepStrictEqual(events, [4, 5])
+    })
+  })
+})

package/src/switchMap.ts

@@ -0,0 +1,64 @@
+import * as Effect from '@effect/core/io/Effect'
+import { Fiber, interrupt } from '@effect/core/io/Fiber'
+import { makeSynchronized } from '@effect/core/io/Ref'
+import { flow, pipe } from '@fp-ts/data/Function'
+
+import { Fx } from './Fx.js'
+import { Sink } from './Sink.js'
+import { refCountDeferred } from './_internal.js'
+
+export function switchMap<A, R2, E2, B, E3>(f: (a: A) => Fx<R2, E2, B, E3>) {
+  return <R, E, E1>(self: Fx<R, E, A, E1>): Fx<R | R2, E | E2, B, E1 | E3> =>
+    new SwitchMapFx(self, f)
+}
+
+export class SwitchMapFx<R, E, A, E1, R2, E2, B, E3> implements Fx<R2 | R, E | E2, B, E1 | E3> {
+  constructor(readonly self: Fx<R, E, A, E1>, readonly f: (a: A) => Fx<R2, E2, B, E3>) {}
+
+  run<R3, E4, C>(sink: Sink<E | E2, B, R3, E4, C>): Effect.Effect<R2 | R | R3, E1 | E3 | E4, C> {
+    const { self, f } = this
+
+    return pipe(
+      refCountDeferred<E1 | E3 | E4, C>(),
+      Effect.map((deferred) => ({ deferred } as const)),
+      Effect.bind('ref', () => makeSynchronized<Fiber<E1 | E3 | E4, any> | null>(() => null)),
+      Effect.flatMap(({ deferred, ref }) =>
+        self.run(
+          Sink(
+            (a) =>
+              ref.updateEffect((current) =>
+                pipe(
+                  current ? interrupt(current) : Effect.unit,
+                  Effect.zipRight(deferred.increment),
+                  Effect.zipRight(
+                    pipe(
+                      f(a).run(
+                        Sink(
+                          sink.event,
+                          flow(sink.error, deferred.error),
+                          pipe(
+                            deferred.decrement,
+                            Effect.flatMap(() => deferred.endIfComplete(sink.end)),
+                          ),
+                        ),
+                      ),
+                      Effect.onInterrupt(() => deferred.decrement),
+                      Effect.fork,
+                    ),
+                  ),
+                ),
+              ),
+            flow(sink.error, deferred.error, Effect.zipRight(deferred.await)),
+            Effect.suspendSucceed(() =>
+              pipe(
+                deferred.end,
+                Effect.flatMap(() => deferred.endIfComplete(sink.end)),
+                Effect.zipRight(deferred.await),
+              ),
+            ),
+          ),
+        ),
+      ),
+    )
+  }
+}

package/src/takeUntil.ts

@@ -0,0 +1,29 @@
+import * as Effect from '@effect/core/io/Effect'
+import * as Exit from '@effect/core/io/Exit'
+import { pipe } from '@fp-ts/data/Function'
+import { Predicate } from '@fp-ts/data/Predicate'
+
+import { Fx } from './Fx.js'
+import { Sink } from './Sink.js'
+import { deferredCallback } from './_internal.js'
+
+export function takeUntil<A>(predicate: Predicate<A>) {
+  return <R, E, E1>(fx: Fx<R, E, A, E1>): Fx<R, E, A, E1> =>
+    Fx(<R2, E2, B>(sink: Sink<E, A, R2, E2, B>) =>
+      deferredCallback<E1 | E2, B, R | R2, E1 | E2>((cb) => {
+        return fx.run({
+          ...sink,
+          event: (a) => {
+            if (!predicate(a)) {
+              return sink.event(a)
+            }
+
+            return pipe(
+              sink.end,
+              Effect.tap((b) => cb(Exit.succeed(b))),
+            )
+          },
+        })
+      }),
+    )
+}

package/src/takeWhile.ts

@@ -0,0 +1,33 @@
+import * as Effect from '@effect/core/io/Effect'
+import * as Exit from '@effect/core/io/Exit'
+import { pipe } from '@fp-ts/data/Function'
+import { Predicate, not } from '@fp-ts/data/Predicate'
+
+import { Fx } from './Fx.js'
+import { Sink } from './Sink.js'
+import { deferredCallback } from './_internal.js'
+
+export function takeWhile<A>(predicate: Predicate<A>) {
+  return <R, E, E1>(fx: Fx<R, E, A, E1>): Fx<R, E, A, E1> =>
+    Fx(<R2, E2, B>(sink: Sink<E, A, R2, E2, B>) =>
+      deferredCallback<E1 | E2, B, R | R2, E1 | E2>((cb) => {
+        return fx.run({
+          ...sink,
+          event: (a) => {
+            if (predicate(a)) {
+              return sink.event(a)
+            }
+
+            return pipe(
+              sink.end,
+              Effect.tap((b) => cb(Exit.succeed(b))),
+            )
+          },
+        })
+      }),
+    )
+}
+
+export function takeUntil<A>(predicate: Predicate<A>) {
+  return <R, E, E1>(fx: Fx<R, E, A, E1>): Fx<R, E, A, E1> => pipe(fx, takeWhile(not(predicate)))
+}

package/src/tap.ts

@@ -0,0 +1,48 @@
+import * as Cause from '@effect/core/io/Cause'
+import * as Effect from '@effect/core/io/Effect'
+import { flow, pipe } from '@fp-ts/data/Function'
+import * as Either from '@tsplus/stdlib/data/Either'
+
+import { Fx } from './Fx.js'
+import { Sink } from './Sink.js'
+import { map } from './map.js'
+
+export function tap<A, B>(f: (a: A) => B) {
+  return map((a: A) => (f(a), a))
+}
+
+export function tapEffect<A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>) {
+  return <R, E, E1>(fx: Fx<R, E, A, E1>): Fx<R | R2, E | E2, A, E1 | E2> =>
+    Fx((sink) =>
+      fx.run(Sink((a) => pipe(a, f, Effect.zipRight(sink.event(a))), sink.error, sink.end)),
+    )
+}
+
+export function tapCauseEffect<E, R2, E2, B>(f: (e: Cause.Cause<E>) => Effect.Effect<R2, E2, B>) {
+  return <R, A, E1>(fx: Fx<R, E, A, E1>): Fx<R | R2, E | E2, A, E1 | E2> =>
+    Fx((sink) =>
+      fx.run(Sink(sink.event, (e) => pipe(e, f, Effect.zipRight(sink.error(e))), sink.end)),
+    )
+}
+
+export function tapErrorEffect<E, R2, E2, B>(f: (e: E) => Effect.Effect<R2, E2, B>) {
+  return <R, A, E1>(fx: Fx<R, E, A, E1>): Fx<R | R2, E | E2, A, E1 | E2> =>
+    Fx((sink) =>
+      fx.run(
+        Sink(
+          sink.event,
+          (e) =>
+            pipe(
+              Cause.failureOrCause(e),
+              Either.fold(flow(f, Effect.zipRight(sink.error(e))), sink.error),
+            ),
+          sink.end,
+        ),
+      ),
+    )
+}
+
+export function tapEndEffect<R2, E2, B>(effect: Effect.Effect<R2, E2, B>) {
+  return <R, E, A, E1>(fx: Fx<R, E, A, E1>): Fx<R | R2, E | E2, A, E1 | E2> =>
+    Fx((sink) => fx.run(Sink(sink.event, sink.error, Effect.zipRight(sink.end)(effect))))
+}

package/src/throttle.test.ts

@@ -0,0 +1,19 @@
+import { deepStrictEqual } from 'assert'
+
+import { unsafeRunPromise } from '@effect/core/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+import { millis } from '@tsplus/stdlib/data/Duration'
+
+import { from } from './from.js'
+import { collectAll } from './reduce.js'
+import { throttle } from './throttle.js'
+
+describe(import.meta.url, () => {
+  describe('throttle', () => {
+    it('favors the first overlapping event', async () => {
+      const test = pipe(from([1, 2, 3]), throttle(millis(100)), collectAll)
+
+      deepStrictEqual(await unsafeRunPromise(test), [1])
+    })
+  })
+})

package/src/throttle.ts

@@ -0,0 +1,58 @@
+import * as Effect from '@effect/core/io/Effect'
+import * as Fiber from '@effect/core/io/Fiber'
+import * as Ref from '@effect/core/io/Ref'
+import * as Schedule from '@effect/core/io/Schedule'
+import { flow, pipe } from '@fp-ts/data/Function'
+import { Duration } from '@tsplus/stdlib/data/Duration'
+
+import { Fx } from './Fx.js'
+import { Sink } from './Sink.js'
+import { refCountDeferred } from './_internal.js'
+
+export function throttle(duration: Duration) {
+  return <R, E, A, E1>(fx: Fx<R, E, A>): Fx<R, E, A, E1> =>
+    Fx(
+      <R2, E2, B>(sink: Sink<E, A, R2, E2, B>): Effect.Effect<R | R2, E1 | E2, B> =>
+        Effect.gen(function* ($) {
+          const ref = yield* $(
+            Ref.makeSynchronized<Fiber.Fiber<unknown, unknown> | null>(() => null),
+          )
+          const deferred = yield* $(refCountDeferred<E1 | E2, B>(true))
+
+          return yield* $(
+            fx.run(
+              Sink<E, A, R | R2, E1 | E2, B>(
+                (a) =>
+                  ref.updateEffect((current) =>
+                    Effect.gen(function* (_) {
+                      if (current) {
+                        return current
+                      }
+
+                      yield* $(deferred.increment)
+
+                      return yield* _(
+                        pipe(
+                          sink.event(a),
+                          Effect.schedule(Schedule.delayed(() => duration)(Schedule.once)),
+                          Effect.tap(() =>
+                            pipe(
+                              ref.set(null),
+                              Effect.zipRight(deferred.decrement),
+                              Effect.zipRight(deferred.endIfComplete(sink.end)),
+                            ),
+                          ),
+                          Effect.uninterruptible,
+                          Effect.fork,
+                        ),
+                      )
+                    }),
+                  ),
+                flow(sink.error, deferred.error, Effect.zipRight(deferred.await)),
+                pipe(sink.end, deferred.endIfComplete, Effect.zipRight(deferred.await)),
+              ),
+            ),
+          )
+        }),
+    )
+}