Copyright	(C) 2011-2019 Edward Kmett
License	BSD-style (see the file LICENSE)
Maintainer	Edward Kmett <ekmett@gmail.com>
Stability	experimental
Portability	non-portable
Safe Haskell	None
Language	Haskell2010

Text.Trifecta

Description

For a short introduction, see the Text.Trifecta.Tutorial module.

Synopsis

module Text.Trifecta.Rendering
module Text.Trifecta.Highlight
module Text.Trifecta.Parser
module Text.Trifecta.Combinators
module Text.Trifecta.Result
module Text.Trifecta.Rope
some :: Alternative f => f a -> f [a]
many :: Alternative f => f a -> f [a]
class Alternative m => Parsing (m :: Type -> Type) where
- try :: m a -> m a
- (<?>) :: m a -> String -> m a
- skipMany :: m a -> m ()
- skipSome :: m a -> m ()
- unexpected :: String -> m a
- eof :: m ()
- notFollowedBy :: Show a => m a -> m ()
choice :: Alternative m => [m a] -> m a
count :: Applicative m => Int -> m a -> m [a]
between :: Applicative m => m bra -> m ket -> m a -> m a
option :: Alternative m => a -> m a -> m a
optional :: Alternative f => f a -> f (Maybe a)
sepBy :: Alternative m => m a -> m sep -> m [a]
sepBy1 :: Alternative m => m a -> m sep -> m [a]
endBy :: Alternative m => m a -> m sep -> m [a]
endBy1 :: Alternative m => m a -> m sep -> m [a]
chainr :: Alternative m => m a -> m (a -> a -> a) -> a -> m a
chainl :: Alternative m => m a -> m (a -> a -> a) -> a -> m a
chainr1 :: Alternative m => m a -> m (a -> a -> a) -> m a
chainl1 :: Alternative m => m a -> m (a -> a -> a) -> m a
manyTill :: Alternative m => m a -> m end -> m [a]
sepEndBy1 :: Alternative m => m a -> m sep -> m [a]
sepEndBy :: Alternative m => m a -> m sep -> m [a]
skipOptional :: Alternative m => m a -> m ()
surroundedBy :: Applicative m => m a -> m sur -> m a
sepByNonEmpty :: Alternative m => m a -> m sep -> m (NonEmpty a)
sepEndByNonEmpty :: Alternative m => m a -> m sep -> m (NonEmpty a)
endByNonEmpty :: Alternative m => m a -> m sep -> m (NonEmpty a)
class Parsing m => CharParsing (m :: Type -> Type) where
- satisfy :: (Char -> Bool) -> m Char
- char :: Char -> m Char
- notChar :: Char -> m Char
- anyChar :: m Char
- string :: String -> m String
- text :: Text -> m Text
space :: CharParsing m => m Char
lower :: CharParsing m => m Char
upper :: CharParsing m => m Char
alphaNum :: CharParsing m => m Char
digit :: CharParsing m => m Char
octDigit :: CharParsing m => m Char
letter :: CharParsing m => m Char
noneOf :: CharParsing m => [Char] -> m Char
oneOf :: CharParsing m => [Char] -> m Char
spaces :: CharParsing m => m ()
newline :: CharParsing m => m Char
tab :: CharParsing m => m Char
hexDigit :: CharParsing m => m Char
oneOfSet :: CharParsing m => CharSet -> m Char
noneOfSet :: CharParsing m => CharSet -> m Char
satisfyRange :: CharParsing m => Char -> Char -> m Char
scientific :: TokenParsing m => m Scientific
parens :: TokenParsing m => m a -> m a
symbol :: TokenParsing m => String -> m String
octal :: TokenParsing m => m Integer
decimal :: TokenParsing m => m Integer
class CharParsing m => TokenParsing (m :: Type -> Type) where
- someSpace :: m ()
- nesting :: m a -> m a
- semi :: m Char
- highlight :: Highlight -> m a -> m a
- token :: m a -> m a
commaSep1 :: TokenParsing m => m a -> m [a]
commaSep :: TokenParsing m => m a -> m [a]
semiSep1 :: TokenParsing m => m a -> m [a]
semiSep :: TokenParsing m => m a -> m [a]
dot :: TokenParsing m => m Char
colon :: TokenParsing m => m Char
comma :: TokenParsing m => m Char
brackets :: TokenParsing m => m a -> m a
angles :: TokenParsing m => m a -> m a
braces :: TokenParsing m => m a -> m a
whiteSpace :: TokenParsing m => m ()
hexadecimal :: TokenParsing m => m Integer
integer :: TokenParsing m => m Integer
natural :: TokenParsing m => m Integer
stringLiteral :: (TokenParsing m, IsString s) => m s
charLiteral :: TokenParsing m => m Char
newtype Unlined (m :: Type -> Type) a = Unlined {
- runUnlined :: m a
}
newtype Unspaced (m :: Type -> Type) a = Unspaced {
- runUnspaced :: m a
}
newtype Unhighlighted (m :: Type -> Type) a = Unhighlighted {
- runUnhighlighted :: m a
}
data IdentifierStyle (m :: Type -> Type) = IdentifierStyle {
- _styleName :: String
- _styleStart :: m Char
- _styleLetter :: m Char
- _styleReserved :: HashSet String
- _styleHighlight :: Highlight
- _styleReservedHighlight :: Highlight
}
stringLiteral' :: (TokenParsing m, IsString s) => m s
double :: TokenParsing m => m Double
naturalOrDouble :: TokenParsing m => m (Either Integer Double)
integerOrDouble :: TokenParsing m => m (Either Integer Double)
naturalOrScientific :: TokenParsing m => m (Either Integer Scientific)
integerOrScientific :: TokenParsing m => m (Either Integer Scientific)
textSymbol :: TokenParsing m => Text -> m Text
symbolic :: TokenParsing m => Char -> m Char
styleName :: forall f (m :: Type -> Type). Functor f => (String -> f String) -> IdentifierStyle m -> f (IdentifierStyle m)
styleStart :: Functor f => (m Char -> f (m Char)) -> IdentifierStyle m -> f (IdentifierStyle m)
styleLetter :: Functor f => (m Char -> f (m Char)) -> IdentifierStyle m -> f (IdentifierStyle m)
styleChars :: Applicative f => (m Char -> f (n Char)) -> IdentifierStyle m -> f (IdentifierStyle n)
styleReserved :: forall f (m :: Type -> Type). Functor f => (HashSet String -> f (HashSet String)) -> IdentifierStyle m -> f (IdentifierStyle m)
styleHighlight :: forall f (m :: Type -> Type). Functor f => (Highlight -> f Highlight) -> IdentifierStyle m -> f (IdentifierStyle m)
styleReservedHighlight :: forall f (m :: Type -> Type). Functor f => (Highlight -> f Highlight) -> IdentifierStyle m -> f (IdentifierStyle m)
styleHighlights :: forall f (m :: Type -> Type). Applicative f => (Highlight -> f Highlight) -> IdentifierStyle m -> f (IdentifierStyle m)
liftIdentifierStyle :: forall (t :: (Type -> Type) -> Type -> Type) (m :: Type -> Type). (MonadTrans t, Monad m) => IdentifierStyle m -> IdentifierStyle (t m)
reserve :: (TokenParsing m, Monad m) => IdentifierStyle m -> String -> m ()
reserveText :: (TokenParsing m, Monad m) => IdentifierStyle m -> Text -> m ()
ident :: (TokenParsing m, Monad m, IsString s) => IdentifierStyle m -> m s
characterChar :: TokenParsing m => m Char
integer' :: TokenParsing m => m Integer

