@fncts/io 0.0.1

package/Schedule/definition.d.ts

@@ -0,0 +1,51 @@
+import { IO } from "@fncts/io/IO/definition";
+import type { Decision } from "./Decision.js";
+import type { Driver as Driver_ } from "./Driver.js";
+/**
+ * A `Schedule<Env, In, Out>` defines a recurring schedule, which consumes
+ * values of type `In`, and which returns values of type `Out`.
+ *
+ * Schedules are defined as a possibly infinite set of intervals spread out over
+ * time. Each interval defines a window in which recurrence is possible.
+ *
+ * When schedules are used to repeat or retry effects, the starting boundary of
+ * each interval produced by a schedule is used as the moment when the effect
+ * will be executed again.
+ *
+ * Schedules compose in the following primary ways:
+ *
+ * - Union. This performs the union of the intervals of two schedules.
+ * - Intersection. This performs the intersection of the intervals of two
+ * schedules.
+ * - Sequence. This concatenates the intervals of one schedule onto
+ * another.
+ *
+ * In addition, schedule inputs and outputs can be transformed, filtered (to
+ * terminate a schedule early in response to some input or output), and so
+ * forth.
+ *
+ * A variety of other operators exist for transforming and combining schedules,
+ * and the companion object for `Schedule` contains all common types of
+ * schedules, both for performing retrying, as well as performing repetition.
+ *
+ * @tsplus type fncts.io.Schedule
+ * @tsplus companion fncts.io.ScheduleOps
+ */
+export declare abstract class Schedule<Env, In, Out> {
+    readonly _Env: (_: Env) => void;
+    readonly _In: (_: In) => void;
+    readonly _Out: () => Out;
+    readonly _State: unknown;
+    abstract readonly initial: this["_State"];
+    abstract step(now: number, inp: In, state: this["_State"], __tsplusTrace?: string): IO<Env, never, readonly [this["_State"], Out, Decision]>;
+}
+export declare namespace Schedule {
+    /**
+     * @tsplus type fncts.io.Schedule
+     */
+    interface WithState<State, Env, In, Out> extends Schedule<Env, In, Out> {
+        readonly _State: State;
+    }
+    type StateOf<X> = [X] extends [Schedule<any, any, any>] ? X["_State"] : never;
+    type Driver<State, Env, In, Out> = Driver_<State, Env, In, Out>;
+}

package/Schedule.d.ts

@@ -0,0 +1,5 @@
+export * from "./Schedule/api.js";
+export * from "./Schedule/Decision.js";
+export * from "./Schedule/definition.js";
+export * from "./Schedule/Driver.js";
+export * from "./Schedule/Interval.js";

package/Scope/Finalizer/definition.d.ts

@@ -0,0 +1,26 @@
+import { HKT } from "@fncts/typelevel/HKT";
+import { Newtype } from "@fncts/base/data/Newtype";
+import { Exit } from "@fncts/base/data/Exit";
+import { IO } from "@fncts/io/IO/definition";
+interface FinalizerN extends HKT {
+    readonly type: Finalizer;
+}
+/**
+ * @tsplus type fncts.io.Managed.Finalizer
+ */
+export interface Finalizer extends Newtype<{
+    readonly Finalizer: unique symbol;
+}, (exit: Exit<any, any>) => IO<unknown, never, any>> {
+}
+/**
+ * @tsplus type fncts.io.Managed.FinalizerOps
+ */
+export interface FinalizerOps extends Newtype.Iso<FinalizerN> {
+}
+export declare const Finalizer: FinalizerOps;
+/**
+ * @tsplus static fncts.io.Managed.FinalizerOps noop
+ * @tsplus location "@fncts/io/Scope/Finalizer/definition"
+ */
+export declare const noop: Finalizer;
+export {};

package/Scope/Finalizer.d.ts

@@ -0,0 +1 @@
+export * from "./Finalizer/definition.js";

package/Scope/ReleaseMap/api/releaseAll.d.ts

