Effect vs Promise

In this guide, we will explore the differences between Promise and Effect, two approaches to handling asynchronous operations in TypeScript. We’ll discuss their type safety, creation, chaining, and concurrency, providing examples to help you understand their usage.

Comparing Effects and Promises: Key Distinctions

Evaluation Strategy: Promises are eagerly evaluated, whereas effects are lazily evaluated.
Execution Mode: Promises are one-shot, executing once, while effects are multi-shot, repeatable.
Interruption Handling and Automatic Propagation: Promises lack built-in interruption handling, posing challenges in managing interruptions, and don’t automatically propagate interruptions, requiring manual abort controller management. In contrast, effects come with interruption handling capabilities and automatically compose interruption, simplifying management locally on smaller computations without the need for high-level orchestration.
Structured Concurrency: Effects offer structured concurrency built-in, which is challenging to achieve with Promises.
Error Reporting (Type Safety): Promises don’t inherently provide detailed error reporting at the type level, whereas effects do, offering type-safe insight into error cases.
Runtime Behavior: The Effect runtime aims to remain synchronous as long as possible, transitioning into asynchronous mode only when necessary due to computation requirements or main thread starvation.

Type safety

Let’s start by comparing the types of Promise and Effect. The type parameter A represents the resolved value of the operation:

Promise<A>

Effect<A, Error, Context>

Here’s what sets Effect apart:

It allows you to track the types of errors statically through the type parameter Error. For more information about error management in Effect, see Expected Errors.
It allows you to track the types of required dependencies statically through the type parameter Context. For more information about context management in Effect, see Managing Services.

Creating

Success

Let’s compare creating a successful operation using Promise and Effect:

1
const 
const success: Promise<number>
success = 
var Promise: PromiseConstructor
Promise.
PromiseConstructor.resolve<number>(value: number): Promise<number> (+2 overloads)
resolve(2)

1
import { 
import Effect
Effect } from "effect"
2

3
const 
const success: Effect.Effect<number, never, never>
success = 
import Effect
Effect.
const succeed: <number>(value: number) => Effect.Effect<number, never, never>
succeed(2)

Failure

Now, let’s see how to handle failures with Promise and Effect:

1
const 
const failure: Promise<never>
failure = 
var Promise: PromiseConstructor
Promise.
PromiseConstructor.reject<never>(reason?: any): Promise<never>
reject("Uh oh!")

1
import { 
import Effect
Effect } from "effect"
2

3
const 
const failure: Effect.Effect<never, string, never>
failure = 
import Effect
Effect.
const fail: <string>(error: string) => Effect.Effect<never, string, never>
fail("Uh oh!")

Constructor

Creating operations with custom logic:

1
const 
const task: Promise<number>
task = new 
var Promise: PromiseConstructor
new <number>(executor: (resolve: (value: number | PromiseLike<number>) => void, reject: (reason?: any) => void) => void) => Promise<number>
Promise<number>((
resolve: (value: number | PromiseLike<number>) => void
resolve, 
reject: (reason?: any) => void
reject) => {
2
  
function setTimeout(handler: TimerHandler, timeout?: number, ...arguments: any[]): number
setTimeout(() => {
3
    
var Math: Math
Math.
Math.random(): number
random() > 0.5 ? 
resolve: (value: number | PromiseLike<number>) => void
resolve(2) : 
reject: (reason?: any) => void
reject("Uh oh!")
4
  }, 300)
5
})

1
import { 
import Effect
Effect } from "effect"
2

3
const 
const task: Effect.Effect<number, string, never>
task = 
import Effect
Effect.
const gen: <Effect.Effect<never, string, never> | Effect.Effect<void, never, never>, number>(f: () => Generator<Effect.Effect<never, string, never> | Effect.Effect<void, never, never>, number, never>) => Effect.Effect<number, string, never> (+1 overload)
gen(function* () {
4
  yield* 
import Effect
Effect.
const sleep: (duration: Input) => Effect.Effect<void>
sleep("300 millis")
5
  return 
var Math: Math
Math.
Math.random(): number
random() > 0.5 ? 2 : yield* 
import Effect
Effect.
const fail: <string>(error: string) => Effect.Effect<never, string, never>
fail("Uh oh!")
6
})

Thenable

Mapping the result of an operation:

map

1
const 
const mapped: Promise<number>
mapped = 
var Promise: PromiseConstructor
Promise.
PromiseConstructor.resolve<string>(value: string): Promise<string> (+2 overloads)
resolve("Hello").
Promise<string>.then<number, never>(onfulfilled?: ((value: string) => number | PromiseLike<number>) | null | undefined, onrejected?: ((reason: any) => PromiseLike<never>) | null | undefined): Promise<number>
then((
s: string
s) => 
s: string
s.
String.length: number
length)

1
import { 
import Effect
Effect } from "effect"
2

