Safe Haskell	Safe-Inferred
Language	Haskell2010

Mini.Transformers.ParserT

Contents

Types
Runner
Parsers
Combinators

Description

Extend a monad with the ability to parse symbol sequences

Synopsis

newtype ParserT s m a = ParserT ([s] -> m (Either ParseError (a, [s])))
newtype ParseError = ParseError {
- unexpected :: String
}
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]
chainl1 :: (Monad m, Eq s) => ParserT s m a -> ParserT s m (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

Constructors

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

Instances

Instances details

MonadTrans (ParserT s) Source #
Instance details Defined in Mini.Transformers.ParserT Methods lift :: Monad m => m a -> ParserT s m a Source #
Monad m => MonadFail (ParserT s m) Source #
Instance details Defined in Mini.Transformers.ParserT Methods fail :: String -> ParserT s m a #
(Monad m, Eq s) => Alternative (ParserT s m) Source #	Parse `p` or, if `p` fails, backtrack and parse `q` via `p <\|> q`
Instance details 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) Source #
Instance details 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) Source #
Instance details 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) Source #
Instance details 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) Source #
Instance details 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) Source #	Combine the results of `p` and `q` via `p <> q`
Instance details 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 Source #

A parse error

Constructors

ParseError
Fields unexpected :: String

Instances

Instances details

Show ParseError Source #
Instance details 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])) 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

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

Parse any symbol

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

Parse a symbol

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

Parse a sequence of symbols

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

Parse symbols included in a collection

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

Parse symbols excluded from a collection

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

Parse successfully only at end of input

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

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

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

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

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

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

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

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

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

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

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

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