<A extends Request.Any>(
self: A,
options: {
readonly resolver: RequestResolver<A>
readonly onExit: (
exit: Exit.Exit<Request.Success<A>, Request.Error<A>>
) => void
readonly context: Context.Context<never>
}
): () => voidRegisters a request with a resolver and delivers the exit value via onExit.
When to use
Use when you already have a Context and need to enqueue a request outside
an Effect while receiving completion through onExit.
Details
It returns a canceler that removes the pending request entry.
export const const requestUnsafe: <
A extends Request.Any
>(
self: A,
options: {
readonly resolver: RequestResolver<A>
readonly onExit: (
exit: Exit.Exit<
Request.Success<A>,
Request.Error<A>
>
) => void
readonly context: Context.Context<never>
}
) => () => void
Registers a request with a resolver and delivers the exit value via onExit.
When to use
Use when you already have a Context and need to enqueue a request outside
an Effect while receiving completion through onExit.
Details
It returns a canceler that removes the pending request entry.
requestUnsafe: <function (type parameter) A in <A extends Request.Any>(self: A, options: {
readonly resolver: RequestResolver<A>;
readonly onExit: (exit: Exit.Exit<Request.Success<A>, Request.Error<A>>) => void;
readonly context: Context.Context<never>;
}): () => void
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: A extends Request.Anyself: function (type parameter) A in <A extends Request.Any>(self: A, options: {
readonly resolver: RequestResolver<A>;
readonly onExit: (exit: Exit.Exit<Request.Success<A>, Request.Error<A>>) => void;
readonly context: Context.Context<never>;
}): () => void
options: {
readonly resolver: RequestResolver<A>
readonly onExit: (
exit: Exit.Exit<
Request.Success<A>,
Request.Error<A>
>
) => void
readonly context: Context.Context<never>
}
resolver: RequestResolver<A>(property) resolver: {
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<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: A, options: {
readonly resolver: RequestResolver<A>;
readonly onExit: (exit: Exit.Exit<Request.Success<A>, Request.Error<A>>) => void;
readonly context: Context.Context<never>;
}): () => void
onExit: (
exit: Exit.Exit<
Request.Success<A>,
Request.Error<A>
>
) => void
exit: Exit.Exit<
Request.Success<A>,
Request.Error<A>
>
import ExitExit.type Exit<A, E = never> = Exit.Success<A, E> | Exit.Failure<A, E>Represents the result of an Effect computation.
When to use
Use when you need to synchronously inspect whether an Effect computation
succeeded or failed.
Details
An Exit<A, E> is either Success<A, E> containing a value of type A, or
Failure<A, E> containing a Cause<E> describing why the computation
failed.
Since Exit is also an Effect, you can yield it inside Effect.gen.
Example (Pattern matching on an Exit)
import { Exit } from "effect"
const success: Exit.Exit<number> = Exit.succeed(42)
const failure: Exit.Exit<number, string> = Exit.fail("error")
const result = Exit.match(success, {
onSuccess: (value) => `Got value: ${value}`,
onFailure: (cause) => `Got error: ${cause}`
})
Namespace containing helper types shared by Exit values.
When to use
Use to reference helper types that describe the shared structure of Exit
values.
Exit<import RequestRequest.type Success<
T extends Request.Request<any, any, any>
> = [T] extends [
Request.Request<infer _A, infer _E, infer _R>
]
? _A
: never
A utility type to extract the value type from a Request.
Example (Extracting a request success type)
import type { Request } from "effect"
interface GetUser extends Request.Request<string, Error> {
readonly _tag: "GetUser"
readonly id: number
}
// Extract the success type from a Request using the utility
type UserSuccess = Request.Success<GetUser> // string
Success<function (type parameter) A in <A extends Request.Any>(self: A, options: {
readonly resolver: RequestResolver<A>;
readonly onExit: (exit: Exit.Exit<Request.Success<A>, Request.Error<A>>) => void;
readonly context: Context.Context<never>;
}): () => void
import RequestRequest.type Error<
T extends Request.Request<any, any, any>
> = [T] extends [
Request.Request<infer _A, infer _E, infer _R>
]
? _E
: never
A utility type to extract the error type from a Request.
Example (Extracting a request error type)
import type { Request } from "effect"
interface GetUser extends Request.Request<string, Error> {
readonly id: number
}
// Extract the error type from a Request using the utility
type UserError = Request.Error<GetUser> // Error
Error<function (type parameter) A in <A extends Request.Any>(self: A, options: {
readonly resolver: RequestResolver<A>;
readonly onExit: (exit: Exit.Exit<Request.Success<A>, Request.Error<A>>) => void;
readonly context: Context.Context<never>;
}): () => void
context: Context.Context<never>(property) 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 ContextContext.type Context.Context = /*unresolved*/ anyContext<never>
}
) => () => void = import internalRequestinternalRequest.const requestUnsafe: <
A extends Request.Any
>(
self: A,
options: {
readonly resolver: RequestResolver<A>
readonly onExit: (
exit: Exit<
Request.Success<A>,
Request.Error<A>
>
) => void
readonly context: Context.Context<never>
}
) => () => void