Kombinierte Parser

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