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

newtype ParseError

A parse error

Constructors

ParseError

Fields

• unexpected :: String

Instances

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

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

Parse any symbol

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

Parse a symbol

string :: (Monad m, Traversable t, Show s, Eq s) => t s -> ParserT s m (t s)

Parse a sequence of symbols

oneOf :: (Applicative m, Foldable t, Show s, Eq s) => t s -> ParserT s m s

Parse symbols included in a collection

noneOf :: (Applicative m, Foldable t, Show s, Eq s) => t s -> ParserT s m s

Parse symbols excluded from a collection

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

Parse successfully only at end of input

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

Parse the next symbol without consuming it

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

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

till :: (Monad m, Eq s) => ParserT s m a -> ParserT s m b -> ParserT s m [a]

Parse zero or more p until q succeeds via p `till` q

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-associatively chained by f via chainl1 p f

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-associatively chained by f via chainr1 p f

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

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

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

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

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

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