-----------------------------------------------------------------------------
-- |
-- Module      :  Text.ParserCombinators.HuttonMeijer
-- Copyright   :  Graham Hutton (University of Nottingham), Erik Meijer (University of Utrecht)
-- Licence     :  BSD
-- 
-- Maintainer  :  Malcolm Wallace <Malcolm.Wallace@cs.york.ac.uk>
-- Stability   :  Stable
-- Portability :  All
--
--                  A LIBRARY OF MONADIC PARSER COMBINATORS
-- 
--                               29th July 1996
-- 
--                  Graham Hutton               Erik Meijer
--             University of Nottingham    University of Utrecht
-- 
-- This Haskell script defines a library of parser combinators, and is
-- taken from sections 1-6 of our article "Monadic Parser Combinators".
-- Some changes to the library have been made in the move from Gofer
-- to Haskell:
-- 
--    * Do notation is used in place of monad comprehension notation;
-- 
--    * The parser datatype is defined using "newtype", to avoid the overhead
--      of tagging and untagging parsers with the P constructor.
-----------------------------------------------------------------------------


module Text.ParserCombinators.HuttonMeijer
   (Parser(..), item, first, papply, (+++), sat, {-tok,-} 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

---------------------------------------------------------
-- | The parser monad

newtype Parser a   = P ([Token] -> [(a,[Token])])

instance Functor Parser where
   -- map         :: (a -> b) -> (Parser a -> Parser b)
   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
return          = a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure

   -- >>=         :: Parser a -> (a -> Parser b) -> Parser b
   (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        :: String -> Parser a
   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 :: Parser a
mzero           = ([Token] -> [(a, [Token])]) -> Parser a
forall a. ([Token] -> [(a, [Token])]) -> Parser a
P (\[Token]
_ -> [])

   -- mplus       :: Parser a -> Parser a -> Parser a
   (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))

-- ------------------------------------------------------------
-- * Other primitive parser combinators
-- ------------------------------------------------------------

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

-- ------------------------------------------------------------
-- * Derived combinators
-- ------------------------------------------------------------

(+++)             :: 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}

--tok               :: Token -> Parser Token
--tok t              = do {x <- item; if t==snd x then return t else 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 []
--many p           = force (many1 p +++ 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}

-- ------------------------------------------------------------
-- * Useful parsers
-- ------------------------------------------------------------

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

-- ------------------------------------------------------------
-- * Lexical combinators
-- ------------------------------------------------------------

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 ()
--comment            = do {string "--"; many (sat (\x -> x /= '\n')); return ()}
--comment            = do 
--                       _ <- string "--"
--                       _ <- many (sat (\x -> x /= '\n'))
--                       return ()
comment :: Parser ()
comment            = 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}

-- ------------------------------------------------------------
-- * Token parsers
-- ------------------------------------------------------------

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})

------------------------------------------------------------------------------