module Text.ParserCombinators.HuttonMeijer
(Parser(..), item, first, papply, (+++), sat, many, many1,
sepby, sepby1, chainl,
chainl1, chainr, chainr1, ops, bracket, char, digit, lower, upper,
letter, alphanum, string, ident, nat, int, spaces, comment, junk,
skip, token, natural, integer, symbol, identifier) where
import Data.Char
import Control.Applicative ( Applicative(pure,(<*>)), Alternative(empty,(<|>)) )
import Control.Monad
import qualified Control.Monad.Fail as Fail
infixr 5 +++
type Token = Char
newtype Parser a = P ([Token] -> [(a,[Token])])
instance Functor Parser where
fmap :: (a -> b) -> Parser a -> Parser b
fmap a -> b
f (P [Token] -> [(a, [Token])]
p) = ([Token] -> [(b, [Token])]) -> Parser b
forall a. ([Token] -> [(a, [Token])]) -> Parser a
P (\[Token]
inp -> [(a -> b
f a
v, [Token]
out) | (a
v,[Token]
out) <- [Token] -> [(a, [Token])]
p [Token]
inp])
instance Applicative Parser where
pure :: a -> Parser a
pure a
v = ([Token] -> [(a, [Token])]) -> Parser a
forall a. ([Token] -> [(a, [Token])]) -> Parser a
P (\[Token]
inp -> [(a
v,[Token]
inp)])
<*> :: Parser (a -> b) -> Parser a -> Parser b
(<*>) = Parser (a -> b) -> Parser a -> Parser b
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
ap
instance Monad Parser where
return :: a -> Parser a
return = a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
(P [Token] -> [(a, [Token])]
p) >>= :: Parser a -> (a -> Parser b) -> Parser b
>>= a -> Parser b
f = ([Token] -> [(b, [Token])]) -> Parser b
forall a. ([Token] -> [(a, [Token])]) -> Parser a
P (\[Token]
inp -> [[(b, [Token])]] -> [(b, [Token])]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [Parser b -> [Token] -> [(b, [Token])]
forall a. Parser a -> [Token] -> [(a, [Token])]
papply (a -> Parser b
f a
v) [Token]
out | (a
v,[Token]
out) <- [Token] -> [(a, [Token])]
p [Token]
inp])
#if !MIN_VERSION_base(4,13,0)
fail = Fail.fail
#endif
instance Fail.MonadFail Parser where
fail :: [Token] -> Parser a
fail [Token]
_ = ([Token] -> [(a, [Token])]) -> Parser a
forall a. ([Token] -> [(a, [Token])]) -> Parser a
P (\[Token]
_ -> [])
instance Alternative Parser where
empty :: Parser a
empty = Parser a
forall (m :: * -> *) a. MonadPlus m => m a
mzero
<|> :: Parser a -> Parser a -> Parser a
(<|>) = Parser a -> Parser a -> Parser a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
mplus
instance MonadPlus Parser where
mzero :: Parser a
mzero = ([Token] -> [(a, [Token])]) -> Parser a
forall a. ([Token] -> [(a, [Token])]) -> Parser a
P (\[Token]
_ -> [])
(P [Token] -> [(a, [Token])]
p) mplus :: Parser a -> Parser a -> Parser a
`mplus` (P [Token] -> [(a, [Token])]
q) = ([Token] -> [(a, [Token])]) -> Parser a
forall a. ([Token] -> [(a, [Token])]) -> Parser a
P (\[Token]
inp -> ([Token] -> [(a, [Token])]
p [Token]
inp [(a, [Token])] -> [(a, [Token])] -> [(a, [Token])]
forall a. [a] -> [a] -> [a]
++ [Token] -> [(a, [Token])]
q [Token]
inp))
item :: Parser Token
item :: Parser Token
item = ([Token] -> [(Token, [Token])]) -> Parser Token
forall a. ([Token] -> [(a, [Token])]) -> Parser a
P (\[Token]
inp -> case [Token]
inp of
[] -> []
(Token
x:[Token]
xs) -> [(Token
x,[Token]
xs)])
first :: Parser a -> Parser a
first :: Parser a -> Parser a
first (P [Token] -> [(a, [Token])]
p) = ([Token] -> [(a, [Token])]) -> Parser a
forall a. ([Token] -> [(a, [Token])]) -> Parser a
P (\[Token]
inp -> case [Token] -> [(a, [Token])]
p [Token]
inp of
[] -> []
((a, [Token])
x:[(a, [Token])]
_) -> [(a, [Token])
x])
papply :: Parser a -> [Token] -> [(a,[Token])]
papply :: Parser a -> [Token] -> [(a, [Token])]
papply (P [Token] -> [(a, [Token])]
p) [Token]
inp = [Token] -> [(a, [Token])]
p [Token]
inp
(+++) :: Parser a -> Parser a -> Parser a
Parser a
p +++ :: Parser a -> Parser a -> Parser a
+++ Parser a
q = Parser a -> Parser a
forall a. Parser a -> Parser a
first (Parser a
p Parser a -> Parser a -> Parser a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus` Parser a
q)
sat :: (Token -> Bool) -> Parser Token
sat :: (Token -> Bool) -> Parser Token
sat Token -> Bool
p = do {Token
x <- Parser Token
item; if Token -> Bool
p Token
x then Token -> Parser Token
forall (m :: * -> *) a. Monad m => a -> m a
return Token
x else Parser Token
forall (m :: * -> *) a. MonadPlus m => m a
mzero}
many :: Parser a -> Parser [a]
many :: Parser a -> Parser [a]
many Parser a
p = Parser a -> Parser [a]
forall a. Parser a -> Parser [a]
many1 Parser a
p Parser [a] -> Parser [a] -> Parser [a]
forall a. Parser a -> Parser a -> Parser a
+++ [a] -> Parser [a]
forall (m :: * -> *) a. Monad m => a -> m a
return []
many1 :: Parser a -> Parser [a]
many1 :: Parser a -> Parser [a]
many1 Parser a
p = do {a
x <- Parser a
p; [a]
xs <- Parser a -> Parser [a]
forall a. Parser a -> Parser [a]
many Parser a
p; [a] -> Parser [a]
forall (m :: * -> *) a. Monad m => a -> m a
return (a
xa -> [a] -> [a]
forall a. a -> [a] -> [a]
:[a]
xs)}
sepby :: Parser a -> Parser b -> Parser [a]
Parser a
p sepby :: Parser a -> Parser b -> Parser [a]
`sepby` Parser b
sep = (Parser a
p Parser a -> Parser b -> Parser [a]
forall a b. Parser a -> Parser b -> Parser [a]
`sepby1` Parser b
sep) Parser [a] -> Parser [a] -> Parser [a]
forall a. Parser a -> Parser a -> Parser a
+++ [a] -> Parser [a]
forall (m :: * -> *) a. Monad m => a -> m a
return []
sepby1 :: Parser a -> Parser b -> Parser [a]
Parser a
p sepby1 :: Parser a -> Parser b -> Parser [a]
`sepby1` Parser b
sep = do {a
x <- Parser a
p; [a]
xs <- Parser a -> Parser [a]
forall a. Parser a -> Parser [a]
many (do {Parser b
sep; Parser a
p}); [a] -> Parser [a]
forall (m :: * -> *) a. Monad m => a -> m a
return (a
xa -> [a] -> [a]
forall a. a -> [a] -> [a]
:[a]
xs)}
chainl :: Parser a -> Parser (a -> a -> a) -> a -> Parser a
chainl :: Parser a -> Parser (a -> a -> a) -> a -> Parser a
chainl Parser a
p Parser (a -> a -> a)
op a
v = (Parser a
p Parser a -> Parser (a -> a -> a) -> Parser a
forall a. Parser a -> Parser (a -> a -> a) -> Parser a
`chainl1` Parser (a -> a -> a)
op) Parser a -> Parser a -> Parser a
forall a. Parser a -> Parser a -> Parser a
+++ a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return a
v
chainl1 :: Parser a -> Parser (a -> a -> a) -> Parser a
Parser a
p chainl1 :: Parser a -> Parser (a -> a -> a) -> Parser a
`chainl1` Parser (a -> a -> a)
op = do {a
x <- Parser a
p; a -> Parser a
rest a
x}
where
rest :: a -> Parser a
rest a
x = do {a -> a -> a
f <- Parser (a -> a -> a)
op; a
y <- Parser a
p; a -> Parser a
rest (a -> a -> a
f a
x a
y)}
Parser a -> Parser a -> Parser a
forall a. Parser a -> Parser a -> Parser a
+++ a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return a
x
chainr :: Parser a -> Parser (a -> a -> a) -> a -> Parser a
chainr :: Parser a -> Parser (a -> a -> a) -> a -> Parser a
chainr Parser a
p Parser (a -> a -> a)
op a
v = (Parser a
p Parser a -> Parser (a -> a -> a) -> Parser a
forall a. Parser a -> Parser (a -> a -> a) -> Parser a
`chainr1` Parser (a -> a -> a)
op) Parser a -> Parser a -> Parser a
forall a. Parser a -> Parser a -> Parser a
+++ a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return a
v
chainr1 :: Parser a -> Parser (a -> a -> a) -> Parser a
Parser a
p chainr1 :: Parser a -> Parser (a -> a -> a) -> Parser a
`chainr1` Parser (a -> a -> a)
op = do {a
x <- Parser a
p; a -> Parser a
rest a
x}
where
rest :: a -> Parser a
rest a
x = do {a -> a -> a
f <- Parser (a -> a -> a)
op; a
y <- Parser a
p Parser a -> Parser (a -> a -> a) -> Parser a
forall a. Parser a -> Parser (a -> a -> a) -> Parser a
`chainr1` Parser (a -> a -> a)
op; a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> a -> a
f a
x a
y)}
Parser a -> Parser a -> Parser a
forall a. Parser a -> Parser a -> Parser a
+++ a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return a
x
ops :: [(Parser a, b)] -> Parser b
ops :: [(Parser a, b)] -> Parser b
ops [(Parser a, b)]
xs = (Parser b -> Parser b -> Parser b) -> [Parser b] -> Parser b
forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
foldr1 Parser b -> Parser b -> Parser b
forall a. Parser a -> Parser a -> Parser a
(+++) [do {Parser a
p; b -> Parser b
forall (m :: * -> *) a. Monad m => a -> m a
return b
op} | (Parser a
p,b
op) <- [(Parser a, b)]
xs]
bracket :: Parser a -> Parser b -> Parser c -> Parser b
bracket :: Parser a -> Parser b -> Parser c -> Parser b
bracket Parser a
open Parser b
p Parser c
close = do {Parser a
open; b
x <- Parser b
p; Parser c
close; b -> Parser b
forall (m :: * -> *) a. Monad m => a -> m a
return b
x}
char :: Char -> Parser Char
char :: Token -> Parser Token
char Token
x = (Token -> Bool) -> Parser Token
sat (\Token
y -> Token
x Token -> Token -> Bool
forall a. Eq a => a -> a -> Bool
== Token
y)
digit :: Parser Char
digit :: Parser Token
digit = (Token -> Bool) -> Parser Token
sat Token -> Bool
isDigit
lower :: Parser Char
lower :: Parser Token
lower = (Token -> Bool) -> Parser Token
sat Token -> Bool
isLower
upper :: Parser Char
upper :: Parser Token
upper = (Token -> Bool) -> Parser Token
sat Token -> Bool
isUpper
letter :: Parser Char
letter :: Parser Token
letter = (Token -> Bool) -> Parser Token
sat Token -> Bool
isAlpha
alphanum :: Parser Char
alphanum :: Parser Token
alphanum = (Token -> Bool) -> Parser Token
sat Token -> Bool
isAlphaNum Parser Token -> Parser Token -> Parser Token
forall a. Parser a -> Parser a -> Parser a
+++ Token -> Parser Token
char Token
'_'
string :: String -> Parser String
string :: [Token] -> Parser [Token]
string [Token]
"" = [Token] -> Parser [Token]
forall (m :: * -> *) a. Monad m => a -> m a
return [Token]
""
string (Token
x:[Token]
xs) = do {Token -> Parser Token
char Token
x; [Token] -> Parser [Token]
string [Token]
xs; [Token] -> Parser [Token]
forall (m :: * -> *) a. Monad m => a -> m a
return (Token
xToken -> [Token] -> [Token]
forall a. a -> [a] -> [a]
:[Token]
xs)}
ident :: Parser String
ident :: Parser [Token]
ident = do {Token
x <- Parser Token
lower; [Token]
xs <- Parser Token -> Parser [Token]
forall a. Parser a -> Parser [a]
many Parser Token
alphanum; [Token] -> Parser [Token]
forall (m :: * -> *) a. Monad m => a -> m a
return (Token
xToken -> [Token] -> [Token]
forall a. a -> [a] -> [a]
:[Token]
xs)}
nat :: Parser Int
nat :: Parser Int
nat = do {Token
x <- Parser Token
digit; Int -> Parser Int
forall (m :: * -> *) a. Monad m => a -> m a
return (Token -> Int
forall a. Enum a => a -> Int
fromEnum Token
x Int -> Int -> Int
forall a. Num a => a -> a -> a
- Token -> Int
forall a. Enum a => a -> Int
fromEnum Token
'0')} Parser Int -> Parser (Int -> Int -> Int) -> Parser Int
forall a. Parser a -> Parser (a -> a -> a) -> Parser a
`chainl1` (Int -> Int -> Int) -> Parser (Int -> Int -> Int)
forall (m :: * -> *) a. Monad m => a -> m a
return Int -> Int -> Int
forall a. Num a => a -> a -> a
op
where
a
m op :: a -> a -> a
`op` a
n = a
10a -> a -> a
forall a. Num a => a -> a -> a
*a
m a -> a -> a
forall a. Num a => a -> a -> a
+ a
n
int :: Parser Int
int :: Parser Int
int = do {Token -> Parser Token
char Token
'-'; Int
n <- Parser Int
nat; Int -> Parser Int
forall (m :: * -> *) a. Monad m => a -> m a
return (-Int
n)} Parser Int -> Parser Int -> Parser Int
forall a. Parser a -> Parser a -> Parser a
+++ Parser Int
nat
spaces :: Parser ()
spaces :: Parser ()
spaces = do {Parser Token -> Parser [Token]
forall a. Parser a -> Parser [a]
many1 ((Token -> Bool) -> Parser Token
sat Token -> Bool
isSpace); () -> Parser ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()}
comment :: Parser ()
= do
Parser [Token]
-> Parser [Token] -> Parser [Token] -> Parser [Token]
forall a b c. Parser a -> Parser b -> Parser c -> Parser b
bracket ([Token] -> Parser [Token]
string [Token]
"/*") (Parser Token -> Parser [Token]
forall a. Parser a -> Parser [a]
many Parser Token
item) ([Token] -> Parser [Token]
string [Token]
"*/")
() -> Parser ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
junk :: Parser ()
junk :: Parser ()
junk = do {Parser () -> Parser [()]
forall a. Parser a -> Parser [a]
many (Parser ()
spaces Parser () -> Parser () -> Parser ()
forall a. Parser a -> Parser a -> Parser a
+++ Parser ()
comment); () -> Parser ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()}
skip :: Parser a -> Parser a
skip :: Parser a -> Parser a
skip Parser a
p = do {Parser ()
junk; Parser a
p}
token :: Parser a -> Parser a
token :: Parser a -> Parser a
token Parser a
p = do {a
v <- Parser a
p; Parser ()
junk; a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return a
v}
natural :: Parser Int
natural :: Parser Int
natural = Parser Int -> Parser Int
forall a. Parser a -> Parser a
token Parser Int
nat
integer :: Parser Int
integer :: Parser Int
integer = Parser Int -> Parser Int
forall a. Parser a -> Parser a
token Parser Int
int
symbol :: String -> Parser String
symbol :: [Token] -> Parser [Token]
symbol [Token]
xs = Parser [Token] -> Parser [Token]
forall a. Parser a -> Parser a
token ([Token] -> Parser [Token]
string [Token]
xs)
identifier :: [String] -> Parser String
identifier :: [[Token]] -> Parser [Token]
identifier [[Token]]
ks = Parser [Token] -> Parser [Token]
forall a. Parser a -> Parser a
token (do {[Token]
x <- Parser [Token]
ident;
if Bool -> Bool
not ([Token] -> [[Token]] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
elem [Token]
x [[Token]]
ks) then [Token] -> Parser [Token]
forall (m :: * -> *) a. Monad m => a -> m a
return [Token]
x
else [Token] -> Parser [Token]
forall (m :: * -> *) a. Monad m => a -> m a
return [Token]
forall (m :: * -> *) a. MonadPlus m => m a
mzero})