@fncts/query 0.0.1

package/Cache/api.d.ts

@@ -0,0 +1,28 @@
+import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
+import { FIO } from "@fncts/io/IO/definition";
+import { Nothing } from "@fncts/base/data/Maybe/definition";
+import { Left, Right } from "@fncts/base/data/Either";
+import type { Either } from "@fncts/base/data/Either";
+import type { Maybe } from "@fncts/base/data/Maybe";
+import type { UIO } from "@fncts/io/IO";
+import type { Request } from "@fncts/query/Request";
+import { Ref } from "@fncts/io/Ref";
+import { Cache } from "@fncts/query/Cache/definition";
+/**
+ * @tsplus static fncts.query.CacheOps empty
+ * @tsplus location "@fncts/query/Cache/api"
+ */
+export declare function empty(__tsplusTrace?: string): UIO<Cache>;
+export declare class Default extends Cache {
+    private readonly state;
+    constructor(state: Ref<HashMap<any, any>>);
+    get<E, A>(request: Request<E, A>, __tsplusTrace?: string | undefined): FIO<void, Ref<Maybe<Either<E, A>>>>;
+    lookup<E, A extends Request<E, B>, B>(request: A, __tsplusTrace?: string | undefined): UIO<Either<Ref<Maybe<Either<E, B>>>, Ref<Maybe<Either<E, B>>>>>;
+    put<E, A>(request: Request<E, A>, result: Ref<Maybe<Either<E, A>>>, __tsplusTrace?: string | undefined): UIO<void>;
+    remove<E, A>(request: Request<E, A>, __tsplusTrace?: string | undefined): UIO<void>;
+}
+/**
+ * @tsplus static fncts.query.CacheOps unsafeMake
+ * @tsplus location "@fncts/query/Cache/api"
+ */
+export declare function unsafeMake(): Cache;

package/Cache/definition.d.ts

@@ -0,0 +1,15 @@
+import { Request } from "@fncts/query/Request";
+import { FIO, UIO } from "@fncts/io/IO/definition";
+import { Ref } from "@fncts/io/Ref/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { Either } from "@fncts/base/data/Either/definition";
+/**
+ * @tsplus type fncts.query.Cache
+ * @tsplus companion fncts.query.CacheOps
+ */
+export declare abstract class Cache {
+    abstract get<E, A>(request: Request<E, A>, __tsplusTrace?: string): FIO<void, Ref<Maybe<Either<E, A>>>>;
+    abstract lookup<E, A>(request: Request<E, A>, __tsplusTrace?: string): UIO<Either<Ref<Maybe<Either<E, A>>>, Ref<Maybe<Either<E, A>>>>>;
+    abstract put<E, A>(request: Request<E, A>, result: Ref<Maybe<Either<E, A>>>, __tsplusTrace?: string): UIO<void>;
+    abstract remove<E, A>(request: Request<E, A>, __tsplusTrace?: string): UIO<void>;
+}

package/Cache.d.ts

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

package/CompletedRequestMap.d.ts

@@ -0,0 +1,17 @@
+import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
+import { Either } from "@fncts/base/data/Either/definition";
+import { Request } from "@fncts/query/Request";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { Left, Right } from "@fncts/base/data/Either";
+import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
+export declare class CompletedRequestMap {
+    private map;
+    constructor(map: HashMap<any, Either<any, any>>);
+    static empty(): CompletedRequestMap;
+    concat(that: CompletedRequestMap): CompletedRequestMap;
+    insert<E, A>(request: Request<E, A>, result: Either<E, A>): CompletedRequestMap;
+    insertMaybe<E, A>(request: Request<E, A>, result: Either<E, Maybe<A>>): CompletedRequestMap;
+    lookup<E, A>(request: Request<E, A>): Maybe<Either<E, A>>;
+    requests(): HashSet<Request<any, any>>;
+    contains(request: any): boolean;
+}

package/DataSource/api.d.ts

