module Parsimony.Combinator where
import Parsimony.Prim
import Parsimony.Error
import Parsimony.Pos
import Parsimony.Stream
import Control.Applicative hiding (many)
choice :: [Parser t a] -> Parser t a
choice ps = foldr (<|>) empty ps
option :: a -> Parser t a -> Parser t a
option x p = p <|> pure x
skip :: Parser t a -> Parser t ()
skip p = (p *> pure ()) <|> return ()
between :: Parser t open -> Parser t close
-> Parser t a -> Parser t a
between o c p = o *> p <* c
skipMany1 :: Parser t a -> Parser t ()
skipMany1 p = p *> skipMany p
many :: Parser t a -> Parser t [a]
many p = reverse <$> foldMany (flip (:)) [] p
many1 :: Parser t a -> Parser t [a]
many1 p = (:) <$> p <*> many p
sepBy :: Parser t a -> Parser t sep -> Parser t [a]
sepBy p sep = option [] (sepBy1 p sep)
sepBy1 :: Parser t a -> Parser t sep -> Parser t [a]
sepBy1 p sep = (:) <$> p <*> many (sep *> p)
endBy1,endBy :: Parser t a -> Parser t sep -> Parser t [a]
endBy1 p sep = many1 (p <* sep)
endBy p sep = many (p <* sep)
sepEndBy :: Parser t a -> Parser t sep -> Parser t [a]
sepEndBy p sep = option [] (sepEndBy1 p sep)
sepEndBy1 :: Parser t a -> Parser t sep -> Parser t [a]
sepEndBy1 p sep = do x <- p
reverse <$> foldManyWhile (flip (:)) [x] loopP
where
loopP = option Nothing (sep >> option Nothing (Just <$> p))
count :: Int -> Parser t a -> Parser t [a]
count n p = sequence (replicate n p)
anyToken :: Stream s t => Parser s t
anyToken = primParser getToken
eof :: Stream s t => Parser s ()
eof = notFollowedBy' showToken anyToken <?> "end of input"
notFollowedBy' :: (a -> String) -> Parser t a -> Parser t ()
notFollowedBy' sh p = skip (try p >>= unexpected . sh)
notFollowedBy :: Show a => Parser t a -> Parser t ()
notFollowedBy = notFollowedBy' show
manyTill :: Parser t a -> Parser t end -> Parser t [a]
manyTill p end = scan
where scan = (end *> return []) <|> ((:) <$> p <*> scan)
getInput :: Parser t t
getInput = stateInput <$> getState
setInput :: t -> Parser t ()
setInput i = updateState (\s -> s { stateInput = i })
updateInput :: (t -> t) -> Parser t ()
updateInput f = updateState (\s -> s { stateInput = f (stateInput s) })
getPosition :: Parser t SourcePos
getPosition = statePos <$> getState
setPosition :: SourcePos -> Parser t ()
setPosition i = updateState (\s -> s { statePos = i })
updatePosition :: (SourcePos -> SourcePos) -> Parser t ()
updatePosition f = updateState (\s -> s { statePos = f (statePos s)})
setState :: State t -> Parser t ()
setState s = updateState (\_ -> s)
infix 0 <?>
(<?>) :: Parser t a -> String -> Parser t a
p <?> l = labels p [l]
unexpected :: String -> Parser t a
unexpected x = parseError $ newErrorMessage $ UnExpect x
parseSource :: Parser t a
-> SourceName
-> t
-> Either ParseError a
parseSource p s i = case runParser p $ State i $ initialPos s of
Error err -> Left err
Ok a _ -> Right a
parse :: Parser t a
-> t
-> Either ParseError a
parse p = parseSource p ""