Documentation

module Text.Trifecta.Rendering

module Text.Trifecta.Highlight

module Text.Trifecta.Parser

module Text.Trifecta.Combinators

module Text.Trifecta.Result

module Text.Trifecta.Rope

some :: Alternative f => f a -> f [a] Source #

One or more.

Examples

Expand

>>> some (putStr "la")
lalalalalalalalala... * goes on forever *

>>> some Nothing
nothing

>>> take 5 <$> some (Just 1)
* hangs forever *

Note that this function can be used with Parsers based on Applicatives. In that case some parser will attempt to parse parser one or more times until it fails.

many :: Alternative f => f a -> f [a] Source #

Zero or more.

Examples

Expand

>>> many (putStr "la")
lalalalalalalalala... * goes on forever *

>>> many Nothing
Just []

>>> take 5 <$> many (Just 1)
* hangs forever *

Note that this function can be used with Parsers based on Applicatives. In that case many parser will attempt to parse parser zero or more times until it fails.

class Alternative m => Parsing (m :: Type -> Type) where #

Minimal complete definition

try, (<?>), notFollowedBy

Methods

try :: m a -> m a #

(<?>) :: m a -> String -> m a #

skipMany :: m a -> m () #

skipSome :: m a -> m () #

unexpected :: String -> m a #

eof :: m () #

notFollowedBy :: Show a => m a -> m () #

Instances

Instances details

