<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.interface Context<in Services>Immutable collection of service implementations used for dependency
injection in Effect programs.
Details
The type parameter tracks the service identifiers available in the context.
At runtime, services are stored by each key's string key.
Example (Creating a context with multiple services)
import { Context } from "effect"
// Create a context with multiple services
const Logger = Context.Service<{ log: (msg: string) => void }>("Logger")
const Database = Context.Service<{ query: (sql: string) => string }>(
"Database"
)
const context = Context.make(Logger, {
log: (msg: string) => console.log(msg)
})
.pipe(Context.add(Database, { query: (sql) => `Result: ${sql}` }))
Context<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