@@ -0,0 +1,38 @@
+import { Environment } from "@fncts/base/data/Environment/definition";
+import { Request } from "@fncts/query/Request";
+import type { Conc } from "@fncts/base/collection/immutable/Conc";
+import type { Described } from "@fncts/query/Described";
+import { IO } from "@fncts/io/IO";
+import { CompletedRequestMap } from "@fncts/query/CompletedRequestMap";
+import { DataSource } from "@fncts/query/DataSource/definition";
+/**
+ * @tsplus pipeable fncts.query.DataSource contramap
+ * @tsplus location "@fncts/query/DataSource/api"
+ */
+export declare function contamap<A, B>(f: Described<(b: B) => A>): <R>(self: DataSource<R, A>) => DataSource<R, B>;
+/**
+ * @tsplus pipeable fncts.query.DataSource contramapEnvironment
+ * @tsplus location "@fncts/query/DataSource/api"
+ */
+export declare function contramapEnvironment<R0, R>(f: Described<(_: Environment<R0>) => Environment<R>>, __tsplusTrace?: string): <A>(self: DataSource<R, A>) => DataSource<R0, A>;
+/**
+ * @tsplus static fncts.query.BatchedOps make
+ * @tsplus static fncts.query.DataSourceOps makeBatched
+ * @tsplus location "@fncts/query/DataSource/api"
+ */
+export declare function makeBatched<R, A>(name: string, f: (requests: Conc<A>) => IO<R, never, CompletedRequestMap>): DataSource<R, A>;
+/**
+ * @tsplus static fncts.query.DataSourceOps make
+ * @tsplus location "@fncts/query/DataSource/api"
+ */
+export declare function make<R, A>(name: string, f: (requests: Conc<Conc<A>>) => IO<R, never, CompletedRequestMap>): DataSource<R, A>;
+/**
+ * @tsplus static fncts.query.DataSourceOps fromFunction
+ * @tsplus location "@fncts/query/DataSource/api"
+ */
+export declare function fromFunction<A extends Request<never, B>, B>(name: string, f: (a: A) => B): DataSource<never, A>;
+/**
+ * @tsplus static fncts.query.DataSourceOps fromFunctionIO
+ * @tsplus location "@fncts/query/DataSource/api"
+ */
+export declare function fromFunctionIO<R, E, A extends Request<E, B>, B>(name: string, f: (a: A) => IO<R, E, B>): DataSource<R, A>;

package/DataSource/definition.d.ts

@@ -0,0 +1,46 @@
+import { Hashable } from "@fncts/base/data/Hashable";
+import { Equatable } from "@fncts/base/data/Equatable";
+import { IllegalArgumentError } from "@fncts/base/data/exceptions";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { IO } from "@fncts/io/IO";
+import { CompletedRequestMap } from "@fncts/query/CompletedRequestMap";
+export declare const DataSourceTypeId: unique symbol;
+export type DataSourceTypeId = typeof DataSourceTypeId;
+export declare const DataSourceVariance: unique symbol;
+export type DataSourceVariance = typeof DataSourceVariance;
+/**
+ * @tsplus type fncts.query.DataSource
+ * @tsplus companion fncts.query.DataSourceOps
+ */
+export declare abstract class DataSource<out R, in A> implements Hashable, Equatable {
+    readonly [DataSourceTypeId]: DataSourceTypeId;
+    [DataSourceVariance]: {
+        readonly _R: (_: never) => R;
+        readonly _A: (_: A) => void;
+    };
+    /**
+     * The data source's identifier.
+     */
+    abstract readonly identifier: string;
+    /**
+     * Execute a collection of requests. The outer `Chunk` represents batches of
+     * requests that must be performed sequentially. The inner `Chunk` represents
+     * a batch of requests that can be performed in parallel.
+     */
+    abstract runAll(requests: Conc<Conc<A>>, __tsplusTrace?: string): IO<R, never, CompletedRequestMap>;
+    /**
+     * Returns a data source that executes at most `n` requests in parallel.
+     */
+    batchN(n: number): DataSource<R, A>;
+    get [Symbol.hash](): number;
+    [Symbol.equals](that: unknown): boolean;
+}
+/**
+ * @tsplus type fncts.query.Batched
+ * @tsplus companion fncts.query.BatchedOps
+ */
+export declare abstract class Batched<R, A> extends DataSource<R, A> {
+    abstract run(requests: Conc<A>, __tsplusTrace?: string): IO<R, never, CompletedRequestMap>;
+    runAll(requests: Conc<Conc<A>>, __tsplusTrace?: string | undefined): IO<R, never, CompletedRequestMap>;
+}
+export declare function isDataSource(u: unknown): u is DataSource<unknown, unknown>;

