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

4
// =============================================================================
5
// 02 - Result Types: Errors as Values
6
// =============================================================================
7
//
8
// A Result is a tagged union of success or failure. Effect<A, E, R> extends the
9
// idea with laziness, composition, and dependency tracking. This file covers
10
// the type only — constructors and runners are exercised in detail in step 03.
11

12
type Result<A, E> = { ok: true; value: A } | { ok: false; error: E }
13

14
function parseAge(input: string): Result<number, string> {
15
  const n = parseInt(input)
16
  if (isNaN(n)) return { ok: false, error: "Not a number" }
17
  if (n < 0) return { ok: false, error: "Negative age" }
18
  return { ok: true, value: n }
19
}
20

21
// @beat
22
//   id: plain-result
23
//   shape: multi-todo
24
//   title: Errors as values with a plain Result
25
//   teaches: A tagged union with an `ok` discriminant narrows to either the value or the error inside each branch.
26
//   hint: check `result.ok` first, then read `result.value` or `result.error`
27
it("narrows to the value when ok is true", () => {
28
  const result = parseAge("25")
29
  expect(result.ok).toBe(true)
30
  if (/* @stub */ result.ok /* @end */) {
31
    expect(result.value).toBe(25)
32
  }
33
})
34

35
it("narrows to the error when ok is false", () => {
36
  const result = parseAge("banana")
37
  expect(result.ok).toBe(false)
38
  if (/* @stub */ !result.ok /* @end */) {
39
    expect(result.error).toBe("Not a number")
40
  }
41
})
42
// @end-beat
43

44
// @beat
45
//   id: succeed-and-fail
46
//   shape: multi-todo
47
//   title: Lift values into Effect's A and E channels
48
//   teaches: Effect.succeed lifts a value into A; Effect.fail lifts a value into E.
49
//   hint: use Effect.succeed for the value and Effect.fail for the error
50
it("Effect.succeed produces Effect<A, never, never>", () => {
51
  //      ┌─── Effect<number, never, never>
52
  //      ▼
53
  const program = /* @stub */ Effect.succeed(42) /* @end */
54
  expect(Effect.runSync(program)).toBe(42)
55
})
56

57
it("Effect.fail produces Effect<never, E, never>", () => {
58
  //      ┌─── Effect<never, string, never>
59
  //      ▼
60
  const program = /* @stub */ Effect.fail("oops") /* @end */
61
  const exit = Effect.runSyncExit(program)
62
  expect(Exit.isFailure(exit)).toBe(true)
63
})
64
// @end-beat
65

66
// @beat
67
//   id: construction-is-lazy
68
//   shape: multi-todo
69
//   title: Construction does not execute
70
//   teaches: Building an Effect performs no work; the description runs only when handed to a runner.
71
//   hint: predict `called` before runSync, then after — the runner flips it
72
it("construction does not execute the computation", () => {
73
  let called = false
74
  const program = Effect.sync(() => {
75
    called = true
76
    return 42
77
  })
78

79
  // Predict `called` before any runner has touched the program.
80
  expect(called).toBe(/* @stub */ false /* @end */)
81
  Effect.runSync(program)
82
  expect(called).toBe(/* @stub */ true /* @end */)
83
})
84
// @end-beat
85

86
// @beat
87
//   id: typed-tagged-error
88
//   shape: multi-todo
89
//   title: Put a structured error in E
90
//   teaches: A Data.TaggedError carries typed fields into the E channel so callers can inspect what went wrong.
91
//   hint: construct ParseError with { input, reason } and place it inside Effect.fail
92
it("succeeds on the happy path", () => {
93
  class ParseError extends Data.TaggedError("ParseError")<{
94
    readonly input: string
95
    readonly reason: string
96
  }> {}
97

98
  //      ┌─── Effect<number, ParseError, never>
99
  //      ▼
100
  const parseAgeE = (input: string): Effect.Effect<number, ParseError> => {
101
    const n = parseInt(input)
102
    if (isNaN(n))
103
      return /* @stub */ Effect.fail(new ParseError({ input, reason: "not a number" })) /* @end */
104
    if (n < 0)
105
      return /* @stub */ Effect.fail(new ParseError({ input, reason: "negative age" })) /* @end */
106
    return Effect.succeed(n)
107
  }
108

109
  expect(Effect.runSync(parseAgeE("25"))).toBe(25)
110
})
111

112
it("places a typed error in the E channel", () => {
113
  class ParseError extends Data.TaggedError("ParseError")<{
114
    readonly input: string
115
    readonly reason: string
116
  }> {}
117

118
  const parseAgeE = (input: string): Effect.Effect<number, ParseError> => {
119
    const n = parseInt(input)
120
    if (isNaN(n)) return Effect.fail(new ParseError({ input, reason: "not a number" }))
121
    if (n < 0) return Effect.fail(new ParseError({ input, reason: "negative age" }))
122
    return Effect.succeed(n)
123
  }
124

125
  const exit = Effect.runSyncExit(parseAgeE("banana"))
126
  expect(Exit.isFailure(exit)).toBe(true)
127
  if (Exit.isFailure(exit) && exit.cause.reasons[0]?._tag === "Fail") {
128
    expect(exit.cause.reasons[0].error._tag).toBe("ParseError")
129
    expect(exit.cause.reasons[0].error.reason).toBe("not a number")
130
  }
131
})
132
// @end-beat
133

134
// @beat
135
//   id: error-unions
136
//   shape: one-todo
137
//   title: List every failure mode in E
138
//   teaches: A function with multiple failure modes lists each one in the E channel as a union.
139
//   hint: return Effect.fail with two distinct literal tags so the union has both members
140
it("tracks every failure mode in the union", () => {
141
  //      ┌─── Effect<number, "NotANumber" | "NotPositive", never>
142
  //      ▼
143
  const parsePositive = (input: string): Effect.Effect<number, "NotANumber" | "NotPositive"> => {
144
    const n = parseInt(input)
145
    if (isNaN(n)) return /* @stub */ Effect.fail("NotANumber" as const) /* @end */
146
    if (n <= 0) return /* @stub */ Effect.fail("NotPositive" as const) /* @end */
147
    return Effect.succeed(n)
148
  }
149

150
  expect(Effect.runSync(parsePositive("5"))).toBe(5)
151

152
  const e1 = Effect.runSyncExit(parsePositive("banana"))
153
  if (Exit.isFailure(e1) && e1.cause.reasons[0]?._tag === "Fail") {
154
    expect(e1.cause.reasons[0].error).toBe("NotANumber")
155
  }
156

157
  const e2 = Effect.runSyncExit(parsePositive("-3"))
158
  if (Exit.isFailure(e2) && e2.cause.reasons[0]?._tag === "Fail") {
159
    expect(e2.cause.reasons[0].error).toBe("NotPositive")
160
  }
161
})
162
// @end-beat