@fncts/io 0.0.48 → 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/Random/definition.ts

@@ -2,6 +2,7 @@ import type { ArrayInt } from "@fncts/base/util/rand";
 
 /**
  * @tsplus static fncts.io.RandomOps Tag
+ * @tsplus implicit
  */
 export const RandomTag = Tag<Random>("fncts.io.Random");
 

package/_src/Ref/Synchronized/api.ts

@@ -201,8 +201,8 @@ export function modifyJustIO<A, R1, E1, B>(
  * @tsplus pipeable fncts.io.Ref.Synchronized updateAndGetIO
  */
 export function updateAndGetIO<A, R1, E1>(f: (a: A) => IO<R1, E1, A>, __tsplusTrace?: string) {
-  return <RA, RB, EA, EB>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>): IO<RA | RB | R1, E1 | EA | EB, void> => {
-    return ref.modifyIO((a) => f(a).map((r) => [r, r])).asUnit;
+  return <RA, RB, EA, EB>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>): IO<RA | RB | R1, E1 | EA | EB, A> => {
+    return ref.modifyIO((a) => f(a).map((r) => [r, r]));
   };
 }
 

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();
   }
@@ -53,75 +97,75 @@ export class PSynchronizedInternal<RA, RB, EA, EB, A, B> extends RefInternal<RA,
     f: (b: B) => IO<R1, E1, readonly [C, A]>,
     __tsplusTrace?: string,
   ): IO<RA | RB | R1, EA | EB | E1, C> {
-    return this.withPermit(this.unsafeGet.flatMap(f).flatMap(([b, a]) => this.unsafeSet(a).as(b)));
+    return this.withPermit(this.unsafeGet.flatMap(f).flatMap(([c, a]) => this.unsafeSet(a).as(c)));
   }
 
   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/Semaphore/Reservation.ts

@@ -0,0 +1,15 @@
+/**
+ * @tsplus type fncts.io.Semaphore.Reservation
+ * @tsplus companion fncts.io.Semaphore.ReservationOps
+ */
+export class Reservation {
+  constructor(
+    readonly acquire: UIO<void>,
+    readonly release: UIO<void>,
+  ) {}
+}
+
+/**
+ * @tsplus static fncts.io.Semaphore.ReservationOps zero
+ */
+export const zero = new Reservation(IO.unit, IO.unit);

package/_src/Semaphore/constructors.ts

@@ -0,0 +1,14 @@
+/**
+ * @tsplus static fncts.io.SemaphoreOps unsafeMake
+ */
+export function unsafeMakeSemaphore(permits: number): Semaphore {
+  return new Semaphore(permits);
+}
+
+/**
+ * @tsplus static fncts.io.SemaphoreOps make
+ * @tsplus static fncts.io.SemaphoreOps __call
+ */
+export function makeSemaphore(permits: number, __tsplusTrace?: string): UIO<Semaphore> {
+  return IO(Semaphore.unsafeMake(permits));
+}