Text.Parser.Input

Parsers that can consume and return a prefix of their input.

Documentation

class LookAheadParsing m => InputParsing m where

Methods for parsing monoidal inputs

Minimal complete definition

getInput, take

Associated Types

type ParserInput m

The type of the input stream that the parser m expects to parse.

type ParserPosition m

type ParserPosition m = Down Int

Methods

getInput :: m (ParserInput m)

Always sucessful parser that returns the entire remaining input without consuming it.

getSourcePos :: m (ParserPosition m)

Retrieve the Position reached by the parser in the input source.

default getSourcePos :: (FactorialMonoid (ParserInput m), Functor m, ParserPosition m ~ Down Int) => m (ParserPosition m)

anyToken :: m (ParserInput m)

A parser that accepts any single atomic prefix of the input stream.

anyToken == satisfy (const True)
anyToken == take 1

take :: Int -> m (ParserInput m)

A parser that accepts exactly the given number of input atoms.

take n == count n anyToken

satisfy :: (ParserInput m -> Bool) -> m (ParserInput m)

A parser that accepts an input atom only if it satisfies the given predicate.

default satisfy :: Monad m => (ParserInput m -> Bool) -> m (ParserInput m)

notSatisfy :: (ParserInput m -> Bool) -> m ()

A parser that succeeds exactly when satisfy doesn't, equivalent to notFollowedBy . satisfy

scan :: state -> (state -> ParserInput m -> Maybe state) -> m (ParserInput m)

A stateful scanner. The predicate modifies a state argument, and each transformed state is passed to successive invocations of the predicate on each token of the input until one returns Nothing or the input ends.

This parser does not fail. It will return an empty string if the predicate returns Nothing on the first character.

Note: Because this parser does not fail, do not use it with combinators such as many, because such parsers loop until a failure occurs. Careless use will thus result in an infinite loop.

default scan :: (Monad m, FactorialMonoid (ParserInput m)) => state -> (state -> ParserInput m -> Maybe state) -> m (ParserInput m)

string :: ParserInput m -> m (ParserInput m)

A parser that consumes and returns the given prefix of the input.

default string :: (Monad m, LeftReductive (ParserInput m), FactorialMonoid (ParserInput m), Show (ParserInput m)) => ParserInput m -> m (ParserInput m)

takeWhile :: (ParserInput m -> Bool) -> m (ParserInput m)

A parser accepting the longest sequence of input atoms that match the given predicate; an optimized version of concat . many . satisfy.

Note: Because this parser does not fail, do not use it with combinators such as many, because such parsers loop until a failure occurs. Careless use will thus result in an infinite loop.

default takeWhile :: (Monad m, FactorialMonoid (ParserInput m)) => (ParserInput m -> Bool) -> m (ParserInput m)

takeWhile1 :: (ParserInput m -> Bool) -> m (ParserInput m)

A parser accepting the longest non-empty sequence of input atoms that match the given predicate; an optimized version of concat . some . satisfy.

default takeWhile1 :: (Monad m, FactorialMonoid (ParserInput m)) => (ParserInput m -> Bool) -> m (ParserInput m)

Instances

InputParsing ReadP

Defined in Text.Parser.Input

Associated Types

type ParserInput ReadP

type ParserPosition ReadP

Methods

getInput :: ReadP (ParserInput ReadP)

getSourcePos :: ReadP (ParserPosition ReadP)

anyToken :: ReadP (ParserInput ReadP)

take :: Int -> ReadP (ParserInput ReadP)

satisfy :: (ParserInput ReadP -> Bool) -> ReadP (ParserInput ReadP)

notSatisfy :: (ParserInput ReadP -> Bool) -> ReadP ()

scan :: state -> (state -> ParserInput ReadP -> Maybe state) -> ReadP (ParserInput ReadP)

string :: ParserInput ReadP -> ReadP (ParserInput ReadP)

takeWhile :: (ParserInput ReadP -> Bool) -> ReadP (ParserInput ReadP)

takeWhile1 :: (ParserInput ReadP -> Bool) -> ReadP (ParserInput ReadP)

InputParsing (Strict Get)

Defined in Text.Parser.Input

Associated Types

type ParserInput (Strict Get)

type ParserPosition (Strict Get)

Methods

getInput :: Strict Get (ParserInput (Strict Get))

getSourcePos :: Strict Get (ParserPosition (Strict Get))

anyToken :: Strict Get (ParserInput (Strict Get))

take :: Int -> Strict Get (ParserInput (Strict Get))

satisfy :: (ParserInput (Strict Get) -> Bool) -> Strict Get (ParserInput (Strict Get))

notSatisfy :: (ParserInput (Strict Get) -> Bool) -> Strict Get ()

scan :: state -> (state -> ParserInput (Strict Get) -> Maybe state) -> Strict Get (ParserInput (Strict Get))

string :: ParserInput (Strict Get) -> Strict Get (ParserInput (Strict Get))

takeWhile :: (ParserInput (Strict Get) -> Bool) -> Strict Get (ParserInput (Strict Get))

takeWhile1 :: (ParserInput (Strict Get) -> Bool) -> Strict Get (ParserInput (Strict Get))

