<S, In, E, R>(
initial: LazyArg<S>,
predicate: Predicate<S>,
f: (s: S, input: In) => Effect.Effect<S, E, R>
): Sink<S, In, In, E, R>A sink that effectfully reduces input elements from the provided initial
state with f while the specified predicate returns true.
reducing
Source effect/Sink.ts:125433 lines
export const const reduceWhileEffect: <S, In, E, R>(
initial: LazyArg<S>,
predicate: Predicate<S>,
f: (s: S, input: In) => Effect.Effect<S, E, R>
) => Sink<S, In, In, E, R>
A sink that effectfully reduces input elements from the provided initial
state with f while the specified predicate returns true.
reduceWhileEffect = <function (type parameter) S in <S, In, E, R>(initial: LazyArg<S>, predicate: Predicate<S>, f: (s: S, input: In) => Effect.Effect<S, E, R>): Sink<S, In, In, E, R>S, function (type parameter) In in <S, In, E, R>(initial: LazyArg<S>, predicate: Predicate<S>, f: (s: S, input: In) => Effect.Effect<S, E, R>): Sink<S, In, In, E, R>In, function (type parameter) E in <S, In, E, R>(initial: LazyArg<S>, predicate: Predicate<S>, f: (s: S, input: In) => Effect.Effect<S, E, R>): Sink<S, In, In, E, R>E, function (type parameter) R in <S, In, E, R>(initial: LazyArg<S>, predicate: Predicate<S>, f: (s: S, input: In) => Effect.Effect<S, E, R>): Sink<S, In, In, E, R>R>(
initial: LazyArg<S>initial: type LazyArg<A> = () => AA zero-argument function that produces a value when invoked.
When to use
Use to type a lazy value provider that should not run until called.
Example (Creating a lazy argument)
import { Function } from "effect"
const constNull: Function.LazyArg<null> = Function.constant(null)
LazyArg<function (type parameter) S in <S, In, E, R>(initial: LazyArg<S>, predicate: Predicate<S>, f: (s: S, input: In) => Effect.Effect<S, E, R>): Sink<S, In, In, E, R>S>,
predicate: Predicate<S>predicate: interface Predicate<in A>A function that decides whether a value of type A satisfies a condition.
When to use
Use when you want a reusable boolean check for A, especially when you plan
to combine checks with
and
/
or
or pass a predicate to arrays
and iterables.
Details
A predicate returns true or false and never throws by itself. It does not
narrow types unless you use Refinement.
Example (Defining a predicate)
import { Predicate } from "effect"
const isPositive: Predicate.Predicate<number> = (n) => n > 0
console.log(isPositive(1))
Type-level utilities for working with
Predicate
types.
When to use
Use when you need to extract input types from predicate signatures while
writing generic helpers over predicate types.
Details
These utilities are type-only, create no runtime values, and the namespace is
erased at runtime.
Example (Extracting predicate input)
import { Predicate } from "effect"
type IsString = Predicate.Predicate<string>
type Input = Predicate.Predicate.In<IsString>
Predicate<function (type parameter) S in <S, In, E, R>(initial: LazyArg<S>, predicate: Predicate<S>, f: (s: S, input: In) => Effect.Effect<S, E, R>): Sink<S, In, In, E, R>S>,
f: (
s: S,
input: In
) => Effect.Effect<S, E, R>
s: Ss: function (type parameter) S in <S, In, E, R>(initial: LazyArg<S>, predicate: Predicate<S>, f: (s: S, input: In) => Effect.Effect<S, E, R>): Sink<S, In, In, E, R>S, input: Ininput: function (type parameter) In in <S, In, E, R>(initial: LazyArg<S>, predicate: Predicate<S>, f: (s: S, input: In) => Effect.Effect<S, E, R>): Sink<S, In, In, E, R>In) => 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<function (type parameter) S in <S, In, E, R>(initial: LazyArg<S>, predicate: Predicate<S>, f: (s: S, input: In) => Effect.Effect<S, E, R>): Sink<S, In, In, E, R>S, function (type parameter) E in <S, In, E, R>(initial: LazyArg<S>, predicate: Predicate<S>, f: (s: S, input: In) => Effect.Effect<S, E, R>): Sink<S, In, In, E, R>E, function (type parameter) R in <S, In, E, R>(initial: LazyArg<S>, predicate: Predicate<S>, f: (s: S, input: In) => Effect.Effect<S, E, R>): Sink<S, In, In, E, R>R>
): interface Sink<out A, in In = unknown, out L = never, out E = never, out R = never>A Sink<A, In, L, E, R> is used to consume elements produced by a Stream.
You can think of a sink as a function that will consume a variable amount of
In elements (could be 0, 1, or many), might fail with an error of type E,
and will eventually yield a value of type A together with a remainder of
type L (i.e. any leftovers).
Example (Running a sink with a stream)
import { Effect, Sink, Stream } from "effect"
// Create a simple sink that always succeeds with a value
const sink: Sink.Sink<number> = Sink.succeed(42)
// Use the sink to consume a stream
const stream = Stream.make(1, 2, 3)
const program = Stream.run(stream, sink)
Effect.runPromise(program).then(console.log)
// Output: 42
Namespace containing types and interfaces for Sink variance and type relationships.
Sink<function (type parameter) S in <S, In, E, R>(initial: LazyArg<S>, predicate: Predicate<S>, f: (s: S, input: In) => Effect.Effect<S, E, R>): Sink<S, In, In, E, R>S, function (type parameter) In in <S, In, E, R>(initial: LazyArg<S>, predicate: Predicate<S>, f: (s: S, input: In) => Effect.Effect<S, E, R>): Sink<S, In, In, E, R>In, function (type parameter) In in <S, In, E, R>(initial: LazyArg<S>, predicate: Predicate<S>, f: (s: S, input: In) => Effect.Effect<S, E, R>): Sink<S, In, In, E, R>In, function (type parameter) E in <S, In, E, R>(initial: LazyArg<S>, predicate: Predicate<S>, f: (s: S, input: In) => Effect.Effect<S, E, R>): Sink<S, In, In, E, R>E, function (type parameter) R in <S, In, E, R>(initial: LazyArg<S>, predicate: Predicate<S>, f: (s: S, input: In) => Effect.Effect<S, E, R>): Sink<S, In, In, E, R>R> =>
const fromTransform: <
In,
A,
E,
R,
L = never
>(
transform: (
upstream: Pull.Pull<
NonEmptyReadonlyArray<In>,
never,
void
>,
scope: Scope.Scope
) => Effect.Effect<End<A, L>, E, R>
) => Sink<A, In, L, E, R>
Creates a Sink from a low-level transform function.
Details
The transform receives the upstream pull of non-empty input arrays and the
active scope, and returns an effect that completes with the sink's End
value.
fromTransform((upstream: Pull.Pull<
readonly [In, ...In[]],
never,
void,
never
>
(parameter) upstream: {
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;
}
let state: Sstate = initial: LazyArg<S>initial()
let let leftover:
| NonEmptyReadonlyArray<In>
| undefined
type NonEmptyReadonlyArray<A> = readonly [A, ...A[]]A readonly array guaranteed to have at least one element.
When to use
Use when non-emptiness must be tracked at the type level while preventing mutation.
Many Array module functions accept or return this type.
Example (Typing a non-empty array)
import type { Array } from "effect"
const nonEmpty: Array.NonEmptyReadonlyArray<number> = [1, 2, 3]
const head: number = nonEmpty[0] // guaranteed to exist
NonEmptyReadonlyArray<function (type parameter) In in <S, In, E, R>(initial: LazyArg<S>, predicate: Predicate<S>, f: (s: S, input: In) => Effect.Effect<S, E, R>): Sink<S, In, In, E, R>In> | undefined = var undefinedundefined
if (!predicate: Predicate<S>predicate(let state: Sstate)) {
return import EffectEffect.const succeed: <A>(value: A) => Effect<A>Creates an Effect that always succeeds with a given value.
When to use
Use when an effect should complete successfully with a specific value without any errors
or external dependencies.
Example (Creating a successful effect)
import { Effect } from "effect"
// Creating an effect that represents a successful scenario
//
// ┌─── Effect<number, never, never>
// ▼
const success = Effect.succeed(42)
succeed([let state: Sstate] as type const = readonly [S]const)
}
return upstream: Pull.Pull<
readonly [In, ...In[]],
never,
void,
never
>
(parameter) upstream: {
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;
}
Pipeable.pipe<Pull.Pull<readonly [In, ...In[]], never, void, never>, Effect.Effect<void, Cause.Done<void> | E, R>, Effect.Effect<never, Cause.Done<void> | E, R>, Effect.Effect<readonly [S, readonly [In, ...In[]] | undefined], Exclude<E, Cause.Done<any>>, R>>(this: Pull.Pull<...>, ab: (_: Pull.Pull<readonly [In, ...In[]], never, void, never>) => Effect.Effect<void, Cause.Done<void> | E, R>, bc: (_: Effect.Effect<void, Cause.Done<void> | E, R>) => Effect.Effect<...>, cd: (_: Effect.Effect<...>) => Effect.Effect<...>): Effect.Effect<...> (+21 overloads)pipe(
import EffectEffect.const flatMap: {
<A, B, E1, R1>(
f: (a: A) => Effect<B, E1, R1>
): <E, R>(
self: Effect<A, E, R>
) => Effect<B, E1 | E, R1 | R>
<A, E, R, B, E1, R1>(
self: Effect<A, E, R>,
f: (a: A) => Effect<B, E1, R1>
): Effect<B, E | E1, R | R1>
}
arr: readonly [In, ...In[]](parameter) arr: {
0: In;
length: number;
toString: () => string;
toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string };
concat: { (...items: Array<ConcatArray<In>>): Array<In>; (...items: Array<In | ConcatArray<In>>): Array<In> };
join: (separator?: string) => string;
slice: (start?: number, end?: number) => Array<In>;
indexOf: (searchElement: In, fromIndex?: number) => number;
lastIndexOf: (searchElement: In, fromIndex?: number) => number;
every: { (predicate: (value: In, index: number, array: ReadonlyArray<In>) => value is S, thisArg?: any): this is readonly S[]; (predicate: (value: In, index: number, array: ReadonlyArray<In>) => unknown, thisArg?: any): boolean };
some: (predicate: (value: In, index: number, array: ReadonlyArray<In>) => unknown, thisArg?: any) => boolean;
forEach: (callbackfn: (value: In, index: number, array: ReadonlyArray<In>) => void, thisArg?: any) => void;
map: (callbackfn: (value: In, index: number, array: ReadonlyArray<In>) => U, thisArg?: any) => Array<U>;
filter: { (predicate: (value: In, index: number, array: ReadonlyArray<In>) => value is S, thisArg?: any): Array<S>; (predicate: (value: In, index: number, array: ReadonlyArray<In>) => unknown, thisArg?: any): Array<In> };
reduce: { (callbackfn: (previousValue: In, currentValue: In, currentIndex: number, array: ReadonlyArray<In>) => In): In; (callbackfn: (previousValue: In, currentValue: In, currentIndex: number, array: ReadonlyArray<In>) => In, initialValue: In): I…;
reduceRight: { (callbackfn: (previousValue: In, currentValue: In, currentIndex: number, array: ReadonlyArray<In>) => In): In; (callbackfn: (previousValue: In, currentValue: In, currentIndex: number, array: ReadonlyArray<In>) => In, initialValue: In): I…;
find: { (predicate: (value: In, index: number, obj: ReadonlyArray<In>) => value is S, thisArg?: any): S | undefined; (predicate: (value: In, index: number, obj: ReadonlyArray<In>) => unknown, thisArg?: any): In | undefined };
findIndex: (predicate: (value: In, index: number, obj: ReadonlyArray<In>) => unknown, thisArg?: any) => number;
entries: () => ArrayIterator<[number, In]>;
keys: () => ArrayIterator<number>;
values: () => ArrayIterator<In>;
includes: (searchElement: In, fromIndex?: number) => boolean;
flatMap: (callback: (this: This, value: In, index: number, array: Array<In>) => U | ReadonlyArray<U>, thisArg?: This | undefined) => Array<U>;
flat: (this: A, depth?: D | undefined) => Array<FlatArray<A, D>>;
at: (index: number) => In | undefined;
findLast: { (predicate: (value: In, index: number, array: ReadonlyArray<In>) => value is S, thisArg?: any): S | undefined; (predicate: (value: In, index: number, array: ReadonlyArray<In>) => unknown, thisArg?: any): In | undefined };
findLastIndex: (predicate: (value: In, index: number, array: ReadonlyArray<In>) => unknown, thisArg?: any) => number;
toReversed: () => Array<In>;
toSorted: (compareFn?: ((a: In, b: In) => number) | undefined) => Array<In>;
toSpliced: { (start: number, deleteCount: number, ...items: Array<In>): Array<In>; (start: number, deleteCount?: number): Array<In> };
with: (index: number, value: In) => Array<In>;
}
let i: numberi = 0
return import EffectEffect.const whileLoop: <A, E, R>(options: {
readonly while: LazyArg<boolean>
readonly body: LazyArg<Effect<A, E, R>>
readonly step: (a: A) => void
}) => Effect<void, E, R>
Executes a body effect repeatedly while a condition holds true.
Example (Repeating an effectful loop)
import { Effect } from "effect"
let counter = 0
const program = Effect.whileLoop({
while: () => counter < 5,
body: () => Effect.sync(() => ++counter),
step: (n) => console.log(`Current count: ${n}`)
})
Effect.runPromise(program)
// Output:
// Current count: 1
// Current count: 2
// Current count: 3
// Current count: 4
// Current count: 5
whileLoop({
while: LazyArg<boolean>while: () => let i: numberi < arr: readonly [In, ...In[]](parameter) arr: {
0: In;
length: number;
toString: () => string;
toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string };
concat: { (...items: Array<ConcatArray<In>>): Array<In>; (...items: Array<In | ConcatArray<In>>): Array<In> };
join: (separator?: string) => string;
slice: (start?: number, end?: number) => Array<In>;
indexOf: (searchElement: In, fromIndex?: number) => number;
lastIndexOf: (searchElement: In, fromIndex?: number) => number;
every: { (predicate: (value: In, index: number, array: ReadonlyArray<In>) => value is S, thisArg?: any): this is readonly S[]; (predicate: (value: In, index: number, array: ReadonlyArray<In>) => unknown, thisArg?: any): boolean };
some: (predicate: (value: In, index: number, array: ReadonlyArray<In>) => unknown, thisArg?: any) => boolean;
forEach: (callbackfn: (value: In, index: number, array: ReadonlyArray<In>) => void, thisArg?: any) => void;
map: (callbackfn: (value: In, index: number, array: ReadonlyArray<In>) => U, thisArg?: any) => Array<U>;
filter: { (predicate: (value: In, index: number, array: ReadonlyArray<In>) => value is S, thisArg?: any): Array<S>; (predicate: (value: In, index: number, array: ReadonlyArray<In>) => unknown, thisArg?: any): Array<In> };
reduce: { (callbackfn: (previousValue: In, currentValue: In, currentIndex: number, array: ReadonlyArray<In>) => In): In; (callbackfn: (previousValue: In, currentValue: In, currentIndex: number, array: ReadonlyArray<In>) => In, initialValue: In): I…;
reduceRight: { (callbackfn: (previousValue: In, currentValue: In, currentIndex: number, array: ReadonlyArray<In>) => In): In; (callbackfn: (previousValue: In, currentValue: In, currentIndex: number, array: ReadonlyArray<In>) => In, initialValue: In): I…;
find: { (predicate: (value: In, index: number, obj: ReadonlyArray<In>) => value is S, thisArg?: any): S | undefined; (predicate: (value: In, index: number, obj: ReadonlyArray<In>) => unknown, thisArg?: any): In | undefined };
findIndex: (predicate: (value: In, index: number, obj: ReadonlyArray<In>) => unknown, thisArg?: any) => number;
entries: () => ArrayIterator<[number, In]>;
keys: () => ArrayIterator<number>;
values: () => ArrayIterator<In>;
includes: (searchElement: In, fromIndex?: number) => boolean;
flatMap: (callback: (this: This, value: In, index: number, array: Array<In>) => U | ReadonlyArray<U>, thisArg?: This | undefined) => Array<U>;
flat: (this: A, depth?: D | undefined) => Array<FlatArray<A, D>>;
at: (index: number) => In | undefined;
findLast: { (predicate: (value: In, index: number, array: ReadonlyArray<In>) => value is S, thisArg?: any): S | undefined; (predicate: (value: In, index: number, array: ReadonlyArray<In>) => unknown, thisArg?: any): In | undefined };
findLastIndex: (predicate: (value: In, index: number, array: ReadonlyArray<In>) => unknown, thisArg?: any) => number;
toReversed: () => Array<In>;
toSorted: (compareFn?: ((a: In, b: In) => number) | undefined) => Array<In>;
toSpliced: { (start: number, deleteCount: number, ...items: Array<In>): Array<In>; (start: number, deleteCount?: number): Array<In> };
with: (index: number, value: In) => Array<In>;
}
length: numberlength,
body: LazyArg<
Effect.Effect<void, Cause.Done<void> | E, R>
>
constant<A>(value: A): LazyArg<A>Creates a zero-argument function that always returns the provided value.
When to use
Use when you need a thunk or callback that returns the same value on every
invocation.
Example (Creating a constant thunk)
import { Function } from "effect"
import * as assert from "node:assert"
const constNull = Function.constant(null)
assert.deepStrictEqual(constNull(), null)
assert.deepStrictEqual(constNull(), null)
constant(import EffectEffect.const flatMap: {
<A, B, E1, R1>(
f: (a: A) => Effect<B, E1, R1>
): <E, R>(
self: Effect<A, E, R>
) => Effect<B, E1 | E, R1 | R>
<A, E, R, B, E1, R1>(
self: Effect<A, E, R>,
f: (a: A) => Effect<B, E1, R1>
): Effect<B, E | E1, R | R1>
}
import EffectEffect.const suspend: <A, E, R>(
effect: LazyArg<Effect<A, E, R>>
) => Effect<A, E, R>
Creates an Effect lazily, delaying construction until it is needed.
When to use
Use when you need to defer the evaluation of an effect until it is required.
Details
suspend takes a thunk that represents an effect and delays creating it
until the suspended effect is evaluated. This is useful for optimizing
expensive computations, managing circular dependencies such as recursive
functions, and helping TypeScript unify return types when branches construct
different effects. Any side effects or scoped captures inside the thunk are
re-executed on each invocation.
Example (Lazily evaluating side effects)
import { Effect } from "effect"
let i = 0
const bad = Effect.succeed(i++)
const good = Effect.suspend(() => Effect.succeed(i++))
console.log(Effect.runSync(bad)) // Output: 0
console.log(Effect.runSync(bad)) // Output: 0
console.log(Effect.runSync(good)) // Output: 1
console.log(Effect.runSync(good)) // Output: 2
Example (Suspending recursive Fibonacci evaluation)
import { Effect } from "effect"
const blowsUp = (n: number): Effect.Effect<number> =>
n < 2
? Effect.succeed(1)
: Effect.zipWith(blowsUp(n - 1), blowsUp(n - 2), (a, b) => a + b)
// console.log(Effect.runSync(blowsUp(32)))
// crash: JavaScript heap out of memory
const allGood = (n: number): Effect.Effect<number> =>
n < 2
? Effect.succeed(1)
: Effect.zipWith(
Effect.suspend(() => allGood(n - 1)),
Effect.suspend(() => allGood(n - 2)),
(a, b) => a + b
)
console.log(Effect.runSync(allGood(32)))
// Output: 3524578
Example (Helping TypeScript infer recursive effect types)
import { Effect } from "effect"
// Without suspend, TypeScript may struggle with type inference.
// Inferred type:
// (a: number, b: number) =>
// Effect<never, Error, never> | Effect<number, never, never>
const withoutSuspend = (a: number, b: number) =>
b === 0
? Effect.fail(new Error("Cannot divide by zero"))
: Effect.succeed(a / b)
// Using suspend to unify return types.
// Inferred type:
// (a: number, b: number) => Effect<number, Error, never>
const withSuspend = (a: number, b: number) =>
Effect.suspend(() =>
b === 0
? Effect.fail(new Error("Cannot divide by zero"))
: Effect.succeed(a / b)
)
suspend(() => f: (
s: S,
input: In
) => Effect.Effect<S, E, R>
let state: Sstate, arr: readonly [In, ...In[]](parameter) arr: {
0: In;
length: number;
toString: () => string;
toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string };
concat: { (...items: Array<ConcatArray<In>>): Array<In>; (...items: Array<In | ConcatArray<In>>): Array<In> };
join: (separator?: string) => string;
slice: (start?: number, end?: number) => Array<In>;
indexOf: (searchElement: In, fromIndex?: number) => number;
lastIndexOf: (searchElement: In, fromIndex?: number) => number;
every: { (predicate: (value: In, index: number, array: ReadonlyArray<In>) => value is S, thisArg?: any): this is readonly S[]; (predicate: (value: In, index: number, array: ReadonlyArray<In>) => unknown, thisArg?: any): boolean };
some: (predicate: (value: In, index: number, array: ReadonlyArray<In>) => unknown, thisArg?: any) => boolean;
forEach: (callbackfn: (value: In, index: number, array: ReadonlyArray<In>) => void, thisArg?: any) => void;
map: (callbackfn: (value: In, index: number, array: ReadonlyArray<In>) => U, thisArg?: any) => Array<U>;
filter: { (predicate: (value: In, index: number, array: ReadonlyArray<In>) => value is S, thisArg?: any): Array<S>; (predicate: (value: In, index: number, array: ReadonlyArray<In>) => unknown, thisArg?: any): Array<In> };
reduce: { (callbackfn: (previousValue: In, currentValue: In, currentIndex: number, array: ReadonlyArray<In>) => In): In; (callbackfn: (previousValue: In, currentValue: In, currentIndex: number, array: ReadonlyArray<In>) => In, initialValue: In): I…;
reduceRight: { (callbackfn: (previousValue: In, currentValue: In, currentIndex: number, array: ReadonlyArray<In>) => In): In; (callbackfn: (previousValue: In, currentValue: In, currentIndex: number, array: ReadonlyArray<In>) => In, initialValue: In): I…;
find: { (predicate: (value: In, index: number, obj: ReadonlyArray<In>) => value is S, thisArg?: any): S | undefined; (predicate: (value: In, index: number, obj: ReadonlyArray<In>) => unknown, thisArg?: any): In | undefined };
findIndex: (predicate: (value: In, index: number, obj: ReadonlyArray<In>) => unknown, thisArg?: any) => number;
entries: () => ArrayIterator<[number, In]>;
keys: () => ArrayIterator<number>;
values: () => ArrayIterator<In>;
includes: (searchElement: In, fromIndex?: number) => boolean;
flatMap: (callback: (this: This, value: In, index: number, array: Array<In>) => U | ReadonlyArray<U>, thisArg?: This | undefined) => Array<U>;
flat: (this: A, depth?: D | undefined) => Array<FlatArray<A, D>>;
at: (index: number) => In | undefined;
findLast: { (predicate: (value: In, index: number, array: ReadonlyArray<In>) => value is S, thisArg?: any): S | undefined; (predicate: (value: In, index: number, array: ReadonlyArray<In>) => unknown, thisArg?: any): In | undefined };
findLastIndex: (predicate: (value: In, index: number, array: ReadonlyArray<In>) => unknown, thisArg?: any) => number;
toReversed: () => Array<In>;
toSorted: (compareFn?: ((a: In, b: In) => number) | undefined) => Array<In>;
toSpliced: { (start: number, deleteCount: number, ...items: Array<In>): Array<In>; (start: number, deleteCount?: number): Array<In> };
with: (index: number, value: In) => Array<In>;
}
let i: numberi++])), (s: Ss) => {
let state: Sstate = s: Ss
if (!predicate: Predicate<S>predicate(let state: Sstate)) {
if (let i: numberi < arr: readonly [In, ...In[]](parameter) arr: {
0: In;
length: number;
toString: () => string;
toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string };
concat: { (...items: Array<ConcatArray<In>>): Array<In>; (...items: Array<In | ConcatArray<In>>): Array<In> };
join: (separator?: string) => string;
slice: (start?: number, end?: number) => Array<In>;
indexOf: (searchElement: In, fromIndex?: number) => number;
lastIndexOf: (searchElement: In, fromIndex?: number) => number;
every: { (predicate: (value: In, index: number, array: ReadonlyArray<In>) => value is S, thisArg?: any): this is readonly S[]; (predicate: (value: In, index: number, array: ReadonlyArray<In>) => unknown, thisArg?: any): boolean };
some: (predicate: (value: In, index: number, array: ReadonlyArray<In>) => unknown, thisArg?: any) => boolean;
forEach: (callbackfn: (value: In, index: number, array: ReadonlyArray<In>) => void, thisArg?: any) => void;
map: (callbackfn: (value: In, index: number, array: ReadonlyArray<In>) => U, thisArg?: any) => Array<U>;
filter: { (predicate: (value: In, index: number, array: ReadonlyArray<In>) => value is S, thisArg?: any): Array<S>; (predicate: (value: In, index: number, array: ReadonlyArray<In>) => unknown, thisArg?: any): Array<In> };
reduce: { (callbackfn: (previousValue: In, currentValue: In, currentIndex: number, array: ReadonlyArray<In>) => In): In; (callbackfn: (previousValue: In, currentValue: In, currentIndex: number, array: ReadonlyArray<In>) => In, initialValue: In): I…;
reduceRight: { (callbackfn: (previousValue: In, currentValue: In, currentIndex: number, array: ReadonlyArray<In>) => In): In; (callbackfn: (previousValue: In, currentValue: In, currentIndex: number, array: ReadonlyArray<In>) => In, initialValue: In): I…;
find: { (predicate: (value: In, index: number, obj: ReadonlyArray<In>) => value is S, thisArg?: any): S | undefined; (predicate: (value: In, index: number, obj: ReadonlyArray<In>) => unknown, thisArg?: any): In | undefined };
findIndex: (predicate: (value: In, index: number, obj: ReadonlyArray<In>) => unknown, thisArg?: any) => number;
entries: () => ArrayIterator<[number, In]>;
keys: () => ArrayIterator<number>;
values: () => ArrayIterator<In>;
includes: (searchElement: In, fromIndex?: number) => boolean;
flatMap: (callback: (this: This, value: In, index: number, array: Array<In>) => U | ReadonlyArray<U>, thisArg?: This | undefined) => Array<U>;
flat: (this: A, depth?: D | undefined) => Array<FlatArray<A, D>>;
at: (index: number) => In | undefined;
findLast: { (predicate: (value: In, index: number, array: ReadonlyArray<In>) => value is S, thisArg?: any): S | undefined; (predicate: (value: In, index: number, array: ReadonlyArray<In>) => unknown, thisArg?: any): In | undefined };
findLastIndex: (predicate: (value: In, index: number, array: ReadonlyArray<In>) => unknown, thisArg?: any) => number;
toReversed: () => Array<In>;
toSorted: (compareFn?: ((a: In, b: In) => number) | undefined) => Array<In>;
toSpliced: { (start: number, deleteCount: number, ...items: Array<In>): Array<In>; (start: number, deleteCount?: number): Array<In> };
with: (index: number, value: In) => Array<In>;
}
length: numberlength) {
let leftover:
| NonEmptyReadonlyArray<In>
| undefined
arr: readonly [In, ...In[]](parameter) arr: {
0: In;
length: number;
toString: () => string;
toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string };
concat: { (...items: Array<ConcatArray<In>>): Array<In>; (...items: Array<In | ConcatArray<In>>): Array<In> };
join: (separator?: string) => string;
slice: (start?: number, end?: number) => Array<In>;
indexOf: (searchElement: In, fromIndex?: number) => number;
lastIndexOf: (searchElement: In, fromIndex?: number) => number;
every: { (predicate: (value: In, index: number, array: ReadonlyArray<In>) => value is S, thisArg?: any): this is readonly S[]; (predicate: (value: In, index: number, array: ReadonlyArray<In>) => unknown, thisArg?: any): boolean };
some: (predicate: (value: In, index: number, array: ReadonlyArray<In>) => unknown, thisArg?: any) => boolean;
forEach: (callbackfn: (value: In, index: number, array: ReadonlyArray<In>) => void, thisArg?: any) => void;
map: (callbackfn: (value: In, index: number, array: ReadonlyArray<In>) => U, thisArg?: any) => Array<U>;
filter: { (predicate: (value: In, index: number, array: ReadonlyArray<In>) => value is S, thisArg?: any): Array<S>; (predicate: (value: In, index: number, array: ReadonlyArray<In>) => unknown, thisArg?: any): Array<In> };
reduce: { (callbackfn: (previousValue: In, currentValue: In, currentIndex: number, array: ReadonlyArray<In>) => In): In; (callbackfn: (previousValue: In, currentValue: In, currentIndex: number, array: ReadonlyArray<In>) => In, initialValue: In): I…;
reduceRight: { (callbackfn: (previousValue: In, currentValue: In, currentIndex: number, array: ReadonlyArray<In>) => In): In; (callbackfn: (previousValue: In, currentValue: In, currentIndex: number, array: ReadonlyArray<In>) => In, initialValue: In): I…;
find: { (predicate: (value: In, index: number, obj: ReadonlyArray<In>) => value is S, thisArg?: any): S | undefined; (predicate: (value: In, index: number, obj: ReadonlyArray<In>) => unknown, thisArg?: any): In | undefined };
findIndex: (predicate: (value: In, index: number, obj: ReadonlyArray<In>) => unknown, thisArg?: any) => number;
entries: () => ArrayIterator<[number, In]>;
keys: () => ArrayIterator<number>;
values: () => ArrayIterator<In>;
includes: (searchElement: In, fromIndex?: number) => boolean;
flatMap: (callback: (this: This, value: In, index: number, array: Array<In>) => U | ReadonlyArray<U>, thisArg?: This | undefined) => Array<U>;
flat: (this: A, depth?: D | undefined) => Array<FlatArray<A, D>>;
at: (index: number) => In | undefined;
findLast: { (predicate: (value: In, index: number, array: ReadonlyArray<In>) => value is S, thisArg?: any): S | undefined; (predicate: (value: In, index: number, array: ReadonlyArray<In>) => unknown, thisArg?: any): In | undefined };
findLastIndex: (predicate: (value: In, index: number, array: ReadonlyArray<In>) => unknown, thisArg?: any) => number;
toReversed: () => Array<In>;
toSorted: (compareFn?: ((a: In, b: In) => number) | undefined) => Array<In>;
toSpliced: { (start: number, deleteCount: number, ...items: Array<In>): Array<In>; (start: number, deleteCount?: number): Array<In> };
with: (index: number, value: In) => Array<In>;
}
ReadonlyArray<In>.slice(start?: number, end?: number): In[]Returns a section of an array.
slice(let i: numberi) as any
}
return import CauseCause.const done: <A = void>(
value?: A
) => Effect.Effect<never, Done<A>>
Creates an Effect that fails with a Done error. Shorthand for
Effect.fail(Cause.Done(value)).
When to use
Use when you model stream or queue completion through the error channel.
Example (Failing with Done)
import { Cause, Effect } from "effect"
const program = Cause.done("finished")
Effect.runPromiseExit(program).then((exit) => {
console.log(exit._tag) // "Failure"
})
done()
}
return import EffectEffect.const void: Effect.Effect<void, never, never>(alias) const void: {
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;
}
Returns an effect that succeeds with void.
void
})),
step: LazyArg<void>step: const constVoid: LazyArg<void>Returns no meaningful value when called.
When to use
Use when you need a thunk that is called only for its effect and has no
meaningful return value.
Example (Returning void from a thunk)
import { Function } from "effect"
import * as assert from "node:assert"
assert.deepStrictEqual(Function.constVoid(), undefined)
constVoid
})
}),
import EffectEffect.const forever: <
Arg extends
| Effect<any, any, any>
| {
readonly disableYield?:
| boolean
| undefined
}
| undefined = {
readonly disableYield?: boolean | undefined
}
>(
effectOrOptions?: Arg,
options?:
| {
readonly disableYield?:
| boolean
| undefined
}
| undefined
) => [Arg] extends [
Effect<infer _A, infer _E, infer _R>
]
? Effect<never, _E, _R>
: <A, E, R>(
self: Effect<A, E, R>
) => Effect<never, E, R>
Repeats this effect forever (until the first error).
Example (Repeating forever)
import { Console, Effect, Fiber } from "effect"
const task = Effect.gen(function*() {
yield* Console.log("Task running...")
yield* Effect.sleep("1 second")
})
// This will run forever, printing every second
const program = task.pipe(Effect.forever)
// This will run forever, without yielding every iteration
const programNoYield = task.pipe(Effect.forever({ disableYield: true }))
// Run for 5 seconds then interrupt
const timedProgram = Effect.gen(function*() {
const fiber = yield* Effect.forkChild(program)
yield* Effect.sleep("5 seconds")
yield* Fiber.interrupt(fiber)
})
forever({ disableYield: truedisableYield: true }),
import PullPull.const catchDone: {
<E, A2, E2, R2>(
f: (
leftover: Cause.Done.Extract<E>
) => Effect<A2, E2, R2>
): <A, R>(
self: Effect<A, E, R>
) => Effect<A | A2, ExcludeDone<E> | E2, R | R2>
<A, R, E, A2, E2, R2>(
self: Effect<A, E, R>,
f: (
leftover: Cause.Done.Extract<E>
) => Effect<A2, E2, R2>
): Effect<A | A2, ExcludeDone<E> | E2, R | R2>
}
import EffectEffect.const succeed: <A>(value: A) => Effect<A>Creates an Effect that always succeeds with a given value.
When to use
Use when an effect should complete successfully with a specific value without any errors
or external dependencies.
Example (Creating a successful effect)
import { Effect } from "effect"
// Creating an effect that represents a successful scenario
//
// ┌─── Effect<number, never, never>
// ▼
const success = Effect.succeed(42)
succeed([let state: Sstate, let leftover:
| NonEmptyReadonlyArray<In>
| undefined
type const = readonly [S, readonly [In, ...In[]] | undefined]const))
)
})Referenced by 2 symbols