@fncts/io 0.0.20 → 0.0.22

package/Queue/api/takeBetween.d.ts

@@ -1,11 +1,11 @@
-import { PQueue } from "@fncts/io/Queue/definition";
 import { IO } from "@fncts/io/IO/definition";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
+import type { PDequeue } from "@fncts/io/Queue/definition";
 /**
  * Takes between min and max number of values from the queue. If there
  * is less than min items available, it'll block until the items are
  * collected.
- * @tsplus fluent fncts.io.Queue takeBetween
+ * @tsplus pipeable fncts.io.Queue takeBetween
  * @tsplus location "@fncts/io/Queue/api/takeBetween"
  */
-export declare function takeBetween_<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, min: number, max: number, __tsplusTrace?: string): IO<RB, EB, Conc<B>>;
+export declare function takeBetween(min: number, max: number, __tsplusTrace?: string): <RA, RB, EA, EB, A, B>(queue: PDequeue<RA, RB, EA, EB, A, B>) => import("../../IO").IO<RB, EB, import("@fncts/base/collection/immutable/Conc").Conc<B>>;

package/Queue/api/zipWithIO.d.ts

@@ -1,23 +1,6 @@
 import { IO, UIO } from "@fncts/io/IO/definition";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
 import { PQueue } from "@fncts/io/Queue/definition";
-import { QueueInternal } from "@fncts/io/Queue/definition";
-export declare class ZipWithIO<RA, RB, EA, EB, RA1, RB1, EA1, EB1, A1 extends A, C, B, R3, E3, D, A> extends QueueInternal<RA | RA1, RB | RB1 | R3, EA | EA1, E3 | EB | EB1, A1, D> {
-    readonly fa: QueueInternal<RA, RB, EA, EB, A, B>;
-    readonly fb: QueueInternal<RA1, RB1, EA1, EB1, A1, C>;
-    readonly f: (b: B, c: C) => IO<R3, E3, D>;
-    constructor(fa: QueueInternal<RA, RB, EA, EB, A, B>, fb: QueueInternal<RA1, RB1, EA1, EB1, A1, C>, f: (b: B, c: C) => IO<R3, E3, D>);
-    awaitShutdown: UIO<void>;
-    capacity: number;
-    isShutdown: UIO<boolean>;
-    offer(a: A1): IO<RA | RA1, EA1 | EA, boolean>;
-    offerAll(as: Iterable<A1>): IO<RA | RA1, EA1 | EA, boolean>;
-    shutdown: UIO<void>;
-    size: UIO<number>;
-    take: IO<RB | RB1 | R3, E3 | EB | EB1, D>;
-    takeAll: IO<RB | RB1 | R3, E3 | EB | EB1, Conc<D>>;
-    takeUpTo(max: number): IO<RB | RB1 | R3, E3 | EB | EB1, Conc<D>>;
-}
 /**
  * Creates a new queue from this queue and another. Offering to the composite queue
  * will broadcast the elements to both queues; taking from the composite queue
@@ -26,19 +9,19 @@ export declare class ZipWithIO<RA, RB, EA, EB, RA1, RB1, EA1, EB1, A1 extends A,
  * Note that using queues with different strategies may result in surprising behavior.
  * For example, a dropping queue and a bounded queue composed together may apply `f`
  * to different elements.
- * @tsplus fluent fncts.io.Queue zipWithIO
+ * @tsplus pipeable fncts.io.Queue zipWithIO
  * @tsplus location "@fncts/io/Queue/api/zipWithIO"
  */
-export declare function zipWithIO_<RA, RB, EA, EB, RA1, RB1, EA1, EB1, A1 extends A, C, B, R3, E3, D, A>(fa: PQueue<RA, RB, EA, EB, A, B>, fb: PQueue<RA1, RB1, EA1, EB1, A1, C>, f: (b: B, c: C) => IO<R3, E3, D>, __tsplusTrace?: string): PQueue<RA | RA1, RB | RB1 | R3, EA | EA1, E3 | EB | EB1, A1, D>;
+export declare function zipWithIO<A, B, RA1, RB1, EA1, EB1, A1 extends A, B1, R3, E3, D>(fb: PQueue<RA1, RB1, EA1, EB1, A1, B1>, f: (b: B, c: B1) => IO<R3, E3, D>, __tsplusTrace?: string): <RA, RB, EA, EB>(fa: import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, A, B>) => import("@fncts/io/Queue/definition").PQueue<RA1 | RA, RB1 | R3 | RB, EA1 | EA, EB1 | E3 | EB, A1, D>;
 /**
- * Like `zipWithM`, but uses a pure function.
- * @tsplus fluent fncts.io.Queue zipWith
+ * Like `zipWithIO`, but uses a pure function.
+ * @tsplus pipeable fncts.io.Queue zipWith
  * @tsplus location "@fncts/io/Queue/api/zipWithIO"
  */
-export declare function zipWith_<RA, RB, EA, EB, RA1, RB1, EA1, EB1, A1 extends A, C, B, D, A>(queue: PQueue<RA, RB, EA, EB, A, B>, that: PQueue<RA1, RB1, EA1, EB1, A1, C>, f: (b: B, c: C) => D, __tsplusTrace?: string): PQueue<RA | RA1, RB | RB1, EA | EA1, EB | EB1, A1, D>;
+export declare function zipWith<A, B, RA1, RB1, EA1, EB1, A1 extends A, B1, C>(that: PQueue<RA1, RB1, EA1, EB1, A1, B1>, f: (a: B, b: B1) => C, __tsplusTrace?: string): <RA, RB, EA, EB>(queue: import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, A, B>) => import("@fncts/io/Queue/definition").PQueue<RA1 | RA, RB1 | RB, EA1 | EA, EB1 | EB, A1, C>;
 /**
  * Like `zipWith`, but tuples the elements instead of applying a function.
- * @tsplus fluent fncts.io.Queue zip
+ * @tsplus pipeable fncts.io.Queue zip
  * @tsplus location "@fncts/io/Queue/api/zipWithIO"
  */
