# Haskell Syllabus: Advent of Code 2026 Edition

## Overview

**Goal:** Solve Advent of Code 2026 in Haskell. Focus on four core skills:

1. **Simple IO:** reading and parsing string data from files
2. **String parsing:** parsing and managing strings
3. **Data transformation:** mapping, filtering, folding, grouping
4. **Terminal IO:** printing and formatting data for the terminal

Plus the techniques AoC puzzles keep asking for: grids, search, simulation, memoization and performance.

**Background:** Proficient in Go, Rust and Python. Experienced with TypeScript, Java and C#. Prior functional programming in OCaml and Elixir.

**Structure:** 24 lessons in 6 units, about 60–90 minutes each, worked through at my own pace.
Every 4th lesson is a practice session with real puzzles from past years. The next lesson is always the first unticked one.

**Approach:** Skip what I already know (immutability, recursion, ADTs, pattern matching, closures). Spend the time on what is different in Haskell: purity and `IO`, laziness, typeclasses, `Text` vs `String`, monadic parsing, and writing efficient code without mutation.

| Unit | Lessons | Theme                                     |
| ---- | ------- | ----------------------------------------- |
| 1    | 1–4     | Setup and foundations                     |
| 2    | 5–8     | Data transformation                       |
| 3    | 9–12    | IO and basic parsing                      |
| 4    | 13–16   | Parser combinators and terminal output    |
| 5    | 17–20   | AoC techniques: grids, search, simulation |
| 6    | 21–24   | Performance, toolkit and mock puzzle days |

### How each session runs

1. **Warm-up (5–10 min):** review items due in `review.md`.
2. **Concepts (20–30 min):** the lesson's topics, explained against Rust/OCaml where it helps.
3. **Exercises (30–45 min):** stubs with failing tests in `src/Exercises/LessonNN.hs`. I write the code; Claude gives hints, not solutions.
4. **Wrap-up (5 min):** check criterion, update `progress.md` and `review.md`, tick the lesson, commit.

**Practice sessions** use past AoC puzzles. Solutions go in `src/AoC/YYYY/DayNN.hs`, puzzle inputs in `inputs/YYYY/DayNN.txt`.
AoC asks people not to share their puzzle inputs, so `inputs/` is in `.gitignore`.

### Legend

- `[ ]` not started · `[x]` done
- **Bridge:** how a concept maps to a language I already know
- **Check:** what I should be able to do without help at the end of the lesson

---

## Unit 1: Setup and foundations

### Lesson 1: Toolchain and AoC project setup

- [ ] Lesson complete

**Goals**

- Install GHC, cabal and HLS via GHCup; editor integration working (type-on-hover, errors inline).
- Create the cabal project with a library, an executable and an hspec test suite (hspec-discover).
- Learn the GHCi loop: `:l`, `:r`, `:t`, `:i`, `:k`, `:doc`, `:set +s`.
- Install `hlint` and `ormolu`; know how to run them.
- Set up the repo layout: `src/Exercises/`, `src/AoC/`, `inputs/` (gitignored), `test/`.

**Bridge:** cabal ≈ cargo (`cabal build`, `cabal run`, `cabal test`, `cabal repl`). Hackage ≈ crates.io. Hoogle ≈ docs.rs, but you can search by type signature.

**Exercises**

- [ ] Get `cabal test` green with one trivial test.
- [ ] Add `text`, `containers` and `megaparsec` as dependencies and import each once to confirm they build.
- [ ] Look up `[a] -> Int`, `(a -> b) -> [a] -> [b]` and `String -> [String]` on Hoogle. Note what you find.

**Check:** I can create, build, test and REPL into the project from scratch.

### Lesson 2: Syntax, types and functions

- [ ] Lesson complete

**Goals**

- Function definitions, type signatures, currying, partial application, operator sections `(+ 1)`, `(/ 2)`.
- `where` vs `let`, guards, `case`, pattern matching on tuples and lists.
- Composition `(.)` and application `($)`; reading point-free code (and knowing when not to write it).
- `data`, `newtype`, `type`; records and record update syntax; deriving `Show`, `Eq`, `Ord`.
- `Maybe` and `Either` as the everyday error types.

