Parser Combinators파서 컴비네이터

-- 파서 타입: 입력을 받아 결과와 나머지 입력을 반환
newtype Parser a = Parser
  { runParser :: String -> Maybe (a, String) }

instance Functor Parser where
  fmap f (Parser p) = Parser $ \input ->
    fmap (\(a, rest) -> (f a, rest)) (p input)

instance Applicative Parser where
  pure a = Parser $ \input -> Just (a, input)
  Parser f <*> Parser a = Parser $ \input -> do
    (func, rest1) <- f input
    (arg,  rest2) <- a rest1
    return (func arg, rest2)

instance Monad Parser where
  return = pure
  Parser p >>= f = Parser $ \input -> do
    (a, rest) <- p input
    runParser (f a) rest

-- 단일 문자 파서
char :: Char -> Parser Char
char c = Parser $ \case
  (x:xs) | x == c -> Just (c, xs)
  _               -> Nothing

-- 조건 파서
satisfy :: (Char -> Bool) -> Parser Char
satisfy p = Parser $ \case
  (x:xs) | p x -> Just (x, xs)
  _            -> Nothing

digit  = satisfy isDigit
letter = satisfy isAlpha
space  = satisfy isSpace

-- 선택 파서 (Alternative)
(<|>) :: Parser a -> Parser a -> Parser a
Parser p1 <|> Parser p2 = Parser $ \input ->
  p1 input `mplus` p2 input

-- 반복 파서
many  :: Parser a -> Parser [a]  -- 0회 이상
many1 :: Parser a -> Parser [a]  -- 1회 이상

data JSON = JNull | JBool Bool | JNum Double
          | JStr String | JArr [JSON] | JObj [(String, JSON)]

parseNull :: Parser JSON
parseNull = JNull <$ string "null"

parseBool :: Parser JSON
parseBool = JBool True  <$ string "true"
        <|> JBool False <$ string "false"

parseString :: Parser JSON
parseString = JStr <$> (char '"' *> manyTill anyChar (char '"'))

parseArray :: Parser JSON
parseArray = JArr <$>
  (char '[' *> sepBy parseJSON (char ',') <* char ']')