-export declare function zip_<RA, RB, EA, EB, RA1, RB1, EA1, EB1, A1 extends A, C, B, A>(queue: PQueue<RA, RB, EA, EB, A, B>, that: PQueue<RA1, RB1, EA1, EB1, A1, C>, __tsplusTrace?: string): PQueue<RA | RA1, RB | RB1, EA | EA1, EB | EB1, A1, readonly [B, C]>;
+export declare function zip<A, B, RA1, RB1, EA1, EB1, A1 extends A, B1>(that: PQueue<RA1, RB1, EA1, EB1, A1, B1>, __tsplusTrace?: string): <RA, RB, EA, EB>(queue: import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, A, B>) => import("@fncts/io/Queue/definition").PQueue<RA1 | RA, RB1 | RB, EA1 | EA, EB1 | EB, A1, readonly [B, B1]>;

package/Queue/definition.d.ts

@@ -1,5 +1,11 @@
 import { UIO, IO } from "@fncts/io/IO/definition";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
+export declare const EnqueueTypeId: unique symbol;
+export type EnqueueTypeId = typeof EnqueueTypeId;
+export declare const DequeueTypeId: unique symbol;
+export type DequeueTypeId = typeof DequeueTypeId;
+export declare const QueueTypeId: unique symbol;
+export type QueueTypeId = typeof QueueTypeId;
 /**
  * A `PQueue<RA, RB, EA, EB, A, B>` is a lightweight, asynchronous queue into which values of
  * type `A` can be enqueued and of which elements of type `B` can be dequeued. The queue's
@@ -9,7 +15,13 @@ import { Conc } from "@fncts/base/collection/immutable/Conc";
  *
  * @tsplus type fncts.io.Queue
  */