InputParsing (Lazy Get)

Defined in Text.Parser.Input

Associated Types

type ParserInput (Lazy Get)

type ParserPosition (Lazy Get)

Methods

getInput :: Lazy Get (ParserInput (Lazy Get))

getSourcePos :: Lazy Get (ParserPosition (Lazy Get))

anyToken :: Lazy Get (ParserInput (Lazy Get))

take :: Int -> Lazy Get (ParserInput (Lazy Get))

satisfy :: (ParserInput (Lazy Get) -> Bool) -> Lazy Get (ParserInput (Lazy Get))

notSatisfy :: (ParserInput (Lazy Get) -> Bool) -> Lazy Get ()

scan :: state -> (state -> ParserInput (Lazy Get) -> Maybe state) -> Lazy Get (ParserInput (Lazy Get))

string :: ParserInput (Lazy Get) -> Lazy Get (ParserInput (Lazy Get))

takeWhile :: (ParserInput (Lazy Get) -> Bool) -> Lazy Get (ParserInput (Lazy Get))

takeWhile1 :: (ParserInput (Lazy Get) -> Bool) -> Lazy Get (ParserInput (Lazy Get))

(Monad m, InputParsing m) => InputParsing (IdentityT m)

Defined in Text.Parser.Input

Associated Types

type ParserInput (IdentityT m)

type ParserPosition (IdentityT m)

Methods

getInput :: IdentityT m (ParserInput (IdentityT m))

getSourcePos :: IdentityT m (ParserPosition (IdentityT m))

anyToken :: IdentityT m (ParserInput (IdentityT m))

take :: Int -> IdentityT m (ParserInput (IdentityT m))

satisfy :: (ParserInput (IdentityT m) -> Bool) -> IdentityT m (ParserInput (IdentityT m))

notSatisfy :: (ParserInput (IdentityT m) -> Bool) -> IdentityT m ()

scan :: state -> (state -> ParserInput (IdentityT m) -> Maybe state) -> IdentityT m (ParserInput (IdentityT m))

string :: ParserInput (IdentityT m) -> IdentityT m (ParserInput (IdentityT m))

takeWhile :: (ParserInput (IdentityT m) -> Bool) -> IdentityT m (ParserInput (IdentityT m))

takeWhile1 :: (ParserInput (IdentityT m) -> Bool) -> IdentityT m (ParserInput (IdentityT m))

(MonadPlus m, InputParsing m) => InputParsing (ReaderT e m)

Defined in Text.Parser.Input

Associated Types

type ParserInput (ReaderT e m)

type ParserPosition (ReaderT e m)

Methods

getInput :: ReaderT e m (ParserInput (ReaderT e m))

getSourcePos :: ReaderT e m (ParserPosition (ReaderT e m))

anyToken :: ReaderT e m (ParserInput (ReaderT e m))

take :: Int -> ReaderT e m (ParserInput (ReaderT e m))

satisfy :: (ParserInput (ReaderT e m) -> Bool) -> ReaderT e m (ParserInput (ReaderT e m))

notSatisfy :: (ParserInput (ReaderT e m) -> Bool) -> ReaderT e m ()

scan :: state -> (state -> ParserInput (ReaderT e m) -> Maybe state) -> ReaderT e m (ParserInput (ReaderT e m))

string :: ParserInput (ReaderT e m) -> ReaderT e m (ParserInput (ReaderT e m))

takeWhile :: (ParserInput (ReaderT e m) -> Bool) -> ReaderT e m (ParserInput (ReaderT e m))

takeWhile1 :: (ParserInput (ReaderT e m) -> Bool) -> ReaderT e m (ParserInput (ReaderT e m))

(MonadPlus m, InputParsing m) => InputParsing (StateT s m)

Defined in Text.Parser.Input

Associated Types

type ParserInput (StateT s m)

type ParserPosition (StateT s m)

Methods

getInput :: StateT s m (ParserInput (StateT s m))

getSourcePos :: StateT s m (ParserPosition (StateT s m))

anyToken :: StateT s m (ParserInput (StateT s m))

take :: Int -> StateT s m (ParserInput (StateT s m))

satisfy :: (ParserInput (StateT s m) -> Bool) -> StateT s m (ParserInput (StateT s m))

notSatisfy :: (ParserInput (StateT s m) -> Bool) -> StateT s m ()

scan :: state -> (state -> ParserInput (StateT s m) -> Maybe state) -> StateT s m (ParserInput (StateT s m))

string :: ParserInput (StateT s m) -> StateT s m (ParserInput (StateT s m))

takeWhile :: (ParserInput (StateT s m) -> Bool) -> StateT s m (ParserInput (StateT s m))

takeWhile1 :: (ParserInput (StateT s m) -> Bool) -> StateT s m (ParserInput (StateT s m))

(MonadPlus m, InputParsing m) => InputParsing (StateT s m)

Defined in Text.Parser.Input

Associated Types

type ParserInput (StateT s m)

type ParserPosition (StateT s m)

Methods

getInput :: StateT s m (ParserInput (StateT s m))

