@fncts/query 0.0.13 → 0.0.15

package/_src/CompletedRequestMap.ts

@@ -1,3 +1,5 @@
+import type { Request } from "@fncts/query/Request";
+
 export class CompletedRequestMap {
   constructor(private map: HashMap<any, Either<any, any>>) {}
 
@@ -14,14 +16,14 @@ export class CompletedRequestMap {
   }
 
   insertMaybe<E, A>(request: Request<E, A>, result: Either<E, Maybe<A>>): CompletedRequestMap {
-    return result.match(
-      (e) => this.insert(request, Left(e)),
-      (r) =>
+    return result.match({
+      Left: (e) => this.insert(request, Left(e)),
+      Right: (r) =>
         r.match(
           () => this,
           (a) => this.insert(request, Right(a)),
         ),
-    );
+    });
   }
 
   lookup<E, A>(request: Request<E, A>): Maybe<Either<E, A>> {

package/_src/DataSource/api.ts

@@ -1,5 +1,6 @@
 import type { Conc } from "@fncts/base/collection/immutable/Conc";
 import type { Described } from "@fncts/query/Described";
+import type { Request } from "@fncts/query/Request";
 
 import { IO } from "@fncts/io/IO";
 import { CompletedRequestMap } from "@fncts/query/CompletedRequestMap";

package/_src/DataSource.ts

@@ -1,4 +1,5 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./DataSource/*.ts }
-export * from "./DataSource/api.js";
 export * from "./DataSource/definition.js";
+export * from "./DataSource/api.js";
 // codegen:end

package/_src/Described.ts

@@ -8,7 +8,10 @@
  * @tsplus companion fncts.query.DescribedOps
  */
 export class Described<A> {
-  constructor(readonly value: A, readonly description: string) {}
+  constructor(
+    readonly value: A,
+    readonly description: string,
+  ) {}
 }
 
 /**

package/_src/Query/api/fromRequest.ts

@@ -1,3 +1,5 @@
+import type { Request } from "@fncts/query/Request";
+
 import { BlockedRequest } from "@fncts/query/internal/BlockedRequest";
 import { BlockedRequests } from "@fncts/query/internal/BlockedRequests";
 
@@ -17,22 +19,22 @@ export function fromRequest<R, A extends Request<any, any>>(
         if (cachingEnabled) {
           return Query.currentCache.get.flatMap((cache) =>
             cache.lookup(request).flatMap((r) =>
-              r.match(
-                (ref) =>
+              r.match({
+                Left: (ref) =>
                   IO.succeedNow(
                     Result.blocked(
                       BlockedRequests.single(dataSource, BlockedRequest.make(request, ref)),
                       Continue(request, dataSource, ref),
                     ),
                   ),
-                (ref) =>
+                Right: (ref) =>
                   ref.get.map((r) =>
                     r.match(
                       () => Result.blocked(BlockedRequests.empty(), Continue(request, dataSource, ref)),
                       (b) => Result.fromEither(b),
                     ),
                   ),
-              ),
+              }),
             ),
           );
         } else {

package/_src/Query/api/matchQuery.ts

@@ -7,6 +7,9 @@ export function matchQuery<E, A, R1, E1, B, R2, E2, C>(
   __tsplusTrace?: string,
 ) {
   return <R>(self: Query<R, E, A>): Query<R | R1 | R2, E1 | E2, B | C> => {
-    return self.matchCauseQuery((cause) => cause.failureOrCause.match(failure, Query.failCauseNow), success);
+    return self.matchCauseQuery(
+      (cause) => cause.failureOrCause.match({ Left: failure, Right: Query.failCauseNow }),
+      success,
+    );
   };
 }

package/_src/Query.ts

@@ -1,35 +1,37 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./Query/*.ts }
-export * from "./Query/api.js";
 export * from "./Query/definition.js";
+export * from "./Query/api.js";
 // codegen:end
 
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./Query/api/*.ts }
-export * from "./Query/api/bimap.js";
-export * from "./Query/api/catchAllCause.js";
-export * from "./Query/api/collectAll.js";
-export * from "./Query/api/collectAllBatched.js";
-export * from "./Query/api/collectAllConcurrent.js";
-export * from "./Query/api/defer.js";
-export * from "./Query/api/ensuring.js";
-export * from "./Query/api/environment.js";
-export * from "./Query/api/flatMap.js";
-export * from "./Query/api/foreach.js";
-export * from "./Query/api/foreachBatched.js";
-export * from "./Query/api/foreachConcurrent.js";
-export * from "./Query/api/fromRequest.js";
-export * from "./Query/api/map.js";
-export * from "./Query/api/mapDataSources.js";
-export * from "./Query/api/mapError.js";
-export * from "./Query/api/mapErrorCause.js";
-export * from "./Query/api/mapIO.js";
-export * from "./Query/api/match.js";
-export * from "./Query/api/matchCauseQuery.js";
-export * from "./Query/api/matchQuery.js";
-export * from "./Query/api/orHalt.js";
-export * from "./Query/api/race.js";
-export * from "./Query/api/run.js";
-export * from "./Query/api/timeout.js";
-export * from "./Query/api/zipWith.js";
-export * from "./Query/api/zipWithBatched.js";
 export * from "./Query/api/zipWithConcurrent.js";
+export * from "./Query/api/zipWithBatched.js";
+export * from "./Query/api/zipWith.js";
+export * from "./Query/api/timeout.js";
+export * from "./Query/api/run.js";
+export * from "./Query/api/race.js";
+export * from "./Query/api/orHalt.js";
+export * from "./Query/api/matchQuery.js";
+export * from "./Query/api/matchCauseQuery.js";
+export * from "./Query/api/match.js";
+export * from "./Query/api/mapIO.js";
+export * from "./Query/api/mapErrorCause.js";
+export * from "./Query/api/mapError.js";
+export * from "./Query/api/mapDataSources.js";
+export * from "./Query/api/map.js";
+export * from "./Query/api/fromRequest.js";
+export * from "./Query/api/foreachConcurrent.js";
+export * from "./Query/api/foreachBatched.js";
+export * from "./Query/api/foreach.js";
+export * from "./Query/api/flatMap.js";
+export * from "./Query/api/environment.js";
+export * from "./Query/api/ensuring.js";
+export * from "./Query/api/defer.js";
+export * from "./Query/api/collectAllConcurrent.js";
+export * from "./Query/api/collectAllBatched.js";
+export * from "./Query/api/collectAll.js";
+export * from "./Query/api/catchAllCause.js";
+export * from "./Query/api/bimap.js";
 // codegen:end

package/_src/QueryFailure.ts

@@ -1,7 +1,12 @@
+import type { Request } from "@fncts/query/Request";
+
 import { show } from "@fncts/base/data/Showable";
 
 export class QueryFailure extends Error {
-  constructor(readonly dataSource: DataSource<any, any>, request: Request<any, any>) {
+  constructor(
+    readonly dataSource: DataSource<any, any>,
+    request: Request<any, any>,
+  ) {
     super(`Data source ${dataSource.identifier} did not complete request ${show(request)}.`);
   }
 }

package/_src/index.ts

@@ -1,11 +1,12 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: type-barrel, include: ./*.ts }
-export type {} from "./Cache.js";
-export type {} from "./CompletedRequestMap.js";
-export type {} from "./DataSource.js";
-export type {} from "./DataSourceAspect.js";
-export type {} from "./Described.js";
 export type {} from "./global.js";
-export type {} from "./Query.js";
-export type {} from "./QueryFailure.js";
 export type {} from "./Request.js";
+export type {} from "./QueryFailure.js";
+export type {} from "./Query.js";
+export type {} from "./Described.js";
+export type {} from "./DataSourceAspect.js";
+export type {} from "./DataSource.js";
+export type {} from "./CompletedRequestMap.js";
+export type {} from "./Cache.js";
 // codegen:end

package/_src/internal/BlockedRequest.ts

@@ -1,3 +1,5 @@
+import type { Request } from "@fncts/query/Request";
+
 export const BlockedRequestTypeId = Symbol.for("fncts.query.BlockedRequest");
 export type BlockedRequestTypeId = typeof BlockedRequestTypeId;
 

package/_src/internal/BlockedRequests.ts

@@ -35,21 +35,30 @@ export class Empty extends BlockedRequests<never> {
 
 export class Single<R, A> extends BlockedRequests<R> {
   readonly _tag = BlockedRequestsTag.Single;
-  constructor(readonly dataSource: DataSource<R, A>, readonly blockedRequest: BlockedRequest<A>) {
+  constructor(
+    readonly dataSource: DataSource<R, A>,
+    readonly blockedRequest: BlockedRequest<A>,
+  ) {
     super();
   }
 }
 
 export class Then<R> extends BlockedRequests<R> {
   readonly _tag = BlockedRequestsTag.Then;
-  constructor(readonly left: BlockedRequests<R>, readonly right: BlockedRequests<R>) {
+  constructor(
+    readonly left: BlockedRequests<R>,
+    readonly right: BlockedRequests<R>,
+  ) {
     super();
   }
 }
 
 export class Both<R> extends BlockedRequests<R> {
   readonly _tag = BlockedRequestsTag.Both;
-  constructor(readonly left: BlockedRequests<R>, readonly right: BlockedRequests<R>) {
+  constructor(
+    readonly left: BlockedRequests<R>,
+    readonly right: BlockedRequests<R>,
+  ) {
     super();
   }
 }
@@ -121,8 +130,8 @@ function foldLoop<R, Z>(
 ): List<Z> {
   if (inp.isEmpty()) {
     return out.foldLeft(List.empty(), (acc, r) =>
-      r.match(
-        (c) => {
+      r.match({
+        Left: (c) => {
           const left            = acc.unsafeHead;
           const right           = acc.unsafeTail.unsafeHead;
           const blockedRequests = acc.unsafeTail.unsafeTail;
@@ -135,8 +144,8 @@ function foldLoop<R, Z>(
             }
           }
         },
-        (z) => Cons(z, acc),
-      ),
+        Right: (z) => Cons(z, acc),
+      }),
     );
   } else {
     const head = inp.head;

package/_src/internal/Continue.ts

@@ -1,4 +1,5 @@
 import type { Described } from "@fncts/query/Described";
+import type { Request } from "@fncts/query/Request";
 
 import { QueryFailure } from "../QueryFailure.js";
 

package/_src/internal/Result.ts

@@ -29,7 +29,10 @@ export const enum ResultTag {
 
 export class Blocked<R, E, A> extends Result<R, E, A> {
   readonly _tag = ResultTag.Blocked;
-  constructor(readonly blockedRequests: BlockedRequests<R>, readonly cont: Continue<R, E, A>) {
+  constructor(
+    readonly blockedRequests: BlockedRequests<R>,
+    readonly cont: Continue<R, E, A>,
+  ) {
     super();
   }
 }
@@ -107,7 +110,7 @@ export function match<E, A, B, C>(failure: (e: E) => B, success: (a: A) => C) {
     return self.matchType({
       Blocked: (br, c) => Result.blocked(br, c.match(failure, success)),
       Done: (a) => Result.done(success(a)),
-      Fail: (e) => e.failureOrCause.match((e) => Result.done(failure(e)), Result.fail),
+      Fail: (e) => e.failureOrCause.match({ Left: (e) => Result.done(failure(e)), Right: Result.fail }),
     });
   };
 }
@@ -228,10 +231,10 @@ export function contramapEnvironment<R0, R>(
  * @tsplus static fncts.query.ResultOps fromEither
  */
 export function fromEither<E, A>(either: Either<E, A>): Result<never, E, A> {
-  return either.match(
-    (e) => Result.fail(Cause.fail(e)),
-    (a) => Result.done(a),
-  );
+  return either.match({
+    Left: (e) => Result.fail(Cause.fail(e)),
+    Right: (a) => Result.done(a),
+  });
 }
 
 /**

package/index.d.ts

@@ -1,9 +1,9 @@
-export type {} from "./Cache.js";
-export type {} from "./CompletedRequestMap.js";
-export type {} from "./DataSource.js";
-export type {} from "./DataSourceAspect.js";
-export type {} from "./Described.js";
 export type {} from "./global.js";
-export type {} from "./Query.js";
-export type {} from "./QueryFailure.js";
 export type {} from "./Request.js";
+export type {} from "./QueryFailure.js";
+export type {} from "./Query.js";
+export type {} from "./Described.js";
+export type {} from "./DataSourceAspect.js";
+export type {} from "./DataSource.js";
+export type {} from "./CompletedRequestMap.js";
+export type {} from "./Cache.js";

package/internal/BlockedRequest.d.ts

@@ -1,7 +1,7 @@
-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";
+import type { Request } from "@fncts/query/Request";
 export declare const BlockedRequestTypeId: unique symbol;
 export type BlockedRequestTypeId = typeof BlockedRequestTypeId;
 /**

package/internal/BlockedRequests.d.ts

@@ -92,7 +92,7 @@ export declare class MapDataSources<R> extends BlockedRequestsFolder<R, BlockedR
  * @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 function mapDataSources<R1>(f: DataSourceAspect<R1>): <R>(self: BlockedRequests<R>) => BlockedRequests<R | R1>;
 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>>);

package/internal/Continue.d.ts

@@ -1,6 +1,5 @@
 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";
@@ -10,6 +9,7 @@ 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";
+import type { Request } from "@fncts/query/Request";
 export declare const ContinueTypeId: unique symbol;
 export type ContinueTypeId = typeof ContinueTypeId;
 export declare const ContinueVariance: unique symbol;
@@ -75,7 +75,7 @@ export declare function matchType<R, E, A, B, C>(cases: {
  * @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>;
+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<R | R1, E | E1, B>;
 /**
  * @tsplus pipeable fncts.query.Continue match
  * @tsplus location "@fncts/query/internal/Continue"
@@ -85,7 +85,7 @@ export declare function match<E, A, B, C>(failure: (e: E) => B, success: (a: A)
  * @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>;
+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<R | R1 | R2, E1 | E2, B | C>;
 /**
  * @tsplus pipeable fncts.query.Continue map
  * @tsplus location "@fncts/query/internal/Continue"
@@ -95,7 +95,7 @@ export declare function map<A, B>(f: (a: A) => B, __tsplusTrace?: string): <R, E
  * @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>;
+export declare function mapDataSources<R1>(f: DataSourceAspect<R1>, __tsplusTrace?: string): <R, E, A>(self: Continue<R, E, A>) => Continue<R | R1, E, A>;
 /**
  * @tsplus pipeable fncts.query.Continue mapError
  * @tsplus location "@fncts/query/internal/Continue"
@@ -110,17 +110,17 @@ export declare function mapErrorCause<E, E1>(f: (cause: Cause<E>) => Cause<E1>,
  * @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>;
+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<R | R1, E | E1, 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>;
+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<R | R1, E | E1, 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>;
+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<R | R1, E | E1, C>;
 /**
  * @tsplus static fncts.query.ContinueOps collectAllConcurrent
  * @tsplus location "@fncts/query/internal/Continue"

package/internal/Parallel.d.ts

@@ -23,7 +23,7 @@ export declare class Parallel<R> {
  * @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>;
+export declare function concat<R1>(that: Parallel<R1>): <R>(self: Parallel<R>) => Parallel<R | R1>;
 /**
  * @tsplus getter fncts.query.Parallel isEmpty
  * @tsplus location "@fncts/query/internal/Parallel"

package/internal/Result.d.ts

@@ -82,7 +82,7 @@ export declare function map<A, B>(f: (a: A) => B, __tsplusTrace?: string): <R, E
  * @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>;
+export declare function mapDataSources<R1>(f: DataSourceAspect<R1>): <R, E, A>(self: Result<R, E, A>) => Result<R | R1, E, A>;
 /**
  * @tsplus pipeable fncts.query.Result mapError
  * @tsplus location "@fncts/query/internal/Result"

package/internal/Sequential.d.ts

@@ -22,7 +22,7 @@ export declare class Sequential<R> {
  * @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>;
+export declare function concat<R1>(that: Sequential<R1>): <R>(self: Sequential<R>) => Sequential<R | R1>;
 /**
  * @tsplus getter fncts.query.Sequential isEmpty
  * @tsplus location "@fncts/query/internal/Sequential"

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@fncts/query",
-  "version": "0.0.13",
+  "version": "0.0.15",
   "dependencies": {
-    "@fncts/base": "0.0.31",
-    "@fncts/io": "0.0.38",
-    "@fncts/typelevel": "0.0.15"
+    "@fncts/base": "0.0.33",
+    "@fncts/io": "0.0.40",
+    "@fncts/typelevel": "0.0.16"
   },
   "exports": {
     "./*": {