3
const 
const mapped: Effect.Effect<number, never, never>
mapped = 
import Effect
Effect.
const succeed: <string>(value: string) => Effect.Effect<string, never, never>
succeed("Hello").
Pipeable.pipe<Effect.Effect<string, never, never>, Effect.Effect<number, never, never>>(this: Effect.Effect<string, never, never>, ab: (_: Effect.Effect<string, never, never>) => Effect.Effect<number, never, never>): Effect.Effect<number, never, never> (+21 overloads)
pipe(
4
  
import Effect
Effect.
const map: <string, number>(f: (a: string) => number) => <E, R>(self: Effect.Effect<string, E, R>) => Effect.Effect<number, E, R> (+1 overload)
map((
s: string
s) => 
s: string
s.
String.length: number
length),
5
  // or Effect.andThen((s) => s.length)
6
)

flatMap

Chaining multiple operations:

1
const 
const flatMapped: Promise<number>
flatMapped = 
var Promise: PromiseConstructor
Promise.
PromiseConstructor.resolve<string>(value: string): Promise<string> (+2 overloads)
resolve("Hello").
Promise<string>.then<number, never>(onfulfilled?: ((value: string) => number | PromiseLike<number>) | null | undefined, onrejected?: ((reason: any) => PromiseLike<never>) | null | undefined): Promise<number>
then((
s: string
s) =>
2
  
var Promise: PromiseConstructor
Promise.
PromiseConstructor.resolve<number>(value: number): Promise<number> (+2 overloads)
resolve(
s: string
s.
String.length: number
length),
3
)

1
import { 
import Effect
Effect } from "effect"
2

3
const 
const flatMapped: Effect.Effect<number, never, never>
flatMapped = 
import Effect
Effect.
const succeed: <string>(value: string) => Effect.Effect<string, never, never>
succeed("Hello").
Pipeable.pipe<Effect.Effect<string, never, never>, Effect.Effect<number, never, never>>(this: Effect.Effect<string, never, never>, ab: (_: Effect.Effect<string, never, never>) => Effect.Effect<number, never, never>): Effect.Effect<number, never, never> (+21 overloads)
pipe(
4
  
import Effect
Effect.
const flatMap: <string, number, never, never>(f: (a: string) => Effect.Effect<number, never, never>) => <E, R>(self: Effect.Effect<string, E, R>) => Effect.Effect<number, E, R> (+1 overload)
flatMap((
s: string
s) => 
import Effect
Effect.
const succeed: <number>(value: number) => Effect.Effect<number, never, never>
succeed(
s: string
s.
String.length: number
length)),
5
  // or Effect.andThen((s) => Effect.succeed(s.length))
6
)

Comparing Effect.gen with async/await

If you are familiar with async/await, you may notice that the flow of writing code is similar.

Let’s compare the two approaches:

1
const 
const increment: (x: number) => number
increment = (
x: number
x: number) => 
x: number
x + 1
2

3
const 
const divide: (a: number, b: number) => Promise<number>
divide = (
a: number
a: number, 
b: number
b: number): 
interface Promise<T>
Promise<number> =>
4
  
b: number
b === 0
5
    ? 
var Promise: PromiseConstructor
Promise.
PromiseConstructor.reject<number>(reason?: any): Promise<number>
reject(new 
var Error: ErrorConstructor
new (message?: string, options?: ErrorOptions) => Error (+1 overload)
Error("Cannot divide by zero"))
6
    : 
var Promise: PromiseConstructor
Promise.
PromiseConstructor.resolve<number>(value: number): Promise<number> (+2 overloads)
resolve(
a: number
a / 
b: number
b)
7

8
const 
const task1: Promise<number>
task1 = 
var Promise: PromiseConstructor
Promise.
PromiseConstructor.resolve<number>(value: number): Promise<number> (+2 overloads)
resolve(10)
9

10
const 
const task2: Promise<number>
task2 = 
var Promise: PromiseConstructor
Promise.
PromiseConstructor.resolve<number>(value: number): Promise<number> (+2 overloads)
resolve(2)
11

12
const 
const program: () => Promise<string>
program = async function () {
13
  const 
const a: number
a = await 
const task1: Promise<number>
task1
14
  const 
const b: number
b = await 
const task2: Promise<number>
task2
15
  const 
const n1: number
n1 = await 
const divide: (a: number, b: number) => Promise<number>
divide(
const a: number
a, 
const b: number
b)
16
  const 
const n2: number
n2 = 
const increment: (x: number) => number
increment(
const n1: number
n1)
17
  return `Result is: ${
const n2: number
n2}`
18
}
19

20
const program: () => Promise<string>
program().
Promise<string>.then<void, never>(onfulfilled?: ((value: string) => void | PromiseLike<void>) | null | undefined, onrejected?: ((reason: any) => PromiseLike<never>) | null | undefined): Promise<void>
then(
var console: Console
console.
Console.log(...data: any[]): void
log) // Output: "Result is: 6"

1
import { 
import Effect
Effect } from "effect"
2

3
const 
const increment: (x: number) => number
increment = (
x: number
x: number) => 
x: number
x + 1
4

5
const 
const divide: (a: number, b: number) => Effect.Effect<number, Error>
divide = (
a: number
a: number, 
b: number
b: number): 
import Effect
Effect.
interface Effect<out A, out E = never, out R = never>
Effect<number, 
interface Error
Error> =>
6
  
b: number
b === 0
7
    ? 
import Effect
Effect.
const fail: <Error>(error: Error) => Effect.Effect<never, Error, never>
fail(new 
var Error: ErrorConstructor
new (message?: string, options?: ErrorOptions) => Error (+1 overload)
Error("Cannot divide by zero"))
8
    : 
