<A extends Request.Any>(
name: string,
options?:
| Tracer.SpanOptions
| ((entries: NonEmptyArray<Request.Entry<A>>) => Tracer.SpanOptions)
| undefined
): (self: RequestResolver<A>) => RequestResolver<A>
<A extends Request.Any>(
self: RequestResolver<A>,
name: string,
options?:
| Tracer.SpanOptions
| ((entries: NonEmptyArray<Request.Entry<A>>) => Tracer.SpanOptions)
| undefined
): RequestResolver<A>Adds a tracing span to the request resolver, which will also add any span links from the request's.
Example (Adding a tracing span)
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")
const resolver = RequestResolver.make<GetDataRequest>((entries) =>
Effect.sync(() => {
for (const entry of entries) {
entry.completeUnsafe(Exit.succeed(`data-${entry.request.id}`))
}
})
)
// Add tracing span with custom name and attributes
const tracedResolver = RequestResolver.withSpan(
resolver,
"user-data-resolver",
{
attributes: {
"resolver.type": "user-data",
"resolver.version": "1.0"
}
}
)
// Spans will automatically include batch size and request links
const effect = Effect.request(GetDataRequest({ id: 123 }), tracedResolver)combinators
Source effect/RequestResolver.ts:92738 lines
export const const withSpan: {
<A extends Request.Any>(
name: string,
options?:
| Tracer.SpanOptions
| ((
entries: NonEmptyArray<Request.Entry<A>>
) => Tracer.SpanOptions)
| undefined
): (
self: RequestResolver<A>
) => RequestResolver<A>
<A extends Request.Any>(
self: RequestResolver<A>,
name: string,
options?:
| Tracer.SpanOptions
| ((
entries: NonEmptyArray<Request.Entry<A>>
) => Tracer.SpanOptions)
| undefined
): RequestResolver<A>
}
Adds a tracing span to the request resolver, which will also add any span
links from the request's.
Example (Adding a tracing span)
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")
const resolver = RequestResolver.make<GetDataRequest>((entries) =>
Effect.sync(() => {
for (const entry of entries) {
entry.completeUnsafe(Exit.succeed(`data-${entry.request.id}`))
}
})
)
// Add tracing span with custom name and attributes
const tracedResolver = RequestResolver.withSpan(
resolver,
"user-data-resolver",
{
attributes: {
"resolver.type": "user-data",
"resolver.version": "1.0"
}
}
)
// Spans will automatically include batch size and request links
const effect = Effect.request(GetDataRequest({ id: 123 }), tracedResolver)
withSpan: {
<function (type parameter) A in <A extends Request.Any>(name: string, options?: Tracer.SpanOptions | ((entries: NonEmptyArray<Request.Entry<A>>) => Tracer.SpanOptions) | undefined): (self: RequestResolver<A>) => RequestResolver<A>A extends import RequestRequest.type Any = Request.Request<any, any, any>Alias for any Request, regardless of its success, error, or service
requirements.
When to use
Use as a generic constraint for APIs that accept any request while preserving
each concrete request's success, error, and service types.
Any>(
name: stringname: string,
options: | Tracer.SpanOptions
| ((
entries: NonEmptyArray<Request.Entry<A>>
) => Tracer.SpanOptions)
| undefined
import TracerTracer.SpanOptions | ((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>>;
}
type NonEmptyArray<A> = [A, ...A[]]A mutable array guaranteed to have at least one element.
When to use
Use when mutation is acceptable and non-emptiness must be tracked at the type
level.
Details
This is the mutable counterpart of
NonEmptyReadonlyArray
. Most Array
module functions return NonEmptyArray when the result is guaranteed
non-empty.
Example (Typing a mutable non-empty array)
import type { Array } from "effect"
const nonEmpty: Array.NonEmptyArray<number> = [1, 2, 3]
nonEmpty.push(4)
NonEmptyArray<import RequestRequest.interface Entry<out R>A pending request handed to a RequestResolver.
Details
An entry contains the original request, the fiber context needed to run it,
an uninterruptible flag used by batching and caching internals, and the
completeUnsafe callback used by resolvers to supply the final Exit.
Entry<function (type parameter) A in <A extends Request.Any>(name: string, options?: Tracer.SpanOptions | ((entries: NonEmptyArray<Request.Entry<A>>) => Tracer.SpanOptions) | undefined): (self: RequestResolver<A>) => RequestResolver<A>A>>) => import TracerTracer.SpanOptions) | 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>(name: string, options?: Tracer.SpanOptions | ((entries: NonEmptyArray<Request.Entry<A>>) => Tracer.SpanOptions) | undefined): (self: RequestResolver<A>) => RequestResolver<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) A in <A extends Request.Any>(name: string, options?: Tracer.SpanOptions | ((entries: NonEmptyArray<Request.Entry<A>>) => Tracer.SpanOptions) | undefined): (self: RequestResolver<A>) => RequestResolver<A>A>
<function (type parameter) A in <A extends Request.Any>(self: RequestResolver<A>, name: string, options?: Tracer.SpanOptions | ((entries: NonEmptyArray<Request.Entry<A>>) => Tracer.SpanOptions) | undefined): RequestResolver<A>A extends import RequestRequest.type Any = Request.Request<any, any, any>Alias for any Request, regardless of its success, error, or service
requirements.
When to use
Use as a generic constraint for APIs that accept any request while preserving
each concrete request's success, error, and service types.
Any>(
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>, name: string, options?: Tracer.SpanOptions | ((entries: NonEmptyArray<Request.Entry<A>>) => Tracer.SpanOptions) | undefined): RequestResolver<A>A>,
name: stringname: string,
options: | Tracer.SpanOptions
| ((
entries: NonEmptyArray<Request.Entry<A>>
) => Tracer.SpanOptions)
| undefined
import TracerTracer.SpanOptions | ((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>>;
}
type NonEmptyArray<A> = [A, ...A[]]A mutable array guaranteed to have at least one element.
When to use
Use when mutation is acceptable and non-emptiness must be tracked at the type
level.
Details
This is the mutable counterpart of
NonEmptyReadonlyArray
. Most Array
module functions return NonEmptyArray when the result is guaranteed
non-empty.
Example (Typing a mutable non-empty array)
import type { Array } from "effect"
const nonEmpty: Array.NonEmptyArray<number> = [1, 2, 3]
nonEmpty.push(4)
NonEmptyArray<import RequestRequest.interface Entry<out R>A pending request handed to a RequestResolver.
Details
An entry contains the original request, the fiber context needed to run it,
an uninterruptible flag used by batching and caching internals, and the
completeUnsafe callback used by resolvers to supply the final Exit.
Entry<function (type parameter) A in <A extends Request.Any>(self: RequestResolver<A>, name: string, options?: Tracer.SpanOptions | ((entries: NonEmptyArray<Request.Entry<A>>) => Tracer.SpanOptions) | undefined): RequestResolver<A>A>>) => import TracerTracer.SpanOptions) | undefined
): 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>, name: string, options?: Tracer.SpanOptions | ((entries: NonEmptyArray<Request.Entry<A>>) => Tracer.SpanOptions) | undefined): RequestResolver<A>A>
} = dual<(...args: Array<any>) => any, <A extends Request.Any>(self: RequestResolver<A>, name: string, options?: Tracer.SpanOptions | ((entries: NonEmptyArray<Request.Entry<A>>) => Tracer.SpanOptions) | undefined) => RequestResolver<A>>(isDataFirst: (args: IArguments) => boolean, body: <A extends Request.Any>(self: RequestResolver<A>, name: string, options?: Tracer.SpanOptions | ((entries: NonEmptyArray<Request.Entry<A>>) => Tracer.SpanOptions) | undefined) => RequestResolver<A>): ((...args: Array<any>) => any) & (<A extends Request.Any>(self: RequestResolver<A>, name: string, options?: Tracer.SpanOptions | ((entries: NonEmptyArray<Request.Entry<A>>) => Tracer.SpanOptions) | undefined) => RequestResolver<A>) (+1 overload)Creates a function that can be called in data-first style or data-last
(pipe-friendly) style.
When to use
Use to expose one implementation through both direct and pipe-friendly
call styles.
Details
Pass either the arity of the uncurried function or a predicate that decides
whether the current call is data-first. Arity is the common case. Use a
predicate when optional arguments make arity ambiguous.
Example (Selecting data-first or data-last style by arity)
import { Function, pipe } from "effect"
const sum = Function.dual<
(that: number) => (self: number) => number,
(self: number, that: number) => number
>(2, (self, that) => self + that)
console.log(sum(2, 3)) // 5
console.log(pipe(2, sum(3))) // 5
Example (Defining overloads with call signatures)
import { Function, pipe } from "effect"
const sum: {
(that: number): (self: number) => number
(self: number, that: number): number
} = Function.dual(2, (self: number, that: number): number => self + that)
console.log(sum(2, 3)) // 5
console.log(pipe(2, sum(3))) // 5
Example (Selecting data-first or data-last style with a predicate)
import { Function, pipe } from "effect"
const sum = Function.dual<
(that: number) => (self: number) => number,
(self: number, that: number) => number
>(
(args) => args.length === 2,
(self, that) => self + that
)
console.log(sum(2, 3)) // 5
console.log(pipe(2, sum(3))) // 5
dual((args: IArgumentsargs) => const isRequestResolver: (
u: unknown
) => u is RequestResolver<any>
Returns true if the specified value is a RequestResolver, false otherwise.
When to use
Use to narrow unknown values before passing them to APIs that require a
RequestResolver.
isRequestResolver(args: IArgumentsargs[0]), <function (type parameter) A in <A extends Request.Any>(self: RequestResolver<A>, name: string, options?: Tracer.SpanOptions | ((entries: NonEmptyArray<Request.Entry<A>>) => Tracer.SpanOptions) | undefined): RequestResolver<A>A extends import RequestRequest.type Any = Request.Request<any, any, any>Alias for any Request, regardless of its success, error, or service
requirements.
When to use
Use as a generic constraint for APIs that accept any request while preserving
each concrete request's success, error, and service types.
Any>(
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>, name: string, options?: Tracer.SpanOptions | ((entries: NonEmptyArray<Request.Entry<A>>) => Tracer.SpanOptions) | undefined): RequestResolver<A>A>,
name: stringname: string,
options: | Tracer.SpanOptions
| ((
entries: NonEmptyArray<Request.Entry<A>>
) => Tracer.SpanOptions)
| undefined
import TracerTracer.SpanOptions | ((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>>;
}
type NonEmptyArray<A> = [A, ...A[]]A mutable array guaranteed to have at least one element.
When to use
Use when mutation is acceptable and non-emptiness must be tracked at the type
level.
Details
This is the mutable counterpart of
NonEmptyReadonlyArray
. Most Array
module functions return NonEmptyArray when the result is guaranteed
non-empty.
Example (Typing a mutable non-empty array)
import type { Array } from "effect"
const nonEmpty: Array.NonEmptyArray<number> = [1, 2, 3]
nonEmpty.push(4)
NonEmptyArray<import RequestRequest.interface Entry<out R>A pending request handed to a RequestResolver.
Details
An entry contains the original request, the fiber context needed to run it,
an uninterruptible flag used by batching and caching internals, and the
completeUnsafe callback used by resolvers to supply the final Exit.
Entry<function (type parameter) A in <A extends Request.Any>(self: RequestResolver<A>, name: string, options?: Tracer.SpanOptions | ((entries: NonEmptyArray<Request.Entry<A>>) => Tracer.SpanOptions) | undefined): RequestResolver<A>A>>) => import TracerTracer.SpanOptions) | undefined
): 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>, name: string, options?: Tracer.SpanOptions | ((entries: NonEmptyArray<Request.Entry<A>>) => Tracer.SpanOptions) | undefined): RequestResolver<A>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: [
Request.Entry<A>,
...Request.Entry<A>[]
],
key: unknown
) => Effect.Effect<void, Request.Error<A>, never>
entries: [
Request.Entry<A>,
...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) =>
import EffectEffect.const suspend: <A, E, R>(
effect: LazyArg<Effect<A, E, R>>
) => Effect<A, E, R>
Creates an Effect lazily, delaying construction until it is needed.
When to use
Use when you need to defer the evaluation of an effect until it is required.
Details
suspend takes a thunk that represents an effect and delays creating it
until the suspended effect is evaluated. This is useful for optimizing
expensive computations, managing circular dependencies such as recursive
functions, and helping TypeScript unify return types when branches construct
different effects. Any side effects or scoped captures inside the thunk are
re-executed on each invocation.
Example (Lazily evaluating side effects)
import { Effect } from "effect"
let i = 0
const bad = Effect.succeed(i++)
const good = Effect.suspend(() => Effect.succeed(i++))
console.log(Effect.runSync(bad)) // Output: 0
console.log(Effect.runSync(bad)) // Output: 0
console.log(Effect.runSync(good)) // Output: 1
console.log(Effect.runSync(good)) // Output: 2
Example (Suspending recursive Fibonacci evaluation)
import { Effect } from "effect"
const blowsUp = (n: number): Effect.Effect<number> =>
n < 2
? Effect.succeed(1)
: Effect.zipWith(blowsUp(n - 1), blowsUp(n - 2), (a, b) => a + b)
// console.log(Effect.runSync(blowsUp(32)))
// crash: JavaScript heap out of memory
const allGood = (n: number): Effect.Effect<number> =>
n < 2
? Effect.succeed(1)
: Effect.zipWith(
Effect.suspend(() => allGood(n - 1)),
Effect.suspend(() => allGood(n - 2)),
(a, b) => a + b
)
console.log(Effect.runSync(allGood(32)))
// Output: 3524578
Example (Helping TypeScript infer recursive effect types)
import { Effect } from "effect"
// Without suspend, TypeScript may struggle with type inference.
// Inferred type:
// (a: number, b: number) =>
// Effect<never, Error, never> | Effect<number, never, never>
const withoutSuspend = (a: number, b: number) =>
b === 0
? Effect.fail(new Error("Cannot divide by zero"))
: Effect.succeed(a / b)
// Using suspend to unify return types.
// Inferred type:
// (a: number, b: number) => Effect<number, Error, never>
const withSuspend = (a: number, b: number) =>
Effect.suspend(() =>
b === 0
? Effect.fail(new Error("Cannot divide by zero"))
: Effect.succeed(a / b)
)
suspend(() => {
const const opts: Tracer.SpanOptions | undefinedopts = typeof options: | Tracer.SpanOptions
| ((
entries: NonEmptyArray<Request.Entry<A>>
) => Tracer.SpanOptions)
| undefined
options: | Tracer.SpanOptions
| ((
entries: NonEmptyArray<Request.Entry<A>>
) => Tracer.SpanOptions)
| undefined
entries: [
Request.Entry<A>,
...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>>;
}
options: | Tracer.SpanOptions
| ((
entries: NonEmptyArray<Request.Entry<A>>
) => Tracer.SpanOptions)
| undefined
const links: Array<Tracer.SpanLink>links = const opts: Tracer.SpanOptions | undefinedopts?.SpanOptionsNoTrace.links?: ReadonlyArray<SpanLink> | undefinedlinks ? const opts: Tracer.SpanOptionsconst opts: {
attributes: Record<string, unknown> | undefined;
links: ReadonlyArray<SpanLink> | undefined;
parent: AnySpan | undefined;
root: boolean | undefined;
annotations: Context.Context<never> | undefined;
kind: SpanKind | undefined;
sampled: boolean | undefined;
level: LogLevel | undefined;
captureStackTrace: boolean | LazyArg<string | undefined> | undefined;
}
SpanOptionsNoTrace.links?: ReadonlyArray<SpanLink> | undefinedlinks.ReadonlyArray<SpanLink>.slice(start?: number, end?: number): Tracer.SpanLink[]Returns a section of an array.
slice() : []
const const seen: Set<Tracer.AnySpan>seen = new var Set: SetConstructor
new <Tracer.AnySpan>(iterable?: Iterable<Tracer.AnySpan> | null | undefined) => Set<Tracer.AnySpan> (+1 overload)
import TracerTracer.type AnySpan =
| Tracer.Span
| Tracer.ExternalSpan
A span value that can participate in tracing, either an Effect-managed
Span or an ExternalSpan propagated from another tracing system.
Example (Accepting any span)
import { Effect, Tracer } from "effect"
// Function that accepts any span type
const logSpan = (span: Tracer.AnySpan) => {
console.log(`Span ID: ${span.spanId}, Trace ID: ${span.traceId}`)
return Effect.succeed(span)
}
// Works with both Span and ExternalSpan
const externalSpan = Tracer.externalSpan({
spanId: "span-123",
traceId: "trace-456"
})
AnySpan>()
for (const const entry: Request.Entry<A>const 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;
}
entries: [
Request.Entry<A>,
...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>>;
}
const span: Option<Tracer.AnySpan>span = import ContextContext.const getOption: {
<S, I>(service: Key<I, S>): <Services>(
self: Context<Services>
) => Option.Option<S>
<Services, S, I>(
self: Context<Services>,
service: Key<I, S>
): Option.Option<S>
}
const entry: Request.Entry<A>const 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<A>.context: Context.Context<[R] extends [Request<infer _A, infer _E, infer _R>] ? _R : never>(property) Entry<A>.context: {
mapUnsafe: ReadonlyMap<string, any>;
mutable: boolean;
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 TracerTracer.class ParentSpanclass ParentSpan {
key: Identifier;
of: (this: void, self: Tracer.AnySpan) => Tracer.AnySpan;
context: (self: Tracer.AnySpan) => Context.Context<Tracer.ParentSpan>;
use: (f: (service: Tracer.AnySpan) => Effect.Effect<A, E, R>) => Effect.Effect<A, E, Tracer.ParentSpan | R>;
useSync: (f: (service: Tracer.AnySpan) => A) => Effect.Effect<A, never, Tracer.ParentSpan>;
Identifier: Identifier;
Service: Shape;
stack: string | undefined;
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;
}
Context service containing the Span or ExternalSpan to use as the parent
of newly-created child spans.
Example (Accessing the parent span)
import { Effect, Tracer } from "effect"
// Access the parent span from the context
const program = Effect.gen(function*() {
const parentSpan = yield* Effect.service(Tracer.ParentSpan)
console.log(`Parent span: ${parentSpan.spanId}`)
})
ParentSpan)
if (const span: Option<Tracer.AnySpan>span._tag: "None" | "Some"_tag === "None" || const seen: Set<Tracer.AnySpan>seen.Set<AnySpan>.has(value: Tracer.AnySpan): booleanhas(const span: Some<Tracer.AnySpan>const span: {
_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;
}
Some<AnySpan>.value: Tracer.AnySpanvalue)) continue
const seen: Set<Tracer.AnySpan>seen.Set<AnySpan>.add(value: Tracer.AnySpan): Set<Tracer.AnySpan>Appends a new element with a specified value to the end of the Set.
add(const span: Some<Tracer.AnySpan>const span: {
_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;
}
Some<AnySpan>.value: Tracer.AnySpanvalue)
const links: Array<Tracer.SpanLink>links.Array<SpanLink>.push(...items: Tracer.SpanLink[]): numberAppends new elements to the end of an array, and returns the new length of the array.
push({ SpanLink.span: Tracer.AnySpanspan: const span: Some<Tracer.AnySpan>const span: {
_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;
}
Some<AnySpan>.value: Tracer.AnySpanvalue, SpanLink.attributes: Readonly<Record<string, unknown>>attributes: {} })
}
return import EffectEffect.const withSpan: {
<Args extends ReadonlyArray<any>>(
name: string,
options?:
| SpanOptionsNoTrace
| ((
...args: NoInfer<Args>
) => SpanOptionsNoTrace)
| undefined,
traceOptions?: TraceOptions | undefined
): <A, E, R>(
self: Effect<A, E, R>,
...args: Args
) => Effect<A, E, Exclude<R, ParentSpan>>
<A, E, R>(
self: Effect<A, E, R>,
name: string,
options?: SpanOptions | undefined
): Effect<A, E, Exclude<R, ParentSpan>>
}
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: [Request.Entry<A>, ...Request.Entry<A>[]], key: unknown): Effect.Effect<void, Request.Error<A>, never>Execute a collection of requests.
runAll(entries: [
Request.Entry<A>,
...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), name: stringname, {
...options: | Tracer.SpanOptions
| ((
entries: NonEmptyArray<Request.Entry<A>>
) => Tracer.SpanOptions)
| undefined
SpanOptionsNoTrace.links?: Array<Tracer.SpanLink>links,
SpanOptionsNoTrace.attributes?: Record<string, unknown> | undefined(property) SpanOptionsNoTrace.attributes?: {
batchSize: number;
}
batchSize: numberbatchSize: entries: [
Request.Entry<A>,
...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>>;
}
length: numberlength,
...const opts: Tracer.SpanOptions | undefinedopts?.SpanOptionsNoTrace.attributes?: Record<string, unknown> | undefinedattributes
}
})
})
}))