@fncts/io 0.0.47 → 0.0.49

package/_src/IO/definition.ts

@@ -37,6 +37,7 @@ export declare namespace IO {
   export type EnvironmentOf<T> = [T] extends [{ [IOVariance]: { _R: () => infer R } }] ? R : never;
   export type ErrorOf<T> = [T] extends [{ [IOVariance]: { _E: () => infer E } }] ? E : never;
   export type ValueOf<T> = [T] extends [{ [IOVariance]: { _A: () => infer A } }] ? A : never;
+  export type Concrete = Primitive;
 }
 
 declare module "@fncts/base/data/Either/definition" {
@@ -90,15 +91,12 @@ export const enum IOTag {
   Async,
   OnSuccessAndFailure,
   OnSuccess,
-  OnFailure,
   UpdateRuntimeFlags,
   UpdateRuntimeFlagsWithin,
-  GenerateStackTrace,
   Stateful,
   WhileLoop,
   YieldNow,
   Commit,
-  RevertFlags,
   UpdateTrace,
   External,
 }
@@ -130,7 +128,7 @@ export interface Sync<A = any>
     }
   > {}
 
-export interface Async<R = any, E = any, A = any>
+export interface Async
   extends IOOp<
     IOTag.Async,
     {
@@ -151,16 +149,6 @@ export interface OnSuccessAndFailure
     }
   > {}
 
-export interface OnFailure
-  extends IOOp<
-    IOTag.OnFailure,
-    {
-      readonly i0: Primitive;
-      readonly i1: (cause: Cause<unknown>) => Primitive;
-      readonly trace: string | undefined;
-    }
-  > {}
-
 export interface OnSuccess
   extends IOOp<
     IOTag.OnSuccess,
@@ -171,7 +159,7 @@ export interface OnSuccess
     }
   > {}
 
-export interface SucceedNow
+export interface Succeed
   extends IOOp<
     IOTag.SucceedNow,
     {
@@ -199,14 +187,6 @@ export interface UpdateRuntimeFlagsWithin
     }
   > {}
 
-export interface GenerateStackTrace
-  extends IOOp<
-    IOTag.GenerateStackTrace,
-    {
-      readonly trace: string | undefined;
-    }
-  > {}
-
 export interface Stateful
   extends IOOp<
     IOTag.Stateful,
@@ -246,14 +226,12 @@ export interface Fail
 
 export type Primitive =
   | OnSuccessAndFailure
-  | OnFailure
   | OnSuccess
   | UpdateRuntimeFlagsWithin
   | Sync
   | Async
-  | SucceedNow
+  | Succeed
   | UpdateRuntimeFlags
-  | GenerateStackTrace
   | Stateful
   | WhileLoop
   | YieldNow
@@ -276,8 +254,6 @@ export function concrete(io: IO<any, any, any>): Primitive {
   return io as Primitive;
 }
 