package/DataSource.d.ts

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

package/DataSourceAspect.d.ts

@@ -0,0 +1,7 @@
+import { DataSource } from "@fncts/query/DataSource";
+export declare const DataSourceAspectTypeId: unique symbol;
+export type DataSourceAspectTypeId = typeof DataSourceAspectTypeId;
+export declare abstract class DataSourceAspect<R> {
+    readonly [DataSourceAspectTypeId]: DataSourceAspectTypeId;
+    abstract apply<R1, A>(dataSource: DataSource<R1, A>): DataSource<R | R1, A>;
+}

package/Described.d.ts

@@ -0,0 +1,19 @@
+/**
+ * A `Described<A>` is a value of type `A` along with a string description of
+ * that value. The description may be used to generate a hash associated with
+ * the value, so values that are equal should have the same description and
+ * values that are not equal should have different descriptions.
+ *
+ * @tsplus type fncts.query.Described
+ * @tsplus companion fncts.query.DescribedOps
+ */
+export declare class Described<A> {
+    readonly value: A;
+    readonly description: string;
+    constructor(value: A, description: string);
+}
+/**
+ * @tsplus pipeable global described
+ * @tsplus location "@fncts/query/Described"
+ */
+export declare function described(description: string): <A>(value: A) => Described<A>;

package/Query/api/bimap.d.ts

@@ -0,0 +1,6 @@
+import { Query } from "@fncts/query/Query/definition";
+/**
+ * @tsplus pipeable fncts.query.Query bimap
+ * @tsplus location "@fncts/query/Query/api/bimap"
+ */
+export declare function bimap<E, A, E1, B>(failure: (e: E) => E1, success: (a: A) => B, __tsplusTrace?: string): <R>(self: import("../definition").Query<R, E, A>) => import("../definition").Query<R, E1, B>;

package/Query/api/catchAllCause.d.ts

@@ -0,0 +1,12 @@
+import { Cause } from "@fncts/base/data/Cause/definition";
+import { Query } from "@fncts/query/Query/definition";
+/**
+ * @tsplus pipeable fncts.query.Query catchAllCause
+ * @tsplus location "@fncts/query/Query/api/catchAllCause"
+ */
+export declare function catchAllCause<E, R1, E1, B>(f: (cause: Cause<E>) => Query<R1, E1, B>, __tsplusTrace?: string): <R, A>(self: import("../definition").Query<R, E, A>) => import("../definition").Query<R1 | R, E1, B | A>;
+/**
+ * @tsplus pipeable fncts.query.Query catchAll
+ * @tsplus location "@fncts/query/Query/api/catchAllCause"
+ */
+export declare function catchAll<E, R1, E1, B>(f: (e: E) => Query<R1, E1, B>, __tsplusTrace?: string): <R, A>(self: import("../definition").Query<R, E, A>) => import("../definition").Query<R1 | R, E1, B | A>;

package/Query/api/collectAll.d.ts

@@ -0,0 +1,7 @@
+import { Query } from "@fncts/query/Query/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+/**
+ * @tsplus static fncts.query.QueryOps collectAll
+ * @tsplus location "@fncts/query/Query/api/collectAll"
+ */
+export declare function collectAll<R, E, A>(self: Iterable<Query<R, E, A>>, __tsplusTrace?: string): Query<R, E, Conc<A>>;

package/Query/api/collectAllBatched.d.ts

@@ -0,0 +1,7 @@
+import { Query } from "@fncts/query/Query/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+/**
+ * @tsplus static fncts.query.QueryOps collectAllBatched
+ * @tsplus location "@fncts/query/Query/api/collectAllBatched"
+ */
+export declare function collectAllBatched<R, E, A>(self: Iterable<Query<R, E, A>>, __tsplusTrace?: string): Query<R, E, Conc<A>>;

package/Query/api/collectAllConcurrent.d.ts

@@ -0,0 +1,7 @@
+import { Query } from "@fncts/query/Query/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+/**
+ * @tsplus static fncts.query.QueryOps collectAllConcurrent
+ * @tsplus location "@fncts/query/Query/api/collectAllConcurrent"
+ */
+export declare function collectAllConcurrent<R, E, A>(self: Iterable<Query<R, E, A>>, __tsplusTrace?: string): Query<R, E, Conc<A>>;

