@fncts/io 0.0.19 → 0.0.21

package/Stream/internal/DebounceState.d.ts

@@ -51,11 +51,11 @@ export declare function previous<A>(fiber: Fiber<never, Conc<A>>): DebounceState
  */
 export declare function current<E, A>(fiber: Fiber<E, HandoffSignal<E, A>>): DebounceState<E, A>;
 /**
- * @tsplus fluent fncts.io.Stream.DebounceState match
+ * @tsplus pipeable fncts.io.Stream.DebounceState match
  * @tsplus location "@fncts/io/Stream/internal/DebounceState"
  */
-export declare function match_<E, A, B, C, D>(ds: DebounceState<E, A>, cases: {
+export declare function match<E, A, B, C, D>(cases: {
     NotStarted: (_: NotStarted) => B;
     Current: (_: Current<E, A>) => C;
     Previous: (_: Previous<A>) => D;
-}): B | C | D;
+}): (ds: DebounceState<E, A>) => B | C | D;

package/Stream/internal/Handoff.d.ts

@@ -36,10 +36,10 @@ export type State<A> = Empty | Full<A>;
  */
 export declare function make<A>(): UIO<Handoff<A>>;
 /**
- * @tsplus fluent fncts.io.Stream.Handoff offer
+ * @tsplus pipeable fncts.io.Stream.Handoff offer
  * @tsplus location "@fncts/io/Stream/internal/Handoff"
  */
-export declare function offer<A>(handoff: Handoff<A>, a: A): UIO<void>;
+export declare function offer<A>(a: A): (handoff: Handoff<A>) => import("../../IO.js").UIO<void>;
 /**
  * @tsplus getter fncts.io.Stream.Handoff take
  * @tsplus location "@fncts/io/Stream/internal/Handoff"
@@ -101,11 +101,11 @@ export declare function halt<E>(error: Cause<E>): HandoffSignal<E, never>;
  */
 export declare function end<C>(reason: SinkEndReason): HandoffSignal<never, never>;
 /**
- * @tsplus fluent fncts.io.Stream.HandoffSignal match
+ * @tsplus pipeable fncts.io.Stream.HandoffSignal match
  * @tsplus location "@fncts/io/Stream/internal/Handoff"
  */
-export declare function matchSignal_<E, A, B, D, F>(signal: HandoffSignal<E, A>, cases: {
+export declare function matchSignal<E, A, B, D, F>(cases: {
     Emit: (_: Emit<A>) => B;
     Halt: (_: Halt<E>) => D;
     End: (_: End) => F;
-}): B | D | F;
+}): (signal: HandoffSignal<E, A>) => B | D | F;

package/Stream/internal/Pull.d.ts

@@ -1,8 +1,8 @@
 import { IO, UIO, FIO } from "@fncts/io/IO/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { Dequeue } from "@fncts/io/Queue/definition";
 import { Cause } from "@fncts/base/data/Cause/definition";
-import type { Queue } from "../../Queue.js";
 import type { Take } from "./Take.js";
 export type Pull<R, E, A> = IO<R, Maybe<E>, Conc<A>>;
 /**
@@ -25,7 +25,7 @@ export declare function emitChunk<A>(as: Conc<A>): UIO<Conc<A>>;
  * @tsplus static fncts.io.Stream.PullOps fromQueue
  * @tsplus location "@fncts/io/Stream/internal/Pull"
  */
-export declare function fromQueue<E, A>(d: Queue.Dequeue<Take<E, A>>): FIO<Maybe<E>, Conc<A>>;
+export declare function fromQueue<E, A>(d: Dequeue<Take<E, A>>): FIO<Maybe<E>, Conc<A>>;
 /**
  * @tsplus static fncts.io.Stream.PullOps fail
  * @tsplus location "@fncts/io/Stream/internal/Pull"

package/Stream/internal/SinkEndReason.d.ts

@@ -18,10 +18,10 @@ export declare class UpstreamEnd {
  */
 export type SinkEndReason = ScheduleEnd | UpstreamEnd;
 /**
- * @tsplus fluent fncts.io.Stream.SinkEndReason match
+ * @tsplus pipeable fncts.io.Stream.SinkEndReason match
  * @tsplus location "@fncts/io/Stream/internal/SinkEndReason"
  */
-export declare function matchSinkEndReason_<A, B>(self: SinkEndReason, cases: {
+export declare function matchSinkEndReason<A, B>(cases: {
     ScheduleEnd: (_: ScheduleEnd) => A;
     UpstreamEnd: (_: UpstreamEnd) => B;
-}): A | B;
+}): (self: SinkEndReason) => A | B;

package/Stream/internal/Take.d.ts

@@ -27,19 +27,19 @@ export declare function done<E, A>(self: Take<E, A>): FIO<Maybe<E>, Conc<A>>;
 /**
  * Folds over the failure cause, success value and end-of-stream marker to
  * yield a value.
- * @tsplus fluent fncts.io.Stream.Take match
+ * @tsplus pipeable fncts.io.Stream.Take match
  * @tsplus location "@fncts/io/Stream/internal/Take"
  */
-export declare function match_<E, A, Z>(self: Take<E, A>, end: Z, error: (cause: Cause<E>) => Z, value: (chunk: Conc<A>) => Z): Z;
+export declare function match<E, A, Z>(end: Z, error: (cause: Cause<E>) => Z, value: (chunk: Conc<A>) => Z): (self: Take<E, A>) => Z;
 /**
  * Effectful version of `Take#fold`.
  *
  * Folds over the failure cause, success value and end-of-stream marker to
  * yield an effect.
- * @tsplus fluent fncts.io.Stream.Take matchIO
+ * @tsplus pipeable fncts.io.Stream.Take matchIO
  * @tsplus location "@fncts/io/Stream/internal/Take"
  */
