@fncts/io 0.0.49 → 0.0.51

package/Channel/internal/SingleProducerAsyncInput.d.ts

@@ -56,13 +56,13 @@ export type State<Err, Elem, Done> = StateEmpty | StateEmit<Err, Elem, Done> | S
 export declare class SingleProducerAsyncInput<Err, Elem, Done> implements AsyncInputProducer<Err, Elem, Done>, AsyncInputConsumer<Err, Elem, Done> {
     readonly ref: Ref<State<Err, Elem, Done>>;
     constructor(ref: Ref<State<Err, Elem, Done>>);
+    get awaitRead(): UIO<void>;
     emit(el: Elem): UIO<unknown>;
     done(a: Done): UIO<unknown>;
     error(cause: Cause<Err>): UIO<unknown>;
     takeWith<X>(onError: (cause: Cause<Err>) => X, onElement: (element: Elem) => X, onDone: (done: Done) => X): UIO<X>;
     take: import("../../IO").UIO<import("@fncts/base/data/Exit").Exit<import("@fncts/base/data/Either").Either<Err, Done>, Elem>>;
     close: import("../../IO").IO<never, never, unknown>;
-    awaitRead: UIO<void>;
 }
 /**
  * Creates a SingleProducerAsyncInput

package/CountdownLatch.d.ts

@@ -12,11 +12,11 @@ export declare class CountdownLatch {
     private _waiters;
     readonly [CountdownLatchTypeId]: CountdownLatchTypeId;
     constructor(_count: Ref<number>, _waiters: Future<never, void>);
-    readonly await: UIO<void>;
-    readonly countDown: UIO<void>;
-    readonly count: UIO<number>;
-    readonly increment: UIO<void>;
-    readonly isOpen: UIO<boolean>;
+    get await(): UIO<void>;
+    get countDown(): UIO<void>;
+    get count(): UIO<number>;
+    get increment(): UIO<void>;
+    get isOpen(): UIO<boolean>;
 }
 /**
  * @tsplus static fncts.io.CountdownLatchOps make

package/Fiber/FiberRuntime.d.ts

@@ -35,12 +35,12 @@ export declare class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
         readonly _E: (_: never) => E;
         readonly _A: (_: never) => A;
     };
-    location: string | undefined;
     get await(): UIO<Exit<E, A>>;
     get children(): UIO<Conc<FiberRuntime<any, any>>>;
     get fiberRefs(): UIO<FiberRefs>;
     get id(): FiberId.Runtime;
     get inheritAll(): UIO<void>;
+    get location(): string | undefined;
     get poll(): UIO<Maybe<Exit<E, A>>>;
     get runtimeFlags(): UIO<RuntimeFlags>;
     get scope(): import("../FiberScope.js").FiberScope;

package/Hub/api.d.ts

@@ -30,6 +30,13 @@ export declare function contramapIO<A, RC, EC, C>(f: (c: C) => IO<RC, EC, A>, __
  * @tsplus location "@fncts/io/Hub/api"
  */
 export declare function dimap<A, B, C, D>(f: (c: C) => A, g: (b: B) => D, __tsplusTrace?: string): <RA, RB, EA, EB>(self: PHub<RA, RB, EA, EB, A, B>) => PHub<RA, RB, EA, EB, C, D>;
+/**
+ * Transforms messages taken from the hub using the specified effectual
+ * function.
+ * @tsplus pipeable fncts.io.Hub mapIO
+ * @tsplus location "@fncts/io/Hub/api"
+ */
+export declare function mapIO<B, RC, EC, C>(f: (b: B) => IO<RC, EC, C>, __tsplusTrace?: string): <RA, RB, EA, EB, A>(self: PHub<RA, RB, EA, EB, A, B>) => PHub<RA, RC | RB, EA, EB | EC, A, C>;
 /**
  * Transforms messages published to and taken from the hub using the
  * specified effectual functions.
@@ -109,13 +116,6 @@ export declare function makeUnbounded<A>(__tsplusTrace?: string): UIO<Hub<A>>;
  * @tsplus location "@fncts/io/Hub/api"
  */
 export declare function map<B, C>(f: (b: B) => C, __tsplusTrace?: string): <RA, RB, EA, EB, A>(self: PHub<RA, RB, EA, EB, A, B>) => PHub<RA, RB, EA, EB, A, C>;
