(duration: Duration.Input): <A, E, R>(
self: Effect<A, E, R>
) => Effect<Option<A>, E, R>
<A, E, R>(self: Effect<A, E, R>, duration: Duration.Input): Effect<
Option<A>,
E,
R
>Runs an effect with a time limit and represents only the timeout case as
Option.none.
When to use
Use when a timeout of an Effect should be handled as Option.none.
Details
If the source effect succeeds before the timeout, the returned effect
succeeds with Option.some(value). If the timeout wins, the source effect is
interrupted and the returned effect succeeds with Option.none. If the
source effect fails before the timeout, that failure is preserved.
Example (Returning None on timeout)
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"
})
const timedOutEffect = Effect.all([
task.pipe(Effect.timeoutOption("3 seconds")),
task.pipe(Effect.timeoutOption("1 second"))
])
Effect.runPromise(timedOutEffect).then(console.log)
// Output:
// Start processing...
// Processing complete.
// Start processing...
// [
// { _id: 'Option', _tag: 'Some', value: 'Result' },
// { _id: 'Option', _tag: 'None' }
// ]export const const timeoutOption: {
(duration: Duration.Input): <A, E, R>(
self: Effect<A, E, R>
) => Effect<Option<A>, E, R>
<A, E, R>(
self: Effect<A, E, R>,
duration: Duration.Input
): Effect<Option<A>, E, R>
}
Runs an effect with a time limit and represents only the timeout case as
Option.none.
When to use
Use when a timeout of an Effect should be handled as Option.none.
Details
If the source effect succeeds before the timeout, the returned effect
succeeds with Option.some(value). If the timeout wins, the source effect is
interrupted and the returned effect succeeds with Option.none. If the
source effect fails before the timeout, that failure is preserved.
Example (Returning None on timeout)
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"
})
const timedOutEffect = Effect.all([
task.pipe(Effect.timeoutOption("3 seconds")),
task.pipe(Effect.timeoutOption("1 second"))
])
Effect.runPromise(timedOutEffect).then(console.log)
// Output:
// Start processing...
// Processing complete.
// Start processing...
// [
// { _id: 'Option', _tag: 'Some', value: 'Result' },
// { _id: 'Option', _tag: 'None' }
// ]
timeoutOption: {
(
duration: Duration.Inputduration: import DurationDuration.type Duration.Input = /*unresolved*/ anyInput
): <function (type parameter) A in <A, E, R>(self: Effect<A, E, R>): Effect<Option<A>, E, R>A, function (type parameter) E in <A, E, R>(self: Effect<A, E, R>): Effect<Option<A>, E, R>E, function (type parameter) R in <A, E, R>(self: Effect<A, E, R>): Effect<Option<A>, E, 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<Option<A>, E, R>A, function (type parameter) E in <A, E, R>(self: Effect<A, E, R>): Effect<Option<A>, E, R>E, function (type parameter) R in <A, E, R>(self: Effect<A, E, R>): Effect<Option<A>, E, 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<type Option<A> = None<A> | Some<A>The Option data type represents optional values. An Option<A> is either
Some<A>, containing a value of type A, or None, representing absence.
When to use
Use to represent initial values that may not yet exist
- Returning from partial functions (not defined for all inputs)
- Managing optional fields in data structures
Namespace containing utility types for Option.
When to use
Use to access type-level helpers associated with Option.
Option<function (type parameter) A in <A, E, R>(self: Effect<A, E, R>): Effect<Option<A>, E, R>A>, function (type parameter) E in <A, E, R>(self: Effect<A, E, R>): Effect<Option<A>, E, R>E, function (type parameter) R in <A, E, R>(self: Effect<A, E, R>): Effect<Option<A>, E, R>R>
<function (type parameter) A in <A, E, R>(self: Effect<A, E, R>, duration: Duration.Input): Effect<Option<A>, E, R>A, function (type parameter) E in <A, E, R>(self: Effect<A, E, R>, duration: Duration.Input): Effect<Option<A>, E, R>E, function (type parameter) R in <A, E, R>(self: Effect<A, E, R>, duration: Duration.Input): Effect<Option<A>, E, 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<Option<A>, E, R>A, function (type parameter) E in <A, E, R>(self: Effect<A, E, R>, duration: Duration.Input): Effect<Option<A>, E, R>E, function (type parameter) R in <A, E, R>(self: Effect<A, E, R>, duration: Duration.Input): Effect<Option<A>, E, 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<type Option<A> = None<A> | Some<A>The Option data type represents optional values. An Option<A> is either
Some<A>, containing a value of type A, or None, representing absence.
When to use
Use to represent initial values that may not yet exist
- Returning from partial functions (not defined for all inputs)
- Managing optional fields in data structures
Namespace containing utility types for Option.
When to use
Use to access type-level helpers associated with Option.
Option<function (type parameter) A in <A, E, R>(self: Effect<A, E, R>, duration: Duration.Input): Effect<Option<A>, E, R>A>, function (type parameter) E in <A, E, R>(self: Effect<A, E, R>, duration: Duration.Input): Effect<Option<A>, E, R>E, function (type parameter) R in <A, E, R>(self: Effect<A, E, R>, duration: Duration.Input): Effect<Option<A>, E, R>R>
} = import internalinternal.const timeoutOption: {
(duration: Duration.Input): <A, E, R>(
self: Effect.Effect<A, E, R>
) => Effect.Effect<Option.Option<A>, E, R>
<A, E, R>(
self: Effect.Effect<A, E, R>,
duration: Duration.Input
): Effect.Effect<Option.Option<A>, E, R>
}