-export interface PQueue<RA, RB, EA, EB, A, B> {
+export interface PQueue<RA, RB, EA, EB, A, B> extends PEnqueue<RA, RB, EA, EB, A, B>, PDequeue<RA, RB, EA, EB, A, B> {
+}
+/**
+ * @tsplus type fncts.io.Queue
+ */
+export interface PQueueCommon<RA, RB, EA, EB, A, B> {
+    readonly [QueueTypeId]: QueueTypeId;
     readonly _RA: () => RA;
     readonly _RB: () => RB;
     readonly _EA: () => EA;
@@ -17,6 +29,20 @@ export interface PQueue<RA, RB, EA, EB, A, B> {
     readonly _A: (_: A) => void;
     readonly _B: () => B;
 }
+/**
+ * @tsplus type fncts.io.Queue
+ * @tsplus type fncts.io.Queue.Enqueue
+ */
+export interface PEnqueue<RA, RB, EA, EB, A, B> extends PQueueCommon<RA, RB, EA, EB, A, B> {
+    readonly [EnqueueTypeId]: EnqueueTypeId;
+}
+/**
+ * @tsplus type fncts.io.Queue
+ * @tsplus type fncts.io.Queue.Dequeue
+ */
+export interface PDequeue<RA, RB, EA, EB, A, B> extends PQueueCommon<RA, RB, EA, EB, A, B> {
+    readonly [DequeueTypeId]: DequeueTypeId;
+}
 /**
  * @tsplus type fncts.io.QueueOps
  */
@@ -27,6 +53,9 @@ export declare const Queue: QueueOps;
  * @optimize remove
  */
 export declare function concrete<RA, RB, EA, EB, A, B>(_: PQueue<RA, RB, EA, EB, A, B>): asserts _ is QueueInternal<RA, RB, EA, EB, A, B>;
+export declare function concrete<RA, RB, EA, EB, A, B>(_: PDequeue<RA, RB, EA, EB, A, B>): asserts _ is PDequeueInternal<RA, RB, EA, EB, A, B>;
+export declare function concrete<RA, RB, EA, EB, A, B>(_: PEnqueue<RA, RB, EA, EB, A, B>): asserts _ is PEnqueueInternal<RA, RB, EA, EB, A, B>;
+export declare function concrete<RA, RB, EA, EB, A, B>(_: PQueueCommon<RA, RB, EA, EB, A, B>): asserts _ is PQueueCommonInternal<RA, RB, EA, EB, A, B>;
 /**
  * A `Queue<RA, RB, EA, EB, A, B>` is a lightweight, asynchronous queue into which values of
  * type `A` can be enqueued and of which elements of type `B` can be dequeued. The queue's
@@ -34,7 +63,10 @@ export declare function concrete<RA, RB, EA, EB, A, B>(_: PQueue<RA, RB, EA, EB,
  * type `EA`. The dequeueing operations may utilize an environment of type `RB` and may fail
  * with errors of type `EB`.
  */
-export declare abstract class QueueInternal<RA, RB, EA, EB, A, B> implements PQueue<RA, RB, EA, EB, A, B> {
+export declare abstract class QueueInternal<RA, RB, EA, EB, A, B> implements PQueue<RA, RB, EA, EB, A, B>, PEnqueue<RA, RB, EA, EB, A, B>, PDequeue<RA, RB, EA, EB, A, B> {
+    readonly [QueueTypeId]: QueueTypeId;
+    readonly [DequeueTypeId]: DequeueTypeId;
+    readonly [EnqueueTypeId]: EnqueueTypeId;
     readonly _RA: () => RA;
     readonly _RB: () => RB;
     readonly _EA: () => EA;
@@ -114,16 +146,88 @@ export interface Queue<A> extends PQueue<never, never, never, never, A, A> {
 export declare namespace Queue {
     /**
      * A queue that can only be dequeued.
-     *
-     * @tsplus type fncts.io.Queue
      */
-    interface Dequeue<A> extends PQueue<never, never, unknown, never, never, A> {
+    interface Dequeue<A> extends PDequeue<never, never, never, never, A, A> {
     }
     /**
      * A queue that can only be enqueued.
-     *
-     * @tsplus type fncts.io.Queue
      */
-    interface Enqueue<A> extends PQueue<never, never, never, unknown, A, any> {
+    interface Enqueue<A> extends PEnqueue<never, never, never, never, A, A> {
     }
 }
+export interface PQueueCommonInternal<RA, RB, EA, EB, A, B> {
+    readonly _RA: () => RA;
+    readonly _RB: () => RB;
+    readonly _EA: () => EA;
+    readonly _EB: () => EB;
+    readonly _A: (_: A) => void;
+    readonly _B: () => B;
+    readonly [QueueTypeId]: QueueTypeId;
+    /**
+     * Waits until the queue is shutdown.
+     * The `IO` returned by this method will not resume until the queue has been shutdown.
+     * If the queue is already shutdown, the `IO` will resume right away.
+     */
+    readonly awaitShutdown: UIO<void>;
+    /**
+     * How many elements can hold in the queue
+     */
+    readonly capacity: number;
+    /**
+     * `true` if `shutdown` has been called.
+     */
+    readonly isShutdown: UIO<boolean>;
+    /**
+     * Interrupts any fibers that are suspended on `offer` or `take`.
+     * Future calls to `offer*` and `take*` will be interrupted immediately.
+     */
+    readonly shutdown: UIO<void>;
+    /**
+     * Retrieves the size of the queue, which is equal to the number of elements
+     * in the queue. This may be negative if fibers are suspended waiting for
+     * elements to be added to the queue.
+     */
+    readonly size: UIO<number>;
+}
+export interface PEnqueueInternal<RA, RB, EA, EB, A, B> extends PQueueCommonInternal<RA, RB, EA, EB, A, B> {
+    readonly [EnqueueTypeId]: EnqueueTypeId;
+    /**
+     * Places one value in the queue.
+     */
+    offer(a: A, __tsplusTrace?: string): IO<RA, EA, boolean>;
+    /**
+     * For Bounded Queue: uses the `BackPressure` Strategy, places the values in the queue and always returns true.
+     * If the queue has reached capacity, then
+     * the fiber performing the `offerAll` will be suspended until there is room in
+     * the queue.
+     *
+     * For Unbounded Queue:
+     * Places all values in the queue and returns true.
+     *
+     * For Sliding Queue: uses `Sliding` Strategy
+     * If there is room in the queue, it places the values otherwise it removes the old elements and
+     * enqueues the new ones. Always returns true.
+     *
+     * For Dropping Queue: uses `Dropping` Strategy,
+     * It places the values in the queue but if there is no room it will not enqueue them and return false.
+     *
+     */
+    offerAll(as: Iterable<A>, __tsplusTrace?: string): IO<RA, EA, boolean>;
+}
+export interface PDequeueInternal<RA, RB, EA, EB, A, B> extends PQueueCommonInternal<RA, RB, EA, EB, A, B> {
+    readonly [DequeueTypeId]: DequeueTypeId;
+    /**
+     * Removes the oldest value in the queue. If the queue is empty, this will
+     * return a computation that resumes when an item has been added to the queue.
+     */
+    readonly take: IO<RB, EB, B>;
+    /**
+     * Removes all the values in the queue and returns the list of the values. If the queue
+     * is empty returns empty list.
+     */
+    readonly takeAll: IO<RB, EB, Conc<B>>;
+    /**
+     * Takes up to max number of values in the queue.
+     */
+    takeUpTo(n: number, __tsplusTrace?: string): IO<RB, EB, Conc<B>>;
+}

package/Queue/internal.d.ts

@@ -1,12 +1,12 @@
 import { Future } from "@fncts/io/Future";
 import { UIO, IO } from "@fncts/io/IO/definition";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { Queue } from "@fncts/io/Queue/definition";
 import type { MutableQueue } from "@fncts/io/internal/MutableQueue";
-import type { Queue } from "@fncts/io/Queue/definition";
 import type { Strategy } from "@fncts/io/Queue/strategy";
-export declare function _makeQueue<A>(strategy: Strategy<A>): (queue: MutableQueue<A>) => IO<never, never, Queue<A>>;
-export declare function _unsafeOfferAll<A>(q: MutableQueue<A>, as: Conc<A>): Conc<A>;
-export declare function _unsafePollAll<A>(q: MutableQueue<A>): Conc<A>;
-export declare function _unsafeCompletePromise<A>(p: Future<never, A>, a: A): void;
-export declare function _unsafeRemove<A>(q: MutableQueue<A>, a: A): import("@fncts/base/collection/immutable/Conc").Conc<A>;
-export declare function _unsafeCompleteTakers<A>(strategy: Strategy<A>, queue: MutableQueue<A>, takers: MutableQueue<Future<never, A>>): void;
+export declare function unsafeMakeQueue<A>(strategy: Strategy<A>): (queue: MutableQueue<A>) => IO<never, never, Queue<A>>;
+export declare function unsafeOfferAll<A>(q: MutableQueue<A>, as: Conc<A>): Conc<A>;
+export declare function unsafePollAll<A>(q: MutableQueue<A>): Conc<A>;
+export declare function unsafeCompletePromise<A>(p: Future<never, A>, a: A): void;
+export declare function unsafeRemove<A>(q: MutableQueue<A>, a: A): import("@fncts/base/collection/immutable/Conc").Conc<A>;
+export declare function unsafeCompleteTakers<A>(strategy: Strategy<A>, queue: MutableQueue<A>, takers: MutableQueue<Future<never, A>>): void;

package/Ref/Atomic.d.ts

@@ -1,2 +1,22 @@
-export * from "./Atomic/api.js";
-export * from "./Atomic/Atomic.js";
+import { Either } from "@fncts/base/data/Either/definition";
+import { UIO } from "@fncts/io/IO/definition";
+import type { PRef } from "./definition.js";
+import type { AtomicReference } from "@fncts/base/internal/AtomicReference";
+import { RefInternal } from "./definition.js";
+export declare const AtomicTypeId: unique symbol;
+export type AtomicTypeId = typeof AtomicTypeId;
+/**
+ * @tsplus type fncts.io.Ref.Atomic
+ */
+export declare class Atomic<A> extends RefInternal<never, never, never, never, A, A> {
+    readonly value: AtomicReference<A>;
+    readonly [AtomicTypeId]: AtomicTypeId;
+    constructor(value: AtomicReference<A>);
+    match<EC, ED, C, D>(_ea: (_: never) => EC, _eb: (_: never) => ED, ca: (_: C) => Either<EC, A>, bd: (_: A) => Either<ED, D>): PRef<never, never, EC, ED, C, D>;
+    matchAll<EC, ED, C, D>(_ea: (_: never) => EC, _eb: (_: never) => ED, _ec: (_: never) => EC, ca: (_: C) => (_: A) => Either<EC, A>, bd: (_: A) => Either<ED, D>): PRef<never, never, EC, ED, C, D>;
+    get unsafeGet(): A;
+    unsafeSet(a: A): void;
+    get get(): UIO<A>;
+    set(a: A): UIO<void>;
+    modify<B>(f: (a: A) => readonly [B, A], __tsplusTrace?: string | undefined): UIO<B>;
+}

package/Ref/Derived.d.ts

@@ -1,7 +1,8 @@
 import { Either } from "@fncts/base/data/Either/definition";
-import { FIO, IO } from "@fncts/io/IO/definition";
-import type { Atomic } from "./Atomic/Atomic.js";
+import { FIO } from "@fncts/io/IO/definition";
+import type { Atomic } from "./Atomic.js";
 import type { PRef } from "./definition.js";
+import { IO } from "@fncts/io/IO";
 import { RefInternal } from "./definition.js";
 export declare class Derived<EA, EB, A, B> extends RefInternal<never, never, EA, EB, A, B> {
     readonly use: <X>(f: <S>(value: Atomic<S>, getEither: (s: S) => Either<EB, B>, setEither: (a: A) => Either<EA, S>) => X) => X;
@@ -11,4 +12,5 @@ export declare class Derived<EA, EB, A, B> extends RefInternal<never, never, EA,
     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<never, never, EC, ED, C, D>;
     get get(): FIO<EB, B>;
     set(a: A): FIO<EA, void>;
+    modify<C>(f: (b: B) => readonly [C, A], __tsplusTrace?: string | undefined): IO<never, EA | EB, C>;
 }

package/Ref/DerivedAll.d.ts

@@ -1,14 +1,18 @@
 import { Either } from "@fncts/base/data/Either/definition";
-import { FIO, IO } from "@fncts/io/IO/definition";
-import type { Atomic } from "./Atomic/Atomic.js";
+import { FIO } from "@fncts/io/IO/definition";
+import type { Atomic } from "./Atomic.js";
 import type { PRef } from "./definition.js";
+import { IO } from "@fncts/io/IO";
 import { RefInternal } from "./definition.js";
+export declare const DerivedAllTypeId: unique symbol;
+export type DerivedAllTypeId = typeof DerivedAllTypeId;
 export declare class DerivedAll<EA, EB, A, B> extends RefInternal<never, never, EA, EB, A, B> {
     readonly use: <X>(f: <S>(value: Atomic<S>, getEither: (s: S) => Either<EB, B>, setEither: (a: A) => (s: S) => Either<EA, S>) => X) => X;
-    readonly _tag = "DerivedAll";
+    readonly [DerivedAllTypeId]: DerivedAllTypeId;
     constructor(use: <X>(f: <S>(value: Atomic<S>, getEither: (s: S) => Either<EB, B>, setEither: (a: A) => (s: S) => Either<EA, S>) => X) => X);
     match<EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ca: (_: C) => Either<EC, A>, bd: (_: B) => Either<ED, D>): PRef<never, never, 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<never, never, EC, ED, C, D>;
     get get(): FIO<EB, B>;
     set(a: A): FIO<EA, void>;
+    modify<C>(f: (b: B) => readonly [C, A], __tsplusTrace?: string | undefined): IO<never, EA | EB, C>;
 }

package/Ref/Synchronized/api.d.ts

@@ -6,95 +6,97 @@ import type { PRef } from "../definition.js";
  * effectual partial function, returning a `SRef` with a `get` value that
  * succeeds with the result of the partial function if it is defined or else
  * fails with `None`.
- * @tsplus fluent fncts.io.Ref.Synchronized collectIO
+ * @tsplus pipeable fncts.io.Ref.Synchronized collectIO
  * @tsplus location "@fncts/io/Ref/Synchronized/api"
  */
-export declare function collectIO_<RA, RB, EA, EB, A, B, RC, EC, C>(ref: PRef.Synchronized<RA, RB, EA, EB, A, B>, f: (b: B) => Maybe<IO<RC, EC, C>>, __tsplusTrace?: string): PRef.Synchronized<RA, RB | RC, EA, Maybe<EB | EC>, A, C>;
+export declare function collectIO<B, RC, EC, C>(f: (b: B) => Maybe<IO<RC, EC, C>>, __tsplusTrace?: string): <RA, RB, EA, EB, A>(ref: PRef.Synchronized<RA, RB, EA, EB, A, B>) => PRef.Synchronized<RA, RC | RB, EA, import("@fncts/base/data/Maybe.js").Maybe<EC | EB>, A, C>;
 /**
  * Transforms the `set` value of the `SRef` with the specified effectual
  * function.
- * @tsplus fluent fncts.io.Ref.Synchronized contramapIO
+ * @tsplus pipeable fncts.io.Ref.Synchronized contramapIO
  * @tsplus location "@fncts/io/Ref/Synchronized/api"
  */
-export declare function contramapIO_<RA, RB, EA, EB, B, A, RC, EC, C>(ref: PRef.Synchronized<RA, RB, EA, EB, A, B>, f: (c: C) => IO<RC, EC, A>, __tsplusTrace?: string): PRef.Synchronized<RA | RC, RB, EC | EA, EB, C, B>;
+export declare function contramapIO<A, RC, EC, C>(f: (c: C) => IO<RC, EC, A>, __tsplusTrace?: string): <RA, RB, EA, EB, B>(ref: PRef.Synchronized<RA, RB, EA, EB, A, B>) => PRef.Synchronized<RC | RA, RB, EC | EA, EB, C, B>;
 /**
  * Transforms both the `set` and `get` values of the `Synchronized` with the
  * specified effectual functions.
- * @tsplus fluent fncts.io.Ref.Synchronized dimapIO
+ * @tsplus pipeable fncts.io.Ref.Synchronized dimapIO
  * @tsplus location "@fncts/io/Ref/Synchronized/api"
  */
-export declare function dimapIO_<RA, RB, EA, EB, B, RC, EC, A, RD, ED, C = A, D = B>(ref: PRef.Synchronized<RA, RB, EA, EB, A, B>, f: (c: C) => IO<RC, EC, A>, g: (b: B) => IO<RD, ED, D>, __tsplusTrace?: string): PRef.Synchronized<RA | RC, RB | RD, EA | EC, EB | ED, C, D>;
+export declare function dimapIO<A, B, RC, EC, RD, ED, C = A, D = B>(f: (c: C) => IO<RC, EC, A>, g: (b: B) => IO<RD, ED, D>, __tsplusTrace?: string): <RA, RB, EA, EB>(ref: PRef.Synchronized<RA, RB, EA, EB, A, B>) => PRef.Synchronized<RC | RA, RD | RB, EC | EA, ED | EB, C, D>;
 /**
  * Filters the `set` value of the `SRef` with the specified effectual
  * predicate, returning a `SRef` with a `set` value that succeeds if the
  * predicate is satisfied or else fails with `None`.
- * @tsplus fluent fncts.io.Ref.Synchronized filterInputIO
+ * @tsplus pipeable fncts.io.Ref.Synchronized filterInputIO
  * @tsplus location "@fncts/io/Ref/Synchronized/api"
  */
-export declare function filterInputIO_<RA, RB, EA, EB, B, A, RC, EC, A1 extends A = A>(ref: PRef.Synchronized<RA, RB, EA, EB, A, B>, f: (a: A1) => IO<RC, EC, boolean>, __tsplusTrace?: string): PRef.Synchronized<RA | RC, RB, Maybe<EC | EA>, EB, A1, B>;
+export declare function filterInputIO<RA, RB, EA, EB, B, A, RC, EC, A1 extends A = A>(f: (a: A1) => IO<RC, EC, boolean>, __tsplusTrace?: string): (self: PRef.Synchronized<RA, RB, EA, EB, A, B>) => PRef.Synchronized<RA | RC, RB, Maybe<EC | EA>, EB, A1, B>;
 /**
  * Filters the `get` value of the `SRef` with the specified effectual predicate,
  * returning a `SRef` with a `get` value that succeeds if the predicate is
  * satisfied or else fails with `None`.
- * @tsplus fluent fncts.io.Ref.Synchronized filterOutputIO
+ * @tsplus pipeable fncts.io.Ref.Synchronized filterOutputIO
  * @tsplus location "@fncts/io/Ref/Synchronized/api"
  */
-export declare function filterOutputIO_<RA, RB, EA, EB, A, B, RC, EC>(ref: PRef.Synchronized<RA, RB, EA, EB, A, B>, f: (b: B) => IO<RC, EC, boolean>, __tsplusTrace?: string): PRef.Synchronized<RA, RB | RC, EA, Maybe<EC | EB>, A, B>;
+export declare function filterOutputIO<B, RC, EC>(f: (b: B) => IO<RC, EC, boolean>, __tsplusTrace?: string): <RA, RB, EA, EB, A>(ref: PRef.Synchronized<RA, RB, EA, EB, A, B>) => PRef.Synchronized<RA, RC | RB, EA, import("@fncts/base/data/Maybe.js").Maybe<EC | EB>, A, B>;
 /**
  * Atomically modifies the `Synchronized` with the specified function, returning the
  * value immediately before modification.
+ * @tsplus pipeable fncts.io.Ref.Synchronized getAndUpdateIO
+ * @tsplus location "@fncts/io/Ref/Synchronized/api"
  */
-export declare function getAndUpdateIO_<RA, RB, EA, EB, R1, E1, A>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>, f: (a: A) => IO<R1, E1, A>, __tsplusTrace?: string): IO<RA | RB | R1, EA | EB | E1, A>;
+export declare function getAndUpdateIO<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>) => import("../../IO.js").IO<R1 | RA | RB, E1 | EA | EB, A>;
 /**
- * Atomically modifies the `SRef` with the specified function, returning the
+ * Atomically modifies the `Synchronized` with the specified function, returning the
  * value immediately before modification.
  */
-export declare function getAndUpdateJustIO_<RA, RB, EA, EB, R1, E1, A>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>, f: (a: A) => Maybe<IO<R1, E1, A>>, __tsplusTrace?: string): IO<RA | RB | R1, EA | EB | E1, A>;
+export declare function getAndUpdateJustIO<A, R1, E1>(f: (a: A) => Maybe<IO<R1, E1, A>>, __tsplusTrace?: string): <RA, RB, EA, EB>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>) => import("../../IO.js").IO<R1 | RA | RB, E1 | EA | EB, A>;
 /**
- * @tsplus fluent fncts.io.Ref.Synchronized matchIO
+ * @tsplus pipeable fncts.io.Ref.Synchronized matchIO
  * @tsplus location "@fncts/io/Ref/Synchronized/api"
  */
-export declare function matchIO_<RA, RB, EA, EB, A, B, RC, RD, EC, ED, C, D>(self: PRef.Synchronized<RA, RB, EA, EB, A, B>, ea: (_: EA) => EC, eb: (_: EB) => ED, ca: (_: C) => IO<RC, EC, A>, bd: (_: B) => IO<RD, ED, D>, __tsplusTrace?: string): PRef.Synchronized<RA | RC, RB | RD, EC, ED, C, D>;
+export declare function matchIO<EA, EB, A, B, RC, RD, EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ca: (_: C) => IO<RC, EC, A>, bd: (_: B) => IO<RD, ED, D>, __tsplusTrace?: string): <RA, RB>(self: PRef.Synchronized<RA, RB, EA, EB, A, B>) => PRef.Synchronized<RC | RA, RD | RB, EC, ED, C, D>;
 /**
- * @tsplus fluent fncts.io.Ref.Synchronized matchAllIO
+ * @tsplus pipeable fncts.io.Ref.Synchronized matchAllIO
  * @tsplus location "@fncts/io/Ref/Synchronized/api"
  */
-export declare function matchAllIO_<RA, RB, EA, EB, A, B, RC, RD, EC, ED, C, D>(self: PRef.Synchronized<RA, RB, EA, EB, A, B>, ea: (_: EA) => EC, eb: (_: EB) => ED, ec: (_: EB) => EC, ca: (_: C) => (_: B) => IO<RC, EC, A>, bd: (_: B) => IO<RD, ED, D>, __tsplusTrace?: string): PRef.Synchronized<RA | RB | RC, RB & RD, EC, ED, C, D>;
+export declare function matchAllIO<EA, EB, A, B, RC, RD, EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ec: (_: EB) => EC, ca: (_: C) => (_: B) => IO<RC, EC, A>, bd: (_: B) => IO<RD, ED, D>, __tsplusTrace?: string): <RA, RB>(self: PRef.Synchronized<RA, RB, EA, EB, A, B>) => PRef.Synchronized<RC | RA | RB, RD | RB, EC, ED, C, D>;
 /**
- * @tsplus fluent fncts.io.Ref.Synchronized modifyIO
+ * @tsplus pipeable fncts.io.Ref.Synchronized modifyIO
  * @tsplus location "@fncts/io/Ref/Synchronized/api"
  */
