@fncts/query 0.0.1

package/_src/Query/api/catchAllCause.ts

@@ -0,0 +1,17 @@
+/**
+ * @tsplus pipeable fncts.query.Query catchAllCause
+ */
+export function catchAllCause<E, R1, E1, B>(f: (cause: Cause<E>) => Query<R1, E1, B>, __tsplusTrace?: string) {
+  return <R, A>(self: Query<R, E, A>): Query<R | R1, E1, A | B> => {
+    return self.matchCauseQuery(f, Query.succeedNow);
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.query.Query catchAll
+ */
+export function catchAll<E, R1, E1, B>(f: (e: E) => Query<R1, E1, B>, __tsplusTrace?: string) {
+  return <R, A>(self: Query<R, E, A>): Query<R | R1, E1, A | B> => {
+    return self.matchQuery(f, Query.succeedNow);
+  };
+}

package/_src/Query/api/collectAll.ts

@@ -0,0 +1,6 @@
+/**
+ * @tsplus static fncts.query.QueryOps collectAll
+ */
+export function collectAll<R, E, A>(self: Iterable<Query<R, E, A>>, __tsplusTrace?: string): Query<R, E, Conc<A>> {
+  return Query.foreach(self, Function.identity);
+}

package/_src/Query/api/collectAllBatched.ts

@@ -0,0 +1,9 @@
+/**
+ * @tsplus static fncts.query.QueryOps collectAllBatched
+ */
+export function collectAllBatched<R, E, A>(
+  self: Iterable<Query<R, E, A>>,
+  __tsplusTrace?: string,
+): Query<R, E, Conc<A>> {
+  return Query.foreachBatched(self, Function.identity);
+}

package/_src/Query/api/collectAllConcurrent.ts

@@ -0,0 +1,6 @@
+/**
+ * @tsplus static fncts.query.QueryOps collectAllConcurrent
+ */
+export function collectAllConcurrent<R, E, A>(self: Iterable<Query<R, E, A>>, __tsplusTrace?: string): Query<R, E, Conc<A>> {
+  return Query.foreachConcurrent(self, Function.identity);
+}

package/_src/Query/api/defer.ts

@@ -0,0 +1,6 @@
+/**
+ * @tsplus static fncts.query.QueryOps defer
+ */
+export function defer<R, E, A>(query: Lazy<Query<R, E, A>>): Query<R, E, A> {
+  return Query.unit.flatMap(() => query())
+}

package/_src/Query/api/ensuring.ts

@@ -0,0 +1,19 @@
+/**
+ * @tsplus pipeable fncts.query.Query ensuring
+ */
+export function ensuring<R1>(finalizer: Query<R1, never, any>, __tsplusTrace?: string) {
+  return <R, E, A>(self: Query<R, E, A>): Query<R | R1, E, A> => {
+    return self.matchCauseQuery(
+      (cause1) =>
+        finalizer.matchCauseQuery(
+          (cause2) => Query.failCauseNow(Cause.then(cause1, cause2)),
+          () => Query.failCauseNow(cause1),
+        ),
+      (value) =>
+        finalizer.matchCauseQuery(
+          (cause) => Query.failCauseNow(cause),
+          () => Query.succeedNow(value),
+        ),
+    );
+  };
+}

package/_src/Query/api/environment.ts

@@ -0,0 +1,82 @@
+import { Described } from "@fncts/query/Described";
+
+/**
+ * @tsplus static fncts.query.QueryOps environment
+ */
+export function environment<R>(): Query<R, never, Environment<R>> {
+  return Query.fromIO(IO.environment<R>());
+}
+
+/**
+ * @tsplus static fncts.query.QueryOps environmentWith
+ */
+export function environmentWith<R, A>(f: (environment: Environment<R>) => A): Query<R, never, A> {
+  return Query.environment<R>().map(f);
+}
+
+/**
+ * @tsplus static fncts.query.QueryOps environmentWithQuery
+ */
+export function environmentWithQuery<R0, R, E, A>(
+  f: (environment: Environment<R0>) => Query<R, E, A>,
+): Query<R0 | R, E, A> {
+  return Query.environment<R0>().flatMap(f);
+}
+
+/**
+ * @tsplus static fncts.query.QueryOps environmentWithIO
+ */
+export function environmentWithIO<R0, R, E, A>(f: (environment: Environment<R0>) => IO<R, E, A>): Query<R0 | R, E, A> {
+  return Query.environment<R0>().mapIO(f);
+}
+
+/**
+ * @tsplus pipeable fncts.query.Query contramapEnvironment
+ */
+export function contramapEnvironment<R0, R>(
+  f: Described<(_: Environment<R0>) => Environment<R>>,
+  __tsplusTrace?: string,
+) {
+  return <E, A>(self: Query<R, E, A>): Query<R0, E, A> => {
+    return new Query(self.step.map((result) => result.contramapEnvironment(f)).contramapEnvironment((r) => f.value(r)));
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.query.Query provideEnvironment
+ */
+export function provideEnvironment<R>(environment: Described<Environment<R>>, __tsplusTrace?: string) {
+  return <E, A>(self: Query<R, E, A>): Query<never, E, A> => {
+    return self.contramapEnvironment(new Described(() => environment.value, `() => ${environment.description}`));
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.query.Query provideSomeEnvironment
+ */
+export function provideSomeEnvironment<R0>(environment: Described<Environment<R0>>, __tsplusTrace?: string) {
+  return <R, E, A>(self: Query<R, E, A>): Query<Exclude<R, R0>, E, A> => {
+    return self.contramapEnvironment(
+      new Described((r) => r.union(environment.value), "Environment<R> => Environment<R | R0>"),
+    );
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.query.Query provideLayer
+ */
+export function provideLayer<RIn, E1, ROut>(layer: Lazy<Described<Layer<RIn, E1, ROut>>>, __tsplusTrace?: string) {
+  return <R, E, A>(self: Query<R, E, A>): Query<RIn | Exclude<R, ROut>, E | E1, A> => {
+    return new Query(
+      IO.scoped(() => {
+        const layer0 = layer();
+        return layer0.value.build.result.flatMap((exit) =>
+          exit.match(
+            (cause) => IO.succeedNow(Result.fail(cause)),
+            (r) => self.provideSomeEnvironment(new Described(r, layer0.description)).step,
+          ),
+        );
+      }) as IO<RIn | Exclude<R, ROut>, never, Result<Exclude<R, ROut>, E | E1, A>>,
+    );
+  };
+}

package/_src/Query/api/flatMap.ts

@@ -0,0 +1,26 @@
+/**
+ * @tsplus pipeable fncts.query.Query flatMap
+ */
+export function flatMap<A, R1, E1, B>(f: (a: A) => Query<R1, E1, B>, __tsplusTrace?: string) {
+  return <R, E>(self: Query<R, E, A>): Query<R | R1, E | E1, B> => {
+    return new Query(
+      self.step.flatMap((result) =>
+        result.matchType({
+          Blocked: (br, c) => IO.succeedNow(Result.blocked(br, c.mapQuery(f))),
+          Done: (a) => f(a).step,
+          Fail: (e) => IO.succeedNow(Result.fail(e)),
+        }),
+      ),
+    );
+  };
+}
+
+/**
+ * @tsplus getter fncts.query.Query flatten
+ */
+export function flatten<R, E, R1, E1, A>(
+  self: Query<R, E, Query<R1, E1, A>>,
+  __tsplusTrace?: string,
+): Query<R | R1, E | E1, A> {
+  return self.flatMap(Function.identity);
+}

package/_src/Query/api/foreach.ts

@@ -0,0 +1,17 @@
+/**
+ * @tsplus static fncts.query.QueryOps foreach
+ */
+export function foreach<A, R, E, B>(
+  as: Iterable<A>,
+  f: (a: A) => Query<R, E, B>,
+  __tsplusTrace?: string,
+): Query<R, E, Conc<B>> {
+  const out: Array<B>            = [];
+  let builder: Query<R, E, void> = Query.unit;
+  for (const a of as) {
+    builder = builder.zipWith(f(a), (_, b) => {
+      out.push(b);
+    });
+  }
+  return builder.map(() => Conc.fromArray(out));
+}

package/_src/Query/api/foreachBatched.ts

@@ -0,0 +1,17 @@
+/**
+ * @tsplus static fncts.query.QueryOps foreachBatched
+ */
+export function foreachBatched<A, R, E, B>(
+  as: Iterable<A>,
+  f: (a: A) => Query<R, E, B>,
+  __tsplusTrace?: string,
+): Query<R, E, Conc<B>> {
+  const out: Array<B>            = [];
+  let builder: Query<R, E, void> = Query.unit;
+  for (const a of as) {
+    builder = builder.zipWithBatched(f(a), (_, b) => {
+      out.push(b);
+    });
+  }
+  return builder.map(() => Conc.fromArray(out));
+}

package/_src/Query/api/foreachConcurrent.ts

@@ -0,0 +1,10 @@
+/**
+ * @tsplus static fncts.query.QueryOps foreachConcurrent
+ */
+export function foreachConcurrent<A, R, E, B>(
+  self: Iterable<A>,
+  f: (a: A) => Query<R, E, B>,
+  __tsplusTrace?: string,
+): Query<R, E, Conc<B>> {
+  return new Query(IO.foreachConcurrent(self, (a) => f(a).step).map((results) => Result.collectAllConcurrent(results)));
+}

package/_src/Query/api/fromRequest.ts

@@ -0,0 +1,49 @@
+import { BlockedRequest } from "@fncts/query/internal/BlockedRequest";
+import { BlockedRequests } from "@fncts/query/internal/BlockedRequests";
+
+/**
+ * @tsplus static fncts.query.QueryOps fromRequest
+ */
+export 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>> {
+  return new Query(
+    IO.defer(() => {
+      const request    = request0();
+      const dataSource = dataSource0();
+      return Query.cachingEnabled.get.flatMap((cachingEnabled) => {
+        if (cachingEnabled) {
+          return Query.currentCache.get.flatMap((cache) =>
+            cache.lookup(request).flatMap((r) =>
+              r.match(
+                (ref) =>
+                  IO.succeedNow(
+                    Result.blocked(
+                      BlockedRequests.single(dataSource, BlockedRequest.make(request, ref)),
+                      Continue(request, dataSource, ref),
+                    ),
+                  ),
+                (ref) =>
+                  ref.get.map((r) =>
+                    r.match(
+                      () => Result.blocked(BlockedRequests.empty(), Continue(request, dataSource, ref)),
+                      (b) => Result.fromEither(b),
+                    ),
+                  ),
+              ),
+            ),
+          );
+        } else {
+          return Ref.make(Nothing<Either<Request.ErrorOf<A>, Request.ValueOf<A>>>()).map((ref) =>
+            Result.blocked(
+              BlockedRequests.single(dataSource, BlockedRequest.make(request, ref)),
+              Continue(request, dataSource, ref),
+            ),
+          );
+        }
+      });
+    }),
+  );
+}

package/_src/Query/api/map.ts

@@ -0,0 +1,8 @@
+/**
+ * @tsplus pipeable fncts.query.Query map
+ */
+export function map<A, B>(f: (a: A) => B) {
+  return <R, E>(self: Query<R, E, A>): Query<R, E, B> => {
+    return new Query(self.step.map((result) => result.map(f)));
+  };
+}

package/_src/Query/api/mapDataSources.ts

@@ -0,0 +1,8 @@
+/**
+ * @tsplus pipeable fncts.query.Query mapDataSources
+ */
+export function mapDataSources<R1>(f: DataSourceAspect<R1>) {
+  return <R, E, A>(self: Query<R, E, A>): Query<R | R1, E, A> => {
+    return new Query(self.step.map((result) => result.mapDataSources(f)))
+  }
+}

package/_src/Query/api/mapError.ts

@@ -0,0 +1,8 @@
+/**
+ * @tsplus pipeable fncts.query.Query mapError
+ */
+export function mapError<E, E1>(f: (e: E) => E1, __tsplusTrace?: string) {
+  return <R, A>(self: Query<R, E, A>): Query<R, E1, A> => {
+    return self.bimap(f, Function.identity);
+  };
+}

package/_src/Query/api/mapErrorCause.ts

@@ -0,0 +1,8 @@
+/**
+ * @tsplus pipeable fncts.query.Query mapErrorCause
+ */
+export function mapErrorCause<E, E1>(f: (cause: Cause<E>) => Cause<E1>, __tsplusTrace?: string) {
+  return <R, A>(self: Query<R, E, A>): Query<R, E1, A> => {
+    return self.matchCauseQuery((c) => Query.failCauseNow(f(c)), Query.succeedNow);
+  };
+}

package/_src/Query/api/mapIO.ts

@@ -0,0 +1,8 @@
+/**
+ * @tsplus pipeable fncts.query.Query mapIO
+ */
+export function mapIO<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>) {
+  return <R, E>(self: Query<R, E, A>): Query<R | R1, E | E1, B> => {
+    return self.flatMap(a => Query.fromIO(f(a)))
+  }
+}

package/_src/Query/api/match.ts

@@ -0,0 +1,11 @@
+/**
+ * @tsplus pipeable fncts.query.Query match
+ */
+export function match<E, A, B, C>(failure: (e: E) => B, success: (a: A) => C) {
+  return <R>(self: Query<R, E, A>): Query<R, never, B | C> => {
+    return self.matchQuery(
+      (e) => Query.succeedNow(failure(e)),
+      (a) => Query.succeedNow(success(a)),
+    );
+  };
+}

package/_src/Query/api/matchCauseQuery.ts

@@ -0,0 +1,21 @@
+/**
+ * @tsplus pipeable fncts.query.Query matchCauseQuery
+ */
+export 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>,
+) {
+  return <R>(self: Query<R, E, A>): Query<R | R1 | R2, E1 | E2, B | C> => {
+    return new Query(
+      self.step.matchCauseIO(
+        (cause) => failure(cause).step,
+        (result) =>
+          result.matchType({
+            Blocked: (br, c) => IO.succeedNow(Result.blocked(br, c.matchCauseQuery(failure, success))),
+            Done: (value) => success(value).step,
+            Fail: (cause) => failure(cause).step,
+          }),
+      ),
+    );
+  };
+}

package/_src/Query/api/matchQuery.ts

@@ -0,0 +1,12 @@
+/**
+ * @tsplus pipeable fncts.query.Query matchQuery
+ */
+export 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,
+) {
+  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);
+  };
+}

package/_src/Query/api/orHalt.ts

@@ -0,0 +1,15 @@
+/**
+ * @tsplus pipeable fncts.query.Query orHaltWith
+ */
+export function orHaltWith<E>(f: (e: E) => unknown, __tsplusTrace?: string) {
+  return <R, A>(self: Query<R, E, A>): Query<R, never, A> => {
+    return self.matchQuery((e) => Query.haltNow(f(e)), Query.succeedNow);
+  };
+}
+
+/**
+ * @tsplus getter fncts.query.Query orHalt
+ */
+export function orHalt<R, E, A>(self: Query<R, E, A>, __tsplusTrace?: string): Query<R, never, A> {
+  return self.orHaltWith(Function.identity);
+}

package/_src/Query/api/race.ts

@@ -0,0 +1,34 @@
+/**
+ * @tsplus pipeable fncts.query.Query race
+ */
+export function race<R1, E1, A1>(that: Lazy<Query<R1, E1, A1>>, __tsplusTrace?: string) {
+  return <R, E, A>(self: Query<R, E, A>): Query<R | R1, E | E1, A | A1> => {
+    function race(
+      query: Query<R | R1, E | E1, A | A1>,
+      fiber: Fiber<never, Result<R | R1, E | E1, A | A1>>,
+    ): Query<R | R1, E | E1, A | A1> {
+      return new Query(query.step.raceWith(fiber.join, coordinate, coordinate));
+    }
+    function coordinate(
+      exit: Exit<never, Result<R | R1, E | E1, A | A1>>,
+      fiber: Fiber<never, Result<R | R1, E | E1, A | A1>>,
+    ): IO<R | R1, never, Result<R | R1, E | E1, A | A1>> {
+      return exit.match(
+        (cause) => fiber.join.map((result) => result.mapErrorCause((c0) => Cause.both(c0, cause))),
+        (result) =>
+          result.matchType({
+            Blocked: (blockedRequests, cont) =>
+              cont.matchType({
+                Effect: (query) => IO.succeedNow(Result.blocked(blockedRequests, Continue.effect(race(query, fiber)))),
+                Get: (io) =>
+                  IO.succeedNow(Result.blocked(blockedRequests, Continue.effect(race(Query.fromIO(io), fiber)))),
+              }),
+            Done: (value) => fiber.interrupt > IO.succeed(Result.done(value)),
+            Fail: (cause) => fiber.join.map((result) => result.mapErrorCause((c0) => Cause.both(c0, cause))),
+          }),
+      );
+    }
+
+    return Query.defer(new Query(self.step.raceWith(that().step, coordinate, coordinate)));
+  };
+}

package/_src/Query/api/run.ts

@@ -0,0 +1,40 @@
+/**
+ * @tsplus pipeable fncts.query.Query runCache
+ */
+export function runCache(cache: Cache, __tsplusTrace?: string) {
+  return <R, E, A>(self: Query<R, E, A>): IO<R, E, A> => {
+    return IO.defer(
+      Query.currentCache.locally(cache)(
+        self.step.flatMap((result) =>
+          result.matchType({
+            Blocked: (br, c) =>
+              c.matchType({
+                Effect: (c) => br.run > c.run,
+                Get: (io) => br.run > io,
+              }),
+            Done: (a) => IO.succeedNow(a),
+            Fail: (cause) => IO.failCauseNow(cause),
+          }),
+        ),
+      ),
+    );
+  };
+}
+
+/**
+ * @tsplus getter fncts.query.Query runLog
+ */
+export function runLog<R, E, A>(self: Query<R, E, A>, __tsplusTrace?: string): IO<R, E, readonly [Cache, A]> {
+  return Do((Δ) => {
+    const cache = Δ(Cache.empty());
+    const a     = Δ(self.runCache(cache));
+    return [cache, a] as const;
+  });
+}
+
+/**
+ * @tsplus getter fncts.query.Query run
+ */
+export function run<R, E, A>(self: Query<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
+  return self.runLog.map(([, a]) => a);
+}

package/_src/Query/api/timeout.ts

@@ -0,0 +1,58 @@
+/**
+ * @tsplus pipeable fncts.query.Query timeoutTo
+ */
+export function timeoutTo<A, B, B1>(duration: Lazy<Duration>, b: Lazy<B>, f: (a: A) => B1, __tsplusTrace?: string) {
+  return <R, E>(self: Query<R, E, A>): Query<R, E, B | B1> => {
+    function race(query: Query<R, E, B | B1>, fiber: Fiber<never, B | B1>): Query<R, E, B | B1> {
+      return new Query(
+        query.step.raceWith(
+          fiber.join,
+          (leftExit, rightFiber) =>
+            leftExit.match(
+              (cause) => rightFiber.interrupt > IO.succeedNow(Result.fail(cause)),
+              (result) =>
+                result.matchType({
+                  Blocked: (br, c) =>
+                    c.matchType({
+                      Effect: (query) => IO.succeedNow(Result.blocked(br, Continue.effect(race(query, fiber)))),
+                      Get: (io) => IO.succeedNow(Result.blocked(br, Continue.effect(race(Query.fromIO(io), fiber)))),
+                    }),
+                  Done: (value) => rightFiber.interrupt > IO.succeedNow(Result.done(value)),
+                  Fail: (cause) => rightFiber.interrupt > IO.succeed(Result.fail(cause)),
+                }),
+            ),
+          (rightExit, leftFiber) => leftFiber.interrupt > IO.succeedNow(Result.fromExit(rightExit)),
+        ),
+      );
+    }
+
+    return Query.fromIO(IO.sleep(duration).interruptible.as(b).fork).flatMap((fiber) => race(self.map(f), fiber));
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.query.Query timeout
+ */
+export function timeout(duration: Lazy<Duration>, __tsplusTrace?: string) {
+  return <R, E, A>(self: Query<R, E, A>): Query<R, E, Maybe<A>> => {
+    return self.timeoutTo(duration, Nothing(), (a) => Just(a));
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.query.Query timeoutFail
+ */
+export function timeoutFail<E1>(duration: Lazy<Duration>, e: Lazy<E1>, __tsplusTrace?: string) {
+  return <R, E, A>(self: Query<R, E, A>): Query<R, E | E1, A> => {
+    return self.timeoutTo(duration, Query.fail(e), Query.succeedNow).flatten;
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.query.Query timeoutFailCause
+ */
+export function timeoutFailCause<E1>(duration: Lazy<Duration>, e: Lazy<Cause<E1>>, __tsplusTrace?: string) {
+  return <R, E, A>(self: Query<R, E, A>): Query<R, E | E1, A> => {
+    return self.timeoutTo(duration, Query.failCause(e), Query.succeedNow).flatten;
+  };
+}

package/_src/Query/api/zipWith.ts

@@ -0,0 +1,44 @@
+import { BlockedRequests } from "@fncts/query/internal/BlockedRequests";
+
+/**
+ * @tsplus pipeable fncts.query.Query zipWith
+ */
+export function zipWith<A, R1, E1, B, C>(that: Lazy<Query<R1, E1, B>>, f: (a: A, b: B) => C, __tsplusTrace?: string) {
+  return <R, E>(self: Query<R, E, A>): Query<R | R1, E | E1, C> => {
+    return new Query(
+      self.step.flatMap((result) =>
+        result.matchType({
+          Blocked: (br, cont) =>
+            cont.matchType({
+              Effect: (query) => IO.succeedNow(Result.blocked(br, Continue.effect(query.zipWith(that, f)))),
+              Get: () =>
+                that().step.map((result) =>
+                  result.matchType({
+                    Blocked: (br2, c2) => Result.blocked(BlockedRequests.then<R | R1>(br, br2), cont.zipWith(c2, f)),
+                    Done: (b) =>
+                      Result.blocked(
+                        br,
+                        cont.map((a) => f(a, b)),
+                      ),
+                    Fail: (cause) => Result.fail(cause),
+                  }),
+                ),
+            }),
+          Done: (a) =>
+            that().step.map((result) =>
+              result.matchType({
+                Blocked: (br, c) =>
+                  Result.blocked(
+                    br,
+                    c.map((b) => f(a, b)),
+                  ),
+                Done: (b) => Result.done(f(a, b)),
+                Fail: (cause) => Result.fail(cause),
+              }),
+            ),
+          Fail: (cause) => Result.fail(cause),
+        }),
+      ),
+    );
+  };
+}

package/_src/Query/api/zipWithBatched.ts

@@ -0,0 +1,41 @@
+import { BlockedRequests } from "@fncts/query/internal/BlockedRequests";
+
+/**
+ * @tsplus pipeable fncts.query.Query zipWithBatched
+ */
+export function zipWithBatched<A, R1, E1, B, C>(that: Query<R1, E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string) {
+  return <R, E>(self: Query<R, E, A>): Query<R | R1, E | E1, C> => {
+    return new Query(
+      self.step.zipWith(that.step, (r1, r2) =>
+        r1.matchType({
+          Blocked: (br1, c1) =>
+            r2.matchType({
+              Blocked: (br2, c2) => Result.blocked(BlockedRequests.both<R | R1>(br1, br2), c1.zipWithBatched(c2, f)),
+              Done: (b) =>
+                Result.blocked(
+                  br1,
+                  c1.map((a) => f(a, b)),
+                ),
+              Fail: (cause) => Result.fail(cause),
+            }),
+          Done: (a) =>
+            r2.matchType({
+              Blocked: (br, c) =>
+                Result.blocked(
+                  br,
+                  c.map((b) => f(a, b)),
+                ),
+              Done: (b) => Result.done(f(a, b)),
+              Fail: (cause) => Result.fail(cause),
+            }),
+          Fail: (cause) =>
+            r2.matchType({
+              Blocked: () => Result.fail(cause),
+              Done: () => Result.fail(cause),
+              Fail: (cause2) => Result.fail(Cause.both(cause, cause2)),
+            }),
+        }),
+      ),
+    );
+  };
+}

package/_src/Query/api/zipWithConcurrent.ts

@@ -0,0 +1,45 @@
+import { BlockedRequests } from "@fncts/query/internal/BlockedRequests";
+
+/**
+ * @tsplus pipeable fncts.query.Query zipWithConcurrent
+ */
+export function zipWithConcurrent<A, R1, E1, B, C>(
+  that: Query<R1, E1, B>,
+  f: (a: A, b: B) => C,
+  __tsplusTrace?: string,
+) {
+  return <R, E>(self: Query<R, E, A>): Query<R | R1, E | E1, C> => {
+    return new Query(
+      self.step.zipWithConcurrent(that.step, (r1, r2) =>
+        r1.matchType({
+          Blocked: (br1, c1) =>
+            r2.matchType({
+              Blocked: (br2, c2) => Result.blocked(BlockedRequests.both<R | R1>(br1, br2), c1.zipWithConcurrent(c2, f)),
+              Done: (b) =>
+                Result.blocked(
+                  br1,
+                  c1.map((a) => f(a, b)),
+                ),
+              Fail: (cause) => Result.fail(cause),
+            }),
+          Done: (a) =>
+            r2.matchType({
+              Blocked: (br, c) =>
+                Result.blocked(
+                  br,
+                  c.map((b) => f(a, b)),
+                ),
+              Done: (b) => Result.done(f(a, b)),
+              Fail: (cause) => Result.fail(cause),
+            }),
+          Fail: (cause) =>
+            r2.matchType({
+              Blocked: () => Result.fail(cause),
+              Done: () => Result.fail(cause),
+              Fail: (cause2) => Result.fail(Cause.both(cause, cause2)),
+            }),
+        }),
+      ),
+    );
+  };
+}