getSourcePos :: StateT s m (ParserPosition (StateT s m))

anyToken :: StateT s m (ParserInput (StateT s m))

take :: Int -> StateT s m (ParserInput (StateT s m))

satisfy :: (ParserInput (StateT s m) -> Bool) -> StateT s m (ParserInput (StateT s m))

notSatisfy :: (ParserInput (StateT s m) -> Bool) -> StateT s m ()

scan :: state -> (state -> ParserInput (StateT s m) -> Maybe state) -> StateT s m (ParserInput (StateT s m))

string :: ParserInput (StateT s m) -> StateT s m (ParserInput (StateT s m))

takeWhile :: (ParserInput (StateT s m) -> Bool) -> StateT s m (ParserInput (StateT s m))

takeWhile1 :: (ParserInput (StateT s m) -> Bool) -> StateT s m (ParserInput (StateT s m))

(MonadPlus m, InputParsing m, Monoid w) => InputParsing (WriterT w m)

Defined in Text.Parser.Input

Associated Types

type ParserInput (WriterT w m)

type ParserPosition (WriterT w m)

Methods

getInput :: WriterT w m (ParserInput (WriterT w m))

getSourcePos :: WriterT w m (ParserPosition (WriterT w m))

anyToken :: WriterT w m (ParserInput (WriterT w m))

take :: Int -> WriterT w m (ParserInput (WriterT w m))

satisfy :: (ParserInput (WriterT w m) -> Bool) -> WriterT w m (ParserInput (WriterT w m))

notSatisfy :: (ParserInput (WriterT w m) -> Bool) -> WriterT w m ()

scan :: state -> (state -> ParserInput (WriterT w m) -> Maybe state) -> WriterT w m (ParserInput (WriterT w m))

string :: ParserInput (WriterT w m) -> WriterT w m (ParserInput (WriterT w m))

takeWhile :: (ParserInput (WriterT w m) -> Bool) -> WriterT w m (ParserInput (WriterT w m))

takeWhile1 :: (ParserInput (WriterT w m) -> Bool) -> WriterT w m (ParserInput (WriterT w m))

(MonadPlus m, InputParsing m, Monoid w) => InputParsing (WriterT w m)

Defined in Text.Parser.Input

Associated Types

type ParserInput (WriterT w m)

type ParserPosition (WriterT w m)

Methods

getInput :: WriterT w m (ParserInput (WriterT w m))

getSourcePos :: WriterT w m (ParserPosition (WriterT w m))

anyToken :: WriterT w m (ParserInput (WriterT w m))

take :: Int -> WriterT w m (ParserInput (WriterT w m))

satisfy :: (ParserInput (WriterT w m) -> Bool) -> WriterT w m (ParserInput (WriterT w m))

notSatisfy :: (ParserInput (WriterT w m) -> Bool) -> WriterT w m ()

scan :: state -> (state -> ParserInput (WriterT w m) -> Maybe state) -> WriterT w m (ParserInput (WriterT w m))

string :: ParserInput (WriterT w m) -> WriterT w m (ParserInput (WriterT w m))

takeWhile :: (ParserInput (WriterT w m) -> Bool) -> WriterT w m (ParserInput (WriterT w m))

takeWhile1 :: (ParserInput (WriterT w m) -> Bool) -> WriterT w m (ParserInput (WriterT w m))

(FactorialMonoid s, LeftReductive s, Show s, Stream s m t, Show t) => InputParsing (ParsecT s u m)

Defined in Text.Parser.Input

Associated Types

type ParserInput (ParsecT s u m)

type ParserPosition (ParsecT s u m)

Methods

getInput :: ParsecT s u m (ParserInput (ParsecT s u m))

getSourcePos :: ParsecT s u m (ParserPosition (ParsecT s u m))

anyToken :: ParsecT s u m (ParserInput (ParsecT s u m))

take :: Int -> ParsecT s u m (ParserInput (ParsecT s u m))

satisfy :: (ParserInput (ParsecT s u m) -> Bool) -> ParsecT s u m (ParserInput (ParsecT s u m))

notSatisfy :: (ParserInput (ParsecT s u m) -> Bool) -> ParsecT s u m ()

scan :: state -> (state -> ParserInput (ParsecT s u m) -> Maybe state) -> ParsecT s u m (ParserInput (ParsecT s u m))

string :: ParserInput (ParsecT s u m) -> ParsecT s u m (ParserInput (ParsecT s u m))

takeWhile :: (ParserInput (ParsecT s u m) -> Bool) -> ParsecT s u m (ParserInput (ParsecT s u m))

takeWhile1 :: (ParserInput (ParsecT s u m) -> Bool) -> ParsecT s u m (ParserInput (ParsecT s u m))

(MonadPlus m, InputParsing m, Monoid w) => InputParsing (RWST r w s m)

Defined in Text.Parser.Input

Associated Types

type ParserInput (RWST r w s m)

type ParserPosition (RWST r w s m)

Methods

getInput :: RWST r w s m (ParserInput (RWST r w s m))

getSourcePos :: RWST r w s m (ParserPosition (RWST r w s m))

