nix-playgraound/notes/014-haskell-learning-path.md

# Haskell Learning Path

This note links the Haskell examples in a suggested order from first project structure through intermediate language and application patterns.

---

## 1. Suggested Order

1. `05-haskell/`: a small Cabal library, executable, test suite, and dev shell
2. `06-haskell-shellfor/`: a Haskell package set override and a `shellFor`-based dev shell
3. `07-haskell-deps/`: external Haskell libraries through Cabal `build-depends`
4. `08-haskell-adt/`: algebraic data types, records, and pattern matching
5. `09-haskell-newtype/`: `newtype`, smart constructors, and validation
6. `10-haskell-effects/`: `ReaderT`, `Except`, and constrained application logic
7. `11-haskell-typeclasses/`: custom type classes and per-type instances
8. `12-haskell-parser-combinators/`: parser combinators with Megaparsec
9. `23-haskell-maybe-either/`: optional values, required-field errors, and layered request validation
10. `24-haskell-deriving/`: deriving strategies for ordering, enumeration, and wrapper behavior
11. `25-haskell-state/`: pure stateful planning with global and per-environment counters
12. `26-haskell-quickcheck/`: property testing for a non-trivial normalization function
13. `27-haskell-aeson-roundtrip/`: explicit JSON instances and round-trip checks
14. `28-haskell-applicative-validation/`: accumulated field validation with an Applicative error type
15. `29-haskell-foldmap-summary/`: monoidal event aggregation with one `foldMap` pass
16. `30-haskell-traverse-resolution/`: batch resolution of requests through `traverse`
17. `31-haskell-writer-audit/`: rollout logging with `Writer`
18. `32-haskell-nonempty-waves/`: rollout planning with `NonEmpty`
19. `33-haskell-optparse-cli/`: command-line parsing with `optparse-applicative`
20. `34-haskell-dependency-order/`: dependency-ordered planning with cycle checks
21. `35-haskell-monad-chaining/`: dependent rollout approval with monadic `Either`
22. `36-haskell-map-set-modeling/`: access-policy modeling with `Map` and `Set`
23. `37-haskell-transformer-stack/`: composed effects with `ReaderT`, `ExceptT`, and `Writer`
24. `38-haskell-generic-json/`: generic JSON instances with Aeson options

---

## 2. What to Focus on at Each Step

- `05-haskell/`: how a Cabal package becomes a flake package, app, dev shell, and check
- `06-haskell-shellfor/`: when a Haskell-specific dev shell is more useful than a generic shell
- `07-haskell-deps/`: why Cabal stays the source of truth for package dependencies
- `08-haskell-adt/`: how to model a problem with constructors before writing behavior
- `09-haskell-newtype/`: how to move validation to the boundary and protect the domain model
- `10-haskell-effects/`: how to separate configuration, logic, and failures
- `11-haskell-typeclasses/`: how to abstract shared behavior across several types
- `12-haskell-parser-combinators/`: how to build a small language from reusable parser pieces
- `23-haskell-maybe-either/`: how optional fields and validation errors play different roles
- `24-haskell-deriving/`: how derived behavior depends on constructor and field layout
- `25-haskell-state/`: how to thread evolving planning state without leaving pure code
- `26-haskell-quickcheck/`: how to test invariants across many generated inputs
- `27-haskell-aeson-roundtrip/`: how to keep domain values and JSON formats aligned
- `28-haskell-applicative-validation/`: how to report several field errors without stopping at the first one
- `29-haskell-foldmap-summary/`: how to express batch aggregation through monoidal summary fragments
- `30-haskell-traverse-resolution/`: how to sequence per-request resolution across a whole batch
- `31-haskell-writer-audit/`: how to compute a result while accumulating ordered audit output
- `32-haskell-nonempty-waves/`: how to encode “at least one rollout step” in the type
- `33-haskell-optparse-cli/`: how to parse a real CLI into typed commands
- `34-haskell-dependency-order/`: how to derive a correct deployment order from dependencies
- `35-haskell-monad-chaining/`: how to express fail-fast workflows where each step depends on earlier results
- `36-haskell-map-set-modeling/`: how to use `Map` and `Set` as primary domain structures, not just helpers
- `37-haskell-transformer-stack/`: how to combine several effects in one concrete workflow
- `38-haskell-generic-json/`: how to reduce JSON boilerplate without giving up a deliberate shape

---

## 3. Related Notes

- `notes/007-haskell.md`
- `notes/008-haskell-shellfor.md`
- `notes/009-haskell-dependencies.md`
- `notes/010-haskell-adts.md`
- `notes/011-haskell-newtypes.md`
- `notes/012-haskell-effects.md`
- `notes/013-haskell-typeclasses.md`
- `notes/015-haskell-parser-combinators.md`
- `notes/026-haskell-maybe-and-either.md`
- `notes/027-haskell-deriving.md`
- `notes/028-haskell-state.md`
- `notes/029-haskell-quickcheck.md`
- `notes/030-haskell-aeson-roundtrip.md`
- `notes/031-haskell-applicative-validation.md`
- `notes/032-haskell-foldmap-summary.md`
- `notes/033-haskell-traverse-resolution.md`
- `notes/034-haskell-writer-audit.md`
- `notes/035-haskell-nonempty-waves.md`
- `notes/036-haskell-optparse-cli.md`
- `notes/037-haskell-dependency-order.md`
- `notes/038-haskell-monad-chaining.md`
- `notes/039-haskell-map-set-modeling.md`
- `notes/040-haskell-transformer-stack.md`
- `notes/041-haskell-generic-json.md`