@@ -0,0 +1,9 @@
+import { Exit } from "@fncts/base/data/Exit";
+import { ExecutionStrategy } from "@fncts/base/data/ExecutionStrategy";
+import { UIO } from "@fncts/io/IO/definition";
+import { ReleaseMap } from "../definition.js";
+/**
+ * @tsplus fluent fncts.io.Scope.ReleaseMap releaseAll
+ * @tsplus location "@fncts/io/Scope/ReleaseMap/api/releaseAll"
+ */
+export declare function releaseAll_(releaseMap: ReleaseMap, exit: Exit<any, any>, execStrategy: ExecutionStrategy): UIO<any>;

package/Scope/ReleaseMap/api.d.ts

@@ -0,0 +1,30 @@
+import { Finalizer } from "@fncts/io/Scope/Finalizer";
+import { UIO, IO } from "@fncts/io/IO/definition";
+import { Maybe } from "@fncts/base/data/Maybe";
+import { Exit } from "@fncts/base/data/Exit";
+import { ReleaseMap } from "./definition.js";
+/**
+ * @tsplus fluent fncts.io.Scope.ReleaseMap addIfOpen
+ * @tsplus location "@fncts/io/Scope/ReleaseMap/api"
+ */
+export declare function addIfOpen_(releaseMap: ReleaseMap, finalizer: Finalizer): UIO<Maybe<number>>;
+/**
+ * @tsplus fluent fncts.io.Scope.ReleaseMap release
+ * @tsplus location "@fncts/io/Scope/ReleaseMap/api"
+ */
+export declare function release_(releaseMap: ReleaseMap, key: number, exit: Exit<any, any>): IO<unknown, never, any>;
+/**
+ * @tsplus fluent fncts.io.Scope.ReleaseMap add
+ * @tsplus location "@fncts/io/Scope/ReleaseMap/api"
+ */
+export declare function add_(releaseMap: ReleaseMap, finalizer: Finalizer): UIO<Finalizer>;
+/**
+ * @tsplus fluent fncts.io.Scope.ReleaseMap replace
+ * @tsplus location "@fncts/io/Scope/ReleaseMap/api"
+ */
+export declare function replace_(releaseMap: ReleaseMap, key: number, finalizer: Finalizer): UIO<Maybe<Finalizer>>;
+/**
+ * @tsplus fluent fncts.io.Scope.ReleaseMap updateAll
+ * @tsplus location "@fncts/io/Scope/ReleaseMap/api"
+ */
+export declare function updateAll_(releaseMap: ReleaseMap, f: (_: Finalizer) => Finalizer): UIO<void>;

package/Scope/ReleaseMap/constructors.d.ts

@@ -0,0 +1,12 @@
+import { UIO } from "@fncts/io/IO/definition";
+import { ReleaseMap } from "./definition.js";
+/**
+ * @tsplus static fncts.io.Scope.ReleaseMapOps unsafeMake
+ * @tsplus location "@fncts/io/Scope/ReleaseMap/constructors"
+ */
+export declare function unsafeMake(): ReleaseMap;
+/**
+ * @tsplus static fncts.io.Scope.ReleaseMapOps make
+ * @tsplus location "@fncts/io/Scope/ReleaseMap/constructors"
+ */
+export declare const make: UIO<ReleaseMap>;

package/Scope/ReleaseMap/definition.d.ts

@@ -0,0 +1,38 @@
+import { Exit } from "@fncts/base/data/Exit";
+import { Finalizer } from "@fncts/io/Scope/Finalizer";
+import { HashMap } from "@fncts/base/collection/immutable/HashMap";
+import { HKT } from "@fncts/typelevel/HKT";
+import { Newtype } from "@fncts/base/data/Newtype";
+import { Ref } from "@fncts/io/Ref";
+export declare class Exited {
+    readonly nextKey: number;
+    readonly exit: Exit<any, any>;
+    readonly update: (_: Finalizer) => Finalizer;
+    readonly _tag = "Exited";
+    constructor(nextKey: number, exit: Exit<any, any>, update: (_: Finalizer) => Finalizer);
+}
+export declare class Running {
+    readonly nextKey: number;
+    readonly finalizers: HashMap<number, Finalizer>;
+    readonly update: (_: Finalizer) => Finalizer;
+    readonly _tag = "Running";
+    constructor(nextKey: number, finalizers: HashMap<number, Finalizer>, update: (_: Finalizer) => Finalizer);
+}
+export declare type State = Exited | Running;
+interface ReleaseMapN extends HKT {
+    readonly type: ReleaseMap;
+}
+/**
+ * @tsplus type fncts.io.Scope.ReleaseMap
+ */
+export interface ReleaseMap extends Newtype<{
+    readonly ReleaseMap: unique symbol;
+}, Ref<State>> {
+}
+/**
+ * @tsplus type fncts.io.Scope.ReleaseMapOps
+ */
+export interface ReleaseMapOps extends Newtype.Iso<ReleaseMapN> {
+}
+export declare const ReleaseMap: ReleaseMapOps;
+export {};

