<B, E, R, S extends Iterable<any>, const Discard extends boolean = false>(
f: (a: Arr.ReadonlyArray.Infer<S>, i: number) => Effect<B, E, R>,
options?:
| {
readonly concurrency?: Concurrency | undefined
readonly discard?: Discard | undefined
}
| undefined
): (
self: S
) => Effect<
Discard extends false ? Arr.ReadonlyArray.With<S, B> : void,
E,
R
>
<B, E, R, S extends Iterable<any>, const Discard extends boolean = false>(
self: S,
f: (a: Arr.ReadonlyArray.Infer<S>, i: number) => Effect<B, E, R>,
options?:
| {
readonly concurrency?: Concurrency | undefined
readonly discard?: Discard | undefined
}
| undefined
): Effect<
Discard extends false ? Arr.ReadonlyArray.With<S, B> : void,
E,
R
>Executes an effectful operation for each element in an Iterable.
When to use
Use to traverse an iterable with an effectful function while preserving element order in the collected results.
Details
The forEach function applies a provided operation to each element in the
iterable, producing a new effect that returns an array of results.
If any effect fails, the iteration stops immediately (short-circuiting), and the error is propagated.
Concurrency:
The concurrency option controls how many operations are performed
concurrently. By default, the operations are performed sequentially.
Discarding Results:
If the discard option is set to true, the intermediate results are not
collected, and the final result of the operation is void.
Example (Mapping over an iterable with effects)
import { Console, Effect } from "effect"
const result = Effect.forEach(
[1, 2, 3, 4, 5],
(n, index) =>
Console.log(`Currently at index ${index}`).pipe(Effect.as(n * 2))
)
Effect.runPromise(result).then(console.log)
// Output:
// Currently at index 0
// Currently at index 1
// Currently at index 2
// Currently at index 3
// Currently at index 4
// [ 2, 4, 6, 8, 10 ]Example (Running effects without collecting results)
import { Console, Effect } from "effect"
// Apply effects but discard the results
const result = Effect.forEach(
[1, 2, 3, 4, 5],
(n, index) =>
Console.log(`Currently at index ${index}`).pipe(Effect.as(n * 2)),
{ discard: true }
)
Effect.runPromise(result).then(console.log)
// Output:
// Currently at index 0
// Currently at index 1
// Currently at index 2
// Currently at index 3
// Currently at index 4
// undefinedexport const const forEach: {
<
B,
E,
R,
S extends Iterable<any>,
Discard extends boolean = false
>(
f: (
a: Arr.ReadonlyArray.Infer<S>,
i: number
) => Effect<B, E, R>,
options?:
| {
readonly concurrency?:
| Concurrency
| undefined
readonly discard?: Discard | undefined
}
| undefined
): (
self: S
) => Effect<
Discard extends false
? Arr.ReadonlyArray.With<S, B>
: void,
E,
R
>
<
B,
E,
R,
S extends Iterable<any>,
Discard extends boolean = false
>(
self: S,
f: (
a: Arr.ReadonlyArray.Infer<S>,
i: number
) => Effect<B, E, R>,
options?:
| {
readonly concurrency?:
| Concurrency
| undefined
readonly discard?: Discard | undefined
}
| undefined
): Effect<
Discard extends false
? Arr.ReadonlyArray.With<S, B>
: void,
E,
R
>
}
Executes an effectful operation for each element in an Iterable.
When to use
Use to traverse an iterable with an effectful function while preserving
element order in the collected results.
Details
The forEach function applies a provided operation to each element in the
iterable, producing a new effect that returns an array of results.
If any effect fails, the iteration stops immediately (short-circuiting), and
the error is propagated.
Concurrency:
The concurrency option controls how many operations are performed
concurrently. By default, the operations are performed sequentially.
Discarding Results:
If the discard option is set to true, the intermediate results are not
collected, and the final result of the operation is void.
Example (Mapping over an iterable with effects)
import { Console, Effect } from "effect"
const result = Effect.forEach(
[1, 2, 3, 4, 5],
(n, index) =>
Console.log(`Currently at index ${index}`).pipe(Effect.as(n * 2))
)
Effect.runPromise(result).then(console.log)
// Output:
// Currently at index 0
// Currently at index 1
// Currently at index 2
// Currently at index 3
// Currently at index 4
// [ 2, 4, 6, 8, 10 ]
Example (Running effects without collecting results)
import { Console, Effect } from "effect"
// Apply effects but discard the results
const result = Effect.forEach(
[1, 2, 3, 4, 5],
(n, index) =>
Console.log(`Currently at index ${index}`).pipe(Effect.as(n * 2)),
{ discard: true }
)
Effect.runPromise(result).then(console.log)
// Output:
// Currently at index 0
// Currently at index 1
// Currently at index 2
// Currently at index 3
// Currently at index 4
// undefined
forEach: {
<function (type parameter) B in <B, E, R, S extends Iterable<any>, const Discard extends boolean = false>(f: (a: Arr.ReadonlyArray.Infer<S>, i: number) => Effect<B, E, R>, options?: {
readonly concurrency?: Concurrency | undefined;
readonly discard?: Discard | undefined;
} | undefined): (self: S) => Effect<Discard extends false ? Arr.ReadonlyArray.With<S, B> : void, E, R>
B, function (type parameter) E in <B, E, R, S extends Iterable<any>, const Discard extends boolean = false>(f: (a: Arr.ReadonlyArray.Infer<S>, i: number) => Effect<B, E, R>, options?: {
readonly concurrency?: Concurrency | undefined;
readonly discard?: Discard | undefined;
} | undefined): (self: S) => Effect<Discard extends false ? Arr.ReadonlyArray.With<S, B> : void, E, R>
E, function (type parameter) R in <B, E, R, S extends Iterable<any>, const Discard extends boolean = false>(f: (a: Arr.ReadonlyArray.Infer<S>, i: number) => Effect<B, E, R>, options?: {
readonly concurrency?: Concurrency | undefined;
readonly discard?: Discard | undefined;
} | undefined): (self: S) => Effect<Discard extends false ? Arr.ReadonlyArray.With<S, B> : void, E, R>
R, function (type parameter) S in <B, E, R, S extends Iterable<any>, const Discard extends boolean = false>(f: (a: Arr.ReadonlyArray.Infer<S>, i: number) => Effect<B, E, R>, options?: {
readonly concurrency?: Concurrency | undefined;
readonly discard?: Discard | undefined;
} | undefined): (self: S) => Effect<Discard extends false ? Arr.ReadonlyArray.With<S, B> : void, E, R>
S extends interface Iterable<T, TReturn = any, TNext = any>Iterable<any>, const function (type parameter) Discard in <B, E, R, S extends Iterable<any>, const Discard extends boolean = false>(f: (a: Arr.ReadonlyArray.Infer<S>, i: number) => Effect<B, E, R>, options?: {
readonly concurrency?: Concurrency | undefined;
readonly discard?: Discard | undefined;
} | undefined): (self: S) => Effect<Discard extends false ? Arr.ReadonlyArray.With<S, B> : void, E, R>
Discard extends boolean = false>(
f: (
a: Arr.ReadonlyArray.Infer<S>,
i: number
) => Effect<B, E, R>
f: (a: Arr.ReadonlyArray.Infer<S>a: import ArrArr.declareReadonlyArray.type Arr.ReadonlyArray.Infer = /*unresolved*/ anyInfer<function (type parameter) S in <B, E, R, S extends Iterable<any>, const Discard extends boolean = false>(f: (a: Arr.ReadonlyArray.Infer<S>, i: number) => Effect<B, E, R>, options?: {
readonly concurrency?: Concurrency | undefined;
readonly discard?: Discard | undefined;
} | undefined): (self: S) => Effect<Discard extends false ? Arr.ReadonlyArray.With<S, B> : void, E, R>
S>, i: numberi: number) => 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) B in <B, E, R, S extends Iterable<any>, const Discard extends boolean = false>(f: (a: Arr.ReadonlyArray.Infer<S>, i: number) => Effect<B, E, R>, options?: {
readonly concurrency?: Concurrency | undefined;
readonly discard?: Discard | undefined;
} | undefined): (self: S) => Effect<Discard extends false ? Arr.ReadonlyArray.With<S, B> : void, E, R>
B, function (type parameter) E in <B, E, R, S extends Iterable<any>, const Discard extends boolean = false>(f: (a: Arr.ReadonlyArray.Infer<S>, i: number) => Effect<B, E, R>, options?: {
readonly concurrency?: Concurrency | undefined;
readonly discard?: Discard | undefined;
} | undefined): (self: S) => Effect<Discard extends false ? Arr.ReadonlyArray.With<S, B> : void, E, R>
E, function (type parameter) R in <B, E, R, S extends Iterable<any>, const Discard extends boolean = false>(f: (a: Arr.ReadonlyArray.Infer<S>, i: number) => Effect<B, E, R>, options?: {
readonly concurrency?: Concurrency | undefined;
readonly discard?: Discard | undefined;
} | undefined): (self: S) => Effect<Discard extends false ? Arr.ReadonlyArray.With<S, B> : void, E, R>
R>,
options: | {
readonly concurrency?:
| Concurrency
| undefined
readonly discard?: Discard | undefined
}
| undefined
options?: { readonly concurrency?: Concurrency | undefinedconcurrency?: type Concurrency = number | "unbounded" | "inherit"Describes the concurrency level for Effect operations that run multiple
effects.
When to use
Use to type options that control how many effects may run at the same time.
Details
number — run at most N effects concurrently.
"unbounded" — run all effects concurrently with no limit.
"inherit" — inherit the concurrency from the surrounding context.
Example (Setting concurrency values)
import type { Types } from "effect"
const sequential: Types.Concurrency = 1
const limited: Types.Concurrency = 5
const unbounded: Types.Concurrency = "unbounded"
const inherit: Types.Concurrency = "inherit"
Concurrency | undefined; readonly discard?: Discard | undefineddiscard?: function (type parameter) Discard in <B, E, R, S extends Iterable<any>, const Discard extends boolean = false>(f: (a: Arr.ReadonlyArray.Infer<S>, i: number) => Effect<B, E, R>, options?: {
readonly concurrency?: Concurrency | undefined;
readonly discard?: Discard | undefined;
} | undefined): (self: S) => Effect<Discard extends false ? Arr.ReadonlyArray.With<S, B> : void, E, R>
Discard | undefined } | undefined
): (self: S extends Iterable<any>self: function (type parameter) S in <B, E, R, S extends Iterable<any>, const Discard extends boolean = false>(f: (a: Arr.ReadonlyArray.Infer<S>, i: number) => Effect<B, E, R>, options?: {
readonly concurrency?: Concurrency | undefined;
readonly discard?: Discard | undefined;
} | undefined): (self: S) => Effect<Discard extends false ? Arr.ReadonlyArray.With<S, B> : void, E, R>
S) => 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) Discard in <B, E, R, S extends Iterable<any>, const Discard extends boolean = false>(f: (a: Arr.ReadonlyArray.Infer<S>, i: number) => Effect<B, E, R>, options?: {
readonly concurrency?: Concurrency | undefined;
readonly discard?: Discard | undefined;
} | undefined): (self: S) => Effect<Discard extends false ? Arr.ReadonlyArray.With<S, B> : void, E, R>
Discard extends false ? import ArrArr.declareReadonlyArray.type Arr.ReadonlyArray.With = /*unresolved*/ anyWith<function (type parameter) S in <B, E, R, S extends Iterable<any>, const Discard extends boolean = false>(f: (a: Arr.ReadonlyArray.Infer<S>, i: number) => Effect<B, E, R>, options?: {
readonly concurrency?: Concurrency | undefined;
readonly discard?: Discard | undefined;
} | undefined): (self: S) => Effect<Discard extends false ? Arr.ReadonlyArray.With<S, B> : void, E, R>
S, function (type parameter) B in <B, E, R, S extends Iterable<any>, const Discard extends boolean = false>(f: (a: Arr.ReadonlyArray.Infer<S>, i: number) => Effect<B, E, R>, options?: {
readonly concurrency?: Concurrency | undefined;
readonly discard?: Discard | undefined;
} | undefined): (self: S) => Effect<Discard extends false ? Arr.ReadonlyArray.With<S, B> : void, E, R>
B> : void, function (type parameter) E in <B, E, R, S extends Iterable<any>, const Discard extends boolean = false>(f: (a: Arr.ReadonlyArray.Infer<S>, i: number) => Effect<B, E, R>, options?: {
readonly concurrency?: Concurrency | undefined;
readonly discard?: Discard | undefined;
} | undefined): (self: S) => Effect<Discard extends false ? Arr.ReadonlyArray.With<S, B> : void, E, R>
E, function (type parameter) R in <B, E, R, S extends Iterable<any>, const Discard extends boolean = false>(f: (a: Arr.ReadonlyArray.Infer<S>, i: number) => Effect<B, E, R>, options?: {
readonly concurrency?: Concurrency | undefined;
readonly discard?: Discard | undefined;
} | undefined): (self: S) => Effect<Discard extends false ? Arr.ReadonlyArray.With<S, B> : void, E, R>
R>
<function (type parameter) B in <B, E, R, S extends Iterable<any>, const Discard extends boolean = false>(self: S, f: (a: Arr.ReadonlyArray.Infer<S>, i: number) => Effect<B, E, R>, options?: {
readonly concurrency?: Concurrency | undefined;
readonly discard?: Discard | undefined;
} | undefined): Effect<Discard extends false ? Arr.ReadonlyArray.With<S, B> : void, E, R>
B, function (type parameter) E in <B, E, R, S extends Iterable<any>, const Discard extends boolean = false>(self: S, f: (a: Arr.ReadonlyArray.Infer<S>, i: number) => Effect<B, E, R>, options?: {
readonly concurrency?: Concurrency | undefined;
readonly discard?: Discard | undefined;
} | undefined): Effect<Discard extends false ? Arr.ReadonlyArray.With<S, B> : void, E, R>
E, function (type parameter) R in <B, E, R, S extends Iterable<any>, const Discard extends boolean = false>(self: S, f: (a: Arr.ReadonlyArray.Infer<S>, i: number) => Effect<B, E, R>, options?: {
readonly concurrency?: Concurrency | undefined;
readonly discard?: Discard | undefined;
} | undefined): Effect<Discard extends false ? Arr.ReadonlyArray.With<S, B> : void, E, R>
R, function (type parameter) S in <B, E, R, S extends Iterable<any>, const Discard extends boolean = false>(self: S, f: (a: Arr.ReadonlyArray.Infer<S>, i: number) => Effect<B, E, R>, options?: {
readonly concurrency?: Concurrency | undefined;
readonly discard?: Discard | undefined;
} | undefined): Effect<Discard extends false ? Arr.ReadonlyArray.With<S, B> : void, E, R>
S extends interface Iterable<T, TReturn = any, TNext = any>Iterable<any>, const function (type parameter) Discard in <B, E, R, S extends Iterable<any>, const Discard extends boolean = false>(self: S, f: (a: Arr.ReadonlyArray.Infer<S>, i: number) => Effect<B, E, R>, options?: {
readonly concurrency?: Concurrency | undefined;
readonly discard?: Discard | undefined;
} | undefined): Effect<Discard extends false ? Arr.ReadonlyArray.With<S, B> : void, E, R>
Discard extends boolean = false>(
self: S extends Iterable<any>self: function (type parameter) S in <B, E, R, S extends Iterable<any>, const Discard extends boolean = false>(self: S, f: (a: Arr.ReadonlyArray.Infer<S>, i: number) => Effect<B, E, R>, options?: {
readonly concurrency?: Concurrency | undefined;
readonly discard?: Discard | undefined;
} | undefined): Effect<Discard extends false ? Arr.ReadonlyArray.With<S, B> : void, E, R>
S,
f: (
a: Arr.ReadonlyArray.Infer<S>,
i: number
) => Effect<B, E, R>
f: (a: Arr.ReadonlyArray.Infer<S>a: import ArrArr.declareReadonlyArray.type Arr.ReadonlyArray.Infer = /*unresolved*/ anyInfer<function (type parameter) S in <B, E, R, S extends Iterable<any>, const Discard extends boolean = false>(self: S, f: (a: Arr.ReadonlyArray.Infer<S>, i: number) => Effect<B, E, R>, options?: {
readonly concurrency?: Concurrency | undefined;
readonly discard?: Discard | undefined;
} | undefined): Effect<Discard extends false ? Arr.ReadonlyArray.With<S, B> : void, E, R>
S>, i: numberi: number) => 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) B in <B, E, R, S extends Iterable<any>, const Discard extends boolean = false>(self: S, f: (a: Arr.ReadonlyArray.Infer<S>, i: number) => Effect<B, E, R>, options?: {
readonly concurrency?: Concurrency | undefined;
readonly discard?: Discard | undefined;
} | undefined): Effect<Discard extends false ? Arr.ReadonlyArray.With<S, B> : void, E, R>
B, function (type parameter) E in <B, E, R, S extends Iterable<any>, const Discard extends boolean = false>(self: S, f: (a: Arr.ReadonlyArray.Infer<S>, i: number) => Effect<B, E, R>, options?: {
readonly concurrency?: Concurrency | undefined;
readonly discard?: Discard | undefined;
} | undefined): Effect<Discard extends false ? Arr.ReadonlyArray.With<S, B> : void, E, R>
E, function (type parameter) R in <B, E, R, S extends Iterable<any>, const Discard extends boolean = false>(self: S, f: (a: Arr.ReadonlyArray.Infer<S>, i: number) => Effect<B, E, R>, options?: {
readonly concurrency?: Concurrency | undefined;
readonly discard?: Discard | undefined;
} | undefined): Effect<Discard extends false ? Arr.ReadonlyArray.With<S, B> : void, E, R>
R>,
options: | {
readonly concurrency?:
| Concurrency
| undefined
readonly discard?: Discard | undefined
}
| undefined
options?: { readonly concurrency?: Concurrency | undefinedconcurrency?: type Concurrency = number | "unbounded" | "inherit"Describes the concurrency level for Effect operations that run multiple
effects.
When to use
Use to type options that control how many effects may run at the same time.
Details
number — run at most N effects concurrently.
"unbounded" — run all effects concurrently with no limit.
"inherit" — inherit the concurrency from the surrounding context.
Example (Setting concurrency values)
import type { Types } from "effect"
const sequential: Types.Concurrency = 1
const limited: Types.Concurrency = 5
const unbounded: Types.Concurrency = "unbounded"
const inherit: Types.Concurrency = "inherit"
Concurrency | undefined; readonly discard?: Discard | undefineddiscard?: function (type parameter) Discard in <B, E, R, S extends Iterable<any>, const Discard extends boolean = false>(self: S, f: (a: Arr.ReadonlyArray.Infer<S>, i: number) => Effect<B, E, R>, options?: {
readonly concurrency?: Concurrency | undefined;
readonly discard?: Discard | undefined;
} | undefined): Effect<Discard extends false ? Arr.ReadonlyArray.With<S, B> : void, E, R>
Discard | undefined } | undefined
): 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) Discard in <B, E, R, S extends Iterable<any>, const Discard extends boolean = false>(self: S, f: (a: Arr.ReadonlyArray.Infer<S>, i: number) => Effect<B, E, R>, options?: {
readonly concurrency?: Concurrency | undefined;
readonly discard?: Discard | undefined;
} | undefined): Effect<Discard extends false ? Arr.ReadonlyArray.With<S, B> : void, E, R>
Discard extends false ? import ArrArr.declareReadonlyArray.type Arr.ReadonlyArray.With = /*unresolved*/ anyWith<function (type parameter) S in <B, E, R, S extends Iterable<any>, const Discard extends boolean = false>(self: S, f: (a: Arr.ReadonlyArray.Infer<S>, i: number) => Effect<B, E, R>, options?: {
readonly concurrency?: Concurrency | undefined;
readonly discard?: Discard | undefined;
} | undefined): Effect<Discard extends false ? Arr.ReadonlyArray.With<S, B> : void, E, R>
S, function (type parameter) B in <B, E, R, S extends Iterable<any>, const Discard extends boolean = false>(self: S, f: (a: Arr.ReadonlyArray.Infer<S>, i: number) => Effect<B, E, R>, options?: {
readonly concurrency?: Concurrency | undefined;
readonly discard?: Discard | undefined;
} | undefined): Effect<Discard extends false ? Arr.ReadonlyArray.With<S, B> : void, E, R>
B> : void, function (type parameter) E in <B, E, R, S extends Iterable<any>, const Discard extends boolean = false>(self: S, f: (a: Arr.ReadonlyArray.Infer<S>, i: number) => Effect<B, E, R>, options?: {
readonly concurrency?: Concurrency | undefined;
readonly discard?: Discard | undefined;
} | undefined): Effect<Discard extends false ? Arr.ReadonlyArray.With<S, B> : void, E, R>
E, function (type parameter) R in <B, E, R, S extends Iterable<any>, const Discard extends boolean = false>(self: S, f: (a: Arr.ReadonlyArray.Infer<S>, i: number) => Effect<B, E, R>, options?: {
readonly concurrency?: Concurrency | undefined;
readonly discard?: Discard | undefined;
} | undefined): Effect<Discard extends false ? Arr.ReadonlyArray.With<S, B> : void, E, R>
R>
} = import internalinternal.const forEach: {
<
B,
E,
R,
S extends Iterable<any>,
Discard extends boolean = false
>(
f: (
a: Arr.ReadonlyArray.Infer<S>,
i: number
) => Effect.Effect<B, E, R>,
options?:
| {
readonly concurrency?:
| Concurrency
| undefined
readonly discard?: Discard | undefined
}
| undefined
): (
self: S
) => Effect.Effect<
Discard extends false
? Arr.ReadonlyArray.With<S, B>
: void,
E,
R
>
<
B,
E,
R,
S extends Iterable<any>,
Discard extends boolean = false
>(
self: S,
f: (
a: Arr.ReadonlyArray.Infer<S>,
i: number
) => Effect.Effect<B, E, R>,
options?:
| {
readonly concurrency?:
| Concurrency
| undefined
readonly discard?: Discard | undefined
}
| undefined
): Effect.Effect<
Discard extends false
? Arr.ReadonlyArray.With<S, B>
: void,
E,
R
>
}
forEach