package/Query/api/defer.d.ts

@@ -0,0 +1,7 @@
+import { Lazy } from "@fncts/base/data/function/definition";
+import { Query } from "@fncts/query/Query/definition";
+/**
+ * @tsplus static fncts.query.QueryOps defer
+ * @tsplus location "@fncts/query/Query/api/defer"
+ */
+export declare function defer<R, E, A>(query: Lazy<Query<R, E, A>>): Query<R, E, A>;

package/Query/api/ensuring.d.ts

@@ -0,0 +1,6 @@
+import { Query } from "@fncts/query/Query/definition";
+/**
+ * @tsplus pipeable fncts.query.Query ensuring
+ * @tsplus location "@fncts/query/Query/api/ensuring"
+ */
+export declare function ensuring<R1>(finalizer: Query<R1, never, any>, __tsplusTrace?: string): <R, E, A>(self: import("../definition").Query<R, E, A>) => import("../definition").Query<R1 | R, E, A>;

package/Query/api/environment.d.ts

@@ -0,0 +1,47 @@
+import { Query } from "@fncts/query/Query/definition";
+import { Environment } from "@fncts/base/data/Environment/definition";
+import { IO } from "@fncts/io/IO/definition";
+import { Lazy } from "@fncts/base/data/function/definition";
+import { Layer } from "@fncts/io/Layer";
+import { Result } from "@fncts/query/internal/Result";
+import { Described } from "@fncts/query/Described";
+/**
+ * @tsplus static fncts.query.QueryOps environment
+ * @tsplus location "@fncts/query/Query/api/environment"
+ */
+export declare function environment<R>(): Query<R, never, Environment<R>>;
+/**
+ * @tsplus static fncts.query.QueryOps environmentWith
+ * @tsplus location "@fncts/query/Query/api/environment"
+ */
+export declare function environmentWith<R, A>(f: (environment: Environment<R>) => A): Query<R, never, A>;
+/**
+ * @tsplus static fncts.query.QueryOps environmentWithQuery
+ * @tsplus location "@fncts/query/Query/api/environment"
+ */
+export declare function environmentWithQuery<R0, R, E, A>(f: (environment: Environment<R0>) => Query<R, E, A>): Query<R0 | R, E, A>;
+/**
+ * @tsplus static fncts.query.QueryOps environmentWithIO
+ * @tsplus location "@fncts/query/Query/api/environment"
+ */
+export declare function environmentWithIO<R0, R, E, A>(f: (environment: Environment<R0>) => IO<R, E, A>): Query<R0 | R, E, A>;
+/**
+ * @tsplus pipeable fncts.query.Query contramapEnvironment
+ * @tsplus location "@fncts/query/Query/api/environment"
+ */
+export declare function contramapEnvironment<R0, R>(f: Described<(_: Environment<R0>) => Environment<R>>, __tsplusTrace?: string): <E, A>(self: import("../definition").Query<R, E, A>) => import("../definition").Query<R0, E, A>;
+/**
+ * @tsplus pipeable fncts.query.Query provideEnvironment
+ * @tsplus location "@fncts/query/Query/api/environment"
+ */
+export declare function provideEnvironment<R>(environment: Described<Environment<R>>, __tsplusTrace?: string): <E, A>(self: import("../definition").Query<R, E, A>) => import("../definition").Query<never, E, A>;
+/**
+ * @tsplus pipeable fncts.query.Query provideSomeEnvironment
+ * @tsplus location "@fncts/query/Query/api/environment"
+ */
+export declare function provideSomeEnvironment<R0>(environment: Described<Environment<R0>>, __tsplusTrace?: string): <R, E, A>(self: import("../definition").Query<R, E, A>) => import("../definition").Query<Exclude<R, R0>, E, A>;
+/**
+ * @tsplus pipeable fncts.query.Query provideLayer
+ * @tsplus location "@fncts/query/Query/api/environment"
+ */
+export declare function provideLayer<RIn, E1, ROut>(layer: Lazy<Described<Layer<RIn, E1, ROut>>>, __tsplusTrace?: string): <R, E, A>(self: import("../definition").Query<R, E, A>) => import("../definition").Query<RIn | Exclude<R, ROut>, E1 | E, A>;

