'cleaned' it up

2025/6/gleam/gleam.toml

···
 [dependencies]
 gleam_stdlib = ">= 0.44.0 and < 2.0.0"
 simplifile = ">= 2.3.0 and < 3.0.0"
-gleam_regexp = ">= 1.1.1 and < 2.0.0"
 
 [dev-dependencies]
 gleeunit = ">= 1.0.0 and < 2.0.0"

2025/6/gleam/manifest.toml

···
 
 packages = [
   { name = "filepath", version = "1.1.2", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "filepath", source = "hex", outer_checksum = "B06A9AF0BF10E51401D64B98E4B627F1D2E48C154967DA7AF4D0914780A6D40A" },
-  { name = "gleam_regexp", version = "1.1.1", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_regexp", source = "hex", outer_checksum = "9C215C6CA84A5B35BB934A9B61A9A306EC743153BE2B0425A0D032E477B062A9" },
   { name = "gleam_stdlib", version = "0.65.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "7C69C71D8C493AE11A5184828A77110EB05A7786EBF8B25B36A72F879C3EE107" },
   { name = "gleeunit", version = "1.7.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleeunit", source = "hex", outer_checksum = "CD701726CBCE5588B375D157B4391CFD0F2F134CD12D9B6998A395484DE05C58" },
   { name = "simplifile", version = "2.3.0", build_tools = ["gleam"], requirements = ["filepath", "gleam_stdlib"], otp_app = "simplifile", source = "hex", outer_checksum = "0A868DAC6063D9E983477981839810DC2E553285AB4588B87E3E9C96A7FB4CB4" },
 ]
 
 [requirements]
-gleam_regexp = { version = ">= 1.1.1 and < 2.0.0" }
 gleam_stdlib = { version = ">= 0.44.0 and < 2.0.0" }
 gleeunit = { version = ">= 1.0.0 and < 2.0.0" }
 simplifile = { version = ">= 2.3.0 and < 3.0.0" }

2025/6/gleam/src/main.gleam

···
 import gleam/int
 import gleam/io
 import gleam/list
-import gleam/regexp
 import gleam/result
 import gleam/string
 import simplifile as file
···
       acc |> string.replace("  ", " ")
     })
 
-  let part_1 =
-    input_pt_1
-    |> string.split("\n")
-    |> list.map(fn(i) { string.trim(i) |> string.split(" ") })
-    |> list.transpose
-    |> list.map(fn(i) {
-      let i = list.reverse(i)
-      let assert Ok(s) = list.first(i)
-      let i =
-        list.drop(i, 1) |> list.map(fn(i) { int.parse(i) |> result.unwrap(0) })
-      let r = case s {
-        "+" -> int.sum(i)
-        "*" -> list.reduce(i, int.multiply) |> result.unwrap(0)
-        _ -> panic as "invalid"
-      }
-      r
-    })
-    |> int.sum
-  echo part_1
+  input_pt_1
+  |> string.split("\n")
+  |> list.map(fn(i) { string.trim(i) |> string.split(" ") })
+  |> list.transpose
+  |> list.map(fn(i) {
+    let i = list.reverse(i)
+    let assert Ok(s) = list.first(i)
+    let i =
+      list.drop(i, 1) |> list.map(fn(i) { int.parse(i) |> result.unwrap(0) })
+    let r = case s {
+      "+" -> int.sum(i)
+      "*" -> list.reduce(i, int.multiply) |> result.unwrap(0)
+      _ -> panic as "invalid"
+    }
+    r
+  })
+  |> int.sum
+  |> int.to_string
+  |> io.println
 
   let lines =
     input
···
         _ -> acc
       }
     })