anyToken :: RWST r w s m (ParserInput (RWST r w s m))

take :: Int -> RWST r w s m (ParserInput (RWST r w s m))

satisfy :: (ParserInput (RWST r w s m) -> Bool) -> RWST r w s m (ParserInput (RWST r w s m))

notSatisfy :: (ParserInput (RWST r w s m) -> Bool) -> RWST r w s m ()

scan :: state -> (state -> ParserInput (RWST r w s m) -> Maybe state) -> RWST r w s m (ParserInput (RWST r w s m))

string :: ParserInput (RWST r w s m) -> RWST r w s m (ParserInput (RWST r w s m))

takeWhile :: (ParserInput (RWST r w s m) -> Bool) -> RWST r w s m (ParserInput (RWST r w s m))

takeWhile1 :: (ParserInput (RWST r w s m) -> Bool) -> RWST r w s m (ParserInput (RWST r w s m))

(MonadPlus m, InputParsing m, Monoid w) => InputParsing (RWST r w s m)

Defined in Text.Parser.Input

Associated Types

type ParserInput (RWST r w s m)

type ParserPosition (RWST r w s m)

Methods

getInput :: RWST r w s m (ParserInput (RWST r w s m))

getSourcePos :: RWST r w s m (ParserPosition (RWST r w s m))

anyToken :: RWST r w s m (ParserInput (RWST r w s m))

take :: Int -> RWST r w s m (ParserInput (RWST r w s m))

satisfy :: (ParserInput (RWST r w s m) -> Bool) -> RWST r w s m (ParserInput (RWST r w s m))

notSatisfy :: (ParserInput (RWST r w s m) -> Bool) -> RWST r w s m ()

scan :: state -> (state -> ParserInput (RWST r w s m) -> Maybe state) -> RWST r w s m (ParserInput (RWST r w s m))

string :: ParserInput (RWST r w s m) -> RWST r w s m (ParserInput (RWST r w s m))

takeWhile :: (ParserInput (RWST r w s m) -> Bool) -> RWST r w s m (ParserInput (RWST r w s m))

takeWhile1 :: (ParserInput (RWST r w s m) -> Bool) -> RWST r w s m (ParserInput (RWST r w s m))

class (CharParsing m, InputParsing m) => InputCharParsing m where

Methods for parsing textual monoid inputs

Minimal complete definition

satisfyCharInput

Methods

satisfyCharInput :: (Char -> Bool) -> m (ParserInput m)

Specialization of satisfy on textual inputs, accepting an input character only if it satisfies the given predicate, and returning the input atom that represents the character. Equivalent to fmap singleton . Char.satisfy

notSatisfyChar :: (Char -> Bool) -> m ()

A parser that succeeds exactly when satisfy doesn't, equivalent to notFollowedBy . Char.satisfy

scanChars :: state -> (state -> Char -> Maybe state) -> m (ParserInput m)

Stateful scanner like scan, but specialized for TextualMonoid inputs.

default scanChars :: (Monad m, TextualMonoid (ParserInput m)) => state -> (state -> Char -> Maybe state) -> m (ParserInput m)

takeCharsWhile :: (Char -> Bool) -> m (ParserInput m)

Specialization of takeWhile on TextualMonoid inputs, accepting the longest sequence of input characters that match the given predicate; an optimized version of fmap fromString . many . Char.satisfy.

Note: Because this parser does not fail, do not use it with combinators such as many, because such parsers loop until a failure occurs. Careless use will thus result in an infinite loop.

default takeCharsWhile :: (Monad m, TextualMonoid (ParserInput m)) => (Char -> Bool) -> m (ParserInput m)

takeCharsWhile1 :: (Char -> Bool) -> m (ParserInput m)

Specialization of takeWhile1 on TextualMonoid inputs, accepting the longest sequence of input characters that match the given predicate; an optimized version of fmap fromString . some . Char.satisfy.

default takeCharsWhile1 :: (Monad m, TextualMonoid (ParserInput m)) => (Char -> Bool) -> m (ParserInput m)

Instances

InputCharParsing ReadP

Defined in Text.Parser.Input

Methods

satisfyCharInput :: (Char -> Bool) -> ReadP (ParserInput ReadP)

notSatisfyChar :: (Char -> Bool) -> ReadP ()

scanChars :: state -> (state -> Char -> Maybe state) -> ReadP (ParserInput ReadP)

takeCharsWhile :: (Char -> Bool) -> ReadP (ParserInput ReadP)

takeCharsWhile1 :: (Char -> Bool) -> ReadP (ParserInput ReadP)

(MonadPlus m, InputCharParsing m) => InputCharParsing (IdentityT m)

Defined in Text.Parser.Input

Methods

satisfyCharInput :: (Char -> Bool) -> IdentityT m (ParserInput (IdentityT m))

notSatisfyChar :: (Char -> Bool) -> IdentityT m ()

scanChars :: state -> (state -> Char -> Maybe state) -> IdentityT m (ParserInput (IdentityT m))

takeCharsWhile :: (Char -> Bool) -> IdentityT m (ParserInput (IdentityT m))