package/Scope/ReleaseMap.d.ts

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

package/Scope/api.d.ts

@@ -0,0 +1,61 @@
+import { Scope } from "@fncts/io/Scope/definition";
+import { Lazy } from "@fncts/base/data/function";
+import { UIO, IO } from "@fncts/io/IO/definition";
+import { Has } from "@fncts/base/typeclass/Has";
+import { Finalizer } from "@fncts/io/Scope/Finalizer";
+import { Exit } from "@fncts/base/data/Exit";
+import { ExecutionStrategy } from "@fncts/base/data/ExecutionStrategy";
+import { Closeable } from "./definition.js";
+/**
+ * @tsplus fluent fncts.io.Scope addFinalizer
+ * @tsplus location "@fncts/io/Scope/api"
+ */
+export declare function addFinalizer_(self: Scope, finalizer: Lazy<UIO<any>>): UIO<void>;
+/**
+ * @tsplus static fncts.io.ScopeOps addFinalizer
+ * @tsplus location "@fncts/io/Scope/api"
+ */
+export declare function addFinalizer(finalizer: Lazy<UIO<void>>): IO<Has<Scope>, never, void>;
+/**
+ * @tsplus static fncts.io.ScopeOps concurrent
+ * @tsplus static fncts.io.Scope.CloseableOps concurrent
+ * @tsplus location "@fncts/io/Scope/api"
+ */
+export declare const concurrent: UIO<Scope.Closeable>;
+/**
+ * @tsplus fluent fncts.io.Scope extend
+ * @tsplus location "@fncts/io/Scope/api"
+ */
+export declare function extend_<R, E, A>(self: Scope, io: Lazy<IO<R & Has<Scope>, E, A>>): IO<R, E, A>;
+/**
+ * @tsplus static fncts.io.ScopeOps global
+ * @tsplus location "@fncts/io/Scope/api"
+ */
+export declare const global: Scope.Closeable;
+/**
+ * @tsplus static fncts.io.ScopeOps make
+ * @tsplus static fncts.io.Scope.CloseableOps make
+ * @tsplus location "@fncts/io/Scope/api"
+ */
+export declare const make: UIO<Scope.Closeable>;
+/**
+ * @tsplus static fncts.io.ScopeOps makeWith
+ * @tsplus static fncts.io.Scope.CloseableOps makeWith
+ * @tsplus location "@fncts/io/Scope/api"
+ */
+export declare function makeWith(executionStrategy: Lazy<ExecutionStrategy>): UIO<Scope.Closeable>;
+/**
+ * @tsplus static fncts.io.ScopeOps unsafeMake
+ * @tsplus location "@fncts/io/Scope/api"
+ */
+export declare function unsafeMake(): Closeable;
+/**
+ * @tsplus static fncts.io.ScopeOps unsafeMakeWith
+ * @tsplus location "@fncts/io/Scope/api"
+ */
+export declare function unsafeMakeWith(executionStrategy: ExecutionStrategy): Scope.Closeable;
+/**
+ * @tsplus fluent fncts.io.Scope.Closeable use
+ * @tsplus location "@fncts/io/Scope/api"
+ */
+export declare function use_<R, E, A>(self: Scope.Closeable, io: Lazy<IO<R & Has<Scope>, E, A>>): IO<R, E, A>;

package/Scope/definition.d.ts