Parsing Get
Instance details Defined in Text.Parser.Combinators Methods try :: Get a -> Get a # (<?>) :: Get a -> String -> Get a # skipMany :: Get a -> Get () # skipSome :: Get a -> Get () # unexpected :: String -> Get a # eof :: Get () # notFollowedBy :: Show a => Get a -> Get () #
Parsing ReadP
Instance details Defined in Text.Parser.Combinators Methods try :: ReadP a -> ReadP a # (<?>) :: ReadP a -> String -> ReadP a # skipMany :: ReadP a -> ReadP () # skipSome :: ReadP a -> ReadP () # unexpected :: String -> ReadP a # eof :: ReadP () # notFollowedBy :: Show a => ReadP a -> ReadP () #
Parsing Parser Source #
Instance details Defined in Text.Trifecta.Parser Methods try :: Parser a -> Parser a # (<?>) :: Parser a -> String -> Parser a # skipMany :: Parser a -> Parser () # skipSome :: Parser a -> Parser () # unexpected :: String -> Parser a # eof :: Parser () # notFollowedBy :: Show a => Parser a -> Parser () #
Chunk t => Parsing (Parser t)
Instance details Defined in Text.Parser.Combinators Methods try :: Parser t a -> Parser t a # (<?>) :: Parser t a -> String -> Parser t a # skipMany :: Parser t a -> Parser t () # skipSome :: Parser t a -> Parser t () # unexpected :: String -> Parser t a # eof :: Parser t () # notFollowedBy :: Show a => Parser t a -> Parser t () #
Parsing m => Parsing (Unhighlighted m)
Instance details Defined in Text.Parser.Token Methods try :: Unhighlighted m a -> Unhighlighted m a # (<?>) :: Unhighlighted m a -> String -> Unhighlighted m a # skipMany :: Unhighlighted m a -> Unhighlighted m () # skipSome :: Unhighlighted m a -> Unhighlighted m () # unexpected :: String -> Unhighlighted m a # eof :: Unhighlighted m () # notFollowedBy :: Show a => Unhighlighted m a -> Unhighlighted m () #
Parsing m => Parsing (Unlined m)
Instance details Defined in Text.Parser.Token Methods try :: Unlined m a -> Unlined m a # (<?>) :: Unlined m a -> String -> Unlined m a # skipMany :: Unlined m a -> Unlined m () # skipSome :: Unlined m a -> Unlined m () # unexpected :: String -> Unlined m a # eof :: Unlined m () # notFollowedBy :: Show a => Unlined m a -> Unlined m () #
Parsing m => Parsing (Unspaced m)
Instance details Defined in Text.Parser.Token Methods try :: Unspaced m a -> Unspaced m a # (<?>) :: Unspaced m a -> String -> Unspaced m a # skipMany :: Unspaced m a -> Unspaced m () # skipSome :: Unspaced m a -> Unspaced m () # unexpected :: String -> Unspaced m a # eof :: Unspaced m () # notFollowedBy :: Show a => Unspaced m a -> Unspaced m () #
(Parsing m, Monad m) => Parsing (IdentityT m)
Instance details Defined in Text.Parser.Combinators Methods try :: IdentityT m a -> IdentityT m a # (<?>) :: IdentityT m a -> String -> IdentityT m a # skipMany :: IdentityT m a -> IdentityT m () # skipSome :: IdentityT m a -> IdentityT m () # unexpected :: String -> IdentityT m a # eof :: IdentityT m () # notFollowedBy :: Show a => IdentityT m a -> IdentityT m () #
(Parsing m, MonadPlus m) => Parsing (ReaderT e m)
Instance details Defined in Text.Parser.Combinators Methods try :: ReaderT e m a -> ReaderT e m a # (<?>) :: ReaderT e m a -> String -> ReaderT e m a # skipMany :: ReaderT e m a -> ReaderT e m () # skipSome :: ReaderT e m a -> ReaderT e m () # unexpected :: String -> ReaderT e m a # eof :: ReaderT e m () # notFollowedBy :: Show a => ReaderT e m a -> ReaderT e m () #
(Parsing m, MonadPlus m) => Parsing (StateT s m)
Instance details Defined in Text.Parser.Combinators Methods try :: StateT s m a -> StateT s m a # (<?>) :: StateT s m a -> String -> StateT s m a # skipMany :: StateT s m a -> StateT s m () # skipSome :: StateT s m a -> StateT s m () # unexpected :: String -> StateT s m a # eof :: StateT s m () # notFollowedBy :: Show a => StateT s m a -> StateT s m () #
(Parsing m, MonadPlus m) => Parsing (StateT s m)
Instance details Defined in Text.Parser.Combinators Methods try :: StateT s m a -> StateT s m a # (<?>) :: StateT s m a -> String -> StateT s m a # skipMany :: StateT s m a -> StateT s m () # skipSome :: StateT s m a -> StateT s m () # unexpected :: String -> StateT s m a # eof :: StateT s m () # notFollowedBy :: Show a => StateT s m a -> StateT s m () #
(Parsing m, MonadPlus m, Monoid w) => Parsing (WriterT w m)
Instance details Defined in Text.Parser.Combinators Methods try :: WriterT w m a -> WriterT w m a # (<?>) :: WriterT w m a -> String -> WriterT w m a # skipMany :: WriterT w m a -> WriterT w m () # skipSome :: WriterT w m a -> WriterT w m () # unexpected :: String -> WriterT w m a # eof :: WriterT w m () # notFollowedBy :: Show a => WriterT w m a -> WriterT w m () #
(Parsing m, MonadPlus m, Monoid w) => Parsing (WriterT w m)
Instance details Defined in Text.Parser.Combinators Methods try :: WriterT w m a -> WriterT w m a # (<?>) :: WriterT w m a -> String -> WriterT w m a # skipMany :: WriterT w m a -> WriterT w m () # skipSome :: WriterT w m a -> WriterT w m () # unexpected :: String -> WriterT w m a # eof :: WriterT w m () # notFollowedBy :: Show a => WriterT w m a -> WriterT w m () #
(Stream s m t, Show t) => Parsing (ParsecT s u m)
Instance details Defined in Text.Parser.Combinators Methods try :: ParsecT s u m a -> ParsecT s u m a # (<?>) :: ParsecT s u m a -> String -> ParsecT s u m a # skipMany :: ParsecT s u m a -> ParsecT s u m () # skipSome :: ParsecT s u m a -> ParsecT s u m () # unexpected :: String -> ParsecT s u m a # eof :: ParsecT s u m () # notFollowedBy :: Show a => ParsecT s u m a -> ParsecT s u m () #
(Parsing m, MonadPlus m, Monoid w) => Parsing (RWST r w s m)
Instance details Defined in Text.Parser.Combinators Methods try :: RWST r w s m a -> RWST r w s m a # (<?>) :: RWST r w s m a -> String -> RWST r w s m a # skipMany :: RWST r w s m a -> RWST r w s m () # skipSome :: RWST r w s m a -> RWST r w s m () # unexpected :: String -> RWST r w s m a # eof :: RWST r w s m () # notFollowedBy :: Show a => RWST r w s m a -> RWST r w s m () #
(Parsing m, MonadPlus m, Monoid w) => Parsing (RWST r w s m)
Instance details Defined in Text.Parser.Combinators Methods try :: RWST r w s m a -> RWST r w s m a # (<?>) :: RWST r w s m a -> String -> RWST r w s m a # skipMany :: RWST r w s m a -> RWST r w s m () # skipSome :: RWST r w s m a -> RWST r w s m () # unexpected :: String -> RWST r w s m a # eof :: RWST r w s m () # notFollowedBy :: Show a => RWST r w s m a -> RWST r w s m () #

choice :: Alternative m => [m a] -> m a #

count :: Applicative m => Int -> m a -> m [a] #

between :: Applicative m => m bra -> m ket -> m a -> m a #

option :: Alternative m => a -> m a -> m a #

optional :: Alternative f => f a -> f (Maybe a) Source #

One or none.

It is useful for modelling any computation that is allowed to fail.

Examples

Expand

Using the Alternative instance of Control.Monad.Except, the following functions:

>>> import Control.Monad.Except

>>> canFail = throwError "it failed" :: Except String Int
>>> final = return 42                :: Except String Int

Can be combined by allowing the first function to fail:

>>> runExcept $ canFail *> final
Left "it failed"

>>> runExcept $ optional canFail *> final
Right 42

sepBy :: Alternative m => m a -> m sep -> m [a] #

sepBy1 :: Alternative m => m a -> m sep -> m [a] #

endBy :: Alternative m => m a -> m sep -> m [a] #

