refactor(2020.18-haskell): adopt advent-of-code-api

Author: yurrriq

VERSION

@@ -1 +1 @@
-2024.7.2.83
+2024.7.2.84

src/AdventOfCode/Year2020/Day18.hs

@@ -1,39 +1,41 @@
+{-# LANGUAGE NoImplicitPrelude #-}
+
 module AdventOfCode.Year2020.Day18
   ( main,
     partOne,
     partTwo,
   )
 where
 
-import AdventOfCode.Input (parseInput)
-import AdventOfCode.TH (inputFilePath)
-import Control.Applicative ((<|>))
-import Control.Monad.Combinators.Expr
-import Text.Trifecta (Parser, natural, parens, some, symbol)
+import AdventOfCode.Input (parseString, rawInputAoC)
+import AdventOfCode.Puzzle
+import AdventOfCode.TH (defaultMainPuzzle)
+import Control.Monad.Combinators.Expr (Operator (InfixL), makeExprParser)
+import Relude
+import Text.Trifecta (Parser, natural, parens, symbol)
 
 main :: IO ()
-main =
-  do
-    putStr "Part One: "
-    print =<< partOne
-    putStr "Part Two: "
-    print =<< partTwo
-
-partOne :: IO Int
-partOne = sum <$> parseInput (some expr) $(inputFilePath)
-  where
-    expr = makeExprParser (parens expr <|> posInt) [[addition, multiplication]]
+main = $(defaultMainPuzzle)
+
+partOne :: SimplePuzzle String Integer
+partOne = solve [[multiplication, addition]]
+
+partTwo :: SimplePuzzle String Integer
+partTwo = solve [[addition], [multiplication]]
+
+getInput :: IO String
+getInput = rawInputAoC 2020 18
 
-partTwo :: IO Int
-partTwo = sum <$> parseInput (some expr) $(inputFilePath)
+solve :: [[Operator Parser Integer]] -> SimplePuzzle String Integer
+solve table = ask >>= parseString (some expr) <&> sum
   where
-    expr = makeExprParser (parens expr <|> posInt) [[addition], [multiplication]]
+    expr = makeExprParser (parens expr <|> natural) table
 
-addition :: Operator Parser Int
-addition = InfixL ((+) <$ symbol "+")
+addition :: (Num a) => Operator Parser a
+addition = binary "+" (+)
 
-multiplication :: Operator Parser Int
-multiplication = InfixL ((*) <$ symbol "*")
+multiplication :: (Num a) => Operator Parser a
+multiplication = binary "*" (*)
 
-posInt :: Parser Int
-posInt = fromInteger <$> natural
+binary :: String -> (a -> a -> a) -> Operator Parser a
+binary name f = InfixL (f <$ symbol name)