package/Query/api/flatMap.d.ts

@@ -0,0 +1,11 @@
+import { Query } from "@fncts/query/Query/definition";
+/**
+ * @tsplus pipeable fncts.query.Query flatMap
+ * @tsplus location "@fncts/query/Query/api/flatMap"
+ */
+export declare function flatMap<A, R1, E1, B>(f: (a: A) => Query<R1, E1, B>, __tsplusTrace?: string): <R, E>(self: import("../definition").Query<R, E, A>) => import("../definition").Query<R1 | R, E1 | E, B>;
+/**
+ * @tsplus getter fncts.query.Query flatten
+ * @tsplus location "@fncts/query/Query/api/flatMap"
+ */
+export declare function flatten<R, E, R1, E1, A>(self: Query<R, E, Query<R1, E1, A>>, __tsplusTrace?: string): Query<R | R1, E | E1, A>;

package/Query/api/foreach.d.ts

@@ -0,0 +1,7 @@
+import { Query } from "@fncts/query/Query/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+/**
+ * @tsplus static fncts.query.QueryOps foreach
+ * @tsplus location "@fncts/query/Query/api/foreach"
+ */
+export declare function foreach<A, R, E, B>(as: Iterable<A>, f: (a: A) => Query<R, E, B>, __tsplusTrace?: string): Query<R, E, Conc<B>>;

package/Query/api/foreachBatched.d.ts

@@ -0,0 +1,7 @@
+import { Query } from "@fncts/query/Query/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+/**
+ * @tsplus static fncts.query.QueryOps foreachBatched
+ * @tsplus location "@fncts/query/Query/api/foreachBatched"
+ */
+export declare function foreachBatched<A, R, E, B>(as: Iterable<A>, f: (a: A) => Query<R, E, B>, __tsplusTrace?: string): Query<R, E, Conc<B>>;

package/Query/api/foreachConcurrent.d.ts

@@ -0,0 +1,7 @@
+import { Query } from "@fncts/query/Query/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+/**
+ * @tsplus static fncts.query.QueryOps foreachConcurrent
+ * @tsplus location "@fncts/query/Query/api/foreachConcurrent"
+ */
+export declare function foreachConcurrent<A, R, E, B>(self: Iterable<A>, f: (a: A) => Query<R, E, B>, __tsplusTrace?: string): Query<R, E, Conc<B>>;

package/Query/api/fromRequest.d.ts

@@ -0,0 +1,10 @@
+import { Request } from "@fncts/query/Request";
+import { Lazy } from "@fncts/base/data/function/definition";
+import { DataSource } from "@fncts/query/DataSource";
+import { Query } from "@fncts/query/Query/definition";
+import { Either } from "@fncts/base/data/Either/definition";
+/**
+ * @tsplus static fncts.query.QueryOps fromRequest
+ * @tsplus location "@fncts/query/Query/api/fromRequest"
+ */
+export declare function fromRequest<R, A extends Request<any, any>>(request0: Lazy<A>, dataSource0: Lazy<DataSource<R, A>>, __tsplusTrace?: string): Query<R, Request.ErrorOf<A>, Request.ValueOf<A>>;

package/Query/api/map.d.ts

@@ -0,0 +1,6 @@
+import { Query } from "@fncts/query/Query/definition";
+/**
+ * @tsplus pipeable fncts.query.Query map
+ * @tsplus location "@fncts/query/Query/api/map"
+ */
+export declare function map<A, B>(f: (a: A) => B): <R, E>(self: import("../definition").Query<R, E, A>) => import("../definition").Query<R, E, B>;

package/Query/api/mapDataSources.d.ts

@@ -0,0 +1,7 @@
+import { DataSourceAspect } from "@fncts/query/DataSourceAspect";
+import { Query } from "@fncts/query/Query/definition";
+/**
+ * @tsplus pipeable fncts.query.Query mapDataSources
+ * @tsplus location "@fncts/query/Query/api/mapDataSources"
+ */
+export declare function mapDataSources<R1>(f: DataSourceAspect<R1>): <R, E, A>(self: import("../definition").Query<R, E, A>) => import("../definition").Query<R1 | R, E, A>;

package/Query/api/mapError.d.ts

