@fncts/io 0.0.20 → 0.0.21

package/Sink/api.d.ts

@@ -1,5 +1,5 @@
-import { Sink } from "@fncts/io/Sink/definition";
 import { Lazy } from "@fncts/base/data/function/definition";
+import { Sink } from "@fncts/io/Sink/definition";
 import { Conc, ConcBuilder } from "@fncts/base/collection/immutable/Conc";
 import { Predicate } from "@fncts/base/data/Predicate/definition";
 import { Channel } from "@fncts/io/Channel";
@@ -9,7 +9,7 @@ import { Cause } from "@fncts/base/data/Cause/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Either } from "@fncts/base/data/Either/definition";
 import { Scope } from "@fncts/io/Scope/definition";
-import { Queue } from "@fncts/io/Queue/definition";
+import { Enqueue } from "@fncts/io/Queue/definition";
 import { Hub } from "@fncts/io/Hub/definition";
 import { Exit } from "@fncts/base/data/Exit/definition";
 import { Tag } from "@fncts/base/data/Tag/definition";
@@ -18,48 +18,48 @@ import { Duration } from "@fncts/base/data/Duration/definition";
 import { MergeDecision } from "../Channel/internal/MergeDecision.js";
 /**
  * Like {@link zip }, but keeps only the result from this sink
- * @tsplus fluent fncts.io.Sink apFirst
+ * @tsplus pipeable fncts.io.Sink apFirst
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function apFirst<R, E, In, L, Z, R1, E1, In1 extends In, L1 extends L, Z1>(self: Sink<R, E, In, L, Z>, that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): Sink<R | R1, E | E1, In & In1, L | L1, Z>;
+export declare function apFirst<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): <R, E, Z_1>(self: import("./definition.js").Sink<R, E, In, L, Z_1>) => import("./definition.js").Sink<R1 | R, E1 | E, In & In1, L | L1, Z_1>;
 /**
  * Like {@link zipC }, but keeps only the result from this sink
- * @tsplus fluent fncts.io.Sink apFirstC
+ * @tsplus pipeable fncts.io.Sink apFirstC
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function apFirstC<R, E, In, L, Z, R1, E1, In1 extends In, L1 extends L, Z1>(self: Sink<R, E, In, L, Z>, that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): Sink<R | R1, E | E1, In & In1, L | L1, Z>;
+export declare function apFirstC<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): <R, E, Z_1>(self: import("./definition.js").Sink<R, E, In, L, Z_1>) => import("./definition.js").Sink<R1 | R, E1 | E, In & In1, L | L1, Z_1>;
 /**
  * Like {@link zip }, but keeps only the result from the `that` sink
- * @tsplus fluent fncts.io.Sink apSecond
+ * @tsplus pipeable fncts.io.Sink apSecond
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function apSecond<R, E, In, L, Z, R1, E1, In1 extends In, L1 extends L, Z1>(self: Sink<R, E, In, L, Z>, that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): Sink<R | R1, E | E1, In & In1, L | L1, Z1>;
+export declare function apSecond<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): <R, E, Z_1>(self: import("./definition.js").Sink<R, E, In, L, Z_1>) => import("./definition.js").Sink<R1 | R, E1 | E, In & In1, L | L1, Z1>;
 /**
  * Like {@link zipC }, but keeps only the result from the `that` sink
- * @tsplus fluent fncts.io.Sink apSecondC
+ * @tsplus pipeable fncts.io.Sink apSecondC
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function apSecondC<R, E, In, L, Z, R1, E1, In1 extends In, L1 extends L, Z1>(self: Sink<R, E, In, L, Z>, that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): Sink<R | R1, E | E1, In & In1, L | L1, Z1>;
+export declare function apSecondC<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): <R, E, Z_1>(self: import("./definition.js").Sink<R, E, In, L, Z_1>) => import("./definition.js").Sink<R1 | R, E1 | E, In & In1, L | L1, Z1>;
 /**
  * Replaces this sink's result with the provided value.
- * @tsplus fluent fncts.io.Sink as
+ * @tsplus pipeable fncts.io.Sink as
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function as<R, E, In, L, Z, Z1>(self: Sink<R, E, In, L, Z>, z: Lazy<Z1>, __tsplusTrace?: string): Sink<R, E, In, L, Z1>;
+export declare function as<Z1>(z: Lazy<Z1>, __tsplusTrace?: string): <R, E, In, L, Z_1>(self: import("./definition.js").Sink<R, E, In, L, Z_1>) => import("./definition.js").Sink<R, E, In, L, Z1>;
 /**
  * Repeatedly runs the sink and accumulates its results into a chunk
- * @tsplus fluent fncts.io.Sink collectAll
+ * @tsplus pipeable fncts.io.Sink collectAll
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function collectAll<R, E, In extends L, L, Z>(self: Sink<R, E, In, L, Z>, __tsplusTrace?: string): Sink<R, E, In, L, Conc<Z>>;
+export declare function collectAll(__tsplusTrace?: string): <R, E, In extends L, L, Z_1>(self: import("./definition.js").Sink<R, E, In, L, Z_1>) => import("./definition.js").Sink<R, E, In, L, import("@fncts/base/collection/immutable/Conc.js").Conc<Z_1>>;
 /**
  * Repeatedly runs the sink for as long as its results satisfy the predicate
  * `p`. The sink's results will be accumulated using the stepping function
  * `f`.
- * @tsplus fluent fncts.io.Sink collectAllWhileWith
+ * @tsplus pipeable fncts.io.Sink collectAllWhileWith
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function collectAllWhileWith<R, E, In extends L, L, Z, S>(self: Sink<R, E, In, L, Z>, z: Lazy<S>, p: Predicate<Z>, f: (s: S, z: Z) => S, __tsplusTrace?: string): Sink<R, E, In, L, S>;
+export declare function collectAllWhileWith<Z, S>(z: Lazy<S>, p: Predicate<Z>, f: (s: S, z: Z) => S, __tsplusTrace?: string): <R, E, In extends L, L>(self: import("./definition.js").Sink<R, E, In, L, Z>) => import("./definition.js").Sink<R, E, In, L, S>;
 /**
  * Collects the leftovers from the stream when the sink succeeds and returns
  * them as part of the sink's result
@@ -69,57 +69,57 @@ export declare function collectAllWhileWith<R, E, In extends L, L, Z, S>(self: S
 export declare function collectLeftover<R, E, In, L, Z>(self: Sink<R, E, In, L, Z>, __tsplusTrace?: string): Sink<R, E, In, never, readonly [Z, Conc<L>]>;
 /**
  * Transforms this sink's input elements.
- * @tsplus fluent fncts.io.Sink contramap
+ * @tsplus pipeable fncts.io.Sink contramap
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function contramap<R, E, In, L, Z, In1>(self: Sink<R, E, In, L, Z>, f: (inp: In1) => In, __tsplusTrace?: string): Sink<R, E, In1, L, Z>;
+export declare function contramap<In, In1>(f: (inp: In1) => In, __tsplusTrace?: string): <R, E, L, Z_1>(self: import("./definition.js").Sink<R, E, In, L, Z_1>) => import("./definition.js").Sink<R, E, In1, L, Z_1>;
 /**
  * Transforms this sink's input chunks. `f` must preserve chunking-invariance
- * @tsplus fluent fncts.io.Sink contramapChunks
+ * @tsplus pipeable fncts.io.Sink contramapChunks
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function contramapChunks<R, E, In, L, Z, In1>(self: Sink<R, E, In, L, Z>, f: (chunk: Conc<In1>) => Conc<In>, __tsplusTrace?: string): Sink<R, E, In1, L, Z>;
+export declare function contramapChunks<In, In1>(f: (chunk: Conc<In1>) => Conc<In>, __tsplusTrace?: string): <R, E, L, Z_1>(self: import("./definition.js").Sink<R, E, In, L, Z_1>) => import("./definition.js").Sink<R, E, In1, L, Z_1>;
 /**
  * Effectfully transforms this sink's input chunks. `f` must preserve
  * chunking-invariance
- * @tsplus fluent fncts.io.Sink contramapChunksIO
+ * @tsplus pipeable fncts.io.Sink contramapChunksIO
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function contramapChunksIO<R, E, In, L, Z, R1, E1, In1>(self: Sink<R, E, In, L, Z>, f: (chunk: Conc<In1>) => IO<R1, E1, Conc<In>>, __tsplusTrace?: string): Sink<R | R1, E | E1, In1, L, Z>;
+export declare function contramapChunksIO<In, R1, E1, In1>(f: (chunk: Conc<In1>) => IO<R1, E1, Conc<In>>, __tsplusTrace?: string): <R, E, L, Z_1>(self: import("./definition.js").Sink<R, E, In, L, Z_1>) => import("./definition.js").Sink<R1 | R, E1 | E, In1, L, Z_1>;
 /**
  * Effectfully transforms this sink's input elements.
- * @tsplus fluent fncts.io.Sink contramapIO
+ * @tsplus pipeable fncts.io.Sink contramapIO
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function contramapIO<R, E, In, L, Z, R1, E1, In1>(self: Sink<R, E, In, L, Z>, f: (inp: In1) => IO<R1, E1, In>, __tsplusTrace?: string): Sink<R | R1, E | E1, In1, L, Z>;
+export declare function contramapIO<In, R1, E1, In1>(f: (inp: In1) => IO<R1, E1, In>, __tsplusTrace?: string): <R, E, L, Z_1>(self: import("./definition.js").Sink<R, E, In, L, Z_1>) => import("./definition.js").Sink<R1 | R, E1 | E, In1, L, Z_1>;
 /**
  * Transforms both inputs and result of this sink using the provided
  * functions.
- * @tsplus fluent fncts.io.Sink dimap
+ * @tsplus pipeable fncts.io.Sink dimap
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function dimap<R, E, In, L, Z, In1, Z1>(self: Sink<R, E, In, L, Z>, f: (inp: In1) => In, g: (z: Z) => Z1, __tsplusTrace?: string): Sink<R, E, In1, L, Z1>;
+export declare function dimap<In, Z, In1, Z1>(f: (inp: In1) => In, g: (z: Z) => Z1, __tsplusTrace?: string): <R, E, L>(self: import("./definition.js").Sink<R, E, In, L, Z>) => import("./definition.js").Sink<R, E, In1, L, Z1>;
 /**
  * Transforms both input chunks and result of this sink using the provided
  * functions.
- * @tsplus fluent fncts.io.Sink dimapChunks
+ * @tsplus pipeable fncts.io.Sink dimapChunks
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function dimapChunks<R, E, In, L, Z, In1, Z1>(self: Sink<R, E, In, L, Z>, f: (chunk: Conc<In1>) => Conc<In>, g: (z: Z) => Z1, __tsplusTrace?: string): Sink<R, E, In1, L, Z1>;
+export declare function dimapChunks<In, Z, In1, Z1>(f: (chunk: Conc<In1>) => Conc<In>, g: (z: Z) => Z1, __tsplusTrace?: string): <R, E, L>(self: import("./definition.js").Sink<R, E, In, L, Z>) => import("./definition.js").Sink<R, E, In1, L, Z1>;
 /**
  * Effectfully transforms both input chunks and result of this sink using the
  * provided functions. `f` and `g` must preserve chunking-invariance
- * @tsplus fluent fncts.io.Sink dimapChunksIO
+ * @tsplus pipeable fncts.io.Sink dimapChunksIO
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function dimapChunksIO<R, E, In, L, Z, R1, E1, In1, R2, E2, Z1>(self: Sink<R, E, In, L, Z>, f: (chunk: Conc<In1>) => IO<R1, E1, Conc<In>>, g: (z: Z) => IO<R2, E2, Z1>, __tsplusTrace?: string): Sink<R | R1 | R2, E | E1 | E2, In1, L, Z1>;
+export declare function dimapChunksIO<In, Z, R1, E1, In1, R2, E2, Z1>(f: (chunk: Conc<In1>) => IO<R1, E1, Conc<In>>, g: (z: Z) => IO<R2, E2, Z1>, __tsplusTrace?: string): <R, E, L>(self: import("./definition.js").Sink<R, E, In, L, Z>) => import("./definition.js").Sink<R1 | R2 | R, E1 | E2 | E, In1, L, Z1>;
 /**
  * Effectfully transforms both inputs and result of this sink using the
  * provided functions.
- * @tsplus fluent fncts.io.Sink dimapIO
+ * @tsplus pipeable fncts.io.Sink dimapIO
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function dimapIO<R, E, In, L, Z, R1, E1, In1, R2, E2, Z1>(self: Sink<R, E, In, L, Z>, f: (inp: In1) => IO<R1, E1, In>, g: (z: Z) => IO<R2, E2, Z1>, __tsplusTrace?: string): Sink<R | R1 | R2, E | E1 | E2, In1, L, Z1>;
+export declare function dimapIO<In, Z, R1, E1, In1, R2, E2, Z1>(f: (inp: In1) => IO<R1, E1, In>, g: (z: Z) => IO<R2, E2, Z1>, __tsplusTrace?: string): <R, E, L>(self: import("./definition.js").Sink<R, E, In, L, Z>) => import("./definition.js").Sink<R1 | R2 | R, E1 | E2 | E, In1, L, Z1>;
 /**
  * Returns a lazily constructed sink that may require effects for its
  * creation.
@@ -220,20 +220,20 @@ export declare function filterInput<R, E, In, L, Z>(self: Sink<R, E, In, L, Z>,
 export declare function filterInputIO<R, E, In, L, Z, R1, E1>(self: Sink<R, E, In, L, Z>, p: (inp: In) => IO<R1, E1, boolean>, __tsplusTrace?: string): Sink<R | R1, E | E1, In, L, Z>;
 /**
  * Creates a sink that produces values until one verifies the predicate `f`.
- * @tsplus fluent fncts.io.Sink findIO
+ * @tsplus pipeable fncts.io.Sink findIO
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function findIO<R, E, In extends L, L, Z, R1, E1>(self: Sink<R, E, In, L, Z>, f: (z: Z) => IO<R1, E1, boolean>, __tsplusTrace?: string): Sink<R | R1, E | E1, In, L, Maybe<Z>>;
+export declare function findIO<Z, R1, E1>(f: (z: Z) => IO<R1, E1, boolean>, __tsplusTrace?: string): <R, E, In extends L, L>(self: import("./definition.js").Sink<R, E, In, L, Z>) => import("./definition.js").Sink<R1 | R, E1 | E, In, L, import("@fncts/base/data/Maybe.js").Maybe<Z>>;
 /**
  * Runs this sink until it yields a result, then uses that result to create
  * another sink from the provided function which will continue to run until it
  * yields a result.
  *
  * This function essentially runs sinks in sequence.
- * @tsplus fluent fncts.io.Sink flatMap
+ * @tsplus pipeable fncts.io.Sink flatMap
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function flatMap<R, E, In, L, Z, R1, E1, In1 extends In, L1, Z1>(self: Sink<R, E, In, L, Z>, f: (z: Z) => Sink<R1, E1, In1, L1, Z1>, __tsplusTrace?: string): Sink<R | R1, E | E1, In1, L | L1, Z1>;
+export declare function flatMap<In, Z, R1, E1, In1 extends In, L1, Z1>(f: (z: Z) => Sink<R1, E1, In1, L1, Z1>, __tsplusTrace?: string): <R, E, L>(self: import("./definition.js").Sink<R, E, In, L, Z>) => import("./definition.js").Sink<R1 | R, E1 | E, In1, L1 | L, Z1>;
 /**
  * Creates a sink from a {@link Channel }
  * @tsplus static fncts.io.SinkOps fromChannel
@@ -252,14 +252,14 @@ export declare function fromPush<R, E, In, L, Z, R1>(push: IO<R, never, (_: Mayb
  * @tsplus static fncts.io.SinkOps fromQueue
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function fromQueue<In>(queue: Lazy<Queue.Enqueue<In>>, __tsplusTrace?: string): Sink<never, never, In, never, void>;
+export declare function fromQueue<In>(queue: Lazy<Enqueue<In>>, __tsplusTrace?: string): Sink<never, never, In, never, void>;
 /**
  * Create a sink which enqueues each element into the specified queue. The
  * queue will be shutdown once the stream is closed.
  * @tsplus static fncts.io.SinkOps fromQueueWithShutdown
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function fromQueueWithShutdown<In>(queue: Lazy<Queue.Enqueue<In>>, __tsplusTrace?: string): Sink<never, never, In, never, void>;
+export declare function fromQueueWithShutdown<In>(queue: Lazy<Enqueue<In>>, __tsplusTrace?: string): Sink<never, never, In, never, void>;
 /**
  * Create a sink which publishes each element to the specified hub.
  * @tsplus static fncts.io.SinkOps fromHub
@@ -498,66 +498,66 @@ export declare function makeFoldWeighted<In, S>(z: Lazy<S>, costFn: (s: S, inp:
 export declare function makeFoldWeightedIO<R, E, In, S, R1, E1>(z: Lazy<S>, costFn: (s: S, inp: In) => IO<R, E, number>, max: Lazy<number>, f: (s: S, inp: In) => IO<R1, E1, S>, __tsplusTrace?: string): Sink<R | R1, E | E1, In, In, S>;
 /**
  * Transforms this sink's result.
- * @tsplus fluent fncts.io.Sink map
+ * @tsplus pipeable fncts.io.Sink map
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function map_<R, E, In, L, Z, Z1>(self: Sink<R, E, In, L, Z>, f: (z: Z) => Z1, __tsplusTrace?: string): Sink<R, E, In, L, Z1>;
+export declare function map<Z, Z1>(f: (z: Z) => Z1, __tsplusTrace?: string): <R, E, In, L>(self: import("./definition.js").Sink<R, E, In, L, Z>) => import("./definition.js").Sink<R, E, In, L, Z1>;
 /**
  * Transforms the errors emitted by this sink using `f`.
- * @tsplus fluent fncts.io.Sink mapError
+ * @tsplus pipeable fncts.io.Sink mapError
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function mapError_<R, E, In, L, Z, E1>(self: Sink<R, E, In, L, Z>, f: (e: E) => E1, __tsplusTrace?: string): Sink<R, E1, In, L, Z>;
+export declare function mapError<E, E1>(f: (e: E) => E1, __tsplusTrace?: string): <R, In, L, Z_1>(self: import("./definition.js").Sink<R, E, In, L, Z_1>) => import("./definition.js").Sink<R, E1, In, L, Z_1>;
 /**
  * Effectfully transforms this sink's result.
- * @tsplus fluent fncts.io.Sink mapIO
+ * @tsplus pipeable fncts.io.Sink mapIO
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function mapIO_<R, E, In, L, Z, R1, E1, Z1>(self: Sink<R, E, In, L, Z>, f: (z: Z) => IO<R1, E1, Z1>, __tsplusTrace?: string): Sink<R | R1, E | E1, In, L, Z1>;
+export declare function mapIO<Z, R1, E1, Z1>(f: (z: Z) => IO<R1, E1, Z1>, __tsplusTrace?: string): <R, E, In, L>(self: import("./definition.js").Sink<R, E, In, L, Z>) => import("./definition.js").Sink<R1 | R, E1 | E, In, L, Z1>;
 /**
  * Runs this sink until it yields a result, then uses that result to create
  * another sink from the provided function which will continue to run until it
  * yields a result.
  *
  * This function essentially runs sinks in sequence.
- * @tsplus fluent fncts.io.Sink matchSink
+ * @tsplus pipeable fncts.io.Sink matchSink
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function matchSink_<R, E, In, L, Z, R1, E1, In1 extends In, L1, Z1, R2, E2, In2 extends In, L2, Z2>(self: Sink<R, E, In, L, Z>, onFailure: (e: E) => Sink<R1, E1, In1, L1, Z1>, onSuccess: (z: Z) => Sink<R2, E2, In2, L2, Z2>, __tsplusTrace?: string): Sink<R | R1 | R2, E1 | E2, In1 & In2, L | L1 | L2, Z1 | Z2>;
+export declare function matchSink<E, In, Z, R1, E1, In1 extends In, L1, Z1, R2, E2, In2 extends In, L2, Z2>(onFailure: (e: E) => Sink<R1, E1, In1, L1, Z1>, onSuccess: (z: Z) => Sink<R2, E2, In2, L2, Z2>, __tsplusTrace?: string): <R, L>(self: import("./definition.js").Sink<R, E, In, L, Z>) => import("./definition.js").Sink<R1 | R2 | R, E1 | E2, In1 & In2, L1 | L2 | L, Z1 | Z2>;
 /**
  * Switch to another sink in case of failure
- * @tsplus fluent fncts.io.Sink orElse
+ * @tsplus pipeable fncts.io.Sink orElse
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function orElse<R, E, In, L, Z, R1, E1, In1, L1, Z1>(self: Sink<R, E, In, L, Z>, that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): Sink<R | R1, E | E1, In & In1, L | L1, Z | Z1>;
+export declare function orElse<R1, E1, In1, L1, Z1>(that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): <R, E, In, L, Z_1>(self: import("./definition.js").Sink<R, E, In, L, Z_1>) => import("./definition.js").Sink<R1 | R, E1 | E, In & In1, L1 | L, Z1 | Z_1>;
 /**
  * Provides the sink with its required environment, which eliminates its
  * dependency on `R`.
- * @tsplus fluent fncts.io.Sink provideEnvironment
+ * @tsplus pipeable fncts.io.Sink provideEnvironment
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function provideEnvironment<R, E, In, L, Z>(self: Sink<R, E, In, L, Z>, r: Lazy<Environment<R>>, __tsplusTrace?: string): Sink<never, E, In, L, Z>;
+export declare function provideEnvironment<R>(r: Lazy<Environment<R>>, __tsplusTrace?: string): <E, In, L, Z_1>(self: import("./definition.js").Sink<R, E, In, L, Z_1>) => import("./definition.js").Sink<never, E, In, L, Z_1>;
 /**
  * Runs both sinks in parallel on the input, returning the result or the
  * error from the one that finishes first.
- * @tsplus fluent fncts.io.Sink race
+ * @tsplus pipeable fncts.io.Sink race
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function race<R, E, In, L, Z, R1, E1, In1, L1, Z1>(self: Sink<R, E, In, L, Z>, that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): Sink<R | R1, E | E1, In & In1, L | L1, Z | Z1>;
+export declare function race<R1, E1, In1, L1, Z1>(that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): <R, E, In, L, Z_1>(self: import("./definition.js").Sink<R, E, In, L, Z_1>) => import("./definition.js").Sink<R1 | R, E1 | E, In & In1, L1 | L, Z1 | Z_1>;
 /**
  * Runs both sinks in parallel on the input, returning the result or the error
  * from the one that finishes first.
- * @tsplus fluent fncts.io.Sink raceBoth
+ * @tsplus pipeable fncts.io.Sink raceBoth
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function raceBoth<R, E, In, L, Z, R1, E1, In1, L1, Z1>(self: Sink<R, E, In, L, Z>, that: Lazy<Sink<R1, E1, In1, L1, Z1>>, capacity?: Lazy<number>, __tsplusTrace?: string): Sink<R | R1, E | E1, In & In1, L | L1, Either<Z, Z1>>;
+export declare function raceBoth<R1, E1, In1, L1, Z1>(that: Lazy<Sink<R1, E1, In1, L1, Z1>>, capacity?: Lazy<number>, __tsplusTrace?: string): <R, E, In, L, Z_1>(self: import("./definition.js").Sink<R, E, In, L, Z_1>) => import("./definition.js").Sink<R1 | R, E1 | E, In & In1, L1 | L, import("@fncts/base/data/Either.js").Either<Z_1, Z1>>;
 /**
  * Runs both sinks in parallel on the input, using the specified merge
  * function as soon as one result or the other has been computed.
- * @tsplus fluent fncts.io.Sink raceWith
+ * @tsplus pipeable fncts.io.Sink raceWith
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function raceWith<R, E, In, L, Z, R1, E1, In1, L1, Z1, R2, E2, Z2, R3, E3, Z3>(self: Sink<R, E, In, L, Z>, that: Lazy<Sink<R1, E1, In1, L1, Z1>>, leftDone: (exit: Exit<E, Z>) => MergeDecision<R1, E1, Z1, E2, Z2>, rightDone: (exit: Exit<E1, Z1>) => MergeDecision<R, E, Z, E3, Z3>, capacity?: Lazy<number>, __tsplusTrace?: string): Sink<R | R1 | R2 | R3, E2 | E3, In & In1, L | L1, Z2 | Z3>;
+export declare function raceWith<R, E, Z, R1, E1, In1, L1, Z1, E2, Z2, E3, Z3>(that: Lazy<Sink<R1, E1, In1, L1, Z1>>, leftDone: (exit: Exit<E, Z>) => MergeDecision<R1, E1, Z1, E2, Z2>, rightDone: (exit: Exit<E1, Z1>) => MergeDecision<R, E, Z, E3, Z3>, capacity?: Lazy<number>, __tsplusTrace?: string): <In, L, R2, R3>(self: import("./definition.js").Sink<R, E, In, L, Z>) => import("./definition.js").Sink<R | R1 | R2 | R3, E2 | E3, In & In1, L1 | L, Z2 | Z3>;
 /**
  * Accesses the specified service in the environment of the effect.
  * @tsplus static fncts.io.SinkOps service
@@ -591,10 +591,10 @@ export declare function serviceWithSink<S, R, E, In, L, Z>(f: (service: S) => Si
  * Splits the sink on the specified predicate, returning a new sink that
  * consumes elements until an element after the first satisfies the specified
  * predicate.
- * @tsplus fluent fncts.io.Sink splitWhere
+ * @tsplus pipeable fncts.io.Sink splitWhere
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function splitWhere<R, E, In, L extends In, Z>(self: Sink<R, E, In, L, Z>, p: Predicate<In>, __tsplusTrace?: string): Sink<R, E, In, In, Z>;
+export declare function splitWhere<In>(p: Predicate<In>, __tsplusTrace?: string): <R, E, L extends In, Z_1>(self: import("./definition.js").Sink<R, E, In, L, Z_1>) => import("./definition.js").Sink<R, E, In, In, Z_1>;
 /**
  * A sink that immediately ends with the specified value.
  * @tsplus static fncts.io.SinkOps succeed
@@ -610,10 +610,10 @@ export declare function succeedNow<Z>(z: Z, __tsplusTrace?: string): Sink<never,
 /**
  * Summarize a sink by running an effect when the sink starts and again when
  * it completes
- * @tsplus fluent fncts.io.Sink summarized
+ * @tsplus pipeable fncts.io.Sink summarized
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function summarized<R, E, In, L, Z, R1, E1, B, C>(self: Sink<R, E, In, L, Z>, summary: Lazy<IO<R1, E1, B>>, f: (b1: B, b2: B) => C, __tsplusTrace?: string): Sink<R | R1, E | E1, In, L, readonly [Z, C]>;
+export declare function summarized<R1, E1, B, C>(summary: Lazy<IO<R1, E1, B>>, f: (b1: B, b2: B) => C, __tsplusTrace?: string): <R, E, In, L, Z_1>(self: import("./definition.js").Sink<R, E, In, L, Z_1>) => import("./definition.js").Sink<R1 | R, E1 | E, In, L, readonly [Z_1, C]>;
 /**
  * @tsplus getter fncts.io.Sink timed
  * @tsplus location "@fncts/io/Sink/api"
@@ -635,29 +635,29 @@ export declare function unwrapScoped<R, E, R1, E1, In, L, Z>(scoped: Lazy<IO<R,
  * Feeds inputs to this sink until it yields a result, then switches over to
  * the provided sink until it yields a result, finally combining the two
  * results into a tuple.
- * @tsplus fluent fncts.io.Sink zip
+ * @tsplus pipeable fncts.io.Sink zip
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function zip<R, E, In, L, Z, R1, E1, In1 extends In, L1 extends L, Z1>(self: Sink<R, E, In, L, Z>, that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): Sink<R | R1, E | E1, In & In1, L | L1, readonly [Z, Z1]>;
+export declare function zip<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): <R, E, Z_1>(self: import("./definition.js").Sink<R, E, In, L, Z_1>) => import("./definition.js").Sink<R1 | R, E1 | E, In & In1, L | L1, readonly [Z_1, Z1]>;
 /**
  * Runs both sinks in parallel on the input and combines the results in a
  * tuple.
- * @tsplus fluent fncts.io.Sink zipC
+ * @tsplus pipeable fncts.io.Sink zipC
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function zipC<R, E, In, L, Z, R1, E1, In1 extends In, L1 extends L, Z1>(self: Sink<R, E, In, L, Z>, that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): Sink<R | R1, E | E1, In & In1, L | L1, readonly [Z, Z1]>;
+export declare function zipC<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): <R, E, Z_1>(self: import("./definition.js").Sink<R, E, In, L, Z_1>) => import("./definition.js").Sink<R1 | R, E1 | E, In & In1, L | L1, readonly [Z_1, Z1]>;
 /**
  * Feeds inputs to this sink until it yields a result, then switches over to
  * the provided sink until it yields a result, finally combining the two
  * results with `f`.
- * @tsplus fluent fncts.io.Sink zipWith
+ * @tsplus pipeable fncts.io.Sink zipWith
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function zipWith<R, E, In, L, Z, R1, E1, In1 extends In, L1 extends L, Z1, Z2>(self: Lazy<Sink<R, E, In, L, Z>>, that: Lazy<Sink<R1, E1, In1, L1, Z1>>, f: (z: Z, z1: Z1) => Z2, __tsplusTrace?: string): Sink<R | R1, E | E1, In & In1, L | L1, Z2>;
+export declare function zipWith<In, L, Z, R1, E1, In1 extends In, L1 extends L, Z1, Z2>(that: Lazy<Sink<R1, E1, In1, L1, Z1>>, f: (z: Z, z1: Z1) => Z2, __tsplusTrace?: string): <R, E>(self: import("@fncts/base/data/function.js").Lazy<import("./definition.js").Sink<R, E, In, L, Z>>) => import("./definition.js").Sink<R1 | R, E1 | E, In & In1, L | L1, Z2>;
 /**
  * Runs both sinks in parallel on the input and combines the results using the
  * provided function.
- * @tsplus fluent fncts.io.Sink zipWithC
+ * @tsplus pipeable fncts.io.Sink zipWithC
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function zipWithC<R, E, In, L, Z, R1, E1, In1, L1, Z1, Z2>(self: Lazy<Sink<R, E, In, L, Z>>, that: Lazy<Sink<R1, E1, In1, L1, Z1>>, f: (z: Z, z1: Z1) => Z2, __tsplusTrace?: string): Sink<R | R1, E | E1, In & In1, L | L1, Z2>;
+export declare function zipWithC<Z, R1, E1, In1, L1, Z1, Z2>(that: Lazy<Sink<R1, E1, In1, L1, Z1>>, f: (z: Z, z1: Z1) => Z2, __tsplusTrace?: string): <R, E, In, L>(self: import("@fncts/base/data/function.js").Lazy<import("./definition.js").Sink<R, E, In, L, Z>>) => import("./definition.js").Sink<R1 | R, E1 | E, In & In1, L1 | L, Z2>;

package/State/api.d.ts

@@ -13,12 +13,12 @@ export declare function get_<S>(self: State<S>, __tsplusTrace?: string): UIO<S>;
  */
 export declare function initial<S>(s: S, tag: Tag<State<S>>, __tsplusTrace?: string): Layer<never, never, State<S>>;
 /**
- * @tsplus fluent fncts.io.State set
+ * @tsplus pipeable fncts.io.State set
  * @tsplus location "@fncts/io/State/api"
  */