endBy1 :: Alternative m => m a -> m sep -> m [a] #

chainr :: Alternative m => m a -> m (a -> a -> a) -> a -> m a #

chainl :: Alternative m => m a -> m (a -> a -> a) -> a -> m a #

chainr1 :: Alternative m => m a -> m (a -> a -> a) -> m a #

chainl1 :: Alternative m => m a -> m (a -> a -> a) -> m a #

manyTill :: Alternative m => m a -> m end -> m [a] #

sepEndBy1 :: Alternative m => m a -> m sep -> m [a] #

sepEndBy :: Alternative m => m a -> m sep -> m [a] #

skipOptional :: Alternative m => m a -> m () #

surroundedBy :: Applicative m => m a -> m sur -> m a #

sepByNonEmpty :: Alternative m => m a -> m sep -> m (NonEmpty a) #

sepEndByNonEmpty :: Alternative m => m a -> m sep -> m (NonEmpty a) #

endByNonEmpty :: Alternative m => m a -> m sep -> m (NonEmpty a) #

class Parsing m => CharParsing (m :: Type -> Type) where #

Minimal complete definition

Nothing

Methods

satisfy :: (Char -> Bool) -> m Char #

char :: Char -> m Char #

notChar :: Char -> m Char #

anyChar :: m Char #

string :: String -> m String #

text :: Text -> m Text #

Instances

Instances details

CharParsing ReadP
Instance details Defined in Text.Parser.Char Methods satisfy :: (Char -> Bool) -> ReadP Char # char :: Char -> ReadP Char # notChar :: Char -> ReadP Char # anyChar :: ReadP Char # string :: String -> ReadP String # text :: Text -> ReadP Text #
CharParsing Parser Source #
Instance details Defined in Text.Trifecta.Parser Methods satisfy :: (Char -> Bool) -> Parser Char # char :: Char -> Parser Char # notChar :: Char -> Parser Char # anyChar :: Parser Char # string :: String -> Parser String # text :: Text -> Parser Text #
Chunk t => CharParsing (Parser t)
Instance details Defined in Text.Parser.Char Methods satisfy :: (Char -> Bool) -> Parser t Char # char :: Char -> Parser t Char # notChar :: Char -> Parser t Char # anyChar :: Parser t Char # string :: String -> Parser t String # text :: Text -> Parser t Text #
CharParsing m => CharParsing (Unhighlighted m)
Instance details Defined in Text.Parser.Token Methods satisfy :: (Char -> Bool) -> Unhighlighted m Char # char :: Char -> Unhighlighted m Char # notChar :: Char -> Unhighlighted m Char # anyChar :: Unhighlighted m Char # string :: String -> Unhighlighted m String # text :: Text -> Unhighlighted m Text #
CharParsing m => CharParsing (Unlined m)
Instance details Defined in Text.Parser.Token Methods satisfy :: (Char -> Bool) -> Unlined m Char # char :: Char -> Unlined m Char # notChar :: Char -> Unlined m Char # anyChar :: Unlined m Char # string :: String -> Unlined m String # text :: Text -> Unlined m Text #
CharParsing m => CharParsing (Unspaced m)
Instance details Defined in Text.Parser.Token Methods satisfy :: (Char -> Bool) -> Unspaced m Char # char :: Char -> Unspaced m Char # notChar :: Char -> Unspaced m Char # anyChar :: Unspaced m Char # string :: String -> Unspaced m String # text :: Text -> Unspaced m Text #
(CharParsing m, MonadPlus m) => CharParsing (IdentityT m)
Instance details Defined in Text.Parser.Char Methods satisfy :: (Char -> Bool) -> IdentityT m Char # char :: Char -> IdentityT m Char # notChar :: Char -> IdentityT m Char # anyChar :: IdentityT m Char # string :: String -> IdentityT m String # text :: Text -> IdentityT m Text #
(CharParsing m, MonadPlus m) => CharParsing (ReaderT e m)
Instance details Defined in Text.Parser.Char Methods satisfy :: (Char -> Bool) -> ReaderT e m Char # char :: Char -> ReaderT e m Char # notChar :: Char -> ReaderT e m Char # anyChar :: ReaderT e m Char # string :: String -> ReaderT e m String # text :: Text -> ReaderT e m Text #
(CharParsing m, MonadPlus m) => CharParsing (StateT s m)
Instance details Defined in Text.Parser.Char Methods satisfy :: (Char -> Bool) -> StateT s m Char # char :: Char -> StateT s m Char # notChar :: Char -> StateT s m Char # anyChar :: StateT s m Char # string :: String -> StateT s m String # text :: Text -> StateT s m Text #
(CharParsing m, MonadPlus m) => CharParsing (StateT s m)
Instance details Defined in Text.Parser.Char Methods satisfy :: (Char -> Bool) -> StateT s m Char # char :: Char -> StateT s m Char # notChar :: Char -> StateT s m Char # anyChar :: StateT s m Char # string :: String -> StateT s m String # text :: Text -> StateT s m Text #
(CharParsing m, MonadPlus m, Monoid w) => CharParsing (WriterT w m)
Instance details Defined in Text.Parser.Char Methods satisfy :: (Char -> Bool) -> WriterT w m Char # char :: Char -> WriterT w m Char # notChar :: Char -> WriterT w m Char # anyChar :: WriterT w m Char # string :: String -> WriterT w m String # text :: Text -> WriterT w m Text #
(CharParsing m, MonadPlus m, Monoid w) => CharParsing (WriterT w m)
Instance details Defined in Text.Parser.Char Methods satisfy :: (Char -> Bool) -> WriterT w m Char # char :: Char -> WriterT w m Char # notChar :: Char -> WriterT w m Char # anyChar :: WriterT w m Char # string :: String -> WriterT w m String # text :: Text -> WriterT w m Text #
Stream s m Char => CharParsing (ParsecT s u m)
Instance details Defined in Text.Parser.Char Methods satisfy :: (Char -> Bool) -> ParsecT s u m Char # char :: Char -> ParsecT s u m Char # notChar :: Char -> ParsecT s u m Char # anyChar :: ParsecT s u m Char # string :: String -> ParsecT s u m String # text :: Text -> ParsecT s u m Text #
(CharParsing m, MonadPlus m, Monoid w) => CharParsing (RWST r w s m)
Instance details Defined in Text.Parser.Char Methods satisfy :: (Char -> Bool) -> RWST r w s m Char # char :: Char -> RWST r w s m Char # notChar :: Char -> RWST r w s m Char # anyChar :: RWST r w s m Char # string :: String -> RWST r w s m String # text :: Text -> RWST r w s m Text #
(CharParsing m, MonadPlus m, Monoid w) => CharParsing (RWST r w s m)
Instance details Defined in Text.Parser.Char Methods satisfy :: (Char -> Bool) -> RWST r w s m Char # char :: Char -> RWST r w s m Char # notChar :: Char -> RWST r w s m Char # anyChar :: RWST r w s m Char # string :: String -> RWST r w s m String # text :: Text -> RWST r w s m Text #

