Ver3.5 ๐งฉ Haskell๋ก ๊ตฌํํ๋ ํ์ ์ปด๋น๋ค์ดํฐ

๐งฉ Haskell๋ก ๊ตฌํํ๋ ํ์ ์ปด๋น๋ค์ดํฐ
์, ์ผ๋จ ๊ธฐ๋ณธ๋ถํฐ ์ง๊ณ ๊ฐ์. ํ์(Parser)๋ ํ
์คํธ(๋ฌธ์์ด)๋ฅผ ์ฝ์ด์ ์๋ฏธ ์๋ ๊ตฌ์กฐ๋ก ๋ณํํ๋ ํ๋ก๊ทธ๋จ์ด์ผ. ์๋ฅผ ๋ค์ด "3 + 4 * 2"๋ผ๋ ๋ฌธ์์ด์ ์ฝ์ด์ "๋ง์
์ด๊ณ , ์ค๋ฅธ์ชฝ ํผ์ฐ์ฐ์๋ ๊ณฑ์
์ด์ผ"๋ผ๋ ๊ตฌ์กฐ๋ก ๋ฐ๊ฟ์ฃผ๋ ๊ฑฐ์ง.
๊ทธ๋ฐ๋ฐ ํ์๋ฅผ ๋ง๋๋ ๋ฐฉ๋ฒ์ด ์ฌ๋ฌ ๊ฐ์ง ์์ด. ์ ํต์ ์ผ๋ก๋ ๋ ์(Lexer) + ํ์ ์ ๋๋ ์ดํฐ(yacc, bison, ANTLR ๋ฑ)๋ฅผ ์ฐ๋ ๋ฐฉ์์ด ์๊ณ , ์๋๋ฉด ์ง์ ์์ผ๋ก ์ฌ๊ท ํ๊ฐ ํ์(Recursive Descent Parser)๋ฅผ ์ง๋ ๋ฐฉ๋ฒ๋ ์์ด.
๊ทธ๋ฐ๋ฐ Haskell ์ธ๊ณ์์๋ ํจ์ฌ ์ฐ์ํ ๋ฐฉ๋ฒ์ด ์์ด. ๋ฐ๋ก ํ์ ์ปด๋น๋ค์ดํฐ(Parser Combinator)์ผ!
๊ฐ๊ฐ์ ํ์๋ "์ ๋ ฅ ๋ฌธ์์ด์ ๋ฐ์์, ํ์ฑ ๊ฒฐ๊ณผ์ ๋จ์ ๋ฌธ์์ด์ ๋ฐํํ๋ ํจ์"์ผ.
๊ทธ๋ฆฌ๊ณ ์ด ํ์๋ค์ ์ปด๋น๋ค์ดํฐ(combinator)๋ผ๋ ๊ณ ์ฐจ ํจ์๋ก ์กฐํฉํด์ ๋ณต์กํ ํ์๋ฅผ ๋ง๋ค์ด๋ด๋ ๊ฑฐ์ง.
์ Haskell์ด ํ์ ์ปด๋น๋ค์ดํฐ์ ํนํ ์ ๋ง๋๊ณ ? ์ด์ ๊ฐ ์์ด ใ ใ ใ
- 1 ๊ณ ์ฐจ ํจ์(Higher-Order Functions): ํจ์๋ฅผ ๊ฐ์ฒ๋ผ ๋ค๋ฃจ๊ณ ์กฐํฉํ๋ ๊ฒ ์์ฐ์ค๋ฌ์
- 2 ํ์ ์์คํ : ๊ฐ๋ ฅํ ํ์ ์ถ๋ก ์ผ๋ก ํ์ ์กฐํฉ ์ ํ์ ์์ ์ฑ ๋ณด์ฅ
- 3 Monad / Applicative: ํ์ ์ปด๋น๋ค์ดํฐ์ ์กฐํฉ ํจํด์ด Monad/Applicative์ ์๋ฒฝํ๊ฒ ๋ง์๋จ์ด์ง
- 4 ์ง์ฐ ํ๊ฐ(Lazy Evaluation): ๋ฌดํ ๋ฌธ๋ฒ๋ ์์ฐ์ค๋ฝ๊ฒ ํํ ๊ฐ๋ฅ
- 5 ๊ฐ๊ฒฐํ ๋ฌธ๋ฒ: do ํ๊ธฐ๋ฒ, ์ฐ์ฐ์ ์ค๋ฒ๋ก๋ฉ์ผ๋ก ํ์ ์ฝ๋๊ฐ BNF ๋ฌธ๋ฒ์ฒ๋ผ ์ฝํ
์ด๋ก ๋ง ๋ค์ผ๋ฉด ์ง๋ฃจํ๋๊น ๋ฐ๋ก ์ฝ๋๋ก ๊ฐ๋ณด์! ใฑใฑ ๐ฅ
ํ์ ์ปด๋น๋ค์ดํฐ๋ฅผ ์ดํดํ๋ ค๋ฉด ๋จผ์ "ํ์๊ฐ ๋ญ์ง"๋ฅผ ํ์ ์ผ๋ก ํํํด์ผ ํด. Haskell์์ ํ์์ ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ํ์ ์ ์ด๋ ๊ฒ ์๊ฒผ์ด:
Haskell-- ๊ฐ์ฅ ๋จ์ํ ํ์ ํ์
newtype Parser a = Parser { runParser :: String -> Maybe (a, String) }
์ด๊ฒ ๋ญ ๋ป์ด๋๋ฉด:
์คํจํ๋ฉด Nothing์ ๋ฐํํ๋ ํจ์๋ฅผ ๊ฐ์ผ ํ์ ์ด์ผ.
a๋ ํ์ฑ ๊ฒฐ๊ณผ์ ํ์
์ด์ผ. ์๋ฅผ ๋ค์ด ์ซ์๋ฅผ ํ์ฑํ๋ฉด Parser Int, ๋ฌธ์๋ฅผ ํ์ฑํ๋ฉด Parser Char.
์ค์ ๋ก ์ฌ์ฉํ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ค์ ์ด๋ณด๋ค ํจ์ฌ ์ ๊ตํ์ง๋ง, ๊ฐ๋ ์ดํด๋ฅผ ์ํด ์ด ๋จ์ํ ๋ฒ์ ์ผ๋ก ์์ํด๋ณด์.
๊ฐ์ฅ ๊ธฐ์ด์ ์ธ ํ์๋ถํฐ ๋ง๋ค์ด๋ณผ๊ฒ. ๋ฑ ํ ๊ธ์๋ฅผ ํ์ฑํ๋ ํ์์ผ:
Haskell-- ์กฐ๊ฑด์ ๋ง์กฑํ๋ ๋จ์ผ ๋ฌธ์๋ฅผ ํ์ฑํ๋ ํ์
satisfy :: (Char -> Bool) -> Parser Char
satisfy predicate = Parser $ \input ->
case input of
[] -> Nothing -- ์
๋ ฅ์ด ๋น์ด์์ผ๋ฉด ์คํจ
(c:cs) -> if predicate c -- ์ฒซ ๊ธ์๊ฐ ์กฐ๊ฑด์ ๋ง์กฑํ๋ฉด
then Just (c, cs) -- ์ฑ๊ณต: (ํ์ฑ๋ ๋ฌธ์, ๋จ์ ๋ฌธ์์ด)
else Nothing -- ์คํจ
-- ํน์ ๋ฌธ์๋ฅผ ํ์ฑํ๋ ํ์
char :: Char -> Parser Char
char c = satisfy (== c)
-- ์ซ์ ๋ฌธ์๋ฅผ ํ์ฑํ๋ ํ์
digit :: Parser Char
digit = satisfy isDigit
-- ์ํ๋ฒณ์ ํ์ฑํ๋ ํ์
letter :: Parser Char
letter = satisfy isAlpha
์ด์ ์ด ํ์๋ค์ ์ค์ ๋ก ์คํํด๋ณด๋ฉด:
Haskell-- ์คํ ์์
runParser (char 'H') "Hello" -- Just ('H', "ello")
runParser (char 'H') "World" -- Nothing
runParser digit "123abc" -- Just ('1', "23abc")
runParser digit "abc" -- Nothing
์, ์ด์ ์ง์ง ์ฌ๋ฐ๋ ๋ถ๋ถ์ด์ผ. Haskell์ ํ์ ํด๋์ค๋ค์ ํ์์ ์ ์ฉํ๋ฉด ํ์ ์กฐํฉ์ด ์์ฒญ ์ฐ์ํด์ ธ. ในใ ๊ฐ๋๋ฐ์ ์ค๋นํด ใ ใ ใ
Functor๋ "์ปจํ ์ด๋ ์์ ๊ฐ์ ํจ์๋ก ๋ณํ"ํ๋ ๊ฐ๋ ์ด์ผ. ํ์์ ์ ์ฉํ๋ฉด "ํ์ฑ ๊ฒฐ๊ณผ๋ฅผ ๋ณํ"ํ ์ ์์ด:
Haskellinstance Functor Parser where
fmap f (Parser p) = Parser $ \input ->
case p input of
Nothing -> Nothing
Just (a, rest) -> Just (f a, rest)
-- ์ฌ์ฉ ์์
digitValue :: Parser Int
digitValue = fmap digitToInt digit
-- digit์ '3' ๊ฐ์ ๋ฌธ์๋ฅผ ํ์ฑํ๊ณ
-- fmap digitToInt๋ก ์ซ์ 3์ผ๋ก ๋ณํ!
runParser digitValue "3abc" -- Just (3, "abc")
Applicative๋ ์ฌ๋ฌ ํ์๋ฅผ ์์๋๋ก ์ ์ฉํ๊ณ ๊ฒฐ๊ณผ๋ฅผ ์กฐํฉํ ๋ ์จ. ์ด๊ฒ ์ง์ง ๊ฐ๋ ฅํด:
Haskellinstance Applicative Parser where
pure a = Parser $ \input -> Just (a, input)
-- pure: ํญ์ ์ฑ๊ณตํ๊ณ ์
๋ ฅ์ ์๋นํ์ง ์๋ ํ์
(Parser pf) <*> (Parser pa) = Parser $ \input ->
case pf input of
Nothing -> Nothing
Just (f, rest) ->
case pa rest of
Nothing -> Nothing
Just (a, rest') -> Just (f a, rest')
-- <*>: ํจ์๋ฅผ ํ์ฑํ๊ณ , ๊ทธ ํจ์๋ฅผ ๊ฐ ํ์ฑ ๊ฒฐ๊ณผ์ ์ ์ฉ
-- ์ฌ์ฉ ์์: ๋ ์ซ์ ์ฌ์ด์ '+'๋ฅผ ํ์ฑ
-- "3+4" -> (3, 4)
addExpr :: Parser (Int, Int)
addExpr = (,) <$> digitValue <*> (char '+' *> digitValue)
-- <$>๋ fmap์ ์ฐ์ฐ์ ๋ฒ์
-- *>๋ ์ผ์ชฝ ํ์ ๊ฒฐ๊ณผ๋ฅผ ๋ฒ๋ฆฌ๊ณ ์ค๋ฅธ์ชฝ ๊ฒฐ๊ณผ๋ง ์ทจํจ
runParser addExpr "3+4" -- Just ((3, 4), "")
Monad๋ ํ์ ์ปด๋น๋ค์ดํฐ์ ์ต์ข ๋ณด์ค์ผ. ์ด์ ํ์ฑ ๊ฒฐ๊ณผ์ ๋ฐ๋ผ ๋ค์์ ์ด๋ค ํ์๋ฅผ ์ธ์ง ๋์ ์ผ๋ก ๊ฒฐ์ ํ ์ ์์ด:
Haskellinstance Monad Parser where
return = pure
(Parser pa) >>= f = Parser $ \input ->
case pa input of
Nothing -> Nothing
Just (a, rest) ->
let (Parser pb) = f a
in pb rest
-- do ํ๊ธฐ๋ฒ์ผ๋ก ์ฐ๋ฉด ์ง์ง ์ฝ๊ธฐ ์ฌ์์ง!
-- "3+4" ํ์ฑํ๊ธฐ
addExprM :: Parser Int
addExprM = do
left <- digitValue -- ์ผ์ชฝ ์ซ์ ํ์ฑ
_ <- char '+' -- '+' ํ์ฑ (๊ฒฐ๊ณผ ๋ฒ๋ฆผ)
right <- digitValue -- ์ค๋ฅธ์ชฝ ์ซ์ ํ์ฑ
return (left + right) -- ๋ ์ซ์๋ฅผ ๋ํ ๊ฒฐ๊ณผ ๋ฐํ
runParser addExprM "3+4" -- Just (7, "")
runParser addExprM "3-4" -- Nothing ('+' ํ์ฑ ์คํจ)
์ด์ ์ค์ ๋ก ๋ง์ด ์ฐ์ด๋ ์ปด๋น๋ค์ดํฐ๋ค์ ์ดํด๋ณด์. ์ด๊ฒ๋ค์ด ๋ ๊ณ ๋ธ๋ก์ด์ผ ใ ใ ใ ์ด๊ฑธ ์กฐํฉํด์ ๋ญ๋ ๋ง๋ค ์ ์์ด!
ํ์ A๊ฐ ์คํจํ๋ฉด ํ์ B๋ฅผ ์๋ํ๋ ์ ํ(choice) ์ปด๋น๋ค์ดํฐ์ผ:
Haskellinstance Alternative Parser where
empty = Parser $ \_ -> Nothing
-- empty: ํญ์ ์คํจํ๋ ํ์
(Parser pa) <|> (Parser pb) = Parser $ \input ->
case pa input of
Nothing -> pb input -- pa ์คํจํ๋ฉด pb ์๋
success -> success -- pa ์ฑ๊ณตํ๋ฉด ๊ทธ๋๋ก ๋ฐํ
-- ์ฌ์ฉ ์์
-- ์ซ์ ๋๋ ์ํ๋ฒณ ํ์ฑ
alphaNum :: Parser Char
alphaNum = digit <|> letter
runParser alphaNum "3abc" -- Just ('3', "abc")
runParser alphaNum "abc3" -- Just ('a', "bc3")
runParser alphaNum "!@#" -- Nothing
ํ์๋ฅผ 0๋ฒ ์ด์, ๋๋ 1๋ฒ ์ด์ ๋ฐ๋ณต ์ ์ฉํ๋ ์ปด๋น๋ค์ดํฐ์ผ:
Haskell-- many: 0๋ฒ ์ด์ ๋ฐ๋ณต (ํญ์ ์ฑ๊ณต)
many :: Parser a -> Parser [a]
many p = some p <|> pure []
-- some: 1๋ฒ ์ด์ ๋ฐ๋ณต (์ต์ 1๋ฒ ์ฑ๊ณตํด์ผ ํจ)
some :: Parser a -> Parser [a]
some p = (:) <$> p <*> many p
-- ์ฌ์ฉ ์์: ์ฌ๋ฌ ์๋ฆฌ ์ซ์ ํ์ฑ
digits :: Parser String
digits = some digit
number :: Parser Int
number = read <$> digits
runParser number "123abc" -- Just (123, "abc")
runParser number "abc" -- Nothing (์ต์ 1๊ฐ ํ์)
runParser (many digit) "abc" -- Just ("", "abc") (0๊ฐ๋ OK)
-- between: ์๋ค๋ฅผ ํน์ ํ์๋ก ๊ฐ์ธ๊ธฐ
between :: Parser open -> Parser close -> Parser a -> Parser a
between open close p = open *> p <* close
-- ์ฌ์ฉ ์์: ๊ดํธ ์์ ์ซ์ ํ์ฑ
parens :: Parser a -> Parser a
parens = between (char '(') (char ')')
runParser (parens number) "(123)" -- Just (123, "")
runParser (parens number) "[123]" -- Nothing
-- sepBy: ๊ตฌ๋ถ์๋ก ๋ถ๋ฆฌ๋ ๋ชฉ๋ก ํ์ฑ
sepBy :: Parser a -> Parser sep -> Parser [a]
sepBy p sep = sepBy1 p sep <|> pure []
sepBy1 :: Parser a -> Parser sep -> Parser [a]
sepBy1 p sep = (:) <$> p <*> many (sep *> p)
-- ์ฌ์ฉ ์์: ์ผํ๋ก ๋ถ๋ฆฌ๋ ์ซ์ ๋ชฉ๋ก
numberList :: Parser [Int]
numberList = sepBy number (char ',')
runParser numberList "1,2,3,4" -- Just ([1,2,3,4], "")
runParser numberList "" -- Just ([], "")
-- optional: ์์ด๋ ๋๊ณ ์์ด๋ ๋๋ ํ์
optional :: Parser a -> Parser (Maybe a)
optional p = (Just <$> p) <|> pure Nothing
-- lookAhead: ํ์ฑํ๋ ์
๋ ฅ์ ์๋นํ์ง ์์
lookAhead :: Parser a -> Parser a
lookAhead (Parser p) = Parser $ \input ->
case p input of
Nothing -> Nothing
Just (a, _) -> Just (a, input) -- ์
๋ ฅ ๊ทธ๋๋ก ์ ์ง!
-- notFollowedBy: ๋ค์์ ํน์ ํจํด์ด ์ค์ง ์์์ผ ์ฑ๊ณต
notFollowedBy :: Parser a -> Parser ()
notFollowedBy (Parser p) = Parser $ \input ->
case p input of
Nothing -> Just ((), input)
Just _ -> Nothing
many์ some์ ์ธ ๋ ๋ฌดํ ๋ฃจํ ์กฐ์ฌ! ํญ์ ์ฑ๊ณตํ๋ ํ์(์: pure ())๋ฅผ many์ ๋ฃ์ผ๋ฉด ๋ฌดํ ๋ฃจํ์ ๋น ์ ธ. ๋ฐ๋์ ์
๋ ฅ์ ์๋นํ๋ ํ์๋ฅผ ๋ฃ์ด์ผ ํด.
์ด์ ์ง์ง ์ค์ ์ด์ผ. ์ฌ์น์ฐ์ฐ ์์์ ํ์ฑํ๋ ํ์๋ฅผ ์ฒ์๋ถํฐ ๋ง๋ค์ด๋ณผ๊ฒ. ์ด๊ฒ ํ์ ์ปด๋น๋ค์ดํฐ์ ์ง๊ฐ๋ฅผ ๋ณด์ฌ์ฃผ๋ ์์ ์ผ ใทใท
๋จผ์ ํ์ฑํ ๋ฌธ๋ฒ์ BNF๋ก ์ ์ํด๋ณด์:
expr ::= term (('+' | '-') term)*term ::= factor (('*' | '/') factor)*factor ::= number | '(' expr ')'number ::= digit+์ด ๋ฌธ๋ฒ์ด ์ฐ์ฐ์ ์ฐ์ ์์๋ฅผ ์๋์ผ๋ก ์ฒ๋ฆฌํด์ค.
*์ /๊ฐ +์ -๋ณด๋ค ๋จผ์ ์ฒ๋ฆฌ๋๋๋ก ๊ณ์ธต ๊ตฌ์กฐ๋ก ํํํ ๊ฑฐ์ผ.
import Control.Applicative
import Data.Char
-- ํ์ ํ์
์ ์
newtype Parser a = Parser { runParser :: String -> Maybe (a, String) }
-- Functor ์ธ์คํด์ค
instance Functor Parser where
fmap f (Parser p) = Parser $ \input ->
fmap (\(a, rest) -> (f a, rest)) (p input)
-- Applicative ์ธ์คํด์ค
instance Applicative Parser where
pure a = Parser $ \input -> Just (a, input)
(Parser pf) <*> (Parser pa) = Parser $ \input -> do
(f, rest) <- pf input
(a, rest') <- pa rest
return (f a, rest')
-- Alternative ์ธ์คํด์ค
instance Alternative Parser where
empty = Parser $ \_ -> Nothing
(Parser pa) <|> (Parser pb) = Parser $ \input ->
pa input <|> pb input
-- Monad ์ธ์คํด์ค
instance Monad Parser where
return = pure
(Parser pa) >>= f = Parser $ \input -> do
(a, rest) <- pa input
runParser (f a) rest
-- ๊ธฐ๋ณธ ํ์๋ค
satisfy :: (Char -> Bool) -> Parser Char
satisfy pred = Parser $ \input ->
case input of
(c:cs) | pred c -> Just (c, cs)
_ -> Nothing
char :: Char -> Parser Char
char c = satisfy (== c)
digit :: Parser Char
digit = satisfy isDigit
spaces :: Parser String
spaces = many (satisfy isSpace)
-- ๊ณต๋ฐฑ์ ๋ฌด์ํ๋ ํ ํฐ ํ์
token :: Parser a -> Parser a
token p = spaces *> p <* spaces
-- ์ซ์ ํ์
number :: Parser Int
number = token $ read <$> some digit
-- ์ฐ์ฐ์ ํ์
addOp :: Parser (Int -> Int -> Int)
addOp = token $ (char '+' *> pure (+)) <|> (char '-' *> pure (-))
mulOp :: Parser (Int -> Int -> Int)
mulOp = token $ (char '*' *> pure (*)) <|> (char '/' *> pure div)
-- ์์ ํ์ (์ฐ์ฐ์ ์ฐ์ ์์ ์ฒ๋ฆฌ)
-- chainl1: ์ผ์ชฝ ๊ฒฐํฉ ์ฐ์ฐ์ ์ฒ๋ฆฌ
chainl1 :: Parser a -> Parser (a -> a -> a) -> Parser a
chainl1 p op = do
x <- p
rest x
where
rest x = (do
f <- op
y <- p
rest (f x y)) <|> pure x
-- factor: ์ซ์ ๋๋ ๊ดํธ ํํ์
factor :: Parser Int
factor = number <|> parens expr
-- term: ๊ณฑ์
/๋๋์
term :: Parser Int
term = chainl1 factor mulOp
-- expr: ๋ง์
/๋บ์
expr :: Parser Int
expr = chainl1 term addOp
-- ๊ดํธ ์ฒ๋ฆฌ
parens :: Parser a -> Parser a
parens p = token (char '(') *> p <* token (char ')')
-- ์ ์ฒด ํ์ ์คํ
calculate :: String -> Maybe Int
calculate input = fst <$> runParser expr input
์ด์ ์ค์ ๋ก ์จ๋ณด๋ฉด:
Haskell - ์คํ ๊ฒฐ๊ณผcalculate "3 + 4" -- Just 7
calculate "3 + 4 * 2" -- Just 11 (์ฐ์ ์์ ์ฒ๋ฆฌ!)
calculate "(3 + 4) * 2" -- Just 14 (๊ดํธ ์ฒ๋ฆฌ!)
calculate "10 / 2 + 3" -- Just 8
calculate "1 + 2 + 3 + 4" -- Just 10 (์ผ์ชฝ ๊ฒฐํฉ!)
calculate "abc" -- Nothing (ํ์ฑ ์คํจ)
expr ::= term (('+' | '-') term)*์ฝ๋๋ฅผ ๋ณด๋ฉด:
expr = chainl1 term addOp๊ฑฐ์ 1:1 ๋์์ด์ผ! ํ์ ์ปด๋น๋ค์ดํฐ์ ์ฝ๋๊ฐ ๋ฌธ๋ฒ ๋ช ์ธ ์์ฒด์ฒ๋ผ ์ฝํ. ์ด๊ฒ ํ์ ์ปด๋น๋ค์ดํฐ์ ์ต๋ ์ฅ์ ์ด์ผ ใ ใ ใ
์์์ ์ง์ ๋ง๋ ํ์๋ ๊ฐ๋ ์ดํด์ฉ์ด๊ณ , ์ค์ ํ๋ก์ ํธ์์๋ ๊ฒ์ฆ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์จ์ผ ํด. Haskell ์ํ๊ณ์์ ๊ฐ์ฅ ์ ๋ช ํ ํ์ ์ปด๋น๋ค์ดํฐ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ค์ ์๊ฐํ ๊ฒ!
| ๋ผ์ด๋ธ๋ฌ๋ฆฌ | ํน์ง | ์ถ์ฒ ์ฉ๋ |
|---|---|---|
| Parsec | Haskell ํ์ ์ปด๋น๋ค์ดํฐ์ ์์กฐ, ์์ ์ | ํ์ต, ๊ฐ๋จํ ํ์ |
| Megaparsec | Parsec ๊ฐ์ ํ, ๋ ๋์ ์๋ฌ ๋ฉ์์ง | ์ค๋ฌด ํ๋ก์ ํธ |
| Attoparsec | ์ฑ๋ฅ ์ต์ ํ, ๋ฐ์ด๋๋ฆฌ ํ์ฑ ์ง์ | ๊ณ ์ฑ๋ฅ ํ์ฑ |
| trifecta | ์์ ์๋ฌ ๋ฉ์์ง, ์์ ์ถ๋ ฅ | ๊ฐ๋ฐ์ ๋๊ตฌ |
Megaparsec์ ์ฐ๋ฉด ์๋ฌ ์ฒ๋ฆฌ๊ฐ ํจ์ฌ ๊ฐ๋ ฅํด์ ธ. ์ค์ ์ฝ๋๋ฅผ ๋ณด์:
Haskell - Megaparsec ์ฌ์ฉ{-# LANGUAGE OverloadedStrings #-}
import Text.Megaparsec
import Text.Megaparsec.Char
import qualified Text.Megaparsec.Char.Lexer as L
import Data.Void
type Parser = Parsec Void String
-- ๊ณต๋ฐฑ ์ฒ๋ฆฌ
sc :: Parser ()
sc = L.space space1 lineCmnt blockCmnt
where
lineCmnt = L.skipLineComment "--"
blockCmnt = L.skipBlockComment "{-" "-}"
-- ํ ํฐ ํ์ (๊ณต๋ฐฑ ์๋ ์ฒ๋ฆฌ)
lexeme :: Parser a -> Parser a
lexeme = L.lexeme sc
symbol :: String -> Parser String
symbol = L.symbol sc
-- ์ ์ ํ์
integer :: Parser Int
integer = lexeme L.decimal
-- ๊ดํธ ํ์
parens :: Parser a -> Parser a
parens = between (symbol "(") (symbol ")")
-- ์์ ํ์ (Megaparsec ๋ฒ์ )
expr :: Parser Int
expr = makeExprParser term operatorTable
term :: Parser Int
term = parens expr <|> integer
operatorTable :: [[Operator Parser Int]]
operatorTable =
[ [ InfixL ((*) <$ symbol "*")
, InfixL (div <$ symbol "/") ]
, [ InfixL ((+) <$ symbol "+")
, InfixL ((-) <$ symbol "-") ] ]
-- ํ์ฑ ์คํ
parseExpr :: String -> Either (ParseErrorBundle String Void) Int
parseExpr = parse (sc *> expr <* eof) ""
Megaparsec์ makeExprParser๋ฅผ ์ฐ๋ฉด ์ฐ์ฐ์ ์ฐ์ ์์ ์ฒ๋ฆฌ๊ฐ ๋ ์ ์ธ์ ์ผ๋ก ๋ผ. ํ
์ด๋ธ ํํ๋ก ์ฐ์ ์์๋ฅผ ์ ์ํ๋ฉด ๋์ด์ผ!
์ง์ ๋ง๋ ํ์๋ ์คํจํ๋ฉด ๊ทธ๋ฅ
Nothing์ด์ง๋ง, Megaparsec์ ์ด๋ฐ ์๋ฌ๋ฅผ ์ค:1:5:
|
1 | 3 + * 4
| ^
unexpected '*'
expecting integer or '('์ค ๋ฒํธ, ์ปฌ๋ผ ๋ฒํธ, ๊ธฐ๋ํ๋ ๊ฒ๊น์ง ์๋ ค์ค. ์ค์ ์ปดํ์ผ๋ฌ ์์ค์ ์๋ฌ ๋ฉ์์ง์ผ!
ํ์ ์ปด๋น๋ค์ดํฐ์ ์ง๊ฐ๋ฅผ ๋ณด์ฌ์ฃผ๋ ์์ ๋ก JSON ํ์๋ฅผ ๋ง๋ค์ด๋ณด์. JSON์ ์ค์ ๋ก ๋ง์ด ์ฐ์ด๋ ํ์์ด๊ณ , ํ์ ์ปด๋น๋ค์ดํฐ๋ก ๋ง๋ค๋ฉด ์ผ๋ง๋ ๊ฐ๊ฒฐํ์ง ๋ณด์ฌ์ค๊ฒ!
import Text.Megaparsec
import Text.Megaparsec.Char
import qualified Text.Megaparsec.Char.Lexer as L
import Data.Map (Map)
import qualified Data.Map as Map
-- JSON ๊ฐ ํ์
์ ์
data JsonValue
= JsonNull
| JsonBool Bool
| JsonNumber Double
| JsonString String
| JsonArray [JsonValue]
| JsonObject (Map String JsonValue)
deriving (Show, Eq)
type Parser = Parsec Void String
-- ๊ณต๋ฐฑ ์ฒ๋ฆฌ
sc :: Parser ()
sc = L.space space1 empty empty
lexeme :: Parser a -> Parser a
lexeme = L.lexeme sc
symbol :: String -> Parser String
symbol = L.symbol sc
-- null ํ์
jsonNull :: Parser JsonValue
jsonNull = JsonNull <$ symbol "null"
-- bool ํ์
jsonBool :: Parser JsonValue
jsonBool = JsonBool True <$ symbol "true"
<|> JsonBool False <$ symbol "false"
-- ์ซ์ ํ์
jsonNumber :: Parser JsonValue
jsonNumber = JsonNumber <$> lexeme L.float
<|> JsonNumber . fromIntegral <$> lexeme L.decimal
-- ๋ฌธ์์ด ํ์ (์ด์ค์ผ์ดํ ์ฒ๋ฆฌ ํฌํจ)
jsonString :: Parser JsonValue
jsonString = JsonString <$> lexeme stringLiteral
stringLiteral :: Parser String
stringLiteral = char '"' *> manyTill L.charLiteral (char '"')
-- ๋ฐฐ์ด ํ์
jsonArray :: Parser JsonValue
jsonArray = JsonArray <$>
between (symbol "[") (symbol "]")
(jsonValue `sepBy` symbol ",")
-- ๊ฐ์ฒด ํ์
jsonObject :: Parser JsonValue
jsonObject = JsonObject . Map.fromList <$>
between (symbol "{") (symbol "}")
(keyValue `sepBy` symbol ",")
where
keyValue = do
key <- stringLiteral <* symbol ":"
val <- jsonValue
return (key, val)
-- ์ ์ฒด JSON ๊ฐ ํ์ (์ฌ๊ท!)
jsonValue :: Parser JsonValue
jsonValue = lexeme $
jsonNull
<|> jsonBool
<|> jsonNumber
<|> jsonString
<|> jsonArray
<|> jsonObject
-- ํ์ฑ ์คํ
parseJson :: String -> Either (ParseErrorBundle String Void) JsonValue
parseJson = parse (sc *> jsonValue <* eof) ""
์ค์ ๋ก ์จ๋ณด๋ฉด:
Haskell - JSON ํ์ ์คํ-- ๊ฐ๋จํ JSON
parseJson "null" -- Right JsonNull
parseJson "true" -- Right (JsonBool True)
parseJson "42" -- Right (JsonNumber 42.0)
parseJson "\"hello\"" -- Right (JsonString "hello")
-- ๋ฐฐ์ด
parseJson "[1, 2, 3]"
-- Right (JsonArray [JsonNumber 1.0, JsonNumber 2.0, JsonNumber 3.0])
-- ๊ฐ์ฒด
parseJson "{\"name\": \"Alice\", \"age\": 30}"
-- Right (JsonObject (fromList [("age", JsonNumber 30.0),
-- ("name", JsonString "Alice")]))
-- ์ค์ฒฉ ๊ตฌ์กฐ
parseJson "{\"data\": [1, {\"x\": true}, null]}"
-- Right (JsonObject ...)
jsonValue๊ฐ jsonArray์ jsonObject๋ฅผ ์ฐธ์กฐํ๊ณ , ๊ทธ ์์์ ๋ค์ jsonValue๋ฅผ ์ฐธ์กฐํด. ์ด๋ฐ ์ํธ ์ฌ๊ท๊ฐ Haskell์ ์ง์ฐ ํ๊ฐ ๋๋ถ์ ์์ฐ์ค๋ฝ๊ฒ ๋์ํด. ๋ค๋ฅธ ์ธ์ด์์๋ ์ด๋ฐ ์ฌ๊ท ํ์ ์ ์๊ฐ ๊น๋ค๋ก์ธ ์ ์์ด!
ํ์๋ฅผ ๋ง๋ค ๋ ์๋ฌ ์ฒ๋ฆฌ๋ ์ ๋ง ์ค์ํด. ์ฌ์ฉ์๊ฐ ์๋ชป๋ ์ ๋ ฅ์ ๋ฃ์์ ๋ "ํ์ฑ ์คํจ"๋ผ๊ณ ๋ง ํ๋ฉด ๋๋ฌด ๋ถ์น์ ํ์์ ใ ใ ใ
-- label: ์๋ฌ ๋ฉ์์ง์ ์ค๋ช
์ถ๊ฐ
jsonValue :: Parser JsonValue
jsonValue = label "JSON ๊ฐ" $
jsonNull
<|> jsonBool
<|> jsonNumber
<|> jsonString
<|> jsonArray
<|> jsonObject
-- <?> ์ฐ์ฐ์ (label์ ์ค์ ๋ฒ์ )
integer :: Parser Int
integer = L.decimal <?> "์ ์"
-- try: ํ์ฑ ์คํจ ์ ์
๋ ฅ์ ๋๋๋ฆฌ๊ธฐ
-- (๋ฐฑํธ๋ํน ํ์ฑํ)
jsonNumber :: Parser JsonValue
jsonNumber = JsonNumber <$>
(try (lexeme L.float) <|> fromIntegral <$> lexeme L.decimal)
-- ์ปค์คํ
์๋ฌ ๋ง๋ค๊ธฐ
data MyError = InvalidEscape Char
deriving (Show, Ord, Eq)
instance ShowErrorComponent MyError where
showErrorComponent (InvalidEscape c) =
"์๋ชป๋ ์ด์ค์ผ์ดํ ๋ฌธ์: \\" ++ [c]
-- ์๋ฌ ๋ฐ์์ํค๊ธฐ
parseEscape :: Parser Char
parseEscape = do
_ <- char '\\'
c <- anySingle
case c of
'n' -> return '\n'
't' -> return '\t'
'"' -> return '"'
'\\' -> return '\\'
_ -> customFailure (InvalidEscape c)
์ค์ ์ปดํ์ผ๋ฌ์ฒ๋ผ ์๋ฌ๊ฐ ๋๋ ๊ณ์ ํ์ฑ์ ์งํํ๊ณ ์ถ์ ๋:
Haskell - ์๋ฌ ๋ณต๊ตฌ-- withRecovery: ์๋ฌ ๋ฐ์ ์ ๋ณต๊ตฌ ์ ๋ต ์ ์ฉ
robustParser :: Parser [JsonValue]
robustParser = many $
withRecovery recover jsonValue
where
recover err = do
-- ์๋ฌ๋ฅผ ๊ธฐ๋กํ๊ณ ๋ค์ ์ผํ๋ ์ค๋ฐ๊ฟ๊น์ง ์คํต
registerParseError err
skipManyTill anySingle (void (char ',') <|> void newline <|> eof)
return JsonNull -- ์คํจํ ์๋ฆฌ์ null ๋ฐํ
ํ์ ์ปด๋น๋ค์ดํฐ๋ ํธ๋ฆฌํ์ง๋ง ์ฑ๋ฅ์ด ๊ฑฑ์ ๋ ์ ์์ด. ํนํ ํฐ ํ์ผ์ ํ์ฑํ ๋. ๋ช ๊ฐ์ง ์ต์ ํ ํ์ ์์๋ณด์!
์ฑ๋ฅ์ด ์ค์ํ๋ค๋ฉด Attoparsec์ ์จ. ByteString ๊ธฐ๋ฐ์ผ๋ก ๋์ํด์ ํจ์ฌ ๋น ๋ฅด๊ฑฐ๋ :
Haskell - Attoparsecimport Data.Attoparsec.ByteString.Char8
import Data.ByteString (ByteString)
-- Attoparsec์ API๊ฐ Megaparsec๊ณผ ๋น์ทํด
-- ํ์ง๋ง ByteString ๊ธฐ๋ฐ์ด๋ผ ํจ์ฌ ๋น ๋ฆ!
fastNumber :: Parser Int
fastNumber = decimal
fastJson :: Parser JsonValue
fastJson = skipSpace *> (
(JsonNull <$ string "null")
<|> (JsonBool True <$ string "true")
<|> (JsonBool False <$ string "false")
<|> (JsonNumber <$> double)
<|> (JsonString <$> stringLiteral)
<|> (JsonArray <$> arrayParser)
<|> (JsonObject <$> objectParser))
try๋ฅผ ๋จ๋ฐํ๋ฉด ๊ฐ์ ์
๋ ฅ์ ์ฌ๋ฌ ๋ฒ ํ์ฑํ๊ฒ ๋ผ์ ๋๋ ค์ ธ.ํด๊ฒฐ์ฑ : ์ฒซ ๊ธ์(lookahead)๋ก ์ด๋ค ํ์๋ฅผ ์ธ์ง ๋ฏธ๋ฆฌ ๊ฒฐ์ ํ๋ ์์ธก ํ์ฑ(Predictive Parsing)์ ํ์ฉํด!
-- ๋นํจ์จ์ : ๋ชจ๋ ๊ฒฝ์ฐ์ try ์ฌ์ฉ
badJsonValue :: Parser JsonValue
badJsonValue =
try jsonNull
<|> try jsonBool
<|> try jsonNumber
<|> try jsonString
<|> try jsonArray
<|> try jsonObject
-- ํจ์จ์ : ์ฒซ ๊ธ์๋ก ๋ถ๊ธฐ
goodJsonValue :: Parser JsonValue
goodJsonValue = do
c <- lookAhead anySingle
case c of
'n' -> jsonNull
't' -> jsonBool
'f' -> jsonBool
'"' -> jsonString
'[' -> jsonArray
'{' -> jsonObject
_ -> jsonNumber -- ์ซ์๋ '-'๋ก ์์
-- ํฐ ํ์ผ์ ํ ๋ฒ์ ๋ฉ๋ชจ๋ฆฌ์ ์ฌ๋ฆฌ์ง ์๊ณ ์คํธ๋ฆฌ๋ฐ์ผ๋ก ํ์ฑ
import qualified Data.Attoparsec.ByteString as A
import qualified Data.ByteString as BS
streamParse :: FilePath -> IO [JsonValue]
streamParse path = do
content <- BS.readFile path
case A.parseOnly (many fastJson) content of
Left err -> error err
Right vals -> return vals
ํ์ ์ปด๋น๋ค์ดํฐ๊ฐ ์ค์ ๋ก ์ด๋์ ์ฐ์ด๋์ง ์์๋ณด์. ์๊ฐ๋ณด๋ค ์์ฒญ ๋ง์ ๊ณณ์์ ์ฐ์ฌ!
- 1 ํ๋ก๊ทธ๋๋ฐ ์ธ์ด ๊ตฌํ: GHC(Haskell ์ปดํ์ผ๋ฌ) ์์ฒด๊ฐ ํ์ ์ปด๋น๋ค์ดํฐ ์ฌ์ฉ
- 2 ์ค์ ํ์ผ ํ์ฑ: YAML, TOML, INI ํ์ผ ํ์
- 3 ์ฟผ๋ฆฌ ์ธ์ด: SQL ํ์, GraphQL ํ์
- 4 ๋งํฌ์ ์ธ์ด: Markdown, HTML, XML ํ์
- 5 ํ๋กํ ์ฝ ํ์ฑ: HTTP ํค๋, ์ด๋ฉ์ผ ํค๋ ํ์ฑ
- 6 DSL(๋๋ฉ์ธ ํนํ ์ธ์ด): ๋น์ฆ๋์ค ๊ท์น ์ธ์ด, ํ ํ๋ฆฟ ์ธ์ด
- 7 ๋ฐ์ดํฐ ๋ณํ: CSV, ๋ก๊ทธ ํ์ผ ํ์ฑ
data MarkdownBlock
= Heading Int String -- # ์ ๋ชฉ
| Paragraph String -- ์ผ๋ฐ ๋ฌธ๋จ
| CodeBlock String String -- ์ฝ๋ ๋ธ๋ก (์ธ์ด, ๋ด์ฉ)
| BulletList [String] -- ๋ชฉ๋ก
deriving (Show)
-- ์ ๋ชฉ ํ์ (# ~ ######)
heading :: Parser MarkdownBlock
heading = do
hashes <- some (char '#')
_ <- char ' '
title <- manyTill anySingle newline
return $ Heading (length hashes) title
-- ์ฝ๋ ๋ธ๋ก ํ์
codeBlock :: Parser MarkdownBlock
codeBlock = do
_ <- string "```"
lang <- manyTill anySingle newline
code <- manyTill anySingle (string "```")
_ <- newline
return $ CodeBlock lang code
-- ๋ชฉ๋ก ํ์
bulletList :: Parser MarkdownBlock
bulletList = BulletList <$> some bulletItem
where
bulletItem = do
_ <- char '-' <|> char '*'
_ <- char ' '
item <- manyTill anySingle newline
return item
-- ์ ์ฒด ๋งํฌ๋ค์ด ํ์
markdown :: Parser [MarkdownBlock]
markdown = many $
try heading
<|> try codeBlock
<|> try bulletList
<|> paragraph
ํ์ ์ปด๋น๋ค์ดํฐ๊ฐ ํญ์ ์ต์ ์ ์๋์ผ. ์ํฉ์ ๋ฐ๋ผ ๋ค๋ฅธ ๋ฐฉ๋ฒ์ด ๋ ๋์ ์๋ ์์ด. ๋น๊ตํด๋ณด์!
| ๋ฐฉ๋ฒ | ์ฅ์ | ๋จ์ | ์ ํฉํ ์ํฉ |
|---|---|---|---|
| ํ์ ์ปด๋น๋ค์ดํฐ | ์ฝ๋ = ๋ฌธ๋ฒ, ์ ์ง๋ณด์ ์ฌ์, ํ์ ์์ | ์ฑ๋ฅ์ด ํ์ ์ ๋๋ ์ดํฐ๋ณด๋ค ๋ฎ์ ์ ์์ | ๋ณต์กํ ๋ฌธ๋ฒ, ๋น ๋ฅธ ๊ฐ๋ฐ |
| ํ์ ์ ๋๋ ์ดํฐ (ANTLR, yacc) | ์ฑ๋ฅ ์ต์ ํ, ๋๊ท๋ชจ ์ธ์ด์ ์ ํฉ | ๋ณ๋ ๋๊ตฌ ํ์, ํ์ต ๊ณก์ | ํ๋ก๋์ ์ปดํ์ผ๋ฌ |
| ์์ผ๋ก ์ง ์ฌ๊ท ํ๊ฐ | ์ต๊ณ ์ฑ๋ฅ, ์์ ํ ์ ์ด | ์ฝ๋ ๋ง์, ์ ์ง๋ณด์ ์ด๋ ค์ | ์ฑ๋ฅ ๊ทนํ ์ต์ ํ |
| ์ ๊ท์ | ๊ฐ๋จํ ํจํด์ ๋น ๋ฆ | ์ค์ฒฉ ๊ตฌ์กฐ ์ฒ๋ฆฌ ๋ถ๊ฐ | ๋จ์ ํ ์คํธ ๋งค์นญ |
- ํ์๋ค์ด ๋ฌธ๋ฒ์ ์ดํดํด์ผ ํ ๋ (์ฝ๋๊ฐ ๋ฌธ๋ฒ ๋ช ์ธ์ฒ๋ผ ์ฝํ๋๊น)
- ๋น ๋ฅธ ํ๋กํ ํ์ดํ์ด ํ์ํ ๋
- Haskell์ด๋ Scala, F# ๊ฐ์ ํจ์ํ ์ธ์ด๋ฅผ ์ธ ๋
ํ์์ ํฌํ ํ์ ์ ์ ์ฉํ๋ฉด ์ปดํ์ผ ํ์์ ๋ ๋ง์ ์ค๋ฅ๋ฅผ ์ก์ ์ ์์ด:
Haskell - ํฌํ ํ์-- ํ์๊ฐ ๊ณต๋ฐฑ์ ์ฒ๋ฆฌํ๋์ง ํ์
์ผ๋ก ํํ
data Trimmed
data Untrimmed
newtype Parser s a = Parser { runParser :: String -> Maybe (a, String) }
-- ๊ณต๋ฐฑ ์ฒ๋ฆฌ๋ ํ์๋ง ์กฐํฉ ๊ฐ๋ฅํ๋๋ก ์ ํ
combine :: Parser Trimmed a -> Parser Trimmed b -> Parser Trimmed (a, b)
combine pa pb = ...
-- ๊ณต๋ฐฑ ์ฒ๋ฆฌ ํจ์
trim :: Parser Untrimmed a -> Parser Trimmed a
trim (Parser p) = Parser $ \input ->
p (dropWhile isSpace input)
-- Megaparsec์ ์คํธ๋ฆผ ํ์
์ ์ถ์ํํด์
-- ๋ฌธ์์ด๋ฟ๋ง ์๋๋ผ ํ ํฐ ์คํธ๋ฆผ๋ ํ์ฑ ๊ฐ๋ฅ!
type TokenParser = Parsec Void [Token]
data Token
= TNumber Int
| TPlus
| TMinus
| TLParen
| TRParen
deriving (Show, Eq, Ord)
-- ํ ํฐ ์คํธ๋ฆผ์ ํ์ฑํ๋ ํ์
tokenExpr :: TokenParser Int
tokenExpr = ...
-- ์ด๋ ๊ฒ ํ๋ฉด ๋ ์ + ํ์๋ฅผ ๋ถ๋ฆฌํ ์ ์์ด
-- ๋ ์: String -> [Token]
-- ํ์: [Token] -> AST
์๋ํฐ๋ IDE์ฒ๋ผ ์ค์๊ฐ์ผ๋ก ํ์ฑํด์ผ ํ ๋๋ ์ฆ๋ถ ํ์ฑ์ด ํ์ํด. Attoparsec์ ์ด๋ฅผ ์ง์ํด:
Haskell - ์ฆ๋ถ ํ์ฑimport qualified Data.Attoparsec.ByteString as A
-- ์ฆ๋ถ ํ์ฑ: ๋ฐ์ดํฐ๋ฅผ ์กฐ๊ธ์ฉ ๋ฐ์์ ํ์ฑ
incrementalParse :: IO ()
incrementalParse = do
let initialResult = A.parse jsonValue ""
-- ๋ฐ์ดํฐ๋ฅผ ์กฐ๊ธ์ฉ ํผ๋
let result1 = A.feed initialResult "{\"key\":"
let result2 = A.feed result1 "\"value\"}"
-- ํ์ฑ ์๋ฃ
case A.feed result2 "" of
A.Done _ val -> print val
A.Fail _ _ err -> putStrLn $ "์๋ฌ: " ++ err
A.Partial _ -> putStrLn "๋ฐ์ดํฐ ๋ถ์กฑ"
์:
expr ::= expr '+' term | term ์ด๋ฐ ๋ฌธ๋ฒ์ ๋ฌดํ ๋ฃจํ์ ๋น ์ ธ!chainl1 ๊ฐ์ ์ปด๋น๋ค์ดํฐ๋ฅผ ์จ์ ์ข์ฌ๊ท๋ฅผ ์ฐ์ฌ๊ท๋ก ๋ณํํด์ผ ํด.
ํ์ ์ปด๋น๋ค์ดํฐ๋ฅผ ๋ง์คํฐํ๊ณ ์ถ๋ค๋ฉด ์ด ์์๋ก ๊ณต๋ถํด๋ด!
- 1 ๊ณ์ฐ๊ธฐ ํ์: ์ฌ์น์ฐ์ฐ + ๊ดํธ + ๋ณ์ ์ง์ (์ด ๊ธ์์ ๋ค๋ฃฌ ๋ด์ฉ!)
- 2 CSV ํ์: ์ผํ, ๋ฐ์ดํ, ์ด์ค์ผ์ดํ ์ฒ๋ฆฌ
- 3 INI ํ์ผ ํ์: [์น์ ], ํค=๊ฐ ํ์
- 4 ๊ฐ๋จํ Lisp ์ธํฐํ๋ฆฌํฐ: S-ํํ์ ํ์ฑ + ํ๊ฐ
- 5 SQL SELECT ํ์: SELECT, FROM, WHERE, ORDER BY
- 6 ๋งํฌ๋ค์ด ํ์: ์ ๋ชฉ, ๊ตต๊ฒ, ๊ธฐ์ธ์, ๋งํฌ, ์ฝ๋ ๋ธ๋ก
- 7 ๋ฏธ๋ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด: ๋ณ์, ํจ์, ์กฐ๊ฑด๋ฌธ, ๋ฐ๋ณต๋ฌธ
์, ์ฌ๊ธฐ๊น์ง ์์ผ๋ฉด ํ์ ์ปด๋น๋ค์ดํฐ์ ํต์ฌ์ ๋ค ์ดํดํ ๊ฑฐ์ผ! ๋ง์ง๋ง์ผ๋ก ์ด ๊ธฐ๋ฒ์ ์ฒ ํ์ ์๋ฏธ๋ฅผ ์ง์ด๋ณด์.
์ด๊ฑด ํจ์ํ ํ๋ก๊ทธ๋๋ฐ์ ํต์ฌ ์ฒ ํ์ ๋ณด์ฌ์ฃผ๋ ์๋ฒฝํ ์์ ์ผ:
"์๊ณ ๋จ์ํ ๊ฒ๋ค์ ์กฐํฉํด์ ๋ณต์กํ ๊ฒ์ ๋ง๋ ๋ค."
satisfy ํ๋๋ก ์์ํด์, char, digit, many, choice๋ฅผ ๊ฑฐ์ณ,๊ฒฐ๊ตญ ์์ ํ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด ํ์๊น์ง ๋ง๋ค ์ ์์ด.
์ด๊ฒ ๋ฐ๋ก ํฉ์ฑ ๊ฐ๋ฅ์ฑ(Composability)์ ํ์ด์ผ.
Parser a = String -> Maybe (a, String)Functor ํ์ฑ ๊ฒฐ๊ณผ๋ฅผ ํจ์๋ก ๋ณํ
Applicative ์ฌ๋ฌ ํ์๋ฅผ ์์๋๋ก ์ ์ฉํ๊ณ ๊ฒฐ๊ณผ ์กฐํฉ
Monad ์ด์ ๊ฒฐ๊ณผ์ ๋ฐ๋ผ ๋์ ์ผ๋ก ๋ค์ ํ์ ๊ฒฐ์
Alternative ํ์ A ์คํจ ์ ํ์ B ์๋
many/some ๋ฐ๋ณต ํ์ฑ
between/sepBy ๊ตฌ์กฐ์ ํ์ฑ
Megaparsec ์ค๋ฌด์ฉ ๋ผ์ด๋ธ๋ฌ๋ฆฌ, ๊ฐ๋ ฅํ ์๋ฌ ๋ฉ์์ง
Attoparsec ์ฑ๋ฅ ์ต์ ํ์ฉ ๋ผ์ด๋ธ๋ฌ๋ฆฌ
ํ์ ์ปด๋น๋ค์ดํฐ๋ ์ฒ์์ ๋ฏ์ค์ด ๋ณด์ฌ๋, ํ ๋ฒ ์ตํ๋ฉด "์ด๊ฑธ ์ ์ด์ ์ผ ์์์ง?" ์ถ์ ๊ธฐ๋ฒ์ด์ผ. ํนํ Haskell์ ํ์ ์์คํ ๊ณผ ๋ง๋๋ฉด ์ง์ง ๊ฐ๋ ฅํ ๋๊ตฌ๊ฐ ๋ผ.
์ฌ๋ฅ๋ท์์ Haskell์ด๋ ํจ์ํ ํ๋ก๊ทธ๋๋ฐ ๊ด๋ จ ์ฌ๋ฅ์ ๊ฐ์ง ๋ถ๋ค์ ์ฐพ์๋ณด๋ฉด, ํ์ ์ปด๋น๋ค์ดํฐ๋ฅผ ์ง์ ๊ฐ๋ฅด์ณ์ค ์ ์๋ ์ ๋ฌธ๊ฐ๋ค๋ ๋ง์ด ์์ ๊ฑฐ์ผ. ํผ์ ๊ณต๋ถํ๋ค ๋งํ๋ฉด ์ ๋ฌธ๊ฐ์ ๋์์ ๋ฐ๋ ๊ฒ๋ ์ข์ ๋ฐฉ๋ฒ์ด์ผ! ๐ช
์, ์ด์ ์ง์ ์ฝ๋๋ฅผ ์ง๋ด. ์ด๋ก ๋ง ์ฝ์ด์๋ ์ ๋ ์ ๋ผ ใ
ใ
ใ
satisfy๋ถํฐ ์์ํด์ ํ๋์ฉ ์์๊ฐ๋ค ๋ณด๋ฉด ์ด๋์ ์์ ํ ํ์๋ฅผ ๋ง๋ค๊ณ ์๋ ์์ ์ ๋ฐ๊ฒฌํ๊ฒ ๋ ๊ฑฐ์ผ! ๐
๊ด๋ จ ํค์๋
๋๊ธ ์์ฑ
์ด ๊ธ์ ๋ํ ์ฌ๋ฌ๋ถ์ ์๊ฐ์ ๋ค๋ ค์ฃผ์ธ์
๋ก๊ทธ์ธ์ด ํ์ํฉ๋๋ค
๋๊ธ์ ์์ฑํ๋ ค๋ฉด ๋จผ์ ๋ก๊ทธ์ธํด์ฃผ์ธ์.
๋๊ธ 0
์ง์์ธ์ ์ฒ - ์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
- ์ ์๊ถ ๋ฐ ์์ ๊ถ: ๋ณธ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ๋ ์ AI ๊ธฐ์ ๋ก ์์ฑ๋์์ผ๋ฉฐ, ๋ํ๋ฏผ๊ตญ ์ ์๊ถ๋ฒ ๋ฐ ๊ตญ์ ์ ์๊ถ ํ์ฝ์ ์ํด ๋ณดํธ๋ฉ๋๋ค.
- AI ์์ฑ ์ปจํ ์ธ ์ ๋ฒ์ ์ง์: ๋ณธ AI ์์ฑ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ์ง์ ์ฐฝ์๋ฌผ๋ก ์ธ์ ๋๋ฉฐ, ๊ด๋ จ ๋ฒ๊ท์ ๋ฐ๋ผ ์ ์๊ถ ๋ณดํธ๋ฅผ ๋ฐ์ต๋๋ค.
- ์ฌ์ฉ ์ ํ: ์ฌ๋ฅ๋ท์ ๋ช ์์ ์๋ฉด ๋์ ์์ด ๋ณธ ์ปจํ ์ธ ๋ฅผ ๋ณต์ , ์์ , ๋ฐฐํฌ, ๋๋ ์์ ์ ์ผ๋ก ํ์ฉํ๋ ํ์๋ ์๊ฒฉํ ๊ธ์ง๋ฉ๋๋ค.
- ๋ฐ์ดํฐ ์์ง ๊ธ์ง: ๋ณธ ์ปจํ ์ธ ์ ๋ํ ๋ฌด๋จ ์คํฌ๋ํ, ํฌ๋กค๋ง, ๋ฐ ์๋ํ๋ ๋ฐ์ดํฐ ์์ง์ ๋ฒ์ ์ ์ฌ์ ๋์์ด ๋ฉ๋๋ค.
- AI ํ์ต ์ ํ: ์ฌ๋ฅ๋ท์ AI ์์ฑ ์ปจํ ์ธ ๋ฅผ ํ AI ๋ชจ๋ธ ํ์ต์ ๋ฌด๋จ ์ฌ์ฉํ๋ ํ์๋ ๊ธ์ง๋๋ฉฐ, ์ด๋ ์ง์ ์ฌ์ฐ๊ถ ์นจํด๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
์์ง ๋๊ธ์ด ์์ต๋๋ค.