<A2 extends Request.Any>(that: RequestResolver<A2>): <
A extends Request.Any
>(
self: RequestResolver<A>
) => RequestResolver<A2 & A>
<A extends Request.Any, A2 extends Request.Any>(
self: RequestResolver<A>,
that: RequestResolver<A2>
): RequestResolver<A & A2>Returns a request resolver that sends each batch to both resolvers and completes with the first resolver to finish.
Details
The losing resolver run is interrupted after the winning resolver completes the batch.
Example (Racing request resolvers)
import { Effect, Exit, Request, RequestResolver } from "effect"
interface GetDataRequest extends Request.Request<string> {
readonly _tag: "GetDataRequest"
readonly id: number
}
const GetDataRequest = Request.tagged<GetDataRequest>("GetDataRequest")
// Fast resolver (simulating cache)
const fastResolver = RequestResolver.make<GetDataRequest>((entries) =>
Effect.gen(function*() {
yield* Effect.sleep("10 millis")
for (const entry of entries) {
entry.completeUnsafe(Exit.succeed(`fast-${entry.request.id}`))
}
})
)
// Slow resolver (simulating database)
const slowResolver = RequestResolver.make<GetDataRequest>((entries) =>
Effect.gen(function*() {
yield* Effect.sleep("100 millis")
for (const entry of entries) {
entry.completeUnsafe(Exit.succeed(`slow-${entry.request.id}`))
}
})
)
// Race resolvers - will use whichever completes first
const racingResolver = RequestResolver.race(fastResolver, slowResolver)combinators
Source effect/RequestResolver.ts:86915 lines
export const const race: {
<A2 extends Request.Any>(
that: RequestResolver<A2>
): <A extends Request.Any>(
self: RequestResolver<A>
) => RequestResolver<A2 & A>
<A extends Request.Any, A2 extends Request.Any>(
self: RequestResolver<A>,
that: RequestResolver<A2>
): RequestResolver<A & A2>
}
Returns a request resolver that sends each batch to both resolvers and
completes with the first resolver to finish.
Details
The losing resolver run is interrupted after the winning resolver completes
the batch.
Example (Racing request resolvers)
import { Effect, Exit, Request, RequestResolver } from "effect"
interface GetDataRequest extends Request.Request<string> {
readonly _tag: "GetDataRequest"
readonly id: number
}
const GetDataRequest = Request.tagged<GetDataRequest>("GetDataRequest")
// Fast resolver (simulating cache)
const fastResolver = RequestResolver.make<GetDataRequest>((entries) =>
Effect.gen(function*() {
yield* Effect.sleep("10 millis")
for (const entry of entries) {
entry.completeUnsafe(Exit.succeed(`fast-${entry.request.id}`))
}
})
)
// Slow resolver (simulating database)
const slowResolver = RequestResolver.make<GetDataRequest>((entries) =>
Effect.gen(function*() {
yield* Effect.sleep("100 millis")
for (const entry of entries) {
entry.completeUnsafe(Exit.succeed(`slow-${entry.request.id}`))
}
})
)
// Race resolvers - will use whichever completes first
const racingResolver = RequestResolver.race(fastResolver, slowResolver)
race: {
<function (type parameter) A2 in <A2 extends Request.Any>(that: RequestResolver<A2>): <A extends Request.Any>(self: RequestResolver<A>) => RequestResolver<A2 & A>A2 extends import RequestRequest.type Request.Any = /*unresolved*/ anyAny>(
that: RequestResolver<A2>(parameter) that: {
delay: Effect.Effect<void>;
batchKey: (entry: Request.Entry<A2>) => unknown;
preCheck: ((entry: Request.Entry<A>) => boolean) | undefined;
collectWhile: (entries: ReadonlySet<Request.Entry<A2>>) => boolean;
runAll: (entries: [Request.Entry<A2>, ...Request.Entry<A2>[]], key: unknown) => Effect.Effect<void, Request.Error<A2>, never>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
interface RequestResolver<in A extends Request.Any>A resolver that executes and completes batched Request entries.
Details
A resolver controls how requests are grouped, delayed, optionally
pre-checked, and finally run. Its runAll method receives a non-empty batch
of Request.Entry values for a single batch key and must complete every
received entry, usually by calling completeUnsafe or one of the Request
completion helpers.
Gotchas
If a resolver finishes without completing an entry, the waiting request fails
because the resolver did not supply a result.
Example (Defining a request resolver)
import { Effect, Exit, RequestResolver } from "effect"
import type { Request } from "effect"
interface GetUserRequest extends Request.Request<string, Error> {
readonly _tag: "GetUserRequest"
readonly id: number
}
// In practice, you would typically use RequestResolver.make() instead
const resolver = RequestResolver.make<GetUserRequest>((entries) =>
Effect.sync(() => {
for (const entry of entries) {
entry.completeUnsafe(Exit.succeed(`User ${entry.request.id}`))
}
})
)
Namespace containing type-level helpers associated with RequestResolver.
RequestResolver<function (type parameter) A2 in <A2 extends Request.Any>(that: RequestResolver<A2>): <A extends Request.Any>(self: RequestResolver<A>) => RequestResolver<A2 & A>A2>
): <function (type parameter) A in <A extends Request.Any>(self: RequestResolver<A>): RequestResolver<A2 & A>A extends import RequestRequest.type Request.Any = /*unresolved*/ anyAny>(self: RequestResolver<A>(parameter) self: {
delay: Effect.Effect<void>;
batchKey: (entry: Request.Entry<A>) => unknown;
preCheck: ((entry: Request.Entry<A>) => boolean) | undefined;
collectWhile: (entries: ReadonlySet<Request.Entry<A>>) => boolean;
runAll: (entries: [Request.Entry<A>, ...Request.Entry<A>[]], key: unknown) => Effect.Effect<void, Request.Error<A>, never>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
interface RequestResolver<in A extends Request.Any>A resolver that executes and completes batched Request entries.
Details
A resolver controls how requests are grouped, delayed, optionally
pre-checked, and finally run. Its runAll method receives a non-empty batch
of Request.Entry values for a single batch key and must complete every
received entry, usually by calling completeUnsafe or one of the Request
completion helpers.
Gotchas
If a resolver finishes without completing an entry, the waiting request fails
because the resolver did not supply a result.
Example (Defining a request resolver)
import { Effect, Exit, RequestResolver } from "effect"
import type { Request } from "effect"
interface GetUserRequest extends Request.Request<string, Error> {
readonly _tag: "GetUserRequest"
readonly id: number
}
// In practice, you would typically use RequestResolver.make() instead
const resolver = RequestResolver.make<GetUserRequest>((entries) =>
Effect.sync(() => {
for (const entry of entries) {
entry.completeUnsafe(Exit.succeed(`User ${entry.request.id}`))
}
})
)
Namespace containing type-level helpers associated with RequestResolver.
RequestResolver<function (type parameter) A in <A extends Request.Any>(self: RequestResolver<A>): RequestResolver<A2 & A>A>) => interface RequestResolver<in A extends Request.Any>A resolver that executes and completes batched Request entries.
Details
A resolver controls how requests are grouped, delayed, optionally
pre-checked, and finally run. Its runAll method receives a non-empty batch
of Request.Entry values for a single batch key and must complete every
received entry, usually by calling completeUnsafe or one of the Request
completion helpers.
Gotchas
If a resolver finishes without completing an entry, the waiting request fails
because the resolver did not supply a result.
Example (Defining a request resolver)
import { Effect, Exit, RequestResolver } from "effect"
import type { Request } from "effect"
interface GetUserRequest extends Request.Request<string, Error> {
readonly _tag: "GetUserRequest"
readonly id: number
}
// In practice, you would typically use RequestResolver.make() instead
const resolver = RequestResolver.make<GetUserRequest>((entries) =>
Effect.sync(() => {
for (const entry of entries) {
entry.completeUnsafe(Exit.succeed(`User ${entry.request.id}`))
}
})
)
Namespace containing type-level helpers associated with RequestResolver.
RequestResolver<function (type parameter) A2 in <A2 extends Request.Any>(that: RequestResolver<A2>): <A extends Request.Any>(self: RequestResolver<A>) => RequestResolver<A2 & A>A2 & function (type parameter) A in <A extends Request.Any>(self: RequestResolver<A>): RequestResolver<A2 & A>A>
<function (type parameter) A in <A extends Request.Any, A2 extends Request.Any>(self: RequestResolver<A>, that: RequestResolver<A2>): RequestResolver<A & A2>A extends import RequestRequest.type Request.Any = /*unresolved*/ anyAny, function (type parameter) A2 in <A extends Request.Any, A2 extends Request.Any>(self: RequestResolver<A>, that: RequestResolver<A2>): RequestResolver<A & A2>A2 extends import RequestRequest.type Request.Any = /*unresolved*/ anyAny>(
self: RequestResolver<A>(parameter) self: {
delay: Effect.Effect<void>;
batchKey: (entry: Request.Entry<A>) => unknown;
preCheck: ((entry: Request.Entry<A>) => boolean) | undefined;
collectWhile: (entries: ReadonlySet<Request.Entry<A>>) => boolean;
runAll: (entries: [Request.Entry<A>, ...Request.Entry<A>[]], key: unknown) => Effect.Effect<void, Request.Error<A>, never>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
interface RequestResolver<in A extends Request.Any>A resolver that executes and completes batched Request entries.
Details
A resolver controls how requests are grouped, delayed, optionally
pre-checked, and finally run. Its runAll method receives a non-empty batch
of Request.Entry values for a single batch key and must complete every
received entry, usually by calling completeUnsafe or one of the Request
completion helpers.
Gotchas
If a resolver finishes without completing an entry, the waiting request fails
because the resolver did not supply a result.
Example (Defining a request resolver)
import { Effect, Exit, RequestResolver } from "effect"
import type { Request } from "effect"
interface GetUserRequest extends Request.Request<string, Error> {
readonly _tag: "GetUserRequest"
readonly id: number
}
// In practice, you would typically use RequestResolver.make() instead
const resolver = RequestResolver.make<GetUserRequest>((entries) =>
Effect.sync(() => {
for (const entry of entries) {
entry.completeUnsafe(Exit.succeed(`User ${entry.request.id}`))
}
})
)
Namespace containing type-level helpers associated with RequestResolver.
RequestResolver<function (type parameter) A in <A extends Request.Any, A2 extends Request.Any>(self: RequestResolver<A>, that: RequestResolver<A2>): RequestResolver<A & A2>A>,
that: RequestResolver<A2>(parameter) that: {
delay: Effect.Effect<void>;
batchKey: (entry: Request.Entry<A2>) => unknown;
preCheck: ((entry: Request.Entry<A>) => boolean) | undefined;
collectWhile: (entries: ReadonlySet<Request.Entry<A2>>) => boolean;
runAll: (entries: [Request.Entry<A2>, ...Request.Entry<A2>[]], key: unknown) => Effect.Effect<void, Request.Error<A2>, never>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
interface RequestResolver<in A extends Request.Any>A resolver that executes and completes batched Request entries.
Details
A resolver controls how requests are grouped, delayed, optionally
pre-checked, and finally run. Its runAll method receives a non-empty batch
of Request.Entry values for a single batch key and must complete every
received entry, usually by calling completeUnsafe or one of the Request
completion helpers.
Gotchas
If a resolver finishes without completing an entry, the waiting request fails
because the resolver did not supply a result.
Example (Defining a request resolver)
import { Effect, Exit, RequestResolver } from "effect"
import type { Request } from "effect"
interface GetUserRequest extends Request.Request<string, Error> {
readonly _tag: "GetUserRequest"
readonly id: number
}
// In practice, you would typically use RequestResolver.make() instead
const resolver = RequestResolver.make<GetUserRequest>((entries) =>
Effect.sync(() => {
for (const entry of entries) {
entry.completeUnsafe(Exit.succeed(`User ${entry.request.id}`))
}
})
)
Namespace containing type-level helpers associated with RequestResolver.
RequestResolver<function (type parameter) A2 in <A extends Request.Any, A2 extends Request.Any>(self: RequestResolver<A>, that: RequestResolver<A2>): RequestResolver<A & A2>A2>
): interface RequestResolver<in A extends Request.Any>A resolver that executes and completes batched Request entries.
Details
A resolver controls how requests are grouped, delayed, optionally
pre-checked, and finally run. Its runAll method receives a non-empty batch
of Request.Entry values for a single batch key and must complete every
received entry, usually by calling completeUnsafe or one of the Request
completion helpers.
Gotchas
If a resolver finishes without completing an entry, the waiting request fails
because the resolver did not supply a result.
Example (Defining a request resolver)
import { Effect, Exit, RequestResolver } from "effect"
import type { Request } from "effect"
interface GetUserRequest extends Request.Request<string, Error> {
readonly _tag: "GetUserRequest"
readonly id: number
}
// In practice, you would typically use RequestResolver.make() instead
const resolver = RequestResolver.make<GetUserRequest>((entries) =>
Effect.sync(() => {
for (const entry of entries) {
entry.completeUnsafe(Exit.succeed(`User ${entry.request.id}`))
}
})
)
Namespace containing type-level helpers associated with RequestResolver.
RequestResolver<function (type parameter) A in <A extends Request.Any, A2 extends Request.Any>(self: RequestResolver<A>, that: RequestResolver<A2>): RequestResolver<A & A2>A & function (type parameter) A2 in <A extends Request.Any, A2 extends Request.Any>(self: RequestResolver<A>, that: RequestResolver<A2>): RequestResolver<A & A2>A2>
} = import dualdual(2, <function (type parameter) A in <A extends Request.Any, A2 extends Request.Any>(self: RequestResolver<A>, that: RequestResolver<A2>): RequestResolver<A & A2>A extends import RequestRequest.type Request.Any = /*unresolved*/ anyAny, function (type parameter) A2 in <A extends Request.Any, A2 extends Request.Any>(self: RequestResolver<A>, that: RequestResolver<A2>): RequestResolver<A & A2>A2 extends import RequestRequest.type Request.Any = /*unresolved*/ anyAny>(
self: RequestResolver<A>(parameter) self: {
delay: Effect.Effect<void>;
batchKey: (entry: Request.Entry<A>) => unknown;
preCheck: ((entry: Request.Entry<A>) => boolean) | undefined;
collectWhile: (entries: ReadonlySet<Request.Entry<A>>) => boolean;
runAll: (entries: [Request.Entry<A>, ...Request.Entry<A>[]], key: unknown) => Effect.Effect<void, Request.Error<A>, never>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
interface RequestResolver<in A extends Request.Any>A resolver that executes and completes batched Request entries.
Details
A resolver controls how requests are grouped, delayed, optionally
pre-checked, and finally run. Its runAll method receives a non-empty batch
of Request.Entry values for a single batch key and must complete every
received entry, usually by calling completeUnsafe or one of the Request
completion helpers.
Gotchas
If a resolver finishes without completing an entry, the waiting request fails
because the resolver did not supply a result.
Example (Defining a request resolver)
import { Effect, Exit, RequestResolver } from "effect"
import type { Request } from "effect"
interface GetUserRequest extends Request.Request<string, Error> {
readonly _tag: "GetUserRequest"
readonly id: number
}
// In practice, you would typically use RequestResolver.make() instead
const resolver = RequestResolver.make<GetUserRequest>((entries) =>
Effect.sync(() => {
for (const entry of entries) {
entry.completeUnsafe(Exit.succeed(`User ${entry.request.id}`))
}
})
)
Namespace containing type-level helpers associated with RequestResolver.
RequestResolver<function (type parameter) A in <A extends Request.Any, A2 extends Request.Any>(self: RequestResolver<A>, that: RequestResolver<A2>): RequestResolver<A & A2>A>,
that: RequestResolver<A2>(parameter) that: {
delay: Effect.Effect<void>;
batchKey: (entry: Request.Entry<A2>) => unknown;
preCheck: ((entry: Request.Entry<A>) => boolean) | undefined;
collectWhile: (entries: ReadonlySet<Request.Entry<A2>>) => boolean;
runAll: (entries: [Request.Entry<A2>, ...Request.Entry<A2>[]], key: unknown) => Effect.Effect<void, Request.Error<A2>, never>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
interface RequestResolver<in A extends Request.Any>A resolver that executes and completes batched Request entries.
Details
A resolver controls how requests are grouped, delayed, optionally
pre-checked, and finally run. Its runAll method receives a non-empty batch
of Request.Entry values for a single batch key and must complete every
received entry, usually by calling completeUnsafe or one of the Request
completion helpers.
Gotchas
If a resolver finishes without completing an entry, the waiting request fails
because the resolver did not supply a result.
Example (Defining a request resolver)
import { Effect, Exit, RequestResolver } from "effect"
import type { Request } from "effect"
interface GetUserRequest extends Request.Request<string, Error> {
readonly _tag: "GetUserRequest"
readonly id: number
}
// In practice, you would typically use RequestResolver.make() instead
const resolver = RequestResolver.make<GetUserRequest>((entries) =>
Effect.sync(() => {
for (const entry of entries) {
entry.completeUnsafe(Exit.succeed(`User ${entry.request.id}`))
}
})
)
Namespace containing type-level helpers associated with RequestResolver.
RequestResolver<function (type parameter) A2 in <A extends Request.Any, A2 extends Request.Any>(self: RequestResolver<A>, that: RequestResolver<A2>): RequestResolver<A & A2>A2>
): interface RequestResolver<in A extends Request.Any>A resolver that executes and completes batched Request entries.
Details
A resolver controls how requests are grouped, delayed, optionally
pre-checked, and finally run. Its runAll method receives a non-empty batch
of Request.Entry values for a single batch key and must complete every
received entry, usually by calling completeUnsafe or one of the Request
completion helpers.
Gotchas
If a resolver finishes without completing an entry, the waiting request fails
because the resolver did not supply a result.
Example (Defining a request resolver)
import { Effect, Exit, RequestResolver } from "effect"
import type { Request } from "effect"
interface GetUserRequest extends Request.Request<string, Error> {
readonly _tag: "GetUserRequest"
readonly id: number
}
// In practice, you would typically use RequestResolver.make() instead
const resolver = RequestResolver.make<GetUserRequest>((entries) =>
Effect.sync(() => {
for (const entry of entries) {
entry.completeUnsafe(Exit.succeed(`User ${entry.request.id}`))
}
})
)
Namespace containing type-level helpers associated with RequestResolver.
RequestResolver<function (type parameter) A in <A extends Request.Any, A2 extends Request.Any>(self: RequestResolver<A>, that: RequestResolver<A2>): RequestResolver<A & A2>A & function (type parameter) A2 in <A extends Request.Any, A2 extends Request.Any>(self: RequestResolver<A>, that: RequestResolver<A2>): RequestResolver<A & A2>A2> =>
const make: <A extends Request.Any>(
runAll: (
entries: NonEmptyArray<Request.Entry<A>>,
key: unknown
) => Effect.Effect<void, Request.Error<A>>
) => RequestResolver<A>
Constructs a request resolver with the specified method to run requests.
Example (Creating a request resolver)
import { Effect, Exit, Request, RequestResolver } from "effect"
// Define a request type
interface GetUserRequest extends Request.Request<string, Error> {
readonly _tag: "GetUserRequest"
readonly id: number
}
const GetUserRequest = Request.tagged<GetUserRequest>("GetUserRequest")
// Create a resolver that handles the requests
const UserResolver = RequestResolver.make<GetUserRequest>((entries) =>
Effect.sync(() => {
for (const entry of entries) {
// Complete each request with a result
entry.completeUnsafe(Exit.succeed(`User ${entry.request.id}`))
}
})
)
// Use the resolver to handle requests
const getUserEffect = Effect.request(GetUserRequest({ id: 123 }), UserResolver)
make(
(requests: NonEmptyArray<Request.Entry<A>>(parameter) requests: {
0: Request.Entry<A & A2>;
length: number;
toString: () => string;
toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string };
pop: () => Request.Entry<A & A2> | undefined;
push: (...items: Array<Request.Entry<A & A2>>) => number;
concat: { (...items: Array<ConcatArray<Request.Entry<A & A2>>>): Array<Request.Entry<A & A2>>; (...items: Array<Request.Entry<A & A2> | ConcatArray<Request.Entry<A & A2>>>): Array<Request.Entry<A & A2>> };
join: (separator?: string) => string;
reverse: () => Array<Request.Entry<A & A2>>;
shift: () => Request.Entry<A & A2> | undefined;
slice: (start?: number, end?: number) => Array<Request.Entry<A & A2>>;
sort: (compareFn?: ((a: Request.Entry<A & A2>, b: Request.Entry<A & A2>) => number) | undefined) => [Request.Entry<A & A2>, ...Request.Entry<A & A2>[]];
splice: { (start: number, deleteCount?: number): Array<Request.Entry<A & A2>>; (start: number, deleteCount: number, ...items: Array<Request.Entry<A & A2>>): Array<Request.Entry<A & A2>> };
unshift: (...items: Array<Request.Entry<A & A2>>) => number;
indexOf: (searchElement: Request.Entry<A & A2>, fromIndex?: number) => number;
lastIndexOf: (searchElement: Request.Entry<A & A2>, fromIndex?: number) => number;
every: { (predicate: (value: Request.Entry<A & A2>, index: number, array: Array<Request.Entry<A & A2>>) => value is S, thisArg?: any): this is S[]; (predicate: (value: Request.Entry<A & A2>, index: number, array: Array<Request.Entry<A & A2>>) => …;
some: (predicate: (value: Request.Entry<A & A2>, index: number, array: Array<Request.Entry<A & A2>>) => unknown, thisArg?: any) => boolean;
forEach: (callbackfn: (value: Request.Entry<A & A2>, index: number, array: Array<Request.Entry<A & A2>>) => void, thisArg?: any) => void;
map: (callbackfn: (value: Request.Entry<A & A2>, index: number, array: Array<Request.Entry<A & A2>>) => U, thisArg?: any) => Array<U>;
filter: { (predicate: (value: Request.Entry<A & A2>, index: number, array: Array<Request.Entry<A & A2>>) => value is S, thisArg?: any): Array<S>; (predicate: (value: Request.Entry<A & A2>, index: number, array: Array<Request.Entry<A & A2>>) => unk…;
reduce: { (callbackfn: (previousValue: Request.Entry<A & A2>, currentValue: Request.Entry<A & A2>, currentIndex: number, array: Array<Request.Entry<A & A2>>) => Request.Entry<A & A2>): Request.Entry<A & A2>; (callbackfn: (previousValue: Request.En…;
reduceRight: { (callbackfn: (previousValue: Request.Entry<A & A2>, currentValue: Request.Entry<A & A2>, currentIndex: number, array: Array<Request.Entry<A & A2>>) => Request.Entry<A & A2>): Request.Entry<A & A2>; (callbackfn: (previousValue: Request.En…;
find: { (predicate: (value: Request.Entry<A & A2>, index: number, obj: Array<Request.Entry<A & A2>>) => value is S, thisArg?: any): S | undefined; (predicate: (value: Request.Entry<A & A2>, index: number, obj: Array<Request.Entry<A & A2>>) => un…;
findIndex: (predicate: (value: Request.Entry<A & A2>, index: number, obj: Array<Request.Entry<A & A2>>) => unknown, thisArg?: any) => number;
fill: (value: Request.Entry<A & A2>, start?: number, end?: number) => [Request.Entry<A & A2>, ...Request.Entry<A & A2>[]];
copyWithin: (target: number, start: number, end?: number) => [Request.Entry<A & A2>, ...Request.Entry<A & A2>[]];
entries: () => ArrayIterator<[number, Request.Entry<A & A2>]>;
keys: () => ArrayIterator<number>;
values: () => ArrayIterator<Request.Entry<A & A2>>;
includes: (searchElement: Request.Entry<A & A2>, fromIndex?: number) => boolean;
flatMap: (callback: (this: This, value: Request.Entry<A & A2>, index: number, array: Array<Request.Entry<A & A2>>) => U | ReadonlyArray<U>, thisArg?: This | undefined) => Array<U>;
flat: (this: A, depth?: D | undefined) => Array<FlatArray<A, D>>;
at: (index: number) => Request.Entry<A & A2> | undefined;
findLast: { (predicate: (value: Request.Entry<A & A2>, index: number, array: Array<Request.Entry<A & A2>>) => value is S, thisArg?: any): S | undefined; (predicate: (value: Request.Entry<A & A2>, index: number, array: Array<Request.Entry<A & A2>>) =…;
findLastIndex: (predicate: (value: Request.Entry<A & A2>, index: number, array: Array<Request.Entry<A & A2>>) => unknown, thisArg?: any) => number;
toReversed: () => Array<Request.Entry<A & A2>>;
toSorted: (compareFn?: ((a: Request.Entry<A & A2>, b: Request.Entry<A & A2>) => number) | undefined) => Array<Request.Entry<A & A2>>;
toSpliced: { (start: number, deleteCount: number, ...items: Array<Request.Entry<A & A2>>): Array<Request.Entry<A & A2>>; (start: number, deleteCount?: number): Array<Request.Entry<A & A2>> };
with: (index: number, value: Request.Entry<A & A2>) => Array<Request.Entry<A & A2>>;
}
key: unknownkey) => import effecteffect.const race: {
<A2, E2, R2>(
that: Effect.Effect<A2, E2, R2>,
options?: {
readonly onWinner?: (options: {
readonly fiber: Fiber.Fiber<any, any>
readonly index: number
readonly parentFiber: Fiber.Fiber<
any,
any
>
}) => void
}
): <A, E, R>(
self: Effect.Effect<A, E, R>
) => Effect.Effect<A | A2, E | E2, R | R2>
<A, E, R, A2, E2, R2>(
self: Effect.Effect<A, E, R>,
that: Effect.Effect<A2, E2, R2>,
options?: {
readonly onWinner?: (options: {
readonly fiber: Fiber.Fiber<any, any>
readonly index: number
readonly parentFiber: Fiber.Fiber<
any,
any
>
}) => void
}
): Effect.Effect<A | A2, E | E2, R | R2>
}
self: RequestResolver<A>(parameter) self: {
delay: Effect.Effect<void>;
batchKey: (entry: Request.Entry<A>) => unknown;
preCheck: ((entry: Request.Entry<A>) => boolean) | undefined;
collectWhile: (entries: ReadonlySet<Request.Entry<A>>) => boolean;
runAll: (entries: [Request.Entry<A>, ...Request.Entry<A>[]], key: unknown) => Effect.Effect<void, Request.Error<A>, never>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
RequestResolver<A>.runAll(entries: NonEmptyArray<Request.Entry<A>>, key: unknown): Effect.Effect<void, Request.Error<A>>Execute a collection of requests.
runAll(requests: NonEmptyArray<Request.Entry<A>>(parameter) requests: {
0: Request.Entry<A & A2>;
length: number;
toString: () => string;
toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string };
pop: () => Request.Entry<A & A2> | undefined;
push: (...items: Array<Request.Entry<A & A2>>) => number;
concat: { (...items: Array<ConcatArray<Request.Entry<A & A2>>>): Array<Request.Entry<A & A2>>; (...items: Array<Request.Entry<A & A2> | ConcatArray<Request.Entry<A & A2>>>): Array<Request.Entry<A & A2>> };
join: (separator?: string) => string;
reverse: () => Array<Request.Entry<A & A2>>;
shift: () => Request.Entry<A & A2> | undefined;
slice: (start?: number, end?: number) => Array<Request.Entry<A & A2>>;
sort: (compareFn?: ((a: Request.Entry<A & A2>, b: Request.Entry<A & A2>) => number) | undefined) => [Request.Entry<A & A2>, ...Request.Entry<A & A2>[]];
splice: { (start: number, deleteCount?: number): Array<Request.Entry<A & A2>>; (start: number, deleteCount: number, ...items: Array<Request.Entry<A & A2>>): Array<Request.Entry<A & A2>> };
unshift: (...items: Array<Request.Entry<A & A2>>) => number;
indexOf: (searchElement: Request.Entry<A & A2>, fromIndex?: number) => number;
lastIndexOf: (searchElement: Request.Entry<A & A2>, fromIndex?: number) => number;
every: { (predicate: (value: Request.Entry<A & A2>, index: number, array: Array<Request.Entry<A & A2>>) => value is S, thisArg?: any): this is S[]; (predicate: (value: Request.Entry<A & A2>, index: number, array: Array<Request.Entry<A & A2>>) => …;
some: (predicate: (value: Request.Entry<A & A2>, index: number, array: Array<Request.Entry<A & A2>>) => unknown, thisArg?: any) => boolean;
forEach: (callbackfn: (value: Request.Entry<A & A2>, index: number, array: Array<Request.Entry<A & A2>>) => void, thisArg?: any) => void;
map: (callbackfn: (value: Request.Entry<A & A2>, index: number, array: Array<Request.Entry<A & A2>>) => U, thisArg?: any) => Array<U>;
filter: { (predicate: (value: Request.Entry<A & A2>, index: number, array: Array<Request.Entry<A & A2>>) => value is S, thisArg?: any): Array<S>; (predicate: (value: Request.Entry<A & A2>, index: number, array: Array<Request.Entry<A & A2>>) => unk…;
reduce: { (callbackfn: (previousValue: Request.Entry<A & A2>, currentValue: Request.Entry<A & A2>, currentIndex: number, array: Array<Request.Entry<A & A2>>) => Request.Entry<A & A2>): Request.Entry<A & A2>; (callbackfn: (previousValue: Request.En…;
reduceRight: { (callbackfn: (previousValue: Request.Entry<A & A2>, currentValue: Request.Entry<A & A2>, currentIndex: number, array: Array<Request.Entry<A & A2>>) => Request.Entry<A & A2>): Request.Entry<A & A2>; (callbackfn: (previousValue: Request.En…;
find: { (predicate: (value: Request.Entry<A & A2>, index: number, obj: Array<Request.Entry<A & A2>>) => value is S, thisArg?: any): S | undefined; (predicate: (value: Request.Entry<A & A2>, index: number, obj: Array<Request.Entry<A & A2>>) => un…;
findIndex: (predicate: (value: Request.Entry<A & A2>, index: number, obj: Array<Request.Entry<A & A2>>) => unknown, thisArg?: any) => number;
fill: (value: Request.Entry<A & A2>, start?: number, end?: number) => [Request.Entry<A & A2>, ...Request.Entry<A & A2>[]];
copyWithin: (target: number, start: number, end?: number) => [Request.Entry<A & A2>, ...Request.Entry<A & A2>[]];
entries: () => ArrayIterator<[number, Request.Entry<A & A2>]>;
keys: () => ArrayIterator<number>;
values: () => ArrayIterator<Request.Entry<A & A2>>;
includes: (searchElement: Request.Entry<A & A2>, fromIndex?: number) => boolean;
flatMap: (callback: (this: This, value: Request.Entry<A & A2>, index: number, array: Array<Request.Entry<A & A2>>) => U | ReadonlyArray<U>, thisArg?: This | undefined) => Array<U>;
flat: (this: A, depth?: D | undefined) => Array<FlatArray<A, D>>;
at: (index: number) => Request.Entry<A & A2> | undefined;
findLast: { (predicate: (value: Request.Entry<A & A2>, index: number, array: Array<Request.Entry<A & A2>>) => value is S, thisArg?: any): S | undefined; (predicate: (value: Request.Entry<A & A2>, index: number, array: Array<Request.Entry<A & A2>>) =…;
findLastIndex: (predicate: (value: Request.Entry<A & A2>, index: number, array: Array<Request.Entry<A & A2>>) => unknown, thisArg?: any) => number;
toReversed: () => Array<Request.Entry<A & A2>>;
toSorted: (compareFn?: ((a: Request.Entry<A & A2>, b: Request.Entry<A & A2>) => number) | undefined) => Array<Request.Entry<A & A2>>;
toSpliced: { (start: number, deleteCount: number, ...items: Array<Request.Entry<A & A2>>): Array<Request.Entry<A & A2>>; (start: number, deleteCount?: number): Array<Request.Entry<A & A2>> };
with: (index: number, value: Request.Entry<A & A2>) => Array<Request.Entry<A & A2>>;
}
key: unknownkey), that: RequestResolver<A2>(parameter) that: {
delay: Effect.Effect<void>;
batchKey: (entry: Request.Entry<A2>) => unknown;
preCheck: ((entry: Request.Entry<A>) => boolean) | undefined;
collectWhile: (entries: ReadonlySet<Request.Entry<A2>>) => boolean;
runAll: (entries: [Request.Entry<A2>, ...Request.Entry<A2>[]], key: unknown) => Effect.Effect<void, Request.Error<A2>, never>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
RequestResolver<A2>.runAll(entries: NonEmptyArray<Request.Entry<A2>>, key: unknown): Effect.Effect<void, Request.Error<A2>>Execute a collection of requests.
runAll(requests: NonEmptyArray<Request.Entry<A>>(parameter) requests: {
0: Request.Entry<A & A2>;
length: number;
toString: () => string;
toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string };
pop: () => Request.Entry<A & A2> | undefined;
push: (...items: Array<Request.Entry<A & A2>>) => number;
concat: { (...items: Array<ConcatArray<Request.Entry<A & A2>>>): Array<Request.Entry<A & A2>>; (...items: Array<Request.Entry<A & A2> | ConcatArray<Request.Entry<A & A2>>>): Array<Request.Entry<A & A2>> };
join: (separator?: string) => string;
reverse: () => Array<Request.Entry<A & A2>>;
shift: () => Request.Entry<A & A2> | undefined;
slice: (start?: number, end?: number) => Array<Request.Entry<A & A2>>;
sort: (compareFn?: ((a: Request.Entry<A & A2>, b: Request.Entry<A & A2>) => number) | undefined) => [Request.Entry<A & A2>, ...Request.Entry<A & A2>[]];
splice: { (start: number, deleteCount?: number): Array<Request.Entry<A & A2>>; (start: number, deleteCount: number, ...items: Array<Request.Entry<A & A2>>): Array<Request.Entry<A & A2>> };
unshift: (...items: Array<Request.Entry<A & A2>>) => number;
indexOf: (searchElement: Request.Entry<A & A2>, fromIndex?: number) => number;
lastIndexOf: (searchElement: Request.Entry<A & A2>, fromIndex?: number) => number;
every: { (predicate: (value: Request.Entry<A & A2>, index: number, array: Array<Request.Entry<A & A2>>) => value is S, thisArg?: any): this is S[]; (predicate: (value: Request.Entry<A & A2>, index: number, array: Array<Request.Entry<A & A2>>) => …;
some: (predicate: (value: Request.Entry<A & A2>, index: number, array: Array<Request.Entry<A & A2>>) => unknown, thisArg?: any) => boolean;
forEach: (callbackfn: (value: Request.Entry<A & A2>, index: number, array: Array<Request.Entry<A & A2>>) => void, thisArg?: any) => void;
map: (callbackfn: (value: Request.Entry<A & A2>, index: number, array: Array<Request.Entry<A & A2>>) => U, thisArg?: any) => Array<U>;
filter: { (predicate: (value: Request.Entry<A & A2>, index: number, array: Array<Request.Entry<A & A2>>) => value is S, thisArg?: any): Array<S>; (predicate: (value: Request.Entry<A & A2>, index: number, array: Array<Request.Entry<A & A2>>) => unk…;
reduce: { (callbackfn: (previousValue: Request.Entry<A & A2>, currentValue: Request.Entry<A & A2>, currentIndex: number, array: Array<Request.Entry<A & A2>>) => Request.Entry<A & A2>): Request.Entry<A & A2>; (callbackfn: (previousValue: Request.En…;
reduceRight: { (callbackfn: (previousValue: Request.Entry<A & A2>, currentValue: Request.Entry<A & A2>, currentIndex: number, array: Array<Request.Entry<A & A2>>) => Request.Entry<A & A2>): Request.Entry<A & A2>; (callbackfn: (previousValue: Request.En…;
find: { (predicate: (value: Request.Entry<A & A2>, index: number, obj: Array<Request.Entry<A & A2>>) => value is S, thisArg?: any): S | undefined; (predicate: (value: Request.Entry<A & A2>, index: number, obj: Array<Request.Entry<A & A2>>) => un…;
findIndex: (predicate: (value: Request.Entry<A & A2>, index: number, obj: Array<Request.Entry<A & A2>>) => unknown, thisArg?: any) => number;
fill: (value: Request.Entry<A & A2>, start?: number, end?: number) => [Request.Entry<A & A2>, ...Request.Entry<A & A2>[]];
copyWithin: (target: number, start: number, end?: number) => [Request.Entry<A & A2>, ...Request.Entry<A & A2>[]];
entries: () => ArrayIterator<[number, Request.Entry<A & A2>]>;
keys: () => ArrayIterator<number>;
values: () => ArrayIterator<Request.Entry<A & A2>>;
includes: (searchElement: Request.Entry<A & A2>, fromIndex?: number) => boolean;
flatMap: (callback: (this: This, value: Request.Entry<A & A2>, index: number, array: Array<Request.Entry<A & A2>>) => U | ReadonlyArray<U>, thisArg?: This | undefined) => Array<U>;
flat: (this: A, depth?: D | undefined) => Array<FlatArray<A, D>>;
at: (index: number) => Request.Entry<A & A2> | undefined;
findLast: { (predicate: (value: Request.Entry<A & A2>, index: number, array: Array<Request.Entry<A & A2>>) => value is S, thisArg?: any): S | undefined; (predicate: (value: Request.Entry<A & A2>, index: number, array: Array<Request.Entry<A & A2>>) =…;
findLastIndex: (predicate: (value: Request.Entry<A & A2>, index: number, array: Array<Request.Entry<A & A2>>) => unknown, thisArg?: any) => number;
toReversed: () => Array<Request.Entry<A & A2>>;
toSorted: (compareFn?: ((a: Request.Entry<A & A2>, b: Request.Entry<A & A2>) => number) | undefined) => Array<Request.Entry<A & A2>>;
toSpliced: { (start: number, deleteCount: number, ...items: Array<Request.Entry<A & A2>>): Array<Request.Entry<A & A2>>; (start: number, deleteCount?: number): Array<Request.Entry<A & A2>> };
with: (index: number, value: Request.Entry<A & A2>) => Array<Request.Entry<A & A2>>;
}
key: unknownkey))
))