-/**
- * Transforms messages taken from the hub using the specified effectual
- * function.
- * @tsplus pipeable fncts.io.Hub mapIO
- * @tsplus location "@fncts/io/Hub/api"
- */
-export declare function mapIO<B, RC, EC, C>(f: (b: B) => IO<RC, EC, C>, __tsplusTrace?: string): <RA, RB, EA, EB, A>(self: PHub<RA, RB, EA, EB, A, B>) => PHub<RA, RC | RB, EA, EB | EC, A, C>;
 /**
  * Publishes a message to the hub, returning whether the message was
  * published to the hub.

package/IO/api/foreachExec.d.ts

@@ -1,6 +1,15 @@
 import { ExecutionStrategy } from "@fncts/base/data/ExecutionStrategy";
 import { IO } from "@fncts/io/IO/definition";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
+/**
+ * Applies the function `f` to each element of the `Iterable<A>` in parallel,
+ * and returns the results in a new `Conc<B>`.
+ *
+ * For a sequential version of this method, see `foreach`.
+ * @tsplus static fncts.io.IOOps foreachWithIndexDiscardExec
+ * @tsplus location "@fncts/io/IO/api/foreachExec"
+ */
+export declare function foreachWithIndexDiscardExec<R, E, A, B>(as: Iterable<A>, es: ExecutionStrategy, f: (index: number, a: A) => IO<R, E, B>, __tsplusTrace?: string): IO<R, E, void>;
 /**
  * Applies the function `f` to each element of the `Iterable<A>` in parallel,
  * and returns the results in a new `Conc<B>`.
@@ -10,3 +19,12 @@ import { Conc } from "@fncts/base/collection/immutable/Conc";
  * @tsplus location "@fncts/io/IO/api/foreachExec"
  */
 export declare function foreachExec<R, E, A, B>(as: Iterable<A>, es: ExecutionStrategy, f: (a: A) => IO<R, E, B>, __tsplusTrace?: string): IO<R, E, Conc<B>>;
+/**
+ * Applies the function `f` to each element of the `Iterable<A>` in parallel,
+ * and returns the results in a new `Conc<B>`.
+ *
+ * For a sequential version of this method, see `foreach`.
+ * @tsplus static fncts.io.IOOps foreachExecDiscard
+ * @tsplus location "@fncts/io/IO/api/foreachExec"
+ */
+export declare function foreachDiscardExec<R, E, A, B>(as: Iterable<A>, es: ExecutionStrategy, f: (a: A) => IO<R, E, B>, __tsplusTrace?: string): IO<R, E, void>;

package/IO/api.d.ts