space :: CharParsing m => m Char #

lower :: CharParsing m => m Char #

upper :: CharParsing m => m Char #

alphaNum :: CharParsing m => m Char #

digit :: CharParsing m => m Char #

octDigit :: CharParsing m => m Char #

letter :: CharParsing m => m Char #

noneOf :: CharParsing m => [Char] -> m Char #

oneOf :: CharParsing m => [Char] -> m Char #

spaces :: CharParsing m => m () #

newline :: CharParsing m => m Char #

tab :: CharParsing m => m Char #

hexDigit :: CharParsing m => m Char #

oneOfSet :: CharParsing m => CharSet -> m Char #

noneOfSet :: CharParsing m => CharSet -> m Char #

satisfyRange :: CharParsing m => Char -> Char -> m Char #

scientific :: TokenParsing m => m Scientific #

parens :: TokenParsing m => m a -> m a #

symbol :: TokenParsing m => String -> m String #

octal :: TokenParsing m => m Integer #

decimal :: TokenParsing m => m Integer #

class CharParsing m => TokenParsing (m :: Type -> Type) where #

Minimal complete definition

Nothing

Methods

someSpace :: m () #

nesting :: m a -> m a #

semi :: m Char #

highlight :: Highlight -> m a -> m a #

token :: m a -> m a #

Instances

Instances details

TokenParsing ReadP
Instance details Defined in Text.Parser.Token Methods someSpace :: ReadP () # nesting :: ReadP a -> ReadP a # semi :: ReadP Char # highlight :: Highlight -> ReadP a -> ReadP a # token :: ReadP a -> ReadP a #
TokenParsing Parser Source #
Instance details Defined in Text.Trifecta.Parser Methods someSpace :: Parser () # nesting :: Parser a -> Parser a # semi :: Parser Char # highlight :: Highlight -> Parser a -> Parser a # token :: Parser a -> Parser a #
Chunk t => TokenParsing (Parser t)
Instance details Defined in Text.Parser.Token Methods someSpace :: Parser t () # nesting :: Parser t a -> Parser t a # semi :: Parser t Char # highlight :: Highlight -> Parser t a -> Parser t a # token :: Parser t a -> Parser t a #
TokenParsing m => TokenParsing (Unhighlighted m)
Instance details Defined in Text.Parser.Token Methods someSpace :: Unhighlighted m () # nesting :: Unhighlighted m a -> Unhighlighted m a # semi :: Unhighlighted m Char # highlight :: Highlight -> Unhighlighted m a -> Unhighlighted m a # token :: Unhighlighted m a -> Unhighlighted m a #
TokenParsing m => TokenParsing (Unlined m)
Instance details Defined in Text.Parser.Token Methods someSpace :: Unlined m () # nesting :: Unlined m a -> Unlined m a # semi :: Unlined m Char # highlight :: Highlight -> Unlined m a -> Unlined m a # token :: Unlined m a -> Unlined m a #
TokenParsing m => TokenParsing (Unspaced m)
Instance details Defined in Text.Parser.Token Methods someSpace :: Unspaced m () # nesting :: Unspaced m a -> Unspaced m a # semi :: Unspaced m Char # highlight :: Highlight -> Unspaced m a -> Unspaced m a # token :: Unspaced m a -> Unspaced m a #
(TokenParsing m, MonadPlus m) => TokenParsing (IdentityT m)
Instance details Defined in Text.Parser.Token Methods someSpace :: IdentityT m () # nesting :: IdentityT m a -> IdentityT m a # semi :: IdentityT m Char # highlight :: Highlight -> IdentityT m a -> IdentityT m a # token :: IdentityT m a -> IdentityT m a #
(TokenParsing m, MonadPlus m) => TokenParsing (ReaderT e m)
Instance details Defined in Text.Parser.Token Methods someSpace :: ReaderT e m () # nesting :: ReaderT e m a -> ReaderT e m a # semi :: ReaderT e m Char # highlight :: Highlight -> ReaderT e m a -> ReaderT e m a # token :: ReaderT e m a -> ReaderT e m a #
(TokenParsing m, MonadPlus m) => TokenParsing (StateT s m)
Instance details Defined in Text.Parser.Token Methods someSpace :: StateT s m () # nesting :: StateT s m a -> StateT s m a # semi :: StateT s m Char # highlight :: Highlight -> StateT s m a -> StateT s m a # token :: StateT s m a -> StateT s m a #
(TokenParsing m, MonadPlus m) => TokenParsing (StateT s m)
Instance details Defined in Text.Parser.Token Methods someSpace :: StateT s m () # nesting :: StateT s m a -> StateT s m a # semi :: StateT s m Char # highlight :: Highlight -> StateT s m a -> StateT s m a # token :: StateT s m a -> StateT s m a #
(TokenParsing m, MonadPlus m, Monoid w) => TokenParsing (WriterT w m)
Instance details Defined in Text.Parser.Token Methods someSpace :: WriterT w m () # nesting :: WriterT w m a -> WriterT w m a # semi :: WriterT w m Char # highlight :: Highlight -> WriterT w m a -> WriterT w m a # token :: WriterT w m a -> WriterT w m a #
(TokenParsing m, MonadPlus m, Monoid w) => TokenParsing (WriterT w m)
Instance details Defined in Text.Parser.Token Methods someSpace :: WriterT w m () # nesting :: WriterT w m a -> WriterT w m a # semi :: WriterT w m Char # highlight :: Highlight -> WriterT w m a -> WriterT w m a # token :: WriterT w m a -> WriterT w m a #
Stream s m Char => TokenParsing (ParsecT s u m)
Instance details Defined in Text.Parser.Token Methods someSpace :: ParsecT s u m () # nesting :: ParsecT s u m a -> ParsecT s u m a # semi :: ParsecT s u m Char # highlight :: Highlight -> ParsecT s u m a -> ParsecT s u m a # token :: ParsecT s u m a -> ParsecT s u m a #
(TokenParsing m, MonadPlus m, Monoid w) => TokenParsing (RWST r w s m)
Instance details Defined in Text.Parser.Token Methods someSpace :: RWST r w s m () # nesting :: RWST r w s m a -> RWST r w s m a # semi :: RWST r w s m Char # highlight :: Highlight -> RWST r w s m a -> RWST r w s m a # token :: RWST r w s m a -> RWST r w s m a #
(TokenParsing m, MonadPlus m, Monoid w) => TokenParsing (RWST r w s m)
Instance details Defined in Text.Parser.Token Methods someSpace :: RWST r w s m () # nesting :: RWST r w s m a -> RWST r w s m a # semi :: RWST r w s m Char # highlight :: Highlight -> RWST r w s m a -> RWST r w s m a # token :: RWST r w s m a -> RWST r w s m a #