-export declare function matchIO_<R, R1, R2, E, E1, E2, E3, A, Z>(self: Take<E, A>, end: IO<R, E1, Z>, error: (cause: Cause<E>) => IO<R1, E2, Z>, value: (chunk: Conc<A>) => IO<R2, E3, Z>): IO<R | R1 | R2, E1 | E2 | E3, Z>;
+export declare function matchIO<R, R1, R2, E, E1, E2, E3, A, Z>(end: IO<R, E1, Z>, error: (cause: Cause<E>) => IO<R1, E2, Z>, value: (chunk: Conc<A>) => IO<R2, E3, Z>): (self: Take<E, A>) => IO<R | R1 | R2, E1 | E2 | E3, Z>;
 /**
  * Checks if this `take` is done (`Take.end`).
  * @tsplus getter fncts.io.Stream.Take isDone
@@ -60,16 +60,16 @@ export declare function isFailure<E, A>(self: Take<E, A>): boolean;
 export declare function isSuccess<E, A>(self: Take<E, A>): boolean;
 /**
  * Transforms `Take<E, A>` to `Take<E, B>` by applying function `f`.
- * @tsplus fluent fncts.io.Stream.Take map
+ * @tsplus pipeable fncts.io.Stream.Take map
  * @tsplus location "@fncts/io/Stream/internal/Take"
  */
-export declare function map_<E, A, B>(self: Take<E, A>, f: (a: A) => B): Take<E, B>;
+export declare function map<A, B>(f: (a: A) => B): <E>(self: Take<E, A>) => Take<E, B>;
 /**
  * Returns an effect that effectfully "peeks" at the success of this take.
- * @tsplus fluent fncts.io.Stream.Take tap
+ * @tsplus pipeable fncts.io.Stream.Take tap
  * @tsplus location "@fncts/io/Stream/internal/Take"
  */
-export declare function tap_<R, E, E1, A>(self: Take<E, A>, f: (chunk: Conc<A>) => IO<R, E1, any>): IO<R, E1, void>;
+export declare function tap<R, E1, A>(f: (chunk: Conc<A>) => IO<R, E1, any>): <E>(self: Take<E, A>) => IO<R, E1, void>;
 /**
  * Creates a `Take<never, A>` with a singleton chunk.
  * @tsplus static fncts.io.Stream.TakeOps single

package/SubscriptionRef.d.ts

@@ -0,0 +1,29 @@
+import { TSemaphore } from "@fncts/io/TSemaphore/definition";
+import { Hub } from "@fncts/io/Hub/definition";
+import { Ref } from "@fncts/io/Ref";
+import { UIO, IO } from "@fncts/io/IO/definition";
+import { Lazy } from "@fncts/base/data/function/definition";
+import { Synchronized } from "@fncts/io/Ref";
+import { Stream } from "@fncts/io/Stream";
+export declare const SubscriptionRefTypeId: unique symbol;
+export type SubscriptionRefTypeId = typeof SubscriptionRefTypeId;
+/**
+ * @tsplus type fncts.io.SubscriptionRef
+ * @tsplus companion fncts.io.SubscriptionRefOps
+ */
+export declare class SubscriptionRef<A> extends Synchronized<A> {
+    readonly semaphore: TSemaphore;
+    readonly hub: Hub<A>;
+    readonly ref: Ref<A>;
+    readonly [SubscriptionRefTypeId]: SubscriptionRefTypeId;
+    constructor(semaphore: TSemaphore, hub: Hub<A>, ref: Ref<A>);
+    changes: Stream<never, never, A>;
+    set(a: A, __tsplusTrace?: string): UIO<void>;
+    modifyIO<R1, E1, B>(f: (a: A) => IO<R1, E1, readonly [B, A]>, __tsplusTrace?: string): IO<R1, E1, B>;
+}
+/**
+ * @tsplus static fncts.io.SubscriptionRefOps make
+ * @tsplus static fncts.io.SubscriptionRefOps __call
+ * @tsplus location "@fncts/io/SubscriptionRef"
+ */
+export declare function make<A>(value: Lazy<A>): UIO<SubscriptionRef<A>>;

package/Supervisor/api.d.ts

@@ -1,11 +1,17 @@
 import { Supervisor } from "@fncts/io/Supervisor/definition";
-import { Environment } from "@fncts/base/data/Environment/definition";
-import { IO } from "@fncts/io/IO/definition";
-import { Maybe } from "@fncts/base/data/Maybe/definition";
-import { Fiber } from "@fncts/io/Fiber/definition";
-import { Exit } from "@fncts/base/data/Exit/definition";
+import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
 /**
- * @tsplus fluent fncts.io.Supervisor zip
+ * @tsplus pipeable fncts.io.Supervisor zip
  * @tsplus location "@fncts/io/Supervisor/api"
  */
-export declare function zip_<A, B>(fa: Supervisor<A>, fb: Supervisor<B>): Supervisor<readonly [A, B]>;
+export declare function zip<B>(fb: Supervisor<B>): <A>(fa: import("@fncts/io/Supervisor/definition").Supervisor<A>) => import("@fncts/io/Supervisor/definition").Supervisor<readonly [A, B]>;
+/**
+ * @tsplus getter fncts.io.Supervisor toSet
+ * @tsplus location "@fncts/io/Supervisor/api"
+ */
+export declare function toSet(self: Supervisor<any>): HashSet<Supervisor<any>>;
+/**
+ * @tsplus pipeable fncts.io.Supervisor removeSupervisor
+ * @tsplus location "@fncts/io/Supervisor/api"
+ */
+export declare function removeSupervisor(that: Supervisor<any>): (self: Supervisor<any>) => Supervisor<any>;

