<A, E, R, Out, E2, R2>(
acquire: Effect.Effect<A, E, R>,
policy: Schedule.Schedule<Out, unknown, E2, R2>
): Effect.Effect<Resource<A, E>, never, R | R2 | Scope.Scope>Creates a Resource that refreshes automatically according to the supplied
schedule.
When to use
Use when a resource should refresh in the background according to a schedule for the lifetime of its scope.
Source effect/Resource.ts:1288 lines
export const const auto: <A, E, R, Out, E2, R2>(
acquire: Effect.Effect<A, E, R>,
policy: Schedule.Schedule<Out, unknown, E2, R2>
) => Effect.Effect<
Resource<A, E>,
never,
R | R2 | Scope.Scope
>
Creates a Resource that refreshes automatically according to the supplied
schedule.
When to use
Use when a resource should refresh in the background according to a schedule
for the lifetime of its scope.
auto = <function (type parameter) A in <A, E, R, Out, E2, R2>(acquire: Effect.Effect<A, E, R>, policy: Schedule.Schedule<Out, unknown, E2, R2>): Effect.Effect<Resource<A, E>, never, R | R2 | Scope.Scope>A, function (type parameter) E in <A, E, R, Out, E2, R2>(acquire: Effect.Effect<A, E, R>, policy: Schedule.Schedule<Out, unknown, E2, R2>): Effect.Effect<Resource<A, E>, never, R | R2 | Scope.Scope>E, function (type parameter) R in <A, E, R, Out, E2, R2>(acquire: Effect.Effect<A, E, R>, policy: Schedule.Schedule<Out, unknown, E2, R2>): Effect.Effect<Resource<A, E>, never, R | R2 | Scope.Scope>R, function (type parameter) Out in <A, E, R, Out, E2, R2>(acquire: Effect.Effect<A, E, R>, policy: Schedule.Schedule<Out, unknown, E2, R2>): Effect.Effect<Resource<A, E>, never, R | R2 | Scope.Scope>Out, function (type parameter) E2 in <A, E, R, Out, E2, R2>(acquire: Effect.Effect<A, E, R>, policy: Schedule.Schedule<Out, unknown, E2, R2>): Effect.Effect<Resource<A, E>, never, R | R2 | Scope.Scope>E2, function (type parameter) R2 in <A, E, R, Out, E2, R2>(acquire: Effect.Effect<A, E, R>, policy: Schedule.Schedule<Out, unknown, E2, R2>): Effect.Effect<Resource<A, E>, never, R | R2 | Scope.Scope>R2>(
acquire: Effect.Effect<A, E, R>(parameter) acquire: {
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 EffectEffect.type Effect.Effect = /*unresolved*/ anyEffect<function (type parameter) A in <A, E, R, Out, E2, R2>(acquire: Effect.Effect<A, E, R>, policy: Schedule.Schedule<Out, unknown, E2, R2>): Effect.Effect<Resource<A, E>, never, R | R2 | Scope.Scope>A, function (type parameter) E in <A, E, R, Out, E2, R2>(acquire: Effect.Effect<A, E, R>, policy: Schedule.Schedule<Out, unknown, E2, R2>): Effect.Effect<Resource<A, E>, never, R | R2 | Scope.Scope>E, function (type parameter) R in <A, E, R, Out, E2, R2>(acquire: Effect.Effect<A, E, R>, policy: Schedule.Schedule<Out, unknown, E2, R2>): Effect.Effect<Resource<A, E>, never, R | R2 | Scope.Scope>R>,
policy: Schedule.Schedule<Out, unknown, E2, R2>(parameter) policy: {
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; <…;
}
import ScheduleSchedule.interface Schedule<out Output, in Input = unknown, out Error = never, out Env = never>A Schedule defines a strategy for repeating or retrying effects based on some policy.
Example (Defining retry and repeat schedules)
import { Console, Data, Effect, Schedule } from "effect"
class NetworkError extends Data.TaggedError("NetworkError")<{
readonly attempt: number
}> {}
// Basic retry schedule - retry up to 3 times with exponential backoff
const retrySchedule = Schedule.max([
Schedule.exponential("100 millis"),
Schedule.recurs(3)
])
// Basic repeat schedule - repeat every 30 seconds forever
const repeatSchedule: Schedule.Schedule<number, unknown, never> = Schedule
.spaced("30 seconds")
const program = Effect.gen(function*() {
let attempts = 0
const result1 = yield* Effect.retry(
Effect.gen(function*() {
attempts++
if (attempts < 3) {
return yield* Effect.fail(new NetworkError({ attempt: attempts }))
}
return "Success"
}),
retrySchedule
)
console.log(result1) // "Success"
yield* Console.log("heartbeat").pipe(
Effect.repeat(repeatSchedule.pipe(Schedule.upTo({ times: 5 })))
)
})
The Schedule namespace contains types and utilities for working with schedules.
Schedule<function (type parameter) Out in <A, E, R, Out, E2, R2>(acquire: Effect.Effect<A, E, R>, policy: Schedule.Schedule<Out, unknown, E2, R2>): Effect.Effect<Resource<A, E>, never, R | R2 | Scope.Scope>Out, unknown, function (type parameter) E2 in <A, E, R, Out, E2, R2>(acquire: Effect.Effect<A, E, R>, policy: Schedule.Schedule<Out, unknown, E2, R2>): Effect.Effect<Resource<A, E>, never, R | R2 | Scope.Scope>E2, function (type parameter) R2 in <A, E, R, Out, E2, R2>(acquire: Effect.Effect<A, E, R>, policy: Schedule.Schedule<Out, unknown, E2, R2>): Effect.Effect<Resource<A, E>, never, R | R2 | Scope.Scope>R2>
): import EffectEffect.type Effect.Effect = /*unresolved*/ anyEffect<interface Resource<in out A, in out E = never>A Resource is a value loaded into memory that can be refreshed manually or
automatically according to a schedule.
When to use
Use to model a scoped value whose latest acquisition result is kept available
for repeated reads and can be refreshed manually or on a schedule.
Resource<function (type parameter) A in <A, E, R, Out, E2, R2>(acquire: Effect.Effect<A, E, R>, policy: Schedule.Schedule<Out, unknown, E2, R2>): Effect.Effect<Resource<A, E>, never, R | R2 | Scope.Scope>A, function (type parameter) E in <A, E, R, Out, E2, R2>(acquire: Effect.Effect<A, E, R>, policy: Schedule.Schedule<Out, unknown, E2, R2>): Effect.Effect<Resource<A, E>, never, R | R2 | Scope.Scope>E>, never, function (type parameter) R in <A, E, R, Out, E2, R2>(acquire: Effect.Effect<A, E, R>, policy: Schedule.Schedule<Out, unknown, E2, R2>): Effect.Effect<Resource<A, E>, never, R | R2 | Scope.Scope>R | function (type parameter) R2 in <A, E, R, Out, E2, R2>(acquire: Effect.Effect<A, E, R>, policy: Schedule.Schedule<Out, unknown, E2, R2>): Effect.Effect<Resource<A, E>, never, R | R2 | Scope.Scope>R2 | import ScopeScope.Scope> =>
import EffectEffect.tap(
const manual: <A, E, R>(
acquire: Effect.Effect<A, E, R>
) => Effect.Effect<
Resource<A, E>,
never,
Scope.Scope | R
>
Creates a Resource that must be refreshed manually.
When to use
Use when you need manual control over resource refresh timing rather than an
automatic schedule.
manual(acquire: Effect.Effect<A, E, R>(parameter) acquire: {
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;
}
self: Resource<A, E>(parameter) self: {
scopedRef: ScopedRef.ScopedRef<Exit.Exit<A, E>>;
acquire: Effect.Effect<A, E>;
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; <…;
}
import EffectEffect.forkScoped(import EffectEffect.repeat(const refresh: <A, E>(
self: Resource<A, E>
) => Effect.Effect<void, E>
Re-runs this resource's acquisition effect and updates the current value.
When to use
Use to force an existing Resource to reacquire its value at a
caller-controlled point.
Details
When acquisition succeeds, refreshing replaces the value stored in the
resource's scoped reference and releases resources associated with the
previous value.
Gotchas
If acquisition fails, the returned effect fails and the previously stored
result is left as what get reads.
refresh(self: Resource<A, E>(parameter) self: {
scopedRef: ScopedRef.ScopedRef<Exit.Exit<A, E>>;
acquire: Effect.Effect<A, E>;
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; <…;
}
policy: Schedule.Schedule<Out, unknown, E2, R2>(parameter) policy: {
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; <…;
}