quaalude

$(grid 6) is Template Haskell: it reads day 6's input when the program is compiled and splices it in as a Grid Char, so the solution itself contains no file handling. Ѓ ℤ (?) is a type family that means Maybe ℤ. walk returns Nothing when the guard revisits a position facing the same way, which is how part 2 detects a loop.

Part 2 tries an obstacle at each position on the original path (only those can change the route) and counts the walks that loop: as @ℤ . isNothing turns "looped" into 1 or 0. The fold starts at −1 for a subtle reason: an obstacle placed on the guard's starting cell overwrites the ^ that marks it, so gridFindOne '^' finds nothing, walk returns Nothing, and that case would be counted as a loop.

This solution in the Advent of Code viewer.

quaalude is not on Hackage. The Advent of Code years that use it carry it as a Git submodule and list it in cabal.project; Cabal's mixins then hide base's Prelude and rename Quaalude to Prelude, so every module in the package gets it without an import.

# cabal.project
packages:
  ./x2024.cabal
  ./lib/quaalude

# package.yaml
dependencies:
  - name: base
    mixin:
      - hiding (Prelude)
  - name: quaalude
    mixin:
      - hiding (Quaalude)
      - (Quaalude as Prelude)

The library turns on 55 language extensions by default (OverloadedStrings, UnicodeSyntax, DataKinds, TypeFamilies …); a project using it copies the same list. It needs GHC 9.8 or newer.

Most of the notation is aliases for things Haskell already has, chosen so that types and expressions read like mathematics. They are real type synonyms and functions, so GHCi expands them:

λ :kind! ℤ
ℤ :: *
= Integer
λ :kind! ℤ₆₄
ℤ₆₄ :: *
= Int
λ :kind! ℤ²
ℤ² :: *
= (Integer, Integer)
λ :kind! Ѓ ℤ (?)
Ѓ ℤ (?) :: *
= Maybe Integer

Grids are everywhere in Advent of Code, so Griddable is the largest class in the library. It is parameterised by a monad, which lets the same operations run over immutable storage and over mutable arrays in ST or IO when a simulation needs speed: Map, IntMap, HashMap, nested Vectors, immutable arrays, and mutable IOArray, STArray, STUArray, STVector and IOVector grids. Coordinates are (x, y) pairs; gridFindOne returns the first match in that order, column before row.

Cells can be any type with a GridCell instance: Char, DotHash, digits, or Cell "…", a cell type restricted at the type level to the characters in its string.

λ let g = readGrid "..#\n#..\n" :: Grid Char
λ g ||? (2, 0)
Just '#'
λ gridFindOne '#' g
Just (0,1)
λ maxXY g
(2,1)
λ turnCW DirUp
→
λ move DirUp (2 :: Int) (5, 5 :: Int)
(5,3)
λ manhattan (1, 2) (4, 6 :: Int)
7

Most puzzle input is numbers in some text, so numbers is a parser that finds them and |- runs a parser on a string and returns its result. Parsec is re-exported for anything harder, and Quaalude.Megaparsec adds a few helpers for Megaparsec. The rest of this block is the small change of everyday code: applying a two-argument function to a pair, duplicating a value, converting with as, sorting, and a conditional that reads left to right.

For search, Quaalude.LossQ provides priority queues ordered by a loss function, for Dijkstra and A*-style searches; monad-memo is re-exported for memoised recursion; and Quaalude.Solve wraps the Z3 solver, so a puzzle that is really a system of constraints can be handed to Z3 and the answer read back by type.

λ "move 10 to -3, then 42" |- numbers :: [ℤ]
[10,-3,42]
λ both (+ 1) (1, 2)
(2,3)
λ (+) $@ (2, 3)
5
λ dup 'x'
('x','x')
λ (<>!) ["ab", "cd"]
"abcd"
λ as @ℤ True
1
λ (🎜) [3, 1, 2]
[1,2,3]
λ (🎝) [3, 1, 2]
[3,2,1]
λ (2 > 1) ??? "yes" $ "no"
"yes"