-export type EvaluationStep = OnSuccessAndFailure | OnFailure | OnSuccess;
-
 export type Canceler<R> = URIO<R, void>;
 
 export abstract class External<R, E, A> extends IOPrimitive implements IO<R, E, A> {

package/_src/IO/runtime.ts

@@ -1,4 +1,3 @@
-import { IOError } from "@fncts/base/data/exceptions";
 import { FiberRuntime } from "@fncts/io/Fiber";
 import { FiberRefs } from "@fncts/io/FiberRefs";
 import { RuntimeFlag } from "@fncts/io/RuntimeFlag";

package/_src/IO.ts

@@ -5,67 +5,69 @@ export * from "./IO/runtime.js";
 // codegen:end
 
 // codegen:start { preset: barrel, include: IO/api/*.ts }
-export * from "./IO/api/acquireRelease.js";
-export * from "./IO/api/acquireReleaseExit.js";
-export * from "./IO/api/acquireReleaseInterruptible.js";
-export * from "./IO/api/acquireReleaseInterruptibleExit.js";
-export * from "./IO/api/addFinalizer.js";
-export * from "./IO/api/addFinalizerExit.js";
-export * from "./IO/api/all.js";
-export * from "./IO/api/asyncInterrupt.js";
-export * from "./IO/api/asyncIO.js";
-export * from "./IO/api/blocking.js";
-export * from "./IO/api/bracket.js";
-export * from "./IO/api/bracketExit.js";
-export * from "./IO/api/clockWith.js";
-export * from "./IO/api/concurrency.js";
-export * from "./IO/api/concurrentFinalizers.js";
-export * from "./IO/api/consoleWith.js";
-export * from "./IO/api/daemonChildren.js";
-export * from "./IO/api/delay.js";
-export * from "./IO/api/descriptor.js";
-export * from "./IO/api/diffFiberRefs.js";
-export * from "./IO/api/disconnect.js";
-export * from "./IO/api/ensuringChildren.js";
-export * from "./IO/api/environment.js";
-export * from "./IO/api/foreachConcurrent.js";
-export * from "./IO/api/foreachExec.js";
-export * from "./IO/api/fork.js";
-export * from "./IO/api/forkAll.js";
-export * from "./IO/api/forkDaemon.js";
-export * from "./IO/api/forkIn.js";
-export * from "./IO/api/forkScoped.js";
-export * from "./IO/api/fulfill.js";
-export * from "./IO/api/interrupt.js";
-export * from "./IO/api/memoize.js";
-export * from "./IO/api/once.js";
-export * from "./IO/api/onTermination.js";
-export * from "./IO/api/patchFiberRefs.js";
-export * from "./IO/api/provideLayer.js";
-export * from "./IO/api/provideScope.js";
-export * from "./IO/api/provideSomeLayer.js";
-export * from "./IO/api/provideSomeRuntime.js";
-export * from "./IO/api/race.js";
-export * from "./IO/api/raceFirst.js";
-export * from "./IO/api/raceWith.js";
-export * from "./IO/api/randomWith.js";
-export * from "./IO/api/repeat.js";
-export * from "./IO/api/retry.js";
-export * from "./IO/api/schedule.js";
-export * from "./IO/api/scope.js";
-export * from "./IO/api/scoped.js";
-export * from "./IO/api/scopeWith.js";
-export * from "./IO/api/sequenceT.js";
-export * from "./IO/api/sleep.js";
-export * from "./IO/api/stateful.js";
-export * from "./IO/api/supervised.js";
-export * from "./IO/api/timeout.js";
-export * from "./IO/api/transplant.js";
-export * from "./IO/api/whenFiberRef.js";
-export * from "./IO/api/whenRef.js";
-export * from "./IO/api/withChildren.js";
-export * from "./IO/api/withEarlyRelease.js";
-export * from "./IO/api/withFinalizer.js";
-export * from "./IO/api/withFinalizerExit.js";
-export * from "./IO/api/zipConcurrent.js";
+export * from "./IO/api/acquireRelease.js"
+export * from "./IO/api/acquireReleaseExit.js"
+export * from "./IO/api/acquireReleaseInterruptible.js"
+export * from "./IO/api/acquireReleaseInterruptibleExit.js"
+export * from "./IO/api/addFinalizer.js"
+export * from "./IO/api/addFinalizerExit.js"
+export * from "./IO/api/all.js"
+export * from "./IO/api/array.js"
+export * from "./IO/api/asyncInterrupt.js"
+export * from "./IO/api/asyncIO.js"
+export * from "./IO/api/awaitAllChildren.js"
+export * from "./IO/api/blocking.js"
+export * from "./IO/api/bracket.js"
+export * from "./IO/api/bracketExit.js"
+export * from "./IO/api/cachedInvalidate.js"
+export * from "./IO/api/clockWith.js"
+export * from "./IO/api/concurrency.js"
+export * from "./IO/api/concurrentFinalizers.js"
+export * from "./IO/api/consoleWith.js"
+export * from "./IO/api/daemonChildren.js"
+export * from "./IO/api/delay.js"
+export * from "./IO/api/descriptor.js"
+export * from "./IO/api/diffFiberRefs.js"
+export * from "./IO/api/disconnect.js"
+export * from "./IO/api/ensuringChildren.js"
+export * from "./IO/api/environment.js"
+export * from "./IO/api/foreachConcurrent.js"
+export * from "./IO/api/foreachExec.js"
+export * from "./IO/api/fork.js"
+export * from "./IO/api/forkAll.js"
+export * from "./IO/api/forkDaemon.js"
+export * from "./IO/api/forkIn.js"
+export * from "./IO/api/forkScoped.js"
+export * from "./IO/api/fulfill.js"
+export * from "./IO/api/interrupt.js"
+export * from "./IO/api/memoize.js"
+export * from "./IO/api/once.js"
+export * from "./IO/api/onTermination.js"
+export * from "./IO/api/patchFiberRefs.js"
+export * from "./IO/api/provideLayer.js"
+export * from "./IO/api/provideScope.js"
+export * from "./IO/api/provideSomeLayer.js"
+export * from "./IO/api/provideSomeRuntime.js"
+export * from "./IO/api/race.js"
+export * from "./IO/api/raceFirst.js"
+export * from "./IO/api/raceWith.js"
+export * from "./IO/api/randomWith.js"
+export * from "./IO/api/repeat.js"
+export * from "./IO/api/retry.js"
+export * from "./IO/api/schedule.js"
+export * from "./IO/api/scope.js"
+export * from "./IO/api/scoped.js"
+export * from "./IO/api/scopeWith.js"
+export * from "./IO/api/sleep.js"
+export * from "./IO/api/stateful.js"
+export * from "./IO/api/supervised.js"
+export * from "./IO/api/timeout.js"
+export * from "./IO/api/transplant.js"
+export * from "./IO/api/whenFiberRef.js"
+export * from "./IO/api/whenRef.js"
+export * from "./IO/api/withChildren.js"
+export * from "./IO/api/withEarlyRelease.js"
+export * from "./IO/api/withFinalizer.js"
+export * from "./IO/api/withFinalizerExit.js"
+export * from "./IO/api/zipConcurrent.js"
 // codegen:end

package/_src/IOEnv/definition.ts

@@ -12,7 +12,4 @@ export const IOEnv: IOEnvOps = {};
 /**
  * @tsplus static fncts.io.IOEnvOps environment
  */
-export const environment = Environment()
-  .add(Clock.Live, Clock.Tag)
-  .add(Random.Live, Random.Tag)
-  .add(Console.Live, Console.Tag);
+export const environment = Environment().add(Clock.Live).add(Random.Live).add(Console.Live);

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

@@ -53,7 +53,7 @@ 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>(

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

package/_src/Semaphore/definition.ts

@@ -0,0 +1,180 @@
+import { EitherTag } from "@fncts/base/data/Either";
+import { IllegalArgumentError } from "@fncts/base/data/exceptions";
+import { Reservation } from "@fncts/io/Semaphore/Reservation";
+
+/**
+ * @tsplus type fncts.io.Semaphore
+ * @tsplus companion fncts.io.SemaphoreOps
+ */
+export class Semaphore {
+  constructor(readonly permits: number) {}
+
+  ref = Ref.unsafeMake<Either<ImmutableQueue<[Future<never, void>, number]>, number>>(Either.right(this.permits));
+
+  available(__tsplusTrace?: string): UIO<number> {
+    return this.ref.get.map((_) =>
+      _.match(
+        () => 0,
+        (permits) => permits,
+      ),
+    );
+  }
+
+  tryReserve(n: number, __tsplusTrace?: string): UIO<Maybe<Reservation>> {
+    if (n < 0) {
+      return IO.halt(new IllegalArgumentError(`Unexpected negative ${n} permits requested`, "Semaphore.tryReserve"));
+    } else if (n === 0) {
+      return IO.succeedNow(Just(Reservation.zero));
+    } else {
+      return this.ref.modify((state) =>
+        state.match(
+          () => [Nothing(), state],
+          (permits) => {
+            if (permits >= n) {
+              return [Just(new Reservation(IO.unit, this.releaseN(n))), Either.right(permits - n)];
+            } else {
+              return [Nothing(), state];
+            }
+          },
+        ),
+      );
+    }
+  }
+
+  reserve(n: number, __tsplusTrace?: string): UIO<Reservation> {
+    if (n < 0) {
+      return IO.halt(new IllegalArgumentError(`Unexpected negative ${n} permits requested`, "Semaphore.reserve"));
+    } else if (n === 0) {
+      return IO.succeedNow(Reservation.zero);
+    } else {
+      return Future.make<never, void>().flatMap((future) =>
+        this.ref.modify((state) =>
+          state.match(
+            (queue) => [
+              new Reservation(future.await, this.restore(future, n)),
+              Either.left(queue.enqueue([future, n])),
+            ],
+            (permits) => {
+              if (permits >= n) {
+                return [new Reservation(IO.unit, this.releaseN(n)), Either.right(permits - n)];
+              } else {
+                return [
+                  new Reservation(future.await, this.restore(future, n)),
+                  Either.left(ImmutableQueue.single([future, n - permits])),
+                ];
+              }
+            },
+          ),
+        ),
+      );
+    }
+  }
+
+  restore(future: Future<never, void>, n: number, __tsplusTrace?: string): UIO<void> {
+    return this.ref.modify((state) =>
+      state.match(
+        (queue) =>
+          queue
+            .find(([waiter]) => waiter === future)
+            .match(
+              () => [this.releaseN(n), Either.left(queue)],
+              ([_, permits]) => [
+                this.releaseN(n - permits),
+                Either.left(queue.filter(([waiter]) => waiter !== future)),
+              ],
+            ),
+        (permits) => [IO.unit, Either.right(permits + n)],
+      ),
+    ).flatten;
+  }
+
+  releaseN(n: number, __tsplusTrace?: string): UIO<void> {
+    const self = this;
+
+    /**
+     * @tsplus tailRec
+     */
+    function loop(
+      n: number,
+      state: Either<ImmutableQueue<[Future<never, any>, number]>, number>,
+      acc: UIO<void>,
+    ): [UIO<void>, Either<ImmutableQueue<[Future<never, any>, number]>, number>] {
+      state.concrete();
+      switch (state._tag) {
+        case EitherTag.Right: {
+          return [acc, Either.right(state.right + n)];
+        }
+        case EitherTag.Left: {
+          const waiter = state.left.dequeue;
+
+          Maybe.concrete(waiter);
+
+          switch (waiter._tag) {
+            case MaybeTag.Nothing: {
+              return [acc, Either.right(self.permits)];
+            }
+            case MaybeTag.Just: {
+              const [[future, permits], queue] = waiter.value;
+              if (n > permits) {
+                return loop(n - permits, Either.left(queue), acc.zipLeft(future.succeed(undefined)));
+              } else if (n === permits) {
+                return [acc.zipRight(future.succeed().asUnit), Either.left(queue)];
+              } else {
+                return [acc, Either.left(queue.prepend([future, permits - n]))];
+              }
+            }
+          }
+        }
+      }
+    }
+
+    return this.ref.modify((state) => loop(n, state, IO.unit)).flatten;
+  }
+
+  tryWithPermits(permits: number) {
+    return <R, E, A>(io: IO<R, E, A>, __tsPlusTrace?: string): IO<R, E, Maybe<A>> => {
+      return this.tryReserve(permits).bracket(
+        (r) =>
+          r.match(
+            () => IO.nothing,
+            () => io.asJust,
+          ),
+        (r) =>
+          r.match(
+            () => Exit.unit,
+            (reservation) => reservation.release,
+          ),
+      );
+    };
+  }
+
+  tryWithPermit<R, E, A>(io: IO<R, E, A>): IO<R, E, Maybe<A>> {
+    return this.tryWithPermits(1)(io);
+  }
+
+  withPermits(permits: number) {
+    return <R, E, A>(io: IO<R, E, A>): IO<R, E, A> => {
+      return IO.bracket(
+        this.reserve(permits),
+        (reservation) => reservation.acquire > io,
+        (reservation) => reservation.release,
+      );
+    };
+  }
+
+  withPermit<R, E, A>(io: IO<R, E, A>): IO<R, E, A> {
+    return this.withPermits(1)(io);
+  }
+
+  withPermitsScoped(permits: number) {
+    return <R, E, A>(io: IO<R, E, A>): IO<Scope | R, E, A> => {
+      return IO.acquireRelease(this.reserve(permits), (reservation) => reservation.release).flatMap(
+        (reservation) => reservation.acquire > io,
+      );
+    };
+  }
+
+  withPermitScoped<R, E, A>(io: IO<R, E, A>): IO<Scope | R, E, A> {
+    return this.withPermitsScoped(1)(io);
+  }
+}

package/_src/Semaphore.ts

@@ -1,159 +1,5 @@
-import { EitherTag } from "@fncts/base/data/Either";
-import { IllegalArgumentError } from "@fncts/base/data/exceptions";
-
-/**
- * @tsplus type fncts.io.Semaphore
- * @tsplus companion fncts.io.SemaphoreOps
- */
-export class Semaphore {
-  constructor(readonly permits: number) {}
-
-  ref = Ref.unsafeMake<Either<ImmutableQueue<[Future<never, void>, number]>, number>>(Either.right(this.permits));
-
-  available(__tsplusTrace?: string): UIO<number> {
-    return this.ref.get.map((_) =>
-      _.match(
-        () => 0,
-        (permits) => permits,
-      ),
-    );
-  }
-
-  reserve(n: number, __tsplusTrace?: string): UIO<Reservation> {
-    if (n < 0) {
-      return IO.halt(new IllegalArgumentError(`Unexpected negative ${n} permits requested`, "Semaphore.reserve"));
-    } else if (n === 0) {
-      return IO.succeedNow(new Reservation(IO.unit, IO.unit));
-    } else {
-      return Future.make<never, void>().flatMap((future) =>
-        this.ref.modify((state) =>
-          state.match(
-            (queue) => [
-              new Reservation(future.await, this.restore(future, n)),
-              Either.left(queue.enqueue([future, n])),
-            ],
-            (permits) => {
-              if (permits >= n) {
-                return [new Reservation(IO.unit, this.releaseN(n)), Either.right(permits - n)];
-              } else {
-                return [
-                  new Reservation(future.await, this.restore(future, n)),
-                  Either.left(ImmutableQueue.single([future, n - permits])),
-                ];
-              }
-            },
-          ),
-        ),
-      );
-    }
-  }
-
-  restore(future: Future<never, void>, n: number, __tsplusTrace?: string): UIO<void> {
-    return this.ref.modify((state) =>
-      state.match(
-        (queue) =>
-          queue
-            .find(([waiter]) => waiter === future)
-            .match(
-              () => [this.releaseN(n), Either.left(queue)],
-              ([_, permits]) => [
-                this.releaseN(n - permits),
-                Either.left(queue.filter(([waiter]) => waiter !== future)),
-              ],
-            ),
-        (permits) => [IO.unit, Either.right(permits + n)],
-      ),
-    ).flatten;
-  }
-
-  releaseN(n: number, __tsplusTrace?: string): UIO<void> {
-    const self = this;
-
-    /**
-     * @tsplus tailRec
-     */
-    function loop(
-      n: number,
-      state: Either<ImmutableQueue<[Future<never, any>, number]>, number>,
-      acc: UIO<void>,
-    ): [UIO<void>, Either<ImmutableQueue<[Future<never, any>, number]>, number>] {
-      state.concrete();
-      switch (state._tag) {
-        case EitherTag.Right: {
-          return [acc, Either.right(state.right + n)];
-        }
-        case EitherTag.Left: {
-          const waiter = state.left.dequeue;
-
-          Maybe.concrete(waiter);
-
-          switch (waiter._tag) {
-            case MaybeTag.Nothing: {
-              return [acc, Either.right(self.permits)];
-            }
-            case MaybeTag.Just: {
-              const [[future, permits], queue] = waiter.value;
-              if (n > permits) {
-                return loop(n - permits, Either.left(queue), acc.zipLeft(future.succeed(undefined)));
-              } else if (n === permits) {
-                return [acc.zipRight(future.succeed().asUnit), Either.left(queue)];
-              } else {
-                return [acc, Either.left(queue.prepend([future, permits - n]))];
-              }
-            }
-          }
-        }
-      }
-    }
-
-    return this.ref.modify((state) => loop(n, state, IO.unit)).flatten;
-  }
-
-  withPermits(permits: number) {
-    return <R, E, A>(io: IO<R, E, A>): IO<R, E, A> => {
-      return IO.bracket(
-        this.reserve(permits),
-        (reservation) => reservation.acquire > io,
-        (reservation) => reservation.release,
-      );
-    };
-  }
-
-  withPermit<R, E, A>(io: IO<R, E, A>): IO<R, E, A> {
-    return this.withPermits(1)(io);
-  }
-
-  withPermitsScoped(permits: number) {
-    return <R, E, A>(io: IO<R, E, A>): IO<Scope | R, E, A> => {
-      return IO.acquireRelease(this.reserve(permits), (reservation) => reservation.release).flatMap(
-        (reservation) => reservation.acquire > io,
-      );
-    };
-  }
-
-  withPermitScoped<R, E, A>(io: IO<R, E, A>): IO<Scope | R, E, A> {
-    return this.withPermitsScoped(1)(io);
-  }
-}
-
-export class Reservation {
-  constructor(
-    readonly acquire: UIO<void>,
-    readonly release: UIO<void>,
-  ) {}
-}
-
-/**
- * @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));
-}
+// codegen:start { preset: barrel, include: ./Semaphore/*.ts }
+export * from "./Semaphore/constructors.js"
+export * from "./Semaphore/definition.js"
+export * from "./Semaphore/Reservation.js"
+// codegen:end