commaSep1 :: TokenParsing m => m a -> m [a] #

commaSep :: TokenParsing m => m a -> m [a] #

semiSep1 :: TokenParsing m => m a -> m [a] #

semiSep :: TokenParsing m => m a -> m [a] #

dot :: TokenParsing m => m Char #

colon :: TokenParsing m => m Char #

comma :: TokenParsing m => m Char #

brackets :: TokenParsing m => m a -> m a #

angles :: TokenParsing m => m a -> m a #

braces :: TokenParsing m => m a -> m a #

whiteSpace :: TokenParsing m => m () #

hexadecimal :: TokenParsing m => m Integer #

integer :: TokenParsing m => m Integer #

natural :: TokenParsing m => m Integer #

stringLiteral :: (TokenParsing m, IsString s) => m s #

charLiteral :: TokenParsing m => m Char #

newtype Unlined (m :: Type -> Type) a #

Constructors

Unlined
Fields runUnlined :: m a

Instances

Instances details

MonadTrans Unlined
Instance details Defined in Text.Parser.Token Methods lift :: Monad m => m a -> Unlined m a Source #
MonadReader e m => MonadReader e (Unlined m)
Instance details Defined in Text.Parser.Token Methods ask :: Unlined m e Source # local :: (e -> e) -> Unlined m a -> Unlined m a Source # reader :: (e -> a) -> Unlined m a Source #
MonadState s m => MonadState s (Unlined m)
Instance details Defined in Text.Parser.Token Methods get :: Unlined m s Source # put :: s -> Unlined m () Source # state :: (s -> (a, s)) -> Unlined m a Source #
MonadWriter e m => MonadWriter e (Unlined m)
Instance details Defined in Text.Parser.Token Methods writer :: (a, e) -> Unlined m a Source # tell :: e -> Unlined m () Source # listen :: Unlined m a -> Unlined m (a, e) Source # pass :: Unlined m (a, e -> e) -> Unlined m a Source #
Alternative m => Alternative (Unlined m)
Instance details Defined in Text.Parser.Token Methods empty :: Unlined m a Source # (<\|>) :: Unlined m a -> Unlined m a -> Unlined m a Source # some :: Unlined m a -> Unlined m [a] Source # many :: Unlined m a -> Unlined m [a] Source #
Applicative m => Applicative (Unlined m)
Instance details Defined in Text.Parser.Token Methods pure :: a -> Unlined m a Source # (<>) :: Unlined m (a -> b) -> Unlined m a -> Unlined m b Source # liftA2 :: (a -> b -> c) -> Unlined m a -> Unlined m b -> Unlined m c Source # (>) :: Unlined m a -> Unlined m b -> Unlined m b Source # (<*) :: Unlined m a -> Unlined m b -> Unlined m a Source #
Functor m => Functor (Unlined m)
Instance details Defined in Text.Parser.Token Methods fmap :: (a -> b) -> Unlined m a -> Unlined m b Source # (<$) :: a -> Unlined m b -> Unlined m a Source #
Monad m => Monad (Unlined m)
Instance details Defined in Text.Parser.Token Methods (>>=) :: Unlined m a -> (a -> Unlined m b) -> Unlined m b Source # (>>) :: Unlined m a -> Unlined m b -> Unlined m b Source # return :: a -> Unlined m a Source #
MonadPlus m => MonadPlus (Unlined m)
Instance details Defined in Text.Parser.Token Methods mzero :: Unlined m a Source # mplus :: Unlined m a -> Unlined m a -> Unlined m a Source #
CharParsing m => CharParsing (Unlined m)
Instance details Defined in Text.Parser.Token Methods satisfy :: (Char -> Bool) -> Unlined m Char # char :: Char -> Unlined m Char # notChar :: Char -> Unlined m Char # anyChar :: Unlined m Char # string :: String -> Unlined m String # text :: Text -> Unlined m Text #
Parsing m => Parsing (Unlined m)
Instance details Defined in Text.Parser.Token Methods try :: Unlined m a -> Unlined m a # (<?>) :: Unlined m a -> String -> Unlined m a # skipMany :: Unlined m a -> Unlined m () # skipSome :: Unlined m a -> Unlined m () # unexpected :: String -> Unlined m a # eof :: Unlined m () # notFollowedBy :: Show a => Unlined m a -> Unlined m () #
TokenParsing m => TokenParsing (Unlined m)
Instance details Defined in Text.Parser.Token Methods someSpace :: Unlined m () # nesting :: Unlined m a -> Unlined m a # semi :: Unlined m Char # highlight :: Highlight -> Unlined m a -> Unlined m a # token :: Unlined m a -> Unlined m a #

