destructuring lets and arrows

aoc2023/Day1.newt

@@ -6,11 +6,9 @@ import Node
 digits1 : List Char -> List Int
 digits1 Nil = Nil
 digits1 (c :: cs) = let x = ord c in
-  case x < 58 of
-    True => case 48 < x of
-      True => x - 48 :: digits1 cs
-      False => digits1 cs
-    False => digits1 cs
+  if 48 < x && x < 58
+    then x - 48 :: digits1 cs
+    else digits1 cs
 
 tail : {a : U} -> List a -> List a
 tail Nil = Nil

aoc2023/Day2.newt

@@ -43,43 +43,38 @@ parseDraw line =
 
 parseGame : String -> Either String Game
 parseGame line =
-  -- Need the Idris | sugar...
-  case split line ": " of
-    -- this is splitting on the Nil instead of the a
-    (a :: b :: Nil) => case split a " " of
-      ("Game" :: ns :: Nil) =>
-        let num = toInt ns in
-        case mapM {Either String} parseDraw $ split b "; " of
-          Right parts => Right $ MkGame num parts
-          Left err => Left err
-      _ => Left "No Game"
-    _ => Left $ "No colon in " ++ line
+  let (a :: b :: Nil) = split line ": "
+    | _ => Left $ "No colon in " ++ line in
+  let ("Game" :: ns :: Nil) = split a " "
+    | _ => Left $ "No Game" in
+  let (Right parts) = mapM {Either String} parseDraw $ split b "; "
+    | Left err => Left err in
+  Right $ MkGame (toInt ns) parts
 
 part1 : List Game -> Int
 part1 Nil = 0
 part1 (MkGame n parts :: rest) =
   let total = foldl maxd (0,0,0) parts in
-  case lte total (12,13,14) of
-    True => n + part1 rest
-    False => part1 rest
+  if lte total (12,13,14)
+    then n + part1 rest
+    else part1 rest
 
 part2 : List Game -> Int
 part2 Nil = 0
 part2 (MkGame n parts :: rest) =
-  case foldl maxd (0,0,0) parts of
-    (a,b,c) => a * b * c + part2 rest
+  let (a,b,c) = foldl maxd (0,0,0) parts
+   in a * b * c + part2 rest
 
 run : String -> IO Unit
 run fn = do
   putStrLn fn
   text <- readFile fn
-  case mapM {Either String} parseGame (split (trim text) "\n") of
-    Left err => putStrLn $ "fail " ++ err
-    Right games => do
-      putStrLn "part1"
-      printLn (part1 games)
-      putStrLn "part2"
-      printLn (part2 games)
+  let (Right games) = mapM {Either String} parseGame (split (trim text) "\n")
+    | Left err => putStrLn $ "fail " ++ err
+  putStrLn "part1"
+  printLn (part1 games)
+  putStrLn "part2"
+  printLn (part2 games)
 
 main : IO Unit
 main = do

aoc2023/Day4.newt

@@ -8,11 +8,9 @@ Round = List Int × List Int
 
 parseRound : String → Maybe Round
 parseRound s =
-  case split s ": " of
-    (a :: b :: Nil) => case split b " | " of
-      (l :: r :: Nil) => Just (nums l, nums r)
-      _ => Nothing
-    _ => Nothing
+  let (a :: b :: Nil) = split s ": "   | _ => Nothing in
+  let (l :: r :: Nil) = split b " | "  | _ => Nothing in
+  Just (nums l, nums r)
   where
     -- Nat or Int here?
     nums : String → List Int
@@ -50,14 +48,12 @@ run : String -> IO Unit
 run fn = do
   putStrLn fn
   text <- readFile fn
-
-  case parse text of
-    Nothing => putStrLn "fail"
-    Just cards => do
-      putStrLn "part1"
-      printLn (part1 cards)
-      putStrLn "part2"
-      printLn (part2 cards)
+  let (Just cards) = parse text
+    | _ => putStrLn "fail"
+  putStrLn "part1"
+  printLn (part1 cards)
+  putStrLn "part2"
+  printLn (part2 cards)
 
 -- 13/30
 -- 25004/14427616

aoc2023/Day5.newt

@@ -33,14 +33,14 @@ parseFile : String → Either String Problem
 parseFile content = do
   let parts = split (trim content) "\n\n"
   -- TODO deconstructing let
-  case parts of
-    (first :: rest) => case split first ": " of
-      (_ :: x :: Nil) => do
-        let seeds = nums x
-        maps <- mapA (λ part => parseMap (split part "\n")) rest
-        Right $ MkProb seeds maps
-      _ => Left $ "expected ': ' in " ++ first
-    _ => Left $ "expected some parts"
+  let (first :: rest) = parts
+    | _ => Left "expected some parts"
+  let (_ :: x :: Nil) = split first ": "
+    | _ => Left $ "expected ': ' in " ++ first
+
+  let seeds = nums x
+  maps <- mapA (λ part => parseMap (split part "\n")) rest
+  Right $ MkProb seeds maps
 
 applyEntry : Int → MapEntry → Int
 applyEntry n (MkEntry dest src len) =
@@ -96,26 +96,23 @@ mkRanges Nil = Just Nil
 mkRanges _ = Nothing
 
 part2 : Problem → IO Unit
-part2 (MkProb seeds maps) =
-  case mkRanges seeds of
-    Nothing => printLn "odd seeds!"
-    Just ranges => do
-      let results = foldl apply ranges maps
-      -- putStrLn $ debugStr results
-      let answer = foldl min 99999999 $ map fst results
-      putStrLn $ "part2 " ++ show answer
+part2 (MkProb seeds maps) = do
+  let (Just ranges) = mkRanges seeds
+    | Nothing => printLn "odd seeds!"
+  let results = foldl apply ranges maps
+  -- putStrLn $ debugStr results
+  let answer = foldl min 99999999 $ map fst results
+  putStrLn $ "part2 " ++ show answer
 
 run : String -> IO Unit
 run fn = do
   putStrLn fn
   text <- readFile fn
-  case parseFile text of
-    Left err => putStrLn err
-    Right prob => do
-      putStrLn $ debugStr prob
-      part1 prob
-      -- putStrLn "part2"
-      part2 prob
+  let (Right prob) = parseFile text
+    | Left err => putStrLn err
+  putStrLn $ debugStr prob
+  part1 prob
+  part2 prob
 
 -- 35 / 46
 -- 282277027 / 11554135