@@ -944,7 +944,7 @@ export declare function tapCause<R, E, E2>(f: (e: Cause<E2>) => IO<R, E, any>, _
  * @tsplus pipeable fncts.io.IO tapError
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function tapError<E, R1, E1>(f: (e: E) => IO<R1, E1, any>, __tsplusTrace?: string): <R, A>(self: IO<R, E, A>) => IO<R1 | R, E | E1, A>;
+export declare function tapError<E, R1, E1>(f: (e: E) => IO<R1, E1, any>, __tsplusTrace?: string): <R, A>(self: IO<R, E, A>) => IO<R | R1, E | E1, A>;
 /**
  * Returns an effect that effectually "peeks" at the cause of the failure of
  * this effect.

package/Push/Bounds.d.ts

@@ -0,0 +1,4 @@
+export interface Bounds {
+    readonly min: number;
+    readonly max: number;
+}

package/Push/FlattenStrategy.d.ts

@@ -0,0 +1,47 @@
+import { IO } from "@fncts/io/IO/definition";
+import { Scope } from "@fncts/io/Scope/definition";
+import { Fiber } from "@fncts/io/Fiber/definition";
+import { ExecutionStrategy } from "@fncts/base/data/ExecutionStrategy";
+import { Ref } from "@fncts/io/Ref/definition";
+import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
+import { Semaphore } from "@fncts/io/Semaphore";
+type Fork = <R>(io: IO<R, never, void>) => IO<R | Scope, never, void>;
+/**
+ * @tsplus type fncts.io.Push.FlattenStrategy
+ * @tsplus companion fncts.io.Push.FlattenStrategyOps
+ */
+export declare abstract class FlattenStrategy {
+    abstract withFork<R>(f: (fork: Fork, scope: Scope) => IO<R, never, void>, executionStrategy: ExecutionStrategy): IO<R | Scope, never, void>;
+}
+/**
+ * @tsplus static fncts.io.Push.FlattenStrategyOps Switch
+ * @tsplus location "@fncts/io/Push/FlattenStrategy"
+ */
+export declare const SwitchStrategy: {
+    withFork<R>(f: (fork: Fork, scope: Scope) => IO<R, never, void>, executionStrategy: ExecutionStrategy): IO<R | Scope, never, void>;
+};
+/**
+ * @tsplus static fncts.io.Push.FlattenStrategyOps Exhaust
+ * @tsplus location "@fncts/io/Push/FlattenStrategy"
+ */
+export declare const ExhaustStrategy: {
+    withFork<R>(f: (fork: Fork, scope: Scope) => IO<R, never, void>, executionStrategy: ExecutionStrategy): IO<R | Scope, never, void>;
+};
+/**
+ * @tsplus static fncts.io.Push.FlattenStrategyOps Unbounded
+ * @tsplus location "@fncts/io/Push/FlattenStrategy"
+ */
+export declare const UnboundedStrategy: {
+    withFork<R>(f: (fork: Fork, scope: Scope) => IO<R, never, void>): IO<R | Scope, never, void>;
+};
+/**
+ * @tsplus static fncts.io.Push.FlattenStrategyOps Bounded
+ * @tsplus location "@fncts/io/Push/FlattenStrategy"
+ */
+export declare function makeBounded(capacity: number): BoundedStrategy;
+declare class BoundedStrategy extends FlattenStrategy {
+    readonly capacity: number;
+    constructor(capacity: number);
+    withFork<R>(f: (fork: Fork, scope: Scope) => IO<R, never, void>, executionStrategy: ExecutionStrategy): IO<R | Scope, never, void>;
+}
+export {};

package/Push/IndexedBuffer.d.ts

@@ -0,0 +1,19 @@
+import { Future } from "@fncts/io/Future";
+import { UIO, IO } from "@fncts/io/IO/definition";
+import { FiberId } from "@fncts/base/data/FiberId/definition";
+import type { Push } from "./definition.js";
+export declare class IndexedBuffer<R, E, A> {
+    ready: boolean;
+    readonly future: Future<never, void>;
+    readonly sink: Push.UnsafeSink<R, E, A>;
+    readonly onDone: UIO<void>;
+    constructor(ready: boolean, future: Future<never, void>, sink: Push.UnsafeSink<R, E, A>, onDone: UIO<void>);
+    buffer: Array<A>;
+    onSuccess(value: A): import("../IO.js").IO<R, never, void>;
+    get onEnd(): import("../IO.js").IO<R, never, void>;
+}
+export declare const withBuffers: <R, E, A>(size: number, sink: Push.UnsafeSink<R, E, A>, id: FiberId) => {
+    onSuccess: (index: number, value: A) => IO<R, never, void>;
+    onEnd: (index: number) => IO<R, never, void>;
+    buffers: Map<number, IndexedBuffer<R, E, A>>;
+};

package/Push/MergeStrategy.d.ts

@@ -0,0 +1,19 @@
+import { IO } from "@fncts/io/IO/definition";
+import { ExecutionStrategy } from "@fncts/base/data/ExecutionStrategy";
+import type { Push } from "./definition.js";
+export declare abstract class MergeStrategy {
+    abstract runMerge<Ps extends ReadonlyArray<Push<any, any, any>>, R>(ps: Ps, sink: Push.UnsafeSink<R, any, any>): IO<R | Push.EnvironmentOf<Ps[number]>, never, void>;
+}
+export declare class Unordered extends MergeStrategy {
+    readonly executionStrategy: ExecutionStrategy;
+    constructor(executionStrategy: ExecutionStrategy);
+    runMerge<Ps extends ReadonlyArray<Push<any, any, any>>, R>(ps: Ps, sink: Push.UnsafeSink<R, any, any>): IO<R | Push.EnvironmentOf<Ps[number]>, never, void>;
+}
+export declare class Ordered extends MergeStrategy {
+    readonly executionStrategy: ExecutionStrategy;
+    constructor(executionStrategy: ExecutionStrategy);
+    runMerge<Ps extends ReadonlyArray<Push<any, any, any>>, R>(ps: Ps, sink: Push.UnsafeSink<R, any, any>): IO<R | Push.EnvironmentOf<Ps[number]>, never, void>;
+}
+export declare class Switch extends MergeStrategy {
+    runMerge<Ps extends ReadonlyArray<Push<any, any, any>>, R>(ps: Ps, sink: Push.UnsafeSink<R, any, any>): IO<R | Push.EnvironmentOf<Ps[number]>, never, void>;
+}

package/Push/Operator/IOLoopOperator.d.ts

@@ -0,0 +1,61 @@
+import { IO } from "@fncts/io/IO/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import type { IOOperator } from "./IOOperator.js";
+import type { SyncLoopOperator } from "@fncts/io/Push/Operator/LoopOperator";
+import type { SyncOperator } from "@fncts/io/Push/Operator/SyncOperator";
+export declare const enum IOLoopOperatorTag {
+    LoopIO = "LoopIO",
+    FilterMapLoopIO = "FilterMapLoopIO"
+}
+/**
+ * @tsplus type fncts.io.Push.IOLoopOperator
+ */
+export type IOLoopOperator<B = any, A = any, R = any, E = any, C = any> = LoopIOOperator<B, A, R, E, C> | FilterMapLoopIOOperator<B, A, R, E, C>;
+export interface LoopIOOperator<B, A, R, E, C> {
+    readonly _tag: IOLoopOperatorTag.LoopIO;
+    readonly seed: B;
+    readonly f: (acc: B, a: A) => IO<R, E, readonly [C, B]>;
+}
+export declare function LoopIOOperator<const B, A, R, E, C>(seed: B, f: (acc: B, a: A) => IO<R, E, readonly [C, B]>): LoopIOOperator<B, A, R, E, C>;
+export interface FilterMapLoopIOOperator<B, A, R, E, C> {
+    readonly _tag: IOLoopOperatorTag.FilterMapLoopIO;
+    readonly seed: B;
+    readonly f: (acc: B, a: A) => IO<R, E, readonly [Maybe<C>, B]>;
+}
+export declare function FilterMapLoopIOOperator<const B, A, R, E, C>(seed: B, f: (acc: B, a: A) => IO<R, E, readonly [Maybe<C>, B]>): FilterMapLoopIOOperator<B, A, R, E, C>;
+/**
+ * @tsplus pipeable fncts.io.Push.IOLoopOperator match
+ * @tsplus location "@fncts/io/Push/Operator/IOLoopOperator"
+ */
+export declare function match<B, A, R, E, C, D, F>(matchers: {
+    LoopIO: (op: LoopIOOperator<B, A, R, E, C>) => D;
+    FilterMapLoopIO: (op: FilterMapLoopIOOperator<B, A, R, E, C>) => F;
+}): (self: IOLoopOperator<B, A, R, E, C>) => D | F;
+/**
+ * @tsplus pipeable fncts.io.Push.IOLoopOperator fuse
+ * @tsplus location "@fncts/io/Push/Operator/IOLoopOperator"
+ */
+export declare function fuse<C, D, F, R2, E2>(that: IOLoopOperator<D, C, R2, E2, F>): <A, B, R1, E1>(self: IOLoopOperator<A, B, R1, E1, C>) => IOLoopOperator<readonly [A, D], B, R1 | R2, E1 | E2, F>;
+/**
+ * @tsplus pipeable fncts.io.Push.IOLoopOperator after
+ * @tsplus location "@fncts/io/Push/Operator/IOLoopOperator"
+ */
+export declare function fuseSyncLoopOperatorBefore<A, B, C>(that: SyncLoopOperator<A, B, C>): <D, R, E, F>(self: IOLoopOperator<D, C, R, E, F>) => IOLoopOperator<readonly [A, D], B, R, E, F>;
+/**
+ * @tsplus pipeable fncts.io.Push.IOLoopOperator before
+ * @tsplus location "@fncts/io/Push/Operator/IOLoopOperator"
+ */
+export declare function fuseSyncLoopOperatorAfter<D, C, F>(that: SyncLoopOperator<D, C, F>): <A, B, R, E>(self: IOLoopOperator<A, B, R, E, C>) => IOLoopOperator<readonly [A, D], B, R, E, F>;
+/**
+ * @tsplus pipeable fncts.io.Push.IOLoopOperator after
+ * @tsplus location "@fncts/io/Push/Operator/IOLoopOperator"
+ */
+export declare function fuseSyncOperatorBefore(that: SyncOperator): (self: IOLoopOperator) => IOLoopOperator;
+/**
+ * @tsplus pipeable fncts.io.Push.IOLoopOperator before
+ * @tsplus location "@fncts/io/Push/Operator/IOLoopOperator"
+ */
+export declare function fuseSyncOperatorAfter(that: SyncOperator): (self: IOLoopOperator) => IOLoopOperator;
+export declare function fuseIOOperatorBefore(that: IOOperator): (self: IOLoopOperator) => IOLoopOperator;
+export declare function fuseIOOperatorAfter(that: IOOperator): (self: IOLoopOperator) => FilterMapLoopIOOperator<any, unknown, any, any, any> | LoopIOOperator<any, unknown, any, any, any>;
+export declare function liftLoopOperator(self: SyncLoopOperator): IOLoopOperator;

package/Push/Operator/IOOperator.d.ts

@@ -0,0 +1,63 @@
+import { IO } from "@fncts/io/IO/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import type { SyncOperator } from "./SyncOperator.js";
+export declare const enum IOOperatorTag {
+    MapIO = "MapIO",
+    TapIO = "TapIO",
+    FilterIO = "FilterIO",
+    FilterMapIO = "FilterMapIO"
+}
+/**
+ * @tsplus type fncts.io.Push.IOOperator
+ * @tsplus companion fncts.io.Push.IOOperatorOps
+ */
+export type IOOperator = MapIO<any, any, any, any> | TapIO<any, any, any, any> | FilterIO<any, any, any> | FilterMapIO<any, any, any, any>;
+export interface MapIO<R, E, A, B> {
+    readonly _tag: IOOperatorTag.MapIO;
+    readonly f: (a: A) => IO<R, E, B>;
+}
+export declare function MapIO<R, E, A, B>(f: (a: A) => IO<R, E, B>): MapIO<R, E, A, B>;
+export interface TapIO<R, E, A, B> {
+    readonly _tag: IOOperatorTag.TapIO;
+    readonly f: (a: A) => IO<R, E, B>;
+}
+export declare function TapIO<R, E, A, B>(f: (a: A) => IO<R, E, B>): TapIO<R, E, A, B>;
+export interface FilterIO<R, E, A> {
+    readonly _tag: IOOperatorTag.FilterIO;
+    readonly f: (a: A) => IO<R, E, boolean>;
+}
+export declare function FilterIO<R, E, A>(f: (a: A) => IO<R, E, boolean>): FilterIO<R, E, A>;
+export interface FilterMapIO<R, E, A, B> {
+    readonly _tag: IOOperatorTag.FilterMapIO;
+    readonly f: (a: A) => IO<R, E, Maybe<B>>;
+}
+export declare function FilterMapIO<R, E, A, B>(f: (a: A) => IO<R, E, Maybe<B>>): FilterMapIO<R, E, A, B>;
+export type IOOperatorFusionMap = {
+    readonly [K in IOOperator["_tag"]]: {
+        readonly [K2 in IOOperator["_tag"]]: (op1: Extract<IOOperator, {
+            readonly _tag: K;
+        }>, op2: Extract<IOOperator, {
+            readonly _tag: K2;
+        }>) => IOOperator;
+    };
+};
+/**
+ * @tsplus pipeable fncts.io.Push.IOOperator fuse
+ * @tsplus location "@fncts/io/Push/Operator/IOOperator"
+ */
+export declare function fuse(that: IOOperator): (self: IOOperator) => IOOperator;
+/**
+ * @tsplus static fncts.io.Push.IOOperatorOps fromSyncOperator
+ * @tsplus location "@fncts/io/Push/Operator/IOOperator"
+ */
+export declare function fromSyncOperator(op: SyncOperator): IOOperator;
+/**
+ * @tsplus pipeable fncts.io.Push.IOOperator match
+ * @tsplus location "@fncts/io/Push/Operator/IOOperator"
+ */
+export declare function match<A, B, C, D>(cases: {
+    readonly MapIO: (f: MapIO<any, any, any, any>) => A;
+    readonly TapIO: (f: TapIO<any, any, any, any>) => B;
+    readonly FilterIO: (f: FilterIO<any, any, any>) => C;
+    readonly FilterMapIO: (f: FilterMapIO<any, any, any, any>) => D;
+}): (self: IOOperator) => A | B | C | D;

package/Push/Operator/LoopOperator.d.ts

@@ -0,0 +1,50 @@
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { Either } from "@fncts/base/data/Either/definition";
+import type { Bounds } from "../Bounds.js";
+import type { SyncOperator } from "./SyncOperator.js";
+export declare const enum SyncLoopOperatorTag {
+    Loop = "Loop",
+    FilterMapLoop = "FilterMapLoop"
+}
+/**
+ * @tsplus type fncts.io.Push.SyncLoopOperator
+ */
+export type SyncLoopOperator<B = any, A = any, C = any> = LoopOperator<B, A, C> | FilterMapLoopOperator<B, A, C>;
+export interface LoopOperator<B, A, C> {
+    readonly _tag: SyncLoopOperatorTag.Loop;
+    readonly seed: B;
+    readonly f: (acc: B, a: A) => readonly [C, B];
+}
+export declare function LoopOperator<const B, A, C>(seed: B, f: (acc: B, a: A) => readonly [C, B]): LoopOperator<B, A, C>;
+export interface FilterMapLoopOperator<B, A, C> {
+    readonly _tag: SyncLoopOperatorTag.FilterMapLoop;
+    readonly seed: B;
+    readonly f: (acc: B, a: A) => readonly [Maybe<C>, B];
+}
+export declare function FilterMapLoopOperator<const B, A, C>(seed: B, f: (acc: B, a: A) => readonly [Maybe<C>, B]): FilterMapLoopOperator<B, A, C>;
+export declare const enum SliceOperatorTag {
+    SliceOperator = 0,
+    FilterMapSliceOperator = 1
+}
+export interface SliceOperator {
+    readonly _tag: SliceOperatorTag.SliceOperator;
+    readonly bounds: Bounds;
+}
+export declare function SliceOperator(bounds: Bounds): SliceOperator;
+export interface FilterMapSliceOperator<A, B, C> {
+    readonly _tag: SliceOperatorTag.FilterMapSliceOperator;
+    readonly seed: B;
+    readonly f: (acc: B, a: A) => Either<readonly [Maybe<C>, B], Maybe<C>>;
+}
+export declare function FilterMapSliceOperator<const B, A, C>(seed: B, f: (acc: B, a: A) => Either<readonly [Maybe<C>, B], Maybe<C>>): FilterMapSliceOperator<A, B, C>;
+/**
+ * @tsplus pipeable fncts.io.Push.SyncLoopOperator match
+ * @tsplus location "@fncts/io/Push/Operator/LoopOperator"
+ */
+export declare function matchSyncLoopOperator<A, B, C, D, E>(matchers: {
+    Loop: (op: LoopOperator<A, B, C>) => D;
+    FilterMapLoop: (op: FilterMapLoopOperator<A, B, C>) => E;
+}): (self: SyncLoopOperator<A, B, C>) => D | E;
+export declare function fuseSyncOperatorBefore(that: SyncOperator): (self: SyncLoopOperator) => SyncLoopOperator;
+export declare function fuseSyncOperatorAfter(that: SyncOperator): (self: SyncLoopOperator) => SyncLoopOperator;
+export declare function fuse<C, D, E>(that: SyncLoopOperator<D, C, E>): <A, B>(self: SyncLoopOperator<A, B, C>) => SyncLoopOperator<readonly [A, D], B, E>;

package/Push/Operator/SyncOperator.d.ts

@@ -0,0 +1,41 @@
+import { Predicate } from "@fncts/base/data/Predicate/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+export declare const enum SyncOperatorTag {
+    Map = "Map",
+    Filter = "Filter",
+    FilterMap = "FilterMap"
+}
+export interface Map<A, B> {
+    readonly _tag: SyncOperatorTag.Map;
+    readonly f: (a: A) => B;
+}
+export declare function Map<A, B>(f: (a: A) => B): Map<A, B>;
+export interface Filter<A> {
+    readonly _tag: SyncOperatorTag.Filter;
+    readonly f: Predicate<A>;
+}
+export declare function Filter<A>(f: Predicate<A>): Filter<A>;
+export interface FilterMap<A, B> {
+    readonly _tag: SyncOperatorTag.FilterMap;
+    readonly f: (a: A) => Maybe<B>;
+}
+export declare function FilterMap<A, B>(f: (a: A) => Maybe<B>): FilterMap<A, B>;
+/**
+ * @tsplus type fncts.io.Push.SyncOperator
+ * @tsplus companion fncts.io.Push.SyncOperatorOps
+ */
+export type SyncOperator<A = any, B = any> = Map<A, B> | Filter<A> | FilterMap<A, B>;
+/**
+ * @tsplus pipeable fncts.io.Push.SyncOperator fuse
+ * @tsplus location "@fncts/io/Push/Operator/SyncOperator"
+ */
+export declare function fuse(that: SyncOperator): (self: SyncOperator) => SyncOperator<any, any>;
+/**
+ * @tsplus pipeable fncts.io.Push.SyncOperator match
+ * @tsplus location "@fncts/io/Push/Operator/SyncOperator"
+ */
+export declare function match<A, B, C, D, E>(cases: {
+    readonly Map: (f: Map<A, B>) => C;
+    readonly Filter: (f: Filter<A>) => D;
+    readonly FilterMap: (f: FilterMap<A, B>) => E;
+}): (self: SyncOperator<A, B>) => C | D | E;

