Advent of Code 2021 - Haskell

Syntax error in navigation subsystem on line: all of them

{-#  OPTIONS_GHC -Wall  #-}

module AoC2021Args (Args(..), aocArgParser) where

import Options.Applicative
import Data.Semigroup ((<>))

data Args = Args
    { day :: Int }

aocArgParser :: Parser Args
aocArgParser = Args
    <$> option auto
        ( long "day"
       <> help "The day to run code for. Use '0' to run all of the solutions."
       <> showDefault
       <> value 0
       <> metavar "DAY") --  The metavariable is displayed in the help text.

module Main (main) where

import AoC2021InputParser
  (
    parseBinaryDiagnosticInput,
    parseBingoInput,
    parseHydrothermalVents,
    parseLanternfishInternalTimers,
    parseHorizontalCrabPositions,
    parseSevenSegmentsDisplay,
    parseHeightMap
  )
import BinaryDiagnostic.BinaryDiagnostic (lifeSupportRating, powerConsumption)
import Data.String (IsString (fromString))
import Dive.Dive (productOfFinalPosition, productOfFinalPositionWithNewIntepretation)
import GiantSquid (scoreOfFirstWinningBoard, scoreOfLastWinningBoard)
import HydrothermalVenture.HydrothermalVenture
  ( pointsWithAtLeastTwoRightSegmentOverlaps,
    pointsWithAtLeastTwoSegmentOverlaps,
  )
import qualified AoC2021.Lanternfish (numOfFishIn80Days, numOfFishIn256Days)
import qualified AoC2021.TreacheryOfWhales as TreacheryOfWhales
  (
    minFuelForAlignmentWithConstantBurnRate,
    minFuelForAlignmentWithIncreasingBurnRate
  )
import qualified AoC2021.SevenSegmentSearch as SevenSegmentSearch
  (numOf1478AppearancesInOutput, sumOfOutputValues)
import qualified AoC2021.SmokeBasin as SmokeBasin
  ( sumOfRiskLevelsOfLowPoints,
    productOf3LargestBasins
  )
import Paths_advent_of_code_y2021 (getDataFileName)
import SonarSweep ( num3MeasurementIncreases, numIncreases )
import System.IO (IOMode (ReadMode), hGetContents, withFile)
import Test.HUnit (Counts(..), Test (TestCase, TestLabel, TestList), assertEqual, runTestTT)
import AoC2021Args (Args(..), aocArgParser)
import Options.Applicative

testSonarSweep :: Test
testSonarSweep =
  TestCase
    ( do
        fp <- getDataFileName "src/scratchpad/01-sonar-sweep.sample.txt"
        withFile
          fp
          ReadMode
          ( \h -> do
              s <- hGetContents h
              let ls = lines (fromString s)
              assertEqual "numIncreases," 7 (SonarSweep.numIncreases ls)
              assertEqual "numIncreases," 5 (SonarSweep.num3MeasurementIncreases ls)
          )
    )

test01 :: Test
test01 = TestLabel "Day 01: Sonar Sweep" testSonarSweep

testDive :: Test
testDive =
  TestCase
    ( do
        fp <- getDataFileName "src/Dive/scratchpad/sample.txt"
        withFile
          fp
          ReadMode
          ( \h -> do
              s <- hGetContents h
              let ls = lines (fromString s)
              assertEqual "Stale Interpretation," 150 (productOfFinalPosition ls)
              assertEqual
                "Correct Interpretation,"
                900
                (productOfFinalPositionWithNewIntepretation ls)
          )
    )

test02 :: Test
test02 = TestLabel "Day 02: Dive!" testDive

testBinaryDiagnostic :: Test
testBinaryDiagnostic =
  TestCase
    ( do
        input <- parseBinaryDiagnosticInput "src/BinaryDiagnostic/scratchpad/sample.txt"
        assertEqual "Power Consumption," 198 (powerConsumption input)
        assertEqual "Life Support Rating," 230 (lifeSupportRating input)
    )

test03 :: Test
test03 = TestLabel "Day 03: Binary Diagnostic" testBinaryDiagnostic

testGiantSquid :: Test
testGiantSquid =
  TestCase
    ( do
        input <- parseBingoInput "src/scratchpad/04-giant-squid.sample.txt"
        assertEqual
          "Score of First Winning Board,"
          4512
          (scoreOfFirstWinningBoard input)
        assertEqual
          "Score of Last Winning Board,"
          1924
          (scoreOfLastWinningBoard input)
    )

test04 :: Test
test04 = TestLabel "Day 04: Giant Squid" testGiantSquid

testHydrothermalVenture :: Test
testHydrothermalVenture =
  TestCase
    ( do
        input <- parseHydrothermalVents "src/HydrothermalVenture/scratchpad/sample.txt"
        assertEqual
          "Num Points w/ >= 2 Right Segments Overlapping,"
          5
          (pointsWithAtLeastTwoRightSegmentOverlaps input)
        assertEqual
          "Num Points w/ >= 2 Segments Overlapping,"
          12
          (pointsWithAtLeastTwoSegmentOverlaps input)
    )

test05 :: Test
test05 = TestLabel "Day 05: Hydrothermal Venture" testHydrothermalVenture

testLanternfish :: Test
testLanternfish =
  TestCase
    ( do
        input <- parseLanternfishInternalTimers "src/scratchpad/06-lanternfish.sample.txt"
        assertEqual
          "Num of lantern fish in 80 days,"
          5934
          (AoC2021.Lanternfish.numOfFishIn80Days input)
        assertEqual
          "Num of lantern fish in 256 days,"
          26984457539
          (AoC2021.Lanternfish.numOfFishIn256Days input)
    )

test06 :: Test
test06 = TestLabel "Day 06: Lanternfish" testLanternfish

testTreacheryOfWhales :: Test
testTreacheryOfWhales =
  TestCase
    ( do
        input <- parseHorizontalCrabPositions "src/scratchpad/07-treachery-of-whales.sample.txt"
        assertEqual
          "Min fuel needed to align horizontal positions "
          37
          (TreacheryOfWhales.minFuelForAlignmentWithConstantBurnRate input)
        assertEqual
          "Min fuel needed to align horizontal postions under increasing burn rate "
          168
          (TreacheryOfWhales.minFuelForAlignmentWithIncreasingBurnRate input)
    )

test07 :: Test
test07 = TestLabel "Day 07: The Treachery Of Whales" testTreacheryOfWhales

testSevenSegmentSearch :: Test
testSevenSegmentSearch =
  TestCase
  ( do
      input <- parseSevenSegmentsDisplay "src/scratchpad/08-seven-segment-search.sample.txt"
      assertEqual
        "Num times 1, 4, 7, or 8 appears in output values "
        26
        (SevenSegmentSearch.numOf1478AppearancesInOutput input)

      assertEqual
        "Sum of output values "
        61229
        (SevenSegmentSearch.sumOfOutputValues input)
  )

test08 :: Test
test08 = TestLabel "Day 08: Seven Segment Search" testSevenSegmentSearch

testSmokeBasin :: Test
testSmokeBasin =
  TestCase
  ( do
      input <- parseHeightMap "src/scratchpad/09-smoke-basin.sample.txt"
      assertEqual
        "Sum of the risk levels of all low points on heightmap "
        15
        (SmokeBasin.sumOfRiskLevelsOfLowPoints input)
      assertEqual
        "Product of the 3 largest basins "
        1134
        (SmokeBasin.productOf3LargestBasins input)
  )

test09 :: Test
test09 = TestLabel "Day 09: Smoke Basin" testSmokeBasin

tests :: Test
tests =
  TestList
    [ test01, test02, test03, test04, test05, test06, test07, test08, test09 ]

runTest :: Int -> IO Counts
runTest 0 = do runTestTT tests
runTest 1 = do runTestTT test01
runTest 2 = do runTestTT test02
runTest 3 = do runTestTT test03
runTest 4 = do runTestTT test04
runTest 5 = do runTestTT test05
runTest 6 = do runTestTT test06
runTest 7 = do runTestTT test07
runTest 8 = do runTestTT test08
runTest 9 = do runTestTT test09
runTest x = do
  putStrLn ("Day " ++ show x ++ " has no associated test.")
  return (Counts 0 0 0 0)

runAoCSolutions :: Args -> IO Counts
runAoCSolutions (Args d) = runTest d

main :: IO Counts
main = runAoCSolutions =<< execParser opts
  where
    opts = info (aocArgParser <**> helper)
      ( fullDesc
     <> progDesc "Run tests for a given DAY of AoC 2021"
     <> header "A module for running tests for AoC 2021")

{-#  OPTIONS_GHC -Wall  #-}

module AoC2021 (runSolution) where

--  https://cabal.readthedocs.io/en/3.4/cabal-package.html#accessing-data-files-from-package-code

import AoC2021InputParser
    ( parseBinaryDiagnosticInput, parseBingoInput, parseHydrothermalVents,
      parseLanternfishInternalTimers, parseHorizontalCrabPositions,
      parseSevenSegmentsDisplay, parseHeightMap )
import BinaryDiagnostic.BinaryDiagnostic (lifeSupportRating, powerConsumption)
import Data.String (IsString (fromString))
import Dive.Dive (productOfFinalPosition, productOfFinalPositionWithNewIntepretation)
import GiantSquid (scoreOfFirstWinningBoard, scoreOfLastWinningBoard)
import HydrothermalVenture.HydrothermalVenture
  ( pointsWithAtLeastTwoRightSegmentOverlaps,
    pointsWithAtLeastTwoSegmentOverlaps,
  )
import qualified AoC2021.Lanternfish (numOfFishIn80Days, numOfFishIn256Days)
import qualified AoC2021.TreacheryOfWhales as TreacheryOfWhales
  (
    minFuelForAlignmentWithConstantBurnRate,
    minFuelForAlignmentWithIncreasingBurnRate
  )
import Paths_advent_of_code_y2021 (getDataFileName)
import SonarSweep ( num3MeasurementIncreases, numIncreases )
import System.IO (IOMode (ReadMode), hGetContents, withFile)
import qualified AoC2021.SevenSegmentSearch as SevenSegmentSearch
  (numOf1478AppearancesInOutput, sumOfOutputValues)
import qualified AoC2021.SmokeBasin as SmokeBasin
  (
    sumOfRiskLevelsOfLowPoints,
    productOf3LargestBasins
  )
import Text.Printf (printf)

allSolutions :: IO ()
allSolutions = do
  solution01
  solution02
  solution03
  solution04
  solution05
  solution06
  solution07
  solution08
  solution09

runSolution :: Int -> IO ()
runSolution 0 = do allSolutions
runSolution 1 = do solution01
runSolution 2 = do solution02
runSolution 3 = do solution03
runSolution 4 = do solution04
runSolution 5 = do solution05
runSolution 6 = do solution06
runSolution 7 = do solution07
runSolution 8 = do solution08
runSolution 9 = do solution09
runSolution x = do putStrLn ("Day " ++ show x ++ " has no associated solution.")

solution01 :: IO ()
solution01 = do
  --  hGetContents is lazy in that data is only read as the characters are
  --  processed. The lazy evaluation of the string is transparent, and so it can
  --  be passed to pure functions without any issues. However, if we try to hold
  --  onto `s` past the call to `numIncreases`, then we lose the memory
  --  efficiency as the compiler is forced to keep its value in memory for future
  --  use. Note that closing a handle before fully consuming its results will
  --  make you miss on the stream's data that had not been evaluated before the
  --  handle's close. [1] [2]
  --
  --  [1]: http://book.realworldhaskell.org/read/io.html#io.lazy.hGetContents
  --  [2]: https://hackage.haskell.org/package/base-4.16.0.0/docs/System-IO.html#v:hGetContents

  fp <- getDataFileName "src/scratchpad/01-sonar-sweep.input.txt"
  putStrLn "Day 01. Sonar Sweep"
  withFile
    fp
    ReadMode
    ( \h -> do
        s <- hGetContents h
        putStr "\tPart 1: Number of measurements larger than previous measurement: "
        print (SonarSweep.numIncreases (lines (fromString s)))
        putStr "\tPart 2: Number of 3-measurements larger than previous 3-measurement: "
        print (SonarSweep.num3MeasurementIncreases (lines (fromString s)))
    )

solution02 :: IO ()
solution02 = do
  fp <- getDataFileName "src/Dive/scratchpad/input.txt"
  putStrLn "Day 02. Dive!"
  withFile
    fp
    ReadMode
    ( \h -> do
        s <- hGetContents h
        putStr "\tPart 1: Product of final horizontal position and final depth: "
        print (productOfFinalPosition (lines (fromString s)))
        putStr "\tPart 2: Product of final horizontal position and final depth "
        putStr "with new instructions of : "
        print (productOfFinalPositionWithNewIntepretation (lines (fromString s)))
    )

solution03 :: IO ()
solution03 = do
  putStrLn "Day 03. Binary Diagnostic"
  putStr "\tPart 1: Power Consumption: "
  input <- parseBinaryDiagnosticInput "src/BinaryDiagnostic/scratchpad/input.txt"
  print (powerConsumption input)
  putStr "\tPart 2: Life Support Rating: "
  print (lifeSupportRating input)

solution04 :: IO ()
solution04 = do
  putStrLn "Day 04. Giant Squid"
  input <- parseBingoInput "src/scratchpad/04-giant-squid.input.txt"

  putStr "\tPart 1: Score of first winning board: "
  print (GiantSquid.scoreOfFirstWinningBoard input)

  putStr "\tPart 2: Score of last winning board: "
  print (GiantSquid.scoreOfLastWinningBoard input)

solution05 :: IO ()
solution05 = do
  putStrLn "Day 05. Hydrothermal Venture"
  input <- parseHydrothermalVents "src/HydrothermalVenture/scratchpad/input.txt"

  putStr "\tPart 1: Num Points Where >= 2 Right Lines Overlap: "
  print (pointsWithAtLeastTwoRightSegmentOverlaps input)

  putStr "\tPart 2: Num Points Where >= 2 Lines Overlap: "
  print (pointsWithAtLeastTwoSegmentOverlaps input)

solution06 :: IO ()
solution06 = do
  putStrLn "Day 06. Lanternfish"
  input <- parseLanternfishInternalTimers "src/scratchpad/06-lanternfish.input.txt"

  putStr "\tPart 1: Number of lanternfish after 80 days: (360610) "
  print (AoC2021.Lanternfish.numOfFishIn80Days input)

  putStr "\tPart 2: Number of lanternfish after 256 days: (1631629590423) "
  print (AoC2021.Lanternfish.numOfFishIn256Days input)

solution07 :: IO ()
solution07 = do
  putStrLn "Day 07. The Treachery of Whales"
  input <- parseHorizontalCrabPositions "src/scratchpad/07-treachery-of-whales.input.txt"

  putStr "\tPart 1: Min fuel needed to align horizontal positions: (329389) "
  print (TreacheryOfWhales.minFuelForAlignmentWithConstantBurnRate input)

  putStr "\tPart 2: Min fuel needed to align with increasing burn rate: "
  print (TreacheryOfWhales.minFuelForAlignmentWithIncreasingBurnRate input)

printCheckedSolution :: (Eq a, Show a) => a -> a -> IO ()
printCheckedSolution actual expected = do
  let actualStr = show actual
  let mark | actual == expected = "✅"
           | otherwise          = "❌ (expected " ++ show expected ++ ")"
  printf "%s %s\n" actualStr mark

solution08 :: IO ()
solution08 = do
  putStrLn "Day 08. Seven Segment Search"
  input <- parseSevenSegmentsDisplay "src/scratchpad/08-seven-segment-search.input.txt"

  putStr "\tPart 1: Number of times the digits 1, 4, 7, or 8 appear in output: "
  printCheckedSolution (SevenSegmentSearch.numOf1478AppearancesInOutput input) 330

  putStr "\tPart 2: Sum of output values: "
  printCheckedSolution (SevenSegmentSearch.sumOfOutputValues input) 1010472

solution09 :: IO ()
solution09 = do
  putStrLn "Day 09. Smoke Basin"
  input <- parseHeightMap "src/scratchpad/09-smoke-basin.input.txt"

  putStr "\tPart 1: Sum of the risk levels of all low points on heightmap: "
  printCheckedSolution (SmokeBasin.sumOfRiskLevelsOfLowPoints input) 417

  putStr "\tPart 2: Product of the 3 largest basins: "
  printCheckedSolution (SmokeBasin.productOf3LargestBasins input) 1148965

module Main where

import qualified AoC2021 (runSolution)
import AoC2021Args (Args(..), aocArgParser)

import Options.Applicative

main :: IO ()
main = runAoCSolutions =<< execParser opts
  where
    opts = info (aocArgParser <**> helper)
      ( fullDesc
     <> progDesc "Run solutions for a given DAY of AoC 2021"
     <> header "A module for running solutions for AoC 2021")

runAoCSolutions :: Args -> IO ()
runAoCSolutions (Args d) = AoC2021.runSolution d

{-#  OPTIONS_GHC -Wall  #-}

--  {-# LANGUAGE FlexibleContexts #-}

--  The `(..)` syntax represents all of the constructors for the data type. [1]
--  Without that export, we can pattern-match in BinaryDiagnostic.hs because we
--  run into a "Not in scope: data constructor ‘BinaryDiagnostics’" error.
--
--  [1]: https://stackoverflow.com/a/34548070/7812406
module AoC2021InputParser
  ( parseBinaryDiagnosticInput,
    parseBingoInput,
    parseHydrothermalVents,
    parseLanternfishInternalTimers,
    parseHorizontalCrabPositions,
    parseSevenSegmentsDisplay,
    parseHeightMap,
  )
where

import BinaryDiagnostic.BinaryDiagnostic (BinaryDiagnostics (..), diagNums, diagWidth)
import Control.DeepSeq (($!!))
import Data.Char (digitToInt, ord)
import Data.Maybe (isJust, listToMaybe)
import Data.String (IsString (fromString))
import qualified Data.List.Split as Split
import qualified Data.Vector as V
import GiantSquid (Board, DrawnNumbers, Tile)
import qualified HydrothermalVenture.HydrothermalVenture as HV (LineSegment (..), Point (..))
import Paths_advent_of_code_y2021 (getDataFileName)
import System.IO (IOMode (ReadMode), hGetContents, withFile)
import Text.Parsec (endOfLine)
import Text.ParserCombinators.Parsec
import Text.Read (readMaybe)
import qualified AoC2021.SevenSegmentSearch as SevenSegmentSearch (SevenSegmentDisplay (..))
import qualified Data.IntSet as IntSet
import qualified AoC2021.SmokeBasin as SmokeBasin (HeightMap)
import qualified Data.Massiv.Array as MassivArray (empty, fromLists')
import qualified Data.Massiv.Core as MassivCore (Comp(Seq))

--  The `Numeric` module has a `readBin` function [1], but for some reason, I get
--  a "Variable not in scope: readBin" error. However, `readDec`, `readOct` and
--  `readHex` work...
--
--  [1]: https://hackage.haskell.org/package/base-4.16.0.0/docs/Numeric.html#v:readBin
readBin' :: String -> Int
readBin' binString = fst $ foldr f (0, 1) binString
  where
    f c (s, powerOf2) = (s + powerOf2 * digitToInt c, powerOf2 * 2)

--  The file is a list of binary digits of the same width, e.g.
--
--  00100
--  11110
parseBinaryDiagnosticInput :: FilePath -> IO BinaryDiagnostics
parseBinaryDiagnosticInput fp = do
  validatedFP <- getDataFileName fp
  withFile
    validatedFP
    ReadMode
    ( \h -> do
        s <- hGetContents h
        let ls = lines (fromString s)
        let width = maybe 0 length (listToMaybe ls)
        --  With lazy I/O, `h` gets closed as soon as we leave `withFile`. This
        --  introduces errors of the form "hGetContents: illegal operation
        --  (delayed read on closed handle)". [1]
        --
        --  In the expression `f $!! x`, `x` is fully evaluated before `f` is
        --  applied to it. [1] [2]
        --
        --  Alternatively, one can use `readFile` which holds the file open until
        --  it has finished reading the file [1]. However, [3] says that
        --  `readFile` reads the file lazily. Hmm...
        --
        --  [1]: https://stackoverflow.com/a/26949379/7812406
        --  [2]: https://hackage.haskell.org/package/deepseq-1.4.6.1/docs/Control-DeepSeq.html#v:-36--33--33-
        --  [3]: https://hackage.haskell.org/package/base-4.16.0.0/docs/html#v:readFile
        return $!! (BinaryDiagnostics {diagWidth = width, diagNums = map readBin' ls})
    )

--  `endBy` expects the very last item to be followed by the separator. It
--  continues parsing until it can't parse any more content. [1]
--
--  TODO: Is it possible to define `bingoFile` as `endBy bingoSection doubleEOL`?
--  The last double EOL is partly consumed by `bingoElementSeparator` that also
--  matches a new line.
--
--  [1]: http://book.realworldhaskell.org/read/using-parsec.html
bingoFile :: Parser [[String]]
bingoFile = endBy bingoSection endOfLine

--  `sepBy` takes two functions as arguments. The first function parses some sort
--  of content, while the second function parses a separator. `sepBy` starts by
--  trying to parse content, then separators, and alternates back and forth until
--  it can't parse a separator. It returns a list of all the content it was able
--  to parse. [1]
--
--  [1]: http://book.realworldhaskell.org/read/using-parsec.html
bingoSection :: Parser [String]
bingoSection = sepBy bingoElement bingoElementSeparator

bingoElement :: Parser String
bingoElement = many digit

bingoElementSeparator :: Parser Char
bingoElementSeparator = try (char ',') <|> try (char ' ') <?> "separator for element"

--  `try` applies a parser, and if it fails, then `try` behaves as if it hadn't
--  consumed any input at all, and tries the option on the right of the `<|>`.
--  Note that `try` only has an effect if its on the left side of a `<|>`. [1]
--
--  `<?>` tries the parser on its left. In the event of a failure, it presents an
--  error message instead of trying another parser. The error message should
--  complete the sentence, "Expecting...". [1]
--
--  [1]: http://book.realworldhaskell.org/read/using-parsec.html
--  eol = try (string "\n\r\n\r")
--          <|> try (string "\r\n\r\n")
--          <|> try (string "\n\n")
--          <|> string "\r\r"
--          <?> "end of line followed by empty line"

--  File format: the first line contains the numbers to draw. The rest is a new
--  line followed by a 5x5 grid of numbers representing a board.
--
--  7,4,9,5,11,17,23,2,0,14,21,24,10,16,13,6,15,25,12,22,18,20,8,19,3,26,1
--
--  22 13 17 11  0
--   8  2 23  4 24
--  21  9 14 16  7
--   6 10  3 18  5
--   1 12 20 15 19
--
--   3 15  0  2 22
--   9 18 13 17  5
--  19  8  7 25 23
--  20 11 10 24  4
--  14 21 16 12  6
parseBingoInput :: FilePath -> IO (DrawnNumbers, [Board])
parseBingoInput fp = do
  dataFp <- getDataFileName fp
  --  Objective: Try using `readFile` and see if `($!!)` is needed to fully
  --  evaluate the contents before exiting this function.
  fileContents <- readFile dataFp
  case parse bingoFile "" fileContents of
    Left e -> do
      putStrLn "Error parsing input"
      print e
      return ([], [])
    Right r -> do
      let parseInt :: String -> Int
          parseInt s = read s :: Int

          drawnNumbers = map parseInt (head r)

          tile :: String -> Tile
          tile x = (parseInt x, False)

          --  TODO: Figure out how to parse multiple spaces as
          --  separators, and get rid of the `isValidNum` filter.
          isValidNum :: String -> Bool
          isValidNum s = isJust (readMaybe s :: Maybe Int)

          parseBoards :: [[String]] -> [Board]
          parseBoards ([_] : l1 : l2 : l3 : l4 : l5 : ls) =
            let nums = V.filter isValidNum (V.fromList (l1 ++ l2 ++ l3 ++ l4 ++ l5))
                board = V.map tile nums
             in (board, False) : parseBoards ls
          parseBoards [l1, l2, l3, l4, l5] =
            let nums = V.filter isValidNum (V.fromList (l1 ++ l2 ++ l3 ++ l4 ++ l5))
                board = V.map tile nums
             in [(board, False)]
          parseBoards _ = []

      return (drawnNumbers, parseBoards (tail r))

hydrothermalFile :: Parser [HV.LineSegment]
hydrothermalFile = endBy hydrothermalLine endOfLine

--  Parses "0,9 -> 5,9" into a `LineSegment`.
hydrothermalLine :: Parser HV.LineSegment
hydrothermalLine =
  do p1 <- commaSeparatedCoordinates --  Underscores to avoid shadowing.
     _ <- string " -> "
     p2 <- commaSeparatedCoordinates
     return HV.LineSegment {HV.p1 = p1, HV.p2 = p2}

--  Parses "0,9" into (0, 9)
commaSeparatedCoordinates :: Parser HV.Point
commaSeparatedCoordinates =
  do x <- many1 digit
     _ <- char ','
     y <- many1 digit
     return HV.Point {HV.x=read x :: Int, HV.y= read y :: Int}

reportError :: ParseError -> IO ()
reportError e = do
  putStrLn "Error parsing input"
  print e

parseHydrothermalVents :: FilePath -> IO [HV.LineSegment]
parseHydrothermalVents fp = do
  dataFp <- getDataFileName fp
  fileContents <- readFile dataFp
  case parse hydrothermalFile "Hydrothermal Parser" fileContents of
    Left e -> do {reportError e; return []}
    Right r -> return r

singleLineCommaDelimitedFile :: Parser [Int]
singleLineCommaDelimitedFile =
  sepBy (do x <- many1 digit; return (read x :: Int)) (char ',')

parseSingleLineCommaDelimitedFile :: FilePath -> IO [Int]
parseSingleLineCommaDelimitedFile fp = do
  dataFp <- getDataFileName fp
  fileContents <- readFile dataFp
  case parse singleLineCommaDelimitedFile "Single Comma-Delimited Int Parser" fileContents of
    Left e  -> do {reportError e; return []}
    Right r -> return r

parseLanternfishInternalTimers :: FilePath -> IO [Int]
parseLanternfishInternalTimers = parseSingleLineCommaDelimitedFile

parseHorizontalCrabPositions :: FilePath -> IO [Int]
parseHorizontalCrabPositions = parseSingleLineCommaDelimitedFile

--  Sample line:
--  fgaebd cg bdaec gdafb agbcfd gdcbef bgcad gfac gcb cdgabef | cg cg fdcagb cbg
sevenSegmentsDisplayLine :: Parser SevenSegmentSearch.SevenSegmentDisplay
sevenSegmentsDisplayLine = do
  --  TODO: Is there syntax for avoiding the intermediate _allSegments variable?
  _allSegments <- many1 (noneOf "\r\n")
  let uniquePatternsAndOutputs = splitAt 10 $ Split.split (Split.dropDelims . Split.dropInnerBlanks $ Split.oneOf "| ") _allSegments

  let stringsToIntSets = map (IntSet.fromList . map ord) :: [String] -> [IntSet.IntSet]
  return SevenSegmentSearch.SevenSegmentDisplay{
    SevenSegmentSearch.uniquePatterns = stringsToIntSets (fst uniquePatternsAndOutputs),
    SevenSegmentSearch.outputValues = stringsToIntSets (snd uniquePatternsAndOutputs)}

sevenSegmentsDisplayFile :: Parser [SevenSegmentSearch.SevenSegmentDisplay]
sevenSegmentsDisplayFile = endBy sevenSegmentsDisplayLine endOfLine

parseSevenSegmentsDisplay :: FilePath -> IO [SevenSegmentSearch.SevenSegmentDisplay]
parseSevenSegmentsDisplay fp = do
  dataFp <- getDataFileName fp
  fileContents <- readFile dataFp
  case parse sevenSegmentsDisplayFile "Seven Segment Display" fileContents of
    Left e  -> do {reportError e; return []}
    Right r -> do {return r}