newtype Unspaced (m :: Type -> Type) a #

Constructors

Unspaced
Fields runUnspaced :: m a

Instances

Instances details

MonadTrans Unspaced
Instance details Defined in Text.Parser.Token Methods lift :: Monad m => m a -> Unspaced m a Source #
MonadReader e m => MonadReader e (Unspaced m)
Instance details Defined in Text.Parser.Token Methods ask :: Unspaced m e Source # local :: (e -> e) -> Unspaced m a -> Unspaced m a Source # reader :: (e -> a) -> Unspaced m a Source #
MonadState s m => MonadState s (Unspaced m)
Instance details Defined in Text.Parser.Token Methods get :: Unspaced m s Source # put :: s -> Unspaced m () Source # state :: (s -> (a, s)) -> Unspaced m a Source #
MonadWriter e m => MonadWriter e (Unspaced m)
Instance details Defined in Text.Parser.Token Methods writer :: (a, e) -> Unspaced m a Source # tell :: e -> Unspaced m () Source # listen :: Unspaced m a -> Unspaced m (a, e) Source # pass :: Unspaced m (a, e -> e) -> Unspaced m a Source #
Alternative m => Alternative (Unspaced m)
Instance details Defined in Text.Parser.Token Methods empty :: Unspaced m a Source # (<\|>) :: Unspaced m a -> Unspaced m a -> Unspaced m a Source # some :: Unspaced m a -> Unspaced m [a] Source # many :: Unspaced m a -> Unspaced m [a] Source #
Applicative m => Applicative (Unspaced m)
Instance details Defined in Text.Parser.Token Methods pure :: a -> Unspaced m a Source # (<>) :: Unspaced m (a -> b) -> Unspaced m a -> Unspaced m b Source # liftA2 :: (a -> b -> c) -> Unspaced m a -> Unspaced m b -> Unspaced m c Source # (>) :: Unspaced m a -> Unspaced m b -> Unspaced m b Source # (<*) :: Unspaced m a -> Unspaced m b -> Unspaced m a Source #
Functor m => Functor (Unspaced m)
Instance details Defined in Text.Parser.Token Methods fmap :: (a -> b) -> Unspaced m a -> Unspaced m b Source # (<$) :: a -> Unspaced m b -> Unspaced m a Source #
Monad m => Monad (Unspaced m)
Instance details Defined in Text.Parser.Token Methods (>>=) :: Unspaced m a -> (a -> Unspaced m b) -> Unspaced m b Source # (>>) :: Unspaced m a -> Unspaced m b -> Unspaced m b Source # return :: a -> Unspaced m a Source #
MonadPlus m => MonadPlus (Unspaced m)
Instance details Defined in Text.Parser.Token Methods mzero :: Unspaced m a Source # mplus :: Unspaced m a -> Unspaced m a -> Unspaced m a Source #
CharParsing m => CharParsing (Unspaced m)
Instance details Defined in Text.Parser.Token Methods satisfy :: (Char -> Bool) -> Unspaced m Char # char :: Char -> Unspaced m Char # notChar :: Char -> Unspaced m Char # anyChar :: Unspaced m Char # string :: String -> Unspaced m String # text :: Text -> Unspaced m Text #
Parsing m => Parsing (Unspaced m)
Instance details Defined in Text.Parser.Token Methods try :: Unspaced m a -> Unspaced m a # (<?>) :: Unspaced m a -> String -> Unspaced m a # skipMany :: Unspaced m a -> Unspaced m () # skipSome :: Unspaced m a -> Unspaced m () # unexpected :: String -> Unspaced m a # eof :: Unspaced m () # notFollowedBy :: Show a => Unspaced m a -> Unspaced m () #
TokenParsing m => TokenParsing (Unspaced m)
Instance details Defined in Text.Parser.Token Methods someSpace :: Unspaced m () # nesting :: Unspaced m a -> Unspaced m a # semi :: Unspaced m Char # highlight :: Highlight -> Unspaced m a -> Unspaced m a # token :: Unspaced m a -> Unspaced m a #

newtype Unhighlighted (m :: Type -> Type) a #

Constructors

Unhighlighted
Fields runUnhighlighted :: m a

Instances

Instances details

