@fncts/query 0.0.1

package/global.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @tsplus global
+ */
+import type {} from "@fncts/base/global";
+/**
+ * @tsplus global
+ */
+import type {} from "@fncts/io/global";
+/**
+ * @tsplus global
+ */
+import type {} from "@fncts/query";
+/**
+ * @tsplus global
+ */
+import { Left, Right } from "@fncts/base/data/Either";
+/**
+ * @tsplus global
+ */
+import { Cache } from "@fncts/query/Cache";
+/**
+ * @tsplus global
+ */
+import { DataSource } from "@fncts/query/DataSource";
+/**
+ * @tsplus global
+ */
+import { DataSourceAspect } from "@fncts/query/DataSourceAspect";
+/**
+ * @tsplus global
+ */
+import { Continue } from "@fncts/query/internal/Continue";
+/**
+ * @tsplus global
+ */
+import { Result } from "@fncts/query/internal/Result";
+/**
+ * @tsplus global
+ */
+import { Query } from "@fncts/query/Query/definition";
+/**
+ * @tsplus global
+ */
+import { Request } from "@fncts/query/Request";
+export {};

package/index.d.ts

@@ -0,0 +1 @@
+export type {} from "./global.js";

package/internal/BlockedRequest.d.ts

@@ -0,0 +1,21 @@
+import { Request } from "@fncts/query/Request";
+import { Ref } from "@fncts/io/Ref/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { Either } from "@fncts/base/data/Either/definition";
+export declare const BlockedRequestTypeId: unique symbol;
+export type BlockedRequestTypeId = typeof BlockedRequestTypeId;
+/**
+ * @tsplus type fncts.query.BlockedRequest
+ * @tsplus companion fncts.query.BlockedRequestOps
+ */
+export declare class BlockedRequest<A> {
+    readonly request: Request<Request.ErrorOf<A>, Request.ValueOf<A>>;
+    readonly result: Ref<Maybe<Either<Request.ErrorOf<A>, Request.ValueOf<A>>>>;
+    readonly [BlockedRequestTypeId]: BlockedRequestTypeId;
+    constructor(request: Request<Request.ErrorOf<A>, Request.ValueOf<A>>, result: Ref<Maybe<Either<Request.ErrorOf<A>, Request.ValueOf<A>>>>);
+}
+/**
+ * @tsplus static fncts.query.BlockedRequestOps make
+ * @tsplus location "@fncts/query/internal/BlockedRequest"
+ */
+export declare function make<A extends Request<any, any>>(request: A, result: Ref<Maybe<Either<Request.ErrorOf<A>, Request.ValueOf<A>>>>): BlockedRequest<A>;

package/internal/BlockedRequests.d.ts