takeCharsWhile1 :: (Char -> Bool) -> IdentityT m (ParserInput (IdentityT m))

(MonadPlus m, InputCharParsing m) => InputCharParsing (ReaderT e m)

Defined in Text.Parser.Input

Methods

satisfyCharInput :: (Char -> Bool) -> ReaderT e m (ParserInput (ReaderT e m))

notSatisfyChar :: (Char -> Bool) -> ReaderT e m ()

scanChars :: state -> (state -> Char -> Maybe state) -> ReaderT e m (ParserInput (ReaderT e m))

takeCharsWhile :: (Char -> Bool) -> ReaderT e m (ParserInput (ReaderT e m))

takeCharsWhile1 :: (Char -> Bool) -> ReaderT e m (ParserInput (ReaderT e m))

(MonadPlus m, InputCharParsing m) => InputCharParsing (StateT s m)

Defined in Text.Parser.Input

Methods

satisfyCharInput :: (Char -> Bool) -> StateT s m (ParserInput (StateT s m))

notSatisfyChar :: (Char -> Bool) -> StateT s m ()

scanChars :: state -> (state -> Char -> Maybe state) -> StateT s m (ParserInput (StateT s m))

takeCharsWhile :: (Char -> Bool) -> StateT s m (ParserInput (StateT s m))

takeCharsWhile1 :: (Char -> Bool) -> StateT s m (ParserInput (StateT s m))

(MonadPlus m, InputCharParsing m) => InputCharParsing (StateT s m)

Defined in Text.Parser.Input

Methods

satisfyCharInput :: (Char -> Bool) -> StateT s m (ParserInput (StateT s m))

notSatisfyChar :: (Char -> Bool) -> StateT s m ()

scanChars :: state -> (state -> Char -> Maybe state) -> StateT s m (ParserInput (StateT s m))

takeCharsWhile :: (Char -> Bool) -> StateT s m (ParserInput (StateT s m))

takeCharsWhile1 :: (Char -> Bool) -> StateT s m (ParserInput (StateT s m))

(MonadPlus m, InputCharParsing m, Monoid w) => InputCharParsing (WriterT w m)

Defined in Text.Parser.Input

Methods

satisfyCharInput :: (Char -> Bool) -> WriterT w m (ParserInput (WriterT w m))

notSatisfyChar :: (Char -> Bool) -> WriterT w m ()

scanChars :: state -> (state -> Char -> Maybe state) -> WriterT w m (ParserInput (WriterT w m))

takeCharsWhile :: (Char -> Bool) -> WriterT w m (ParserInput (WriterT w m))

takeCharsWhile1 :: (Char -> Bool) -> WriterT w m (ParserInput (WriterT w m))

(MonadPlus m, InputCharParsing m, Monoid w) => InputCharParsing (WriterT w m)

Defined in Text.Parser.Input

Methods

satisfyCharInput :: (Char -> Bool) -> WriterT w m (ParserInput (WriterT w m))

notSatisfyChar :: (Char -> Bool) -> WriterT w m ()

scanChars :: state -> (state -> Char -> Maybe state) -> WriterT w m (ParserInput (WriterT w m))

takeCharsWhile :: (Char -> Bool) -> WriterT w m (ParserInput (WriterT w m))

takeCharsWhile1 :: (Char -> Bool) -> WriterT w m (ParserInput (WriterT w m))

(TextualMonoid s, Show s, Stream s m Char) => InputCharParsing (ParsecT s u m)

Defined in Text.Parser.Input

Methods

satisfyCharInput :: (Char -> Bool) -> ParsecT s u m (ParserInput (ParsecT s u m))

notSatisfyChar :: (Char -> Bool) -> ParsecT s u m ()

scanChars :: state -> (state -> Char -> Maybe state) -> ParsecT s u m (ParserInput (ParsecT s u m))

takeCharsWhile :: (Char -> Bool) -> ParsecT s u m (ParserInput (ParsecT s u m))

takeCharsWhile1 :: (Char -> Bool) -> ParsecT s u m (ParserInput (ParsecT s u m))

(MonadPlus m, InputCharParsing m, Monoid w) => InputCharParsing (RWST r w s m)

Defined in Text.Parser.Input

Methods

satisfyCharInput :: (Char -> Bool) -> RWST r w s m (ParserInput (RWST r w s m))

notSatisfyChar :: (Char -> Bool) -> RWST r w s m ()

scanChars :: state -> (state -> Char -> Maybe state) -> RWST r w s m (ParserInput (RWST r w s m))

takeCharsWhile :: (Char -> Bool) -> RWST r w s m (ParserInput (RWST r w s m))

takeCharsWhile1 :: (Char -> Bool) -> RWST r w s m (ParserInput (RWST r w s m))

(MonadPlus m, InputCharParsing m, Monoid w) => InputCharParsing (RWST r w s m)

Defined in Text.Parser.Input

Methods

satisfyCharInput :: (Char -> Bool) -> RWST r w s m (ParserInput (RWST r w s m))

notSatisfyChar :: (Char -> Bool) -> RWST r w s m ()

scanChars :: state -> (state -> Char -> Maybe state) -> RWST r w s m (ParserInput (RWST r w s m))

