@fncts/io 0.0.49 → 0.0.50

package/_src/Push/definition.ts

@@ -1,53 +1,246 @@
+import type { Sink as Sink_, UnsafeSink, UnsafeSink as UnsafeSink_ } from "./Sink.js";
+import type { FlattenStrategy } from "@fncts/io/Push/FlattenStrategy";
+import type { IOProducer } from "@fncts/io/Push/Producer/IOProducer";
+
+import { type SyncProducer } from "@fncts/io/Push/Producer/SyncProducer";
+
+import { Sink } from "./Sink.js";
+
 export const PushVariance = Symbol.for("fncts.io.Push.Variance");
 export type PushVariance = typeof PushVariance;
 
 export const PushTypeId = Symbol.for("fncts.io.Push");
 export type PushTypeId = typeof PushTypeId;
 
+export const enum PushTag {
+  Defer,
+  ProducerSync,
+  ProducerIO,
+  FailCause,
+  OnSuccess,
+  OnSuccessWithStrategy,
+  OnSuccessAndFailure,
+  External,
+  FromPush,
+  Transform,
+}
+
 /**
  * @tsplus type fncts.io.Push
  * @tsplus companion fncts.io.PushOps
  */
-export class Push<R, E, A> {
-  readonly [PushTypeId]: PushTypeId = PushTypeId;
+export abstract class Push<R, E, A> {
+  readonly [PushTypeId]: PushTypeId    = PushTypeId;
+  readonly _pushOpCode: PushTag | null = null;
+
   declare [PushVariance]: {
     readonly _R: (_: never) => R;
     readonly _E: (_: never) => E;
     readonly _A: (_: never) => A;
   };
-  constructor(readonly run: <R1>(emitter: Sink<R1, E, A>) => IO<R | R1, never, unknown>) {}
+
+  constructor() {
+    this.run = this.run.bind(this);
+  }
+
+  run<R1>(sink: UnsafeSink<R1, E, A>): IO<R | R1, never, void> {
+    return this.unsafeRun(sink);
+  }
 }
 
 export declare namespace Push {
+  export type Run<R, E, A> = <R1>(emitter: UnsafeSink<R1, E, A>) => IO<R | R1, never, unknown>;
   export type EnvironmentOf<X> = [X] extends [{ [PushVariance]: { readonly _R: (_: never) => infer R } }] ? R : never;
   export type ErrorOf<X> = [X] extends [{ [PushVariance]: { readonly _E: (_: never) => infer E } }] ? E : never;
   export type ValueOf<X> = [X] extends [{ [PushVariance]: { readonly _A: (_: never) => infer A } }] ? A : never;
+  export type Sink<Env, R, E, A> = Sink_<Env, R, E, A>;
+  export type UnsafeSink<R, E, A> = UnsafeSink_<R, E, A>;
 }
 
 /**
- * @tsplus type fncts.io.Push.Sink
- * @tsplus companion fncts.io.Push.SinkOps
+ * @tsplus pipeable fncts.io.Push unsafeRun
  */
-export class Sink<R, E, A> {
-  constructor(
-    readonly event: (value: A) => IO<R, never, void>,
-    readonly error: (cause: Cause<E>) => IO<R, never, void>,
-  ) {}
+export function unsafeRun<E, A, R1>(sink: UnsafeSink<R1, E, A>) {
+  return <R>(push: Push<R, E, A>): IO<R | R1, never, void> => unsafeRunPush(push, sink);
 }
 
-/**
- * @tsplus static fncts.io.PushOps __call
- */
-export function makePush<R, E, A>(run: <R1>(sink: Sink<R1, E, A>) => IO<R | R1, never, unknown>): Push<R, E, A> {
-  return new Push(run);
+export type PushOp<Tag extends string | number | null, Body = {}> = Push<never, any, any> &
+  Body & {
+    readonly _pushOpCode: Tag;
+  };
+
+export class PushPrimitive extends Push<never, any, any> {
+  public i0: any                   = undefined;
+  public i1: any                   = undefined;
+  public i2: any                   = undefined;
+  public i3: any                   = undefined;
+  public i4: any                   = undefined;
+  public trace: string | undefined = undefined;
+  constructor(readonly _pushOpCode: PushTag | null) {
+    super();
+  }
 }
 
-/**
- * @tsplus static fncts.io.Push.SinkOps __call
- */
-export function makeSink<R, E, A>(
-  value: (value: A) => IO<R, never, unknown>,
-  error: (cause: Cause<E>) => IO<R, never, unknown>,
-): Sink<R, E, A> {
-  return new Sink(value, error);
+export interface Base<R = never, E = any, A = any>
+  extends PushOp<
+    null,
+    {
+      readonly run: Push.Run<R, E, A>;
+    }
+  > {}
+
+export interface Defer
+  extends PushOp<
+    PushTag.Defer,
+    {
+      readonly i0: () => Primitive;
+    }
+  > {}
+
+export interface FromPush<R = never, E = any, A = any>
+  extends PushOp<
+    PushTag.FromPush,
+    {
+      readonly i0: Push.Run<R, E, A>;
+    }
+  > {}
+
+export interface ProducerSync<A = any>
+  extends PushOp<
+    PushTag.ProducerSync,
+    {
+      readonly i0: SyncProducer<A>;
+    }
+  > {}
+
+export interface ProducerIO<R = never, E = any, A = any>
+  extends PushOp<
+    PushTag.ProducerIO,
+    {
+      readonly i0: IOProducer<R, E, A>;
+    }
+  > {}
+
+export interface Fail<E = any>
+  extends PushOp<
+    PushTag.FailCause,
+    {
+      readonly i0: () => Cause<E>;
+    }
+  > {}
+
+export interface OnSuccess<A = any>
+  extends PushOp<
+    PushTag.OnSuccess,
+    {
+      readonly i0: Primitive;
+      readonly i1: (a: A) => Primitive;
+    }
+  > {}
+
+export interface OnSuccessWithStrategy<A = any>
+  extends PushOp<
+    PushTag.OnSuccessWithStrategy,
+    {
+      readonly i0: Primitive;
+      readonly i1: (a: A) => Primitive;
+      readonly i2: FlattenStrategy;
+      readonly i3: ExecutionStrategy;
+    }
+  > {}
+
+export interface OnSuccessAndFailure<E = any, A = any>
+  extends PushOp<
+    PushTag.OnSuccessAndFailure,
+    {
+      readonly i0: Primitive;
+      readonly i1: (cause: Cause<E>) => Primitive;
+      readonly i2: (a: A) => Primitive;
+      readonly i3: FlattenStrategy;
+      readonly i4: ExecutionStrategy;
+    }
+  > {}
+
+export interface Transform
+  extends PushOp<
+    PushTag.Transform,
+    {
+      i0: Primitive;
+      i1: (io: IO<any, any, any>) => IO<any, never, void>;
+    }
+  > {}
+
+type Primitive =
+  | Base
+  | ProducerSync
+  | ProducerIO
+  | Fail
+  | OnSuccess
+  | OnSuccessWithStrategy
+  | OnSuccessAndFailure
+  | FromPush
+  | Defer
+  | Transform;
+
+export function concrete(push: Push<any, any, any>): asserts push is Primitive {
+  //
+}
+
+export function unsafeRunPush(push: Push<any, any, any>, sink: UnsafeSink<any, any, any>): IO<any, never, void> {
+  concrete(push);
+  switch (push._pushOpCode) {
+    case PushTag.Defer: {
+      return IO.defer(push.i0().unsafeRun(sink));
+    }
+    case PushTag.ProducerSync: {
+      return push.i0.runSink(sink);
+    }
+    case PushTag.ProducerIO: {
+      return push.i0.runSink(sink);
+    }
+    case PushTag.FailCause: {
+      return sink.onFailure(push.i0());
+    }
+    case PushTag.OnSuccessWithStrategy: {
+      return push.i2.withFork(
+        (fork) =>
+          push.i0.unsafeRun(
+            Sink.unsafeMake(
+              (value) => fork(push.i1(value).unsafeRun(sink)),
+              (cause) => sink.onFailure(cause),
+            ),
+          ),
+        push.i3,
+      );
+    }
+    case PushTag.OnSuccess: {
+      return push.i0.unsafeRun(
+        Sink.unsafeMake(
+          (value) => push.i1(value).unsafeRun(sink),
+          (cause) => sink.onFailure(cause),
+        ),
+      );
+    }
+    case PushTag.OnSuccessAndFailure: {
+      return push.i3.withFork(
+        (fork) =>
+          push.i0.unsafeRun(
+            Sink.unsafeMake(
+              (value) => fork(push.i2(value).unsafeRun(sink)),
+              (cause) => fork(push.i1(cause).unsafeRun(sink)),
+            ),
+          ),
+        push.i4,
+      );
+    }
+    case PushTag.FromPush: {
+      return IO.environmentWith((environment) => push.i0(sink).provideSomeEnvironment(environment));
+    }
+    case PushTag.Transform: {
+      return IO.defer(push.i1(push.i0.unsafeRun(sink)));
+    }
+    case null: {
+      return push.run(sink);
+    }
+  }
 }

package/_src/Push/internal.ts

@@ -1,5 +1,16 @@
 import type { RuntimeFiber } from "@fncts/io/Fiber";
 
+export function withScope<R, E, A>(
+  f: (scope: Scope.Closeable) => IO<R, E, A>,
+  executionStrategy: ExecutionStrategy,
+): IO<R | Scope, E, A> {
+  return IO.bracketExit(
+    IO.scopeWith((scope) => scope.forkWith(executionStrategy)),
+    f,
+    (scope, exit) => scope.close(exit),
+  );
+}
+
 export function withScopedFork<R, E, A>(
   f: (fork: <R, E, A>(io: IO<R, E, A>) => IO<R, never, RuntimeFiber<E, A>>) => IO<R, E, A>,
 ): IO<R, E, A> {

package/_src/Push.ts

@@ -1,5 +1,11 @@
-// codegen:start { preset: barrel, include: ./Push/*.ts }
+// codegen:start { preset: barrel, include: ./Push/*.ts, exclude: ./Push/Sink.ts }
 export * from "./Push/api.js";
+export * from "./Push/Bounds.js";
 export * from "./Push/definition.js";
+export * from "./Push/FlattenStrategy.js";
+export * from "./Push/IndexedBuffer.js";
 export * from "./Push/internal.js";
+export * from "./Push/MergeStrategy.js";
+export * from "./Push/Operator.js";
+export * from "./Push/Producer.js";
 // codegen:end

package/_src/Ref/Synchronized/definition.ts

@@ -1,4 +1,4 @@
-import type { PRef } from "../definition.js";
+import type { PRef, RefVariance } from "../definition.js";
 
 import { IO } from "@fncts/io/IO";
 
@@ -24,15 +24,59 @@ export interface PSynchronizedOps {}
  */
 export const Synchronized: PSynchronizedOps = {};
 
+export interface ModifiableSynchronized<RA, RB, EA, EB, A, B> {
+  readonly [RefVariance]: {
+    readonly _RA: (_: never) => RA;
+    readonly _RB: (_: never) => RB;
+    readonly _EA: (_: never) => EA;
+    readonly _EB: (_: never) => EB;
+    readonly _A: (_: A) => void;
+    readonly _B: (_: never) => B;
+  };
+
+  modifyIO<R1, E1, C>(
+    f: (b: B) => IO<R1, E1, readonly [C, A]>,
+    __tsplusTrace?: string,
+  ): IO<RA | RB | R1, EA | EB | E1, C>;
+}
+
+export interface MappableSynchronized<RA, RB, EA, EB, A, B> {
+  readonly [RefVariance]: {
+    readonly _RA: (_: never) => RA;
+    readonly _RB: (_: never) => RB;
+    readonly _EA: (_: never) => EA;
+    readonly _EB: (_: never) => EB;
+    readonly _A: (_: A) => void;
+    readonly _B: (_: never) => B;
+  };
+
+  matchIO<RC, RD, EC, ED, C, D>(
+    mapSetError: (_: EA) => EC,
+    mapGetError: (_: EB) => ED,
+    mapSet: (_: C) => IO<RC, EC, A>,
+    mapGet: (_: B) => IO<RD, ED, D>,
+    __tsplusTrace?: string,
+  ): PSynchronized<RA | RC, RB | RD, EC, ED, C, D>;
+
+  matchAllIO<RC, RD, EC, ED, C, D>(
+    mapSetError: (_: EA) => EC,
+    mapGetError: (_: EB) => ED,
+    mapSetGetError: (_: EB) => EC,
+    mapSet: (_: C) => (_: B) => IO<RC, EC, A>,
+    mapGet: (_: B) => IO<RD, ED, D>,
+    __tsplusTrace?: string,
+  ): PSynchronized<RA | RC | RB, RB | RD, EC, ED, C, D>;
+}
+
 /**
  * @tsplus type fncts.io.Ref.Synchronized
  */
 export class PSynchronizedInternal<RA, RB, EA, EB, A, B> extends RefInternal<RA, RB, EA, EB, A, B> {
   readonly [SynchronizedTypeId]: SynchronizedTypeId = SynchronizedTypeId;
   constructor(
-    readonly semaphore: Semaphore,
-    readonly unsafeGet: IO<RB, EB, B>,
-    readonly unsafeSet: (a: A) => IO<RA, EA, void>,
+    protected semaphore: Semaphore,
+    protected unsafeGet: IO<RB, EB, B>,
+    protected unsafeSet: (a: A) => IO<RA, EA, void>,
   ) {
     super();
   }
@@ -57,71 +101,71 @@ export class PSynchronizedInternal<RA, RB, EA, EB, A, B> extends RefInternal<RA,
   }
 
   matchAllIO<RC, RD, EC, ED, C, D>(
-    ea: (_: EA) => EC,
-    eb: (_: EB) => ED,
-    ec: (_: EB) => EC,
-    ca: (_: C) => (_: B) => IO<RC, EC, A>,
-    bd: (_: B) => IO<RD, ED, D>,
+    mapSetError: (_: EA) => EC,
+    mapGetError: (_: EB) => ED,
+    mapSetGetError: (_: EB) => EC,
+    mapSet: (_: C) => (_: B) => IO<RC, EC, A>,
+    mapGet: (_: B) => IO<RD, ED, D>,
     __tsplusTrace?: string,
   ): PSynchronizedInternal<RA | RC | RB, RB | RD, EC, ED, C, D> {
     return new PSynchronizedInternal(
       this.semaphore,
-      this.get.matchIO((e) => IO.failNow(eb(e)), bd),
+      this.get.matchIO((e) => IO.failNow(mapGetError(e)), mapGet),
       (c) =>
         this.get.matchIO(
-          (e) => IO.failNow(ec(e)),
-          (b) => ca(c)(b).flatMap((a) => this.unsafeSet(a).mapError(ea)),
+          (e) => IO.failNow(mapSetGetError(e)),
+          (b) => mapSet(c)(b).flatMap((a) => this.unsafeSet(a).mapError(mapSetError)),
         ),
     );
   }
 
   matchIO<RC, RD, EC, ED, C, D>(
-    ea: (_: EA) => EC,
-    eb: (_: EB) => ED,
-    ca: (_: C) => IO<RC, EC, A>,
-    bd: (_: B) => IO<RD, ED, D>,
+    mapSetError: (_: EA) => EC,
+    mapGetError: (_: EB) => ED,
+    mapSet: (_: C) => IO<RC, EC, A>,
+    mapGet: (_: B) => IO<RD, ED, D>,
     __tsplusTrace?: string,
   ): PSynchronizedInternal<RA | RC, RB | RD, EC, ED, C, D> {
     return new PSynchronizedInternal(
       this.semaphore,
-      this.unsafeGet.matchIO((e) => IO.failNow(eb(e)), bd),
-      (c) => ca(c).flatMap((a) => this.unsafeSet(a).mapError(ea)),
+      this.unsafeGet.matchIO((e) => IO.failNow(mapGetError(e)), mapGet),
+      (c) => mapSet(c).flatMap((a) => this.unsafeSet(a).mapError(mapSetError)),
     );
   }
 
   match<EC, ED, C, D>(
-    ea: (_: EA) => EC,
-    eb: (_: EB) => ED,
-    ca: (_: C) => Either<EC, A>,
-    bd: (_: B) => Either<ED, D>,
+    mapSetError: (_: EA) => EC,
+    mapGetError: (_: EB) => ED,
+    mapSet: (_: C) => Either<EC, A>,
+    mapGet: (_: B) => Either<ED, D>,
     __tsplusTrace?: string,
   ): PSynchronizedInternal<RA, RB, EC, ED, C, D> {
     return this.matchIO(
-      ea,
-      eb,
-      (c) => IO.fromEitherNow(ca(c)),
-      (b) => IO.fromEitherNow(bd(b)),
+      mapSetError,
+      mapGetError,
+      (c) => IO.fromEitherNow(mapSet(c)),
+      (b) => IO.fromEitherNow(mapGet(b)),
     );
   }
 
   matchAll<EC, ED, C, D>(
-    ea: (_: EA) => EC,
-    eb: (_: EB) => ED,
-    ec: (_: EB) => EC,
-    ca: (_: C) => (_: B) => Either<EC, A>,
-    bd: (_: B) => Either<ED, D>,
+    mapSetError: (_: EA) => EC,
+    mapGetError: (_: EB) => ED,
+    mapSetGetError: (_: EB) => EC,
+    mapSet: (_: C) => (_: B) => Either<EC, A>,
+    mapGet: (_: B) => Either<ED, D>,
     __tsplusTrace?: string,
   ): PSynchronizedInternal<RA, RB, EC, ED, C, D> {
     return this.matchAllIO(
-      ea,
-      eb,
-      ec,
-      (c) => (b) => IO.fromEitherNow(ca(c)(b)),
-      (b) => IO.fromEitherNow(bd(b)),
+      mapSetError,
+      mapGetError,
+      mapSetGetError,
+      (c) => (b) => IO.fromEitherNow(mapSet(c)(b)),
+      (b) => IO.fromEitherNow(mapGet(b)),
     ) as PSynchronizedInternal<RA, RB, EC, ED, C, D>;
   }
 
-  withPermit<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
+  protected withPermit<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
     return this.semaphore.withPermit(io);
   }
 }

package/_src/Ref/definition.ts

@@ -75,6 +75,32 @@ export interface ModifiableRef<RA, RB, EA, EB, A, B> {
   modify<C>(f: (b: B) => readonly [C, A], __tsplusTrace?: string): IO<RA | RB, EA | EB, C>;
 }
 
+export interface MappableRef<RA, RB, EA, EB, A, B> {
+  readonly [RefVariance]: {
+    readonly _RA: (_: never) => RA;
+    readonly _RB: (_: never) => RB;
+    readonly _EA: (_: never) => EA;
+    readonly _EB: (_: never) => EB;
+    readonly _A: (_: A) => void;
+    readonly _B: (_: never) => B;
+  };
+
+  match<EC, ED, C, D>(
+    ea: (_: EA) => EC,
+    eb: (_: EB) => ED,
+    ca: (_: C) => Either<EC, A>,
+    bd: (_: B) => Either<ED, D>,
+  ): PRef<RA, RB, EC, ED, C, D>;
+
+  matchAll<EC, ED, C, D>(
+    ea: (_: EA) => EC,
+    eb: (_: EB) => ED,
+    ec: (_: EB) => EC,
+    ca: (_: C) => (_: B) => Either<EC, A>,
+    bd: (_: B) => Either<ED, D>,
+  ): PRef<RA | RB, RB, EC, ED, C, D>;
+}
+
 export abstract class RefInternal<RA, RB, EA, EB, A, B>
   implements
     PRef<RA, RB, EA, EB, A, B>,

package/_src/Scope/api.ts

@@ -19,6 +19,16 @@ export function makeAddFinalizer(finalizer: Lazy<UIO<void>>, __tsplusTrace?: str
   return IO.serviceWithIO((scope) => scope.addFinalizer(finalizer), Scope.Tag);
 }
 
+/**
+ * @tsplus static fncts.io.ScopeOps addFinalizerExit
+ */
+export function makeAddFinalizerExit(
+  finalizer: (exit: Exit<any, any>) => UIO<any>,
+  __tsplusTrace?: string,
+): IO<Scope, never, void> {
+  return IO.serviceWithIO((scope) => scope.addFinalizerExit(Finalizer.get(finalizer)), Scope.Tag);
+}
+
 /**
  * @tsplus static fncts.io.ScopeOps concurrent
  * @tsplus static fncts.io.Scope.CloseableOps concurrent
@@ -131,3 +141,15 @@ export function use<R, E, A>(io: Lazy<IO<R, E, A>>, __tsplusTrace?: string) {
     return self.extend(io).onExit((exit) => self.close(exit));
   };
 }
+
+/**
+ * @tsplus getter fncts.io.Scope awaitClose
+ */
+export function awaitClose(scope: Scope): UIO<void> {
+  return IO.asyncIO((cb) => scope.addFinalizer(IO(() => cb(IO.unit))));
+}
+
+/**
+ * @tsplus static fncts.io.ScopeOps awaitClose
+ */
+export const wait: IO<Scope, never, void> = IO.asyncIO((cb) => Scope.addFinalizer(IO(() => cb(IO.unit))));

package/_src/Sink/definition.ts

@@ -1,12 +1,11 @@
 /**
  * Sink is a data type that represent a channel that reads elements
- * of type `In`, handles input errors of type `InErr`, emits errors
- * of type `OutErr`, emits outputs of type `L` and ends with a value
- * of type `Z`.
+ * of type `In`, emits errors of type `OutErr`, emits outputs of type `Out` and ends with a value
+ * of type `Done`.
  *
  * @tsplus type fncts.io.Sink
  * @tsplus companion fncts.io.SinkOps
  */
-export class Sink<R, E, In, L, Z> {
-  constructor(readonly channel: Channel<R, never, Conc<In>, unknown, E, Conc<L>, Z>) {}
+export class Sink<Env, OutErr, In, Out, Done> {
+  constructor(readonly channel: Channel<Env, never, Conc<In>, unknown, OutErr, Conc<Out>, Done>) {}
 }

package/_src/Stream/definition.ts

@@ -1,5 +1,4 @@
 import type { _A, _E, _R } from "@fncts/base/types";
-
 export const StreamVariance = Symbol.for("fncts.io.Stream.Variance");
 export type StreamVariance = typeof StreamVariance;
 

package/_src/Subject/Atomic.ts

@@ -1,11 +1,16 @@
-import type { Sink } from "@fncts/io/Push/definition";
-import type { Subject } from "@fncts/io/Subject/definition";
+import type { Scope } from "../Scope.js";
+import type { Push } from "@fncts/io/Push";
+import type { UnsafeSink } from "@fncts/io/Push/Sink";
 
-import { Multicast, Push } from "@fncts/io/Push";
+import { HashSet as MutableHashSet } from "@fncts/base/collection/mutable/HashSet";
 import { PushTypeId, PushVariance } from "@fncts/io/Push/definition";
+import { withScope } from "@fncts/io/Push/internal";
+import { PSubject } from "@fncts/io/Subject/definition";
 import { SubjectTypeId } from "@fncts/io/Subject/definition";
 
-export class AtomicSubject<E, A> implements Subject<never, E, A> {
+import { IO } from "../IO.js";
+
+export class AtomicSubject<E, A> extends PSubject<Scope, never, E, E, A, A> {
   readonly [SubjectTypeId]: SubjectTypeId = SubjectTypeId;
   readonly [PushTypeId]: PushTypeId       = PushTypeId;
   declare [PushVariance]: {
@@ -14,17 +19,69 @@ export class AtomicSubject<E, A> implements Subject<never, E, A> {
     readonly _A: (_: never) => A;
   };
 
-  readonly stream = new Multicast<never, E, A>(Push.never);
+  get subscribers(): number {
+    return this.sinks.size;
+  }
+
+  protected sinks = MutableHashSet.empty<readonly [UnsafeSink<any, E, A>, Environment<any>, Scope.Closeable]>();
+
+  protected interruptScopes = IO.fiberIdWith((fiberId) =>
+    this.sinks.foreachDiscardIO(([, , scope]) => scope.close(Exit.interrupt(fiberId))),
+  );
+
+  readonly interrupt = this.interruptScopes;
+
+  run<R1>(sink: UnsafeSink<R1, E, A>): IO<Scope | R1, never, void> {
+    return this.addSink(sink, (scope) => scope.awaitClose);
+  }
+
+  onSuccess(value: A): IO<never, never, void> {
+    return IO.defer(this.unsafeOnSuccess(value));
+  }
+
+  onFailure(cause: Cause<E>): IO<never, never, void> {
+    return IO.defer(this.unsafeOnFailure(cause));
+  }
 
-  run<R>(emitter: Sink<R, E, A>): IO<R, never, unknown> {
-    return this.stream.run(emitter);
+  protected addSink<R, R1, B>(
+    sink: UnsafeSink<R, E, A>,
+    f: (scope: Scope) => IO<R1, never, B>,
+  ): IO<Scope | R1, never, B> {
+    return withScope(
+      (innerScope) =>
+        IO.environmentWithIO((environment) => {
+          const entry = [sink, environment, innerScope] as const;
+          this.sinks.add(entry);
+          const remove = IO(this.sinks.remove(entry));
+          return innerScope.addFinalizer(remove) > f(innerScope);
+        }),
+      ExecutionStrategy.sequential,
+    );
   }
 
-  event(value: A): IO<never, never, void> {
-    return this.stream.event(value);
+  protected unsafeOnSuccess(a: A) {
+    if (this.sinks.size === 0) {
+      return IO.unit;
+    } else {
+      return this.sinks.foreachDiscardIO(([sink, environment]) =>
+        sink
+          .onSuccess(a)
+          .catchAllCause((cause) => sink.onFailure(cause))
+          .provideSomeEnvironment(environment),
+      );
+    }
   }
 
-  error(cause: Cause<E>): IO<never, never, void> {
-    return this.stream.error(cause);
+  protected unsafeOnFailure(cause: Cause<E>) {
+    if (this.sinks.size === 0) {
+      return IO.unit;
+    } else {
+      return this.sinks.foreachDiscardIO(([sink, environment, scope]) =>
+        sink
+          .onFailure(cause)
+          .catchAllCause((error) => scope.close(Exit.failCause(error)))
+          .provideSomeEnvironment(environment),
+      );
+    }
   }
 }