import Effect
Effect.
const succeed: <number>(value: number) => Effect.Effect<number, never, never>
succeed(
a: number
a / 
b: number
b)
9

10
const 
const task1: Effect.Effect<number, never, never>
task1 = 
import Effect
Effect.
const promise: <number>(evaluate: (signal: AbortSignal) => PromiseLike<number>) => Effect.Effect<number, never, never>
promise(() => 
var Promise: PromiseConstructor
Promise.
PromiseConstructor.resolve<number>(value: number): Promise<number> (+2 overloads)
resolve(10))
11

12
const 
const task2: Effect.Effect<number, never, never>
task2 = 
import Effect
Effect.
const promise: <number>(evaluate: (signal: AbortSignal) => PromiseLike<number>) => Effect.Effect<number, never, never>
promise(() => 
var Promise: PromiseConstructor
Promise.
PromiseConstructor.resolve<number>(value: number): Promise<number> (+2 overloads)
resolve(2))
13

14
const 
const program: Effect.Effect<string, Error, never>
program = 
import Effect
Effect.
const gen: <Effect.Effect<number, Error, never>, string>(f: () => Generator<Effect.Effect<number, Error, never>, string, never>) => Effect.Effect<string, Error, never> (+1 overload)
gen(function* () {
15
  const 
const a: number
a = yield* 
const task1: Effect.Effect<number, never, never>
task1
16
  const 
const b: number
b = yield* 
const task2: Effect.Effect<number, never, never>
task2
17
  const 
const n1: number
n1 = yield* 
const divide: (a: number, b: number) => Effect.Effect<number, Error>
divide(
const a: number
a, 
const b: number
b)
18
  const 
const n2: number
n2 = 
const increment: (x: number) => number
increment(
const n1: number
n1)
19
  return `Result is: ${
const n2: number
n2}`
20
})
21

22
import Effect
Effect.
const runPromise: <string, Error>(effect: Effect.Effect<string, Error, never>, options?: Effect.RunOptions | undefined) => Promise<string>
runPromise(
const program: Effect.Effect<string, Error, never>
program).
Promise<string>.then<void, never>(onfulfilled?: ((value: string) => void | PromiseLike<void>) | null | undefined, onrejected?: ((reason: any) => PromiseLike<never>) | null | undefined): Promise<void>
then(
var console: Console
console.
Console.log(...data: any[]): void
log)
23
// Output: "Result is: 6"

It’s important to note that although the code appears similar, the two programs are not identical. The purpose of comparing them side by side is just to highlight the resemblance in how they are written.

Concurrency

Promise.all()

1
const 
const task1: Promise<number>
task1 = new 
var Promise: PromiseConstructor
new <number>(executor: (resolve: (value: number | PromiseLike<number>) => void, reject: (reason?: any) => void) => void) => Promise<number>
Promise<number>((
resolve: (value: number | PromiseLike<number>) => void
resolve, 
reject: (reason?: any) => void
reject) => {
2
  
var console: Console
console.
Console.log(...data: any[]): void
log("Executing task1...")
3
  
function setTimeout(handler: TimerHandler, timeout?: number, ...arguments: any[]): number
setTimeout(() => {
4
    
var console: Console
console.
Console.log(...data: any[]): void
log("task1 done")
5
    
resolve: (value: number | PromiseLike<number>) => void
resolve(1)
6
  }, 100)
7
})
8

9
const 
const task2: Promise<number>
task2 = new 
var Promise: PromiseConstructor
new <number>(executor: (resolve: (value: number | PromiseLike<number>) => void, reject: (reason?: any) => void) => void) => Promise<number>
Promise<number>((
resolve: (value: number | PromiseLike<number>) => void
resolve, 
reject: (reason?: any) => void
reject) => {
10
  
var console: Console
console.
Console.log(...data: any[]): void
log("Executing task2...")
11
  
function setTimeout(handler: TimerHandler, timeout?: number, ...arguments: any[]): number
setTimeout(() => {
12
    
var console: Console
console.
Console.log(...data: any[]): void
log("task2 done")
13
    
reject: (reason?: any) => void
reject("Uh oh!")
14
  }, 200)
15
})
16

17
const 
const task3: Promise<number>
task3 = new 
var Promise: PromiseConstructor
new <number>(executor: (resolve: (value: number | PromiseLike<number>) => void, reject: (reason?: any) => void) => void) => Promise<number>
Promise<number>((
resolve: (value: number | PromiseLike<number>) => void
resolve, 
reject: (reason?: any) => void
reject) => {
18
  
var console: Console
console.
Console.log(...data: any[]): void
log("Executing task3...")
19
  
function setTimeout(handler: TimerHandler, timeout?: number, ...arguments: any[]): number
setTimeout(() => {
20
    
var console: Console
console.
Console.log(...data: any[]): void
log("task3 done")
21
    
resolve: (value: number | PromiseLike<number>) => void
resolve(3)
22
  }, 300)
23
})
24