takeCharsWhile :: (Char -> Bool) -> RWST r w s m (ParserInput (RWST r w s m))

takeCharsWhile1 :: (Char -> Bool) -> RWST r w s m (ParserInput (RWST r w s m))

class InputParsing m => ConsumedInputParsing m where

Parsers that keep track of the consumed input.

Methods

match :: m a -> m (ParserInput m, a)

Return both the result of a parse and the portion of the input that the argument parser consumed.

Instances

ConsumedInputParsing ReadP

Defined in Text.Parser.Input

Methods

match :: ReadP a -> ReadP (ParserInput ReadP, a)

ConsumedInputParsing (Strict Get)

Defined in Text.Parser.Input

Methods

match :: Strict Get a -> Strict Get (ParserInput (Strict Get), a)

ConsumedInputParsing (Lazy Get)

Defined in Text.Parser.Input

Methods

match :: Lazy Get a -> Lazy Get (ParserInput (Lazy Get), a)

(Monad m, ConsumedInputParsing m) => ConsumedInputParsing (IdentityT m)

Defined in Text.Parser.Input

Methods

match :: IdentityT m a -> IdentityT m (ParserInput (IdentityT m), a)

(MonadPlus m, ConsumedInputParsing m) => ConsumedInputParsing (ReaderT e m)

Defined in Text.Parser.Input

Methods

match :: ReaderT e m a -> ReaderT e m (ParserInput (ReaderT e m), a)

(MonadPlus m, ConsumedInputParsing m) => ConsumedInputParsing (StateT s m)

Defined in Text.Parser.Input

Methods

match :: StateT s m a -> StateT s m (ParserInput (StateT s m), a)

(MonadPlus m, ConsumedInputParsing m) => ConsumedInputParsing (StateT s m)

Defined in Text.Parser.Input

Methods

match :: StateT s m a -> StateT s m (ParserInput (StateT s m), a)

(MonadPlus m, ConsumedInputParsing m, Monoid w) => ConsumedInputParsing (WriterT w m)

Defined in Text.Parser.Input

Methods

match :: WriterT w m a -> WriterT w m (ParserInput (WriterT w m), a)

(MonadPlus m, ConsumedInputParsing m, Monoid w) => ConsumedInputParsing (WriterT w m)

Defined in Text.Parser.Input

Methods

match :: WriterT w m a -> WriterT w m (ParserInput (WriterT w m), a)

(MonadPlus m, ConsumedInputParsing m, Monoid w) => ConsumedInputParsing (RWST r w s m)

Defined in Text.Parser.Input

Methods

match :: RWST r w s m a -> RWST r w s m (ParserInput (RWST r w s m), a)

(MonadPlus m, ConsumedInputParsing m, Monoid w) => ConsumedInputParsing (RWST r w s m)

Defined in Text.Parser.Input

Methods

match :: RWST r w s m a -> RWST r w s m (ParserInput (RWST r w s m), a)

newtype Lazy f a

Wrapper that signifies lazy ByteString inputs

Constructors

Lazy

Fields

• getLazy :: f a

Instances

Monad f => Monad (Lazy f)

Defined in Text.Parser.Wrapper

Methods

(>>=) :: Lazy f a -> (a -> Lazy f b) -> Lazy f b

(>>) :: Lazy f a -> Lazy f b -> Lazy f b

return :: a -> Lazy f a

Functor f => Functor (Lazy f)

Defined in Text.Parser.Wrapper

Methods

fmap :: (a -> b) -> Lazy f a -> Lazy f b

(<$) :: a -> Lazy f b -> Lazy f a

Applicative f => Applicative (Lazy f)

Defined in Text.Parser.Wrapper

Methods

pure :: a -> Lazy f a

(<*>) :: Lazy f (a -> b) -> Lazy f a -> Lazy f b

liftA2 :: (a -> b -> c) -> Lazy f a -> Lazy f b -> Lazy f c

(*>) :: Lazy f a -> Lazy f b -> Lazy f b

(<*) :: Lazy f a -> Lazy f b -> Lazy f a

Alternative f => Alternative (Lazy f)

Defined in Text.Parser.Wrapper

Methods

empty :: Lazy f a

(<|>) :: Lazy f a -> Lazy f a -> Lazy f a

some :: Lazy f a -> Lazy f [a]

many :: Lazy f a -> Lazy f [a]

MonadPlus f => MonadPlus (Lazy f)

Defined in Text.Parser.Wrapper

Methods

mzero :: Lazy f a

mplus :: Lazy f a -> Lazy f a -> Lazy f a

TokenParsing f => TokenParsing (Lazy f)

Defined in Text.Parser.Wrapper

Methods

someSpace :: Lazy f ()

nesting :: Lazy f a -> Lazy f a

semi :: Lazy f Char

highlight :: Highlight -> Lazy f a -> Lazy f a

token :: Lazy f a -> Lazy f a

LookAheadParsing f => LookAheadParsing (Lazy f)

Defined in Text.Parser.Wrapper

Methods

lookAhead :: Lazy f a -> Lazy f a