**Bridge**

- `Maybe a` ≈ Rust `Option<T>` / OCaml `'a option`. `Either e a` ≈ `Result<T, E>` (note: error on the **left**).
- `data Dir = N | E | S | W` ≈ OCaml variant / Rust enum.
- `newtype` ≈ Rust tuple-struct newtype, zero runtime cost.
- `x & f` (from `Data.Function`) ≈ Elixir/OCaml `|>`.

**Exercises**

- [ ] Model a `Dir` type with `turnLeft`, `turnRight`, `opposite`, and `move :: Dir -> (Int, Int) -> (Int, Int)`.
- [ ] Write `safeDiv :: Int -> Int -> Maybe Int` and `parseDir :: Char -> Either String Dir`.
- [ ] Rewrite three small functions in point-free style, then decide which version reads better.

**Check:** I can read a type signature and predict roughly what a function does before reading its body.

### Lesson 3: Typeclasses, purity and laziness

- [ ] Lesson complete

**Goals**

- Typeclasses as interfaces: `Show`, `Eq`, `Ord`, `Enum`, `Bounded`, `Num`, `Semigroup`, `Monoid`; writing an instance by hand.
- Constraints in signatures: `(Ord a, Show a) => [a] -> String`.
- Purity: the "pure core, thin IO shell" design that every AoC solution will follow.
- Laziness: infinite lists, `take`/`iterate`/`cycle`, and when laziness bites (space leaks from lazy folds).
- Partial functions to avoid: `head`, `tail`, `!!`, `read`, `fromJust`. Safe alternatives.

**Bridge**

- Typeclasses ≈ Rust traits (closest match), more than OCaml modules or Java interfaces.
- `Semigroup`/`Monoid` ≈ `impl Add` plus an identity; `<>` combines, `mempty` is the empty value.
- Laziness ≈ Rust iterators or Python generators, except it's the default everywhere.

**Exercises**

- [ ] Derive `Enum` and `Bounded` for `Dir` and use them to rewrite `turnRight` without listing every case.
- [ ] Write a `Monoid` instance for a `Stats` type (count, sum, min, max) and combine a list with `mconcat`.
- [ ] Predict, then verify in GHCi: `take 5 (filter even [1..])`, `length [undefined, undefined]`, `foldl (+) 0 [1..10^7]` vs `foldl' (+) 0 [1..10^7]` with `:set +s`.

**Check:** I can explain why `foldl'` is preferred over `foldl`, and design a program as pure functions plus a small `main`.

### Lesson 4: Practice session 1

- [ ] Lesson complete

**Goals**

- Solve first real puzzles with what I know, using `String`, `lines`, `words` and `read` for now.
- Establish the solution template: `parse`, `part1`, `part2`, `main` reading `inputs/YYYY/DayNN.txt`.
- Test against the example input from the puzzle text before running on the real input.

**Exercises**

- [ ] 2022 Day 1 (Calorie Counting), both parts
- [ ] 2024 Day 1 (Historian Hysteria), both parts
- [ ] Compare with the reference solutions afterwards; note idioms to adopt in `review.md`.

**Check:** I can go from puzzle text to a correct answer for an easy puzzle, with example-based tests.

---

## Unit 2: Data transformation

### Lesson 5: Lists and the core toolkit

- [ ] Lesson complete

**Goals**

- `map`, `filter`, `foldr`, `foldl'`, `zip`, `zipWith`, `zip3`, `concatMap`, `takeWhile`, `dropWhile`, `span`, `break`, `splitAt`.
- `sum`, `product`, `maximum`, `minimum`, `and`, `or`, `any`, `all`, `elem`, `lookup`.
- List comprehensions vs `map`/`filter` chains; comprehensions for generating combinations and pairs.
- `Data.List`: `sort`, `sortOn`, `sortBy`, `group`, `groupBy`, `nub`, `partition`, `transpose`, `tails`, `inits`, `isPrefixOf`, `isInfixOf`.
- `Data.Ord`: `comparing`, `Down` for descending sorts.

**Bridge**