-export declare function set_<S>(self: State<S>, value: S, __tsplusTrace?: string): UIO<void>;
+export declare function set<S>(value: S, __tsplusTrace?: string): (self: State<S>) => import("../IO.js").UIO<void>;
 /**
- * @tsplus fluent fncts.io.State update
+ * @tsplus pipeable fncts.io.State update
  * @tsplus location "@fncts/io/State/api"
  */
-export declare function update_<S>(self: State<S>, f: (s: S) => S, __tsplusTrace?: string): UIO<void>;
+export declare function update<S>(f: (s: S) => S, __tsplusTrace?: string): (self: State<S>) => import("../IO.js").UIO<void>;

package/State/internal.d.ts

@@ -2,7 +2,7 @@ import { UIO } from "@fncts/io/IO/definition";
 export declare const StateTypeId: unique symbol;
 export type StateTypeId = typeof StateTypeId;
 export declare abstract class StateInternal<S> {
-    readonly _A: () => S;
+    _A: () => S;
     readonly _typeId: StateTypeId;
     abstract get: UIO<S>;
     abstract set(s: S, __tsplusTrace?: string): UIO<void>;

package/Stream/api/zipAllWith.d.ts

@@ -4,7 +4,7 @@ import { IO } from "@fncts/io/IO/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Exit } from "@fncts/base/data/Exit/definition";
 /**
- * @tsplus fluent fncts.io.Stream zipAllWith
+ * @tsplus pipeable fncts.io.Stream zipAllWith
  * @tsplus location "@fncts/io/Stream/api/zipAllWith"
  */
-export declare function zipAllWith_<R, E, A, R1, E1, B, C, D, F>(self: Stream<R, E, A>, that: Stream<R1, E1, B>, left: (a: A) => C, right: (b: B) => D, both: (a: A, b: B) => F, __tsplusTrace?: string): Stream<R | R1, E | E1, C | D | F>;
+export declare function zipAllWith<A, R1, E1, B, C, D, F>(that: Stream<R1, E1, B>, left: (a: A) => C, right: (b: B) => D, both: (a: A, b: B) => F, __tsplusTrace?: string): <R, E>(self: import("../definition.js").Stream<R, E, A>) => import("../definition.js").Stream<R1 | R, E1 | E, C | D | F>;

package/Stream/api/zipWith.d.ts

@@ -1,6 +1,6 @@
 import { Stream } from "@fncts/io/Stream/definition";
 /**
- * @tsplus fluent fncts.io.Stream zipWith
+ * @tsplus pipeable fncts.io.Stream zipWith
  * @tsplus location "@fncts/io/Stream/api/zipWith"
  */
-export declare function zipWith_<R, E, A, R1, E1, B, C>(self: Stream<R, E, A>, that: Stream<R1, E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string): Stream<R | R1, E | E1, C>;
+export declare function zipWith<A, R1, E1, B, C>(that: Stream<R1, E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string): <R, E>(self: import("../definition.js").Stream<R, E, A>) => import("../definition.js").Stream<R1 | R, E1 | E, C>;

package/Stream/api/zipWithChunks.d.ts

@@ -5,7 +5,7 @@ import { Either } from "@fncts/base/data/Either/definition";
 import { Exit } from "@fncts/base/data/Exit/definition";
 import { Stream } from "@fncts/io/Stream/definition";
 /**
- * @tsplus fluent fncts.io.Stream zipWithChunks
+ * @tsplus pipeable fncts.io.Stream zipWithChunks
  * @tsplus location "@fncts/io/Stream/api/zipWithChunks"
  */
-export declare function zipWithChunks_<R, E, A, R1, E1, B, C>(self: Stream<R, E, A>, that: Stream<R1, E1, B>, f: (as: Conc<A>, bs: Conc<B>) => readonly [Conc<C>, Either<Conc<A>, Conc<B>>], __tsplusTrace?: string): Stream<R | R1, E | E1, C>;
+export declare function zipWithChunks<A, R1, E1, B, C>(that: Stream<R1, E1, B>, f: (as: Conc<A>, bs: Conc<B>) => readonly [Conc<C>, Either<Conc<A>, Conc<B>>], __tsplusTrace?: string): <R, E>(self: import("../definition").Stream<R, E, A>) => import("../definition").Stream<R1 | R, E1 | E, C>;