-export declare function modifyIO_<RA, RB, EA, EB, A, R1, E1, B>(self: PRef.Synchronized<RA, RB, EA, EB, A, A>, f: (a: A) => IO<R1, E1, readonly [B, A]>, __tsplusTrace?: string): IO<RA | RB | R1, EA | EB | E1, B>;
+export declare function modifyIO<A, R1, E1, B>(f: (a: A) => IO<R1, E1, readonly [B, A]>, __tsplusTrace?: string): <RA, RB, EA, EB>(self: PRef.Synchronized<RA, RB, EA, EB, A, A>) => import("../../IO.js").IO<R1 | RA | RB, E1 | EA | EB, B>;
 /**
  * Atomically modifies the `Synchronized` with the specified function, which computes
  * a return value for the modification if the function is defined in the current value
  * otherwise it returns a default value.
  * This is a more powerful version of `updateJust`.
- * @tsplus fluent fncts.io.Ref.Synchronized modifyJustIO
+ * @tsplus pipeable fncts.io.Ref.Synchronized modifyJustIO
  * @tsplus location "@fncts/io/Ref/Synchronized/api"
  */
-export declare function modifyJustIO_<RA, RB, EA, EB, R1, E1, A, B>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>, def: B, f: (a: A) => Maybe<IO<R1, E1, readonly [B, A]>>, __tsplusTrace?: string): IO<RA | RB | R1, EA | EB | E1, B>;
+export declare function modifyJustIO<A, R1, E1, B>(def: B, f: (a: A) => Maybe<IO<R1, E1, readonly [B, A]>>, __tsplusTrace?: string): <RA, RB, EA, EB>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>) => import("../../IO.js").IO<R1 | RA | RB, E1 | EA | EB, B>;
 /**
  * Atomically modifies the `SRef` with the specified function.
- * @tsplus fluent fncts.io.Ref.Synchronized updateAndGetIO
+ * @tsplus pipeable fncts.io.Ref.Synchronized updateAndGetIO
  * @tsplus location "@fncts/io/Ref/Synchronized/api"
  */
