@fncts/io 0.0.48 → 0.0.50

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),
+      );
+    }
   }
 }

package/_src/Subject/DeferredRef.ts

@@ -0,0 +1,44 @@
+import type { AtomicReference } from "@fncts/base/internal/AtomicReference";
+
+import { External, IO } from "../IO.js";
+
+export class FutureRef<E, A> extends External<never, E, A> {
+  public version = -1;
+  public future!: Future<E, A>;
+
+  constructor(
+    readonly fiberId: FiberId,
+    readonly current: AtomicReference<Maybe<Exit<E, A>>>,
+  ) {
+    super();
+    this.reset();
+  }
+
+  toIO: IO<never, E, A> = IO.defer(() => {
+    const current = this.current.get;
+    if (current.isNothing()) {
+      return this.future.await;
+    } else {
+      return current.value!;
+    }
+  });
+
+  done(exit: Exit<E, A>) {
+    const current = this.current.get;
+    if (current.isJust() && Equatable.strictEquals(current.value, exit)) {
+      return false;
+    }
+    this.future.unsafeDone(exit);
+    this.version += 1;
+    return true;
+  }
+
+  reset() {
+    this.current.set(Nothing());
+    this.version = -1;
+    if (this.future) {
+      this.future.unsafeDone(Exit.interrupt(this.fiberId));
+    }
+    this.future = Future.unsafeMake(this.fiberId);
+  }
+}

package/_src/Subject/Hold.ts

@@ -0,0 +1,48 @@
+import type { Scope } from "../Scope.js";
+import type { Subject } from "../Subject.js";
+import type { Cause } from "@fncts/base/data/Cause";
+import type { UnsafeSink } from "@fncts/io/Push/Sink";
+
+import { AtomicReference } from "@fncts/base/internal/AtomicReference";
+
+import { IO } from "../IO.js";
+import { AtomicSubject } from "./Atomic.js";
+
+export interface Hold<E, A> extends Subject<never, E, A> {
+  value: AtomicReference<Maybe<Exit<E, A>>>;
+}
+
+export class HoldSubject<E, A> extends AtomicSubject<E, A> implements Hold<E, A> {
+  readonly value: AtomicReference<Maybe<Exit<E, A>>> = new AtomicReference(Nothing());
+
+  onSuccess(value: A): IO<never, never, void> {
+    return IO.defer(() => {
+      this.value.set(Just(Exit.succeed(value)));
+      return this.unsafeOnSuccess(value);
+    });
+  }
+
+  onFailure(cause: Cause<E>): IO<never, never, void> {
+    return IO.defer(() => {
+      this.value.set(Just(Exit.failCause(cause)));
+      return this.unsafeOnFailure(cause);
+    });
+  }
+
+  run<R1>(sink: UnsafeSink<R1, E, A>): IO<Scope | R1, never, void> {
+    return this.addSink(
+      sink,
+      (scope) =>
+        this.value.get.match(
+          () => IO.unit,
+          (exit) =>
+            exit.match(
+              (cause) => sink.onFailure(cause),
+              (value) => sink.onSuccess(value),
+            ),
+        ) > scope.awaitClose,
+    );
+  }
+
+  interrupt: IO<never, never, void> = this.interruptScopes > IO(this.value.set(Nothing()));
+}

package/_src/Subject/RefSubject/Atomic.ts

