@fncts/io 0.0.20 → 0.0.21

package/Ref/definition.d.ts

@@ -1,74 +1,76 @@
-import { Either } from "@fncts/base/data/Either/definition";
-import { IO } from "@fncts/io/IO/definition";
-import type { Atomic as Atomic_ } from "./Atomic/Atomic.js";
-import type { Derived } from "./Derived.js";
-import type { DerivedAll } from "./DerivedAll.js";
-import type * as Synchro from "./Synchronized/definition.js";
+import { UIO } from "@fncts/io/IO/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import type { Atomic as Atomic_ } from "./Atomic.js";
+import type { Synchronized as Synchronized_ } from "./Synchronized.js";
 export declare const RefTypeId: unique symbol;
 export type RefTypeId = typeof RefTypeId;
-/**
- * @tsplus type fncts.io.Ref
- */
-export interface PRef<RA, RB, EA, EB, A, B> {
-    readonly _U: RefTypeId;
-    readonly _RA: () => RA;
-    readonly _RB: () => RB;
-    readonly _EA: () => EA;
-    readonly _EB: () => EB;
-    readonly _A: (_: A) => void;
-    readonly _B: () => B;
-}
-export type Ref<A> = PRef<never, never, never, never, A, A>;
-export type ERef<E, A> = PRef<unknown, unknown, E, E, A, A>;
-export declare namespace PRef {
-    type Synchronized<RA, RB, EA, EB, A, B> = Synchro.PSynchronized<RA, RB, EA, EB, A, B>;
-}
-export declare namespace ERef {
-    type Synchronized<E, A> = Synchro.PSynchronized<never, never, E, E, A, A>;
-}
 export declare namespace Ref {
     type Atomic<A> = Atomic_<A>;
-    type Synchronized<A> = Synchro.PSynchronized<never, never, never, never, A, A>;
+    type Synchronized<A> = Synchronized_<A>;
 }
 /**
- * @tsplus type fncts.io.RefOps
+ * @tsplus type fncts.io.Ref
+ * @tsplus companion fncts.io.RefOps
  */