package/Supervisor/definition.d.ts

@@ -3,6 +3,12 @@ import { Environment } from "@fncts/base/data/Environment/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Fiber } from "@fncts/io/Fiber/definition";
 import { Exit } from "@fncts/base/data/Exit/definition";
+import type { SupervisorPatch } from "@fncts/io/SupervisorPatch";
+export declare const enum SupervisorTag {
+    Const = 0,
+    Proxy = 1,
+    Zip = 2
+}
 /**
  * @tsplus type fncts.io.Supervisor
  * @tsplus companion fncts.io.SupervisorOps
@@ -15,8 +21,12 @@ export declare abstract class Supervisor<A> {
     unsafeOnSuspend<E, A>(_fiber: Fiber.Runtime<E, A>): void;
     unsafeOnResume<E, A>(_fiber: Fiber.Runtime<E, A>): void;
 }
+export declare namespace Supervisor {
+    type Patch = SupervisorPatch;
+}
 export declare class ConstSupervisor<A> extends Supervisor<A> {
     readonly value: UIO<A>;
+    readonly _tag = SupervisorTag.Const;
     constructor(value: UIO<A>);
     unsafeOnStart(): void;
     unsafeOnEnd(): void;
@@ -27,6 +37,7 @@ export declare class ConstSupervisor<A> extends Supervisor<A> {
 export declare class ProxySupervisor<A> extends Supervisor<A> {
     readonly value: UIO<A>;
     readonly underlying: Supervisor<any>;
+    readonly _tag = SupervisorTag.Proxy;
     constructor(value: UIO<A>, underlying: Supervisor<any>);
     unsafeOnStart<R, E, A>(environment: Environment<R>, effect: IO<R, E, A>, parent: Maybe<Fiber.Runtime<E, A>>, fiber: Fiber.Runtime<E, A>): void;
     unsafeOnEnd<E, A>(value: Exit<E, A>, fiber: Fiber.Runtime<E, A>): void;
@@ -34,3 +45,20 @@ export declare class ProxySupervisor<A> extends Supervisor<A> {
     unsafeOnSuspend<E, A>(fiber: Fiber.Runtime<E, A>): void;
     unsafeOnResume<E, A>(fiber: Fiber.Runtime<E, A>): void;
 }
+export declare class Zip<A, B> extends Supervisor<readonly [A, B]> {
+    readonly first: Supervisor<A>;
+    readonly second: Supervisor<B>;
+    readonly _tag = SupervisorTag.Zip;
+    constructor(first: Supervisor<A>, second: Supervisor<B>);
+    value: import("../IO").IO<never, never, readonly [A, B]>;
+    unsafeOnStart<R, E, A>(environment: Environment<R>, effect: IO<R, E, A>, parent: Maybe<Fiber.Runtime<any, any>>, fiber: Fiber.Runtime<E, A>): void;
+    unsafeOnEnd<E, A>(value: Exit<E, A>, fiber: Fiber.Runtime<E, A>): void;
+    unsafeOnEffect<E, A>(fiber: Fiber.Runtime<E, A>, effect: IO<any, any, any>): void;
+    unsafeOnSuspend<E, A>(fiber: Fiber.Runtime<E, A>): void;
+    unsafeOnResume<E, A>(fiber: Fiber.Runtime<E, A>): void;
+}
+export type Concrete = ConstSupervisor<any> | ProxySupervisor<any> | Zip<any, any>;
+/**
+ * @tsplus macro remove
+ */
+export declare function concrete(_: Supervisor<any>): asserts _ is Concrete;

package/SupervisorPatch.d.ts

@@ -0,0 +1,61 @@
+import { Supervisor } from "@fncts/io/Supervisor/definition";
+import { List } from "@fncts/base/collection/immutable/List/definition";
+export declare const SupervisorPatchTypeId: unique symbol;
+export type SupervisorPatchTypeId = typeof SupervisorPatchTypeId;
+export declare const enum SupervisorPatchTag {
+    AddSupervisor = 0,
+    Combine = 1,
+    Empty = 2,
+    RemoveSupervisor = 3
+}
+/**
+ * @tsplus type fncts.io.SupervisorPatch
+ * @tsplus companion fncts.io.SupervisorPatchOps
+ */
+export declare abstract class SupervisorPatch {
+    readonly _typeId: SupervisorPatchTypeId;
+}
+export declare class AddSupervisor extends SupervisorPatch {
+    readonly supervisor: Supervisor<any>;
+    readonly _tag = SupervisorPatchTag.AddSupervisor;
+    constructor(supervisor: Supervisor<any>);
+}
+export declare class Combine extends SupervisorPatch {
+    readonly first: SupervisorPatch;
+    readonly second: SupervisorPatch;
+    readonly _tag = SupervisorPatchTag.Combine;
+    constructor(first: SupervisorPatch, second: SupervisorPatch);
+}
+export declare class Empty extends SupervisorPatch {
+    readonly _tag = SupervisorPatchTag.Empty;
+}
+export declare class RemoveSupervisor extends SupervisorPatch {
+    readonly supervisor: Supervisor<any>;
+    readonly _tag = SupervisorPatchTag.RemoveSupervisor;
+    constructor(supervisor: Supervisor<any>);
+}
+export type Concrete = AddSupervisor | Combine | Empty | RemoveSupervisor;
+/**
+ * @tsplus macro remove
+ */
+export declare function concrete(_: SupervisorPatch): asserts _ is Concrete;
+/**
+ * @tsplus static fncts.io.SupervisorPatchOps empty
+ * @tsplus location "@fncts/io/SupervisorPatch"
+ */
+export declare const empty: SupervisorPatch;
+/**
+ * @tsplus pipeable fncts.io.SupervisorPatch combine
+ * @tsplus location "@fncts/io/SupervisorPatch"
+ */
+export declare function combine(second: SupervisorPatch): (first: SupervisorPatch) => SupervisorPatch;
+/**
+ * @tsplus static fncts.io.SupervisorPatchOps diff
+ * @tsplus location "@fncts/io/SupervisorPatch"
+ */
+export declare function diff(oldValue: Supervisor<any>, newValue: Supervisor<any>): SupervisorPatch;
+/**
+ * @tsplus pipeable fncts.io.SupervisorPatch __call
+ * @tsplus location "@fncts/io/SupervisorPatch"
+ */
+export declare function apply(supervisor: Supervisor<any>): (self: SupervisorPatch) => Supervisor<any>;