@@ -0,0 +1,193 @@
+import type { Runtime } from "@fncts/io/IO/runtime";
+import type { UnsafeSink } from "@fncts/io/Push/Sink";
+import type { Scope } from "@fncts/io/Scope";
+
+import { IO } from "@fncts/io/IO";
+import { PSynchronizedInternal } from "@fncts/io/Ref/Synchronized/definition";
+
+import { FutureRef } from "../DeferredRef.js";
+import { HoldSubject } from "../Hold.js";
+import { Derived } from "./Derived.js";
+import { PRefSubject } from "./RefSubject.js";
+
+export class Atomic<R, E, A> extends PRefSubject<never, never, E, E, E, A, A> {
+  constructor(
+    readonly fiberId: FiberId,
+    readonly initial: IO<R, E, A>,
+    readonly runtime: Runtime<R>,
+    readonly scope: Scope.Closeable,
+  ) {
+    super();
+  }
+
+  readonly semaphore                = Semaphore.unsafeMake(1);
+  private subject                   = new HoldSubject<E, A>();
+  private futureRef                 = new FutureRef(this.fiberId, this.subject.value);
+  private fiber: Fiber<E, A> | null = null;
+
+  readonly interrupt = IO.fiberIdWith((fiberId) => {
+    this.futureRef.reset();
+    return this.scope.close(Exit.interrupt(fiberId)) > this.interruptFiber > this.subject.interrupt;
+  });
+
+  readonly subscribers = this.subject.subscribers;
+
+  run<R1>(sink: UnsafeSink<R1, E, A>): IO<Scope | R1, never, void> {
+    return this.subject.run(sink);
+  }
+
+  onFailure(cause: Cause<E>): IO<never, never, void> {
+    const exit = Exit.failCause(cause);
+    return IO.defer(() => {
+      if (this.futureRef.done(exit)) {
+        return this.sendEvent(exit);
+      } else {
+        return IO.unit;
+      }
+    });
+  }
+
+  onSuccess = this.set;
+
+  modify<C>(f: (a: A) => readonly [C, A], __tsplusTrace?: string): IO<never, E, C> {
+    return this.get.flatMap((a) => {
+      const [c, a1] = f(a);
+      return this.set(a1).as(c);
+    });
+  }
+
+  modifyIO<R1, E1, B>(f: (a: A) => IO<R1, E1, readonly [B, A]>, __tsplusTrace?: string): IO<R1, E1 | E, B> {
+    return this.get.flatMap(f).flatMap(([b, a]) => this.set(a).as(b));
+  }
+
+  match<EC, ED, C, D>(
+    setError: (_: E) => EC,
+    getError: (_: E) => ED,
+    set: (_: C) => Either<EC, A>,
+    get: (_: A) => Either<ED, D>,
+    __tsplusTrace?: string,
+  ): PSynchronizedInternal<never, never, EC, ED, C, D> {
+    return this.matchIO(setError, getError, set, get);
+  }
+
+  matchAll<EC, ED, C, D>(
+    setError: (_: E) => EC,
+    getError: (_: E) => ED,
+    setGetError: (_: E) => EC,
+    set: (_: C) => (_: A) => Either<EC, A>,
+    get: (_: A) => Either<ED, D>,
+    __tsplusTrace?: string,
+  ): PSynchronizedInternal<never, never, EC, ED, C, D> {
+    return this.matchAllIO(setError, getError, setGetError, set, get);
+  }
+
+  matchIO<RC, RD, EC, ED, C, D>(
+    setError: (_: E) => EC,
+    getError: (_: E) => ED,
+    set: (_: C) => IO<RC, EC, A>,
+    get: (_: A) => IO<RD, ED, D>,
+    __tsplusTrace?: string,
+  ): PSynchronizedInternal<RC, RD, EC, ED, C, D> {
+    return new PSynchronizedInternal(
+      this.semaphore,
+      this.get.matchIO((e) => IO.failNow(getError(e)), get),
+      (c) => set(c).flatMap((a) => this.set(a).mapError(setError)),
+    );
+  }
+
+  matchAllIO<RC, RD, EC, ED, C, D>(
+    setError: (_: E) => EC,
+    getError: (_: E) => ED,
+    setGetError: (_: E) => EC,
+    set: (_: C) => (_: A) => IO<RC, EC, A>,
+    get: (_: A) => IO<RD, ED, D>,
+    __tsplusTrace?: string,
+  ): PSynchronizedInternal<RC, RD, EC, ED, C, D> {
+    return new PSynchronizedInternal(
+      this.semaphore,
+      this.get.matchIO((e) => IO.failNow(getError(e)), get),
+      (c) =>
+        this.get.matchIO(
+          (e) => IO.failNow(setGetError(e)),
+          (b) => set(c)(b).flatMap((a) => this.set(a).mapError(setError)),
+        ),
+    );
+  }
+
+  matchIOSubject<RC, RD, EI, EC, ED, C, D>(
+    mapSetError: (_: E) => EC,
+    mapGetError: (_: E) => ED,
+    mapErrorInput: (_: EI) => E,
+    mapSetErrorInput: (_: EC) => E,
+    mapSet: (_: C) => IO<RC, EC, A>,
+    mapGet: (_: A) => IO<RD, ED, D>,
+    __tsplusTrace?: string,
+  ): PRefSubject<RC, RD, EI, ED, EC, C, D> {
+    return new Derived((f) =>
+      f({
+        ref: this,
+        mapSetError,
+        mapGetError,
+        mapErrorInput,
+        mapSetErrorInput,
+        mapSet,
+        mapGet,
+      }),
+    );
+  }
+
+  set(a: A, __tsplusTrace?: string): IO<never, never, void> {
+    const exit = Exit.succeed(a);
+    return IO.defer(() => {
+      if (this.futureRef.done(exit)) {
+        return this.sendEvent(exit);
+      } else {
+        return IO.unit;
+      }
+    });
+  }
+
+  get get(): IO<never, E, A> {
+    return this.getOrInit(false);
+  }
+
+  private sendEvent(exit: Exit<E, A>) {
+    return exit.match(
+      (cause) => this.subject.onFailure(cause).provideEnvironment(this.runtime.environment),
+      (value) => this.subject.onSuccess(value).provideEnvironment(this.runtime.environment),
+    );
+  }
+
+  private getOrInit(lock: boolean) {
+    return IO.defer(() => {
+      if (this.fiber === null && this.futureRef.current.get.isNothing()) {
+        return this.init(lock) > this.futureRef;
+      } else {
+        return this.futureRef;
+      }
+    });
+  }
+
+  private interruptFiber = IO.defer(() => {
+    if (this.fiber) {
+      return this.fiber.interrupt;
+    } else {
+      return IO.unit;
+    }
+  });
+
+  private init(lock: boolean) {
+    const maybeWithLock = lock ? this.semaphore.withPermits(1) : Function.identity;
+
+    const initialize = maybeWithLock(
+      this.initial.provideEnvironment(this.runtime.environment).onExit((exit) =>
+        IO(() => {
+          this.fiber = null;
+          this.futureRef.done(exit);
+        }),
+      ),
+    );
+
+    return initialize.forkIn(this.scope).flatMap((fiber) => IO((this.fiber = fiber)));
+  }
+}

