Crossbow

Crossbow was written to solve Advent of Code, and test/aoc.cb solves the first days of 2021. Day 1 is the pipeline in the figure above, applied to the puzzle input: aoc 2021 1 reads the day's input, ints parses one number per line, and each part is one line.

Day 2 shows the other tools: <- binds a name, case picks a branch by the command's first letter, ! maps a function over a list, and fold threads a three-part state through the commands. Day 3 defines its own higher-order helpers, favouring and step, as lambdas.

Running this file prints 8 answers in 3.5 seconds (the answers depend on personal puzzle inputs, so they are not shown).

Only the primitives are written in Haskell: arithmetic, foldl, map, filter, zip, fork, if and so on. Everything else is defined in lib.cb, loaded before your first line, in Crossbow itself. {…} is a lambda whose arguments are $0, $1, …, and a lambda that never mentions an argument is fed the pipeline's value as $0.

enum shows the intended style: fork the list into two copies, turn one into its indices, and zip them, with no names for intermediate values. pairs zips a list with itself shifted by one; windows takes the tails, transposes them and trims the ragged end.

# Basic
id <- {null|$0}
const <- {$1|null|$0}

# Parsing and IO
aoc <- {(((("test/aoc_input/" ++ (string $0)) ++ "/") ++ (string $1)) ++ ".txt") | read}
ints <- {lines|int}

# Bools and Predicates
not <- {if | $0 | False | True}
odd <- {mod $0 2|bool}
even <- {odd $0|not}
lengthy <- {$1|length|(== $0)}

# Numerical
min <- {if | ($0 < $1) | $0 | $1}
max <- {if | ($0 > $1) | $0 | $1}

# List Operations
fold <- foldl
scan <- scanl
head <- ix 0
tail <- drop 1
foldl1 <- {foldl | $0 | head $1 | tail $1}
scanl1 <- {scanl | $0 | head $1 | tail $1}
reverse <- {foldl | flip cons | [] | $0}
length <- {map (const 1) | sum}
sum <- {foldl|+|0|$0}
minOn <- {map $0 [$1, $2]|monadic <= |if|$1|$2}
maxOn <- {map $0 [$1, $2]|monadic > |if|$1|$2}
maximum <- foldl1 max
minimum <- foldl1 min
maximumOn <- {$1 | foldl1 (maxOn $0)}
minimumOn <- {$1 | foldl1 (minOn $0)}
count <- {filter $0 $1 | length}
mode <- {counts|maximumOn snd|fst}
antimode <- {counts|minimumOn snd|fst}
pairs <- {$0|fork 2|[id, drop 1]|monadic zip}
square <- {$0 | fork (length $0)}
enum <- {$0|fork 2|[length,id]|[range 0, id]|monadic zip}
windows <- {$1|tails|take $0|transpose|take ((1 + length $1) - $0)}

# Accessor / Setter Aliases
first <- nap 0
second <- nap 1
third <- nap 2
fst <- ix 0
snd <- ix 1
thd <- ix 2