- `foldr`/`foldl'` ≈ OCaml `List.fold_right`/`List.fold_left`, Rust `.fold()`.
- `sortOn (Down . snd)` ≈ Rust `sort_by_key(|x| Reverse(x.1))`.
- `[(x, y) | (x:ys) <- tails xs, y <- ys]` ≈ all unique pairs, like Python `itertools.combinations(xs, 2)`.

**Exercises**

- [ ] Top-N: given `[(String, Int)]`, return the 3 highest scores, ties broken by name.
- [ ] Run-length encoding: `"aaabcc"` → `[('a',3),('b',1),('c',2)]` using `group`.
- [ ] Sliding windows: `windows 3 [1..6]` → `[[1,2,3],[2,3,4],[3,4,5],[4,5,6]]`.
- [ ] All pairs of a list whose sum equals a target.
- [ ] Transpose a grid of characters and find columns where all characters are the same.

**Check:** I can solve a typical "transform this list" task with library functions instead of hand-written recursion.

### Lesson 6: Maps, sets and pipelines that can fail

- [ ] Lesson complete

**Goals**

- `Data.Map.Strict` (qualified as `M`): `fromList`, `fromListWith`, `insertWith`, `adjust`, `alter`, `lookup`, `findWithDefault`, `toList`, `foldrWithKey`, `unionWith`.
- `Data.Set`: membership, union, intersection, difference; `Data.IntMap` for `Int` keys.
- Counting and grouping idioms: frequency tables, group-by-key.
- Functor and `fmap`/`<$>` on `Maybe`, `Either`, lists.
- `traverse`/`mapM` to turn `[Maybe a]` into `Maybe [a]` (fail fast); `mapMaybe` and `catMaybes` to drop failures.

**Bridge**

- `M.fromListWith (+)` ≈ Rust `entry().or_insert(0) += 1` or Python `Counter`.
- `traverse parse xs` ≈ Rust `xs.iter().map(parse).collect::<Result<Vec<_>, _>>()`.
- `>>=` on `Maybe` ≈ Rust `.and_then()`; `<$>` ≈ `.map()`.

**Exercises**

- [ ] Word frequency: count words in a string, case-insensitive, sorted by count desc.
- [ ] Group `(department, employee)` pairs into `Map String [String]`.
- [ ] Validate a list of raw strings into `Either String [Int]`, reporting the first bad value.
- [ ] Find items present in list A but not B, and in both, using `Set`.

**Check:** I reach for `Map`/`Set` naturally, and I can chain `Maybe`/`Either` functions without nested `case` pyramids.

### Lesson 7: State without mutation

- [ ] Lesson complete

**Goals**

- Threading state through a fold: `foldl'` with a tuple or record accumulator.
- `scanl` for every intermediate state; `iterate` plus `!!`/`takeWhile` for repeated steps.
- `until` and fixpoint iteration: repeat a step until nothing changes.
- Cycle detection: store seen states in a `Map`, find the loop, skip ahead (a classic "run 1 billion steps" trick).
- Recognizing the `State` monad at a reading level (`get`, `put`, `modify`), without depending on it yet.

**Bridge**

- A fold with a record accumulator ≈ a Rust loop mutating a struct, written as a pure function `step :: State -> Input -> State`.
- `iterate step s0` ≈ an infinite Rust `std::iter::successors`.

**Exercises**

- [ ] Simulate a robot following `"RRUULD..."` instructions; return its final position and all visited positions.
- [ ] Find the first position visited twice.
- [ ] Apply a state transformation 1,000,000,000 times using cycle detection.

**Check:** I can model any "simulate N steps" problem as a pure step function plus a fold or `iterate`.

### Lesson 8: Practice session 2

- [ ] Lesson complete

**Exercises**

- [ ] 2022 Day 2 (Rock Paper Scissors), both parts: model the domain with ADTs and `Enum`.
- [ ] 2024 Day 2 (Red-Nosed Reports), both parts: windows, `all`, removing one element.
- [ ] 2021 Day 1 (Sonar Sweep), both parts: `zipWith` and sliding windows, ideally in two lines each.