25
const 
const program: Promise<[number, number, number]>
program = 
var Promise: PromiseConstructor
Promise.
PromiseConstructor.all<[Promise<number>, Promise<number>, Promise<number>]>(values: [Promise<number>, Promise<number>, Promise<number>]): Promise<[number, number, number]> (+1 overload)
all([
const task1: Promise<number>
task1, 
const task2: Promise<number>
task2, 
const task3: Promise<number>
task3])
26

27
const program: Promise<[number, number, number]>
program.
Promise<[number, number, number]>.then<void, void>(onfulfilled?: ((value: [number, number, number]) => void | PromiseLike<void>) | null | undefined, onrejected?: ((reason: any) => void | PromiseLike<void>) | null | undefined): Promise<void>
then(
var console: Console
console.
Console.log(...data: any[]): void
log, 
var console: Console
console.
Console.error(...data: any[]): void
error)
28
/*
29
Output:
30
Executing task1...
31
Executing task2...
32
Executing task3...
33
task1 done
34
task2 done
35
Uh oh!
36
task3 done
37
*/

1
import { 
import Effect
Effect } from "effect"
2

3
const 
const task1: Effect.Effect<number, never, never>
task1 = 
import Effect
Effect.
const gen: <Effect.Effect<void, never, never>, number>(f: () => Generator<Effect.Effect<void, never, never>, number, never>) => Effect.Effect<number, never, never> (+1 overload)
gen(function* () {
4
  
var console: Console
console.
Console.log(...data: any[]): void
log("Executing task1...")
5
  yield* 
import Effect
Effect.
const sleep: (duration: Input) => Effect.Effect<void>
sleep("100 millis")
6
  
var console: Console
console.
Console.log(...data: any[]): void
log("task1 done")
7
  return 1
8
})
9

10
const 
const task2: Effect.Effect<never, string, never>
task2 = 
import Effect
Effect.
const gen: <Effect.Effect<void, never, never> | Effect.Effect<never, string, never>, never>(f: () => Generator<Effect.Effect<void, never, never> | Effect.Effect<never, string, never>, never, never>) => Effect.Effect<never, string, never> (+1 overload)
gen(function* () {
11
  
var console: Console
console.
Console.log(...data: any[]): void
log("Executing task2...")
12
  yield* 
import Effect
Effect.
const sleep: (duration: Input) => Effect.Effect<void>
sleep("200 millis")
13
  
var console: Console
console.
Console.log(...data: any[]): void
log("task2 done")
14
  return yield* 
import Effect
Effect.
const fail: <string>(error: string) => Effect.Effect<never, string, never>
fail("Uh oh!")
15
})
16

17
const 
const task3: Effect.Effect<number, never, never>
task3 = 
import Effect
Effect.
const gen: <Effect.Effect<void, never, never>, number>(f: () => Generator<Effect.Effect<void, never, never>, number, never>) => Effect.Effect<number, never, never> (+1 overload)
gen(function* () {
18
  
var console: Console
console.
Console.log(...data: any[]): void
log("Executing task3...")
19
  yield* 
import Effect
Effect.
const sleep: (duration: Input) => Effect.Effect<void>
sleep("300 millis")
20
  
var console: Console
console.
Console.log(...data: any[]): void
log("task3 done")
21
  return 3
22
})
23

24
const 
const program: Effect.Effect<[number, never, number], string, never>
program = 
import Effect
Effect.
const all: <readonly [Effect.Effect<number, never, never>, Effect.Effect<never, string, never>, Effect.Effect<number, never, never>], {
    concurrency: "unbounded";
}>(arg: readonly [Effect.Effect<number, never, never>, Effect.Effect<never, string, never>, Effect.Effect<number, never, never>], options?: {
    concurrency: "unbounded";
} | undefined) => Effect.Effect<[number, never, number], string, never>
all([
const task1: Effect.Effect<number, never, never>
task1, 
const task2: Effect.Effect<never, string, never>
task2, 
const task3: Effect.Effect<number, never, never>
task3], {
25
  
concurrency: "unbounded"
concurrency: "unbounded",
26
})
27

28
import Effect
Effect.
const runPromise: <[number, never, number], string>(effect: Effect.Effect<[number, never, number], string, never>, options?: Effect.RunOptions | undefined) => Promise<[number, never, number]>
runPromise(
const program: Effect.Effect<[number, never, number], string, never>
program).
Promise<[number, never, number]>.then<void, void>(onfulfilled?: ((value: [number, never, number]) => void | PromiseLike<void>) | null | undefined, onrejected?: ((reason: any) => void | PromiseLike<void>) | null | undefined): Promise<void>
then(
var console: Console
console.
Console.log(...data: any[]): void
log, 
var console: Console
console.
Console.error(...data: any[]): void
error)
29
/*
30
Output:
31
Executing task1...
32
Executing task2...
33
Executing task3...
34
task1 done
35
task2 done
36
(FiberFailure) Error: Uh oh!
37
*/

Promise.allSettled()

1
const task1 = new Promise<number>((resolve, reject) => {
2
  console.log("Executing task1...")
3
  setTimeout(() => {
4
    console.log("task1 done")
5
    resolve(1)
6
  }, 100)
7
})
8

9
const task2 = new Promise<number>((resolve, reject) => {
10
  console.log("Executing task2...")
11
  setTimeout(() => {
12
    console.log("task2 done")
13
    reject("Uh oh!")
14
  }, 200)
15
})
16

