<
A extends Request.Any,
ServiceMode extends "lookup" | "construction" = never
>(options: {
readonly capacity: number
readonly timeToLive?:
| ((exit: Request.Result<A>, request: A) => Duration.Input)
| undefined
readonly requireServicesAt?: ServiceMode | undefined
}): (
self: RequestResolver<A>
) => Effect.Effect<
Cache.Cache<
A,
Request.Success<A>,
Request.Error<A>,
"construction" extends ServiceMode ? never : Request.Services<A>
>,
never,
"construction" extends ServiceMode ? Request.Services<A> : never
>
<
A extends Request.Any,
ServiceMode extends "lookup" | "construction" = never
>(
self: RequestResolver<A>,
options: {
readonly capacity: number
readonly timeToLive?:
| ((exit: Request.Result<A>, request: A) => Duration.Input)
| undefined
readonly requireServicesAt?: ServiceMode | undefined
}
): Effect.Effect<
Cache.Cache<
A,
Request.Success<A>,
Request.Error<A>,
"construction" extends ServiceMode ? never : Request.Services<A>
>,
never,
"construction" extends ServiceMode ? Request.Services<A> : never
>Wraps a request resolver in a cache, allowing it to cache results up to a specified capacity and optional time-to-live.
When to use
Use to turn a request resolver into a first-class Cache when callers need
cache lookup, refresh, invalidation, or inspection around request results.
Details
The request value is the cache key. Cache misses run the resolver via
Effect.request, timeToLive receives the request Exit and the request,
and requireServicesAt controls whether services are required at lookup time
or construction time.
Gotchas
Cache hits depend on the request value's equality semantics.
Source effect/RequestResolver.ts:99357 lines
export const const asCache: {
<
A extends Request.Any,
ServiceMode extends
| "lookup"
| "construction" = never
>(options: {
readonly capacity: number
readonly timeToLive?:
| ((
exit: Request.Result<A>,
request: A
) => Duration.Input)
| undefined
readonly requireServicesAt?:
| ServiceMode
| undefined
}): (
self: RequestResolver<A>
) => Effect.Effect<
Cache.Cache<
A,
Request.Success<A>,
Request.Error<A>,
"construction" extends ServiceMode
? never
: Request.Services<A>
>,
never,
"construction" extends ServiceMode
? Request.Services<A>
: never
>
<
A extends Request.Any,
ServiceMode extends
| "lookup"
| "construction" = never
>(
self: RequestResolver<A>,
options: {
readonly capacity: number
readonly timeToLive?:
| ((
exit: Request.Result<A>,
request: A
) => Duration.Input)
| undefined
readonly requireServicesAt?:
| ServiceMode
| undefined
}
): Effect.Effect<
Cache.Cache<
A,
Request.Success<A>,
Request.Error<A>,
"construction" extends ServiceMode
? never
: Request.Services<A>
>,
never,
"construction" extends ServiceMode
? Request.Services<A>
: never
>
}
Wraps a request resolver in a cache, allowing it to cache results up to a
specified capacity and optional time-to-live.
When to use
Use to turn a request resolver into a first-class Cache when callers need
cache lookup, refresh, invalidation, or inspection around request results.
Details
The request value is the cache key. Cache misses run the resolver via
Effect.request, timeToLive receives the request Exit and the request,
and requireServicesAt controls whether services are required at lookup time
or construction time.
Gotchas
Cache hits depend on the request value's equality semantics.
asCache: {
<
function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): (self: RequestResolver<A>) => Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
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,
function (type parameter) ServiceMode in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): (self: RequestResolver<A>) => Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
options: {
readonly capacity: number
readonly timeToLive?:
| ((
exit: Request.Result<A>,
request: A
) => Duration.Input)
| undefined
readonly requireServicesAt?:
| ServiceMode
| undefined
}
capacity: numbercapacity: number
readonly timeToLive?: | ((
exit: Request.Result<A>,
request: A
) => Duration.Input)
| undefined
exit: Request.Result<A>exit: import RequestRequest.type Result<
T extends Request.Request<any, any, any>
> = T extends Request.Request<
infer A,
infer E,
infer _R
>
? Exit.Exit<A, E>
: never
A utility type to extract the result type from a Request.
Example (Extracting a request result type)
import type { Request } from "effect"
interface GetUser extends Request.Request<string, Error> {
readonly _tag: "GetUser"
readonly id: number
}
// Extract the result type from a Request using the utility
type UserResult = Request.Result<GetUser> // Exit.Exit<string, Error>
Result<function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): (self: RequestResolver<A>) => Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
request: A extends Request.Anyrequest: function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): (self: RequestResolver<A>) => Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
import DurationDuration.type Input =
| number
| bigint
| Duration.Duration
| readonly [seconds: number, nanos: number]
| `${number} nano`
| `${number} nanos`
| `${number} micro`
| `${number} micros`
| `${number} milli`
| `${number} millis`
| `${number} second`
| `${number} seconds`
| `${number} minute`
| `${number} minutes`
| `${number} hour`
| `${number} hours`
| `${number} day`
| `${number} days`
| `${number} week`
| `${number} weeks`
| "Infinity"
| "-Infinity"
| Duration.DurationObject
Valid input types that can be converted to a Duration.
When to use
Use when an API should accept any value that Effect can convert into a
Duration, including existing durations, millisecond numbers, nanosecond
bigints, high-resolution tuples, duration strings, infinity strings, or
duration objects.
Details
String inputs accept values like "10 seconds", "500 millis",
"Infinity", and "-Infinity". Finite fractional values that are
normalized to nanoseconds are rounded to the nearest nanosecond, with ties
away from zero.
Input) | undefined
readonly requireServicesAt?: ServiceMode | undefinedrequireServicesAt?: function (type parameter) ServiceMode in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): (self: RequestResolver<A>) => Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
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, ServiceMode extends "lookup" | "construction" = never>(options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): (self: RequestResolver<A>) => Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
import EffectEffect.interface Effect<out A, out E = never, out R = never>The Effect interface defines a value that lazily describes a workflow or
job. The workflow requires some context R, and may fail with an error of
type E, or succeed with a value of type A.
When to use
Use when you need to represent a lazy, composable workflow that can require
services, fail with a typed error, or succeed with a typed value.
Details
Effect values model resourceful interaction with the outside world,
including synchronous, asynchronous, concurrent, and parallel interaction.
They use a fiber-based concurrency model, with built-in support for
scheduling, fine-grained interruption, structured concurrency, and high
scalability.
To run an Effect value, you need a Runtime, which is a type that is
capable of executing Effect values.
Effect<
import CacheCache.interface Cache<in out Key, in out A, in out E = never, out R = never>A cache interface that provides a mutable key-value store with automatic TTL management,
capacity limits, and lookup functions for cache misses.
Example (Creating a basic cache)
import { Cache, Effect } from "effect"
// Basic cache with string keys and number values
const program = Effect.gen(function*() {
const cache = yield* Cache.make<string, number>({
capacity: 100,
lookup: (key: string) => Effect.succeed(key.length)
})
// Cache operations
const value1 = yield* Cache.get(cache, "hello") // 5
const value2 = yield* Cache.get(cache, "world") // 5
const value3 = yield* Cache.get(cache, "hello") // 5 (cached)
return [value1, value2, value3]
})
Example (Handling lookup failures)
import { Cache, Effect } from "effect"
// Cache with error handling
const program = Effect.gen(function*() {
const cache = yield* Cache.make<string, number, string>({
capacity: 10,
lookup: (key: string) =>
key === "error"
? Effect.fail("Lookup failed")
: Effect.succeed(key.length)
})
// Handle successful and failed lookups
const success = yield* Cache.get(cache, "test") // 4
const failure = yield* Effect.exit(Cache.get(cache, "error")) // Exit.fail
return { success, failure }
})
Example (Using complex keys with TTL)
import { Cache, Data, Duration, Effect } from "effect"
// Cache with complex key types and TTL
class UserId extends Data.Class<{ id: number }> {}
const program = Effect.gen(function*() {
const userCache = yield* Cache.make<UserId, string>({
capacity: 1000,
lookup: (userId: UserId) => Effect.succeed(`User-${userId.id}`),
timeToLive: Duration.minutes(5)
})
const userId = new UserId({ id: 123 })
const userName = yield* Cache.get(userCache, userId)
return userName // "User-123"
})
Cache<
function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): (self: RequestResolver<A>) => Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
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, ServiceMode extends "lookup" | "construction" = never>(options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): (self: RequestResolver<A>) => Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
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, ServiceMode extends "lookup" | "construction" = never>(options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): (self: RequestResolver<A>) => Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
function (type parameter) ServiceMode in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): (self: RequestResolver<A>) => Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
import RequestRequest.type Services<
T extends Request.Request<any, any, any>
> = [T] extends [
Request.Request<infer _A, infer _E, infer _R>
]
? _R
: never
A utility type to extract the requirements type from a Request.
Services<function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): (self: RequestResolver<A>) => Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
function (type parameter) ServiceMode in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): (self: RequestResolver<A>) => Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
import RequestRequest.type Services<
T extends Request.Request<any, any, any>
> = [T] extends [
Request.Request<infer _A, infer _E, infer _R>
]
? _R
: never
A utility type to extract the requirements type from a Request.
Services<function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): (self: RequestResolver<A>) => Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
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,
function (type parameter) ServiceMode in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
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, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
options: {
readonly capacity: number
readonly timeToLive?:
| ((
exit: Request.Result<A>,
request: A
) => Duration.Input)
| undefined
readonly requireServicesAt?:
| ServiceMode
| undefined
}
capacity: numbercapacity: number
readonly timeToLive?: | ((
exit: Request.Result<A>,
request: A
) => Duration.Input)
| undefined
exit: Request.Result<A>exit: import RequestRequest.type Result<
T extends Request.Request<any, any, any>
> = T extends Request.Request<
infer A,
infer E,
infer _R
>
? Exit.Exit<A, E>
: never
A utility type to extract the result type from a Request.
Example (Extracting a request result type)
import type { Request } from "effect"
interface GetUser extends Request.Request<string, Error> {
readonly _tag: "GetUser"
readonly id: number
}
// Extract the result type from a Request using the utility
type UserResult = Request.Result<GetUser> // Exit.Exit<string, Error>
Result<function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
request: A extends Request.Anyrequest: function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
import DurationDuration.type Input =
| number
| bigint
| Duration.Duration
| readonly [seconds: number, nanos: number]
| `${number} nano`
| `${number} nanos`
| `${number} micro`
| `${number} micros`
| `${number} milli`
| `${number} millis`
| `${number} second`
| `${number} seconds`
| `${number} minute`
| `${number} minutes`
| `${number} hour`
| `${number} hours`
| `${number} day`
| `${number} days`
| `${number} week`
| `${number} weeks`
| "Infinity"
| "-Infinity"
| Duration.DurationObject
Valid input types that can be converted to a Duration.
When to use
Use when an API should accept any value that Effect can convert into a
Duration, including existing durations, millisecond numbers, nanosecond
bigints, high-resolution tuples, duration strings, infinity strings, or
duration objects.
Details
String inputs accept values like "10 seconds", "500 millis",
"Infinity", and "-Infinity". Finite fractional values that are
normalized to nanoseconds are rounded to the nearest nanosecond, with ties
away from zero.
Input) | undefined
readonly requireServicesAt?: ServiceMode | undefinedrequireServicesAt?: function (type parameter) ServiceMode in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
import EffectEffect.interface Effect<out A, out E = never, out R = never>The Effect interface defines a value that lazily describes a workflow or
job. The workflow requires some context R, and may fail with an error of
type E, or succeed with a value of type A.
When to use
Use when you need to represent a lazy, composable workflow that can require
services, fail with a typed error, or succeed with a typed value.
Details
Effect values model resourceful interaction with the outside world,
including synchronous, asynchronous, concurrent, and parallel interaction.
They use a fiber-based concurrency model, with built-in support for
scheduling, fine-grained interruption, structured concurrency, and high
scalability.
To run an Effect value, you need a Runtime, which is a type that is
capable of executing Effect values.
Effect<
import CacheCache.interface Cache<in out Key, in out A, in out E = never, out R = never>A cache interface that provides a mutable key-value store with automatic TTL management,
capacity limits, and lookup functions for cache misses.
Example (Creating a basic cache)
import { Cache, Effect } from "effect"
// Basic cache with string keys and number values
const program = Effect.gen(function*() {
const cache = yield* Cache.make<string, number>({
capacity: 100,
lookup: (key: string) => Effect.succeed(key.length)
})
// Cache operations
const value1 = yield* Cache.get(cache, "hello") // 5
const value2 = yield* Cache.get(cache, "world") // 5
const value3 = yield* Cache.get(cache, "hello") // 5 (cached)
return [value1, value2, value3]
})
Example (Handling lookup failures)
import { Cache, Effect } from "effect"
// Cache with error handling
const program = Effect.gen(function*() {
const cache = yield* Cache.make<string, number, string>({
capacity: 10,
lookup: (key: string) =>
key === "error"
? Effect.fail("Lookup failed")
: Effect.succeed(key.length)
})
// Handle successful and failed lookups
const success = yield* Cache.get(cache, "test") // 4
const failure = yield* Effect.exit(Cache.get(cache, "error")) // Exit.fail
return { success, failure }
})
Example (Using complex keys with TTL)
import { Cache, Data, Duration, Effect } from "effect"
// Cache with complex key types and TTL
class UserId extends Data.Class<{ id: number }> {}
const program = Effect.gen(function*() {
const userCache = yield* Cache.make<UserId, string>({
capacity: 1000,
lookup: (userId: UserId) => Effect.succeed(`User-${userId.id}`),
timeToLive: Duration.minutes(5)
})
const userId = new UserId({ id: 123 })
const userName = yield* Cache.get(userCache, userId)
return userName // "User-123"
})
Cache<
function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
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, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
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, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
function (type parameter) ServiceMode in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
import RequestRequest.type Services<
T extends Request.Request<any, any, any>
> = [T] extends [
Request.Request<infer _A, infer _E, infer _R>
]
? _R
: never
A utility type to extract the requirements type from a Request.
Services<function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
function (type parameter) ServiceMode in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
import RequestRequest.type Services<
T extends Request.Request<any, any, any>
> = [T] extends [
Request.Request<infer _A, infer _E, infer _R>
]
? _R
: never
A utility type to extract the requirements type from a Request.
Services<function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
dual<(...args: Array<any>) => any, <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}) => Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>>(arity: 2, body: <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}) => Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>): ((...args: Array<any>) => any) & (<A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}) => Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>) (+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(2, <
function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
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,
function (type parameter) ServiceMode in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
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, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
options: {
readonly capacity: number
readonly timeToLive?:
| ((
exit: Request.Result<A>,
request: A
) => Duration.Input)
| undefined
readonly requireServicesAt?:
| ServiceMode
| undefined
}
capacity: numbercapacity: number
readonly timeToLive?: | ((
exit: Request.Result<A>,
request: A
) => Duration.Input)
| undefined
exit: Request.Result<A>exit: import RequestRequest.type Result<
T extends Request.Request<any, any, any>
> = T extends Request.Request<
infer A,
infer E,
infer _R
>
? Exit.Exit<A, E>
: never
A utility type to extract the result type from a Request.
Example (Extracting a request result type)
import type { Request } from "effect"
interface GetUser extends Request.Request<string, Error> {
readonly _tag: "GetUser"
readonly id: number
}
// Extract the result type from a Request using the utility
type UserResult = Request.Result<GetUser> // Exit.Exit<string, Error>
Result<function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
request: A extends Request.Anyrequest: function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
import DurationDuration.type Input =
| number
| bigint
| Duration.Duration
| readonly [seconds: number, nanos: number]
| `${number} nano`
| `${number} nanos`
| `${number} micro`
| `${number} micros`
| `${number} milli`
| `${number} millis`
| `${number} second`
| `${number} seconds`
| `${number} minute`
| `${number} minutes`
| `${number} hour`
| `${number} hours`
| `${number} day`
| `${number} days`
| `${number} week`
| `${number} weeks`
| "Infinity"
| "-Infinity"
| Duration.DurationObject
Valid input types that can be converted to a Duration.
When to use
Use when an API should accept any value that Effect can convert into a
Duration, including existing durations, millisecond numbers, nanosecond
bigints, high-resolution tuples, duration strings, infinity strings, or
duration objects.
Details
String inputs accept values like "10 seconds", "500 millis",
"Infinity", and "-Infinity". Finite fractional values that are
normalized to nanoseconds are rounded to the nearest nanosecond, with ties
away from zero.
Input) | undefined
readonly requireServicesAt?: ServiceMode | undefinedrequireServicesAt?: function (type parameter) ServiceMode in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
import EffectEffect.interface Effect<out A, out E = never, out R = never>The Effect interface defines a value that lazily describes a workflow or
job. The workflow requires some context R, and may fail with an error of
type E, or succeed with a value of type A.
When to use
Use when you need to represent a lazy, composable workflow that can require
services, fail with a typed error, or succeed with a typed value.
Details
Effect values model resourceful interaction with the outside world,
including synchronous, asynchronous, concurrent, and parallel interaction.
They use a fiber-based concurrency model, with built-in support for
scheduling, fine-grained interruption, structured concurrency, and high
scalability.
To run an Effect value, you need a Runtime, which is a type that is
capable of executing Effect values.
Effect<
import CacheCache.interface Cache<in out Key, in out A, in out E = never, out R = never>A cache interface that provides a mutable key-value store with automatic TTL management,
capacity limits, and lookup functions for cache misses.
Example (Creating a basic cache)
import { Cache, Effect } from "effect"
// Basic cache with string keys and number values
const program = Effect.gen(function*() {
const cache = yield* Cache.make<string, number>({
capacity: 100,
lookup: (key: string) => Effect.succeed(key.length)
})
// Cache operations
const value1 = yield* Cache.get(cache, "hello") // 5
const value2 = yield* Cache.get(cache, "world") // 5
const value3 = yield* Cache.get(cache, "hello") // 5 (cached)
return [value1, value2, value3]
})
Example (Handling lookup failures)
import { Cache, Effect } from "effect"
// Cache with error handling
const program = Effect.gen(function*() {
const cache = yield* Cache.make<string, number, string>({
capacity: 10,
lookup: (key: string) =>
key === "error"
? Effect.fail("Lookup failed")
: Effect.succeed(key.length)
})
// Handle successful and failed lookups
const success = yield* Cache.get(cache, "test") // 4
const failure = yield* Effect.exit(Cache.get(cache, "error")) // Exit.fail
return { success, failure }
})
Example (Using complex keys with TTL)
import { Cache, Data, Duration, Effect } from "effect"
// Cache with complex key types and TTL
class UserId extends Data.Class<{ id: number }> {}
const program = Effect.gen(function*() {
const userCache = yield* Cache.make<UserId, string>({
capacity: 1000,
lookup: (userId: UserId) => Effect.succeed(`User-${userId.id}`),
timeToLive: Duration.minutes(5)
})
const userId = new UserId({ id: 123 })
const userName = yield* Cache.get(userCache, userId)
return userName // "User-123"
})
Cache<
function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
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, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
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, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
function (type parameter) ServiceMode in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
import RequestRequest.type Services<
T extends Request.Request<any, any, any>
> = [T] extends [
Request.Request<infer _A, infer _E, infer _R>
]
? _R
: never
A utility type to extract the requirements type from a Request.
Services<function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
function (type parameter) ServiceMode in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
import RequestRequest.type Services<
T extends Request.Request<any, any, any>
> = [T] extends [
Request.Request<infer _A, infer _E, infer _R>
]
? _R
: never
A utility type to extract the requirements type from a Request.
Services<function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
import CacheCache.const makeWith: <
Key,
A,
E = never,
R = never,
ServiceMode extends
| "lookup"
| "construction" = never
>(
lookup: (key: Key) => Effect.Effect<A, E, R>,
options: {
readonly capacity: number
readonly timeToLive?:
| ((
exit: Exit.Exit<A, E>,
key: Key
) => Duration.Input)
| undefined
readonly requireServicesAt?:
| ServiceMode
| undefined
}
) => Effect.Effect<
Cache<
Key,
A,
E,
"lookup" extends ServiceMode ? R : never
>,
never,
"lookup" extends ServiceMode ? never : R
>
Creates a cache with dynamic time-to-live based on the result and key.
When to use
Use when you need different cache entry lifetimes based on the lookup result
or key characteristics.
Details
The timeToLive function receives both the exit result and the key, allowing
for flexible TTL policies based on success/failure state and key characteristics.
Example (Configuring dynamic time to live)
import { Cache, Effect, Exit } from "effect"
// Cache with TTL based on computed value
const userCache = Effect.gen(function*() {
const cache = yield* Cache.makeWith(
(id: number) => Effect.succeed({ id, active: id % 2 === 0 }),
{
capacity: 1000,
timeToLive(exit) {
if (Exit.isSuccess(exit)) {
const user = exit.value
return user.active ? "1 hour" : "5 minutes"
}
return "30 seconds"
}
}
)
return cache
})
makeWith((req: A extends Request.Anyreq: function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
import internalinternal.const request: {
<A extends Request.Any, EX = never, RX = never>(
resolver:
| RequestResolver<A>
| Effect<RequestResolver<A>, EX, RX>
): (
self: A
) => Effect<
Request.Success<A>,
Request.Error<A> | EX,
Request.Services<A> | RX
>
<A extends Request.Any, EX = never, RX = never>(
self: A,
resolver:
| RequestResolver<A>
| Effect<RequestResolver<A>, EX, RX>
): Effect<
Request.Success<A>,
Request.Error<A> | EX,
Request.Services<A> | RX
>
}
req: A extends Request.Anyreq, 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; <…;
}
capacity: numbercapacity: options: {
readonly capacity: number
readonly timeToLive?:
| ((
exit: Request.Result<A>,
request: A
) => Duration.Input)
| undefined
readonly requireServicesAt?:
| ServiceMode
| undefined
}
capacity: numbercapacity,
timeToLive?: | ((
exit: Exit.Exit<
Request.Success<A>,
Request.Error<A>
>,
key: A
) => Duration.Input)
| undefined
options: {
readonly capacity: number
readonly timeToLive?:
| ((
exit: Request.Result<A>,
request: A
) => Duration.Input)
| undefined
readonly requireServicesAt?:
| ServiceMode
| undefined
}
timeToLive?: | ((
exit: Request.Result<A>,
request: A
) => Duration.Input)
| undefined
requireServicesAt?: ServiceMode | undefinedrequireServicesAt: options: {
readonly capacity: number
readonly timeToLive?:
| ((
exit: Request.Result<A>,
request: A
) => Duration.Input)
| undefined
readonly requireServicesAt?:
| ServiceMode
| undefined
}
requireServicesAt?: ServiceMode | undefinedrequireServicesAt ?? "lookup" as function (type parameter) ServiceMode in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>