@@ -0,0 +1,32 @@
+import { Finalizer } from "@fncts/io/Scope/Finalizer";
+import { UIO } from "@fncts/io/IO/definition";
+import { Lazy } from "@fncts/base/data/function";
+import { Exit } from "@fncts/base/data/Exit";
+export declare const ScopeTypeId: unique symbol;
+export declare type ScopeTypeId = typeof ScopeTypeId;
+/**
+ * @tsplus type fncts.io.Scope
+ * @tsplus companion fncts.io.ScopeOps
+ */
+export declare abstract class Scope {
+    readonly _typeId: ScopeTypeId;
+    abstract addFinalizerExit(finalizer: Finalizer): UIO<void>;
+    abstract fork: UIO<Scope.Closeable>;
+}
+/**
+ * @tsplus type fncts.io.Scope.Closeable
+ * @tsplus companion fncts.io.Scope.CloseableOps
+ */
+export declare abstract class Closeable extends Scope {
+    abstract close(exit: Lazy<Exit<any, any>>): UIO<void>;
+}
+declare type Closeable_ = Closeable;
+export declare namespace Scope {
+    type Closeable = Closeable_;
+}
+/**
+ * @tsplus static fncts.io.ScopeOps Tag
+ * @tsplus location "@fncts/io/Scope/definition"
+ */
+export declare const ScopeTag: import("@fncts/base/data/Tag").Tag<Scope>;
+export {};

package/Scope.d.ts

@@ -0,0 +1,2 @@
+export * from "./Scope/api.js";
+export * from "./Scope/definition.js";

package/ScopedRef/api.d.ts

@@ -0,0 +1,9 @@
+import { IO, UIO, FIO } from "@fncts/io/IO/definition";
+import { Has } from "@fncts/base/typeclass/Has";
+import { Scope } from "@fncts/io/Scope/definition";
+import { ScopedRef } from "@fncts/io/ScopedRef/definition";
+/**
+ * @tsplus static fncts.io.ScopedRefOps fromAcquire
+ * @tsplus location "@fncts/io/ScopedRef/api"
+ */
+export declare function fromAcquire<R, E, A>(acquire: IO<R, E, A>, __tsplusTrace?: string): IO<R & Has<Scope>, E, ScopedRef<A>>;

package/ScopedRef/definition.d.ts

@@ -0,0 +1,14 @@
+import { IO, UIO } from "@fncts/io/IO/definition";
+import { Has } from "@fncts/base/typeclass/Has";
+import { Scope } from "@fncts/io/Scope/definition";
+export declare const ScopedRefTypeId: unique symbol;
+export declare type ScopedRefTypeId = typeof ScopedRefTypeId;
+/**
+ * @tsplus type fncts.io.ScopedRef
+ * @tsplus companion fncts.io.ScopedRefOps
+ */
+export declare abstract class ScopedRef<A> {
+    readonly _typeId: ScopedRefTypeId;
+    abstract set<R, E>(acquire: IO<R & Has<Scope>, E, A>, __tsplusTrace?: string): IO<R, E, void>;
+    abstract get: UIO<A>;
+}

package/ScopedRef.d.ts

@@ -0,0 +1,2 @@
+export * from "./ScopedRef/api.js";
+export * from "./ScopedRef/definition.js";

package/Sink/api.d.ts

@@ -0,0 +1,35 @@
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { Channel } from "@fncts/io/Channel";
+import { Sink } from "@fncts/io/Sink/definition";
+import { Predicate } from "@fncts/base/data/Predicate";
+import { IO } from "@fncts/io/IO/definition";
+/**
+ * A sink that collects all of its inputs into a chunk.
+ * @tsplus static fncts.io.SinkOps collectAll
+ * @tsplus location "@fncts/io/Sink/api"
+ */
+export declare function collectAll<Err, A>(): Sink<unknown, Err, A, never, Conc<A>>;
+/**
+ * A sink that ignores all of its inputs.
+ * @tsplus static fncts.io.SinkOps drain
+ * @tsplus location "@fncts/io/Sink/api"
+ */
+export declare const drain: Sink<unknown, never, unknown, never, void>;
+/**
+ * @tsplus static fncts.io.SinkOps dropWhile
+ * @tsplus location "@fncts/io/Sink/api"
+ */
+export declare function dropWhile<Err, In>(predicate: Predicate<In>): Sink<unknown, never, In, In, any>;
+/**
+ * A sink that executes the provided effectful function for every element fed to it.
+ * @tsplus static fncts.io.SinkOps foreach
+ * @tsplus location "@fncts/io/Sink/api"
+ */
+export declare function foreach<R, Err, In>(f: (inp: In) => IO<R, Err, any>): Sink<R, Err, In, In, void>;
+/**
+ * A sink that executes the provided effectful function for every element fed to it
+ * until `f` evaluates to `false`.
+ * @tsplus static fncts.io.SinkOps foreachWhile
+ * @tsplus location "@fncts/io/Sink/api"
+ */
+export declare function foreachWhile<R, Err, In>(f: (_: In) => IO<R, Err, boolean>): Sink<R, Err, In, In, void>;