package/Push/Operator.d.ts

@@ -0,0 +1,4 @@
+export type {} from "./Operator/SyncOperator.js";
+export type {} from "./Operator/LoopOperator.js";
+export type {} from "./Operator/IOOperator.js";
+export type {} from "./Operator/IOLoopOperator.js";

package/Push/Producer/IOProducer.d.ts

@@ -0,0 +1,41 @@
+import { IO } from "@fncts/io/IO/definition";
+import { Schedule } from "@fncts/io/Schedule/definition";
+import { Cause } from "@fncts/base/data/Cause/definition";
+import type { Push } from "../definition.js";
+export declare const enum IOProducerTag {
+    FromIO = 0,
+    FromScheduled = 1,
+    Scheduled = 2
+}
+export declare class FromIO<R, E, A> {
+    readonly source: IO<R, E, A>;
+    readonly _tag = IOProducerTag.FromIO;
+    constructor(source: IO<R, E, A>);
+}
+export declare class FromScheduled<R, E, I, R1, O> {
+    readonly input: IO<R, E, I>;
+    readonly schedule: Schedule<R1, I, O>;
+    readonly _tag = IOProducerTag.FromScheduled;
+    constructor(input: IO<R, E, I>, schedule: Schedule<R1, I, O>);
+}
+export declare class Scheduled<R, E, A, R1, O> {
+    readonly input: IO<R, E, A>;
+    readonly schedule: Schedule<R1, unknown, O>;
+    readonly _tag = IOProducerTag.Scheduled;
+    constructor(input: IO<R, E, A>, schedule: Schedule<R1, unknown, O>);
+}
+/**
+ * @tsplus type fncts.io.Push.IOProducer
+ * @tsplus companion fncts.io.Push.IOProducerOps
+ */
+export type IOProducer<R, E, A> = FromIO<R, E, A> | FromScheduled<R, E, any, any, A> | Scheduled<R, E, A, any, any>;
+/**
+ * @tsplus fluent fncts.io.Push.IOProducer runSink
+ * @tsplus location "@fncts/io/Push/Producer/IOProducer"
+ */
+export declare function runSink<R, E, A, R1>(self: IOProducer<R, E, A>, sink: Push.UnsafeSink<R1, E, A>): IO<R | R1, never, unknown>;
+/**
+ * @tsplus fluent fncts.io.Push.IOProducer runIO
+ * @tsplus location "@fncts/io/Push/Producer/IOProducer"
+ */
+export declare function runIO<R, E, A, R1, E1, A1>(self: IOProducer<R, E, A>, f: (a: A) => IO<R1, E1, A1>): IO<R | R1, E | E1, unknown>;