-export interface RefOps {
-}
-export declare const Ref: RefOps;
-export declare abstract class RefInternal<RA, RB, EA, EB, A, B> implements PRef<RA, RB, EA, EB, A, B> {
-    _U: RefTypeId;
-    _RA: () => RA;
-    _RB: () => RB;
-    _EA: () => EA;
-    _EB: () => EB;
-    _A: (_: A) => void;
-    _B: () => B;
+export declare abstract class Ref<A> {
+    readonly _typeId: RefTypeId;
+    _A: (_: A) => A;
     /**
-     * Folds over the error and value types of the `Ref`. This is a highly
-     * polymorphic method that is capable of arbitrarily transforming the error
-     * and value types of the `Ref`. For most use cases one of the more specific
-     * combinators implemented in terms of `match` will be more ergonomic but this
-     * method is extremely useful for implementing new combinators.
+     * Reads the value from the `Ref`.
      */
-    abstract 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>;
+    abstract get: UIO<A>;
     /**
-     * Folds over the error and value types ofthe `Ref`, allowing access to
-     * the state in transforming the `set` value. This is a more powerful version
-     * of `match` but requires unifying the error types.
+     * Writes a new value to the `Ref`, with a guarantee of immediate
+     * consistency (at some cost to performance).
      */
-    abstract 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>;
+    abstract set(a: A, __tsplusTrace?: string): UIO<void>;
     /**
-     * Reads the value from the `Ref`.
+     * Atomically modifies the `Ref` with the specified function, which
+     * computes a return value for the modification. This is a more powerful
+     * version of `update`.
      */
-    abstract get get(): IO<RB, EB, B>;
+    abstract modify<B>(f: (a: A) => readonly [B, A], __tsplusTrace?: string): UIO<B>;
     /**
-     * Writes a new value to the `Ref`, with a guarantee of immediate
-     * consistency (at some cost to performance).
+     * Atomically writes the specified value to the `Ref`, returning the value
+     * immediately before modification.
+     */
+    getAndSet(a: A, __tsplusTrace?: string): UIO<A>;
+    /**
+     * Atomically modifies the `Ref` with the specified function, returning the
+     * value immediately before modification.
+     */
+    getAndUpdate(f: (a: A) => A, __tsplusTrace?: string): UIO<A>;
+    /**
+     * Atomically modifies the `Ref` with the specified partial function,
+     * returning the value immediately before modification. If the function is
+     * undefined on the current value it doesn't change it.
+     */
+    getAndUpdateJust(f: (a: A) => Maybe<A>, __tsplusTrace?: string): UIO<A>;
+    /**
+     * Atomically modifies the `Ref` with the specified partial function, which
+     * computes a return value for the modification if the function is defined on
+     * the current value otherwise it returns a default value. This is a more
+     * powerful version of `updateJust`.
+     */
+    modifyJust<B>(orElse: B, f: (a: A) => Maybe<readonly [B, A]>, __tsplusTrace?: string): UIO<B>;
+    /**
+     * Atomically modifies the `Ref` with the specified function.
      */
-    abstract set(a: A, __tsplusTrace?: string): IO<RA, EA, void>;
+    update(f: (a: A) => A, __tsplusTrace?: string): UIO<void>;
+    /**
+     * Atomically modifies the `Ref` with the specified function and returns the
+     * updated value.
+     */
+    updateAndGet(f: (a: A) => A, __tsplusTrace?: string): UIO<A>;
+    /**
+     * Atomically modifies the `Ref` with the specified partial function. If the
+     * function is undefined on the current value it doesn't change it.
+     */
+    updateJust(f: (a: A) => Maybe<A>, __tsplusTrace?: string): UIO<void>;
+    /**
+     * Atomically modifies the `Ref` with the specified partial function. If the
+     * function is undefined on the current value it returns the old value without
+     * changing it.
+     */
+    updateJustAndGet(f: (a: A) => Maybe<A>, __tsplusTrace?: string): UIO<A>;
 }
-/**
- * @tsplus macro remove
- */
-export declare function concrete<RA, RB, EA, EB, A, B>(_: PRef<RA, RB, EA, EB, A, B>): asserts _ is Atomic_<A | B> | Derived<EA, EB, A, B> | DerivedAll<EA, EB, A, B> | Synchro.PSynchronizedInternal<RA, RB, EA, EB, A, B>;

package/Ref.d.ts

@@ -1,9 +1,4 @@
-export * from "./Ref/api.js";
 export * from "./Ref/Atomic.js";
 export * from "./Ref/constructors.js";
 export * from "./Ref/definition.js";
-export * from "./Ref/Derived.js";
-export * from "./Ref/DerivedAll.js";
-export * from "./Ref/Synchronized/api.js";
-export * from "./Ref/Synchronized/constructors.js";
-export * from "./Ref/Synchronized/definition.js";
+export * from "./Ref/Synchronized.js";

package/STM/api/core-api.d.ts

@@ -1,35 +1,35 @@
 import { STM } from "@fncts/io/STM/definition";
 /**
  * Recovers from all errors.
- * @tsplus fluent fncts.io.STM catchAll
+ * @tsplus pipeable fncts.io.STM catchAll
  * @tsplus location "@fncts/io/STM/api/core-api"
  */
-export declare function catchAll_<R, E, A, R1, E1, B>(self: STM<R, E, A>, f: (e: E) => STM<R1, E1, B>, __tsplusTrace?: string): STM<R1 | R, E1, A | B>;
+export declare function catchAll<E, R1, E1, B>(f: (e: E) => STM<R1, E1, B>, __tsplusTrace?: string): <R, A>(self: import("../definition.js").STM<R, E, A>) => import("../definition.js").STM<R1 | R, E1, B | A>;
 /**
  * Feeds the value produced by this effect to the specified function,
  * and then runs the returned effect as well to produce its results.
- * @tsplus fluent fncts.io.STM flatMap
+ * @tsplus pipeable fncts.io.STM flatMap
  * @tsplus location "@fncts/io/STM/api/core-api"
  */
-export declare function flatMap_<R, E, A, R1, E1, B>(self: STM<R, E, A>, f: (a: A) => STM<R1, E1, B>, __tsplusTrace?: string): STM<R1 | R, E | E1, B>;
+export declare function flatMap<A, R1, E1, B>(f: (a: A) => STM<R1, E1, B>, __tsplusTrace?: string): <R, E>(self: import("../definition.js").STM<R, E, A>) => import("../definition.js").STM<R1 | R, E1 | E, B>;
 /**
  * Executes the specified finalization transaction whether or
  * not this effect succeeds. Note that as with all STM transactions,
  * if the full transaction fails, everything will be rolled back.
- * @tsplus fluent fncts.io.STM ensuring
+ * @tsplus pipeable fncts.io.STM ensuring
  * @tsplus location "@fncts/io/STM/api/core-api"
  */
-export declare function ensuring_<R, E, A, R1, B>(self: STM<R, E, A>, finalizer: STM<R1, never, B>, __tsplusTrace?: string): STM<R | R1, E, A>;
+export declare function ensuring<R1, B>(finalizer: STM<R1, never, B>, __tsplusTrace?: string): <R, E, A>(self: import("../definition.js").STM<R, E, A>) => import("../definition.js").STM<R1 | R, E, A>;
 /**
  * Maps the value produced by the effect.
- * @tsplus fluent fncts.io.STM map
+ * @tsplus pipeable fncts.io.STM map
  * @tsplus location "@fncts/io/STM/api/core-api"
  */
-export declare function map_<R, E, A, B>(self: STM<R, E, A>, f: (a: A) => B, __tsplusTrace?: string): STM<R, E, B>;
+export declare function map<A, B>(f: (a: A) => B, __tsplusTrace?: string): <R, E>(self: import("../definition.js").STM<R, E, A>) => import("../definition.js").STM<R, E, B>;
 /**
  * Effectfully folds over the `STM` effect, handling both failure and
  * success.
- * @tsplus fluent fncts.io.STM matchSTM
+ * @tsplus pipeable fncts.io.STM matchSTM
  * @tsplus location "@fncts/io/STM/api/core-api"
  */
-export declare function matchSTM_<R, E, A, R1, E1, B, R2, E2, C>(self: STM<R, E, A>, g: (e: E) => STM<R2, E2, C>, f: (a: A) => STM<R1, E1, B>, __tsplusTrace?: string): STM<R1 | R2 | R, E1 | E2, B | C>;
+export declare function matchSTM<E, A, R1, E1, B, R2, E2, C>(g: (e: E) => STM<R2, E2, C>, f: (a: A) => STM<R1, E1, B>, __tsplusTrace?: string): <R>(self: import("../definition.js").STM<R, E, A>) => import("../definition.js").STM<R1 | R2 | R, E1 | E2, B | C>;

package/STM/api.d.ts

@@ -10,10 +10,10 @@ import type { Journal } from "./internal/Journal.js";
 import { STM } from "./definition.js";
 /**
  * Maps the success value of this effect to the specified constant value.
- * @tsplus fluent fncts.io.STM as
+ * @tsplus pipeable fncts.io.STM as
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function as_<R, E, A, B>(stm: STM<R, E, A>, b: Lazy<B>, __tsplusTrace?: string): STM<R, E, B>;
+export declare function as<B>(b: Lazy<B>, __tsplusTrace?: string): <R, E, A>(stm: STM<R, E, A>) => STM<R, E, B>;
 /**
  * Maps the success value of this effect to an optional value.
  * @tsplus getter fncts.io.STM asJust
@@ -65,43 +65,43 @@ export declare function atomically<R, E, A>(stm: STM<R, E, A>, __tsplusTrace?: s
 /**
  * Returns an `STM` effect whose failure and success channels have been mapped by
  * the specified pair of functions, `f` and `g`.
+ * @tsplus pipeable fncts.io.STM bimap
+ * @tsplus location "@fncts/io/STM/api"
  */
-export declare function bimap_<R, E, A, E1, B>(stm: STM<R, E, A>, g: (e: E) => E1, f: (a: A) => B, __tsplusTrace?: string): STM<R, E1, B>;
+export declare function bimap<E, A, E1, B>(g: (e: E) => E1, f: (a: A) => B, __tsplusTrace?: string): <R>(self: STM<R, E, A>) => STM<R, E1, B>;
 /**
  * Recovers from specified error.
- * @tsplus fluent fncts.io.STM catch
+ * @tsplus pipeable fncts.io.STM catch
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function catch_<N extends keyof E, K extends E[N] & string, E, R, A, R1, E1, A1>(stm: STM<R, E, A>, tag: N, k: K, f: (e: Extract<E, {
-    [n in N]: K;
-}>) => STM<R1, E1, A1>, __tsplusTrace?: string): STM<R | R1, Exclude<E, {
+export declare function catchWith<N extends keyof E, K extends E[N] & string, E, R1, E1, A1>(tag: N, k: K, f: (e: Extract<E, {
     [n in N]: K;
-}> | E1, A | A1>;
+}>) => STM<R1, E1, A1>, __tsplusTrace?: string): <R, A>(stm: STM<R, E, A>) => STM<R1 | R, E1 | Exclude<E, { [n in N]: K; }>, A1 | A>;
 /**
  * Recovers from some or all of the error cases.
- * @tsplus fluent fncts.io.STM catchJust
+ * @tsplus pipeable fncts.io.STM catchJust
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function catchJust_<R, E, A, R1, E1, B>(stm: STM<R, E, A>, f: (e: E) => Maybe<STM<R1, E1, B>>, __tsplusTrace?: string): STM<R1 | R, E | E1, A | B>;
+export declare function catchJust<E, R1, E1, B>(f: (e: E) => Maybe<STM<R1, E1, B>>, __tsplusTrace?: string): <R, A>(stm: STM<R, E, A>) => STM<R1 | R, E | E1, B | A>;
 /**
  * Recovers from specified error.
- * @tsplus fluent fncts.io.STM catchTag
+ * @tsplus pipeable fncts.io.STM catchTag
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function catchTag_<K extends E["_tag"] & string, E extends {
+export declare function catchTag<K extends E["_tag"] & string, E extends {
     _tag: string;
-}, R, A, R1, E1, A1>(stm: STM<R, E, A>, k: K, f: (e: Extract<E, {
+}, R1, E1, A1>(k: K, f: (e: Extract<E, {
     _tag: K;
-}>) => STM<R1, E1, A1>, __tsplusTrace?: string): STM<R | R1, Exclude<E, {
+}>) => STM<R1, E1, A1>, __tsplusTrace?: string): <R, A>(stm: STM<R, E, A>) => STM<R1 | R, E1 | Exclude<E, {
     _tag: K;
-}> | E1, A | A1>;
+}>, A1 | A>;
 /**
  * Creates a composite effect that represents this effect followed by another
  * one that may depend on the error produced by this one.
- * @tsplus fluent fncts.io.STM flatMapError
+ * @tsplus pipeable fncts.io.STM flatMapError
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function chainError_<R, E, A, R2, E2>(stm: STM<R, E, A>, f: (e: E) => STM<R2, never, E2>, __tsplusTrace?: string): STM<R2 | R, E2, A>;
+export declare function chainError<E, R2, E2>(f: (e: E) => STM<R2, never, E2>, __tsplusTrace?: string): <R, A>(stm: STM<R, E, A>) => STM<R2 | R, E2, A>;
 /**
  * Checks the condition, and if it's true, returns unit, otherwise, retries.
  * @tsplus static fncts.io.STMOps check
@@ -116,31 +116,31 @@ export declare function commitEither<R, E, A>(stm: STM<R, E, A>, __tsplusTrace?:
 /**
  * Fail with `e` if the supplied `PartialFunction` does not match, otherwise
  * succeed with the returned value.
- * @tsplus fluent fncts.io.STM continueOrFail
+ * @tsplus pipeable fncts.io.STM continueOrFail
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function continueOrFail_<R, E, E1, A, A2>(fa: STM<R, E, A>, e: Lazy<E1>, pf: (a: A) => Maybe<A2>, __tsplusTrace?: string): STM<R, E | E1, A2>;
+export declare function continueOrFail<E1, A, A2>(e: Lazy<E1>, pf: (a: A) => Maybe<A2>, __tsplusTrace?: string): <R, E>(fa: STM<R, E, A>) => STM<R, E1 | E, A2>;
 /**
  * Fail with `e` if the supplied `PartialFunction` does not match, otherwise
  * continue with the returned value.
- * @tsplus fluent fncts.io.STM continueOrFailSTM
+ * @tsplus pipeable fncts.io.STM continueOrFailSTM
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function continueOrFailSTM_<R, E, E1, A, R2, E2, A2>(fa: STM<R, E, A>, e: Lazy<E1>, pf: (a: A) => Maybe<STM<R2, E2, A2>>, __tsplusTrace?: string): STM<R2 | R, E | E1 | E2, A2>;
+export declare function continueOrFailSTM<E1, A, R2, E2, A2>(e: Lazy<E1>, pf: (a: A) => Maybe<STM<R2, E2, A2>>, __tsplusTrace?: string): <R, E>(fa: STM<R, E, A>) => STM<R2 | R, E1 | E2 | E, A2>;
 /**
  * Fail with `e` if the supplied `PartialFunction` does not match, otherwise
  * succeed with the returned value.
- * @tsplus fluent fncts.io.STM continueOrRetry
+ * @tsplus pipeable fncts.io.STM continueOrRetry
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function continueOrRetry_<R, E, A, A2>(fa: STM<R, E, A>, pf: (a: A) => Maybe<A2>, __tsplusTrace?: string): STM<R, E, A2>;
+export declare function continueOrRetry<A, A2>(pf: (a: A) => Maybe<A2>, __tsplusTrace?: string): <R, E>(fa: STM<R, E, A>) => STM<R, E, A2>;
 /**
  * Simultaneously filters and flatMaps the value produced by this effect.
  * Continues on the effect returned from pf.
- * @tsplus fluent fncts.io.STM continueOrRetrySTM
+ * @tsplus pipeable fncts.io.STM continueOrRetrySTM
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function continueOrRetrySTM_<R, E, A, R2, E2, A2>(fa: STM<R, E, A>, pf: (a: A) => Maybe<STM<R2, E2, A2>>, __tsplusTrace?: string): STM<R2 | R, E | E2, A2>;
+export declare function continueOrRetrySTM<A, R2, E2, A2>(pf: (a: A) => Maybe<STM<R2, E2, A2>>, __tsplusTrace?: string): <R, E>(fa: STM<R, E, A>) => STM<R2 | R, E2 | E, A2>;
 /**
  * Suspends creation of the specified transaction lazily.
  * @tsplus static fncts.io.STMOps defer
@@ -161,38 +161,38 @@ export declare function either<R, E, A>(stm: STM<R, E, A>, __tsplusTrace?: strin
 export declare function eventually<R, E, A>(stm: STM<R, E, A>, __tsplusTrace?: string): STM<R, never, A>;
 /**
  * Simultaneously filters and maps the value produced by this effect.
- * @tsplus fluent fncts.io.STM filterMap
+ * @tsplus pipeable fncts.io.STM filterMap
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function filterMap_<R, E, A, B>(stm: STM<R, E, A>, f: (a: A) => Maybe<B>, __tsplusTrace?: string): STM<R, E, B>;
+export declare function filterMap<A, B>(f: (a: A) => Maybe<B>, __tsplusTrace?: string): <R, E>(stm: STM<R, E, A>) => STM<R, E, B>;
 /**
  * Simultaneously filters and chains the value produced by this effect.
  * Continues on the effect returned from f.
- * @tsplus fluent fncts.io.STM filterMapSTM
+ * @tsplus pipeable fncts.io.STM filterMapSTM
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function filterMapSTM_<R, E, A, R1, E1, B>(self: STM<R, E, A>, f: (a: A) => Maybe<STM<R1, E1, B>>, __tsplusTrace?: string): STM<R | R1, E | E1, B>;
+export declare function filterMapSTM<A, R1, E1, B>(f: (a: A) => Maybe<STM<R1, E1, B>>, __tsplusTrace?: string): <R, E>(self: STM<R, E, A>) => STM<R1 | R, E1 | E, B>;
 /**
  * Applies `or` if the predicate fails.
- * @tsplus fluent fncts.io.STM filterOrElse
+ * @tsplus pipeable fncts.io.STM filterOrElse
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function filterOrElse_<R, E, A, B extends A, R2, E2, A2>(fa: STM<R, E, A>, p: Refinement<A, B>, or: (a: Exclude<A, B>) => STM<R2, E2, A2>): STM<R | R2, E | E2, B | A2>;
-export declare function filterOrElse_<R, E, A, R2, E2, A2>(fa: STM<R, E, A>, p: Predicate<A>, or: (a: A) => STM<R2, E2, A2>): STM<R | R2, E | E2, A | A2>;
+export declare function filterOrElse<A, B extends A, R2, E2, A2>(p: Refinement<A, B>, or: (a: Exclude<A, B>) => STM<R2, E2, A2>): <R, E>(fa: STM<R, E, A>) => STM<R | R2, E | E2, B | A2>;
+export declare function filterOrElse<A, R2, E2, A2>(p: Predicate<A>, or: (a: A) => STM<R2, E2, A2>): <R, E>(fa: STM<R, E, A>) => STM<R | R2, E | E2, A | A2>;
 /**
  * Fails with `failWith` if the predicate fails.
- * @tsplus fluent fncts.io.STM filterOrFail
+ * @tsplus pipeable fncts.io.STM filterOrFail
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function filterOrFail_<R, E, E1, A, B extends A>(fa: STM<R, E, A>, p: Refinement<A, B>, failWith: (a: Exclude<A, B>) => E1): STM<R, E | E1, B>;
-export declare function filterOrFail_<R, E, E1, A>(fa: STM<R, E, A>, p: Predicate<A>, failWith: (a: A) => E1): STM<R, E | E1, A>;
+export declare function filterOrFail<E1, A, B extends A>(p: Refinement<A, B>, failWith: (a: Exclude<A, B>) => E1): <R, E>(fa: STM<R, E, A>) => STM<R, E | E1, B>;
+export declare function filterOrFail<E1, A>(p: Predicate<A>, failWith: (a: A) => E1): <R, E>(fa: STM<R, E, A>) => STM<R, E | E1, A>;
 /**
  * Halts with specified `unknown` if the predicate fails.
- * @tsplus fluent fncts.io.STM filterOrHalt
+ * @tsplus pipeable fncts.io.STM filterOrHalt
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function filterOrHalt_<R, E, A, B extends A>(fa: STM<R, E, A>, p: Refinement<A, B>, haltWith: (a: Exclude<A, B>) => unknown): STM<R, E, B>;
-export declare function filterOrHalt_<R, E, A>(fa: STM<R, E, A>, p: Predicate<A>, haltWith: (a: A) => unknown): STM<R, E, A>;
+export declare function filterOrHalt<A, B extends A>(p: Refinement<A, B>, haltWith: (a: Exclude<A, B>) => unknown): <R, E>(fa: STM<R, E, A>) => STM<R, E, B>;
+export declare function filterOrHalt<A>(p: Predicate<A>, haltWith: (a: A) => unknown): <R, E>(fa: STM<R, E, A>) => STM<R, E, A>;
 /**
  * Flattens out a nested `STM` effect.
  * @tsplus getter fncts.io.STM flatten
@@ -201,17 +201,17 @@ export declare function filterOrHalt_<R, E, A>(fa: STM<R, E, A>, p: Predicate<A>
 export declare function flatten<R, E, R1, E1, B>(stm: STM<R, E, STM<R1, E1, B>>, __tsplusTrace?: string): STM<R1 | R, E | E1, B>;
 /**
  * Unwraps the optional error, defaulting to the provided value.
- * @tsplus fluent fncts.io.STM flattenErrorOption
+ * @tsplus pipeable fncts.io.STM flattenErrorOption
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function flattenErrorOption_<R, E, A, E2>(stm: STM<R, Maybe<E>, A>, def: Lazy<E2>, __tsplusTrace?: string): STM<R, E | E2, A>;
+export declare function flattenErrorOption<E2>(def: Lazy<E2>, __tsplusTrace?: string): <R, E, A>(stm: STM<R, import("@fncts/base/data/Maybe.js").Maybe<E>, A>) => STM<R, E2 | E, A>;
 /**
  * Applies the function `f` to each element of the `Iterable<A>` and
  * returns a transactional effect that produces a new `ReadonlyArray<B>`.
  * @tsplus static fncts.io.STMOps foreach
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function foreach_<A, R, E, B>(it: Iterable<A>, f: (a: A) => STM<R, E, B>, __tsplusTrace?: string): STM<R, E, readonly B[]>;
+export declare function foreach<A, R, E, B>(it: Iterable<A>, f: (a: A) => STM<R, E, B>, __tsplusTrace?: string): STM<R, E, readonly B[]>;
 /**
  * Lifts an `Either` into a `STM`.
  * @tsplus static fncts.io.STMOps fromEither
@@ -231,17 +231,17 @@ export declare function get<R, E, A>(stm: STM<R, E, Maybe<A>>, __tsplusTrace?: s
 /**
  * Provides the transaction its required environment, which eliminates
  * its dependency on `R`.
- * @tsplus fluent fncts.io.STM provideEnvironment
+ * @tsplus pipeable fncts.io.STM provideEnvironment
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function provideEnvironment_<R, E, A>(stm: STM<R, E, A>, r: Environment<R>, __tsplusTrace?: string): STM<never, E, A>;
+export declare function provideEnvironment<R>(r: Environment<R>, __tsplusTrace?: string): <E, A>(stm: STM<R, E, A>) => STM<never, E, A>;
 /**
  * Provides some of the environment required to run this effect,
  * leaving the remainder `R0`.
- * @tsplus fluent fncts.io.STM contramapEnvironment
+ * @tsplus pipeable fncts.io.STM contramapEnvironment
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function contramapEnvironment_<R, E, A, R0>(self: STM<R, E, A>, f: (r: Environment<R0>) => Environment<R>, __tsplusTrace?: string): STM<R0, E, A>;
+export declare function contramapEnvironment<R, R0>(f: (r: Environment<R0>) => Environment<R>, __tsplusTrace?: string): <E, A>(self: STM<R, E, A>) => STM<R0, E, A>;
 /**
  * Halts the fiber running the effect.
  * @tsplus static fncts.io.STMOps halt
@@ -287,23 +287,23 @@ export declare function isSuccess<R, E, A>(stm: STM<R, E, A>, __tsplusTrace?: st
 export declare function left<R, E, B, C>(stm: STM<R, E, Either<B, C>>, __tsplusTrace?: string): STM<R, Maybe<E>, B>;
 /**
  * Returns a successful effect if the value is `Left`, or fails with the error e.
- * @tsplus fluent fncts.io.STM leftOrFail
+ * @tsplus pipeable fncts.io.STM leftOrFail
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function leftOrFail_<R, E, B, C, E1>(stm: STM<R, E, Either<B, C>>, orFail: (c: C) => E1, __tsplusTrace?: string): STM<R, E | E1, B>;
+export declare function leftOrFail<C, E1>(orFail: (c: C) => E1, __tsplusTrace?: string): <R, E, B>(stm: STM<R, E, import("@fncts/base/data/Either.js").Either<B, C>>) => STM<R, E1 | E, B>;
 /**
  * Maps from one error type to another.
- * @tsplus fluent fncts.io.STM mapError
+ * @tsplus pipeable fncts.io.STM mapError
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function mapError_<R, E, A, E1>(stm: STM<R, E, A>, f: (a: E) => E1, __tsplusTrace?: string): STM<R, E1, A>;
+export declare function mapError<E, E1>(f: (a: E) => E1, __tsplusTrace?: string): <R, A>(stm: STM<R, E, A>) => STM<R, E1, A>;
 /**
  * Folds over the `STM` effect, handling both failure and success, but not
  * retry.
- * @tsplus fluent fncts.io.STM match
+ * @tsplus pipeable fncts.io.STM match
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function match_<R, E, A, B, C>(stm: STM<R, E, A>, g: (e: E) => C, f: (a: A) => B, __tsplusTrace?: string): STM<R, never, B | C>;
+export declare function match<E, A, B, C>(g: (e: E) => C, f: (a: A) => B, __tsplusTrace?: string): <R>(stm: STM<R, E, A>) => STM<R, never, B | C>;
 /**
  * Repeats this `STM` effect until its result satisfies the specified predicate.
  *
@@ -315,10 +315,10 @@ export declare function match_<R, E, A, B, C>(stm: STM<R, E, A>, g: (e: E) => C,
  *
  * - Use `retryUntil` instead if you don't need to maintain transaction state for repeats.
  * - Ensure repeating the STM effect will eventually satisfy the predicate.
- * @tsplus fluent fncts.io.STM repeatUntil
+ * @tsplus pipeable fncts.io.STM repeatUntil
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function repeatUntil_<R, E, A>(stm: STM<R, E, A>, f: (a: A) => boolean, __tsplusTrace?: string): STM<R, E, A>;
+export declare function repeatUntil<A>(f: (a: A) => boolean, __tsplusTrace?: string): <R, E>(stm: STM<R, E, A>) => STM<R, E, A>;
 /**
  * Repeats this `STM` effect while its result satisfies the specified predicate.
  *
@@ -330,10 +330,10 @@ export declare function repeatUntil_<R, E, A>(stm: STM<R, E, A>, f: (a: A) => bo
  *
  * - Use `retryWhile` instead if you don't need to maintain transaction state for repeats.
  * - Ensure repeating the STM effect will eventually not satisfy the predicate.
- * @tsplus fluent fncts.io.STM repeatWhile
+ * @tsplus pipeable fncts.io.STM repeatWhile
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function repeatWhile_<R, E, A>(stm: STM<R, E, A>, f: (a: A) => boolean, __tsplusTrace?: string): STM<R, E, A>;
+export declare function repeatWhile<A>(f: (a: A) => boolean, __tsplusTrace?: string): <R, E>(stm: STM<R, E, A>) => STM<R, E, A>;
 /**
  * Returns an effect that swaps the error/success cases. This allows you to
  * use all methods on the error channel, possibly before flipping back.
@@ -343,16 +343,16 @@ export declare function repeatWhile_<R, E, A>(stm: STM<R, E, A>, f: (a: A) => bo
 export declare function swap<R, E, A>(stm: STM<R, E, A>, __tsplusTrace?: string): STM<R, A, E>;
 /**
  * Swaps the error/value parameters, applies the function `f` and flips the parameters back
- * @tsplus fluent fncts.io.STM swapWith
+ * @tsplus pipeable fncts.io.STM swapWith
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function swapWith_<R, E, A, R2, E2, A2>(stm: STM<R, E, A>, f: (stm: STM<R, A, E>) => STM<R2, A2, E2>, __tsplusTrace?: string): STM<R2, E2, A2>;
+export declare function swapWith<R, E, A, R2, E2, A2>(f: (stm: STM<R, A, E>) => STM<R2, A2, E2>, __tsplusTrace?: string): (stm: STM<R, E, A>) => STM<R2, E2, A2>;
 /**
  * "Peeks" at the success of transactional effect.
- * @tsplus fluent fncts.io.STM tap
+ * @tsplus pipeable fncts.io.STM tap
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function tap_<R, E, A, R1, E1, B>(stm: STM<R, E, A>, f: (a: A) => STM<R1, E1, B>, __tsplusTrace?: string): STM<R1 | R, E | E1, A>;
+export declare function tap<A, R1, E1, B>(f: (a: A) => STM<R1, E1, B>, __tsplusTrace?: string): <R, E>(stm: STM<R, E, A>) => STM<R1 | R, E1 | E, A>;
 /**
  * Returns an effect with the value on the left part.
  * @tsplus static fncts.io.STMOps toLeft
@@ -368,7 +368,7 @@ export declare const unit: STM<never, never, void>;
 /**
  * Sequentially zips this value with the specified one, combining the values
  * using the specified combiner function.
- * @tsplus fluent fncts.io.STM zipWith
+ * @tsplus pipeable fncts.io.STM zipWith
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function zipWith_<R, E, A, R1, E1, B, C>(self: STM<R, E, A>, that: STM<R1, E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string): STM<R | R1, E | E1, C>;
+export declare function zipWith<A, R1, E1, B, C>(that: STM<R1, E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string): <R, E>(self: STM<R, E, A>) => STM<R1 | R, E1 | E, C>;

package/STM/internal/Journal.d.ts

@@ -70,17 +70,17 @@ export declare function collectTodos(journal: Journal): Map<TxnId, Todo>;
 export declare function execTodos(todos: Map<TxnId, Todo>): void;
 /**
  * Runs all the todos.
- * @tsplus fluent fncts.io.Journal completeTodos
+ * @tsplus pipeable fncts.io.Journal completeTodos
  * @tsplus location "@fncts/io/STM/internal/Journal"
  */
-export declare function completeTodos<E, A>(journal: Journal, exit: Exit<E, A>, scheduler: Scheduler): Done<E, A>;
+export declare function completeTodos<E, A>(exit: Exit<E, A>, scheduler: Scheduler): (journal: Journal) => Done<E, A>;
 /**
  * For the given transaction id, adds the specified todo effect to all
  * `TRef` values.
- * @tsplus fluent fncts.io.Journal addTodo
+ * @tsplus pipeable fncts.io.Journal addTodo
  * @tsplus location "@fncts/io/STM/internal/Journal"
  */
-export declare function addTodo(journal: Journal, txnId: TxnId, todoEffect: Todo): boolean;
+export declare function addTodo(txnId: TxnId, todoEffect: Todo): (journal: Journal) => boolean;
 /**
  * Finds all the new todo targets that are not already tracked in the `oldJournal`.
  */

package/Schedule/Decision.d.ts

@@ -38,7 +38,7 @@ export declare function continue_(interval: Intervals): Decision;
  */
 export declare function continueWith(interval: Interval): Decision;
 /**
- * @tsplus fluent fncts.io.Schedule.Decision match
+ * @tsplus pipeable fncts.io.Schedule.Decision match
  * @tsplus location "@fncts/io/Schedule/Decision"
  */
-export declare function match_<A, B>(self: Decision, onDone: () => A, onContinue: (interval: Intervals) => B): A | B;
+export declare function match<A, B>(onDone: () => A, onContinue: (interval: Intervals) => B): (self: Decision) => A | B;