17
const task3 = new Promise<number>((resolve, reject) => {
18
  console.log("Executing task3...")
19
  setTimeout(() => {
20
    console.log("task3 done")
21
    resolve(3)
22
  }, 300)
23
})
24

25
const program = Promise.allSettled([task1, task2, task3])
26

27
program.then(console.log, console.error)
28
/*
29
Output:
30
Executing task1...
31
Executing task2...
32
Executing task3...
33
task1 done
34
task2 done
35
task3 done
36
[
37
  { status: 'fulfilled', value: 1 },
38
  { status: 'rejected', reason: 'Uh oh!' },
39
  { status: 'fulfilled', value: 3 }
40
]
41
*/

1
import { 
import Effect
Effect } from "effect"
2

3
const 
const task1: Effect.Effect<number, never, never>
task1 = 
import Effect
Effect.
const gen: <Effect.Effect<void, never, never>, number>(f: () => Generator<Effect.Effect<void, never, never>, number, never>) => Effect.Effect<number, never, never> (+1 overload)
gen(function* () {
4
  
var console: Console
console.
Console.log(...data: any[]): void
log("Executing task1...")
5
  yield* 
import Effect
Effect.
const sleep: (duration: Input) => Effect.Effect<void>
sleep("100 millis")
6
  
var console: Console
console.
Console.log(...data: any[]): void
log("task1 done")
7
  return 1
8
})
9

10
const 
const task2: Effect.Effect<never, string, never>
task2 = 
import Effect
Effect.
const gen: <Effect.Effect<void, never, never> | Effect.Effect<never, string, never>, never>(f: () => Generator<Effect.Effect<void, never, never> | Effect.Effect<never, string, never>, never, never>) => Effect.Effect<never, string, never> (+1 overload)
gen(function* () {
11
  
var console: Console
console.
Console.log(...data: any[]): void
log("Executing task2...")
12
  yield* 
import Effect
Effect.
const sleep: (duration: Input) => Effect.Effect<void>
sleep("200 millis")
13
  
var console: Console
console.
Console.log(...data: any[]): void
log("task2 done")
14
  return yield* 
import Effect
Effect.
const fail: <string>(error: string) => Effect.Effect<never, string, never>
fail("Uh oh!")
15
})
16

17
const 
const task3: Effect.Effect<number, never, never>
task3 = 
import Effect
Effect.
const gen: <Effect.Effect<void, never, never>, number>(f: () => Generator<Effect.Effect<void, never, never>, number, never>) => Effect.Effect<number, never, never> (+1 overload)
gen(function* () {
18
  
var console: Console
console.
Console.log(...data: any[]): void
log("Executing task3...")
19
  yield* 
import Effect
Effect.
const sleep: (duration: Input) => Effect.Effect<void>
sleep("300 millis")
20
  
var console: Console
console.
Console.log(...data: any[]): void
log("task3 done")
21
  return 3
22
})
23

24
const 
const program: Effect.Effect<unknown[], unknown, unknown>
program = 
import Effect
Effect.
const forEach: <unknown, unknown, unknown, (Effect.Effect<number, never, never> | Effect.Effect<never, string, never>)[], false>(self: (Effect.Effect<number, never, never> | Effect.Effect<never, string, never>)[], f: (a: Effect.Effect<number, never, never> | Effect.Effect<never, string, never>, i: number) => Effect.Effect<unknown, unknown, unknown>, options?: {
    readonly concurrency?: Concurrency | undefined;
    readonly discard?: false | undefined;
} | undefined) => Effect.Effect<unknown[], unknown, unknown> (+1 overload)
forEach(
25
  [
const task1: Effect.Effect<number, never, never>
task1, 
const task2: Effect.Effect<never, string, never>
task2, 
const task3: Effect.Effect<number, never, never>
task3],
26
  (
task: Effect.Effect<number, never, never> | Effect.Effect<never, string, never>
task) => 
import Effect
Effect.either(
task: Effect.Effect<number, never, never> | Effect.Effect<never, string, never>
task), // or Effect.exitError ts(2339)  ― Property 'either' does not exist on type 'typeof import("/home/runner/work/website/website/node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Effect")'.
27
  {
28
    
concurrency?: Concurrency | undefined
concurrency: "unbounded",
29
  },
30
)
31

32
import Effect
Effect.
const runPromise: <unknown[], unknown>(effect: Effect.Effect<unknown[], unknown, never>, options?: Effect.RunOptions | undefined) => Promise<unknown[]>
runPromise(program).
Promise<unknown[]>.then<void, void>(onfulfilled?: ((value: unknown[]) => void | PromiseLike<void>) | null | undefined, onrejected?: ((reason: any) => void | PromiseLike<void>) | null | undefined): Promise<void>
then(
var console: Console
console.
Console.log(...data: any[]): void
log, 
var console: Console
console.
Console.error(...data: any[]): void
error)Error ts(2345)  ― Argument of type 'Effect<unknown[], unknown, unknown>' is not assignable to parameter of type 'Effect<unknown[], unknown, never>'.
  Type 'unknown' is not assignable to type 'never'.