**Check:** I solve easy puzzles with idiomatic list and map functions, without manual recursion.

---

## Unit 3: IO and basic parsing

### Lesson 9: IO, do-notation and files

- [ ] Lesson complete

**Goals**

- The `IO` type; `do`-notation; `<-` vs `let` inside `do`; `pure`/`return`.
- Reading input: `readFile`, `getContents`, `interact`; writing: `putStrLn`, `print`.
- Command-line arguments with `getArgs`; exiting with `System.Exit`.
- `mapM_`, `forM_`, `when`, `unless` from `Control.Monad`.
- An AoC runner: `cabal run aoc -- 2024 1` picks the day's module and input file.

**Bridge**

- `do` ≈ Rust `?`-chained code or OCaml `let*`; `<-` "unwraps" a monadic value.
- `interact :: (String -> String) -> IO ()` ≈ a whole stdin-to-stdout filter in one line.

**Exercises**

- [ ] `wc` clone: count lines, words and characters of a file given as an argument.
- [ ] Build the AoC runner: takes year and day, reads the input, prints part 1 and part 2 with timings.
- [ ] Print a usage message and exit with code 1 on bad arguments.

**Check:** I can run any solved puzzle with one command, and my solution modules contain no IO.

### Lesson 10: Text and robust input

- [ ] Lesson complete

**Goals**

- Why `String` (`[Char]`) is slow, and when it's fine anyway (most AoC inputs are small).
- `Data.Text` and `Data.Text.IO` (qualified as `T`/`TIO`); `OverloadedStrings`; `T.pack`/`T.unpack`.
- Common operations: `T.lines`, `T.words`, `T.splitOn`, `T.strip`, `T.breakOn`, `T.chunksOf`, `T.isPrefixOf`, `T.replace`.
- Handling blank-line-separated blocks (`T.splitOn "\n\n"`), trailing newlines and Windows line endings.
- Handling IO errors: missing files, `try` with `IOException`, turning them into `Either`.

**Bridge**

- `String` ≈ a linked list of chars; `Text` ≈ Rust `String`/`&str`.
- `try (readFile p) :: IO (Either IOException String)` ≈ Rust `fs::read_to_string(p)` returning `Result`.

**Exercises**

- [ ] Port the runner to `Text` input.
- [ ] Parse blank-line-separated groups of numbers into `[[Int]]`.
- [ ] Read a `key = value` file into `Map Text Text`, ignoring blanks and `#` comments.
- [ ] Print a friendly error instead of crashing when an input file is missing.

**Check:** I default to `Text` for input and never get tripped up by trailing newlines.

### Lesson 11: Parsing without a library, and grids

- [ ] Lesson complete

**Goals**

- Splitting and reading: `lines`, `words`, `T.splitOn`, `break`/`span` on a delimiter.
- `readMaybe` from `Text.Read`; `Data.Text.Read` (`decimal`, `signed`) for `Text`.
- `Data.Char`: `isDigit`, `isSpace`, `isAlpha`, `digitToInt`.
- Extracting all integers from a messy line (a very common AoC shortcut).
- Parsing character grids into `Map (Int, Int) Char` with `zip [0..]`.

**Bridge**

- `readMaybe s :: Maybe Int` ≈ Rust `s.parse::<i32>().ok()`.
- Grid parsing with nested `zip [0..]` ≈ Python `enumerate` inside `enumerate`.

**Exercises**

- [ ] `ints :: Text -> [Int]`: extract all (possibly negative) integers from `"x=-3, y=12 to 7"`.
- [ ] Parse lines like `move 3 from 1 to 2` into a `Command` type.
- [ ] Parse a character grid into `Map (Int, Int) Char`; find all coordinates of `#`.
- [ ] Parse a CSV-like file into records, reporting the line number of every malformed row.

**Check:** I can turn any structured text into typed values with only `base`, `text` and `containers`.

### Lesson 12: Practice session 3

- [ ] Lesson complete

**Exercises**

- [ ] 2022 Day 5 (Supply Stacks), both parts: a tricky two-section input with a drawn diagram.
- [ ] 2023 Day 2 (Cube Conundrum), both parts: nested separators.
- [ ] 2023 Day 1 (Trebuchet?!), both parts: string scanning with overlapping words.

