Safe Haskell | Safe-Inferred |
---|---|
Language | Haskell2010 |
Extend a monad with the ability to parse symbol sequences
Synopsis
- newtype ParserT s m a = ParserT ([s] -> m (Either ParseError (a, [s])))
- data ParseError
- runParserT :: ParserT s m a -> [s] -> m (Either ParseError (a, [s]))
- sat :: (Applicative m, Show s) => (s -> Bool) -> ParserT s m s
- item :: (Applicative m, Show s) => ParserT s m s
- symbol :: (Applicative m, Show s, Eq s) => s -> ParserT s m s
- string :: (Monad m, Traversable t, Show s, Eq s) => t s -> ParserT s m (t s)
- oneOf :: (Applicative m, Foldable t, Show s, Eq s) => t s -> ParserT s m s
- noneOf :: (Applicative m, Foldable t, Show s, Eq s) => t s -> ParserT s m s
- eof :: (Monad m, Show s) => ParserT s m ()
- sepBy :: (Monad m, Eq s) => ParserT s m a -> ParserT s m b -> ParserT s m [a]
- sepBy1 :: (Monad m, Eq s) => ParserT s m a -> ParserT s m b -> ParserT s m [a]
- endBy :: (Monad m, Eq s) => ParserT s m a -> ParserT s m b -> ParserT s m [a]
- endBy1 :: (Monad m, Eq s) => ParserT s m a -> ParserT s m b -> ParserT s m [a]
- chainl :: (Monad m, Eq s) => ParserT s m a -> ParserT s m (a -> a -> a) -> a -> ParserT s m a
- chainl1 :: (Monad m, Eq s) => ParserT s m a -> ParserT s m (a -> a -> a) -> ParserT s m a
- chainr :: (Monad m, Eq s) => ParserT s m a -> ParserT s m (a -> a -> a) -> a -> ParserT s m a
- chainr1 :: (Monad m, Eq s) => ParserT s m a -> ParserT s m (a -> a -> a) -> ParserT s m a
- between :: Monad m => ParserT s m open -> ParserT s m close -> ParserT s m a -> ParserT s m a
- option :: (Monad m, Eq s) => a -> ParserT s m a -> ParserT s m a
- reject :: (Monad m, Show a) => ParserT s m a -> ParserT s m ()
- accept :: Monad m => ParserT s m a -> ParserT s m a
Types
newtype ParserT s m a Source #
A transformer parsing symbols s, inner monad m, return a
ParserT ([s] -> m (Either ParseError (a, [s]))) |
Instances
MonadTrans (ParserT s) Source # | |
Monad m => MonadFail (ParserT s m) Source # | |
Defined in Mini.Transformers.ParserT | |
(Monad m, Eq s) => Alternative (ParserT s m) Source # | Parse |
Monad m => Applicative (ParserT s m) Source # | |
Defined in Mini.Transformers.ParserT | |
Monad m => Functor (ParserT s m) Source # | |
Monad m => Monad (ParserT s m) Source # | |
(Monad m, Monoid a) => Monoid (ParserT s m a) Source # | |
(Monad m, Semigroup a) => Semigroup (ParserT s m a) Source # | Combine the results of |
data ParseError Source #
Abstract representation of a parse error
Instances
Monoid ParseError Source # | |
Defined in Mini.Transformers.ParserT mempty :: ParseError # mappend :: ParseError -> ParseError -> ParseError # mconcat :: [ParseError] -> ParseError # | |
Semigroup ParseError Source # | |
Defined in Mini.Transformers.ParserT (<>) :: ParseError -> ParseError -> ParseError # sconcat :: NonEmpty ParseError -> ParseError # stimes :: Integral b => b -> ParseError -> ParseError # | |
Show ParseError Source # | |
Defined in Mini.Transformers.ParserT showsPrec :: Int -> ParseError -> ShowS # show :: ParseError -> String # showList :: [ParseError] -> ShowS # |
Runner
runParserT :: ParserT s m a -> [s] -> m (Either ParseError (a, [s])) Source #
Unwrap a ParserT
computation with a sequence of symbols to parse
Parsers
sat :: (Applicative m, Show s) => (s -> Bool) -> ParserT s m s Source #
Parse symbols satisfying a predicate
Examples
>>>
runParserT (some $ sat isDigit) "123abc"
Right ("123","abc")
item :: (Applicative m, Show s) => ParserT s m s Source #
Parse any symbol
Examples
>>>
runParserT (item *> item <* item) "bar"
Right ('a',"")
symbol :: (Applicative m, Show s, Eq s) => s -> ParserT s m s Source #
Parse a symbol
Examples
>>>
runParserT (symbol 'f') "foo"
Right ('f',"oo")
string :: (Monad m, Traversable t, Show s, Eq s) => t s -> ParserT s m (t s) Source #
Parse a sequence of symbols
Examples
>>>
runParserT (string "foo") "foobar"
Right ("foo","bar")
oneOf :: (Applicative m, Foldable t, Show s, Eq s) => t s -> ParserT s m s Source #
Parse symbols included in a collection
Examples
>>>
runParserT (oneOf "abc") "bar"
Right ('b',"ar")
noneOf :: (Applicative m, Foldable t, Show s, Eq s) => t s -> ParserT s m s Source #
Parse symbols excluded from a collection
Examples
>>>
runParserT (noneOf "abc") "foo"
Right ('f',"oo")
eof :: (Monad m, Show s) => ParserT s m () Source #
Parse successfully only at end of input
Examples
>>>
runParserT (string "foobar" *> eof) "foobar"
Right ((),"")
Combinators
sepBy :: (Monad m, Eq s) => ParserT s m a -> ParserT s m b -> ParserT s m [a] Source #
Parse zero or more p
separated by q
via p `sepBy` q
Examples
>>>
runParserT (sat isDigit `sepBy` symbol ',') "1,2,3,four"
Right ("123",",four")
sepBy1 :: (Monad m, Eq s) => ParserT s m a -> ParserT s m b -> ParserT s m [a] Source #
Parse one or more p
separated by q
via p `sepBy1` q
Examples
>>>
runParserT (sat isDigit `sepBy1` symbol ',') "1,2,3,four"
Right ("123",",four")
endBy :: (Monad m, Eq s) => ParserT s m a -> ParserT s m b -> ParserT s m [a] Source #
Parse zero or more p
separated and ended by q
via p `endBy` q
Examples
>>>
runParserT (sat isDigit `endBy` symbol ',') "1,2,3,four"
Right ("123","four")
endBy1 :: (Monad m, Eq s) => ParserT s m a -> ParserT s m b -> ParserT s m [a] Source #
Parse one or more p
separated and ended by q
via p `endBy1` q
Examples
>>>
runParserT (sat isDigit `endBy1` symbol ',') "1,2,3,four"
Right ("123","four")
chainl :: (Monad m, Eq s) => ParserT s m a -> ParserT s m (a -> a -> a) -> a -> ParserT s m a Source #
Parse zero or more p
left-chained with op
atop a
via chainl p op a
Examples
>>>
runParserT (chainl (read <$> some (sat isDigit)) ((+) <$ item) 10) "2a3b4c"
Right (9,"c")
chainl1 :: (Monad m, Eq s) => ParserT s m a -> ParserT s m (a -> a -> a) -> ParserT s m a Source #
Parse one or more p
left-chained with op
via chainl1 p op
Examples
>>>
runParserT (chainl1 (read <$> some (sat isDigit)) ((+) <$ item)) "2a3b4c"
Right (9,"c")
chainr :: (Monad m, Eq s) => ParserT s m a -> ParserT s m (a -> a -> a) -> a -> ParserT s m a Source #
Parse zero or more p
right-chained with op
atop a
via chainr p op a
Examples
>>>
runParserT (chainr (read <$> some (sat isDigit)) ((*) <$ item) 10) "2a3b4c"
Right (24,"c")
chainr1 :: (Monad m, Eq s) => ParserT s m a -> ParserT s m (a -> a -> a) -> ParserT s m a Source #
Parse one or more p
right-chained with op
via chainr1 p op
Examples
>>>
runParserT (chainr1 (read <$> some (sat isDigit)) ((*) <$ item)) "2a3b4c"
Right (24,"c")
between :: Monad m => ParserT s m open -> ParserT s m close -> ParserT s m a -> ParserT s m a Source #
Parse p
enclosed by a
and b
via between a b p
Examples
>>>
runParserT (between (symbol '(') (symbol ')') (many $ sat isLetter)) "(yes)"
Right ("yes","")
option :: (Monad m, Eq s) => a -> ParserT s m a -> ParserT s m a Source #
Parse p
returning a
in case of failure via option a p
Examples
>>>
runParserT (option "foo" $ string "bar") "baz"
Right ("foo","baz")