@fncts/io 0.0.48 → 0.0.50

package/Ref/definition.d.ts

@@ -65,6 +65,18 @@ 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 declare abstract class RefInternal<RA, RB, EA, EB, A, B> implements PRef<RA, RB, EA, EB, A, B>, ReadableRef<RB, EB, B>, WritableRef<RA, EA, A>, ModifiableRef<RA, RB, EA, EB, A, B> {
     readonly [RefTypeId]: RefTypeId;
     [RefVariance]: {

package/Scope/api.d.ts

@@ -1,8 +1,8 @@
 import { Lazy } from "@fncts/base/data/function/definition";
 import { UIO, IO } from "@fncts/io/IO/definition";
 import { Scope } from "@fncts/io/Scope/definition";
-import { Finalizer } from "@fncts/io/Scope/Finalizer";
 import { Exit } from "@fncts/base/data/Exit/definition";
+import { Finalizer } from "@fncts/io/Scope/Finalizer";
 import { ExecutionStrategy } from "@fncts/base/data/ExecutionStrategy";
 import { Closeable } from "./definition.js";
 /**
@@ -15,6 +15,11 @@ export declare function addFinalizer(finalizer: Lazy<UIO<any>>, __tsplusTrace?:
  * @tsplus location "@fncts/io/Scope/api"
  */
 export declare function makeAddFinalizer(finalizer: Lazy<UIO<void>>, __tsplusTrace?: string): IO<Scope, never, void>;
+/**
+ * @tsplus static fncts.io.ScopeOps addFinalizerExit
+ * @tsplus location "@fncts/io/Scope/api"
+ */
+export declare function makeAddFinalizerExit(finalizer: (exit: Exit<any, any>) => UIO<any>, __tsplusTrace?: string): IO<Scope, never, void>;
 /**
  * @tsplus static fncts.io.ScopeOps concurrent
  * @tsplus static fncts.io.Scope.CloseableOps concurrent
@@ -63,3 +68,13 @@ export declare function unsafeMakeWith(executionStrategy: ExecutionStrategy, __t
  * @tsplus location "@fncts/io/Scope/api"
  */
 export declare function use<R, E, A>(io: Lazy<IO<R, E, A>>, __tsplusTrace?: string): (self: Scope.Closeable) => IO<Exclude<R, Scope>, E, A>;
+/**
+ * @tsplus getter fncts.io.Scope awaitClose
+ * @tsplus location "@fncts/io/Scope/api"
+ */
+export declare function awaitClose(scope: Scope): UIO<void>;
+/**
+ * @tsplus static fncts.io.ScopeOps awaitClose
+ * @tsplus location "@fncts/io/Scope/api"
+ */
+export declare const wait: IO<Scope, never, void>;

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";

package/Sink/definition.d.ts

@@ -2,14 +2,13 @@ import { Channel } from "@fncts/io/Channel";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
 /**
  * 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 declare class Sink<R, E, In, L, Z> {
-    readonly channel: Channel<R, never, Conc<In>, unknown, E, Conc<L>, Z>;
-    constructor(channel: Channel<R, never, Conc<In>, unknown, E, Conc<L>, Z>);
+export declare class Sink<Env, OutErr, In, Out, Done> {
+    readonly channel: Channel<Env, never, Conc<In>, unknown, OutErr, Conc<Out>, Done>;
+    constructor(channel: Channel<Env, never, Conc<In>, unknown, OutErr, Conc<Out>, Done>);
 }