1
import { it, expect } from "vite-plus/test"
2
import { Effect, Exit, Fiber, Data, Cause } from "effect"
3

4
// =============================================================================
5
// 14 - Runners
6
// =============================================================================
7
//
8
// Two axes: sync vs async (caller waits or gets a Promise) and total vs
9
// partial (returns Exit vs throws/rejects on failure). Plus runFork for
10
// fire-and-forget.
11

12
class DivideByZero extends Data.TaggedError("DivideByZero")<{}> {}
13

14
const divide = (a: number, b: number) =>
15
  b === 0 ? Effect.fail(new DivideByZero()) : Effect.succeed(a / b)
16

17
// @beat
18
//   id: run-sync
19
//   shape: one-todo
20
//   title: Effect.runSync — synchronous, throws on failure
21
//   teaches: runSync executes a fully synchronous Effect and returns A directly. Failures throw.
22
//   hint: Effect.runSync(Effect.sync(() => 42))
23
it("runSync returns the success value for a synchronous Effect", () => {
24
  const compute = Effect.sync(() => 6 * 7)
25

26
  const answer = /* @stub */ Effect.runSync(compute) /* @end */
27

28
  expect(answer).toBe(42)
29
})
30
// @end-beat
31

32
// @beat
33
//   id: run-sync-exit
34
//   shape: one-todo
35
//   title: Effect.runSyncExit — synchronous, returns Exit
36
//   teaches: runSyncExit returns Exit<A, E> so callers can branch on success/failure without try/catch.
37
//   hint: Effect.runSyncExit(divide(10, 0)) — branch on Exit.isFailure
38
it("runSyncExit returns an Exit and never throws", () => {
39
  const ok = /* @stub */ Effect.runSyncExit(divide(10, 2)) /* @end */
40
  expect(Exit.isSuccess(ok)).toBe(true)
41
  if (Exit.isSuccess(ok)) expect(ok.value).toBe(5)
42

43
  const bad = /* @stub */ Effect.runSyncExit(divide(10, 0)) /* @end */
44
  expect(Exit.isFailure(bad)).toBe(true)
45
  if (Exit.isFailure(bad)) {
46
    const error = Cause.findErrorOption(bad.cause)
47
    expect(error._tag).toBe("Some")
48
    if (error._tag === "Some") {
49
      expect(error.value._tag).toBe("DivideByZero")
50
    }
51
  }
52
})
53
// @end-beat
54

55
// @beat
56
//   id: run-promise
57
//   shape: one-todo
58
//   title: Effect.runPromise — asynchronous, rejects on failure
59
//   teaches: runPromise is the right runner whenever the Effect contains async work; it returns a Promise that rejects on failure.
60
//   hint: await Effect.runPromise(asyncEffect)
61
it("runPromise awaits an async Effect and resolves with A", async () => {
62
  const asyncJob = Effect.promise(() => Promise.resolve("ok"))
63

64
  const result = /* @stub */ await Effect.runPromise(asyncJob) /* @end */
65

66
  expect(result).toBe("ok")
67
})
68
// @end-beat
69

70
// @beat
71
//   id: run-promise-exit
72
//   shape: one-todo
73
//   title: Effect.runPromiseExit — asynchronous, returns Exit
74
//   teaches: runPromiseExit is the async sibling of runSyncExit; the returned Promise never rejects — it resolves with an Exit.
75
//   hint: const exit = await Effect.runPromiseExit(...)
76
it("runPromiseExit resolves with an Exit instead of rejecting", async () => {
77
  const fail = Effect.fail(new DivideByZero())
78

79
  const exit = /* @stub */ await Effect.runPromiseExit(fail) /* @end */
80

81
  expect(Exit.isFailure(exit)).toBe(true)
82
  if (Exit.isFailure(exit)) {
83
    const error = Cause.findErrorOption(exit.cause)
84
    expect(error._tag).toBe("Some")
85
    if (error._tag === "Some") {
86
      expect(error.value._tag).toBe("DivideByZero")
87
    }
88
  }
89
})
90
// @end-beat
91

92
// @beat
93
//   id: run-sync-on-async
94
//   shape: mistake-first
95
//   title: runSync cannot wait for async — it throws
96
//   teaches: runSync on an Effect containing any async work (promise, sleep, fork) throws AsyncFiberException at runtime. Use runPromise instead.
97
//   hint: first half shows the throw; second half uses runPromise
98
it("runSync on async work throws AsyncFiberException", async () => {
99
  const asyncJob = Effect.promise(() => Promise.resolve("ok"))
100

101
  // ❌ Wrong runner — throws.
102
  expect(() => Effect.runSync(asyncJob)).toThrow()
103

104
  // ✅ Right runner — awaits the work.
105
  const result = /* @stub */ await Effect.runPromise(asyncJob) /* @end */
106
  expect(result).toBe("ok")
107
})
108
// @end-beat
109

110
// @beat
111
//   id: run-fork
112
//   shape: one-todo
113
//   title: Effect.runFork — fire-and-forget
114
//   teaches: runFork spawns the Effect as a fiber and returns immediately. Fiber.await collects the eventual Exit; Fiber.interrupt cancels it.
115
//   hint: const fiber = Effect.runFork(work); const exit = await Effect.runPromise(Fiber.await(fiber))
116
it("runFork returns a fiber that can be awaited later", async () => {
117
  const work = Effect.succeed("forked").pipe(Effect.delay("1 millis"))
118

119
  const fiber = /* @stub */ Effect.runFork(work) /* @end */
120

121
  const exit = await Effect.runPromise(Fiber.await(fiber))
122
  expect(Exit.isSuccess(exit)).toBe(true)
123
  if (Exit.isSuccess(exit)) expect(exit.value).toBe("forked")
124
})
125
// @end-beat