Vorlesung: Praxis der Funktionalen Programmierung
| Index
Kombinierte Parser
Wir bauen uns nun einen Parserbaukasten.
Wir programmieren voll abstrakt,
d. h. wir sehen uns nie die Implementierung der Monade an.
module Parser_Combinators where
import Parser_Type
import Parser_Basic
-----------------------------------------------------
satisfy :: (a -> Bool) -> Parser a -> Parser a
satisfy b p = do
x <- p
guard (b x)
return x
match :: Char -> Parser Char
match x = satisfy (== x) item
blank :: Parser Char
blank = satisfy (`elem` " \t\n") item
letter :: Parser Char
letter = satisfy ( \ c -> ('A' <= c && c <= 'Z')
|| ('a' <= c && c <= 'z') ) item
digit :: Parser Char
digit = satisfy ( \ c -> '0' <= c && c <= '9' ) item
symbol :: Parser Char
symbol = satisfy (`elem` "+-*/:%$&|<>=,;.!?") item
-----------------------------------------------------
many1 :: Parser a -> Parser [a]
many1 p = do x <- p
xs <- many p
return $ x : xs
many :: Parser a -> Parser [a]
many p = many1 p
`plus` return []
white :: Parser ()
white = do cs <- many blank
return ()
unWhite :: Parser a -> Parser a
unWhite p = do white; p
final :: Parser a -> Parser a
final p = do x <- p; unWhite eof; return x
natural :: Parser Integer
natural = unWhite $ do
cs <- many1 digit
return $ foldl (\ x c -> 10 * x + fromInt (ord c - ord '0')) 0 cs
name :: Parser String
name = unWhite $ do
c <- letter
cs <- many (letter `plus` digit)
return $ c : cs
keyword :: String -> Parser ()
keyword w = do
n <- name
guard $ n == w
oper :: Parser String
oper = unWhite $ many1 symbol
operator :: String -> Parser ()
operator r = do
o <- oper
guard $ o == r
-----------------------------------------------------
sepBy :: Parser s -> Parser a -> Parser [a]
sepBy s p = do x <- p
xs <- many $ do s; p
return $ x : xs
-----------------------------------------------------
klammer :: Char -> Char -> Parser a -> Parser a
klammer auf zu p = do
unWhite $ match auf
x <- p
unWhite $ match zu
return x
paren :: Parser a -> Parser a
paren = klammer '(' ')'
brace :: Parser a -> Parser a
brace = klammer '{' '}'
bracket :: Parser a -> Parser a
bracket = klammer '[' ']'
-----------------------------------------------------
parse_final :: Parser a -> String -> Either String a
parse_final = parse . final
http://www.informatik.uni-leipzig.de/~joe/
mailto:joe@informatik.uni-leipzig.de