package/Sink/definition.d.ts

@@ -0,0 +1,15 @@
+import { Channel } from "@fncts/io/Channel";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+/**
+ * Sink is a data type that represent a channel that reads elements
+ * of type `In`, handles input errors of type `InErr`, emits errors
+ * of type `OutErr`, emits outputs of type `L` and ends with a value
+ * of type `Z`.
+ *
+ * @tsplus type fncts.io.Sink
+ * @tsplus companion fncts.io.SinkOps
+ */
+export declare class Sink<R, E, In, L, Z> {
+    readonly channel: Channel<R, never, Conc<In>, unknown, E, Conc<L>, Z>;
+    constructor(channel: Channel<R, never, Conc<In>, unknown, E, Conc<L>, Z>);
+}

package/Sink.d.ts

@@ -0,0 +1,2 @@
+export * from "./Sink/api.js";
+export * from "./Sink/definition.js";

package/State/api.d.ts

@@ -0,0 +1,25 @@
+import { UIO } from "@fncts/io/IO/definition";
+import { Tag } from "@fncts/base/data/Tag";
+import { Layer } from "@fncts/io/Layer";
+import { Has } from "@fncts/base/typeclass/Has";
+import type { State } from "./definition.js";
+/**
+ * @tsplus getter fncts.io.State get
+ * @tsplus location "@fncts/io/State/api"
+ */
+export declare function get_<S>(self: State<S>, __tsplusTrace?: string): UIO<S>;
+/**
+ * @tsplus static fncts.io.StateOps initial
+ * @tsplus location "@fncts/io/State/api"
+ */
+export declare function initial<S>(s: S, tag: Tag<State<S>>): Layer<unknown, never, Has<State<S>>>;
+/**
+ * @tsplus fluent fncts.io.State set
+ * @tsplus location "@fncts/io/State/api"
+ */
+export declare function set_<S>(self: State<S>, value: S, __tsplusTrace?: string): UIO<void>;
+/**
+ * @tsplus fluent 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>;

package/State/definition.d.ts

@@ -0,0 +1,14 @@
+import type { StateInternal } from "./internal.js";
+import { StateTypeId } from "./internal.js";
+/**
+ * @tsplus type fncts.io.State
+ * @tsplus companion fncts.io.StateOps
+ */
+export declare abstract class State<S> {
+    readonly _A: () => S;
+    readonly _typeId: StateTypeId;
+}
+/**
+ * @tsplus macro remove
+ */
+export declare function concrete<A>(_: State<A>): asserts _ is StateInternal<A>;

package/State/internal.d.ts

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

package/State.d.ts

@@ -0,0 +1,2 @@
+export * from "./State/api.js";
+export * from "./State/definition.js";

package/Stream/api/zipAllWith.d.ts

@@ -0,0 +1,10 @@
+import { Stream } from "@fncts/io/Stream/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { IO } from "@fncts/io/IO/definition";
+import { Maybe } from "@fncts/base/data/Maybe";
+import { Exit } from "@fncts/base/data/Exit";
+/**
+ * @tsplus fluent 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): Stream<R & R1, E | E1, C | D | F>;

package/Stream/api/zipWith.d.ts

@@ -0,0 +1,6 @@
+import { Stream } from "@fncts/io/Stream/definition";
+/**
+ * @tsplus fluent 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): Stream<R & R1, E | E1, C>;

package/Stream/api/zipWithChunks.d.ts

@@ -0,0 +1,11 @@
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { IO } from "@fncts/io/IO/definition";
+import { Maybe } from "@fncts/base/data/Maybe";
+import { Either } from "@fncts/base/data/Either";
+import { Exit } from "@fncts/base/data/Exit";
+import { Stream } from "@fncts/io/Stream/definition";
+/**
+ * @tsplus fluent 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>>]): Stream<R & R1, E | E1, C>;