package/TFuture/api.d.ts

@@ -1,27 +1,27 @@
-import { TFuture } from "@fncts/io/TFuture/definition";
 import { Either } from "@fncts/base/data/Either/definition";
+import { TFuture } from "@fncts/io/TFuture/definition";
 import { USTM, STM } from "@fncts/io/STM/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 /**
- * @tsplus fluent fncts.io.TFuture done
+ * @tsplus pipeable fncts.io.TFuture done
  * @tsplus location "@fncts/io/TFuture/api"
  */
-export declare function done_<E, A>(self: TFuture<E, A>, v: Either<E, A>, __tsplusTrace?: string): USTM<boolean>;
+export declare function done<E, A>(v: Either<E, A>, __tsplusTrace?: string): (self: TFuture<E, A>) => USTM<boolean>;
 /**
- * @tsplus fluent fncts.io.TFuture fail
+ * @tsplus pipeable fncts.io.TFuture fail
  * @tsplus location "@fncts/io/TFuture/api"
  */
-export declare function fail_<E, A>(self: TFuture<E, A>, e: E, __tsplusTrace?: string): USTM<boolean>;
+export declare function fail<E>(e: E, __tsplusTrace?: string): <A>(self: import("./definition").TFuture<E, A>) => USTM<boolean>;
 /**
  * @tsplus getter fncts.io.TFuture poll
  * @tsplus location "@fncts/io/TFuture/api"
  */
 export declare function poll<E, A>(self: TFuture<E, A>, __tsplusTrace?: string): USTM<Maybe<Either<E, A>>>;
 /**
- * @tsplus fluent fncts.io.TFuture succeed
+ * @tsplus pipeable fncts.io.TFuture succeed
  * @tsplus location "@fncts/io/TFuture/api"
  */
-export declare function succeed_<E, A>(self: TFuture<E, A>, a: A, __tsplusTrace?: string): USTM<boolean>;
+export declare function succeed<A>(a: A, __tsplusTrace?: string): <E>(self: import("./definition").TFuture<E, A>) => USTM<boolean>;
 /**
  * @tsplus getter fncts.io.TFuture await
  * @tsplus location "@fncts/io/TFuture/api"

package/TReentrantLock/api.d.ts

@@ -40,15 +40,15 @@ export declare function releaseRead(self: TReentrantLock, __tsplusTrace?: string
  */
 export declare function releaseWrite(self: TReentrantLock, __tsplusTrace?: string): USTM<number>;
 /**
- * @tsplus fluent fncts.io.TReentrantLock withReadLock
+ * @tsplus pipeable fncts.io.TReentrantLock withReadLock
  * @tsplus location "@fncts/io/TReentrantLock/api"
  */
-export declare function withReadLock<R, E, A>(self: TReentrantLock, io: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
+export declare function withReadLock<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): (self: TReentrantLock) => IO<R, E, A>;
 /**
- * @tsplus fluent fncts.io.TReentrantLock withWriteLock
+ * @tsplus pipeable fncts.io.TReentrantLock withWriteLock
  * @tsplus location "@fncts/io/TReentrantLock/api"
  */
-export declare function withWriteLock<R, E, A>(self: TReentrantLock, io: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
+export declare function withWriteLock<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): (self: TReentrantLock) => IO<R, E, A>;
 /**
  * @tsplus getter fncts.io.TReentrantLock readLock
  * @tsplus location "@fncts/io/TReentrantLock/api"

package/TRef/api.d.ts

@@ -12,74 +12,74 @@ export declare function get<EA, EB, A, B>(self: TRef<EA, EB, A, B>, __tsplusTrac
 /**
  * Updates the value of the variable, returning a function of the specified
  * value.
- * @tsplus fluent fncts.io.TRef modify
+ * @tsplus pipeable fncts.io.TRef modify
  * @tsplus location "@fncts/io/TRef/api"
  */
-export declare function modify_<E, A, B>(self: TRef<E, E, A, A>, f: (a: A) => readonly [B, A], __tsplusTrace?: string): STM<never, E, B>;
+export declare function modify<A, B>(f: (a: A) => readonly [B, A], __tsplusTrace?: string): <E>(self: TRef<E, E, A, A>) => import("../STM/definition.js").STM<never, E, B>;
 /**
  * Sets the value of the `TRef`.
- * @tsplus fluent fncts.io.TRef set
+ * @tsplus pipeable fncts.io.TRef set
  * @tsplus location "@fncts/io/TRef/api"
  */