package/Push/Producer/SyncProducer.d.ts

@@ -0,0 +1,61 @@
+import { Lazy } from "@fncts/base/data/function/definition";
+import { UIO, IO } from "@fncts/io/IO/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import type { Push } from "@fncts/io/Push/definition";
+export declare const enum SyncProducerTag {
+    Success = 0,
+    FromSync = 1,
+    FromArray = 2,
+    FromIterable = 3
+}
+/**
+ * @tsplus type fncts.io.Push.SyncProducer
+ * @tsplus companion fncts.io.Push.SyncProducerOps
+ */
+export type SyncProducer<A> = Success<A> | FromSync<A> | FromArray<A> | FromIterable<A>;
+export declare class Success<A> {
+    readonly source: A;
+    readonly _tag = SyncProducerTag.Success;
+    constructor(source: A);
+}
+export declare class FromSync<A> {
+    readonly f: Lazy<A>;
+    readonly _tag = SyncProducerTag.FromSync;
+    constructor(f: Lazy<A>);
+}
+export declare class FromArray<A> {
+    readonly array: ReadonlyArray<A>;
+    readonly _tag = SyncProducerTag.FromArray;
+    constructor(array: ReadonlyArray<A>);
+}
+export declare class FromIterable<A> {
+    readonly iterable: Iterable<A>;
+    readonly _tag = SyncProducerTag.FromIterable;
+    constructor(iterable: Iterable<A>);
+}
+/**
+ * @tsplus static fncts.io.Push.SyncProducerOps Success
+ * @tsplus location "@fncts/io/Push/Producer/SyncProducer"
+ */
+export declare function success<A>(source: A): SyncProducer<A>;
+/**
+ * @tsplus static fncts.io.Push.SyncProducerOps fromSync
+ * @tsplus location "@fncts/io/Push/Producer/SyncProducer"
+ */
+export declare function fromSync<A>(f: Lazy<A>): SyncProducer<A>;
+/**
+ * @tsplus static fncts.io.Push.SyncProducerOps fromArray
+ * @tsplus location "@fncts/io/Push/Producer/SyncProducer"
+ */
+export declare function fromArray<A extends ReadonlyArray<any>>(array: A): SyncProducer<A[number]>;
+/**
+ * @tsplus static fncts.io.Push.SyncProducerOps fromIterable
+ * @tsplus location "@fncts/io/Push/Producer/SyncProducer"
+ */
+export declare function fromIterable<A>(iterable: Iterable<A>): SyncProducer<A>;
+export declare function syncOnce<A>(f: () => A): UIO<A>;
+/**
+ * @tsplus fluent fncts.io.Push.SyncProducer runSink
+ * @tsplus location "@fncts/io/Push/Producer/SyncProducer"
+ */
+export declare function runSink<R, E, A>(self: SyncProducer<A>, sink: Push.UnsafeSink<R, E, A>): IO<R, never, unknown>;

