@typed/fx 0.0.8 → 0.0.9

package/src/continueWith.ts

@@ -0,0 +1,23 @@
+import * as Effect from '@effect/core/io/Effect'
+
+import { Fx } from './Fx.js'
+import { Sink } from './Sink.js'
+import { succeed } from './fromEffect.js'
+
+export function continueWith<R2, E2, B, E3>(continueWith: () => Fx<R2, E2, B, E3>) {
+  return <R, E, A, E1>(fx: Fx<R, E, A, E1>): Fx<R | R2, E | E2, A | B, E1 | E3> =>
+    Fx((sink) =>
+      fx.run(
+        Sink(
+          sink.event,
+          sink.error,
+          Effect.suspendSucceed(() => continueWith().run(sink)),
+        ),
+      ),
+    )
+}
+
+export function startWith<B>(value: B) {
+  return <R, E, A, E1>(fx: Fx<R, E, A, E1>): Fx<R, E, A | B, E1> =>
+    continueWith(() => fx)(succeed(value))
+}

package/src/debounce.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 { debounce } from './debounce.js'
+import { from } from './from.js'
+import { collectAll } from './reduce.js'
+
+describe(import.meta.url, () => {
+  describe('debounce', () => {
+    it('favors the latest overlapping event', async () => {
+      const test = pipe(from([1, 2, 3]), debounce(millis(100)), collectAll)
+
+      deepStrictEqual(await unsafeRunPromise(test), [3])
+    })
+  })
+})

package/src/debounce.ts

@@ -0,0 +1,68 @@
+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 debounce(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((previous) =>
+                    Effect.gen(function* (_) {
+                      if (previous) {
+                        yield* _(Fiber.interrupt(previous))
+                      } else {
+                        yield* $(deferred.increment)
+                      }
+
+                      return yield* _(
+                        pipe(
+                          sink.event(a),
+                          Effect.schedule(Schedule.delayed(() => duration)(Schedule.once)),
+                          Effect.interruptible,
+                          Effect.tap(() =>
+                            pipe(
+                              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)),
+              ),
+            ),
+          )
+        }),
+    )
+}
+
+/**
+ *     pipe(
+        Ref.makeSynchronized<Fiber.Fiber<unknown, unknown> | null>(() => null),
+        Effect.flatMap((ref) =>
+          ,
+        ),
+        Effect.scoped,
+      ),
+ */

package/src/delay.test.ts

@@ -0,0 +1,25 @@
+import { deepStrictEqual, ok } 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 { at } from './delay.js'
+import { collectAll } from './reduce.js'
+
+describe(import.meta.url, () => {
+  describe('delay', () => {
+    it('adds a delay to an event', async () => {
+      const value = Math.random()
+      const delayMs = 100
+      const test = at(Duration.millis(delayMs))(value)
+      const start = performance.now()
+      const events = await pipe(test, collectAll, unsafeRunPromise)
+      const end = performance.now()
+
+      ok(end - start >= delayMs)
+
+      deepStrictEqual(events, [value])
+    })
+  })
+})

package/src/delay.ts

@@ -0,0 +1,16 @@
+import * as Effect from '@effect/core/io/Effect'
+import { flow } from '@fp-ts/data/Function'
+import * as Duration from '@tsplus/stdlib/data/Duration'
+
+import { Fx } from './Fx.js'
+import { Sink } from './Sink.js'
+import { fromEffect } from './fromEffect.js'
+
+export function delay(delayDuration: Duration.Duration) {
+  return <R, E, A, E1>(fx: Fx<R, E, A, E1>): Fx<R, E, A, E1> =>
+    Fx((sink) => fx.run(Sink(flow(sink.event, Effect.delay(delayDuration)), sink.error, sink.end)))
+}
+
+export function at(delayDuration: Duration.Duration) {
+  return <A>(value: A) => fromEffect(Effect.delay(delayDuration)(Effect.succeed(value)))
+}

package/src/drain.ts