**Check:** I can parse irregular inputs by hand, and I know when that's getting too painful.

---

## Unit 4: Parser combinators and terminal output

### Lesson 13: Parser combinators, part 1

- [ ] Lesson complete

**Goals**

- The idea: a parser is a value, and parsers combine into bigger parsers.
- `Applicative` operators that make parsing readable: `<$>`, `<*>`, `*>`, `<*`, `<|>`.
- `megaparsec` basics: `Parsec Void Text`, `parse`, `errorBundlePretty`, `char`, `string`, `space`, `L.decimal`, `L.signed`, `sepBy`, `some`, `many`.
- Brief look at `ReadP` (in `base`, no dependency) for quick one-offs.

**Bridge**

- ≈ Rust `nom` or `chumsky`, OCaml `angstrom`.
- `Point <$> int <* char ',' <*> int` ≈ "parse an int, skip a comma, parse an int, build a Point".

**Exercises**

- [ ] Parse `"(3,4)"` into `Point 3 4`.
- [ ] Parse `"Game 12: 3 red, 5 blue; 1 green"` into a record with nested lists.
- [ ] Make a parser fail on purpose and read the `errorBundlePretty` output.

**Check:** I can write a small combinator parser and explain what each operator does.

### Lesson 14: Parser combinators, part 2

- [ ] Lesson complete

**Goals**

- Structuring a parser: lexeme and symbol helpers, whitespace handling, `try` and backtracking.
- `choice`, `optional`, `between`, `sepEndBy`, `manyTill`, `eof`, `anySingle`.
- Finding patterns inside noise: skipping junk until something parses.
- Parsing keywords into sum types; why `do`-notation also works inside parsers.
- A shared `AoC.Parse` module with my reusable helpers.

**Bridge**

- `try` ≈ explicit backtracking; megaparsec doesn't backtrack by default, for good error messages.

**Exercises**

- [ ] Parse arithmetic expressions with `+`, `*` and parentheses; evaluate them.
- [ ] Extract every valid `mul(a,b)` from a corrupted string (the core of 2024 Day 3).
- [ ] Parse a small INI file into `Map Text (Map Text Text)`.

**Check:** I can parse a realistic, messy text format end to end with good error messages.

### Lesson 15: Terminal output and debugging

- [ ] Lesson complete

**Goals**

- `show` vs custom rendering; `Text.Printf.printf` with widths and precision (`%-10s %6.2f`).
- Padding and alignment: `T.justifyLeft`, `T.justifyRight`, `T.center`; computing column widths.
- Rendering a grid `Map (Int, Int) Char` back to text: essential for debugging simulations and for puzzles whose answer appears as letters on a grid.
- ANSI colors via escape codes (`"\ESC[31m"`) to highlight positions in a grid.
- `Debug.Trace` (`trace`, `traceShow`, `traceShowId`) for printing from pure code while debugging.

**Bridge**

- `printf "%-10s %5d\n" name n` ≈ Rust `println!("{:<10} {:>5}", name, n)`, Go `fmt.Printf`.
- `traceShowId x` ≈ Rust `dbg!(x)`.

**Exercises**

- [ ] Print a word-frequency result as an aligned table with a header and separator line.
- [ ] `renderGrid :: Map (Int, Int) Char -> Text`, with a highlighted set of positions in color.
- [ ] Animate a simulation from Lesson 7 in the terminal, frame by frame.
- [ ] Add per-part timing and nicely formatted output to the AoC runner.

**Check:** I can visualize any grid or data structure in the terminal and debug pure code with `trace`.

### Lesson 16: Practice session 4

- [ ] Lesson complete

**Exercises**

- [ ] 2024 Day 3 (Mull It Over), both parts, using megaparsec.
- [ ] 2023 Day 4 (Scratchcards), both parts: parsing plus a counting recurrence.
- [ ] 2022 Day 7 (No Space Left On Device), both parts: parse a terminal log into a tree or a `Map` of paths.

**Check:** My default for any non-trivial input is a megaparsec parser written in minutes.

