@fncts/query 0.0.1

package/_src/internal/Continue.ts

@@ -0,0 +1,305 @@
+import type { Described } from "@fncts/query/Described";
+
+import { QueryFailure } from "../QueryFailure.js";
+
+export const ContinueTypeId = Symbol.for("fncts.query.Continue");
+export type ContinueTypeId = typeof ContinueTypeId;
+
+export const ContinueVariance = Symbol.for("fncts.query.Continue.Variance");
+export type ContinueVariance = typeof ContinueVariance;
+
+/**
+ * @tsplus type fncts.query.Continue
+ * @tsplus companion fncts.query.ContinueOps
+ */
+export abstract class Continue<R, E, A> {
+  readonly [ContinueTypeId]: ContinueTypeId = ContinueTypeId;
+  declare [ContinueVariance]: {
+    readonly _R: (_: never) => R;
+    readonly _E: (_: never) => E;
+    readonly _A: (_: never) => A;
+  };
+}
+
+export const enum ContinueTag {
+  Effect,
+  Get,
+}
+
+/**
+ * @tsplus companion fncts.query.Continue.EffectOps
+ */
+export class Effect<R, E, A> extends Continue<R, E, A> {
+  readonly _tag = ContinueTag.Effect;
+  constructor(readonly query: Query<R, E, A>) {
+    super();
+  }
+}
+
+/**
+ * @tsplus companion fncts.query.Continue.GetOps
+ */
+export class Get<E, A> extends Continue<never, E, A> {
+  readonly _tag = ContinueTag.Get;
+  constructor(readonly io: FIO<E, A>) {
+    super();
+  }
+}
+
+type Concrete<R, E, A> = Effect<R, E, A> | Get<E, A>;
+
+function concrete<R, E, A>(_: Continue<R, E, A>): asserts _ is Concrete<R, E, A> {
+  //
+}
+
+/**
+ * @tsplus static fncts.query.Continue.EffectOps __call
+ * @tsplus static fncts.query.Continue effect
+ */
+export function effect<R, E, A>(query: Query<R, E, A>): Continue<R, E, A> {
+  return new Effect(query);
+}
+
+/**
+ * @tsplus static fncts.query.Continue.GetOps __call
+ * @tsplus static fncts.query.Continue get
+ */
+export function get<E, A>(io: FIO<E, A>): Continue<never, E, A> {
+  return new Get(io);
+}
+
+/**
+ * @tsplus static fncts.query.ContinueOps __call
+ */
+export 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> {
+  return Continue.get(
+    ref.get.flatMap((m) =>
+      m.match(
+        () => IO.haltNow(new QueryFailure(dataSource, request)),
+        (b) => IO.fromEitherNow(b),
+      ),
+    ),
+  );
+}
+
+/**
+ * @tsplus pipeable fncts.query.Continue matchType
+ */
+export function matchType<R, E, A, B, C>(cases: { Effect: (query: Query<R, E, A>) => B; Get: (io: FIO<E, A>) => C }) {
+  return (self: Continue<R, E, A>): B | C => {
+    concrete(self);
+    switch (self._tag) {
+      case ContinueTag.Effect:
+        return cases.Effect(self.query);
+      case ContinueTag.Get:
+        return cases.Get(self.io);
+    }
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.query.Continue mapQuery
+ */
+export function mapQuery<A, R1, E1, B>(f: (a: A) => Query<R1, E1, B>, __tsplusTrace?: string) {
+  return <R, E>(self: Continue<R, E, A>): Continue<R | R1, E | E1, B> => {
+    return self.matchType({
+      Effect: (query) => Effect(query.flatMap(f)),
+      Get: (io) => Effect(Query.fromIO(io).flatMap(f)),
+    });
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.query.Continue match
+ */
+export function match<E, A, B, C>(failure: (e: E) => B, success: (a: A) => C, __tsplusTrace?: string) {
+  return <R>(self: Continue<R, E, A>): Continue<R, never, B | C> => {
+    return self.matchType({
+      Effect: (query) => Effect(query.match(failure, success)),
+      Get: (io) => Get(io.match(failure, success)),
+    });
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.query.Continue matchCauseQuery
+ */
+export 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,
+) {
+  return <R>(self: Continue<R, E, A>): Continue<R | R1 | R2, E1 | E2, B | C> => {
+    return self.matchType({
+      Effect: (query) => Effect(query.matchCauseQuery(failure, success)),
+      Get: (io) => Effect(Query.fromIO(io).matchCauseQuery(failure, success)),
+    });
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.query.Continue map
+ */
+export function map<A, B>(f: (a: A) => B, __tsplusTrace?: string) {
+  return <R, E>(self: Continue<R, E, A>): Continue<R, E, B> => {
+    return self.matchType({
+      Effect: (query) => Effect(query.map(f)),
+      Get: (io) => Get(io.map(f)),
+    });
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.query.Continue mapDataSources
+ */
+export function mapDataSources<R1>(f: DataSourceAspect<R1>, __tsplusTrace?: string) {
+  return <R, E, A>(self: Continue<R, E, A>): Continue<R | R1, E, A> => {
+    return self.matchType({
+      Effect: (query) => Effect(query.mapDataSources(f)),
+      Get: (io) => Get(io),
+    });
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.query.Continue mapError
+ */
+export function mapError<E, E1>(f: (e: E) => E1, __tsplusTrace?: string) {
+  return <R, A>(self: Continue<R, E, A>): Continue<R, E1, A> => {
+    return self.matchType({
+      Effect: (query) => Effect(query.mapError(f)),
+      Get: (io) => Get(io.mapError(f)),
+    });
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.query.Continue mapErrorCause
+ */
+export function mapErrorCause<E, E1>(f: (cause: Cause<E>) => Cause<E1>, __tsplusTrace?: string) {
+  return <R, A>(self: Continue<R, E, A>): Continue<R, E1, A> => {
+    return self.matchType({
+      Effect: (query) => Effect(query.mapErrorCause(f)),
+      Get: (io) => Get(io.mapErrorCause(f)),
+    });
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.query.Continue zipWith
+ */
+export function zipWith<A, R1, E1, B, C>(that: Continue<R1, E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string) {
+  return <R, E>(self: Continue<R, E, A>): Continue<R | R1, E | E1, C> => {
+    return self.matchType({
+      Effect: (l) =>
+        that.matchType({
+          Effect: (r) => Effect(l.zipWith(r, f)),
+          Get: (r) => Effect(l.zipWith(Query.fromIO(r), f)),
+        }),
+      Get: (l) =>
+        that.matchType({
+          Effect: (r) => Effect(Query.fromIO(l).zipWith(r, f)),
+          Get: (r) => Get(l.zipWith(r, f)),
+        }),
+    });
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.query.Continue zipWithConcurrent
+ */
+export function zipWithConcurrent<A, R1, E1, B, C>(
+  that: Continue<R1, E1, B>,
+  f: (a: A, b: B) => C,
+  __tsplusTrace?: string,
+) {
+  return <R, E>(self: Continue<R, E, A>): Continue<R | R1, E | E1, C> => {
+    return self.matchType({
+      Effect: (l) =>
+        that.matchType({
+          Effect: (r) => Effect(l.zipWithConcurrent(r, f)),
+          Get: (r) => Effect(l.zipWith(Query.fromIO(r), f)),
+        }),
+      Get: (l) =>
+        that.matchType({
+          Effect: (r) => Effect(Query.fromIO(l).zipWith(r, f)),
+          Get: (r) => Get(l.zipWith(r, f)),
+        }),
+    });
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.query.Continue zipWithBatched
+ */
+export function zipWithBatched<A, R1, E1, B, C>(
+  that: Continue<R1, E1, B>,
+  f: (a: A, b: B) => C,
+  __tsplusTrace?: string,
+) {
+  return <R, E>(self: Continue<R, E, A>): Continue<R | R1, E | E1, C> => {
+    return self.matchType({
+      Effect: (l) =>
+        that.matchType({
+          Effect: (r) => Effect(l.zipWithBatched(r, f)),
+          Get: (r) => Effect(l.zipWith(Query.fromIO(r), f)),
+        }),
+      Get: (l) =>
+        that.matchType({
+          Effect: (r) => Effect(Query.fromIO(l).zipWith(r, f)),
+          Get: (r) => Get(l.zipWith(r, f)),
+        }),
+    });
+  };
+}
+
+/**
+ * @tsplus static fncts.query.ContinueOps collectAllConcurrent
+ */
+export function collectAllConcurrent<R, E, A>(continues: Iterable<Continue<R, E, A>>): Continue<R, E, Conc<A>> {
+  const [queries, ios] = continues.zipWithIndex.foldLeft(
+    [Conc.empty<readonly [Query<R, E, A>, number]>(), Conc.empty<readonly [FIO<E, A>, number]>()] as const,
+    ([queries, ios], [index, cont]) =>
+      cont.matchType({
+        Effect: (query) => [queries.append([query, index] as const), ios] as const,
+        Get: (io) => [queries, ios.append([io, index] as const)] as const,
+      }),
+  );
+  if (queries.length === 0) {
+    return Continue.get(IO.sequenceIterable(ios.map(([io]) => io)));
+  } else {
+    const query = Query.collectAllConcurrent(queries.map(([query]) => query)).flatMap((as) => {
+      const array = Array(continues.size);
+      as.zip(queries.map(([_, index]) => index)).forEach(([a, i]) => {
+        array[i] = a;
+      });
+      return Query.fromIO(IO.sequenceIterable(ios.map(([io]) => io))).map((as) => {
+        as.zip(ios.map(([_, index]) => index)).forEach(([a, i]) => {
+          array[i] = a;
+        });
+        return Conc.from(array);
+      });
+    });
+    return Continue.effect(query);
+  }
+}
+
+/**
+ * @tsplus pipeable fncts.query.Continue contramapEnvironment
+ */
+export function contramapEnvironment<R0, R>(
+  f: Described<(_: Environment<R0>) => Environment<R>>,
+  __tsplusTrace?: string,
+) {
+  return <E, A>(self: Continue<R, E, A>): Continue<R0, E, A> => {
+    return self.matchType({
+      Effect: (query) => Continue.effect(query.contramapEnvironment(f)),
+      Get: (io) => Continue.get(io),
+    });
+  };
+}

package/_src/internal/Parallel.ts

@@ -0,0 +1,82 @@
+import type { DataSource } from "@fncts/query/DataSource";
+import type { BlockedRequest } from "@fncts/query/internal/BlockedRequest";
+
+import { Sequential } from "@fncts/query/internal/Sequential";
+
+export const ParallelTypeId = Symbol.for("fncts.query.Parallel");
+export type ParallelTypeId = typeof ParallelTypeId;
+
+export const ParallelVariance = Symbol.for("fncts.query.Parallel.Variance");
+export type ParallelVariance = typeof ParallelVariance;
+
+/**
+ * @tsplus type fncts.query.Parallel
+ * @tsplus companion fncts.query.ParallelOps
+ */
+export class Parallel<R> {
+  readonly [ParallelTypeId]: ParallelTypeId = ParallelTypeId;
+  declare [ParallelVariance]: {
+    readonly _R: (_: never) => R;
+  };
+
+  constructor(readonly map: HashMap<DataSource<any, any>, Conc<BlockedRequest<any>>>) {}
+}
+
+/**
+ * @tsplus pipeable fncts.query.Parallel concat
+ */
+export function concat<R1>(that: Parallel<R1>) {
+  return <R>(self: Parallel<R>): Parallel<R | R1> => {
+    return new Parallel(
+      that.map.foldLeftWithIndex(self.map, (k, map, v) =>
+        map.set(
+          k,
+          map.get(k).match(
+            () => v,
+            (requests) => requests.concat(v),
+          ),
+        ),
+      ),
+    );
+  };
+}
+
+/**
+ * @tsplus getter fncts.query.Parallel isEmpty
+ */
+export function isEmpty<R>(self: Parallel<R>): boolean {
+  return self.map.isEmpty;
+}
+
+/**
+ * @tsplus getter fncts.query.Parallel keys
+ */
+export function keys<R>(self: Parallel<R>): Iterable<DataSource<R, any>> {
+  return self.map.keys;
+}
+
+/**
+ * @tsplus getter fncts.query.Parallel toIterable
+ */
+export function toIterable<R>(self: Parallel<R>): Iterable<readonly [DataSource<R, any>, Conc<BlockedRequest<any>>]> {
+  return self.map;
+}
+
+/**
+ * @tsplus getter fncts.query.Parallel sequential
+ */
+export function sequential<R>(self: Parallel<R>): Sequential<R> {
+  return new Sequential(self.map.map((v) => Conc(v)));
+}
+
+/**
+ * @tsplus static fncts.query.ParallelOps __call
+ */
+export function makeParallel<R, A>(dataSource: DataSource<R, A>, blockedRequest: BlockedRequest<A>): Parallel<R> {
+  return new Parallel(HashMap([dataSource, Conc(blockedRequest)]));
+}
+
+/**
+ * @tsplus static fncts.query.ParallelOps empty
+ */
+export const empty: Parallel<never> = new Parallel(HashMap.empty());

package/_src/internal/Result.ts

@@ -0,0 +1,242 @@
+import type { Described } from "@fncts/query/Described";
+
+import { BlockedRequests } from "@fncts/query/internal/BlockedRequests";
+
+export const ResultTypeId = Symbol.for("fncts.query.Result");
+export type ResultTypeId = typeof ResultTypeId;
+
+export const ResultVariance = Symbol.for("fncts.query.Result.Variance");
+export type ResultVariance = typeof ResultVariance;
+
+/**
+ * @tsplus type fncts.query.Result
+ * @tsplus companion fncts.query.ResultOps
+ */
+export abstract class Result<R, E, A> {
+  readonly [ResultTypeId]: ResultTypeId = ResultTypeId;
+  declare [ResultVariance]: {
+    readonly _R: (_: never) => R;
+    readonly _E: (_: never) => E;
+    readonly _A: (_: never) => A;
+  };
+}
+
+export const enum ResultTag {
+  Blocked,
+  Done,
+  Fail,
+}
+
+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>) {
+    super();
+  }
+}
+
+export class Done<A> extends Result<never, never, A> {
+  readonly _tag = ResultTag.Done;
+  constructor(readonly value: A) {
+    super();
+  }
+}
+
+export class Fail<E> extends Result<never, E, never> {
+  readonly _tag = ResultTag.Fail;
+  constructor(readonly cause: Cause<E>) {
+    super();
+  }
+}
+
+type Concrete<R, E, A> = Blocked<R, E, A> | Done<A> | Fail<E>;
+
+function concrete<R, E, A>(_: Result<R, E, A>): asserts _ is Concrete<R, E, A> {
+  //
+}
+
+/**
+ * @tsplus static fncts.query.ResultOps blocked
+ */
+export function blocked<R, E, A>(blockedRequests: BlockedRequests<R>, cont: Continue<R, E, A>): Result<R, E, A> {
+  return new Blocked(blockedRequests, cont);
+}
+
+/**
+ * @tsplus static fncts.query.ResultOps done
+ */
+export function done<A>(value: A): Result<never, never, A> {
+  return new Done(value);
+}
+
+/**
+ * @tsplus static fncts.query.ResultOps fail
+ */
+export function fail<E>(cause: Cause<E>): Result<never, E, never> {
+  return new Fail(cause);
+}
+
+/**
+ * @tsplus pipeable fncts.query.Result matchType
+ */
+export 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;
+}) {
+  return (self: Result<R, E, A>): B | C | D => {
+    concrete(self);
+    switch (self._tag) {
+      case ResultTag.Blocked: {
+        return cases.Blocked(self.blockedRequests, self.cont);
+      }
+      case ResultTag.Done: {
+        return cases.Done(self.value);
+      }
+      case ResultTag.Fail: {
+        return cases.Fail(self.cause);
+      }
+    }
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.query.Result match
+ */
+export function match<E, A, B, C>(failure: (e: E) => B, success: (a: A) => C) {
+  return <R>(self: Result<R, E, A>): Result<R, never, B | 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),
+    });
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.query.Result map
+ */
+export function map<A, B>(f: (a: A) => B, __tsplusTrace?: string) {
+  return <R, E>(self: Result<R, E, A>): Result<R, E, B> => {
+    return self.matchType({
+      Blocked: (br, c) => Result.blocked(br, c.map(f)),
+      Done: (a) => Result.done(f(a)),
+      Fail: (cause) => Result.fail(cause),
+    });
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.query.Result mapDataSources
+ */
+export function mapDataSources<R1>(f: DataSourceAspect<R1>) {
+  return <R, E, A>(self: Result<R, E, A>): Result<R | R1, E, A> => {
+    return self.matchType({
+      Blocked: (br, c) => Result.blocked(br.mapDataSources(f), c.mapDataSources(f)),
+      Done: (a) => Result.done(a),
+      Fail: (cause) => Result.fail(cause),
+    });
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.query.Result mapError
+ */
+export function mapError<E, E1>(f: (e: E) => E1, __tsplusTrace?: string) {
+  return <R, A>(self: Result<R, E, A>): Result<R, E1, A> => {
+    return self.matchType({
+      Blocked: (br, c) => Result.blocked(br, c.mapError(f)),
+      Done: Result.done,
+      Fail: (cause) => Result.fail(cause.map(f)),
+    });
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.query.Result mapErrorCause
+ */
+export function mapErrorCause<E, E1>(f: (cause: Cause<E>) => Cause<E1>, __tsplusTrace?: string) {
+  return <R, A>(self: Result<R, E, A>): Result<R, E1, A> => {
+    return self.matchType({
+      Blocked: (br, c) => Result.blocked(br, c.mapErrorCause(f)),
+      Done: Result.done,
+      Fail: (cause) => Result.fail(f(cause)),
+    });
+  };
+}
+
+/**
+ * @tsplus static fncts.query.ResultOps collectAllConcurrent
+ */
+export function collectAllConcurrent<R, E, A>(
+  self: Iterable<Result<R, E, A>>,
+  __tsplusTrace?: string,
+): Result<R, E, Conc<A>> {
+  const [blocked, done, fails] = self.zipWithIndex.foldLeft(
+    [
+      Conc.empty<readonly [BlockedRequests<R>, Continue<R, E, A>, number]>(),
+      Conc.empty<readonly [A, number]>(),
+      Conc.empty<readonly [Cause<E>, number]>(),
+    ] as const,
+    ([blocked, done, fails], [index, result]) =>
+      result.matchType({
+        Blocked: (br, c) => [blocked.append([br, c, index] as const), done, fails] as const,
+        Done: (a) => [blocked, done.append([a, index] as const), fails] as const,
+        Fail: (e) => [blocked, done, fails.append([e, index] as const)] as const,
+      }),
+  );
+
+  if (blocked.isEmpty && fails.isEmpty) {
+    return Result.done(done.map(([a]) => a));
+  } else if (fails.isEmpty) {
+    const blockedRequests = blocked
+      .map(([br]) => br)
+      .foldLeft(BlockedRequests.empty<R>(), (b, a) => BlockedRequests.both(b, a));
+
+    const cont = Continue.collectAllConcurrent(blocked.map(([_, cont]) => cont)).map((as) => {
+      const array = Array(as.length);
+      as.zip(blocked.map(([cont]) => cont)).forEachWithIndex((i, a) => {
+        array[i] = a;
+      });
+      done.forEachWithIndex((i, a) => {
+        array[i] = a;
+      });
+      return Conc.from(array);
+    });
+    return Result.blocked<R, E, Conc<A>>(blockedRequests, cont);
+  } else {
+    return Result.fail(fails.map(([cause]) => cause).foldLeft(Cause.empty(), (b, a) => Cause.both(b, a)));
+  }
+}
+
+/**
+ * @tsplus pipeable fncts.query.Result contramapEnvironment
+ */
+export function contramapEnvironment<R0, R>(
+  f: Described<(_: Environment<R0>) => Environment<R>>,
+  __tsplusTrace?: string,
+) {
+  return <E, A>(self: Result<R, E, A>): Result<R0, E, A> => {
+    return self.matchType({
+      Blocked: (br, cont) => Result.blocked(br.contramapEnvironment(f), cont.contramapEnvironment(f)),
+      Done: (a) => Result.done(a),
+      Fail: (e) => Result.fail(e),
+    });
+  };
+}
+
+/**
+ * @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),
+  );
+}
+
+/**
+ * @tsplus static fncts.query.ResultOps fromExit
+ */
+export function fromExit<E, A>(exit: Exit<E, A>): Result<never, E, A> {
+  return exit.match(Result.fail, Result.done);
+}

package/_src/internal/Sequential.ts

@@ -0,0 +1,63 @@
+import type { DataSource } from "@fncts/query/DataSource";
+import type { BlockedRequest } from "@fncts/query/internal/BlockedRequest";
+
+export const SequentialTypeId = Symbol.for("fncts.query.Sequential");
+export type SequentialTypeId = typeof SequentialTypeId;
+
+export const SequentialVariance = Symbol.for("fncts.query.Sequential.Variance");
+export type SequentialVariance = typeof SequentialVariance;
+
+/**
+ * @tsplus type fncts.query.Sequential
+ * @tsplus companion fncts.query.SequentialOps
+ */
+export class Sequential<R> {
+  readonly [SequentialTypeId]: SequentialTypeId = SequentialTypeId;
+  declare [SequentialVariance]: {
+    readonly _R: (_: never) => R;
+  };
+
+  constructor(readonly map: HashMap<DataSource<any, any>, Conc<Conc<BlockedRequest<any>>>>) {}
+}
+
+/**
+ * @tsplus pipeable fncts.query.Sequential concat
+ */
+export function concat<R1>(that: Sequential<R1>) {
+  return <R>(self: Sequential<R>): Sequential<R | R1> => {
+    return new Sequential(
+      that.map.foldLeftWithIndex(self.map, (k, map, v) =>
+        map.set(
+          k,
+          map.get(k).match(
+            () => v,
+            (requests) => requests.concat(v),
+          ),
+        ),
+      ),
+    );
+  };
+}
+
+/**
+ * @tsplus getter fncts.query.Sequential isEmpty
+ */
+export function isEmpty<R>(self: Sequential<R>): boolean {
+  return self.map.isEmpty;
+}
+
+/**
+ * @tsplus getter fncts.query.Sequential keys
+ */
+export function keys<R>(self: Sequential<R>): Iterable<DataSource<R, any>> {
+  return self.map.keys;
+}
+
+/**
+ * @tsplus getter fncts.query.Sequential toIterable
+ */
+export function toIterable<R>(
+  self: Sequential<R>,
+): Iterable<readonly [DataSource<R, any>, Conc<Conc<BlockedRequest<any>>>]> {
+  return self.map;
+}