-export declare function updateAndGetIO_<RA, RB, EA, EB, R1, E1, A>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>, f: (a: A) => IO<R1, E1, A>, __tsplusTrace?: string): 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>) => import("../../IO.js").IO<R1 | RA | RB, E1 | EA | EB, void>;
 /**
  * Atomically modifies the `Synchronized` with the specified function.
- * @tsplus fluent fncts.io.Ref.Synchronized updateIO
+ * @tsplus pipeable fncts.io.Ref.Synchronized updateIO
  * @tsplus location "@fncts/io/Ref/Synchronized/api"
  */
-export declare function updateIO_<RA, RB, EA, EB, R1, E1, A>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>, f: (a: A) => IO<R1, E1, A>, __tsplusTrace?: string): IO<RA | RB | R1, E1 | EA | EB, void>;
+export declare function updateIO<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>) => import("../../IO.js").IO<R1 | RA | RB, E1 | EA | EB, void>;
 /**
  * Atomically modifies the `SRef` with the specified function.
- * @tsplus fluent fncts.io.Ref.Synchronized updateJustAndGetIO
+ * @tsplus pipeable fncts.io.Ref.Synchronized updateJustAndGetIO
  * @tsplus location "@fncts/io/Ref/Synchronized/api"
  */
-export declare function updateJustAndGetIO_<RA, RB, EA, EB, R1, E1, A>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>, f: (a: A) => Maybe<IO<R1, E1, A>>, __tsplusTrace?: string): IO<RA | RB | R1, E1 | EA | EB, A>;
+export declare function updateJustAndGetIO<A, R1, E1>(f: (a: A) => Maybe<IO<R1, E1, A>>, __tsplusTrace?: string): <RA, RB, EA, EB>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>) => import("../../IO.js").IO<R1 | RA | RB, E1 | EA | EB, A>;
 /**
  * Atomically modifies the `SRef` with the specified function.
- * @tsplus fluent fncts.io.Ref.Synchronized updateJustIO
+ * @tsplus pipeable fncts.io.Ref.Synchronized updateJustIO
  * @tsplus location "@fncts/io/Ref/Synchronized/api"
  */
