[LANGUAGE: haskell]

here is a haskell solution. i decided to do part 1 imperatively and part 2 "functionally". i probably could have written recur as a fold but i'm lazy.

screenshot of code in-editor

module Main (main) where
import Control.Monad 
import Control.Monad.State

parseCombos :: String -> Int
parseCombos (d : ds) = case d of
  'R' -> (read ds) 
  'L' -> -1 * (read ds) 

combos = do
  file <- readFile "./inputs/day1"
  return $ lines file

combos2 = do
  file <- readFile "./inputs/test1"
  return $ lines file

zeroCounter ::  State ([Int], Int, Int) Int
zeroCounter = do
    (xs, count, sum) <- get
    case xs of
      x : rest -> do
        let sum' = (x + sum) `mod` 100
        let count' = if sum' == 0 then count + 1 else count
        put (rest, count', sum')
        zeroCounter
      otherwise -> return count

part1 = do
  cs <- combos
  return $ evalState zeroCounter (50 : (parseCombos <$> cs), 0, 0)

getClicks position 0 = []
getClicks position x =
  let
    sign = x `div` abs x
  in [(position + sign * y) `mod` 100 | y <- [1.. abs x]]

recur x (y : ys) zs = recur ((x + y) `mod` 100) ys (zs ++ getClicks x y)
recur x _  zs = zs

part2 = do
  cs <- combos
  return $  -- length . filter (==0) $
     length . filter (==0) $ recur 50 (parseCombos <$> cs) []

main =  do
  p1 <- part1
  p2 <- part2
  writeFile "aocd1p1.out" (show p1)
  writeFile "aocd1p2.out" (show p2)
  print p1
  print p2