-  let input_pt_2 =
-    bounds
-    |> list.index_fold(dict.new(), fn(d, bound, i) {
-      let numbers =
-        list.map(lines, fn(line) {
-          string.slice(line, bound.0, bound.1 - bound.0)
-        })
-      let align =
-        numbers
-        |> list.drop(1)
-        |> list.fold_until(Left, fn(res, number) {
-          case
-            string.trim(number) == number,
-            string.trim_start(number) == number
-          {
-            True, _ -> list.Continue(res)
-            _, True -> list.Stop(Left)
-            _, _ -> list.Stop(Right)
+  bounds
+  |> list.index_fold(dict.new(), fn(d, bound, i) {
+    let numbers =
+      list.map(lines, fn(line) {
+        string.slice(line, bound.0, bound.1 - bound.0)
+      })
+    let align =
+      numbers
+      |> list.drop(1)
+      |> list.fold_until(Left, fn(res, number) {
+        case
+          string.trim(number) == number,
+          string.trim_start(number) == number
+        {
+          True, _ -> list.Continue(res)
+          _, True -> list.Stop(Left)
+          _, _ -> list.Stop(Right)
+        }
+      })
+    let assert Ok(sign) = list.first(numbers)
+    let sign = case string.trim(sign) {
+      "*" -> Mul
+      "+" -> Sum
+      _ -> panic as sign
+    }
+    dict.insert(
+      d,
+      i,
+      Part2Line(
+        align,
+        sign,
+        numbers |> list.drop(1) |> list.map(string.trim) |> list.reverse,
+      ),
+    )
+  })
+  |> dict.to_list
+  |> list.map(fn(i) { i.1 })
+  |> list.map(fn(line) {
+    let d: Part2Dict = dict.new()
+    let d =
+      line.numbers
+      |> list.fold(d, fn(d, number) {
+        let number_len = string.length(number)
+        string.to_graphemes(number)
+        |> list.index_fold(d, fn(d, digit, index) {
+          let assert Ok(digit) = digit |> int.parse
+          let pos = case line.align {
+            Right -> number_len - index
+            Left -> index
           }
-        })
-      let assert Ok(sign) = list.first(numbers)
-      let sign = case string.trim(sign) {
-        "*" -> Mul
-        "+" -> Sum
-        _ -> panic as sign
-      }
-      dict.insert(
-        d,
-        i,
-        Part2Line(
-          align,
-          sign,
-          numbers |> list.drop(1) |> list.map(string.trim) |> list.reverse,
-        ),
-      )
-    })
-  let part_2 =
-    input_pt_2
-    |> dict.to_list
-    |> list.map(fn(i) { i.1 })
-    |> list.map(fn(line) {
-      let d: Part2Dict = dict.new()
-      let d =
-        line.numbers
-        |> list.fold(d, fn(d, number) {
-          let number_len = string.length(number)
-          string.to_graphemes(number)
-          |> list.index_fold(d, fn(d, digit, index) {
-            let assert Ok(digit) = digit |> int.parse
-            let pos = case line.align {
-              Right -> number_len - index
-              Left -> index
-            }
-            dict.insert(
-              d,
-              pos,
-              { dict.get(d, pos) |> result.unwrap(0) } * 10 + digit,
-            )
-          })
+          dict.insert(
+            d,
+            pos,
+            { dict.get(d, pos) |> result.unwrap(0) } * 10 + digit,
+          )
         })
-      echo #(d, line)
-      let numbers =
-        dict.to_list(d)
-        |> list.map(fn(n) { n.1 })
+      })
+    let numbers =
+      dict.to_list(d)
+      |> list.map(fn(n) { n.1 })
 
-      let r = case line.op {
-        Sum -> int.sum(numbers)
-        Mul -> list.reduce(numbers, int.multiply) |> result.unwrap(0)
-      }
-      r
-    })
-    |> int.sum
-  echo part_2
+    let r = case line.op {
+      Sum -> int.sum(numbers)
+      Mul -> list.reduce(numbers, int.multiply) |> result.unwrap(0)
+    }
+    r
+  })
+  |> int.sum
+  |> int.to_string
+  |> io.println
 }