-export declare function updateJustIO_<RA, RB, EA, EB, R1, E1, A>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>, f: (a: A) => Maybe<IO<R1, E1, A>>, __tsplusTrace?: string): IO<RA | RB | R1, E1 | EA | EB, void>;
+export declare function updateJustIO<A, R1, E1>(f: (a: A) => Maybe<IO<R1, E1, A>>, __tsplusTrace?: string): <RA, RB, EA, EB>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>) => import("../../IO.js").IO<R1 | RA | RB, E1 | EA | EB, void>;

package/Ref/Synchronized/constructors.d.ts

@@ -1,6 +1,6 @@
 import { Lazy } from "@fncts/base/data/function/definition";
 import { UIO } from "@fncts/io/IO/definition";
-import { Ref } from "@fncts/io/Ref";
+import { Ref } from "@fncts/io/Ref/definition";
 /**
  * @tsplus static fncts.io.Ref.SynchronizedOps make
  * @tsplus location "@fncts/io/Ref/Synchronized/constructors"

package/Ref/Synchronized/definition.d.ts

@@ -1,13 +1,13 @@
 import { TSemaphore } from "@fncts/io/TSemaphore/definition";
-import { IO } from "@fncts/io/IO/definition";
 import { Either } from "@fncts/base/data/Either/definition";
-import { STM } from "@fncts/io/STM/definition";
 import type { PRef } from "../definition.js";
+import { IO } from "@fncts/io/IO";
 import { RefInternal } from "../definition.js";
 /**
  * @tsplus type fncts.io.Ref.Synchronized
  */
 export interface PSynchronized<RA, RB, EA, EB, A, B> extends PRef<RA, RB, EA, EB, A, B> {
+    readonly _tag: "Synchronized";
 }
 /**
  * @tsplus type fncts.io.Ref.SynchronizedOps
@@ -23,13 +23,15 @@ export declare const Synchronized: PSynchronizedOps;
  * @tsplus type fncts.io.Ref.Synchronized
  */
 export declare class PSynchronizedInternal<RA, RB, EA, EB, A, B> extends RefInternal<RA, RB, EA, EB, A, B> {
-    readonly semaphores: Set<TSemaphore>;
+    readonly semaphore: TSemaphore;
     readonly unsafeGet: IO<RB, EB, B>;
     readonly unsafeSet: (a: A) => IO<RA, EA, void>;
     readonly _tag = "Synchronized";
-    constructor(semaphores: Set<TSemaphore>, unsafeGet: IO<RB, EB, B>, unsafeSet: (a: A) => IO<RA, EA, void>);
+    constructor(semaphore: TSemaphore, unsafeGet: IO<RB, EB, B>, unsafeSet: (a: A) => IO<RA, EA, void>);
     get get(): IO<RB, EB, B>;
     set(a: A, __tsplusTrace?: string): IO<RA, EA, void>;
+    modify<C>(f: (b: B) => readonly [C, A], __tsplusTrace?: string | undefined): IO<RA | RB, EA | EB, C>;
+    modifyIO<R1, E1, C>(f: (b: B) => IO<R1, E1, readonly [C, A]>, __tsplusTrace?: string): IO<RA | RB | R1, EA | EB | E1, C>;
     matchAllIO<RC, RD, EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ec: (_: EB) => EC, ca: (_: C) => (_: B) => IO<RC, EC, A>, bd: (_: B) => IO<RD, ED, D>, __tsplusTrace?: string): PSynchronizedInternal<RA | RC | RB, RB | RD, EC, ED, C, D>;
     matchIO<RC, RD, EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ca: (_: C) => IO<RC, EC, A>, bd: (_: B) => IO<RD, ED, D>, __tsplusTrace?: string): PSynchronizedInternal<RA | RC, RB | RD, EC, ED, C, D>;
     match<EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ca: (_: C) => Either<EC, A>, bd: (_: B) => Either<ED, D>, __tsplusTrace?: string): PSynchronizedInternal<RA, RB, EC, ED, C, D>;