CharParsing f => CharParsing (Lazy f)

Defined in Text.Parser.Wrapper

Methods

satisfy :: (Char -> Bool) -> Lazy f Char

char :: Char -> Lazy f Char

notChar :: Char -> Lazy f Char

anyChar :: Lazy f Char

string :: String -> Lazy f String

text :: Text -> Lazy f Text

Parsing f => Parsing (Lazy f)

Defined in Text.Parser.Wrapper

Methods

try :: Lazy f a -> Lazy f a

(<?>) :: Lazy f a -> String -> Lazy f a

skipMany :: Lazy f a -> Lazy f ()

skipSome :: Lazy f a -> Lazy f ()

unexpected :: String -> Lazy f a

eof :: Lazy f ()

notFollowedBy :: Show a => Lazy f a -> Lazy f ()

ConsumedInputParsing (Lazy Get)

Defined in Text.Parser.Input

Methods

match :: Lazy Get a -> Lazy Get (ParserInput (Lazy Get), a)

InputParsing (Lazy Get)

Defined in Text.Parser.Input

Associated Types

type ParserInput (Lazy Get)

type ParserPosition (Lazy Get)

Methods

getInput :: Lazy Get (ParserInput (Lazy Get))

getSourcePos :: Lazy Get (ParserPosition (Lazy Get))

anyToken :: Lazy Get (ParserInput (Lazy Get))

take :: Int -> Lazy Get (ParserInput (Lazy Get))

satisfy :: (ParserInput (Lazy Get) -> Bool) -> Lazy Get (ParserInput (Lazy Get))

notSatisfy :: (ParserInput (Lazy Get) -> Bool) -> Lazy Get ()

scan :: state -> (state -> ParserInput (Lazy Get) -> Maybe state) -> Lazy Get (ParserInput (Lazy Get))

string :: ParserInput (Lazy Get) -> Lazy Get (ParserInput (Lazy Get))

takeWhile :: (ParserInput (Lazy Get) -> Bool) -> Lazy Get (ParserInput (Lazy Get))

takeWhile1 :: (ParserInput (Lazy Get) -> Bool) -> Lazy Get (ParserInput (Lazy Get))

DeterministicParsing (Lazy Get)

Defined in Text.Parser.Deterministic

Methods

(<<|>) :: Lazy Get a -> Lazy Get a -> Lazy Get a

takeOptional :: Lazy Get a -> Lazy Get (Maybe a)

takeMany :: Lazy Get a -> Lazy Get [a]

takeSome :: Lazy Get a -> Lazy Get [a]

concatAll :: Monoid a => Lazy Get a -> Lazy Get a

skipAll :: Lazy Get a -> Lazy Get ()

Eq (f a) => Eq (Lazy f a)

Defined in Text.Parser.Wrapper

Methods

(==) :: Lazy f a -> Lazy f a -> Bool

(/=) :: Lazy f a -> Lazy f a -> Bool

Ord (f a) => Ord (Lazy f a)

Defined in Text.Parser.Wrapper

Methods

compare :: Lazy f a -> Lazy f a -> Ordering

(<) :: Lazy f a -> Lazy f a -> Bool

(<=) :: Lazy f a -> Lazy f a -> Bool

(>) :: Lazy f a -> Lazy f a -> Bool

(>=) :: Lazy f a -> Lazy f a -> Bool

max :: Lazy f a -> Lazy f a -> Lazy f a

min :: Lazy f a -> Lazy f a -> Lazy f a

Read (f a) => Read (Lazy f a)

Defined in Text.Parser.Wrapper

Methods

readsPrec :: Int -> ReadS (Lazy f a)

readList :: ReadS [Lazy f a]

readPrec :: ReadPrec (Lazy f a)

readListPrec :: ReadPrec [Lazy f a]

Show (f a) => Show (Lazy f a)

Defined in Text.Parser.Wrapper

Methods

showsPrec :: Int -> Lazy f a -> ShowS

show :: Lazy f a -> String

showList :: [Lazy f a] -> ShowS

type ParserInput (Lazy Get)

Defined in Text.Parser.Input

type ParserInput (Lazy Get) = ByteString

type ParserPosition (Lazy Get)

Defined in Text.Parser.Input

type ParserPosition (Lazy Get) = Int

newtype Strict f a

Wrapper that signifies strict ByteString inputs

Constructors

Strict

Fields

• getStrict :: f a

Instances

Monad f => Monad (Strict f)

Defined in Text.Parser.Wrapper

Methods

(>>=) :: Strict f a -> (a -> Strict f b) -> Strict f b

(>>) :: Strict f a -> Strict f b -> Strict f b

return :: a -> Strict f a

Functor f => Functor (Strict f)

Defined in Text.Parser.Wrapper

Methods

fmap :: (a -> b) -> Strict f a -> Strict f b

(<$) :: a -> Strict f b -> Strict f a

Applicative f => Applicative (Strict f)

Defined in Text.Parser.Wrapper

Methods

pure :: a -> Strict f a

(<*>) :: Strict f (a -> b) -> Strict f a -> Strict f b

liftA2 :: (a -> b -> c) -> Strict f a -> Strict f b -> Strict f c