33
/*
34
Output:
35
Executing task1...
36
Executing task2...
37
Executing task3...
38
task1 done
39
task2 done
40
task3 done
41
[
42
  {
43
    _id: "Either",
44
    _tag: "Right",
45
    right: 1
46
  }, {
47
    _id: "Either",
48
    _tag: "Left",
49
    left: "Uh oh!"
50
  }, {
51
    _id: "Either",
52
    _tag: "Right",
53
    right: 3
54
  }
55
]
56
*/

Promise.any()

1
const task1 = new Promise<number>((resolve, reject) => {
2
  console.log("Executing task1...")
3
  setTimeout(() => {
4
    console.log("task1 done")
5
    reject("Something went wrong!")
6
  }, 100)
7
})
8

9
const task2 = new Promise<number>((resolve, reject) => {
10
  console.log("Executing task2...")
11
  setTimeout(() => {
12
    console.log("task2 done")
13
    resolve(2)
14
  }, 200)
15
})
16

17
const task3 = new Promise<number>((resolve, reject) => {
18
  console.log("Executing task3...")
19
  setTimeout(() => {
20
    console.log("task3 done")
21
    reject("Uh oh!")
22
  }, 300)
23
})
24

25
const program = Promise.any([task1, task2, task3])
26

27
program.then(console.log, console.error)
28
/*
29
Output:
30
Executing task1...
31
Executing task2...
32
Executing task3...
33
task1 done
34
task2 done
35
2
36
task3 done
37
*/

1
import { 
import Effect
Effect } from "effect"
2

3
const 
const task1: Effect.Effect<never, string, never>
task1 = 
import Effect
Effect.
const gen: <Effect.Effect<never, string, never> | Effect.Effect<void, never, never>, never>(f: () => Generator<Effect.Effect<never, string, never> | Effect.Effect<void, never, never>, never, never>) => Effect.Effect<never, string, never> (+1 overload)
gen(function* () {
4
  
var console: Console
console.
Console.log(...data: any[]): void
log("Executing task1...")
5
  yield* 
import Effect
Effect.
const sleep: (duration: Input) => Effect.Effect<void>
sleep("100 millis")
6
  
var console: Console
console.
Console.log(...data: any[]): void
log("task1 done")
7
  return yield* 
import Effect
Effect.
const fail: <string>(error: string) => Effect.Effect<never, string, never>
fail("Something went wrong!")
8
})
9

10
const 
const task2: Effect.Effect<number, never, never>
task2 = 
import Effect
Effect.
const gen: <Effect.Effect<void, never, never>, number>(f: () => Generator<Effect.Effect<void, never, never>, number, never>) => Effect.Effect<number, never, never> (+1 overload)
gen(function* () {
11
  
var console: Console
console.
Console.log(...data: any[]): void
log("Executing task2...")
12
  yield* 
import Effect
Effect.
const sleep: (duration: Input) => Effect.Effect<void>
sleep("200 millis")
13
  
var console: Console
console.
Console.log(...data: any[]): void
log("task2 done")
14
  return 2
15
})
16

17
const 
const task3: Effect.Effect<never, string, never>
task3 = 
import Effect
Effect.
const gen: <Effect.Effect<never, string, never> | Effect.Effect<void, never, never>, never>(f: () => Generator<Effect.Effect<never, string, never> | Effect.Effect<void, never, never>, never, never>) => Effect.Effect<never, string, never> (+1 overload)
gen(function* () {
18
  
var console: Console
console.
Console.log(...data: any[]): void
log("Executing task3...")
19
  yield* 
import Effect
Effect.
const sleep: (duration: Input) => Effect.Effect<void>
sleep("300 millis")
20
  
var console: Console
console.
Console.log(...data: any[]): void
log("task3 done")
21
  return yield* 
import Effect
Effect.
const fail: <string>(error: string) => Effect.Effect<never, string, never>
fail("Uh oh!")
22
})
23

24
const 
const program: Effect.Effect<number, string, never>
program = 
import Effect
Effect.
const raceAll: <Effect.Effect<never, string, never> | Effect.Effect<number, never, never>>(all: Iterable<Effect.Effect<never, string, never> | Effect.Effect<number, never, never>>, options?: {
    readonly onWinner?: (options: {
        readonly fiber: Fiber<any, any>;
        readonly index: number;
        readonly parentFiber: Fiber<any, any>;
    }) => void;
}) => Effect.Effect<number, string, never>
raceAll([
const task1: Effect.Effect<never, string, never>
task1, 
const task2: Effect.Effect<number, never, never>
task2, 
const task3: Effect.Effect<never, string, never>
task3])
25

26
import Effect
Effect.
const runPromise: <number, string>(effect: Effect.Effect<number, string, never>, options?: Effect.RunOptions | undefined) => Promise<number>
runPromise(
const program: Effect.Effect<number, string, never>
program).
Promise<number>.then<void, void>(onfulfilled?: ((value: number) => void | PromiseLike<void>) | null | undefined, onrejected?: ((reason: any) => void | PromiseLike<void>) | null | undefined): Promise<void>
then(
var console: Console
console.
Console.log(...data: any[]): void
log, 
var console: Console
console.
Console.error(...data: any[]): void
error)
27
/*
28
Output:
29
Executing task1...
30
Executing task2...
31
Executing task3...
32
task1 done
33
task2 done
34
2
35
*/