@@ -0,0 +1,123 @@
+import { List } from "@fncts/base/collection/immutable/List/definition";
+import { Either } from "@fncts/base/data/Either/definition";
+import { DataSourceAspect } from "@fncts/query/DataSourceAspect";
+import { Environment } from "@fncts/base/data/Environment/definition";
+import { IO } from "@fncts/io/IO/definition";
+import type { Sequential } from "./Sequential.js";
+import type { DataSource } from "@fncts/query/DataSource";
+import type { Described } from "@fncts/query/Described";
+import type { BlockedRequest } from "@fncts/query/internal/BlockedRequest";
+import { Parallel } from "./Parallel.js";
+export declare const BlockedRequestsTypeId: unique symbol;
+export type BlockedRequestsTypeId = typeof BlockedRequestsTypeId;
+export declare const BlockedRequestsVariance: unique symbol;
+export type BlockedRequestsVariance = typeof BlockedRequestsVariance;
+/**
+ * @tsplus type fncts.query.BlockedRequests
+ * @tsplus companion fncts.query.BlockedRequestsOps
+ */
+export declare abstract class BlockedRequests<R> {
+    readonly [BlockedRequestsTypeId]: BlockedRequestsTypeId;
+    [BlockedRequestsVariance]: {
+        readonly _R: (_: never) => R;
+    };
+}
+export declare const enum BlockedRequestsTag {
+    Empty = 0,
+    Single = 1,
+    Then = 2,
+    Both = 3
+}
+export declare class Empty extends BlockedRequests<never> {
+    readonly _tag = BlockedRequestsTag.Empty;
+}
+export declare class Single<R, A> extends BlockedRequests<R> {
+    readonly dataSource: DataSource<R, A>;
+    readonly blockedRequest: BlockedRequest<A>;
+    readonly _tag = BlockedRequestsTag.Single;
+    constructor(dataSource: DataSource<R, A>, blockedRequest: BlockedRequest<A>);
+}
+export declare class Then<R> extends BlockedRequests<R> {
+    readonly left: BlockedRequests<R>;
+    readonly right: BlockedRequests<R>;
+    readonly _tag = BlockedRequestsTag.Then;
+    constructor(left: BlockedRequests<R>, right: BlockedRequests<R>);
+}
+export declare class Both<R> extends BlockedRequests<R> {
+    readonly left: BlockedRequests<R>;
+    readonly right: BlockedRequests<R>;
+    readonly _tag = BlockedRequestsTag.Both;
+    constructor(left: BlockedRequests<R>, right: BlockedRequests<R>);
+}
+/**
+ * @tsplus static fncts.query.BlockedRequestsOps empty
+ * @tsplus location "@fncts/query/internal/BlockedRequests"
+ */
+export declare function empty<R>(): BlockedRequests<R>;
+/**
+ * @tsplus static fncts.query.BlockedRequestsOps single
+ * @tsplus location "@fncts/query/internal/BlockedRequests"
+ */
+export declare function single<R, A>(dataSource: DataSource<R, A>, blockedRequest: BlockedRequest<A>): BlockedRequests<R>;
+/**
+ * @tsplus static fncts.query.BlockedRequestsOps then
+ * @tsplus location "@fncts/query/internal/BlockedRequests"
+ */
+export declare function then<R>(left: BlockedRequests<R>, right: BlockedRequests<R>): BlockedRequests<R>;
+/**
+ * @tsplus static fncts.query.BlockedRequestsOps both
+ * @tsplus location "@fncts/query/internal/BlockedRequests"
+ */
+export declare function both<R>(left: BlockedRequests<R>, right: BlockedRequests<R>): BlockedRequests<R>;
+export declare abstract class BlockedRequestsFolder<R, Z> {
+    abstract readonly emptyCase: Z;
+    abstract singleCase<A>(dataSource: DataSource<R, A>, blockedRequest: BlockedRequest<A>): Z;
+    abstract bothCase(left: Z, right: Z): Z;
+    abstract thenCase(left: Z, right: Z): Z;
+}
+/**
+ * @tsplus pipeable fncts.query.BlockedRequests fold
+ * @tsplus location "@fncts/query/internal/BlockedRequests"
+ */
+export declare function fold<R, Z>(folder: BlockedRequestsFolder<R, Z>): (self: BlockedRequests<R>) => Z;
+export declare class MapDataSources<R> extends BlockedRequestsFolder<R, BlockedRequests<R>> {
+    readonly f: DataSourceAspect<R>;
+    constructor(f: DataSourceAspect<R>);
+    emptyCase: BlockedRequests<R>;
+    singleCase<A>(dataSource: DataSource<R, A>, blockedRequest: BlockedRequest<A>): BlockedRequests<R>;
+    bothCase(left: BlockedRequests<R>, right: BlockedRequests<R>): BlockedRequests<R>;
+    thenCase(left: BlockedRequests<R>, right: BlockedRequests<R>): BlockedRequests<R>;
+}
+/**
+ * @tsplus pipeable fncts.query.BlockedRequests mapDataSources
+ * @tsplus location "@fncts/query/internal/BlockedRequests"
+ */
+export declare function mapDataSources<R1>(f: DataSourceAspect<R1>): <R>(self: BlockedRequests<R>) => BlockedRequests<R1 | R>;
+export declare class ContramapEnvironment<R0, R> extends BlockedRequestsFolder<R, BlockedRequests<R0>> {
+    readonly f: Described<(_: Environment<R0>) => Environment<R>>;
+    constructor(f: Described<(_: Environment<R0>) => Environment<R>>);
+    emptyCase: BlockedRequests<R0>;
+    singleCase<A>(dataSource: DataSource<R, A>, blockedRequest: BlockedRequest<A>): BlockedRequests<R0>;
+    bothCase(left: BlockedRequests<R0>, right: BlockedRequests<R0>): BlockedRequests<R0>;
+    thenCase(left: BlockedRequests<R0>, right: BlockedRequests<R0>): BlockedRequests<R0>;
+}
+/**
+ * @tsplus pipeable fncts.query.BlockedRequests contramapEnvironment
+ * @tsplus location "@fncts/query/internal/BlockedRequests"
+ */
+export declare function contramapEnvironment<R0, R>(f: Described<(_: Environment<R0>) => Environment<R>>, __tsplusTrace?: string): (self: BlockedRequests<R>) => BlockedRequests<R0>;
+/**
+ * @tsplus getter fncts.query.BlockedRequests step
+ * @tsplus location "@fncts/query/internal/BlockedRequests"
+ */
+export declare function step<R>(c: BlockedRequests<R>): readonly [Parallel<R>, List<BlockedRequests<R>>];
+/**
+ * @tsplus getter fncts.query.BlockedRequests flatten
+ * @tsplus location "@fncts/query/internal/BlockedRequests"
+ */
+export declare function flatten<R>(blockedRequests: BlockedRequests<R>): List<Sequential<R>>;
+/**
+ * @tsplus getter fncts.query.BlockedRequests run
+ * @tsplus location "@fncts/query/internal/BlockedRequests"
+ */
+export declare function run<R>(self: BlockedRequests<R>, __tsplusTrace?: string): IO<R, never, void>;