@@ -0,0 +1,6 @@
+import { Query } from "@fncts/query/Query/definition";
+/**
+ * @tsplus pipeable fncts.query.Query mapError
+ * @tsplus location "@fncts/query/Query/api/mapError"
+ */
+export declare function mapError<E, E1>(f: (e: E) => E1, __tsplusTrace?: string): <R, A>(self: import("../definition").Query<R, E, A>) => import("../definition").Query<R, E1, A>;

package/Query/api/mapErrorCause.d.ts

@@ -0,0 +1,7 @@
+import { Cause } from "@fncts/base/data/Cause/definition";
+import { Query } from "@fncts/query/Query/definition";
+/**
+ * @tsplus pipeable fncts.query.Query mapErrorCause
+ * @tsplus location "@fncts/query/Query/api/mapErrorCause"
+ */
+export declare function mapErrorCause<E, E1>(f: (cause: Cause<E>) => Cause<E1>, __tsplusTrace?: string): <R, A>(self: import("../definition").Query<R, E, A>) => import("../definition").Query<R, E1, A>;

package/Query/api/mapIO.d.ts

@@ -0,0 +1,7 @@
+import { IO } from "@fncts/io/IO/definition";
+import { Query } from "@fncts/query/Query/definition";
+/**
+ * @tsplus pipeable fncts.query.Query mapIO
+ * @tsplus location "@fncts/query/Query/api/mapIO"
+ */
+export declare function mapIO<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>): <R, E>(self: import("../definition").Query<R, E, A>) => import("../definition").Query<R1 | R, E1 | E, B>;

package/Query/api/match.d.ts

@@ -0,0 +1,6 @@
+import { Query } from "@fncts/query/Query/definition";
+/**
+ * @tsplus pipeable fncts.query.Query match
+ * @tsplus location "@fncts/query/Query/api/match"
+ */
+export declare function match<E, A, B, C>(failure: (e: E) => B, success: (a: A) => C): <R>(self: import("../definition").Query<R, E, A>) => import("../definition").Query<R, never, B | C>;

package/Query/api/matchCauseQuery.d.ts

@@ -0,0 +1,7 @@
+import { Cause } from "@fncts/base/data/Cause/definition";
+import { Query } from "@fncts/query/Query/definition";
+/**
+ * @tsplus pipeable fncts.query.Query matchCauseQuery
+ * @tsplus location "@fncts/query/Query/api/matchCauseQuery"
+ */
+export declare function matchCauseQuery<E, A, R1, E1, B, R2, E2, C>(failure: (cause: Cause<E>) => Query<R1, E1, B>, success: (a: A) => Query<R2, E2, C>): <R>(self: import("../definition").Query<R, E, A>) => import("../definition").Query<R1 | R2 | R, E1 | E2, B | C>;

package/Query/api/matchQuery.d.ts

@@ -0,0 +1,6 @@
+import { Query } from "@fncts/query/Query/definition";
+/**
+ * @tsplus pipeable fncts.query.Query matchQuery
+ * @tsplus location "@fncts/query/Query/api/matchQuery"
+ */
+export declare function matchQuery<E, A, R1, E1, B, R2, E2, C>(failure: (e: E) => Query<R1, E1, B>, success: (a: A) => Query<R2, E2, C>, __tsplusTrace?: string): <R>(self: import("../definition").Query<R, E, A>) => import("../definition").Query<R1 | R2 | R, E1 | E2, B | C>;

package/Query/api/orHalt.d.ts

@@ -0,0 +1,11 @@
+import { Query } from "@fncts/query/Query/definition";
+/**
+ * @tsplus pipeable fncts.query.Query orHaltWith
+ * @tsplus location "@fncts/query/Query/api/orHalt"
+ */
+export declare function orHaltWith<E>(f: (e: E) => unknown, __tsplusTrace?: string): <R, A>(self: import("../definition").Query<R, E, A>) => import("../definition").Query<R, never, A>;
+/**
+ * @tsplus getter fncts.query.Query orHalt
+ * @tsplus location "@fncts/query/Query/api/orHalt"
+ */
+export declare function orHalt<R, E, A>(self: Query<R, E, A>, __tsplusTrace?: string): Query<R, never, A>;

package/Query/api/race.d.ts

