Mini.Transformers.ParserT

Extend a monad with the ability to parse symbol sequences

Types

newtype ParserT s m a

A transformer parsing symbols s, inner monad m, return a

Constructors

ParserT ([s] -> m (Either ParseError (a, [s])))

Instances

MonadTrans (ParserT s)

Defined in Mini.Transformers.ParserT

Methods

lift :: Monad m => m a -> ParserT s m a

Monad m => MonadFail (ParserT s m)

Defined in Mini.Transformers.ParserT

Methods

fail :: String -> ParserT s m a

(Monad m, Eq s) => Alternative (ParserT s m)

Parse p or, if p fails, backtrack and parse q via p <|> q

Defined in Mini.Transformers.ParserT

Methods

empty :: ParserT s m a

(<|>) :: ParserT s m a -> ParserT s m a -> ParserT s m a

some :: ParserT s m a -> ParserT s m [a]

many :: ParserT s m a -> ParserT s m [a]

Monad m => Applicative (ParserT s m)

Defined in Mini.Transformers.ParserT

Methods

pure :: a -> ParserT s m a

(<*>) :: ParserT s m (a -> b) -> ParserT s m a -> ParserT s m b

liftA2 :: (a -> b -> c) -> ParserT s m a -> ParserT s m b -> ParserT s m c

(*>) :: ParserT s m a -> ParserT s m b -> ParserT s m b

(<*) :: ParserT s m a -> ParserT s m b -> ParserT s m a

Monad m => Functor (ParserT s m)

Defined in Mini.Transformers.ParserT

Methods

fmap :: (a -> b) -> ParserT s m a -> ParserT s m b

(<$) :: a -> ParserT s m b -> ParserT s m a

Monad m => Monad (ParserT s m)

Defined in Mini.Transformers.ParserT

Methods

(>>=) :: ParserT s m a -> (a -> ParserT s m b) -> ParserT s m b

(>>) :: ParserT s m a -> ParserT s m b -> ParserT s m b

return :: a -> ParserT s m a

(Monad m, Monoid a) => Monoid (ParserT s m a)

Defined in Mini.Transformers.ParserT

Methods

mempty :: ParserT s m a

mappend :: ParserT s m a -> ParserT s m a -> ParserT s m a

mconcat :: [ParserT s m a] -> ParserT s m a

(Monad m, Semigroup a) => Semigroup (ParserT s m a)

Combine the results of p and q via p <> q

Defined in Mini.Transformers.ParserT

Methods

(<>) :: ParserT s m a -> ParserT s m a -> ParserT s m a

sconcat :: NonEmpty (ParserT s m a) -> ParserT s m a

stimes :: Integral b => b -> ParserT s m a -> ParserT s m a

data ParseError

Abstract representation of a parse error

Instances

Monoid ParseError

Defined in Mini.Transformers.ParserT

Methods

mempty :: ParseError

mappend :: ParseError -> ParseError -> ParseError

mconcat :: [ParseError] -> ParseError

Semigroup ParseError

Defined in Mini.Transformers.ParserT

Methods

(<>) :: ParseError -> ParseError -> ParseError

sconcat :: NonEmpty ParseError -> ParseError

stimes :: Integral b => b -> ParseError -> ParseError

Show ParseError

Defined in Mini.Transformers.ParserT

Methods

showsPrec :: Int -> ParseError -> ShowS

show :: ParseError -> String

showList :: [ParseError] -> ShowS

Runner

runParserT :: ParserT s m a -> [s] -> m (Either ParseError (a, [s]))

Unwrap a ParserT computation with a sequence of symbols to parse

Parsers

sat :: (Applicative m, Show s) => (s -> Bool) -> ParserT s m s

Parse symbols satisfying a predicate

Examples

>>> runParserT (some $ sat isDigit) "123abc"
Right ("123","abc")

item :: (Applicative m, Show s) => ParserT s m s

Parse any symbol

Examples

>>> runParserT (item *> item <* item) "bar"
Right ('a',"")

symbol :: (Applicative m, Show s, Eq s) => s -> ParserT s m s

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)

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

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

Parse symbols excluded from a collection

Examples

>>> runParserT (noneOf "abc") "foo"
Right ('f',"oo")

eof :: (Monad m, Show s) => ParserT s m ()

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]

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]

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]

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]

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

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

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

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

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

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

Parse p returning a in case of failure via option a p

Examples

>>> runParserT (option "foo" $ string "bar") "baz"
Right ("foo","baz")

reject :: (Monad m, Show a) => ParserT s m a -> ParserT s m ()

Parse p, without consuming input, iff p fails via reject p

Examples

>>> runParserT (string "foo" <* reject (sat isLetter)) "foo(bar)"
Right ("foo","(bar)")

accept :: Monad m => ParserT s m a -> ParserT s m a

Parse p, without consuming input, iff p succeeds via accept p

Examples

>>> runParserT (accept item >>= pure . (== 'a')) "foo"
Right (False,"foo")