@fncts/io 0.0.48 → 0.0.49

package/IO/definition.d.ts

@@ -51,6 +51,7 @@ export declare namespace IO {
             _A: () => infer A;
         };
     }] ? A : never;
+    type Concrete = Primitive;
 }
 declare module "@fncts/base/data/Either/definition" {
     interface Either<E, A> extends IO<never, E, A> {
@@ -112,17 +113,14 @@ export declare const enum IOTag {
     Async = 3,
     OnSuccessAndFailure = 4,
     OnSuccess = 5,
-    OnFailure = 6,
-    UpdateRuntimeFlags = 7,
-    UpdateRuntimeFlagsWithin = 8,
-    GenerateStackTrace = 9,
-    Stateful = 10,
-    WhileLoop = 11,
-    YieldNow = 12,
-    Commit = 13,
-    RevertFlags = 14,
-    UpdateTrace = 15,
-    External = 16
+    UpdateRuntimeFlags = 6,
+    UpdateRuntimeFlagsWithin = 7,
+    Stateful = 8,
+    WhileLoop = 9,
+    YieldNow = 10,
+    Commit = 11,
+    UpdateTrace = 12,
+    External = 13
 }
 export type IOOp<Tag extends string | number, Body = {}> = IO<never, never, never> & Body & {
     readonly _ioOpCode: Tag;
@@ -142,7 +140,7 @@ export interface Sync<A = any> extends IOOp<IOTag.Sync, {
     readonly trace: string | undefined;
 }> {
 }
-export interface Async<R = any, E = any, A = any> extends IOOp<IOTag.Async, {
+export interface Async extends IOOp<IOTag.Async, {
     readonly i0: (resume: (io: Primitive) => void) => void;
     readonly i1: () => FiberId;
     readonly trace: string | undefined;
@@ -155,19 +153,13 @@ export interface OnSuccessAndFailure extends IOOp<IOTag.OnSuccessAndFailure, {
     readonly trace: string | undefined;
 }> {
 }
-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, {
     readonly i0: Primitive;
     readonly i1: (a: unknown) => Primitive;
     readonly trace: string | undefined;
 }> {
 }
-export interface SucceedNow extends IOOp<IOTag.SucceedNow, {
+export interface Succeed extends IOOp<IOTag.SucceedNow, {
     readonly i0: any;
     readonly trace: string | undefined;
 }> {
@@ -183,10 +175,6 @@ export interface UpdateRuntimeFlagsWithin extends IOOp<IOTag.UpdateRuntimeFlagsW
     readonly trace: string | undefined;
 }> {
 }
-export interface GenerateStackTrace extends IOOp<IOTag.GenerateStackTrace, {
-    readonly trace: string | undefined;
-}> {
-}
 export interface Stateful extends IOOp<IOTag.Stateful, {
     readonly i0: (fiber: FiberRuntime<any, any>, status: Running) => Primitive;
     readonly trace: string | undefined;
@@ -208,14 +196,13 @@ export interface Fail extends IOOp<IOTag.Fail, {
     readonly trace: string | undefined;
 }> {
 }
-export type Primitive = OnSuccessAndFailure | OnFailure | OnSuccess | UpdateRuntimeFlagsWithin | Sync | Async | SucceedNow | UpdateRuntimeFlags | GenerateStackTrace | Stateful | WhileLoop | YieldNow | Fail | External<any, any, any> | STM<any, any, any> | Left<any> | Right<any> | Nothing | Just<any> | Failure<any> | Success<any> | Tag<any>;
+export type Primitive = OnSuccessAndFailure | OnSuccess | UpdateRuntimeFlagsWithin | Sync | Async | Succeed | UpdateRuntimeFlags | Stateful | WhileLoop | YieldNow | Fail | External<any, any, any> | STM<any, any, any> | Left<any> | Right<any> | Nothing | Just<any> | Failure<any> | Success<any> | Tag<any>;
 /**
  * @tsplus static fncts.io.IOOps concrete
  * @tsplus macro identity
  * @tsplus location "@fncts/io/IO/definition"
  */
 export declare function concrete(io: IO<any, any, any>): Primitive;
-export type EvaluationStep = OnSuccessAndFailure | OnFailure | OnSuccess;
 export type Canceler<R> = URIO<R, void>;
 export declare abstract class External<R, E, A> extends IOPrimitive implements IO<R, E, A> {
     _ioOpCode: IOTag.External;

package/IO.d.ts

@@ -8,11 +8,14 @@ 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";
@@ -51,7 +54,6 @@ 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";

package/Random/definition.d.ts

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

package/Ref/Synchronized/api.d.ts

@@ -81,7 +81,7 @@ export declare function modifyJustIO<A, R1, E1, B>(def: B, f: (a: A) => Maybe<IO
  * @tsplus pipeable fncts.io.Ref.Synchronized updateAndGetIO
  * @tsplus location "@fncts/io/Ref/Synchronized/api"
  */
-export declare function updateAndGetIO<A, R1, E1>(f: (a: A) => IO<R1, E1, A>, __tsplusTrace?: string): <RA, RB, EA, EB>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>) => IO<RA | RB | R1, E1 | EA | EB, void>;
+export declare function updateAndGetIO<A, R1, E1>(f: (a: A) => IO<R1, E1, A>, __tsplusTrace?: string): <RA, RB, EA, EB>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>) => IO<RA | RB | R1, E1 | EA | EB, A>;
 /**
  * Atomically modifies the `Synchronized` with the specified function.
  * @tsplus pipeable fncts.io.Ref.Synchronized updateIO

package/Semaphore/Reservation.d.ts

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

package/Semaphore/constructors.d.ts

@@ -0,0 +1,13 @@
+import { Semaphore } from "@fncts/io/Semaphore";
+import { UIO } from "@fncts/io/IO/definition";
+/**
+ * @tsplus static fncts.io.SemaphoreOps unsafeMake
+ * @tsplus location "@fncts/io/Semaphore/constructors"
+ */
+export declare function unsafeMakeSemaphore(permits: number): Semaphore;
+/**
+ * @tsplus static fncts.io.SemaphoreOps make
+ * @tsplus static fncts.io.SemaphoreOps __call
+ * @tsplus location "@fncts/io/Semaphore/constructors"
+ */
+export declare function makeSemaphore(permits: number, __tsplusTrace?: string): UIO<Semaphore>;

package/Semaphore/definition.d.ts

@@ -0,0 +1,29 @@
+import { Ref } from "@fncts/io/Ref/definition";
+import { Either } from "@fncts/base/data/Either/definition";
+import { ImmutableQueue } from "@fncts/base/collection/immutable/Queue/definition";
+import { Future } from "@fncts/io/Future";
+import { UIO, IO } from "@fncts/io/IO/definition";
+import { Maybe, Just, Nothing, MaybeTag } from "@fncts/base/data/Maybe/definition";
+import { Exit } from "@fncts/base/data/Exit/definition";
+import { Scope } from "@fncts/io/Scope/definition";
+import { Reservation } from "@fncts/io/Semaphore/Reservation";
+/**
+ * @tsplus type fncts.io.Semaphore
+ * @tsplus companion fncts.io.SemaphoreOps
+ */
+export declare class Semaphore {
+    readonly permits: number;
+    constructor(permits: number);
+    ref: import("../Ref").Ref.Atomic<import("@fncts/base/data/Either").Either<import("@fncts/base/collection/immutable/Queue").Queue<[import("../Future").Future<never, void>, number]>, number>>;
+    available(__tsplusTrace?: string): UIO<number>;
+    tryReserve(n: number, __tsplusTrace?: string): UIO<Maybe<Reservation>>;
+    reserve(n: number, __tsplusTrace?: string): UIO<Reservation>;
+    restore(future: Future<never, void>, n: number, __tsplusTrace?: string): UIO<void>;
+    releaseN(n: number, __tsplusTrace?: string): UIO<void>;
+    tryWithPermits(permits: number): <R, E, A>(io: IO<R, E, A>, __tsPlusTrace?: string) => IO<R, E, Maybe<A>>;
+    tryWithPermit<R, E, A>(io: IO<R, E, A>): IO<R, E, Maybe<A>>;
+    withPermits(permits: number): <R, E, A>(io: IO<R, E, A>) => IO<R, E, A>;
+    withPermit<R, E, A>(io: IO<R, E, A>): IO<R, E, A>;
+    withPermitsScoped(permits: number): <R, E, A>(io: IO<R, E, A>) => IO<Scope | R, E, A>;
+    withPermitScoped<R, E, A>(io: IO<R, E, A>): IO<Scope | R, E, A>;
+}

package/Semaphore.d.ts

@@ -1,40 +1,3 @@
-import { Ref } from "@fncts/io/Ref/definition";
-import { Either } from "@fncts/base/data/Either/definition";
-import { ImmutableQueue } from "@fncts/base/collection/immutable/Queue/definition";
-import { Future } from "@fncts/io/Future";
-import { UIO, IO } from "@fncts/io/IO/definition";
-import { Maybe, MaybeTag } from "@fncts/base/data/Maybe/definition";
-import { Scope } from "@fncts/io/Scope/definition";
-/**
- * @tsplus type fncts.io.Semaphore
- * @tsplus companion fncts.io.SemaphoreOps
- */
-export declare class Semaphore {
-    readonly permits: number;
-    constructor(permits: number);
-    ref: import("./Ref").Ref.Atomic<import("@fncts/base/data/Either").Either<import("@fncts/base/collection/immutable/Queue").Queue<[import("./Future").Future<never, void>, number]>, number>>;
-    available(__tsplusTrace?: string): UIO<number>;
-    reserve(n: number, __tsplusTrace?: string): UIO<Reservation>;
-    restore(future: Future<never, void>, n: number, __tsplusTrace?: string): UIO<void>;
-    releaseN(n: number, __tsplusTrace?: string): UIO<void>;
-    withPermits(permits: number): <R, E, A>(io: IO<R, E, A>) => IO<R, E, A>;
-    withPermit<R, E, A>(io: IO<R, E, A>): IO<R, E, A>;
-    withPermitsScoped(permits: number): <R, E, A>(io: IO<R, E, A>) => IO<Scope | R, E, A>;
-    withPermitScoped<R, E, A>(io: IO<R, E, A>): IO<Scope | R, E, A>;
-}
-export declare class Reservation {
-    readonly acquire: UIO<void>;
-    readonly release: UIO<void>;
-    constructor(acquire: UIO<void>, release: UIO<void>);
-}
-/**
- * @tsplus static fncts.io.SemaphoreOps unsafeMake
- * @tsplus location "@fncts/io/Semaphore"
- */
-export declare function unsafeMakeSemaphore(permits: number): Semaphore;
-/**
- * @tsplus static fncts.io.SemaphoreOps make
- * @tsplus static fncts.io.SemaphoreOps __call
- * @tsplus location "@fncts/io/Semaphore"
- */
-export declare function makeSemaphore(permits: number, __tsplusTrace?: string): UIO<Semaphore>;
+export * from "./Semaphore/constructors.js";
+export * from "./Semaphore/definition.js";
+export * from "./Semaphore/Reservation.js";