-export declare function set_<EA, EB, A, B>(self: TRef<EA, EB, A, B>, a: A, __tsplusTrace?: string): STM<never, EA, void>;
+export declare function set<A>(a: A, __tsplusTrace?: string): <EA, EB, B>(self: TRef<EA, EB, A, B>) => import("../STM/definition.js").STM<never, EA, void>;
 /**
  * Unsafely retrieves the value of the `TRef`.
- * @tsplus fluent fncts.io.TRef unsafeGet
+ * @tsplus pipeable fncts.io.TRef unsafeGet
  * @tsplus location "@fncts/io/TRef/api"
  */
-export declare function unsafeGet_<EA, EB, A, B>(self: TRef<EA, EB, A, B>, journal: Journal, __tsplusTrace?: string): A;
+export declare function unsafeGet(journal: Journal, __tsplusTrace?: string): <EA, EB, A, B>(self: TRef<EA, EB, A, B>) => A;
 /**
  * Updates the value of the variable, returning a function of the specified
  * value.
- * @tsplus fluent fncts.io.TRef modifyJust
+ * @tsplus pipeable fncts.io.TRef modifyJust
  * @tsplus location "@fncts/io/TRef/api"
  */
-export declare function modifyJust_<E, A, B>(self: TRef<E, E, A, A>, b: B, f: (a: A) => Maybe<readonly [B, A]>, __tsplusTrace?: string): STM<never, E, B>;
+export declare function modifyJust<A, B>(b: B, f: (a: A) => Maybe<readonly [B, A]>, __tsplusTrace?: string): <E>(self: TRef<E, E, A, A>) => import("../STM/definition.js").STM<never, E, B>;
 /**
  * Sets the value of the `TRef` and returns the old value.
- * @tsplus fluent fncts.io.TRef getAndSet
+ * @tsplus pipeable fncts.io.TRef getAndSet
  * @tsplus location "@fncts/io/TRef/api"
  */
-export declare function getAndSet_<E, A>(self: TRef<E, E, A, A>, a: A, __tsplusTrace?: string): STM<never, E, A>;
+export declare function getAndSet<A>(a: A, __tsplusTrace?: string): <E>(self: TRef<E, E, A, A>) => import("../STM/definition.js").STM<never, E, A>;
 /**
  * Updates the value of the variable and returns the old value.
- * @tsplus fluent fncts.io.TRef getAndUpdate
+ * @tsplus pipeable fncts.io.TRef getAndUpdate
  * @tsplus location "@fncts/io/TRef/api"
  */
-export declare function getAndUpdate_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => A, __tsplusTrace?: string): STM<never, E, A>;
+export declare function getAndUpdate<A>(f: (a: A) => A, __tsplusTrace?: string): <E>(self: TRef<E, E, A, A>) => import("../STM/definition.js").STM<never, E, A>;
 /**
  * Updates some values of the variable but leaves others alone, returning the
  * old value.
- * @tsplus fluent fncts.io.TRef getAndUpdateJust
+ * @tsplus pipeable fncts.io.TRef getAndUpdateJust
  * @tsplus location "@fncts/io/TRef/api"
  */
-export declare function getAndUpdateJust_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => Maybe<A>, __tsplusTrace?: string): STM<never, E, A>;
+export declare function getAndUpdateJust<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string): <E>(self: TRef<E, E, A, A>) => import("../STM/definition.js").STM<never, E, A>;
 /**
  * Updates the value of the variable.
- * @tsplus fluent fncts.io.TRef update
+ * @tsplus pipeable fncts.io.TRef update
  * @tsplus location "@fncts/io/TRef/api"
  */
-export declare function update_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => A, __tsplusTrace?: string): STM<never, E, void>;
+export declare function update<A>(f: (a: A) => A, __tsplusTrace?: string): <E>(self: TRef<E, E, A, A>) => import("../STM/definition.js").STM<never, E, void>;
 /**
  * Updates some values of the variable but leaves others alone.
- * @tsplus fluent fncts.io.TRef updateJust
+ * @tsplus pipeable fncts.io.TRef updateJust
  * @tsplus location "@fncts/io/TRef/api"
  */
-export declare function updateJust_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => Maybe<A>, __tsplusTrace?: string): STM<never, E, void>;
+export declare function updateJust<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string): <E>(self: TRef<E, E, A, A>) => import("../STM/definition.js").STM<never, E, void>;
 /**
  * Updates the value of the variable and returns the new value.
- * @tsplus fluent fncts.io.TRef updateAndGet
+ * @tsplus pipeable fncts.io.TRef updateAndGet
  * @tsplus location "@fncts/io/TRef/api"
  */
-export declare function updateAndGet_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => A, __tsplusTrace?: string): STM<never, E, A>;
+export declare function updateAndGet<A>(f: (a: A) => A, __tsplusTrace?: string): <E>(self: TRef<E, E, A, A>) => import("../STM/definition.js").STM<never, E, A>;
 /**
  * Updates some values of the variable but leaves others alone.
- * @tsplus fluent fncts.io.TRef updateJustAndGet
+ * @tsplus pipeable fncts.io.TRef updateJustAndGet
  * @tsplus location "@fncts/io/TRef/api"
  */