---

## Unit 5: AoC techniques

### Lesson 17: Grids and coordinates

- [ ] Lesson complete

**Goals**

- Representations: `Map (Int, Int) Char`, `Set (Int, Int)` for sparse grids, `Data.Array` for dense ones; when to use which.
- Coordinate helpers: a `V2`-style point type with `Num` instance, neighbors (4 and 8), directions, bounds checks.
- Scanning in a direction until a condition holds; rotating and flipping grids with `transpose`/`reverse`.
- Flood fill and counting connected regions.

**Bridge**

- `Data.Array` ≈ an immutable `Vec`; `(//)` copies, so batch updates or use a `Map` for frequent changes.

**Exercises**

- [ ] Build `AoC.Grid` with `parseGrid`, `neighbors4`, `neighbors8`, `inBounds`, `renderGrid`.
- [ ] Count the regions of each letter in a grid with flood fill.
- [ ] Find all occurrences of a word in a grid in all 8 directions.

**Check:** I have a grid module I trust, and grid puzzles feel routine.

### Lesson 18: Search: BFS, DFS and Dijkstra

- [ ] Lesson complete

**Goals**

- BFS with `Data.Sequence` as a queue and a `Set` of visited states.
- DFS via recursion or a list as a stack; enumerating all paths.
- Dijkstra with `Data.Set (cost, state)` as a priority queue (or the `psqueues` package).
- Searching over states, not just positions: `(position, direction, keysCollected)`.
- Generic search functions parameterized by a `next :: s -> [(s, cost)]` function.

**Bridge**

- `Data.Sequence` ≈ Rust `VecDeque`, but persistent; `Set.deleteFindMin` ≈ popping a `BinaryHeap` (with `Reverse`).

**Exercises**

- [ ] Shortest path through a maze with BFS.
- [ ] Count all distinct paths from start to end in a DAG.
- [ ] Shortest path in a weighted grid with Dijkstra, where turning costs extra.
- [ ] Generalize: `bfs :: Ord s => (s -> [s]) -> s -> Map s Int`.

**Check:** I can write BFS and Dijkstra from memory, in a generic form I reuse.

### Lesson 19: Memoization, recursion and number tricks

- [ ] Lesson complete

**Goals**

- Memoization with a `Map` threaded through recursion, or the `State` monad for convenience.
- Lazy memoization: a lazily filled `Data.Array` or `Map` whose values reference each other (dynamic programming for free).
- Integer types: `Int` vs `Integer` (overflow!), `div`/`mod` vs `quot`/`rem`, `gcd`/`lcm`.
- Combinatorics helpers: subsequences, permutations, choosing k elements.
- Ranges and intervals: merging, splitting, counting overlaps without enumerating elements.

**Bridge**

- Lazy array DP ≈ a Python `@cache` decorator, without mutation.
- `Integer` ≈ Python's unbounded `int`; `Int` ≈ Rust `i64`, and it wraps silently on overflow.

**Exercises**

- [ ] Count ways to build a string from a set of patterns, using memoization.
- [ ] Solve a grid DP (min path sum) with a lazy array.
- [ ] Merge overlapping ranges and count the total length covered.
- [ ] Use `lcm` to find when several cycles line up.

**Check:** When part 2 makes brute force impossible, I know which of these tools to reach for.

### Lesson 20: Practice session 5

- [ ] Lesson complete

**Exercises**

- [ ] 2024 Day 4 (Ceres Search), both parts: grid scanning.
- [ ] 2022 Day 12 (Hill Climbing Algorithm), both parts: BFS.
- [ ] 2024 Day 10 (Hoof It), both parts: DFS and counting paths.

**Check:** I solve medium grid and search puzzles with my own helper modules.

---

## Unit 6: Performance, toolkit and mock days

### Lesson 21: Performance

- [ ] Lesson complete

**Goals**

- Compiling with `-O2`; why `cabal repl` is much slower than the compiled program.
- Strictness: `foldl'`, `Data.Map.Strict`, strict record fields (`!Int`), `BangPatterns`, `seq`.
- Faster containers: `Data.IntMap`/`IntSet`, `Data.Array.Unboxed`, `Data.Vector`.
- Encoding coordinates as a single `Int` key for speed.
- Basic profiling: `+RTS -s` for memory and GC stats.