package/internal/Continue.d.ts

@@ -0,0 +1,133 @@
+import { Query } from "@fncts/query/Query/definition";
+import { FIO } from "@fncts/io/IO/definition";
+import { Request } from "@fncts/query/Request";
+import { DataSource } from "@fncts/query/DataSource";
+import { Ref } from "@fncts/io/Ref/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { Either } from "@fncts/base/data/Either/definition";
+import { Cause } from "@fncts/base/data/Cause/definition";
+import { DataSourceAspect } from "@fncts/query/DataSourceAspect";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { Environment } from "@fncts/base/data/Environment/definition";
+import type { Described } from "@fncts/query/Described";
+export declare const ContinueTypeId: unique symbol;
+export type ContinueTypeId = typeof ContinueTypeId;
+export declare const ContinueVariance: unique symbol;
+export type ContinueVariance = typeof ContinueVariance;
+/**
+ * @tsplus type fncts.query.Continue
+ * @tsplus companion fncts.query.ContinueOps
+ */
+export declare abstract class Continue<R, E, A> {
+    readonly [ContinueTypeId]: ContinueTypeId;
+    [ContinueVariance]: {
+        readonly _R: (_: never) => R;
+        readonly _E: (_: never) => E;
+        readonly _A: (_: never) => A;
+    };
+}
+export declare const enum ContinueTag {
+    Effect = 0,
+    Get = 1
+}
+/**
+ * @tsplus companion fncts.query.Continue.EffectOps
+ */
+export declare class Effect<R, E, A> extends Continue<R, E, A> {
+    readonly query: Query<R, E, A>;
+    readonly _tag = ContinueTag.Effect;
+    constructor(query: Query<R, E, A>);
+}
+/**
+ * @tsplus companion fncts.query.Continue.GetOps
+ */
+export declare class Get<E, A> extends Continue<never, E, A> {
+    readonly io: FIO<E, A>;
+    readonly _tag = ContinueTag.Get;
+    constructor(io: FIO<E, A>);
+}
+/**
+ * @tsplus static fncts.query.Continue.EffectOps __call
+ * @tsplus static fncts.query.Continue effect
+ * @tsplus location "@fncts/query/internal/Continue"
+ */
+export declare function effect<R, E, A>(query: Query<R, E, A>): Continue<R, E, A>;
+/**
+ * @tsplus static fncts.query.Continue.GetOps __call
+ * @tsplus static fncts.query.Continue get
+ * @tsplus location "@fncts/query/internal/Continue"
+ */
+export declare function get<E, A>(io: FIO<E, A>): Continue<never, E, A>;
+/**
+ * @tsplus static fncts.query.ContinueOps __call
+ * @tsplus location "@fncts/query/internal/Continue"
+ */
+export declare function makeContinue<R, E, A extends Request<E, B>, B>(request: A, dataSource: DataSource<R, A>, ref: Ref<Maybe<Either<E, B>>>, __tsplusTrace?: string): Continue<R, E, B>;
+/**
+ * @tsplus pipeable fncts.query.Continue matchType
+ * @tsplus location "@fncts/query/internal/Continue"
+ */
+export declare function matchType<R, E, A, B, C>(cases: {
+    Effect: (query: Query<R, E, A>) => B;
+    Get: (io: FIO<E, A>) => C;
+}): (self: Continue<R, E, A>) => B | C;
+/**
+ * @tsplus pipeable fncts.query.Continue mapQuery
+ * @tsplus location "@fncts/query/internal/Continue"
+ */
+export declare function mapQuery<A, R1, E1, B>(f: (a: A) => Query<R1, E1, B>, __tsplusTrace?: string): <R, E>(self: Continue<R, E, A>) => Continue<R1 | R, E1 | E, B>;
+/**
+ * @tsplus pipeable fncts.query.Continue match
+ * @tsplus location "@fncts/query/internal/Continue"
+ */
+export declare function match<E, A, B, C>(failure: (e: E) => B, success: (a: A) => C, __tsplusTrace?: string): <R>(self: Continue<R, E, A>) => Continue<R, never, B | C>;
+/**
+ * @tsplus pipeable fncts.query.Continue matchCauseQuery
+ * @tsplus location "@fncts/query/internal/Continue"
+ */
+export declare function matchCauseQuery<E, A, R1, E1, B, R2, E2, C>(failure: (cause: Cause<E>) => Query<R1, E1, B>, success: (value: A) => Query<R2, E2, C>, __tsplusTrace?: string): <R>(self: Continue<R, E, A>) => Continue<R1 | R2 | R, E1 | E2, B | C>;
+/**
+ * @tsplus pipeable fncts.query.Continue map
+ * @tsplus location "@fncts/query/internal/Continue"
+ */
+export declare function map<A, B>(f: (a: A) => B, __tsplusTrace?: string): <R, E>(self: Continue<R, E, A>) => Continue<R, E, B>;
+/**
+ * @tsplus pipeable fncts.query.Continue mapDataSources
+ * @tsplus location "@fncts/query/internal/Continue"
+ */
+export declare function mapDataSources<R1>(f: DataSourceAspect<R1>, __tsplusTrace?: string): <R, E, A>(self: Continue<R, E, A>) => Continue<R1 | R, E, A>;
+/**
+ * @tsplus pipeable fncts.query.Continue mapError
+ * @tsplus location "@fncts/query/internal/Continue"
+ */
+export declare function mapError<E, E1>(f: (e: E) => E1, __tsplusTrace?: string): <R, A>(self: Continue<R, E, A>) => Continue<R, E1, A>;
+/**
+ * @tsplus pipeable fncts.query.Continue mapErrorCause
+ * @tsplus location "@fncts/query/internal/Continue"
+ */
+export declare function mapErrorCause<E, E1>(f: (cause: Cause<E>) => Cause<E1>, __tsplusTrace?: string): <R, A>(self: Continue<R, E, A>) => Continue<R, E1, A>;
+/**
+ * @tsplus pipeable fncts.query.Continue zipWith
+ * @tsplus location "@fncts/query/internal/Continue"
+ */
+export declare function zipWith<A, R1, E1, B, C>(that: Continue<R1, E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string): <R, E>(self: Continue<R, E, A>) => Continue<R1 | R, E1 | E, C>;
+/**
+ * @tsplus pipeable fncts.query.Continue zipWithConcurrent
+ * @tsplus location "@fncts/query/internal/Continue"
+ */
+export declare function zipWithConcurrent<A, R1, E1, B, C>(that: Continue<R1, E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string): <R, E>(self: Continue<R, E, A>) => Continue<R1 | R, E1 | E, C>;
+/**
+ * @tsplus pipeable fncts.query.Continue zipWithBatched
+ * @tsplus location "@fncts/query/internal/Continue"
+ */
+export declare function zipWithBatched<A, R1, E1, B, C>(that: Continue<R1, E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string): <R, E>(self: Continue<R, E, A>) => Continue<R1 | R, E1 | E, C>;
+/**
+ * @tsplus static fncts.query.ContinueOps collectAllConcurrent
+ * @tsplus location "@fncts/query/internal/Continue"
+ */
+export declare function collectAllConcurrent<R, E, A>(continues: Iterable<Continue<R, E, A>>): Continue<R, E, Conc<A>>;
+/**
+ * @tsplus pipeable fncts.query.Continue contramapEnvironment
+ * @tsplus location "@fncts/query/internal/Continue"
+ */
+export declare function contramapEnvironment<R0, R>(f: Described<(_: Environment<R0>) => Environment<R>>, __tsplusTrace?: string): <E, A>(self: Continue<R, E, A>) => Continue<R0, E, A>;

