updated for new exhaustiveness checks in 0.33

6 files changed, 31 insertions, 32 deletions

diff --git a/aoc2023/src/aoc2023.gleam b/aoc2023/src/aoc2023.gleam
index 30335ee..aab904d 100644
--- a/aoc2023/src/aoc2023.gleam
+++ b/aoc2023/src/aoc2023.gleam
@@ -6,6 +6,7 @@ abcdefgh"
 
 pub fn main() {
   let trim = 8
-  let <<_:bytes-size(trim), "\n":utf8, rest:bytes>> = bit_array.from_string(str)
+  let assert <<_:bytes-size(trim), "\n":utf8, rest:bytes>> =
+    bit_array.from_string(str)
   io.debug(rest)
 }
diff --git a/aoc2023/src/day2/solve.gleam b/aoc2023/src/day2/solve.gleam
index 916704c..22470ab 100644
--- a/aoc2023/src/day2/solve.gleam
+++ b/aoc2023/src/day2/solve.gleam
@@ -10,18 +10,19 @@ pub type Game {
 
 fn parse(input: String) -> List(List(Game)) {
   use line <- list.map(string.split(input, "\n"))
-  let [_, rounds] = string.split(line, on: ": ")
+  let assert [_, rounds] = string.split(line, on: ": ")
   use match <- list.map(string.split(rounds, on: "; "))
   use acc, draw <- list.fold(
     over: string.split(match, on: ", "),
     from: Game(0, 0, 0),
   )
-  let [n_str, color] = string.split(draw, " ")
+  let assert Ok(#(n_str, color)) = string.split_once(draw, " ")
   let assert Ok(n) = int.parse(n_str)
   case color {
     "red" -> Game(..acc, red: n)
     "blue" -> Game(..acc, blue: n)
     "green" -> Game(..acc, green: n)
+    _ -> panic as { "unrecognized color " <> color }
   }
 }
 
@@ -44,10 +45,9 @@ pub fn part2(input: String) {
       green: int.max(green, acc.green),
     )
   }
-  |> list.fold(
-    from: 0,
-    with: fn(acc, g: Game) { acc + g.red * g.blue * g.green },
-  )
+  |> list.fold(from: 0, with: fn(acc, g: Game) {
+    acc + g.red * g.blue * g.green
+  })
 }
 
 pub fn main() {
diff --git a/aoc2023/src/day3/solve.gleam b/aoc2023/src/day3/solve.gleam
index fa16bb8..ad975aa 100644
--- a/aoc2023/src/day3/solve.gleam
+++ b/aoc2023/src/day3/solve.gleam
@@ -87,8 +87,10 @@ fn do_parts(cells: List(Cell), parts: List(Part)) -> List(Part) {
               do_parts(t, [Part([next, ..coords], n0 * 10 + n), ..rest_parts])
             _, _ -> do_parts(t, [Part([next], n), ..parts])
           }
+        _ -> panic
       }
     }
+    _ -> panic
   }
 }
 