package/Ref/Synchronized.d.ts

@@ -0,0 +1,3 @@
+export * from "./Synchronized/api.js";
+export * from "./Synchronized/constructors.js";
+export * from "./Synchronized/definition.js";

package/Ref/api/collect.d.ts

@@ -4,8 +4,8 @@ import type { PRef } from "../definition.js";
  * Maps and filters the `get` value of the `Ref` with the specified partial
  * function, returning a `Ref` with a `get` value that succeeds with the
  * result of the partial function if it is defined or else fails with `None`.
- * @tsplus fluent fncts.io.Ref collect
- * @tsplus fluent fncts.io.Ref.Synchronized collect
+ * @tsplus pipeable fncts.io.Ref collect
+ * @tsplus pipeable fncts.io.Ref.Synchronized collect
  * @tsplus location "@fncts/io/Ref/api/collect"
  */
-export declare function collect_<RA, RB, EA, EB, A, B, C>(ref: PRef<RA, RB, EA, EB, A, B>, pf: (_: B) => Maybe<C>, __tsplusTrace?: string): PRef<RA, RB, EA, Maybe<EB>, A, C>;
+export declare function collect<B, C>(pf: (_: B) => Maybe<C>, __tsplusTrace?: string): <RA, RB, EA, EB, A>(ref: PRef<RA, RB, EA, EB, A, B>) => PRef<RA, RB, EA, import("@fncts/base/data/Maybe.js").Maybe<EB>, A, C>;

package/Ref/api/dimap.d.ts

@@ -2,55 +2,55 @@ import { Either } from "@fncts/base/data/Either/definition";
 import type { PRef } from "../definition.js";
 /**
  * Transforms the `set` value of the `Ref` with the specified function.
- * @tsplus fluent fncts.io.Ref contramap
- * @tsplus fluent fncts.io.Ref.Synchronized contramap
+ * @tsplus pipeable fncts.io.Ref contramap
+ * @tsplus pipeable fncts.io.Ref.Synchronized contramap
  * @tsplus location "@fncts/io/Ref/api/dimap"
  */
-export declare function contramap_<RA, RB, EA, EB, B, A, C>(ref: PRef<RA, RB, EA, EB, A, B>, f: (_: C) => A, __tsplusTrace?: string): PRef<RA, RB, EA, EB, C, B>;
+export declare function contramap<A, C>(f: (_: C) => A, __tsplusTrace?: string): <RA, RB, EA, EB, B>(self: PRef<RA, RB, EA, EB, A, B>) => PRef<RA, RB, EA, EB, C, B>;
 /**
  * Transforms the `set` value of the `Ref` with the specified fallible
  * function.
- * @tsplus fluent fncts.io.Ref contramapEither
- * @tsplus fluent fncts.io.Ref.Synchronized contramapEither
+ * @tsplus pipeable fncts.io.Ref contramapEither
+ * @tsplus pipeable fncts.io.Ref.Synchronized contramapEither
  * @tsplus location "@fncts/io/Ref/api/dimap"
  */
