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

4
// =============================================================================
5
// 04 - Pipe and Flow: Composing Effects
6
// =============================================================================
7
//
8
// pipe(value, f, g)   threads a value through functions left-to-right.
9
// flow(f, g)          returns a new function — pipe without the value.
10
// Effect.map          transforms success with a pure function.
11
// Effect.flatMap      chains an effectful step (returns a new Effect).
12

13
// @beat
14
//   id: pipe-basics
15
//   shape: multi-todo
16
//   title: Thread a value through pipe
17
//   teaches: pipe applies a sequence of unary functions left to right and works on any value, not just Effects.
18
//   hint: pass the value first, then the transformations in the order you want them applied
19
it("threads a value through a sequence of functions", () => {
20
  //      ┌─── Effect<string, never, never>
21
  //      ▼
22
  const program = Effect.succeed(5).pipe(
23
    /* @stub */ Effect.map((n) => n * 2) /* @end */,
24
    /* @stub */ Effect.map((n) => n + 3) /* @end */,
25
    /* @stub */ Effect.map((n) => n.toString()) /* @end */,
26
  )
27

28
  expect(Effect.runSync(program)).toBe("13")
29
})
30

31
it("works as a standalone function", () => {
32
  const program = /* @stub */ pipe(
33
    Effect.succeed(10),
34
    Effect.map((n) => n * 2),
35
    Effect.map((n) => n + 1),
36
  ) /* @end */
37

38
  expect(Effect.runSync(program)).toBe(21)
39
})
40

41
it("composes plain values and plain functions", () => {
42
  const result = pipe(
43
    "  hello world  ",
44
    /* @stub */ (s) => s.trim() /* @end */,
45
    /* @stub */ (s) => s.toUpperCase() /* @end */,
46
    /* @stub */ (s) => s.split(" ") /* @end */,
47
  )
48

49
  expect(result).toEqual(["HELLO", "WORLD"])
50
})
51
// @end-beat
52

53
// @beat
54
//   id: effect-map
55
//   shape: one-todo
56
//   title: Transform success with Effect.map
57
//   teaches: Effect.map applies a pure function to the success channel and leaves the error channel untouched.
58
//   hint: wrap a pure transformation, not one that returns another Effect
59
it("transforms the success value with a pure function", () => {
60
  const program = Effect.succeed(5).pipe(/* @stub */ Effect.map((n) => n * 2) /* @end */)
61
  expect(Effect.runSync(program)).toBe(10)
62
})
63
// @end-beat
64

65
// @beat
66
//   id: effect-flatmap
67
//   shape: multi-todo
68
//   title: Chain effectful steps with flatMap
69
//   teaches: Effect.flatMap chains an effect-returning callback; its error type unions into the outer E.
70
//   hint: the callback must return an Effect — Effect.succeed or Effect.fail, never a plain value
71
it("chains an effectful step", () => {
72
  const program = Effect.succeed(5).pipe(
73
    /* @stub */ Effect.flatMap((n) => Effect.succeed(n * 2)) /* @end */,
74
    /* @stub */ Effect.flatMap((n) => Effect.succeed(n + 1)) /* @end */,
75
  )
76

77
  expect(Effect.runSync(program)).toBe(11)
78
})
79

80
it("unions the inner error into the outer E", () => {
81
  //      ┌─── Effect<string, "too small", never>
82
  //      ▼
83
  const program = Effect.succeed(5).pipe(
84
    Effect.flatMap((n) =>
85
      /* @stub */ n > 5 ? Effect.succeed(`big: ${n}`) : Effect.fail("too small" as const) /* @end */,
86
    ),
87
  )
88

89
  const exit = Effect.runSyncExit(program)
90
  expect(Exit.isFailure(exit)).toBe(true)
91
})
92
// @end-beat
93

94
// @beat
95
//   id: short-circuit
96
//   shape: one-todo
97
//   title: Failures short-circuit the pipeline
98
//   teaches: Once an Effect enters the error channel, subsequent map/flatMap steps are skipped and the failure propagates.
99
//   hint: which steps logged before the failure fired? everything after is skipped
100
it("short-circuits at the first failure", () => {
101
  const log: string[] = []
102

103
  const program = Effect.succeed(5).pipe(
104
    Effect.map((n) => {
105
      log.push("step1")
106
      return n * 2
107
    }),
108
    Effect.flatMap(() => {
109
      log.push("step2")
110
      return Effect.fail("boom" as const)
111
    }),
112
    Effect.map((n) => {
113
      log.push("step3")
114
      return n + 3
115
    }),
116
  )
117

118
  const exit = Effect.runSyncExit(program)
119
  expect(Exit.isFailure(exit)).toBe(true)
120
  // Predict which step labels made it into the log before the failure short-circuited the rest.
121
  expect(log).toEqual(/* @stub */ ["step1", "step2"] /* @end */)
122
})
123

124
it("short-circuits on flatMap failure", () => {
125
  const program = Effect.succeed(5).pipe(
126
    Effect.flatMap(() => Effect.fail("first")),
127
    Effect.flatMap(() => Effect.succeed("never")),
128
  )
129

130
  expect(Exit.isFailure(Effect.runSyncExit(program))).toBe(true)
131
})
132
// @end-beat
133

134
// @beat
135
//   id: flow
136
//   shape: multi-todo
137
//   title: Build reusable pipelines with flow
138
//   teaches: flow composes functions without a starting value, producing a reusable function.
139
//   hint: flow is pipe without the value — reach for it when the same pipeline applies to many inputs
140
it("composes plain functions into a new function", () => {
141
  const process = /* @stub */ flow(
142
    (n: number) => n * 2,
143
    (n: number) => n + 1,
144
    (n: number) => `Result: ${n}`,
145
  ) /* @end */
146

147
  expect(process(5)).toBe("Result: 11")
148
  expect(process(10)).toBe("Result: 21")
149
})
150

151
it("builds reusable Effect pipelines", () => {
152
  const normalize = /* @stub */ flow(
153
    Effect.map((s: string) => s.trim()),
154
    Effect.map((s) => s.toLowerCase()),
155
    Effect.map((s) => s.replace(/\s+/g, "-")),
156
  ) /* @end */
157

158
  expect(Effect.runSync(normalize(Effect.succeed("  Hello World  ")))).toBe("hello-world")
159
  expect(Effect.runSync(normalize(Effect.succeed("  Effect TS  ")))).toBe("effect-ts")
160
})
161
// @end-beat