(duration: Duration.Input): <A, E, R>(
self: Effect<A, E, R>
) => Effect<A, E | Cause.TimeoutError, R>
<A, E, R>(self: Effect<A, E, R>, duration: Duration.Input): Effect<
A,
E | Cause.TimeoutError,
R
>Adds a time limit to an effect, triggering a timeout if the effect exceeds the duration.
When to use
Use when you need a timeout of an Effect to be represented as a typed
failure.
Details
The timeout function allows you to specify a time limit for an
effect's execution. If the effect does not complete within the given time, a
TimeoutException is raised. This can be useful for controlling how long
your program waits for a task to finish, ensuring that it doesn't hang
indefinitely if the task takes too long.
Gotchas
If the timeout wins, the source effect is interrupted.
Example (Failing when work takes too long)
import { Effect } from "effect"
const task = Effect.gen(function*() {
console.log("Start processing...")
yield* Effect.sleep("2 seconds") // Simulates a delay in processing
console.log("Processing complete.")
return "Result"
})
// Output will show a TimeoutException as the task takes longer
// than the specified timeout duration
const timedEffect = task.pipe(Effect.timeout("1 second"))
Effect.runPromiseExit(timedEffect).then(console.log)
// Output:
// Start processing...
// {
// _id: 'Exit',
// _tag: 'Failure',
// cause: {
// _id: 'Cause',
// _tag: 'Fail',
// failure: { _tag: 'TimeoutException' }
// }
// }export const const timeout: {
(duration: Duration.Input): <A, E, R>(
self: Effect<A, E, R>
) => Effect<A, E | Cause.TimeoutError, R>
<A, E, R>(
self: Effect<A, E, R>,
duration: Duration.Input
): Effect<A, E | Cause.TimeoutError, R>
}
Adds a time limit to an effect, triggering a timeout if the effect exceeds
the duration.
When to use
Use when you need a timeout of an Effect to be represented as a typed
failure.
Details
The timeout function allows you to specify a time limit for an
effect's execution. If the effect does not complete within the given time, a
TimeoutException is raised. This can be useful for controlling how long
your program waits for a task to finish, ensuring that it doesn't hang
indefinitely if the task takes too long.
Gotchas
If the timeout wins, the source effect is interrupted.
Example (Failing when work takes too long)
import { Effect } from "effect"
const task = Effect.gen(function*() {
console.log("Start processing...")
yield* Effect.sleep("2 seconds") // Simulates a delay in processing
console.log("Processing complete.")
return "Result"
})
// Output will show a TimeoutException as the task takes longer
// than the specified timeout duration
const timedEffect = task.pipe(Effect.timeout("1 second"))
Effect.runPromiseExit(timedEffect).then(console.log)
// Output:
// Start processing...
// {
// _id: 'Exit',
// _tag: 'Failure',
// cause: {
// _id: 'Cause',
// _tag: 'Fail',
// failure: { _tag: 'TimeoutException' }
// }
// }
timeout: {
(
duration: Duration.Inputduration: import DurationDuration.type Duration.Input = /*unresolved*/ anyInput
): <function (type parameter) A in <A, E, R>(self: Effect<A, E, R>): Effect<A, E | Cause.TimeoutError, R>A, function (type parameter) E in <A, E, R>(self: Effect<A, E, R>): Effect<A, E | Cause.TimeoutError, R>E, function (type parameter) R in <A, E, R>(self: Effect<A, E, R>): Effect<A, E | Cause.TimeoutError, R>R>(self: Effect<A, E, R>(parameter) self: {
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;
}
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<function (type parameter) A in <A, E, R>(self: Effect<A, E, R>): Effect<A, E | Cause.TimeoutError, R>A, function (type parameter) E in <A, E, R>(self: Effect<A, E, R>): Effect<A, E | Cause.TimeoutError, R>E, function (type parameter) R in <A, E, R>(self: Effect<A, E, R>): Effect<A, E | Cause.TimeoutError, R>R>) => 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<function (type parameter) A in <A, E, R>(self: Effect<A, E, R>): Effect<A, E | Cause.TimeoutError, R>A, function (type parameter) E in <A, E, R>(self: Effect<A, E, R>): Effect<A, E | Cause.TimeoutError, R>E | import CauseCause.type Cause.TimeoutError = /*unresolved*/ anyTimeoutError, function (type parameter) R in <A, E, R>(self: Effect<A, E, R>): Effect<A, E | Cause.TimeoutError, R>R>
<function (type parameter) A in <A, E, R>(self: Effect<A, E, R>, duration: Duration.Input): Effect<A, E | Cause.TimeoutError, R>A, function (type parameter) E in <A, E, R>(self: Effect<A, E, R>, duration: Duration.Input): Effect<A, E | Cause.TimeoutError, R>E, function (type parameter) R in <A, E, R>(self: Effect<A, E, R>, duration: Duration.Input): Effect<A, E | Cause.TimeoutError, R>R>(
self: Effect<A, E, R>(parameter) self: {
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;
}
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<function (type parameter) A in <A, E, R>(self: Effect<A, E, R>, duration: Duration.Input): Effect<A, E | Cause.TimeoutError, R>A, function (type parameter) E in <A, E, R>(self: Effect<A, E, R>, duration: Duration.Input): Effect<A, E | Cause.TimeoutError, R>E, function (type parameter) R in <A, E, R>(self: Effect<A, E, R>, duration: Duration.Input): Effect<A, E | Cause.TimeoutError, R>R>,
duration: Duration.Inputduration: import DurationDuration.type Duration.Input = /*unresolved*/ anyInput
): 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<function (type parameter) A in <A, E, R>(self: Effect<A, E, R>, duration: Duration.Input): Effect<A, E | Cause.TimeoutError, R>A, function (type parameter) E in <A, E, R>(self: Effect<A, E, R>, duration: Duration.Input): Effect<A, E | Cause.TimeoutError, R>E | import CauseCause.type Cause.TimeoutError = /*unresolved*/ anyTimeoutError, function (type parameter) R in <A, E, R>(self: Effect<A, E, R>, duration: Duration.Input): Effect<A, E | Cause.TimeoutError, R>R>
} = import internalinternal.const timeout: {
(duration: Duration.Input): <A, E, R>(
self: Effect.Effect<A, E, R>
) => Effect.Effect<A, E | Cause.TimeoutError, R>
<A, E, R>(
self: Effect.Effect<A, E, R>,
duration: Duration.Input
): Effect.Effect<A, E | Cause.TimeoutError, R>
}