@@ -0,0 +1,11 @@
+import { Lazy } from "@fncts/base/data/function/definition";
+import { Query } from "@fncts/query/Query/definition";
+import { Fiber } from "@fncts/io/Fiber/definition";
+import { Result } from "@fncts/query/internal/Result";
+import { Exit } from "@fncts/base/data/Exit/definition";
+import { IO } from "@fncts/io/IO/definition";
+/**
+ * @tsplus pipeable fncts.query.Query race
+ * @tsplus location "@fncts/query/Query/api/race"
+ */
+export declare function race<R1, E1, A1>(that: Lazy<Query<R1, E1, A1>>, __tsplusTrace?: string): <R, E, A>(self: import("../definition").Query<R, E, A>) => import("../definition").Query<R1 | R, E1 | E, A1 | A>;

package/Query/api/run.d.ts

@@ -0,0 +1,18 @@
+import { Cache } from "@fncts/query/Cache";
+import { Query } from "@fncts/query/Query/definition";
+import { IO } from "@fncts/io/IO/definition";
+/**
+ * @tsplus pipeable fncts.query.Query runCache
+ * @tsplus location "@fncts/query/Query/api/run"
+ */
+export declare function runCache(cache: Cache, __tsplusTrace?: string): <R, E, A>(self: import("../definition").Query<R, E, A>) => import("@fncts/io/IO").IO<R, E, A>;
+/**
+ * @tsplus getter fncts.query.Query runLog
+ * @tsplus location "@fncts/query/Query/api/run"
+ */
+export declare function runLog<R, E, A>(self: Query<R, E, A>, __tsplusTrace?: string): IO<R, E, readonly [Cache, A]>;
+/**
+ * @tsplus getter fncts.query.Query run
+ * @tsplus location "@fncts/query/Query/api/run"
+ */
+export declare function run<R, E, A>(self: Query<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;

package/Query/api/timeout.d.ts

@@ -0,0 +1,26 @@
+import { Lazy } from "@fncts/base/data/function/definition";
+import { Duration } from "@fncts/base/data/Duration/definition";
+import { Query } from "@fncts/query/Query/definition";
+import { Fiber } from "@fncts/io/Fiber/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { Cause } from "@fncts/base/data/Cause/definition";
+/**
+ * @tsplus pipeable fncts.query.Query timeoutTo
+ * @tsplus location "@fncts/query/Query/api/timeout"
+ */
+export declare function timeoutTo<A, B, B1>(duration: Lazy<Duration>, b: Lazy<B>, f: (a: A) => B1, __tsplusTrace?: string): <R, E>(self: import("../definition").Query<R, E, A>) => import("../definition").Query<R, E, B | B1>;
+/**
+ * @tsplus pipeable fncts.query.Query timeout
+ * @tsplus location "@fncts/query/Query/api/timeout"
+ */
+export declare function timeout(duration: Lazy<Duration>, __tsplusTrace?: string): <R, E, A>(self: import("../definition").Query<R, E, A>) => import("../definition").Query<R, E, import("@fncts/base/data/Maybe").Maybe<A>>;
+/**
+ * @tsplus pipeable fncts.query.Query timeoutFail
+ * @tsplus location "@fncts/query/Query/api/timeout"
+ */
+export declare function timeoutFail<E1>(duration: Lazy<Duration>, e: Lazy<E1>, __tsplusTrace?: string): <R, E, A>(self: import("../definition").Query<R, E, A>) => import("../definition").Query<R, E1 | E, A>;
+/**
+ * @tsplus pipeable fncts.query.Query timeoutFailCause
+ * @tsplus location "@fncts/query/Query/api/timeout"
+ */
+export declare function timeoutFailCause<E1>(duration: Lazy<Duration>, e: Lazy<Cause<E1>>, __tsplusTrace?: string): <R, E, A>(self: import("../definition").Query<R, E, A>) => import("../definition").Query<R, E1 | E, A>;

package/Query/api/zipWith.d.ts

@@ -0,0 +1,7 @@
+import { Lazy } from "@fncts/base/data/function/definition";
+import { Query } from "@fncts/query/Query/definition";
+/**
+ * @tsplus pipeable fncts.query.Query zipWith
+ * @tsplus location "@fncts/query/Query/api/zipWith"
+ */
+export declare function zipWith<A, R1, E1, B, C>(that: Lazy<Query<R1, E1, B>>, f: (a: A, b: B) => C, __tsplusTrace?: string): <R, E>(self: import("../definition").Query<R, E, A>) => import("../definition").Query<R1 | R, E1 | E, C>;

package/Query/api/zipWithBatched.d.ts

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

package/Query/api/zipWithConcurrent.d.ts

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

package/Query/api.d.ts

@@ -0,0 +1,66 @@
+import { FiberRef } from "@fncts/io/FiberRef/definition";
+import { Cache } from "@fncts/query/Cache";
+import { Lazy } from "@fncts/base/data/function/definition";
+import { IO } from "@fncts/io/IO/definition";
+import { Query } from "@fncts/query/Query/definition";
+import { Cause } from "@fncts/base/data/Cause/definition";
+/**
+ * @tsplus static fncts.query.QueryOps cachingEnabled
+ * @tsplus location "@fncts/query/Query/api"
+ */
+export declare const cachingEnabled: FiberRef<boolean>;
+/**
+ * @tsplus static fncts.query.QueryOps currentCache
+ * @tsplus location "@fncts/query/Query/api"
+ */
+export declare const currentCache: FiberRef<Cache>;
+/**
+ * @tsplus static fncts.query.QueryOps fromIO
+ * @tsplus location "@fncts/query/Query/api"
+ */
+export declare function fromIO<R, E, A>(io: Lazy<IO<R, E, A>>): Query<R, E, A>;
+/**
+ * @tsplus static fncts.query.QueryOps failCause
+ * @tsplus location "@fncts/query/Query/api"
+ */
+export declare function failCause<E>(cause: Lazy<Cause<E>>, __tsplusTrace?: string): Query<never, E, never>;
+/**
+ * @tsplus static fncts.query.QueryOps failCauseNow
+ * @tsplus location "@fncts/query/Query/api"
+ */
+export declare function failCauseNow<E>(cause: Cause<E>, __tsplusTrace?: string): Query<never, E, never>;
+/**
+ * @tsplus static fncts.query.QueryOps fail
+ * @tsplus location "@fncts/query/Query/api"
+ */
+export declare function fail<E>(e: Lazy<E>, __tsplusTrace?: string): Query<never, E, never>;
+/**
+ * @tsplus static fncts.query.QueryOps failNow
+ * @tsplus location "@fncts/query/Query/api"
+ */
+export declare function failNow<E>(e: E, __tsplusTrace?: string): Query<never, E, never>;
+/**
+ * @tsplus static fncts.query.QueryOps halt
+ * @tsplus location "@fncts/query/Query/api"
+ */
+export declare function halt(t: Lazy<unknown>, __tsplusTrace?: string): Query<never, never, never>;
+/**
+ * @tsplus static fncts.query.QueryOps haltNow
+ * @tsplus location "@fncts/query/Query/api"
+ */
+export declare function haltNow(t: unknown, __tsplusTrace?: string): Query<never, never, never>;
+/**
+ * @tsplus static fncts.query.QueryOps succeed
+ * @tsplus location "@fncts/query/Query/api"
+ */
+export declare function succeed<A>(value: Lazy<A>): Query<never, never, A>;
+/**
+ * @tsplus static fncts.query.QueryOps succeedNow
+ * @tsplus location "@fncts/query/Query/api"
+ */
+export declare function succeedNow<A>(value: A): Query<never, never, A>;
+/**
+ * @tsplus static fncts.query.QueryOps unit
+ * @tsplus location "@fncts/query/Query/api"
+ */
+export declare const unit: Query<never, never, void>;

package/Query/definition.d.ts

@@ -0,0 +1,13 @@
+import { IO } from "@fncts/io/IO/definition";
+import type { Result } from "@fncts/query/internal/Result";
+export declare const QueryTypeId: unique symbol;
+export type QueryTypeId = typeof QueryTypeId;
+/**
+ * @tsplus type fncts.query.Query
+ * @tsplus companion fncts.query.QueryOps
+ */
+export declare class Query<R, E, A> {
+    readonly step: IO<R, never, Result<R, E, A>>;
+    readonly [QueryTypeId]: QueryTypeId;
+    constructor(step: IO<R, never, Result<R, E, A>>);
+}