package/internal/Parallel.d.ts

@@ -0,0 +1,56 @@
+import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import type { DataSource } from "@fncts/query/DataSource";
+import type { BlockedRequest } from "@fncts/query/internal/BlockedRequest";
+import { Sequential } from "@fncts/query/internal/Sequential";
+export declare const ParallelTypeId: unique symbol;
+export type ParallelTypeId = typeof ParallelTypeId;
+export declare const ParallelVariance: unique symbol;
+export type ParallelVariance = typeof ParallelVariance;
+/**
+ * @tsplus type fncts.query.Parallel
+ * @tsplus companion fncts.query.ParallelOps
+ */
+export declare class Parallel<R> {
+    readonly map: HashMap<DataSource<any, any>, Conc<BlockedRequest<any>>>;
+    readonly [ParallelTypeId]: ParallelTypeId;
+    [ParallelVariance]: {
+        readonly _R: (_: never) => R;
+    };
+    constructor(map: HashMap<DataSource<any, any>, Conc<BlockedRequest<any>>>);
+}
+/**
+ * @tsplus pipeable fncts.query.Parallel concat
+ * @tsplus location "@fncts/query/internal/Parallel"
+ */
+export declare function concat<R1>(that: Parallel<R1>): <R>(self: Parallel<R>) => Parallel<R1 | R>;
+/**
+ * @tsplus getter fncts.query.Parallel isEmpty
+ * @tsplus location "@fncts/query/internal/Parallel"
+ */
+export declare function isEmpty<R>(self: Parallel<R>): boolean;
+/**
+ * @tsplus getter fncts.query.Parallel keys
+ * @tsplus location "@fncts/query/internal/Parallel"
+ */
+export declare function keys<R>(self: Parallel<R>): Iterable<DataSource<R, any>>;
+/**
+ * @tsplus getter fncts.query.Parallel toIterable
+ * @tsplus location "@fncts/query/internal/Parallel"
+ */
+export declare function toIterable<R>(self: Parallel<R>): Iterable<readonly [DataSource<R, any>, Conc<BlockedRequest<any>>]>;
+/**
+ * @tsplus getter fncts.query.Parallel sequential
+ * @tsplus location "@fncts/query/internal/Parallel"
+ */
+export declare function sequential<R>(self: Parallel<R>): Sequential<R>;
+/**
+ * @tsplus static fncts.query.ParallelOps __call
+ * @tsplus location "@fncts/query/internal/Parallel"
+ */
+export declare function makeParallel<R, A>(dataSource: DataSource<R, A>, blockedRequest: BlockedRequest<A>): Parallel<R>;
+/**
+ * @tsplus static fncts.query.ParallelOps empty
+ * @tsplus location "@fncts/query/internal/Parallel"
+ */
+export declare const empty: Parallel<never>;