**Bridge**

- Space leaks from laziness have no Rust equivalent; strict fields ≈ making sure values are computed, not just promised.

**Exercises**

- [ ] Take a slow solution from earlier and make it at least 10× faster; record each step's effect.
- [ ] Fix a deliberate space leak found with `+RTS -s`.

**Check:** I can explain why a Haskell solution is slow and fix the common causes.

### Lesson 22: Personal AoC toolkit

- [ ] Lesson complete

**Goals**

- Consolidate reusable modules: `AoC.Parse`, `AoC.Grid`, `AoC.Search`, `AoC.Util` (counting, windows, ranges).
- A day template generator: creates `DayNN.hs`, an example test file and an input placeholder.
- Tests for the toolkit, so I can trust it under pressure.
- Optional: fetch inputs automatically with a session cookie (stored outside the repo).

**Exercises**

- [ ] Review all practice solutions; move repeated helpers into the toolkit.
- [ ] Write the day template generator.
- [ ] Re-solve one earlier puzzle using only the toolkit and time it.

**Check:** Starting a new day takes one command, and common helpers are one import away.

### Lesson 23: Mock puzzle day 1

- [ ] Lesson complete

**Goals**

- Simulate a real AoC day: read the puzzle, parse, solve part 1, then part 2, timing each phase.
- Hints only when stuck for more than 15 minutes.

**Exercises**

- [ ] 2024 Day 6 (Guard Gallivant), both parts: simulation, cycle detection, performance in part 2.
- [ ] Note the time spent on parsing vs logic vs debugging.

**Check:** I can complete a mid-level puzzle independently.

### Lesson 24: Mock puzzle day 2 and readiness check

- [ ] Lesson complete

**Exercises**

- [ ] One unseen puzzle from 2023 or 2024 chosen by Claude, at a medium difficulty, solved under the same rules.
- [ ] Retrospective in `progress.md`: strengths, weak spots, what to review before the event starts.
- [ ] Check that the toolchain, runner, template and toolkit all work on a fresh clone.

**Check:** I'm ready for Advent of Code.

---

## During Advent of Code

- Last year's event had 12 puzzles instead of the usual 25. Check the AoC website for this year's format and its rules on using AI tools.
- Try every puzzle alone first. Claude gives hints only (as defined in `CLAUDE.md`), never solutions while the puzzle is fresh.
- After solving, ask for a code review and a reference solution, and add new helpers to the toolkit.
- Keep logging in `progress.md`; add new techniques to `review.md`.

---

## Reference

### Essential imports

```haskell
{-# LANGUAGE OverloadedStrings #-}

import qualified Data.Map.Strict as M
import qualified Data.Set as S
import qualified Data.Sequence as Seq
import qualified Data.Text as T
import qualified Data.Text.IO as TIO
import Data.List (foldl', sortOn, group, sort, transpose, tails)
import Data.Ord (Down (..), comparing)
import Data.Maybe (mapMaybe, fromMaybe)
import Data.Char (isDigit, isSpace)
import Text.Read (readMaybe)
import Text.Printf (printf)
import Control.Monad (forM_, when, unless)
import Debug.Trace (traceShowId)
```

### Solution template

```haskell
module AoC.Y2024.Day01 (solve) where

import Data.Text (Text)

data Input = Input -- puzzle-specific

parse :: Text -> Input
parse = undefined

part1 :: Input -> Int
part1 = undefined

part2 :: Input -> Int
part2 = undefined

solve :: Text -> (String, String)
solve raw = let x = parse raw in (show (part1 x), show (part2 x))
```

### Resources

- _Learn You a Haskell for Great Good!_ (quick syntax refresher)
- _Programming in Haskell_ by Graham Hutton (chapters on parsers and IO)
- Hoogle for searching functions by type
- megaparsec tutorial by Mark Karpov
- Past AoC puzzles at adventofcode.com, and r/adventofcode for discussions after solving