MonadTrans Unhighlighted
Instance details Defined in Text.Parser.Token Methods lift :: Monad m => m a -> Unhighlighted m a Source #
MonadReader e m => MonadReader e (Unhighlighted m)
Instance details Defined in Text.Parser.Token Methods ask :: Unhighlighted m e Source # local :: (e -> e) -> Unhighlighted m a -> Unhighlighted m a Source # reader :: (e -> a) -> Unhighlighted m a Source #
MonadState s m => MonadState s (Unhighlighted m)
Instance details Defined in Text.Parser.Token Methods get :: Unhighlighted m s Source # put :: s -> Unhighlighted m () Source # state :: (s -> (a, s)) -> Unhighlighted m a Source #
MonadWriter e m => MonadWriter e (Unhighlighted m)
Instance details Defined in Text.Parser.Token Methods writer :: (a, e) -> Unhighlighted m a Source # tell :: e -> Unhighlighted m () Source # listen :: Unhighlighted m a -> Unhighlighted m (a, e) Source # pass :: Unhighlighted m (a, e -> e) -> Unhighlighted m a Source #
Alternative m => Alternative (Unhighlighted m)
Instance details Defined in Text.Parser.Token Methods empty :: Unhighlighted m a Source # (<\|>) :: Unhighlighted m a -> Unhighlighted m a -> Unhighlighted m a Source # some :: Unhighlighted m a -> Unhighlighted m [a] Source # many :: Unhighlighted m a -> Unhighlighted m [a] Source #
Applicative m => Applicative (Unhighlighted m)
Instance details Defined in Text.Parser.Token Methods pure :: a -> Unhighlighted m a Source # (<>) :: Unhighlighted m (a -> b) -> Unhighlighted m a -> Unhighlighted m b Source # liftA2 :: (a -> b -> c) -> Unhighlighted m a -> Unhighlighted m b -> Unhighlighted m c Source # (>) :: Unhighlighted m a -> Unhighlighted m b -> Unhighlighted m b Source # (<*) :: Unhighlighted m a -> Unhighlighted m b -> Unhighlighted m a Source #
Functor m => Functor (Unhighlighted m)
Instance details Defined in Text.Parser.Token Methods fmap :: (a -> b) -> Unhighlighted m a -> Unhighlighted m b Source # (<$) :: a -> Unhighlighted m b -> Unhighlighted m a Source #
Monad m => Monad (Unhighlighted m)
Instance details Defined in Text.Parser.Token Methods (>>=) :: Unhighlighted m a -> (a -> Unhighlighted m b) -> Unhighlighted m b Source # (>>) :: Unhighlighted m a -> Unhighlighted m b -> Unhighlighted m b Source # return :: a -> Unhighlighted m a Source #
MonadPlus m => MonadPlus (Unhighlighted m)
Instance details Defined in Text.Parser.Token Methods mzero :: Unhighlighted m a Source # mplus :: Unhighlighted m a -> Unhighlighted m a -> Unhighlighted m a Source #
CharParsing m => CharParsing (Unhighlighted m)
Instance details Defined in Text.Parser.Token Methods satisfy :: (Char -> Bool) -> Unhighlighted m Char # char :: Char -> Unhighlighted m Char # notChar :: Char -> Unhighlighted m Char # anyChar :: Unhighlighted m Char # string :: String -> Unhighlighted m String # text :: Text -> Unhighlighted m Text #
Parsing m => Parsing (Unhighlighted m)
Instance details Defined in Text.Parser.Token Methods try :: Unhighlighted m a -> Unhighlighted m a # (<?>) :: Unhighlighted m a -> String -> Unhighlighted m a # skipMany :: Unhighlighted m a -> Unhighlighted m () # skipSome :: Unhighlighted m a -> Unhighlighted m () # unexpected :: String -> Unhighlighted m a # eof :: Unhighlighted m () # notFollowedBy :: Show a => Unhighlighted m a -> Unhighlighted m () #
TokenParsing m => TokenParsing (Unhighlighted m)
Instance details Defined in Text.Parser.Token Methods someSpace :: Unhighlighted m () # nesting :: Unhighlighted m a -> Unhighlighted m a # semi :: Unhighlighted m Char # highlight :: Highlight -> Unhighlighted m a -> Unhighlighted m a # token :: Unhighlighted m a -> Unhighlighted m a #

data IdentifierStyle (m :: Type -> Type) #

Constructors

IdentifierStyle
Fields _styleName :: String _styleStart :: m Char _styleLetter :: m Char _styleReserved :: HashSet String _styleHighlight :: Highlight _styleReservedHighlight :: Highlight

stringLiteral' :: (TokenParsing m, IsString s) => m s #

double :: TokenParsing m => m Double #

naturalOrDouble :: TokenParsing m => m (Either Integer Double) #

integerOrDouble :: TokenParsing m => m (Either Integer Double) #

naturalOrScientific :: TokenParsing m => m (Either Integer Scientific) #

integerOrScientific :: TokenParsing m => m (Either Integer Scientific) #

textSymbol :: TokenParsing m => Text -> m Text #

symbolic :: TokenParsing m => Char -> m Char #

styleName :: forall f (m :: Type -> Type). Functor f => (String -> f String) -> IdentifierStyle m -> f (IdentifierStyle m) #

styleStart :: Functor f => (m Char -> f (m Char)) -> IdentifierStyle m -> f (IdentifierStyle m) #

styleLetter :: Functor f => (m Char -> f (m Char)) -> IdentifierStyle m -> f (IdentifierStyle m) #

styleChars :: Applicative f => (m Char -> f (n Char)) -> IdentifierStyle m -> f (IdentifierStyle n) #

styleReserved :: forall f (m :: Type -> Type). Functor f => (HashSet String -> f (HashSet String)) -> IdentifierStyle m -> f (IdentifierStyle m) #

styleHighlight :: forall f (m :: Type -> Type). Functor f => (Highlight -> f Highlight) -> IdentifierStyle m -> f (IdentifierStyle m) #

styleReservedHighlight :: forall f (m :: Type -> Type). Functor f => (Highlight -> f Highlight) -> IdentifierStyle m -> f (IdentifierStyle m) #

styleHighlights :: forall f (m :: Type -> Type). Applicative f => (Highlight -> f Highlight) -> IdentifierStyle m -> f (IdentifierStyle m) #

liftIdentifierStyle :: forall (t :: (Type -> Type) -> Type -> Type) (m :: Type -> Type). (MonadTrans t, Monad m) => IdentifierStyle m -> IdentifierStyle (t m) #

reserve :: (TokenParsing m, Monad m) => IdentifierStyle m -> String -> m () #

reserveText :: (TokenParsing m, Monad m) => IdentifierStyle m -> Text -> m () #

ident :: (TokenParsing m, Monad m, IsString s) => IdentifierStyle m -> m s #

characterChar :: TokenParsing m => m Char #

integer' :: TokenParsing m => m Integer #