Promise.race()

1
const 
const task1: Promise<number>
task1 = new 
var Promise: PromiseConstructor
new <number>(executor: (resolve: (value: number | PromiseLike<number>) => void, reject: (reason?: any) => void) => void) => Promise<number>
Promise<number>((
resolve: (value: number | PromiseLike<number>) => void
resolve, 
reject: (reason?: any) => void
reject) => {
2
  
var console: Console
console.
Console.log(...data: any[]): void
log("Executing task1...")
3
  
function setTimeout(handler: TimerHandler, timeout?: number, ...arguments: any[]): number
setTimeout(() => {
4
    
var console: Console
console.
Console.log(...data: any[]): void
log("task1 done")
5
    
reject: (reason?: any) => void
reject("Something went wrong!")
6
  }, 100)
7
})
8

9
const 
const task2: Promise<number>
task2 = new 
var Promise: PromiseConstructor
new <number>(executor: (resolve: (value: number | PromiseLike<number>) => void, reject: (reason?: any) => void) => void) => Promise<number>
Promise<number>((
resolve: (value: number | PromiseLike<number>) => void
resolve, 
reject: (reason?: any) => void
reject) => {
10
  
var console: Console
console.
Console.log(...data: any[]): void
log("Executing task2...")
11
  
function setTimeout(handler: TimerHandler, timeout?: number, ...arguments: any[]): number
setTimeout(() => {
12
    
var console: Console
console.
Console.log(...data: any[]): void
log("task2 done")
13
    
reject: (reason?: any) => void
reject("Uh oh!")
14
  }, 200)
15
})
16

17
const 
const task3: Promise<number>
task3 = new 
var Promise: PromiseConstructor
new <number>(executor: (resolve: (value: number | PromiseLike<number>) => void, reject: (reason?: any) => void) => void) => Promise<number>
Promise<number>((
resolve: (value: number | PromiseLike<number>) => void
resolve, 
reject: (reason?: any) => void
reject) => {
18
  
var console: Console
console.
Console.log(...data: any[]): void
log("Executing task3...")
19
  
function setTimeout(handler: TimerHandler, timeout?: number, ...arguments: any[]): number
setTimeout(() => {
20
    
var console: Console
console.
Console.log(...data: any[]): void
log("task3 done")
21
    
resolve: (value: number | PromiseLike<number>) => void
resolve(3)
22
  }, 300)
23
})
24

25
const 
const program: Promise<number>
program = 
var Promise: PromiseConstructor
Promise.
PromiseConstructor.race<[Promise<number>, Promise<number>, Promise<number>]>(values: [Promise<number>, Promise<number>, Promise<number>]): Promise<number> (+1 overload)
race([
const task1: Promise<number>
task1, 
const task2: Promise<number>
task2, 
const task3: Promise<number>
task3])
26

27
const program: Promise<number>
program.
Promise<number>.then<void, void>(onfulfilled?: ((value: number) => void | PromiseLike<void>) | null | undefined, onrejected?: ((reason: any) => void | PromiseLike<void>) | null | undefined): Promise<void>
then(
var console: Console
console.
Console.log(...data: any[]): void
log, 
var console: Console
console.
Console.error(...data: any[]): void
error)
28
/*
29
Output:
30
Executing task1...
31
Executing task2...
32
Executing task3...
33
task1 done
34
Something went wrong!
35
task2 done
36
task3 done
37
*/

1
import { 
import Effect
Effect } from "effect"
2

3
const 
const task1: Effect.Effect<never, string, never>
task1 = 
import Effect
Effect.
const gen: <Effect.Effect<never, string, never> | Effect.Effect<void, never, never>, never>(f: () => Generator<Effect.Effect<never, string, never> | Effect.Effect<void, never, never>, never, never>) => Effect.Effect<never, string, never> (+1 overload)
gen(function* () {
4
  
var console: Console
console.
Console.log(...data: any[]): void
log("Executing task1...")
5
  yield* 
import Effect
Effect.
const sleep: (duration: Input) => Effect.Effect<void>
sleep("100 millis")
6
  
var console: Console
console.
Console.log(...data: any[]): void
log("task1 done")
7
  return yield* 
import Effect
Effect.
const fail: <string>(error: string) => Effect.Effect<never, string, never>
fail("Something went wrong!")
8
})
9

10
const 
const task2: Effect.Effect<never, string, never>
task2 = 
import Effect
Effect.
const gen: <Effect.Effect<never, string, never> | Effect.Effect<void, never, never>, never>(f: () => Generator<Effect.Effect<never, string, never> | Effect.Effect<void, never, never>, never, never>) => Effect.Effect<never, string, never> (+1 overload)
gen(function* () {
11
  
var console: Console
console.
Console.log(...data: any[]): void
log("Executing task2...")
12
  yield* 
import Effect
Effect.
const sleep: (duration: Input) => Effect.Effect<void>
sleep("200 millis")
13
  
var console: Console
console.
Console.log(...data: any[]): void
log("task2 done")
14
  return yield* 
import Effect
Effect.
const fail: <string>(error: string) => Effect.Effect<never, string, never>
fail("Uh oh!")
15
})
16

