@fncts/io 0.0.49 → 0.0.51

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/Schedule/api.ts

@@ -9,7 +9,7 @@ export function make<State, Env, In, Out>(
   __tsplusTrace?: string,
 ): Schedule.WithState<State, Env, In, Out> {
   return new (class extends Schedule<Env, In, Out> {
-    readonly _State!: State;
+    declare readonly _State: State;
     initial = initial;
     step = step;
   })();

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/ScopedRef/api.ts

@@ -20,7 +20,9 @@ class Synch<A> extends ScopedRef<A> {
   constructor(readonly ref: Ref.Synchronized<readonly [Scope.Closeable, A]>) {
     super();
   }
-  close: UIO<void> = this.ref.get.flatMap(([scope, _]) => scope.close(Exit.unit));
+  get close(): UIO<void> {
+    return this.ref.get.flatMap(([scope, _]) => scope.close(Exit.unit));
+  }
   set<R, E>(acquire: IO<R, E, A>, __tsplusTrace?: string): IO<Exclude<R, Scope>, E, void> {
     return this.ref.modifyIO(([oldScope, a]) =>
       IO.uninterruptibleMask((restore) =>
@@ -39,5 +41,7 @@ class Synch<A> extends ScopedRef<A> {
       ),
     ).flatten;
   }
-  get: UIO<A> = this.ref.get.map(([_, a]) => a);
+  get get(): UIO<A> {
+    return this.ref.get.map(([_, a]) => a);
+  }
 }

package/_src/Semaphore/definition.ts

@@ -7,9 +7,11 @@ import { Reservation } from "@fncts/io/Semaphore/Reservation";
  * @tsplus companion fncts.io.SemaphoreOps
  */
 export class Semaphore {
-  constructor(readonly permits: number) {}
+  readonly ref: Ref<Either<ImmutableQueue<[Future<never, void>, number]>, number>>;
 
-  ref = Ref.unsafeMake<Either<ImmutableQueue<[Future<never, void>, number]>, number>>(Either.right(this.permits));
+  constructor(readonly permits: number) {
+    this.ref = Ref.unsafeMake(Either.right(this.permits));
+  }
 
   available(__tsplusTrace?: string): UIO<number> {
     return this.ref.get.map((_) =>

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/api.ts

@@ -1367,9 +1367,7 @@ export function failNow<E>(error: E, __tsplusTrace?: string): Stream<never, E, n
  * @tsplus pipeable fncts.io.Stream filter
  */
 export function filter<A, B extends A>(refinement: Refinement<A, B>): <R, E>(fa: Stream<R, E, A>) => Stream<R, E, B>;
-
 export function filter<A>(predicate: Predicate<A>): <R, E>(fa: Stream<R, E, A>) => Stream<R, E, A>;
-
 export function filter<A>(predicate: Predicate<A>, __tsplusTrace?: string) {
   return <R, E>(fa: Stream<R, E, A>): Stream<R, E, A> => {
     return fa.mapChunks((chunk) => chunk.filter(predicate));

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