package/Push/Producer.d.ts

@@ -0,0 +1 @@
+export {};

package/Push/Sink.d.ts

@@ -0,0 +1,65 @@
+import { HKT } from "@fncts/typelevel/HKT";
+import { Newtype, NewtypeIso } from "@fncts/base/data/Newtype";
+import { URIO, UIO } from "@fncts/io/IO/definition";
+import { Environment } from "@fncts/base/data/Environment/definition";
+import { Predicate } from "@fncts/base/data/Predicate/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import type { Cause } from "@fncts/base/data/Cause";
+import { IO } from "@fncts/io/IO";
+interface SinkN extends HKT {
+    readonly type: Sink<this["I"], this["R"], this["E"], this["A"]>;
+    readonly variance: {
+        I: "+";
+        R: "+";
+        E: "-";
+        A: "-";
+    };
+}
+/**
+ * @tsplus type fncts.io.Push.Sink
+ */
+export interface Sink<Env, R, E, A> extends Newtype<{
+    readonly Sink: unique symbol;
+}, URIO<Env, UnsafeSink<R, E, A>>> {
+}
+/**
+ * @tsplus type fncts.io.Push.SinkOps
+ */
+export interface SinkOps extends NewtypeIso<SinkN> {
+}
+export declare const Sink: SinkOps;
+/**
+ * @tsplus type fncts.io.Push.Sink
+ * @tsplus companion fncts.io.Push.SinkOps
+ */
+export declare abstract class UnsafeSink<R, in E, in A> {
+    abstract onSuccess(value: A): IO<R, never, void>;
+    abstract onFailure(cause: Cause<E>): IO<R, never, void>;
+}
+/**
+ * @tsplus static fncts.io.Push.SinkOps unsafeMake
+ * @tsplus location "@fncts/io/Push/Sink"
+ */
+export declare function unsafeMakeSink<R, E, A>(onSuccess: (value: A) => IO<R, never, unknown>, onFailure: (cause: Cause<E>) => IO<R, never, unknown>): UnsafeSink<R, E, A>;
+/**
+ * @tsplus static fncts.io.Push.SinkOps __call
+ * @tsplus location "@fncts/io/Push/Sink"
+ */
+export declare function makeSink<R, E, A>(onSuccess: (value: A) => IO<R, never, unknown>, onFailure: (cause: Cause<E>) => IO<R, never, unknown>): Sink<never, R, E, A>;
+export declare class WithEarlyExit<R, E, A> extends UnsafeSink<R, E, A> {
+    readonly onSuccess: (value: A) => IO<R, never, void>;
+    readonly onFailure: (cause: Cause<E>) => IO<R, never, void>;
+    readonly earlyExit: UIO<void>;
+    constructor(onSuccess: (value: A) => IO<R, never, void>, onFailure: (cause: Cause<E>) => IO<R, never, void>, earlyExit: UIO<void>);
+}
+/**
+ * @tsplus static fncts.io.Push.SinkOps withEarlyExit
+ * @tsplus location "@fncts/io/Push/Sink"
+ */
+export declare function withEarlyExit<R, E, A, R1, B>(sink: UnsafeSink<R, E, A>, f: (sink: WithEarlyExit<R, E, A>) => IO<R1, E, B>): IO<R | R1, never, void>;
+/**
+ * @tsplus pipeable fncts.io.Push.Sink provideSomeEnvironment
+ * @tsplus location "@fncts/io/Push/Sink"
+ */
+export declare function provideSomeEnvironment<R1>(environment: Environment<R1>): <Env, R, E, A>(self: Sink<Env, R, E, A>) => Sink<Env, Exclude<R, R1>, E, A>;
+export {};