(*>) :: Strict f a -> Strict f b -> Strict f b

(<*) :: Strict f a -> Strict f b -> Strict f a

Alternative f => Alternative (Strict f)

Defined in Text.Parser.Wrapper

Methods

empty :: Strict f a

(<|>) :: Strict f a -> Strict f a -> Strict f a

some :: Strict f a -> Strict f [a]

many :: Strict f a -> Strict f [a]

MonadPlus f => MonadPlus (Strict f)

Defined in Text.Parser.Wrapper

Methods

mzero :: Strict f a

mplus :: Strict f a -> Strict f a -> Strict f a

TokenParsing f => TokenParsing (Strict f)

Defined in Text.Parser.Wrapper

Methods

someSpace :: Strict f ()

nesting :: Strict f a -> Strict f a

semi :: Strict f Char

highlight :: Highlight -> Strict f a -> Strict f a

token :: Strict f a -> Strict f a

LookAheadParsing f => LookAheadParsing (Strict f)

Defined in Text.Parser.Wrapper

Methods

lookAhead :: Strict f a -> Strict f a

CharParsing f => CharParsing (Strict f)

Defined in Text.Parser.Wrapper

Methods

satisfy :: (Char -> Bool) -> Strict f Char

char :: Char -> Strict f Char

notChar :: Char -> Strict f Char

anyChar :: Strict f Char

string :: String -> Strict f String

text :: Text -> Strict f Text

Parsing f => Parsing (Strict f)

Defined in Text.Parser.Wrapper

Methods

try :: Strict f a -> Strict f a

(<?>) :: Strict f a -> String -> Strict f a

skipMany :: Strict f a -> Strict f ()

skipSome :: Strict f a -> Strict f ()

unexpected :: String -> Strict f a

eof :: Strict f ()

notFollowedBy :: Show a => Strict f a -> Strict f ()

ConsumedInputParsing (Strict Get)

Defined in Text.Parser.Input

Methods

match :: Strict Get a -> Strict Get (ParserInput (Strict Get), a)

InputParsing (Strict Get)

Defined in Text.Parser.Input

Associated Types

type ParserInput (Strict Get)

type ParserPosition (Strict Get)

Methods

getInput :: Strict Get (ParserInput (Strict Get))

getSourcePos :: Strict Get (ParserPosition (Strict Get))

anyToken :: Strict Get (ParserInput (Strict Get))

take :: Int -> Strict Get (ParserInput (Strict Get))

satisfy :: (ParserInput (Strict Get) -> Bool) -> Strict Get (ParserInput (Strict Get))

notSatisfy :: (ParserInput (Strict Get) -> Bool) -> Strict Get ()

scan :: state -> (state -> ParserInput (Strict Get) -> Maybe state) -> Strict Get (ParserInput (Strict Get))

string :: ParserInput (Strict Get) -> Strict Get (ParserInput (Strict Get))

takeWhile :: (ParserInput (Strict Get) -> Bool) -> Strict Get (ParserInput (Strict Get))

takeWhile1 :: (ParserInput (Strict Get) -> Bool) -> Strict Get (ParserInput (Strict Get))

DeterministicParsing (Strict Get)

Defined in Text.Parser.Deterministic

Methods

(<<|>) :: Strict Get a -> Strict Get a -> Strict Get a

takeOptional :: Strict Get a -> Strict Get (Maybe a)

takeMany :: Strict Get a -> Strict Get [a]

takeSome :: Strict Get a -> Strict Get [a]

concatAll :: Monoid a => Strict Get a -> Strict Get a

skipAll :: Strict Get a -> Strict Get ()

Eq (f a) => Eq (Strict f a)

Defined in Text.Parser.Wrapper

Methods

(==) :: Strict f a -> Strict f a -> Bool

(/=) :: Strict f a -> Strict f a -> Bool

Ord (f a) => Ord (Strict f a)

Defined in Text.Parser.Wrapper

Methods

compare :: Strict f a -> Strict f a -> Ordering

(<) :: Strict f a -> Strict f a -> Bool

(<=) :: Strict f a -> Strict f a -> Bool

(>) :: Strict f a -> Strict f a -> Bool

(>=) :: Strict f a -> Strict f a -> Bool

max :: Strict f a -> Strict f a -> Strict f a

min :: Strict f a -> Strict f a -> Strict f a

Read (f a) => Read (Strict f a)

Defined in Text.Parser.Wrapper

Methods

readsPrec :: Int -> ReadS (Strict f a)

readList :: ReadS [Strict f a]

readPrec :: ReadPrec (Strict f a)

readListPrec :: ReadPrec [Strict f a]

Show (f a) => Show (Strict f a)

Defined in Text.Parser.Wrapper

Methods

showsPrec :: Int -> Strict f a -> ShowS

show :: Strict f a -> String

showList :: [Strict f a] -> ShowS

type ParserInput (Strict Get)

Defined in Text.Parser.Input

type ParserInput (Strict Get) = ByteString

type ParserPosition (Strict Get)

Defined in Text.Parser.Input

type ParserPosition (Strict Get) = Int