-export declare function updateJustAndGet_<E, A>(self: TRef<E, E, A, A>, f: (a: A) => Maybe<A>, __tsplusTrace?: string): STM<never, E, A>;
+export declare function updateJustAndGet<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string): <E>(self: TRef<E, E, A, A>) => import("../STM/definition.js").STM<never, E, A>;
 /**
- * @tsplus fluent fncts.io.TRef unsafeSet
+ * @tsplus pipeable fncts.io.TRef unsafeSet
  * @tsplus location "@fncts/io/TRef/api"
  */
-export declare function unsafeSet_<EA, EB, A, B>(self: TRef<EA, EB, A, B>, journal: Journal, a: A, __tsplusTrace?: string): void;
+export declare function unsafeSet<A>(journal: Journal, a: A, __tsplusTrace?: string): <EA, EB, B>(self: TRef<EA, EB, A, B>) => void;

package/TSemaphore/api.d.ts

@@ -7,10 +7,10 @@ import { IO } from "@fncts/io/IO/definition";
  */
 export declare function acquire(self: TSemaphore, __tsplusTrace?: string): USTM<void>;
 /**
- * @tsplus fluent fncts.io.TSemaphore acquireN
+ * @tsplus pipeable fncts.io.TSemaphore acquireN
  * @tsplus location "@fncts/io/TSemaphore/api"
  */
-export declare function acquireN_(self: TSemaphore, n: number, __tsplusTrace?: string): USTM<void>;
+export declare function acquireN(n: number, __tsplusTrace?: string): (self: TSemaphore) => USTM<void>;
 /**
  * @tsplus getter fncts.io.TSemaphore available
  * @tsplus location "@fncts/io/TSemaphore/api"
@@ -22,10 +22,10 @@ export declare function available(self: TSemaphore, __tsplusTrace?: string): UST
  */
 export declare function release(self: TSemaphore, __tsplusTrace?: string): USTM<void>;
 /**
- * @tsplus fluent fncts.io.TSemaphore releaseN
+ * @tsplus pipeable fncts.io.TSemaphore releaseN
  * @tsplus location "@fncts/io/TSemaphore/api"
  */
-export declare function releaseN_(self: TSemaphore, n: number, __tsplusTrace?: string): USTM<void>;
+export declare function releaseN(n: number, __tsplusTrace?: string): (self: TSemaphore) => USTM<void>;
 /**
  * @tsplus getter fncts.io.TSemaphore withPermits
  * @tsplus location "@fncts/io/TSemaphore/api"

package/TSemaphore/constructors.d.ts

@@ -1,11 +1,17 @@
 import { USTM } from "@fncts/io/STM/definition";
 import { TSemaphore } from "@fncts/io/TSemaphore/definition";
+import { UIO } from "@fncts/io/IO/definition";
 /**
  * @tsplus static fncts.io.TSemaphoreOps __call
  * @tsplus static fncts.io.TSemaphoreOps make
  * @tsplus location "@fncts/io/TSemaphore/constructors"
  */
 export declare function make(permits: number, __tsplusTrace?: string): USTM<TSemaphore>;
+/**
+ * @tsplus static fncts.io.TSemaphoreOps makeCommit
+ * @tsplus location "@fncts/io/TSemaphore/constructors"
+ */
+export declare function makeCommit(permits: number, __tsplusTrace?: string): UIO<TSemaphore>;
 /**
  * @tsplus static fncts.io.TSemaphoreOps unsafeMake
  * @tsplus location "@fncts/io/TSemaphore/constructors"

package/_cjs/Cached/api.cjs

@@ -4,8 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.auto = auto;
-exports.get_ = get_;
-exports.refresh_ = exports.manual = void 0;
+exports.get = get;
+exports.refresh = exports.manual = void 0;
 
 var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/IO/api/schedule"));
 
@@ -36,21 +36,21 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj &&
 const fileName_1 = "(@fncts/io) src/Cached/api.ts";
 const manual = manual_1;
 exports.manual = manual;
-const refresh_ = refresh_1;
-exports.refresh_ = refresh_;
+const refresh = refresh_1;
+exports.refresh = refresh;
 
 /**
  * @tsplus static fncts.io.CachedOps auto
  */
 function auto(acquire, policy, __tsplusTrace) {
-  return tsplus_module_6.flatMap_(manual_1(acquire, __tsplusTrace), manual => tsplus_module_6.map_(tsplus_module_5.acquireRelease(() => tsplus_module_3.forkDaemon(tsplus_module_2.interruptible(tsplus_module_1.schedule(refresh_1(manual, __tsplusTrace), () => policy, __tsplusTrace), __tsplusTrace), __tsplusTrace), fiber => tsplus_module_4.interrupt(fiber, __tsplusTrace), __tsplusTrace), () => manual, __tsplusTrace), __tsplusTrace);
+  return tsplus_module_6.flatMap(manual => tsplus_module_6.map(() => manual, __tsplusTrace)(tsplus_module_5.acquireRelease(() => tsplus_module_3.forkDaemon(tsplus_module_2.interruptible(tsplus_module_1.schedule(() => policy, __tsplusTrace)(refresh_1(manual, __tsplusTrace)), __tsplusTrace), __tsplusTrace), fiber => tsplus_module_4.interrupt(fiber, __tsplusTrace), __tsplusTrace)), __tsplusTrace)(manual_1(acquire, __tsplusTrace));
 }
 /**
  * @tsplus getter fncts.io.Cached get
  */
 
 