package/_src/Subject/RefSubject/Derived.ts

@@ -0,0 +1,179 @@
+import type { Atomic } from "./Atomic.js";
+import type { Cause } from "@fncts/base/data/Cause";
+import type { Either } from "@fncts/base/data/Either";
+import type { UnsafeSink } from "@fncts/io/Push/Sink";
+import type { PRef } from "@fncts/io/Ref";
+import type { Scope } from "@fncts/io/Scope";
+
+import { IO } from "@fncts/io/IO";
+import { Sink } from "@fncts/io/Push/Sink";
+import { type PSynchronized, PSynchronizedInternal } from "@fncts/io/Ref";
+
+import { PRefSubject } from "./RefSubject.js";
+
+export class Derived<EnvIn, EnvOut, ErrIn, ErrOut, ErrInRef, In, Out> extends PRefSubject<
+  EnvIn,
+  EnvOut,
+  ErrIn,
+  ErrOut,
+  ErrInRef,
+  In,
+  Out
+> {
+  constructor(
+    readonly use: <X>(
+      f: <R, E0, A0>(_: {
+        ref: Atomic<R, E0, A0>;
+        mapSetError: (_: E0) => ErrInRef;
+        mapGetError: (_: E0) => ErrOut;
+        mapErrorInput: (_: ErrIn) => E0;
+        mapSetErrorInput: (_: ErrInRef) => E0;
+        mapSet: (a: In) => IO<EnvIn, ErrInRef, A0>;
+        mapGet: (a: A0) => IO<EnvOut, ErrOut, Out>;
+      }) => X,
+    ) => X,
+  ) {
+    super();
+  }
+
+  subscribers = this.use(({ ref }) => ref.subscribers);
+  interrupt   = this.use(({ ref }) => ref.interrupt);
+
+  onSuccess(value: In): IO<EnvIn, never, void> {
+    return this.use(({ ref, mapSetErrorInput, mapSet }) =>
+      mapSet(value).matchCauseIO(
+        (cause) => ref.onFailure(cause.map(mapSetErrorInput)),
+        (a0) => ref.onSuccess(a0),
+      ),
+    );
+  }
+
+  onFailure(cause: Cause<ErrIn>): IO<EnvIn, never, void> {
+    return this.use(({ ref, mapErrorInput }) => ref.onFailure(cause.map(mapErrorInput)));
+  }
+
+  get get(): IO<EnvOut, ErrOut, Out> {
+    return this.use(({ ref, mapGetError, mapGet }) => ref.get.matchIO((e) => IO.failNow(mapGetError(e)), mapGet));
+  }
+
+  set(a: In, __tsplusTrace?: string): IO<EnvIn, ErrInRef, void> {
+    return this.use(({ ref, mapSet }) => mapSet(a).flatMap((a0) => ref.set(a0)));
+  }
+
+  modify<C>(f: (b: Out) => readonly [C, In], __tsplusTrace?: string): IO<EnvIn | EnvOut, ErrOut | ErrInRef, C> {
+    return this.modifyIO((out) => IO.succeedNow(f(out)));
+  }
+
+  modifyIO<R1, E1, C>(
+    f: (b: Out) => IO<R1, E1, readonly [C, In]>,
+    __tsplusTrace?: string,
+  ): IO<EnvIn | EnvOut | R1, ErrOut | ErrInRef | E1, C> {
+    return this.use(({ ref, mapGetError, mapSet, mapGet }) =>
+      ref.get.mapError(mapGetError).flatMap((a0) =>
+        mapGet(a0)
+          .flatMap(f)
+          .flatMap(([c, a]) =>
+            mapSet(a)
+              .flatMap((a0) => ref.set(a0))
+              .as(c),
+          ),
+      ),
+    );
+  }
+
+  match<EC, ED, C, D>(
+    ea: (_: ErrInRef) => EC,
+    eb: (_: ErrOut) => ED,
+    ca: (_: C) => Either<EC, In>,
+    bd: (_: Out) => Either<ED, D>,
+    __tsplusTrace?: string,
+  ): PRef<EnvIn, EnvOut, EC, ED, C, D> {
+    return this.matchIO(ea, eb, ca, bd);
+  }
+
+  matchAll<EC, ED, C, D>(
+    ea: (_: ErrInRef) => EC,
+    eb: (_: ErrOut) => ED,
+    ec: (_: ErrOut) => EC,
+    ca: (_: C) => (_: Out) => Either<EC, In>,
+    bd: (_: Out) => Either<ED, D>,
+    __tsplusTrace?: string,
+  ): PRef<EnvIn | EnvOut, EnvOut, EC, ED, C, D> {
+    return this.matchAllIO(ea, eb, ec, ca, bd);
+  }
+
+  matchIO<RC, RD, EC, ED, C, D>(
+    mapSetError: (_: ErrInRef) => EC,
+    mapGetError: (_: ErrOut) => ED,
+    mapSet: (_: C) => IO<RC, EC, In>,
+    mapGet: (_: Out) => IO<RD, ED, D>,
+    __tsplusTrace?: string,
+  ): PSynchronized<EnvIn | RC, EnvOut | RD, EC, ED, C, D> {
+    return this.use(
+      ({ ref }) =>
+        new PSynchronizedInternal(
+          ref.semaphore,
+          this.get.matchIO((e) => IO.failNow(mapGetError(e)), mapGet),
+          (c) => mapSet(c).flatMap((a) => this.set(a).mapError(mapSetError)),
+        ),
+    );
+  }
+
+  matchAllIO<RC, RD, EC, ED, C, D>(
+    mapSetError: (_: ErrInRef) => EC,
+    mapGetError: (_: ErrOut) => ED,
+    mapSetGetError: (_: ErrOut) => EC,
+    mapSet: (_: C) => (_: Out) => IO<RC, EC, In>,
+    mapGet: (_: Out) => IO<RD, ED, D>,
+    __tsplusTrace?: string,
+  ): PSynchronized<EnvIn | EnvOut | RC, EnvOut | RD, EC, ED, C, D> {
+    return this.use(
+      ({ ref }) =>
+        new PSynchronizedInternal(
+          ref.semaphore,
+          this.get.matchIO((e) => IO.failNow(mapGetError(e)), mapGet),
+          (c) =>
+            this.get.matchIO(
+              (e) => IO.failNow(mapSetGetError(e)),
+              (b) => mapSet(c)(b).flatMap((a) => this.set(a).mapError(mapSetError)),
+            ),
+        ),
+    );
+  }
+
+  matchIOSubject<RC, RD, EI, EC, ED, C, D>(
+    mapSetError: (_: ErrInRef) => EC,
+    mapGetError: (_: ErrOut) => ED,
+    mapErrorInput: (_: EI) => ErrIn,
+    mapSetErrorInput: (_: EC) => ErrInRef,
+    mapSet: (_: C) => IO<RC, EC, In>,
+    mapGet: (_: Out) => IO<RD, ED, D>,
+    __tsplusTrace?: string,
+  ): PRefSubject<EnvIn | RC, EnvOut | RD, EI, ED, EC, C, D> {
+    return this.use(
+      (r) =>
+        new Derived<EnvIn | RC, EnvOut | RD, EI, ED, EC, C, D>((f) =>
+          f({
+            ref: r.ref,
+            mapSetError: (e0) => mapSetError(r.mapSetError(e0)),
+            mapGetError: (e0) => mapGetError(r.mapGetError(e0)),
+            mapErrorInput: (ei) => r.mapErrorInput(mapErrorInput(ei)),
+            mapSetErrorInput: (ec) => r.mapSetErrorInput(mapSetErrorInput(ec)),
+            mapSet: (c) => mapSet(c).flatMap((inp) => r.mapSet(inp).mapError(mapSetError)),
+            mapGet: (a0) => r.mapGet(a0).mapError(mapGetError).flatMap(mapGet),
+          }),
+        ),
+    );
+  }
+
+  run<R1>(sink: UnsafeSink<R1, ErrOut, Out>): IO<Scope | EnvOut | R1, never, void> {
+    return this.use(({ ref, mapGet, mapGetError }) =>
+      ref.run(
+        Sink.unsafeMake(
+          (a0) => mapGet(a0).matchCauseIO(sink.onFailure, sink.onSuccess),
+          (cause) => sink.onFailure(cause.map(mapGetError)),
+        ),
+      ),
+    );
+  }
+}