@@ -0,0 +1,21 @@
+import * as Effect from '@effect/core/io/Effect'
+import { Fiber } from '@effect/core/io/Fiber'
+
+import { Fx } from './Fx.js'
+import { Sink } from './Sink.js'
+
+export function drainNow<R, E, A, E1>(fx: Fx<R, E, A, E1>): Effect.Effect<R, E | E1, void> {
+  return fx.run(Sink(Effect.succeed, Effect.failCause, Effect.unit))
+}
+
+export function drain<R, E, A, E1>(
+  fx: Fx<R, E, A, E1>,
+): Effect.Effect<R, never, Fiber.Runtime<E | E1, void>> {
+  return Effect.fork(drainNow(fx))
+}
+
+export function drainDaemon<R, E, A, E1>(
+  fx: Fx<R, E, A, E1>,
+): Effect.Effect<R, never, Fiber.Runtime<E | E1, void>> {
+  return Effect.forkDaemon(drainNow(fx))
+}

package/src/during.ts

@@ -0,0 +1,58 @@
+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 during<R2, E2, R3, E3, B, E4, E5>(signal: Fx<R2, E2, Fx<R3, E3, B, E4>, E5>) {
+  return <R, E, A, E1>(fx: Fx<R, E, A, E1>): Fx<R | R2 | R3, E, A, E1 | E2 | E3 | E4 | E5> =>
+    Fx(<R6, E6, C>(sink: Sink<E, A, R6, E6, C>) =>
+      Effect.gen(function* ($) {
+        const ref = yield* $(makeRef(() => false))
+        const deferred = yield* $(refCountDeferred<E1 | E2 | E3 | E4 | E5 | E6, C>(true))
+
+        yield* $(
+          Effect.fork(
+            signal.run(
+              Sink(
+                (endSignal) =>
+                  pipe(
+                    ref.set(true),
+                    Effect.zipRight(
+                      endSignal.run(
+                        Sink(
+                          () => deferred.endIfComplete(sink.end),
+                          flow(Effect.failCause, deferred.error),
+                          deferred.endIfComplete(sink.end),
+                        ),
+                      ),
+                    ),
+                  ),
+                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/empty.ts

@@ -0,0 +1,5 @@
+import { Fx } from './Fx.js'
+
+export function empty<A>(): Fx<unknown, never, A, never> {
+  return Fx((sink) => sink.end)
+}

package/src/flatMap.test.ts

@@ -0,0 +1,23 @@
+import { deepStrictEqual } from 'assert'
+
+import { unsafeRunPromise } from '@effect/core/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+
+import { flatMap } from './flatMap.js'
+import { from } from './from.js'
+import { collectAll } from './reduce.js'
+
+describe(import.meta.url, () => {
+  describe('flatMap', () => {
+    it('chains fx together', async () => {
+      const values = [1, 2, 3]
+      const test = pipe(
+        from(values),
+        flatMap((x) => from([x + 1, x + 2])),
+      )
+      const events = await pipe(test, collectAll, unsafeRunPromise)
+
+      deepStrictEqual(events, [2, 3, 3, 4, 4, 5])
+    })
+  })
+})

package/src/flatMap.ts

@@ -0,0 +1,66 @@
+import * as Effect from '@effect/core/io/Effect'
+import { flow, pipe } from '@fp-ts/data/Function'
+
+import { Fx } from './Fx.js'
+import { Sink } from './Sink.js'
+import { refCountDeferred } from './_internal.js'
+import { MapFx } from './map.js'
+
+export function flatMap<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 FlatMapFx(self, f)
+}
+
+export class FlatMapFx<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.flatMap((deferred) =>
+        self.run(
+          Sink(
+            (a) =>
+              pipe(
+                deferred.increment, // Increment ref count
+                Effect.zipRight(
+                  Effect.fork(
+                    f(a).run(
+                      Sink(
+                        sink.event,
+                        flow(sink.error, deferred.error),
+                        pipe(
+                          deferred.decrement, // Decrement ref count
+                          Effect.flatMap(() => deferred.endIfComplete(sink.end)),
+                        ),
+                      ),
+                    ),
+                  ),
+                ),
+              ),
+            flow(sink.error, deferred.error, Effect.zipRight(deferred.await)),
+            Effect.suspendSucceed(() =>
+              pipe(
+                deferred.end, // Track that the "outer" stream has completed
+                Effect.flatMap(() => deferred.endIfComplete(sink.end)),
+                Effect.zipRight(deferred.await),
+              ),
+            ),
+          ),
+        ),
+      ),
+    )
+  }
+
+  static make<R, E, A, E1, R2, E2, B, E3>(
+    fx: Fx<R, E, A, E1>,
+    f: (a: A) => Fx<R2, E2, B, E3>,
+  ): Fx<R | R2, E | E2, B, E1 | E3> {
+    if (fx instanceof MapFx) {
+      return new FlatMapFx(fx.fx, flow(fx.f, f))
+    }
+
+    return new FlatMapFx(fx, f)
+  }
+}

package/src/flatMapConcurrently.ts

@@ -0,0 +1,22 @@
+import * as TSemaphore from '@effect/core/stm/TSemaphore'
+import { flow, pipe } from '@fp-ts/data/Function'
+
+import { Fx } from './Fx.js'
+import { withPermit } from './TSemaphore.js'
+import { flatMap } from './flatMap.js'
+import { suspendSucceed } from './suspendSucceed.js'
+
+export function flatMapConcurrently<A, R2, E2, B, E3>(
+  concurrency: number,
+  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> =>
+    suspendSucceed(() =>
+      pipe(self, flatMap(flow(f, withPermit(TSemaphore.unsafeMake(concurrency))))),
+    )
+}
+
+export function concatMap<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> =>
+    pipe(self, flatMapConcurrently(1, f))
+}

package/src/from.test.ts

@@ -0,0 +1,18 @@
+import { deepStrictEqual } from 'assert'
+
+import { unsafeRunPromise } from '@effect/core/io/Effect'
+
+import { from } from './from.js'
+import { collectAll } from './reduce.js'
+
+describe(import.meta.url, () => {
+  describe('from', () => {
+    it('converts a collection into a fx', async () => {
+      const values = [1, 2, 3]
+      const test = collectAll(from(values))
+      const events = await unsafeRunPromise(test)
+
+      deepStrictEqual(events, values)
+    })
+  })
+})

package/src/from.ts

@@ -0,0 +1,18 @@
+import * as Effect from '@effect/core/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+import { Collection } from '@tsplus/stdlib/collections/Collection'
+
+import { Fx } from './Fx.js'
+import { Sink } from './Sink.js'
+
+export function from<A>(collection: Collection<A>): Fx<never, never, A> {
+  return new FromCollectionFx(collection)
+}
+
+export class FromCollectionFx<A> implements Fx<never, never, A> {
+  constructor(readonly collection: Collection<A>) {}
+
+  run<R2, E2, B>(sink: Sink<never, A, R2, E2, B>): Effect.Effect<R2, E2, B> {
+    return pipe(Effect.forEachDiscard(this.collection, sink.event), Effect.zipRight(sink.end))
+  }
+}

package/src/fromCallback.ts

@@ -0,0 +1,40 @@
+import { Cause } from '@effect/core/io/Cause'
+import * as Effect from '@effect/core/io/Effect'
+import * as Exit from '@effect/core/io/Exit'
+import { unsafeForkUnstarted } from '@effect/core/io/Fiber/_internal/runtime'
+import { flow } from '@fp-ts/data/Function'
+
+import { Fx } from './Fx.js'
+import { Sink } from './Sink.js'
+
+export function make<R, E, A>(
+  f: (sink: {
+    readonly event: (a: A) => void
+    readonly error: (cause: Cause<E>) => void
+    readonly end: () => void
+  }) => Effect.Canceler<R>,
+): Fx<R, E, A> {
+  return Fx<R, E, A>(<R2, E2, B>(sink: Sink<E, A, R2, E2, B>) =>
+    Effect.withFiberRuntime<R | R2, E2, B>((fiber, status) => {
+      const unsafeRun = <R, E, A>(
+        eff: Effect.Effect<R, E, A>,
+        observer: (exit: Exit.Exit<E, A>) => void,
+      ) => {
+        const f = unsafeForkUnstarted(eff, fiber, status.runtimeFlags)
+        f.addObserver(observer)
+        f.start(eff)
+      }
+
+      return Effect.asyncEffect((cb) =>
+        f({
+          event: (a) =>
+            unsafeRun(sink.event(a), (exit) =>
+              Exit.isFailure(exit) ? cb(Effect.failCause(exit.cause)) : undefined,
+            ),
+          error: (e) => unsafeRun(sink.error(e), flow(Effect.done, cb)),
+          end: () => unsafeRun(sink.end, flow(Effect.done, cb)),
+        }),
+      )
+    }),
+  )
+}

package/src/fromEffect.ts

@@ -0,0 +1,64 @@
+import * as Cause from '@effect/core/io/Cause'
+import * as Effect from '@effect/core/io/Effect'
+import { Exit } from '@effect/core/io/Exit'
+import { LazyArg, flow, pipe } from '@fp-ts/data/Function'
+import { Either } from '@tsplus/stdlib/data/Either'
+import { Maybe } from '@tsplus/stdlib/data/Maybe'
+
+import { Fx } from './Fx.js'
+import { Sink } from './Sink.js'
+
+export function fromEffect<R, E, A>(effect: Effect.Effect<R, E, A>): Fx<R, E, A> {
+  return new FromEffectFx(effect)
+}
+
+export class FromEffectFx<R, E, A> implements Fx<R, E, A> {
+  constructor(readonly effect: Effect.Effect<R, E, A>) {}
+
+  run<R2, E2, B>(sink: Sink<E, A, R2, E2, B>): Effect.Effect<R | R2, E2, B> {
+    return pipe(
+      this.effect,
+      Effect.foldCauseEffect(sink.error, flow(sink.event, Effect.zipRight(sink.end))),
+    )
+  }
+}
+
+export const succeed = flow(Effect.succeed, fromEffect)
+
+export const fail = flow(Effect.fail, fromEffect)
+export const die = flow(Effect.die, fromEffect)
+export const dieMessage = flow(Effect.dieMessage, fromEffect)
+export const dieSync: <A>(f: LazyArg<A>) => Fx<never, never, never> = flow(
+  Effect.dieSync,
+  fromEffect,
+)
+
+export const failCause: <E>(cause: Cause.Cause<E>) => Fx<never, E, never, never> = flow(
+  Effect.failCause,
+  fromEffect,
+)
+
+export const fromEither: <E, A>(either: Either<E, A>) => Fx<never, E, A> = flow(
+  Effect.fromEither,
+  fromEffect,
+)
+
+export const done: <E, A>(exit: Exit<E, A>) => Fx<never, E, A> = flow(Effect.done, fromEffect)
+
+export const async = flow(Effect.async, fromEffect)
+
+export const asyncEffect = flow(Effect.asyncEffect, fromEffect)
+
+export const asyncInterrupt: <R, E, A>(
+  register: (
+    callback: (_: Effect.Effect<R, E, A>) => void,
+  ) => Either<Effect.Effect<R, never, void>, Effect.Effect<R, E, A>>,
+) => Fx<R, E, A> = flow(Effect.asyncInterrupt, fromEffect)
+
+export const asyncMaybe: <R, E, A>(
+  register: (callback: (_: Effect.Effect<R, E, A>) => void) => Maybe<Effect.Effect<R, E, A>>,
+) => Fx<R, E, A> = flow(Effect.asyncMaybe, fromEffect)
+
+export const suspendSucceedEffect: <R, E, A>(
+  effect: LazyArg<Effect.Effect<R, E, A>>,
+) => Fx<R, E, A> = flow(Effect.suspendSucceed, fromEffect)

package/src/hold.test.ts

@@ -0,0 +1,49 @@
+import { deepStrictEqual } from 'assert'
+
+import * as Effect from '@effect/core/io/Effect'
+import * as Fiber from '@effect/core/io/Fiber'
+import { pipe } from '@fp-ts/data/Function'
+import * as Duration from '@tsplus/stdlib/data/Duration'
+
+import * as Fx from './index.js'
+
+describe(import.meta.url, () => {
+  describe('hold', () => {
+    it('emits values to late observers', async () => {
+      const value = Math.random()
+
+      let started = 0
+      const fx = pipe(
+        Fx.fromEffect(Effect.sync(() => started++)),
+        Fx.flatMap(() =>
+          Fx.mergeAll([
+            Fx.at(Duration.millis(0))(value),
+            Fx.at(Duration.millis(100))(value + 1),
+            Fx.at(Duration.millis(200))(value + 2),
+          ]),
+        ),
+        Fx.hold,
+      )
+
+      const test = Effect.gen(function* ($) {
+        const a = yield* $(Effect.fork(Fx.collectAll(fx)))
+
+        yield* $(Effect.sleep(Duration.millis(50)))
+
+        const b = yield* $(Effect.fork(Fx.collectAll(fx)))
+
+        yield* $(Effect.sleep(Duration.millis(100)))
+
+        const c = yield* $(Effect.fork(Fx.collectAll(fx)))
+
+        deepStrictEqual(yield* $(Fiber.join(a)), [value, value + 1, value + 2])
+        deepStrictEqual(yield* $(Fiber.join(b)), [value, value + 1, value + 2])
+        deepStrictEqual(yield* $(Fiber.join(c)), [value + 1, value + 2])
+
+        deepStrictEqual(started, 1)
+      })
+
+      await Effect.unsafeRunPromise(test)
+    })
+  })
+})

package/src/hold.ts

@@ -0,0 +1,130 @@
+import { Cause } from '@effect/core/io/Cause'
+import { Deferred } from '@effect/core/io/Deferred'
+import * as Effect from '@effect/core/io/Effect'
+import * as Fiber from '@effect/core/io/Fiber'
+import * as FiberId from '@effect/core/io/FiberId'
+import { pipe } from '@fp-ts/data/Function'
+import * as Maybe from '@tsplus/stdlib/data/Maybe'
+import { Env } from '@tsplus/stdlib/service/Env'
+
+import { Fx } from './Fx.js'
+import { Sink } from './Sink.js'
+import { asap } from './_internal.js'
+import { Multicast } from './multicast.js'
+
+export function hold<R, E, A, E1>(fx: Fx<R, E, A, E1>): Fx<R, E, A, E1> {
+  return new Hold(fx)
+}
+
+export class Hold<R, E, E1, A> extends Multicast<R, E, A, E1> {
+  protected _value: Maybe.Maybe<A> = Maybe.none
+  protected _pendingSinks: Array<readonly [Sink<E, A, any, any, any>, A[]]> = []
+  protected _scheduledFiber: Fiber.RealFiber<any, any> | undefined
+
+  constructor(readonly fx: Fx<R, E, A, E1>) {
+    super(fx)
+  }
+
+  run<R2, E2, B>(sink: Sink<E, A, R2, E2, B>): Effect.Effect<R | R2, E1 | E2, B> {
+    if (this.shouldScheduleFlush()) {
+      return pipe(
+        this.scheduleFush(sink),
+        Effect.flatMap(() => super.run(sink)),
+      )
+    }
+
+    return super.run(sink)
+  }
+
+  event(value: A) {
+    this.addValue(value)
+
+    return pipe(
+      this.flushPending(),
+      Effect.flatMap(() => super.event(value)),
+    )
+  }
+
+  error(cause: Cause<E>) {
+    return pipe(
+      this.flushPending(),
+      Effect.flatMap(() => super.error(cause)),
+    )
+  }
+
+  get end() {
+    return pipe(
+      this.flushPending(),
+      Effect.flatMap(() => super.end),
+    )
+  }
+
+  protected shouldScheduleFlush() {
+    return Maybe.isSome(this._value) && this.sinks.length > 0
+  }
+
+  protected scheduleFush(sink: Sink<E, A, any, any, any>) {
+    this._pendingSinks.push([
+      sink,
+      pipe(
+        this._value,
+        Maybe.fold(
+          () => [],
+          (a) => [a],
+        ),
+      ),
+    ])
+
+    const interrupt = this._scheduledFiber
+      ? this._scheduledFiber.interruptAsFork(new FiberId.None())
+      : Effect.unit
+
+    this._scheduledFiber = undefined
+
+    return pipe(
+      interrupt,
+      Effect.flatMap(() => this.flushPending()),
+      Effect.schedule(asap),
+      Effect.fork,
+      Effect.tap((fiber: Fiber.RealFiber<any, any>) =>
+        Effect.sync(() => (this._scheduledFiber = fiber)),
+      ),
+    )
+  }
+
+  protected flushPending() {
+    if (this._pendingSinks.length === 0) {
+      return Effect.unit
+    }
+
+    const pendingSinks = this._pendingSinks
+    this._pendingSinks = []
+
+    return Effect.forEachDiscard(pendingSinks, (pending) =>
+      Effect.suspendSucceed(() => {
+        const [sink, values] = pending
+        const observer = this.findSink(sink)
+
+        if (!observer) {
+          return Effect.unit
+        }
+
+        return Effect.forEachDiscard(values, (value) => this.runEvent(value, observer))
+      }),
+    )
+  }
+
+  protected addValue(value: A) {
+    this._value = Maybe.some(value)
+
+    this._pendingSinks.forEach(([, values]) => {
+      values.push(value)
+    })
+  }
+
+  protected findSink(
+    sink: Sink<E, A, any, any, any>,
+  ): readonly [Sink<E, A, any, any, any>, Env<any>, Deferred<any, any>] | undefined {
+    return this.sinks.find(([s]) => s === sink)
+  }
+}