diff --git a/aoc2023/src/day5/solve.gleam b/aoc2023/src/day5/solve.gleam
index 9885710..7c05310 100644
--- a/aoc2023/src/day5/solve.gleam
+++ b/aoc2023/src/day5/solve.gleam
@@ -26,7 +26,8 @@ type Mapper =
 // Parsing -----------------------------------------------------------------------------------------
 
 fn parse_input(input: String) {
-  let ["seeds: " <> raw_seeds, ..raw_mappers] = string.split(input, on: "\n\n")
+  let assert ["seeds: " <> raw_seeds, ..raw_mappers] =
+    string.split(input, on: "\n\n")
 
   let seeds = string_to_int_list(raw_seeds)
   let mappers =
@@ -45,7 +46,7 @@ fn string_to_int_list(str: String) {
 }
 
 fn parse_mapper(strs: List(String)) -> Mapper {
-  let [_, ..raw_ranges] = strs
+  let assert [_, ..raw_ranges] = strs
   list.map(raw_ranges, parse_mrange)
   |> list.sort(fn(a, b) { int.compare(a.start, b.start) })
 }
@@ -79,11 +80,11 @@ fn correspond(n: Int, mapper: Mapper) {
 pub fn part2(input: String) {
   let Almanac(seeds, mappers) = parse_input(input)
 
-  let [SRange(answer, _), ..] =
+  let assert [SRange(answer, _), ..] =
     seeds
     |> list.sized_chunk(into: 2)
     |> list.map(fn(chunk) {
-      let [start, length] = chunk
+      let assert [start, length] = chunk
       [SRange(start, start + length - 1)]
       |> remap_all_seed_ranges(mappers)
     })
@@ -131,22 +132,17 @@ fn do_remap_range(r: SeedRange, mapper: Mapper, acc: List(SeedRange)) {
     ]
     // range overlaps end but not start -> left side transformed, right side moves to next mapping
     [m, ..ms] if r.start >= m.start && r.end > m.end ->
-      do_remap_range(
-        SRange(m.end + 1, r.end),
-        ms,
-        [transform_range(SRange(r.start, m.end), m), ..acc],
-      )
+      do_remap_range(SRange(m.end + 1, r.end), ms, [
+        transform_range(SRange(r.start, m.end), m),
+        ..acc
+      ])
     // mapping is fully inside range -> left not transformed, middle transformed, right to next
     [m, ..ms] ->
-      do_remap_range(
-        SRange(m.end + 1, r.end),
-        ms,
-        [
-          SRange(r.start, m.start - 1),
-          transform_range(SRange(m.start, m.end), m),
-          ..acc
-        ],
-      )
+      do_remap_range(SRange(m.end + 1, r.end), ms, [
+        SRange(r.start, m.start - 1),
+        transform_range(SRange(m.start, m.end), m),
+        ..acc
+      ])
   }
 }
 
diff --git a/aoc2023/src/day6/solve.gleam b/aoc2023/src/day6/solve.gleam
index 98f39a1..88044c4 100644
--- a/aoc2023/src/day6/solve.gleam
+++ b/aoc2023/src/day6/solve.gleam
@@ -20,7 +20,7 @@ fn parse_with_bad_kerning(input: String) {
   })
   |> list.transpose
   |> list.map(fn(ns) {
-    let [t, d] = ns
+    let assert [t, d] = ns
     Race(t, d)
   })
 }
@@ -59,12 +59,12 @@ fn parse_properly(input: String) {
 }
 
 pub fn part2(input: String) {
-  let [time, distance] =
+  let assert [time, distance] =
     input
     |> parse_properly
 
   let race = Race(time, distance)
-  
+
   upper_bound(race) - lower_bound(race) + 1
   |> string.inspect
 }
diff --git a/aoc2023/src/day7/solve.gleam b/aoc2023/src/day7/solve.gleam
index 08740f6..4454883 100644
--- a/aoc2023/src/day7/solve.gleam
+++ b/aoc2023/src/day7/solve.gleam
@@ -16,7 +16,7 @@ type Hand {
 // Common functions --------------------------------------------------------------------------------
 
 fn parse_hand(str: String) -> Hand {
-  let [cards, wager] = string.split(str, " ")
+  let assert [cards, wager] = string.split(str, " ")
   let cards =
     string.to_graphemes(cards)
     |> list.map(card_rank)
@@ -54,7 +54,7 @@ fn card_rank(card: String) -> Int {
     _, "Q" -> 12
     _, "J" -> 11
     _, "T" -> 10
-    _, "*" -> 1
+    _, _ -> 1
   }
 }
 
@@ -67,8 +67,8 @@ fn compare_hands(hand1: Hand, hand2: Hand, using: fn(Hand) -> Int) -> Order {
 
 fn compare_top_card(cards1: List(Int), cards2: List(Int)) -> Order {
   use <- bool.guard(cards1 == [] || cards2 == [], Eq)
-  let [c1, ..rest1] = cards1
-  let [c2, ..rest2] = cards2
+  let assert [c1, ..rest1] = cards1
+  let assert [c2, ..rest2] = cards2
   case int.compare(c1, c2) {
     Eq -> compare_top_card(rest1, rest2)
     other -> other