package/_src/Subject/RefSubject/RefSubject.ts

@@ -0,0 +1,90 @@
+import type {
+  MappableRef,
+  MappableSynchronized,
+  ModifiableRef,
+  ModifiableSynchronized,
+  PSynchronized,
+  ReadableRef,
+  WritableRef,
+} from "../../Ref.js";
+import type { IO } from "@fncts/io/IO";
+
+import { RefTypeId, RefVariance, SynchronizedTypeId } from "../../Ref.js";
+import { PSubject } from "../definition.js";
+
+export abstract class PRefSubject<EnvIn, EnvOut, ErrIn, ErrOut, ErrInRef, In, Out>
+  extends PSubject<EnvIn, EnvOut, ErrIn, ErrOut, In, Out>
+  implements
+    PRef<EnvIn, EnvOut, ErrInRef, ErrOut, In, Out>,
+    PSynchronized<EnvIn, EnvOut, ErrInRef, ErrOut, In, Out>,
+    ReadableRef<EnvOut, ErrOut, Out>,
+    WritableRef<EnvIn, ErrInRef, In>,
+    ModifiableRef<EnvIn, EnvOut, ErrInRef, ErrOut, In, Out>,
+    MappableRef<EnvIn, EnvOut, ErrInRef, ErrOut, In, Out>,
+    ModifiableSynchronized<EnvIn, EnvOut, ErrInRef, ErrOut, In, Out>,
+    MappableSynchronized<EnvIn, EnvOut, ErrInRef, ErrOut, In, Out>
+{
+  readonly [SynchronizedTypeId]: SynchronizedTypeId = SynchronizedTypeId;
+  readonly [RefTypeId]: RefTypeId                   = RefTypeId;
+  declare [RefVariance]: {
+    readonly _RA: (_: never) => EnvIn;
+    readonly _RB: (_: never) => EnvOut;
+    readonly _EA: (_: never) => ErrInRef;
+    readonly _EB: (_: never) => ErrOut;
+    readonly _A: (_: In) => void;
+    readonly _B: (_: never) => Out;
+  };
+
+  abstract get: IO<EnvOut, ErrOut, Out>;
+
+  abstract set(a: In, __tsplusTrace?: string): IO<EnvIn, ErrInRef, void>;
+
+  abstract modify<C>(f: (b: Out) => readonly [C, In], __tsplusTrace?: string): IO<EnvIn | EnvOut, ErrOut | ErrInRef, C>;
+
+  abstract modifyIO<R1, E1, C>(
+    f: (b: Out) => IO<R1, E1, readonly [C, In]>,
+    __tsplusTrace?: string,
+  ): IO<EnvIn | EnvOut | R1, ErrOut | ErrInRef | E1, C>;
+
+  abstract match<EC, ED, C, D>(
+    ea: (_: ErrInRef) => EC,
+    eb: (_: ErrOut) => ED,
+    ca: (_: C) => Either<EC, In>,
+    bd: (_: Out) => Either<ED, D>,
+  ): PRef<EnvIn, EnvOut, EC, ED, C, D>;
+
+  abstract matchAll<EC, ED, C, D>(
+    ea: (_: ErrInRef) => EC,
+    eb: (_: ErrOut) => ED,
+    ec: (_: ErrOut) => EC,
+    ca: (_: C) => (_: Out) => Either<EC, In>,
+    bd: (_: Out) => Either<ED, D>,
+  ): PRef<EnvIn | EnvOut, EnvOut, EC, ED, C, D>;
+
+  abstract matchIO<RC, RD, EC, ED, C, D>(
+    mapSetError: (_: ErrInRef) => EC,
+    mapGetError: (_: ErrOut) => ED,
+    mapSet: (_: C) => IO<RC, EC, In>,
+    mapGet: (_: Out) => IO<RD, ED, D>,
+    __tsplusTrace?: string,
+  ): PSynchronized<EnvIn | RC, EnvOut | RD, EC, ED, C, D>;
+
+  abstract matchAllIO<RC, RD, EC, ED, C, D>(
+    mapSetError: (_: ErrInRef) => EC,
+    mapGetError: (_: ErrOut) => ED,
+    mapSetGetError: (_: ErrOut) => EC,
+    mapSet: (_: C) => (_: Out) => IO<RC, EC, In>,
+    mapGet: (_: Out) => IO<RD, ED, D>,
+    __tsplusTrace?: string,
+  ): PSynchronized<EnvIn | EnvOut | RC, EnvOut | RD, EC, ED, C, D>;
+
+  abstract matchIOSubject<RC, RD, EI, EC, ED, C, D>(
+    mapSetError: (_: ErrInRef) => EC,
+    mapGetError: (_: ErrOut) => ED,
+    mapErrorInput: (_: EI) => ErrIn,
+    mapSetErrorInput: (_: EC) => ErrInRef,
+    mapSet: (_: C) => IO<RC, EC, In>,
+    mapGet: (_: Out) => IO<RD, ED, D>,
+    __tsplusTrace?: string,
+  ): PRefSubject<EnvIn | RC, EnvOut | RD, EI, ED, EC, C, D>;
+}

