<A extends Request.Any>(options: {
readonly capacity: number
readonly strategy?: "lru" | "fifo" | undefined
}): (self: RequestResolver<A>) => Effect.Effect<RequestResolver<A>>
<A extends Request.Any>(
self: RequestResolver<A>,
options: {
readonly capacity: number
readonly strategy?: "lru" | "fifo" | undefined
}
): Effect.Effect<RequestResolver<A>>Adds a bounded in-memory cache to a request resolver.
When to use
Use to reuse completed results for repeated equal request values while still
passing a RequestResolver to Effect.request.
Details
Running the returned effect creates the cache and returns a wrapped resolver.
The cache stores completed success or failure results by request equality up
to capacity. The strategy option controls eviction order and defaults to
"lru"; "fifo" keeps insertion order.
Gotchas
Entries do not expire by time, and completed failures are cached the same as successes. Request equality controls cache hits.
Source effect/RequestResolver.ts:107764 lines
export const const withCache: {
<A extends Request.Any>(options: {
readonly capacity: number
readonly strategy?: "lru" | "fifo" | undefined
}): (
self: RequestResolver<A>
) => Effect.Effect<RequestResolver<A>>
<A extends Request.Any>(
self: RequestResolver<A>,
options: {
readonly capacity: number
readonly strategy?:
| "lru"
| "fifo"
| undefined
}
): Effect.Effect<RequestResolver<A>>
}
Adds a bounded in-memory cache to a request resolver.
When to use
Use to reuse completed results for repeated equal request values while still
passing a RequestResolver to Effect.request.
Details
Running the returned effect creates the cache and returns a wrapped resolver.
The cache stores completed success or failure results by request equality up
to capacity. The strategy option controls eviction order and defaults to
"lru"; "fifo" keeps insertion order.
Gotchas
Entries do not expire by time, and completed failures are cached the same as
successes. Request equality controls cache hits.
withCache: {
<function (type parameter) A in <A extends Request.Any>(options: {
readonly capacity: number;
readonly strategy?: "lru" | "fifo" | undefined;
}): (self: RequestResolver<A>) => Effect.Effect<RequestResolver<A>>
import RequestRequest.type Request.Any = /*unresolved*/ anyAny>(options: {
readonly capacity: number
readonly strategy?: "lru" | "fifo" | undefined
}
capacity: numbercapacity: number
readonly strategy?: "lru" | "fifo" | undefinedstrategy?: "lru" | "fifo" | undefined
}): (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>(options: {
readonly capacity: number;
readonly strategy?: "lru" | "fifo" | undefined;
}): (self: RequestResolver<A>) => Effect.Effect<RequestResolver<A>>
import EffectEffect.type Effect.Effect = /*unresolved*/ anyEffect<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>(options: {
readonly capacity: number;
readonly strategy?: "lru" | "fifo" | undefined;
}): (self: RequestResolver<A>) => Effect.Effect<RequestResolver<A>>
function (type parameter) A in <A extends Request.Any>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly strategy?: "lru" | "fifo" | undefined;
}): Effect.Effect<RequestResolver<A>>
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>, options: {
readonly capacity: number;
readonly strategy?: "lru" | "fifo" | undefined;
}): Effect.Effect<RequestResolver<A>>
options: {
readonly capacity: number
readonly strategy?: "lru" | "fifo" | undefined
}
capacity: numbercapacity: number
readonly strategy?: "lru" | "fifo" | undefinedstrategy?: "lru" | "fifo" | undefined
}): import EffectEffect.type Effect.Effect = /*unresolved*/ anyEffect<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>, options: {
readonly capacity: number;
readonly strategy?: "lru" | "fifo" | undefined;
}): Effect.Effect<RequestResolver<A>>
import dualdual(2, <function (type parameter) A in <A extends Request.Any>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly strategy?: "lru" | "fifo" | undefined;
}): Effect.Effect<RequestResolver<A>>
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>, options: {
readonly capacity: number;
readonly strategy?: "lru" | "fifo" | undefined;
}): Effect.Effect<RequestResolver<A>>
options: {
readonly capacity: number
readonly strategy?: "lru" | "fifo" | undefined
}
capacity: numbercapacity: number
readonly strategy?: "lru" | "fifo" | undefinedstrategy?: "lru" | "fifo" | undefined
}): import EffectEffect.type Effect.Effect = /*unresolved*/ anyEffect<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>, options: {
readonly capacity: number;
readonly strategy?: "lru" | "fifo" | undefined;
}): Effect.Effect<RequestResolver<A>>
import EffectEffect.sync(() => {
const const strategy: "lru" | "fifo"strategy = options: {
readonly capacity: number
readonly strategy?: "lru" | "fifo" | undefined
}
strategy?: "lru" | "fifo" | undefinedstrategy ?? "lru"
const const cache: MutableHashMap.MutableHashMap<
A,
{
readonly entry: Request.Entry<A>
exit: Request.Result<A> | undefined
}
>
const cache: {
backing: Map<K, V>;
buckets: Map<number, NonEmptyArray<K>>;
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; <…;
toString: () => string;
toJSON: () => unknown;
}
import MutableHashMapMutableHashMap.empty<function (type parameter) A in <A extends Request.Any>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly strategy?: "lru" | "fifo" | undefined;
}): Effect.Effect<RequestResolver<A>>
entry: Request.Entry<A>(property) entry: {
request: R;
context: Context.Context<[R] extends [Request<infer _A, infer _E, infer _R>] ? _R : never>;
uninterruptible: boolean;
completeUnsafe: (exit: Exit.Exit<[A] extends [Request.Request<infer _A, infer _E, infer _R>] ? _A : never, [A] extends [Request.Request<infer _A, infer _E, infer _R>] ? _E : never>) => void;
}
import RequestRequest.type Request.Entry = /*unresolved*/ anyEntry<function (type parameter) A in <A extends Request.Any>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly strategy?: "lru" | "fifo" | undefined;
}): Effect.Effect<RequestResolver<A>>
exit: Request.Result<A> | undefinedexit: import RequestRequest.type Request.Result = /*unresolved*/ anyResult<function (type parameter) A in <A extends Request.Any>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly strategy?: "lru" | "fifo" | undefined;
}): Effect.Effect<RequestResolver<A>>
const makeWith: <
A extends Request.Any
>(options: {
readonly batchKey: (
request: Request.Entry<A>
) => unknown
readonly preCheck?:
| ((entry: Request.Entry<A>) => boolean)
| undefined
readonly delay: Effect.Effect<void>
readonly collectWhile: (
requests: ReadonlySet<Request.Entry<A>>
) => boolean
readonly runAll: (
entries: NonEmptyArray<Request.Entry<A>>,
key: unknown
) => Effect.Effect<void, Request.Error<A>>
}) => RequestResolver<A>
Creates a request resolver with fine-grained
control over its behavior.
When to use
Use when you need to supply the resolver batching primitives directly,
including the batch key, optional pre-check, delay effect, collection cutoff,
and batch runner.
Details
batchKey groups request entries, delay schedules batch execution,
collectWhile can end collection early, and runAll receives a non-empty
batch for one key.
Gotchas
Accepted entries must be completed. If runAll succeeds with incomplete
entries, waiting requests fail. If preCheck returns false, the entry is
not batched, so it must be completed or linked to another completion path.
makeWith({
...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; <…;
}
runAll: (
entries: NonEmptyArray<
Request.Entry<Request.Any>
>,
key: unknown
) => Effect.Effect<
void,
Request.Error<Request.Any>
>
entries: NonEmptyArray<Request.Entry<A>>(parameter) entries: {
0: Request.Entry<A>;
length: number;
toString: () => string;
toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string };
pop: () => Request.Entry<A> | undefined;
push: (...items: Array<Request.Entry<A>>) => number;
concat: { (...items: Array<ConcatArray<Request.Entry<A>>>): Array<Request.Entry<A>>; (...items: Array<Request.Entry<A> | ConcatArray<Request.Entry<A>>>): Array<Request.Entry<A>> };
join: (separator?: string) => string;
reverse: () => Array<Request.Entry<A>>;
shift: () => Request.Entry<A> | undefined;
slice: (start?: number, end?: number) => Array<Request.Entry<A>>;
sort: (compareFn?: ((a: Request.Entry<A>, b: Request.Entry<A>) => number) | undefined) => [Request.Entry<A>, ...Request.Entry<A>[]];
splice: { (start: number, deleteCount?: number): Array<Request.Entry<A>>; (start: number, deleteCount: number, ...items: Array<Request.Entry<A>>): Array<Request.Entry<A>> };
unshift: (...items: Array<Request.Entry<A>>) => number;
indexOf: (searchElement: Request.Entry<A>, fromIndex?: number) => number;
lastIndexOf: (searchElement: Request.Entry<A>, fromIndex?: number) => number;
every: { (predicate: (value: Request.Entry<A>, index: number, array: Array<Request.Entry<A>>) => value is S, thisArg?: any): this is S[]; (predicate: (value: Request.Entry<A>, index: number, array: Array<Request.Entry<A>>) => unknown, thisArg?: a…;
some: (predicate: (value: Request.Entry<A>, index: number, array: Array<Request.Entry<A>>) => unknown, thisArg?: any) => boolean;
forEach: (callbackfn: (value: Request.Entry<A>, index: number, array: Array<Request.Entry<A>>) => void, thisArg?: any) => void;
map: (callbackfn: (value: Request.Entry<A>, index: number, array: Array<Request.Entry<A>>) => U, thisArg?: any) => Array<U>;
filter: { (predicate: (value: Request.Entry<A>, index: number, array: Array<Request.Entry<A>>) => value is S, thisArg?: any): Array<S>; (predicate: (value: Request.Entry<A>, index: number, array: Array<Request.Entry<A>>) => unknown, thisArg?: any)…;
reduce: { (callbackfn: (previousValue: Request.Entry<A>, currentValue: Request.Entry<A>, currentIndex: number, array: Array<Request.Entry<A>>) => Request.Entry<A>): Request.Entry<A>; (callbackfn: (previousValue: Request.Entry<A>, currentValue: Req…;
reduceRight: { (callbackfn: (previousValue: Request.Entry<A>, currentValue: Request.Entry<A>, currentIndex: number, array: Array<Request.Entry<A>>) => Request.Entry<A>): Request.Entry<A>; (callbackfn: (previousValue: Request.Entry<A>, currentValue: Req…;
find: { (predicate: (value: Request.Entry<A>, index: number, obj: Array<Request.Entry<A>>) => value is S, thisArg?: any): S | undefined; (predicate: (value: Request.Entry<A>, index: number, obj: Array<Request.Entry<A>>) => unknown, thisArg?: any…;
findIndex: (predicate: (value: Request.Entry<A>, index: number, obj: Array<Request.Entry<A>>) => unknown, thisArg?: any) => number;
fill: (value: Request.Entry<A>, start?: number, end?: number) => [Request.Entry<A>, ...Request.Entry<A>[]];
copyWithin: (target: number, start: number, end?: number) => [Request.Entry<A>, ...Request.Entry<A>[]];
entries: () => ArrayIterator<[number, Request.Entry<A>]>;
keys: () => ArrayIterator<number>;
values: () => ArrayIterator<Request.Entry<A>>;
includes: (searchElement: Request.Entry<A>, fromIndex?: number) => boolean;
flatMap: (callback: (this: This, value: Request.Entry<A>, index: number, array: Array<Request.Entry<A>>) => U | ReadonlyArray<U>, thisArg?: This | undefined) => Array<U>;
flat: (this: A, depth?: D | undefined) => Array<FlatArray<A, D>>;
at: (index: number) => Request.Entry<A> | undefined;
findLast: { (predicate: (value: Request.Entry<A>, index: number, array: Array<Request.Entry<A>>) => value is S, thisArg?: any): S | undefined; (predicate: (value: Request.Entry<A>, index: number, array: Array<Request.Entry<A>>) => unknown, thisArg?:…;
findLastIndex: (predicate: (value: Request.Entry<A>, index: number, array: Array<Request.Entry<A>>) => unknown, thisArg?: any) => number;
toReversed: () => Array<Request.Entry<A>>;
toSorted: (compareFn?: ((a: Request.Entry<A>, b: Request.Entry<A>) => number) | undefined) => Array<Request.Entry<A>>;
toSpliced: { (start: number, deleteCount: number, ...items: Array<Request.Entry<A>>): Array<Request.Entry<A>>; (start: number, deleteCount?: number): Array<Request.Entry<A>> };
with: (index: number, value: Request.Entry<A>) => Array<Request.Entry<A>>;
}
key: unknownkey) {
return import EffectEffect.onExit(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(entries: NonEmptyArray<Request.Entry<A>>(parameter) entries: {
0: Request.Entry<A>;
length: number;
toString: () => string;
toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string };
pop: () => Request.Entry<A> | undefined;
push: (...items: Array<Request.Entry<A>>) => number;
concat: { (...items: Array<ConcatArray<Request.Entry<A>>>): Array<Request.Entry<A>>; (...items: Array<Request.Entry<A> | ConcatArray<Request.Entry<A>>>): Array<Request.Entry<A>> };
join: (separator?: string) => string;
reverse: () => Array<Request.Entry<A>>;
shift: () => Request.Entry<A> | undefined;
slice: (start?: number, end?: number) => Array<Request.Entry<A>>;
sort: (compareFn?: ((a: Request.Entry<A>, b: Request.Entry<A>) => number) | undefined) => [Request.Entry<A>, ...Request.Entry<A>[]];
splice: { (start: number, deleteCount?: number): Array<Request.Entry<A>>; (start: number, deleteCount: number, ...items: Array<Request.Entry<A>>): Array<Request.Entry<A>> };
unshift: (...items: Array<Request.Entry<A>>) => number;
indexOf: (searchElement: Request.Entry<A>, fromIndex?: number) => number;
lastIndexOf: (searchElement: Request.Entry<A>, fromIndex?: number) => number;
every: { (predicate: (value: Request.Entry<A>, index: number, array: Array<Request.Entry<A>>) => value is S, thisArg?: any): this is S[]; (predicate: (value: Request.Entry<A>, index: number, array: Array<Request.Entry<A>>) => unknown, thisArg?: a…;
some: (predicate: (value: Request.Entry<A>, index: number, array: Array<Request.Entry<A>>) => unknown, thisArg?: any) => boolean;
forEach: (callbackfn: (value: Request.Entry<A>, index: number, array: Array<Request.Entry<A>>) => void, thisArg?: any) => void;
map: (callbackfn: (value: Request.Entry<A>, index: number, array: Array<Request.Entry<A>>) => U, thisArg?: any) => Array<U>;
filter: { (predicate: (value: Request.Entry<A>, index: number, array: Array<Request.Entry<A>>) => value is S, thisArg?: any): Array<S>; (predicate: (value: Request.Entry<A>, index: number, array: Array<Request.Entry<A>>) => unknown, thisArg?: any)…;
reduce: { (callbackfn: (previousValue: Request.Entry<A>, currentValue: Request.Entry<A>, currentIndex: number, array: Array<Request.Entry<A>>) => Request.Entry<A>): Request.Entry<A>; (callbackfn: (previousValue: Request.Entry<A>, currentValue: Req…;
reduceRight: { (callbackfn: (previousValue: Request.Entry<A>, currentValue: Request.Entry<A>, currentIndex: number, array: Array<Request.Entry<A>>) => Request.Entry<A>): Request.Entry<A>; (callbackfn: (previousValue: Request.Entry<A>, currentValue: Req…;
find: { (predicate: (value: Request.Entry<A>, index: number, obj: Array<Request.Entry<A>>) => value is S, thisArg?: any): S | undefined; (predicate: (value: Request.Entry<A>, index: number, obj: Array<Request.Entry<A>>) => unknown, thisArg?: any…;
findIndex: (predicate: (value: Request.Entry<A>, index: number, obj: Array<Request.Entry<A>>) => unknown, thisArg?: any) => number;
fill: (value: Request.Entry<A>, start?: number, end?: number) => [Request.Entry<A>, ...Request.Entry<A>[]];
copyWithin: (target: number, start: number, end?: number) => [Request.Entry<A>, ...Request.Entry<A>[]];
entries: () => ArrayIterator<[number, Request.Entry<A>]>;
keys: () => ArrayIterator<number>;
values: () => ArrayIterator<Request.Entry<A>>;
includes: (searchElement: Request.Entry<A>, fromIndex?: number) => boolean;
flatMap: (callback: (this: This, value: Request.Entry<A>, index: number, array: Array<Request.Entry<A>>) => U | ReadonlyArray<U>, thisArg?: This | undefined) => Array<U>;
flat: (this: A, depth?: D | undefined) => Array<FlatArray<A, D>>;
at: (index: number) => Request.Entry<A> | undefined;
findLast: { (predicate: (value: Request.Entry<A>, index: number, array: Array<Request.Entry<A>>) => value is S, thisArg?: any): S | undefined; (predicate: (value: Request.Entry<A>, index: number, array: Array<Request.Entry<A>>) => unknown, thisArg?:…;
findLastIndex: (predicate: (value: Request.Entry<A>, index: number, array: Array<Request.Entry<A>>) => unknown, thisArg?: any) => number;
toReversed: () => Array<Request.Entry<A>>;
toSorted: (compareFn?: ((a: Request.Entry<A>, b: Request.Entry<A>) => number) | undefined) => Array<Request.Entry<A>>;
toSpliced: { (start: number, deleteCount: number, ...items: Array<Request.Entry<A>>): Array<Request.Entry<A>>; (start: number, deleteCount?: number): Array<Request.Entry<A>> };
with: (index: number, value: Request.Entry<A>) => Array<Request.Entry<A>>;
}
key: unknownkey), () => {
let let toRemove: numbertoRemove = import MutableHashMapMutableHashMap.size(const cache: MutableHashMap.MutableHashMap<
A,
{
readonly entry: Request.Entry<A>
exit: Request.Result<A> | undefined
}
>
const cache: {
backing: Map<K, V>;
buckets: Map<number, NonEmptyArray<K>>;
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; <…;
toString: () => string;
toJSON: () => unknown;
}
options: {
readonly capacity: number
readonly strategy?: "lru" | "fifo" | undefined
}
capacity: numbercapacity
if (let toRemove: numbertoRemove <= 0) return import EffectEffect.void
for (const const k: anyk of import MutableHashMapMutableHashMap.keys(const cache: MutableHashMap.MutableHashMap<
A,
{
readonly entry: Request.Entry<A>
exit: Request.Result<A> | undefined
}
>
const cache: {
backing: Map<K, V>;
buckets: Map<number, NonEmptyArray<K>>;
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; <…;
toString: () => string;
toJSON: () => unknown;
}
import MutableHashMapMutableHashMap.remove(const cache: MutableHashMap.MutableHashMap<
A,
{
readonly entry: Request.Entry<A>
exit: Request.Result<A> | undefined
}
>
const cache: {
backing: Map<K, V>;
buckets: Map<number, NonEmptyArray<K>>;
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; <…;
toString: () => string;
toJSON: () => unknown;
}
const k: anyk)
let toRemove: numbertoRemove--
if (let toRemove: numbertoRemove <= 0) break
}
return import EffectEffect.void
})
},
preCheck?: | ((
entry: Request.Entry<Request.Any>
) => boolean)
| undefined
entry: Request.Entry<A>(parameter) entry: {
request: R;
context: Context.Context<[R] extends [Request<infer _A, infer _E, infer _R>] ? _R : never>;
uninterruptible: boolean;
completeUnsafe: (exit: Exit.Exit<[A] extends [Request.Request<infer _A, infer _E, infer _R>] ? _A : never, [A] extends [Request.Request<infer _A, infer _E, infer _R>] ? _E : never>) => void;
}
const ocached: Option<{
readonly entry: Request.Entry<A>
exit: Request.Result<A> | undefined
}>
import MutableHashMapMutableHashMap.get(const cache: MutableHashMap.MutableHashMap<
A,
{
readonly entry: Request.Entry<A>
exit: Request.Result<A> | undefined
}
>
const cache: {
backing: Map<K, V>;
buckets: Map<number, NonEmptyArray<K>>;
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; <…;
toString: () => string;
toJSON: () => unknown;
}
entry: Request.Entry<A>(parameter) entry: {
request: R;
context: Context.Context<[R] extends [Request<infer _A, infer _E, infer _R>] ? _R : never>;
uninterruptible: boolean;
completeUnsafe: (exit: Exit.Exit<[A] extends [Request.Request<infer _A, infer _E, infer _R>] ? _A : never, [A] extends [Request.Request<infer _A, infer _E, infer _R>] ? _E : never>) => void;
}
const ocached: Option<{
readonly entry: Request.Entry<A>
exit: Request.Result<A> | undefined
}>
const cached: {
entry: Request.Entry<A>
exit: Request.Result<A> | undefined
}
entry: Request.Entry<A>(property) entry: {
request: R;
context: Context.Context<[R] extends [Request<infer _A, infer _E, infer _R>] ? _R : never>;
uninterruptible: boolean;
completeUnsafe: (exit: Exit.Exit<[A] extends [Request.Request<infer _A, infer _E, infer _R>] ? _A : never, [A] extends [Request.Request<infer _A, infer _E, infer _R>] ? _E : never>) => void;
}
exit: anyexit: var undefinedundefined as import RequestRequest.type Request.Result = /*unresolved*/ anyResult<function (type parameter) A in <A extends Request.Any>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly strategy?: "lru" | "fifo" | undefined;
}): Effect.Effect<RequestResolver<A>>
import MutableHashMapMutableHashMap.set(const cache: MutableHashMap.MutableHashMap<
A,
{
readonly entry: Request.Entry<A>
exit: Request.Result<A> | undefined
}
>
const cache: {
backing: Map<K, V>;
buckets: Map<number, NonEmptyArray<K>>;
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; <…;
toString: () => string;
toJSON: () => unknown;
}
entry: Request.Entry<A>(parameter) entry: {
request: R;
context: Context.Context<[R] extends [Request<infer _A, infer _E, infer _R>] ? _R : never>;
uninterruptible: boolean;
completeUnsafe: (exit: Exit.Exit<[A] extends [Request.Request<infer _A, infer _E, infer _R>] ? _A : never, [A] extends [Request.Request<infer _A, infer _E, infer _R>] ? _E : never>) => void;
}
const cached: {
entry: Request.Entry<A>
exit: Request.Result<A> | undefined
}
const prevComplete: anyprevComplete = entry: Request.Entry<A>(parameter) entry: {
request: R;
context: Context.Context<[R] extends [Request<infer _A, infer _E, infer _R>] ? _R : never>;
uninterruptible: boolean;
completeUnsafe: (exit: Exit.Exit<[A] extends [Request.Request<infer _A, infer _E, infer _R>] ? _A : never, [A] extends [Request.Request<infer _A, infer _E, infer _R>] ? _E : never>) => void;
}
entry: Request.Entry<A>(parameter) entry: {
request: R;
context: Context.Context<[R] extends [Request<infer _A, infer _E, infer _R>] ? _R : never>;
uninterruptible: boolean;
completeUnsafe: (exit: Exit.Exit<[A] extends [Request.Request<infer _A, infer _E, infer _R>] ? _A : never, [A] extends [Request.Request<infer _A, infer _E, infer _R>] ? _E : never>) => void;
}
exit: Exit.Exit<
[A] extends [
Request.Request<infer _A, infer _E, infer _R>
]
? _A
: never,
[A] extends [
Request.Request<infer _A, infer _E, infer _R>
]
? _E
: never
>
const cached: {
entry: Request.Entry<A>
exit: Request.Result<A> | undefined
}
exit: anyexit = exit: Exit.Exit<
[A] extends [
Request.Request<infer _A, infer _E, infer _R>
]
? _A
: never,
[A] extends [
Request.Request<infer _A, infer _E, infer _R>
]
? _E
: never
>
const prevComplete: anyprevComplete(exit: Exit.Exit<
[A] extends [
Request.Request<infer _A, infer _E, infer _R>
]
? _A
: never,
[A] extends [
Request.Request<infer _A, infer _E, infer _R>
]
? _E
: never
>
const cached: {
readonly entry: Request.Entry<A>
exit: Request.Result<A> | undefined
}
const cached: {
entry: Request.Entry<A>;
exit: Request.Result<A> | undefined;
}
const ocached: Some<{
readonly entry: Request.Entry<A>
exit: Request.Result<A> | undefined
}>
const ocached: {
_tag: "Some";
_op: "Some";
value: A;
valueOrUndefined: A;
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; <…;
toString: () => string;
toJSON: () => unknown;
}
const cached: {
readonly entry: Request.Entry<A>
exit: Request.Result<A> | undefined
}
const cached: {
entry: Request.Entry<A>;
exit: Request.Result<A> | undefined;
}
const strategy: "lru" | "fifo"strategy === "lru") {
import MutableHashMapMutableHashMap.remove(const cache: MutableHashMap.MutableHashMap<
A,
{
readonly entry: Request.Entry<A>
exit: Request.Result<A> | undefined
}
>
const cache: {
backing: Map<K, V>;
buckets: Map<number, NonEmptyArray<K>>;
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; <…;
toString: () => string;
toJSON: () => unknown;
}
const cached: {
readonly entry: Request.Entry<A>
exit: Request.Result<A> | undefined
}
const cached: {
entry: Request.Entry<A>;
exit: Request.Result<A> | undefined;
}
import MutableHashMapMutableHashMap.set(const cache: MutableHashMap.MutableHashMap<
A,
{
readonly entry: Request.Entry<A>
exit: Request.Result<A> | undefined
}
>
const cache: {
backing: Map<K, V>;
buckets: Map<number, NonEmptyArray<K>>;
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; <…;
toString: () => string;
toJSON: () => unknown;
}
const cached: {
readonly entry: Request.Entry<A>
exit: Request.Result<A> | undefined
}
const cached: {
entry: Request.Entry<A>;
exit: Request.Result<A> | undefined;
}
const cached: {
readonly entry: Request.Entry<A>
exit: Request.Result<A> | undefined
}
const cached: {
entry: Request.Entry<A>;
exit: Request.Result<A> | undefined;
}
entry: Request.Entry<A>(parameter) entry: {
request: R;
context: Context.Context<[R] extends [Request<infer _A, infer _E, infer _R>] ? _R : never>;
uninterruptible: boolean;
completeUnsafe: (exit: Exit.Exit<[A] extends [Request.Request<infer _A, infer _E, infer _R>] ? _A : never, [A] extends [Request.Request<infer _A, infer _E, infer _R>] ? _E : never>) => void;
}
const cached: {
readonly entry: Request.Entry<A>
exit: Request.Result<A> | undefined
}
const cached: {
entry: Request.Entry<A>;
exit: Request.Result<A> | undefined;
}
const cached: {
readonly entry: Request.Entry<A>
exit: Request.Result<A> | undefined
}
const cached: {
entry: Request.Entry<A>;
exit: Request.Result<A> | undefined;
}
const prevComplete: anyprevComplete = const cached: {
readonly entry: Request.Entry<A>
exit: Request.Result<A> | undefined
}
const cached: {
entry: Request.Entry<A>;
exit: Request.Result<A> | undefined;
}
const cached: {
readonly entry: Request.Entry<A>
exit: Request.Result<A> | undefined
}
const cached: {
entry: Request.Entry<A>;
exit: Request.Result<A> | undefined;
}
exit: Exit.Exit<
[A] extends [
Request.Request<infer _A, infer _E, infer _R>
]
? _A
: never,
[A] extends [
Request.Request<infer _A, infer _E, infer _R>
]
? _E
: never
>
const prevComplete: anyprevComplete(exit: Exit.Exit<
[A] extends [
Request.Request<infer _A, infer _E, infer _R>
]
? _A
: never,
[A] extends [
Request.Request<infer _A, infer _E, infer _R>
]
? _E
: never
>
entry: Request.Entry<A>(parameter) entry: {
request: R;
context: Context.Context<[R] extends [Request<infer _A, infer _E, infer _R>] ? _R : never>;
uninterruptible: boolean;
completeUnsafe: (exit: Exit.Exit<[A] extends [Request.Request<infer _A, infer _E, infer _R>] ? _A : never, [A] extends [Request.Request<infer _A, infer _E, infer _R>] ? _E : never>) => void;
}
exit: Exit.Exit<
[A] extends [
Request.Request<infer _A, infer _E, infer _R>
]
? _A
: never,
[A] extends [
Request.Request<infer _A, infer _E, infer _R>
]
? _E
: never
>