-export declare function contramapEither_<RA, RB, EA, EB, A, B, EC, C>(ref: PRef<RA, RB, EA, EB, A, B>, f: (_: C) => Either<EC, A>, __tsplusTrace?: string): PRef<RA, RB, EC | EA, EB, C, B>;
+export declare function contramapEither<A, EC, C>(f: (_: C) => Either<EC, A>, __tsplusTrace?: string): <RA, RB, EA, EB, B>(self: PRef<RA, RB, EA, EB, A, B>) => PRef<RA, RB, EC | EA, EB, C, B>;
 /**
  * Transforms both the `set` and `get` values of the `Ref` with the
  * specified functions.
- * @tsplus fluent fncts.io.Ref dimap
- * @tsplus fluent fncts.io.Ref.Synchronized dimap
+ * @tsplus pipeable fncts.io.Ref dimap
+ * @tsplus pipeable fncts.io.Ref.Synchronized dimap
  * @tsplus location "@fncts/io/Ref/api/dimap"
  */
-export declare function dimap_<RA, RB, EA, EB, A, B, C, D>(ref: PRef<RA, RB, EA, EB, A, B>, f: (_: C) => A, g: (_: B) => D, __tsplusTrace?: string): PRef<RA, RB, EA, EB, C, D>;
+export declare function dimap<A, B, C, D>(f: (_: C) => A, g: (_: B) => D, __tsplusTrace?: string): <RA, RB, EA, EB>(self: PRef<RA, RB, EA, EB, A, B>) => PRef<RA, RB, EA, EB, C, D>;
 /**
  * Transforms both the `set` and `get` values of the `Ref` with the
  * specified fallible functions.
- * @tsplus fluent fncts.io.Ref dimapEither
- * @tsplus fluent fncts.io.Ref.Synchronized dimapEither
+ * @tsplus pipeable fncts.io.Ref dimapEither
+ * @tsplus pipeable fncts.io.Ref.Synchronized dimapEither
  * @tsplus location "@fncts/io/Ref/api/dimap"
  */
-export declare function dimapEither_<RA, RB, EA, EB, A, B, C, EC, D, ED>(ref: PRef<RA, RB, EA, EB, A, B>, f: (_: C) => Either<EC, A>, g: (_: B) => Either<ED, D>, __tsplusTrace?: string): PRef<RA, RB, EC | EA, ED | EB, C, D>;
+export declare function dimapEither<A, B, C, EC, D, ED>(f: (_: C) => Either<EC, A>, g: (_: B) => Either<ED, D>, __tsplusTrace?: string): <RA, RB, EA, EB>(ref: PRef<RA, RB, EA, EB, A, B>) => PRef<RA, RB, EC | EA, ED | EB, C, D>;
 /**
  * Transforms both the `set` and `get` errors of the `Ref` with the
  * specified functions.
- * @tsplus fluent fncts.io.Ref dimapError
- * @tsplus fluent fncts.io.Ref.Synchronized dimapError
+ * @tsplus pipeable fncts.io.Ref dimapError
+ * @tsplus pipeable fncts.io.Ref.Synchronized dimapError
  * @tsplus location "@fncts/io/Ref/api/dimap"
  */
-export declare function dimapError_<RA, RB, EA, EB, A, B, EC, ED>(ref: PRef<RA, RB, EA, EB, A, B>, f: (_: EA) => EC, g: (_: EB) => ED, __tsplusTrace?: string): PRef<RA, RB, EC, ED, A, B>;
+export declare function dimapError<EA, EB, EC, ED>(f: (_: EA) => EC, g: (_: EB) => ED, __tsplusTrace?: string): <RA, RB, A, B>(ref: PRef<RA, RB, EA, EB, A, B>) => PRef<RA, RB, EC, ED, A, B>;
 /**
  * Transforms the `get` value of the `Ref` with the specified fallible
  * function.
- * @tsplus fluent fncts.io.Ref mapEither
- * @tsplus fluent fncts.io.Ref.Synchronized mapEither
+ * @tsplus pipeable fncts.io.Ref mapEither
+ * @tsplus pipeable fncts.io.Ref.Synchronized mapEither
  * @tsplus location "@fncts/io/Ref/api/dimap"
  */
-export declare function mapEither_<RA, RB, EA, EB, A, B, EC, C>(ref: PRef<RA, RB, EA, EB, A, B>, f: (_: B) => Either<EC, C>, __tsplusTrace?: string): PRef<RA, RB, EA, EC | EB, A, C>;
+export declare function mapEither<B, EC, C>(f: (_: B) => Either<EC, C>, __tsplusTrace?: string): <RA, RB, EA, EB, A>(ref: PRef<RA, RB, EA, EB, A, B>) => PRef<RA, RB, EA, EC | EB, A, C>;
 /**
  * Transforms the `get` value of the `Ref` with the specified function.
- * @tsplus fluent fncts.io.Ref map
- * @tsplus fluent fncts.io.Ref.Synchronized map
+ * @tsplus pipeable fncts.io.Ref map
+ * @tsplus pipeable fncts.io.Ref.Synchronized map
  * @tsplus location "@fncts/io/Ref/api/dimap"
  */
-export declare function map_<RA, RB, EA, EB, A, B, C>(ref: PRef<RA, RB, EA, EB, A, B>, f: (_: B) => C, __tsplusTrace?: string): PRef<RA, RB, EA, EB, A, C>;
+export declare function map<B, C>(f: (_: B) => C, __tsplusTrace?: string): <RA, RB, EA, EB, A>(ref: PRef<RA, RB, EA, EB, A, B>) => PRef<RA, RB, EA, EB, A, C>;