package/internal/Result.d.ts

@@ -0,0 +1,115 @@
+import { Continue } from "@fncts/query/internal/Continue";
+import { Cause } from "@fncts/base/data/Cause/definition";
+import { DataSourceAspect } from "@fncts/query/DataSourceAspect";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { Environment } from "@fncts/base/data/Environment/definition";
+import { Either } from "@fncts/base/data/Either/definition";
+import { Exit } from "@fncts/base/data/Exit/definition";
+import type { Described } from "@fncts/query/Described";
+import { BlockedRequests } from "@fncts/query/internal/BlockedRequests";
+export declare const ResultTypeId: unique symbol;
+export type ResultTypeId = typeof ResultTypeId;
+export declare const ResultVariance: unique symbol;
+export type ResultVariance = typeof ResultVariance;
+/**
+ * @tsplus type fncts.query.Result
+ * @tsplus companion fncts.query.ResultOps
+ */
+export declare abstract class Result<R, E, A> {
+    readonly [ResultTypeId]: ResultTypeId;
+    [ResultVariance]: {
+        readonly _R: (_: never) => R;
+        readonly _E: (_: never) => E;
+        readonly _A: (_: never) => A;
+    };
+}
+export declare const enum ResultTag {
+    Blocked = 0,
+    Done = 1,
+    Fail = 2
+}
+export declare class Blocked<R, E, A> extends Result<R, E, A> {
+    readonly blockedRequests: BlockedRequests<R>;
+    readonly cont: Continue<R, E, A>;
+    readonly _tag = ResultTag.Blocked;
+    constructor(blockedRequests: BlockedRequests<R>, cont: Continue<R, E, A>);
+}
+export declare class Done<A> extends Result<never, never, A> {
+    readonly value: A;
+    readonly _tag = ResultTag.Done;
+    constructor(value: A);
+}
+export declare class Fail<E> extends Result<never, E, never> {
+    readonly cause: Cause<E>;
+    readonly _tag = ResultTag.Fail;
+    constructor(cause: Cause<E>);
+}
+/**
+ * @tsplus static fncts.query.ResultOps blocked
+ * @tsplus location "@fncts/query/internal/Result"
+ */
+export declare function blocked<R, E, A>(blockedRequests: BlockedRequests<R>, cont: Continue<R, E, A>): Result<R, E, A>;
+/**
+ * @tsplus static fncts.query.ResultOps done
+ * @tsplus location "@fncts/query/internal/Result"
+ */
+export declare function done<A>(value: A): Result<never, never, A>;
+/**
+ * @tsplus static fncts.query.ResultOps fail
+ * @tsplus location "@fncts/query/internal/Result"
+ */
+export declare function fail<E>(cause: Cause<E>): Result<never, E, never>;
+/**
+ * @tsplus pipeable fncts.query.Result matchType
+ * @tsplus location "@fncts/query/internal/Result"
+ */
+export declare function matchType<R, E, A, B, C, D>(cases: {
+    Blocked: (blockedRequests: BlockedRequests<R>, cont: Continue<R, E, A>) => B;
+    Done: (value: A) => C;
+    Fail: (cause: Cause<E>) => D;
+}): (self: Result<R, E, A>) => B | C | D;
+/**
+ * @tsplus pipeable fncts.query.Result match
+ * @tsplus location "@fncts/query/internal/Result"
+ */
+export declare function match<E, A, B, C>(failure: (e: E) => B, success: (a: A) => C): <R>(self: Result<R, E, A>) => Result<R, never, B | C>;
+/**
+ * @tsplus pipeable fncts.query.Result map
+ * @tsplus location "@fncts/query/internal/Result"
+ */
+export declare function map<A, B>(f: (a: A) => B, __tsplusTrace?: string): <R, E>(self: Result<R, E, A>) => Result<R, E, B>;
+/**
+ * @tsplus pipeable fncts.query.Result mapDataSources
+ * @tsplus location "@fncts/query/internal/Result"
+ */
+export declare function mapDataSources<R1>(f: DataSourceAspect<R1>): <R, E, A>(self: Result<R, E, A>) => Result<R1 | R, E, A>;
+/**
+ * @tsplus pipeable fncts.query.Result mapError
+ * @tsplus location "@fncts/query/internal/Result"
+ */
+export declare function mapError<E, E1>(f: (e: E) => E1, __tsplusTrace?: string): <R, A>(self: Result<R, E, A>) => Result<R, E1, A>;
+/**
+ * @tsplus pipeable fncts.query.Result mapErrorCause
+ * @tsplus location "@fncts/query/internal/Result"
+ */
+export declare function mapErrorCause<E, E1>(f: (cause: Cause<E>) => Cause<E1>, __tsplusTrace?: string): <R, A>(self: Result<R, E, A>) => Result<R, E1, A>;
+/**
+ * @tsplus static fncts.query.ResultOps collectAllConcurrent
+ * @tsplus location "@fncts/query/internal/Result"
+ */
+export declare function collectAllConcurrent<R, E, A>(self: Iterable<Result<R, E, A>>, __tsplusTrace?: string): Result<R, E, Conc<A>>;
+/**
+ * @tsplus pipeable fncts.query.Result contramapEnvironment
+ * @tsplus location "@fncts/query/internal/Result"
+ */
+export declare function contramapEnvironment<R0, R>(f: Described<(_: Environment<R0>) => Environment<R>>, __tsplusTrace?: string): <E, A>(self: Result<R, E, A>) => Result<R0, E, A>;
+/**
+ * @tsplus static fncts.query.ResultOps fromEither
+ * @tsplus location "@fncts/query/internal/Result"
+ */
+export declare function fromEither<E, A>(either: Either<E, A>): Result<never, E, A>;
+/**
+ * @tsplus static fncts.query.ResultOps fromExit
+ * @tsplus location "@fncts/query/internal/Result"
+ */
+export declare function fromExit<E, A>(exit: Exit<E, A>): Result<never, E, A>;