package/_src/Subject/definition.ts

@@ -1,4 +1,8 @@
-import type { Push, Sink } from "../Push.js";
+import type { UnsafeSink } from "../Push/Sink.js";
+import type { Cause } from "@fncts/base/data/Cause";
+import type { IO } from "@fncts/io/IO";
+
+import { Push, PushTypeId } from "../Push.js";
 
 export const SubjectTypeId = Symbol.for("fncts.io.Push.Subject");
 export type SubjectTypeId = typeof SubjectTypeId;
@@ -6,10 +10,24 @@ export type SubjectTypeId = typeof SubjectTypeId;
 /**
  * @tsplus type fncts.io.Push.Subject
  */
-export interface Subject<R, E, A> extends Push<R, E, A>, Sink<R, E, A> {
-  readonly [SubjectTypeId]: SubjectTypeId;
+export abstract class PSubject<out EnvIn, out EnvOut, in ErrIn, out ErrOut, in In, Out>
+  extends Push<EnvOut | Scope, ErrOut, Out>
+  implements Push<EnvOut | Scope, ErrOut, Out>, UnsafeSink<EnvIn, ErrIn, In>
+{
+  readonly _pushOpCode                    = null;
+  readonly [PushTypeId]: PushTypeId       = PushTypeId;
+  readonly [SubjectTypeId]: SubjectTypeId = SubjectTypeId;
+
+  abstract onSuccess(value: In): IO<EnvIn, never, void>;
+  abstract onFailure(cause: Cause<ErrIn>): IO<EnvIn, never, void>;
+
+  abstract interrupt: URIO<EnvIn, void>;
+
+  abstract subscribers: number;
 }
 
+export type Subject<R, E, A> = PSubject<R, R, E, E, A, A>;
+
 /**
  * @tsplus type fncts.io.Push.SubjectOps
  */