17
const 
const task3: Effect.Effect<number, never, never>
task3 = 
import Effect
Effect.
const gen: <Effect.Effect<void, never, never>, number>(f: () => Generator<Effect.Effect<void, never, never>, number, never>) => Effect.Effect<number, never, never> (+1 overload)
gen(function* () {
18
  
var console: Console
console.
Console.log(...data: any[]): void
log("Executing task3...")
19
  yield* 
import Effect
Effect.
const sleep: (duration: Input) => Effect.Effect<void>
sleep("300 millis")
20
  
var console: Console
console.
Console.log(...data: any[]): void
log("task3 done")
21
  return 3
22
})
23

24
const 
const program: Effect.Effect<any, any, any>
program = 
import Effect
Effect.
const raceAll: <Effect.Effect<any, any, any>>(all: Iterable<Effect.Effect<any, any, any>>, options?: {
    readonly onWinner?: (options: {
        readonly fiber: Fiber<any, any>;
        readonly index: number;
        readonly parentFiber: Fiber<any, any>;
    }) => void;
}) => Effect.Effect<any, any, any>
raceAll([
const task1: Effect.Effect<never, string, never>
task1, 
const task2: Effect.Effect<never, string, never>
task2, 
const task3: Effect.Effect<number, never, never>
task3].
Array<Effect<never, string, never> | Effect<number, never, never>>.map<unknown>(callbackfn: (value: Effect.Effect<never, string, never> | Effect.Effect<number, never, never>, index: number, array: (Effect.Effect<never, string, never> | Effect.Effect<number, never, never>)[]) => unknown, thisArg?: any): unknown[]
map(
import Effect
Effect.either)) // or Effect.exitError ts(2345)  ― Argument of type 'unknown[]' is not assignable to parameter of type 'Iterable<Effect<any, any, any>>'.
  The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types.
    Type 'IteratorResult<unknown, undefined>' is not assignable to type 'IteratorResult<Effect<any, any, any>, any>'.
      Type 'IteratorYieldResult<unknown>' is not assignable to type 'IteratorResult<Effect<any, any, any>, any>'.
        Type 'IteratorYieldResult<unknown>' is not assignable to type 'IteratorYieldResult<Effect<any, any, any>>'.
          Type 'unknown' is not assignable to type 'Effect<any, any, any>'.Error ts(2339)  ― Property 'either' does not exist on type 'typeof import("/home/runner/work/website/website/node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Effect")'.
25

26
import Effect
Effect.
const runPromise: <any, any>(effect: Effect.Effect<any, any, never>, options?: Effect.RunOptions | undefined) => Promise<any>
runPromise(program).
Promise<any>.then<void, void>(onfulfilled?: ((value: any) => void | PromiseLike<void>) | null | undefined, onrejected?: ((reason: any) => void | PromiseLike<void>) | null | undefined): Promise<void>
then(
var console: Console
console.
Console.log(...data: any[]): void
log, 
var console: Console
console.
Console.error(...data: any[]): void
error)Error ts(2345)  ― Argument of type 'Effect<any, any, any>' is not assignable to parameter of type 'Effect<any, any, never>'.
  Type 'any' is not assignable to type 'never'.
27
/*
28
Output:
29
Executing task1...
30
Executing task2...
31
Executing task3...
32
task1 done
33
{
34
  _id: "Either",
35
  _tag: "Left",
36
  left: "Something went wrong!"
37
}
38
*/

FAQ

Question. What is the equivalent of starting a promise without immediately waiting for it in Effects?

1
const task = (delay: number, name: string) =>
2
  new Promise((resolve) =>
3
    setTimeout(() => {
4
      console.log(`${name} done`)
5
      return resolve(name)
6
    }, delay),
7
  )
8

9
export async function program() {
10
  const r0 = task(2_000, "long running task")
11
  const r1 = await task(200, "task 2")
12
  const r2 = await task(100, "task 3")
13
  return {
14
    r1,
15
    r2,
16
    r0: await r0,
17
  }
18
}
19

20
program().then(console.log)
21
/*
22
Output:
23
task 2 done
24
task 3 done
25
long running task done
26
{ r1: 'task 2', r2: 'task 3', r0: 'long running promise' }
27
*/

Answer: You can achieve this by utilizing Effect.fork and Fiber.join.

1
import { Effect, Fiber } from "effect"
2

3
const task = (delay: number, name: string) =>
4
  Effect.gen(function* () {
5
    yield* Effect.sleep(delay)
6
    console.log(`${name} done`)
7
    return name
8
  })
9

10
const program = Effect.gen(function* () {
11
  const r0 = yield* Effect.fork(task(2_000, "long running task"))
12
  const r1 = yield* task(200, "task 2")
13
  const r2 = yield* task(100, "task 3")
14
  return {
15
    r1,
16
    r2,
17
    r0: yield* Fiber.join(r0),
18
  }
19
})
20

21
Effect.runPromise(program).then(console.log)
22
/*
23
Output:
24
task 2 done
25
task 3 done
26
long running task done
27
{ r1: 'task 2', r2: 'task 3', r0: 'long running promise' }
28
*/