package/internal/Sequential.d.ts

@@ -0,0 +1,40 @@
+import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import type { DataSource } from "@fncts/query/DataSource";
+import type { BlockedRequest } from "@fncts/query/internal/BlockedRequest";
+export declare const SequentialTypeId: unique symbol;
+export type SequentialTypeId = typeof SequentialTypeId;
+export declare const SequentialVariance: unique symbol;
+export type SequentialVariance = typeof SequentialVariance;
+/**
+ * @tsplus type fncts.query.Sequential
+ * @tsplus companion fncts.query.SequentialOps
+ */
+export declare class Sequential<R> {
+    readonly map: HashMap<DataSource<any, any>, Conc<Conc<BlockedRequest<any>>>>;
+    readonly [SequentialTypeId]: SequentialTypeId;
+    [SequentialVariance]: {
+        readonly _R: (_: never) => R;
+    };
+    constructor(map: HashMap<DataSource<any, any>, Conc<Conc<BlockedRequest<any>>>>);
+}
+/**
+ * @tsplus pipeable fncts.query.Sequential concat
+ * @tsplus location "@fncts/query/internal/Sequential"
+ */
+export declare function concat<R1>(that: Sequential<R1>): <R>(self: Sequential<R>) => Sequential<R1 | R>;
+/**
+ * @tsplus getter fncts.query.Sequential isEmpty
+ * @tsplus location "@fncts/query/internal/Sequential"
+ */
+export declare function isEmpty<R>(self: Sequential<R>): boolean;
+/**
+ * @tsplus getter fncts.query.Sequential keys
+ * @tsplus location "@fncts/query/internal/Sequential"
+ */
+export declare function keys<R>(self: Sequential<R>): Iterable<DataSource<R, any>>;
+/**
+ * @tsplus getter fncts.query.Sequential toIterable
+ * @tsplus location "@fncts/query/internal/Sequential"
+ */
+export declare function toIterable<R>(self: Sequential<R>): Iterable<readonly [DataSource<R, any>, Conc<Conc<BlockedRequest<any>>>]>;

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@fncts/query",
+  "version": "0.0.1",
+  "dependencies": {
+    "@fncts/base": "0.0.24",
+    "@fncts/io": "0.0.26",
+    "@fncts/typelevel": "0.0.15"
+  },
+  "exports": {
+    "./*": {
+      "import": "./_mjs/*.mjs",
+      "require": "./_cjs/*.cjs"
+    },
+    ".": {
+      "import": "./_mjs/index.mjs",
+      "require": "./_cjs/index.cjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/runTests.d.ts

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