-function get_(self, __tsplusTrace) {
+function get(self, __tsplusTrace) {
   void 0;
   return self.get;
 }
@@ -60,7 +60,7 @@ function get_(self, __tsplusTrace) {
 
 
 function manual_1(acquire, __tsplusTrace) {
-  return tsplus_module_6.flatMap_(tsplus_module_7.environment(__tsplusTrace), env => tsplus_module_6.map_(tsplus_module_8.fromAcquire(tsplus_module_6.result(acquire, __tsplusTrace), __tsplusTrace), ref => new Manual(ref, tsplus_module_7.provideEnvironment_(acquire, env, __tsplusTrace)), __tsplusTrace), __tsplusTrace);
+  return tsplus_module_6.flatMap(env => tsplus_module_6.map(ref => new Manual(ref, tsplus_module_7.provideEnvironment(env, __tsplusTrace)(acquire)), __tsplusTrace)(tsplus_module_8.fromAcquire(tsplus_module_6.result(acquire, __tsplusTrace), __tsplusTrace)), __tsplusTrace)(tsplus_module_7.environment(__tsplusTrace));
 }
 
 class Manual extends _internal.CachedInternal {
@@ -68,8 +68,8 @@ class Manual extends _internal.CachedInternal {
     super();
     this.ref = ref;
     this.acquire = acquire;
-    this.get = tsplus_module_6.flatMap_(this.ref.get, tsplus_module_6.fromExitNow, fileName_1 + ":45:51");
-    this.refresh = this.ref.set(tsplus_module_6.map_(this.acquire, tsplus_module_9.succeed, fileName_1 + ":46:60"), fileName_1 + ":46:43");
+    this.get = tsplus_module_6.flatMap(tsplus_module_6.fromExitNow, fileName_1 + ":45:51")(this.ref.get);
+    this.refresh = this.ref.set(tsplus_module_6.map(tsplus_module_9.succeed, fileName_1 + ":46:60")(this.acquire), fileName_1 + ":46:43");
   }
 
 }

package/_cjs/Cached/api.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"api.cjs","mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;AACA;;;;;;;MA4BgBA,MAAM;;MAsBNC,QAAQ;;;AAhDxB;;;AAGM,SAAUC,IAAV,CACJC,OADI,EAEJC,MAFI,EAGJC,aAHI,EAGkB;EAEtB,gCACmBC,SAAcH,OAAd,EAHnBE,aAGmB,CADnB,EACQL,MAAM,yBACVO,gEAAkBC,8BAAiBC,2CAJvCJ,aAIuC,GAJvC,MAI+DD,MAAxB,EAJvCC,aAIuC,CAAjB,EAJtBA,aAIsB,CAAlB,EAJJA,aAII,GAAiFK,KAAD,IAAUC,0BAACD,KAAD,EAJ9FL,aAI8F,CAA1F,EAJJA,aAII,CADU,EACiG,MACtGL,MAFK,EAHdK,aAGc,CADd,EAFAA,aAEA;AAKD;AAED;;;;;AAGM,SAAUO,IAAV,CAAgCC,IAAhC,EAA+DR,aAA/D,EAAqF;EACzF;EACA,OAAOQ,IAAI,CAACC,GAAZ;AACD;AAED;;;;;AAGA,kBACEX,OADF,EAEEE,aAFF,EAEwB;EAEtB,gCACgBU,4BAHhBV,aAGgB,CADhB,EACQW,GAAG,yBACKC,mDAAsBd,OAAtB,EAJhBE,aAIgB,GAJhBA,aAIgB,CADL,EACHa,GAAG,IACF,IAAIC,MAAJ,CAAWD,GAAX,EAAgBH,6CAA2BC,GAA3B,EALzBX,aAKyB,CAAhB,CAFE,EAHXA,aAGW,CADX,EAFAA,aAEA;AAKD;;AAED,MAAMc,MAAN,SAAsCC,wBAAtC,CAAqE;EACnEC,YAAqBH,GAArB,EAAqEf,OAArE,EAAwG;IACtG;IADmB;IAAgD;IAGrE,WAA4BmB,8BAAKJ,GAAL,CAASJ,GAAT,EAAYQ,2BAAZ,EAAYC,qBAAZ,CAA5B;IACA,eAA4B,KAAKL,GAAL,CAASM,GAAT,CAAaF,0BAAKnB,OAAL,EAAYsB,uBAAZ,EAAYF,qBAAZ,CAAb,EAA2CA,qBAA3C,CAA5B;EAFC;;AAHkE;AAQrE;;;;;AAGA,mBAA0CV,IAA1C,EAAyER,aAAzE,EAA+F;EAC7F;EACA,OAAOQ,IAAI,CAACa,OAAZ;AACD","names":["manual","refresh_","auto","acquire","policy","__tsplusTrace","manual_1","tsplus_module_5","tsplus_module_2","tsplus_module_1","fiber","tsplus_module_4","get_","self","get","tsplus_module_7","env","tsplus_module_8","ref","Manual","CachedInternal","constructor","tsplus_module_6","fileName_1","set","tsplus_module_9","refresh"],"sourceRoot":"","sources":["../../_src/Cached/api.ts"],"sourcesContent":[null]}
+{"version":3,"file":"api.cjs","mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;AACA;;;;;;;MA4BgBA,MAAM;;MAsBNC,OAAO;;;AAhDvB;;;AAGM,SAAUC,IAAV,CACJC,OADI,EAEJC,MAFI,EAGJC,aAHI,EAGkB;EAEtB,+BACQL,MAAM,8BAELA,MAFK,EAHdK,aAGc,EACVC,gEAAkBC,8BAAiBC,+BAAwBJ,MAAxB,EAJvCC,aAIuC,EAJvCI,UAIuCT,MAJvC,gBAIuC,CAAjB,EAJtBK,aAIsB,CAAlB,EAJJA,aAII,GAAiFK,KAAD,IAAUC,0BAACD,KAAD,EAJ9FL,aAI8F,CAA1F,EAJJA,aAII,CADU,CADd,EAFAA,aAEA,EACmBO,SAAcT,OAAd,EAHnBE,aAGmB,CADnB;AAKD;AAED;;;;;AAGM,SAAUQ,GAAV,CAA+BC,IAA/B,EAA8DT,aAA9D,EAAoF;EACxF;EACA,OAAOS,IAAI,CAACD,GAAZ;AACD;AAED;;;;;AAGA,kBACEV,OADF,EAEEE,aAFF,EAEwB;EAEtB,+BACQU,GAAG,wBACHC,GAAG,IACF,IAAIC,MAAJ,CAAWD,GAAX,EAAgBE,mCAA2BH,GAA3B,EALzBV,aAKyB,UAAhB,CAFE,EAHXA,aAGW,EACKc,mDAAsBhB,OAAtB,EAJhBE,aAIgB,GAJhBA,aAIgB,CADL,CADX,EAFAA,aAEA,EACgBa,4BAHhBb,aAGgB,CADhB;AAKD;;AAED,MAAMY,MAAN,SAAsCG,wBAAtC,CAAqE;EACnEC,YAAqBL,GAArB,EAAqEb,OAArE,EAAwG;IACtG;IADmB;IAAgD;IAGrE,WAA4BmB,iFAAKN,GAAL,CAASH,GAAT,CAA5B;IACA,eAA4B,KAAKG,GAAL,CAASO,GAAT,CAAaD,yEAAKnB,OAAL,CAAb,EAA2CqB,qBAA3C,CAA5B;EAFC;;AAHkE;AAQrE;;;;;AAGA,mBAAyCV,IAAzC,EAAwET,aAAxE,EAA8F;EAC5F;EACA,OAAOS,IAAI,CAACb,OAAZ;AACD","names":["manual","refresh","auto","acquire","policy","__tsplusTrace","tsplus_module_5","tsplus_module_2","tsplus_module_1","refresh_1","fiber","tsplus_module_4","manual_1","get","self","env","ref","Manual","tsplus_module_7","tsplus_module_8","CachedInternal","constructor","tsplus_module_6","set","fileName_1"],"sourceRoot":"","sources":["../../_src/Cached/api.ts"],"sourcesContent":[null]}

package/_cjs/Channel/ChildExecutorDecision/api.cjs

@@ -3,27 +3,29 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.match_ = match_;
+exports.match = match;
 
 /**
- * @tsplus fluent fncts.io.Channel.ChildExecutorDecision match
+ * @tsplus pipeable fncts.io.Channel.ChildExecutorDecision match
  */
-function match_(d, onContinue, onClose, onYield) {
-  switch (d._tag) {
-    case "Continue":
-      {
-        return onContinue();
-      }
+function match(onContinue, onClose, onYield) {
+  return d => {
+    switch (d._tag) {
+      case "Continue":
+        {
+          return onContinue();
+        }
 
-    case "Close":
-      {
-        return onClose(d.value);
-      }
+      case "Close":
+        {
+          return onClose(d.value);
+        }
 
-    case "Yield":
-      {
-        return onYield();
-      }
-  }
+      case "Yield":
+        {
+          return onYield();
+        }
+    }
+  };
 }
 //# sourceMappingURL=api.cjs.map

package/_cjs/Channel/ChildExecutorDecision/api.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"api.cjs","mappings":";;;;;;;AAEA;;;AAGM,SAAUA,MAAV,CACJC,CADI,EAEJC,UAFI,EAGJC,OAHI,EAIJC,OAJI,EAIY;EAEhB,QAAQH,CAAC,CAACI,IAAV;IACE,KAAK,UAAL;MAAiB;QACf,OAAOH,UAAU,EAAjB;MACD;;IACD,KAAK,OAAL;MAAc;QACZ,OAAOC,OAAO,CAACF,CAAC,CAACK,KAAH,CAAd;MACD;;IACD,KAAK,OAAL;MAAc;QACZ,OAAOF,OAAO,EAAd;MACD;EATH;AAWD","names":["match_","d","onContinue","onClose","onYield","_tag","value"],"sourceRoot":"","sources":["../../../_src/Channel/ChildExecutorDecision/api.ts"],"sourcesContent":[null]}
+{"version":3,"file":"api.cjs","mappings":";;;;;;;AAEA;;;AAGM,SAAUA,KAAV,CAAyBC,UAAzB,EAA8CC,OAA9C,EAA0EC,OAA1E,EAA0F;EAC9F,OAAQC,CAAD,IAAwC;IAC7C,QAAQA,CAAC,CAACC,IAAV;MACE,KAAK,UAAL;QAAiB;UACf,OAAOJ,UAAU,EAAjB;QACD;;MACD,KAAK,OAAL;QAAc;UACZ,OAAOC,OAAO,CAACE,CAAC,CAACE,KAAH,CAAd;QACD;;MACD,KAAK,OAAL;QAAc;UACZ,OAAOH,OAAO,EAAd;QACD;IATH;EAWD,CAZD;AAaD","names":["match","onContinue","onClose","onYield","d","_tag","value"],"sourceRoot":"","sources":["../../../_src/Channel/ChildExecutorDecision/api.ts"],"sourcesContent":[null]}