-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/
-- | Monadic parser combinators
--
-- Parsec is designed from scratch as an industrial-strength parser
-- library. It is simple, safe, well documented (on the package
-- homepage), has extensive libraries and good error messages, and is
-- also fast. It is defined as a monad transformer that can be stacked on
-- arbitrary monads, and it is also parametric in the input stream type.
@package parsec
@version 3.1.3
-- | Textual source positions.
module Text.Parsec.Pos
type SourceName = String
type Line = Int
type Column = Int
-- | The abstract data type SourcePos represents source positions.
-- It contains the name of the source (i.e. file name), a line number and
-- a column number. SourcePos is an instance of the Show,
-- Eq and Ord class.
data SourcePos
-- | Extracts the line number from a source position.
sourceLine :: SourcePos -> Line
-- | Extracts the column number from a source position.
sourceColumn :: SourcePos -> Column
-- | Extracts the name of the source from a source position.
sourceName :: SourcePos -> SourceName
-- | Increments the line number of a source position.
incSourceLine :: SourcePos -> Line -> SourcePos
-- | Increments the column number of a source position.
incSourceColumn :: SourcePos -> Column -> SourcePos
-- | Set the line number of a source position.
setSourceLine :: SourcePos -> Line -> SourcePos
-- | Set the column number of a source position.
setSourceColumn :: SourcePos -> Column -> SourcePos
-- | Set the name of the source.
setSourceName :: SourcePos -> SourceName -> SourcePos
-- | Create a new SourcePos with the given source name, line number
-- and column number.
newPos :: SourceName -> Line -> Column -> SourcePos
-- | Create a new SourcePos with the given source name, and line
-- number and column number set to 1, the upper left.
initialPos :: SourceName -> SourcePos
-- | Update a source position given a character. If the character is a
-- newline ('\n') or carriage return ('\r') the line number is
-- incremented by 1. If the character is a tab ('t') the column number is
-- incremented to the nearest 8'th column, ie. column + 8 -
-- ((column-1) `mod` 8). In all other cases, the column is
-- incremented by 1.
updatePosChar :: SourcePos -> Char -> SourcePos
-- | The expression updatePosString pos s updates the source
-- position pos by calling updatePosChar on every
-- character in s, ie. foldl updatePosChar pos string.
updatePosString :: SourcePos -> String -> SourcePos
instance Typeable SourcePos
instance Eq SourcePos
instance Ord SourcePos
instance Data SourcePos
instance Show SourcePos
-- | Parse errors
module Text.Parsec.Error
-- | This abstract data type represents parse error messages. There are
-- four kinds of messages:
--
--
-- data Message = SysUnExpect String
-- | UnExpect String
-- | Expect String
-- | Message String
--
--
-- The fine distinction between different kinds of parse errors allows
-- the system to generate quite good error messages for the user. It also
-- allows error messages that are formatted in different languages. Each
-- kind of message is generated by different combinators:
--
--
-- - A SysUnExpect message is automatically generated by the
-- satisfy combinator. The argument is the unexpected input.
-- - A UnExpect message is generated by the unexpected
-- combinator. The argument describes the unexpected item.
-- - A Expect message is generated by the <?>
-- combinator. The argument describes the expected item.
-- - A Message message is generated by the fail
-- combinator. The argument is some general parser message.
--
data Message
SysUnExpect :: !String -> Message
UnExpect :: !String -> Message
Expect :: !String -> Message
Message :: !String -> Message
-- | Extract the message string from an error message
messageString :: Message -> String
-- | The abstract data type ParseError represents parse errors. It
-- provides the source position (SourcePos) of the error and a
-- list of error messages (Message). A ParseError can be
-- returned by the function parse. ParseError is an
-- instance of the Show class.
data ParseError
-- | Extracts the source position from the parse error
errorPos :: ParseError -> SourcePos
-- | Extracts the list of error messages from the parse error
errorMessages :: ParseError -> [Message]
errorIsUnknown :: ParseError -> Bool
showErrorMessages :: String -> String -> String -> String -> String -> [Message] -> String
newErrorMessage :: Message -> SourcePos -> ParseError
newErrorUnknown :: SourcePos -> ParseError
addErrorMessage :: Message -> ParseError -> ParseError
setErrorPos :: SourcePos -> ParseError -> ParseError
setErrorMessage :: Message -> ParseError -> ParseError
mergeError :: ParseError -> ParseError -> ParseError
instance Show ParseError
instance Ord Message
instance Eq Message
instance Enum Message
-- | Parsec compatibility module
module Text.ParserCombinators.Parsec.Error
-- | This abstract data type represents parse error messages. There are
-- four kinds of messages:
--
--
-- data Message = SysUnExpect String
-- | UnExpect String
-- | Expect String
-- | Message String
--
--
-- The fine distinction between different kinds of parse errors allows
-- the system to generate quite good error messages for the user. It also
-- allows error messages that are formatted in different languages. Each
-- kind of message is generated by different combinators:
--
--
-- - A SysUnExpect message is automatically generated by the
-- satisfy combinator. The argument is the unexpected input.
-- - A UnExpect message is generated by the unexpected
-- combinator. The argument describes the unexpected item.
-- - A Expect message is generated by the <?>
-- combinator. The argument describes the expected item.
-- - A Message message is generated by the fail
-- combinator. The argument is some general parser message.
--
data Message
SysUnExpect :: !String -> Message
UnExpect :: !String -> Message
Expect :: !String -> Message
Message :: !String -> Message
-- | Extract the message string from an error message
messageString :: Message -> String
messageCompare :: Message -> Message -> Ordering
messageEq :: Message -> Message -> Bool
-- | The abstract data type ParseError represents parse errors. It
-- provides the source position (SourcePos) of the error and a
-- list of error messages (Message). A ParseError can be
-- returned by the function parse. ParseError is an
-- instance of the Show class.
data ParseError
-- | Extracts the source position from the parse error
errorPos :: ParseError -> SourcePos
-- | Extracts the list of error messages from the parse error
errorMessages :: ParseError -> [Message]
errorIsUnknown :: ParseError -> Bool
showErrorMessages :: String -> String -> String -> String -> String -> [Message] -> String
newErrorMessage :: Message -> SourcePos -> ParseError
newErrorUnknown :: SourcePos -> ParseError
addErrorMessage :: Message -> ParseError -> ParseError
setErrorPos :: SourcePos -> ParseError -> ParseError
setErrorMessage :: Message -> ParseError -> ParseError
mergeError :: ParseError -> ParseError -> ParseError
-- | Parsec compatibility module
module Text.ParserCombinators.Parsec.Pos
type SourceName = String
type Line = Int
type Column = Int
-- | The abstract data type SourcePos represents source positions.
-- It contains the name of the source (i.e. file name), a line number and
-- a column number. SourcePos is an instance of the Show,
-- Eq and Ord class.
data SourcePos
-- | Extracts the line number from a source position.
sourceLine :: SourcePos -> Line
-- | Extracts the column number from a source position.
sourceColumn :: SourcePos -> Column
-- | Extracts the name of the source from a source position.
sourceName :: SourcePos -> SourceName
-- | Increments the line number of a source position.
incSourceLine :: SourcePos -> Line -> SourcePos
-- | Increments the column number of a source position.
incSourceColumn :: SourcePos -> Column -> SourcePos
-- | Set the line number of a source position.
setSourceLine :: SourcePos -> Line -> SourcePos
-- | Set the column number of a source position.
setSourceColumn :: SourcePos -> Column -> SourcePos
-- | Set the name of the source.
setSourceName :: SourcePos -> SourceName -> SourcePos
-- | Create a new SourcePos with the given source name, line number
-- and column number.
newPos :: SourceName -> Line -> Column -> SourcePos
-- | Create a new SourcePos with the given source name, and line
-- number and column number set to 1, the upper left.
initialPos :: SourceName -> SourcePos
-- | Update a source position given a character. If the character is a
-- newline ('\n') or carriage return ('\r') the line number is
-- incremented by 1. If the character is a tab ('t') the column number is
-- incremented to the nearest 8'th column, ie. column + 8 -
-- ((column-1) `mod` 8). In all other cases, the column is
-- incremented by 1.
updatePosChar :: SourcePos -> Char -> SourcePos
-- | The expression updatePosString pos s updates the source
-- position pos by calling updatePosChar on every
-- character in s, ie. foldl updatePosChar pos string.
updatePosString :: SourcePos -> String -> SourcePos
-- | The primitive parser combinators.
module Text.Parsec.Prim
unknownError :: State s u -> ParseError
sysUnExpectError :: String -> SourcePos -> Reply s u a
-- | The parser unexpected msg always fails with an unexpected
-- error message msg without consuming any input.
--
-- The parsers fail, (<?>) and unexpected
-- are the three parsers used to generate error messages. Of these, only
-- (<?>) is commonly used. For an example of the use of
-- unexpected, see the definition of notFollowedBy.
unexpected :: Stream s m t => String -> ParsecT s u m a
-- | ParserT monad transformer and Parser type
--
-- ParsecT s u m a is a parser with stream type s, user
-- state type u, underlying monad m and return type
-- a. Parsec is strict in the user state. If this is
-- undesirable, simply used a data type like data Box a = Box a
-- and the state type Box YourStateType to add a level of
-- indirection.
data ParsecT s u m a
-- | Low-level unpacking of the ParsecT type. To run your parser, please
-- look to runPT, runP, runParserT, runParser and other such functions.
runParsecT :: Monad m => ParsecT s u m a -> State s u -> m (Consumed (m (Reply s u a)))
-- | Low-level creation of the ParsecT type. You really shouldn't have to
-- do this.
mkPT :: Monad m => (State s u -> m (Consumed (m (Reply s u a)))) -> ParsecT s u m a
type Parsec s u = ParsecT s u Identity
data Consumed a
Consumed :: a -> Consumed a
Empty :: !a -> Consumed a
data Reply s u a
Ok :: a -> !State s u -> ParseError -> Reply s u a
Error :: ParseError -> Reply s u a
data State s u
State :: s -> !SourcePos -> !u -> State s u
stateInput :: State s u -> s
statePos :: State s u -> !SourcePos
stateUser :: State s u -> !u
parsecMap :: (a -> b) -> ParsecT s u m a -> ParsecT s u m b
parserReturn :: a -> ParsecT s u m a
parserBind :: ParsecT s u m a -> (a -> ParsecT s u m b) -> ParsecT s u m b
mergeErrorReply :: ParseError -> Reply s u a -> Reply s u a
parserFail :: String -> ParsecT s u m a
-- | parserZero always fails without consuming any input.
-- parserZero is defined equal to the mzero member of the
-- MonadPlus class and to the empty member of the
-- Applicative class.
parserZero :: ParsecT s u m a
parserPlus :: ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
-- | The parser p ? msg behaves as parser p, but
-- whenever the parser p fails without consuming any
-- input, it replaces expect error messages with the expect error
-- message msg.
--
-- This is normally used at the end of a set alternatives where we want
-- to return an error message in terms of a higher level construct rather
-- than returning all possible characters. For example, if the
-- expr parser from the try example would fail, the error
-- message is: '...: expecting expression'. Without the
-- (<?>) combinator, the message would be like '...:
-- expecting "let" or letter', which is less friendly.
() :: (ParsecT s u m a) -> String -> (ParsecT s u m a)
-- | This combinator implements choice. The parser p <|> q
-- first applies p. If it succeeds, the value of p is
-- returned. If p fails without consuming any input,
-- parser q is tried. This combinator is defined equal to the
-- mplus member of the MonadPlus class and the
-- (<|>) member of Alternative.
--
-- The parser is called predictive since q is only tried
-- when parser p didn't consume any input (i.e.. the look ahead
-- is 1). This non-backtracking behaviour allows for both an efficient
-- implementation of the parser combinators and the generation of good
-- error messages.
(<|>) :: (ParsecT s u m a) -> (ParsecT s u m a) -> (ParsecT s u m a)
label :: ParsecT s u m a -> String -> ParsecT s u m a
labels :: ParsecT s u m a -> [String] -> ParsecT s u m a
-- | lookAhead p parses p without consuming any input.
--
-- If p fails and consumes some input, so does
-- lookAhead. Combine with try if this is undesirable.
lookAhead :: Stream s m t => ParsecT s u m a -> ParsecT s u m a
-- | An instance of Stream has stream type s, underlying
-- monad m and token type t determined by the stream
--
-- Some rough guidelines for a "correct" instance of Stream:
--
--
-- - unfoldM uncons gives the [t] corresponding to the stream
-- - A Stream instance is responsible for maintaining the
-- "position within the stream" in the stream state s. This is
-- trivial unless you are using the monad in a non-trivial way.
--
class Monad m => Stream s m t | s -> t
uncons :: Stream s m t => s -> m (Maybe (t, s))
tokens :: (Stream s m t, Eq t) => ([t] -> String) -> (SourcePos -> [t] -> SourcePos) -> [t] -> ParsecT s u m [t]
-- | The parser try p behaves like parser p, except that
-- it pretends that it hasn't consumed any input when an error occurs.
--
-- This combinator is used whenever arbitrary look ahead is needed. Since
-- it pretends that it hasn't consumed any input when p fails,
-- the (<|>) combinator will try its second alternative even
-- when the first parser failed while consuming input.
--
-- The try combinator can for example be used to distinguish
-- identifiers and reserved words. Both reserved words and identifiers
-- are a sequence of letters. Whenever we expect a certain reserved word
-- where we can also expect an identifier we have to use the try
-- combinator. Suppose we write:
--
--
-- expr = letExpr <|> identifier <?> "expression"
--
-- letExpr = do{ string "let"; ... }
-- identifier = many1 letter
--
--
-- If the user writes "lexical", the parser fails with: unexpected
-- 'x', expecting 't' in "let". Indeed, since the (<|>)
-- combinator only tries alternatives when the first alternative hasn't
-- consumed input, the identifier parser is never tried (because
-- the prefix "le" of the string "let" parser is already
-- consumed). The right behaviour can be obtained by adding the
-- try combinator:
--
--
-- expr = letExpr <|> identifier <?> "expression"
--
-- letExpr = do{ try (string "let"); ... }
-- identifier = many1 letter
--
try :: ParsecT s u m a -> ParsecT s u m a
-- | The parser token showTok posFromTok testTok accepts a token
-- t with result x when the function testTok t
-- returns Just x. The source position of the t
-- should be returned by posFromTok t and the token can be shown
-- using showTok t.
--
-- This combinator is expressed in terms of tokenPrim. It is used
-- to accept user defined token streams. For example, suppose that we
-- have a stream of basic tokens tupled with source positions. We can
-- than define a parser that accepts single tokens as:
--
--
-- mytoken x
-- = token showTok posFromTok testTok
-- where
-- showTok (pos,t) = show t
-- posFromTok (pos,t) = pos
-- testTok (pos,t) = if x == t then Just t else Nothing
--
token :: Stream s Identity t => (t -> String) -> (t -> SourcePos) -> (t -> Maybe a) -> Parsec s u a
-- | The parser tokenPrim showTok nextPos testTok accepts a token
-- t with result x when the function testTok t
-- returns Just x. The token can be shown using
-- showTok t. The position of the next token should be
-- returned when nextPos is called with the current source
-- position pos, the current token t and the rest of
-- the tokens toks, nextPos pos t toks.
--
-- This is the most primitive combinator for accepting tokens. For
-- example, the char parser could be implemented as:
--
--
-- char c
-- = tokenPrim showChar nextPos testChar
-- where
-- showChar x = "'" ++ x ++ "'"
-- testChar x = if x == c then Just x else Nothing
-- nextPos pos x xs = updatePosChar pos x
--
tokenPrim :: Stream s m t => (t -> String) -> (SourcePos -> t -> s -> SourcePos) -> (t -> Maybe a) -> ParsecT s u m a
tokenPrimEx :: Stream s m t => (t -> String) -> (SourcePos -> t -> s -> SourcePos) -> Maybe (SourcePos -> t -> s -> u -> u) -> (t -> Maybe a) -> ParsecT s u m a
-- | many p applies the parser p zero or more
-- times. Returns a list of the returned values of p.
--
--
-- identifier = do{ c <- letter
-- ; cs <- many (alphaNum <|> char '_')
-- ; return (c:cs)
-- }
--
many :: ParsecT s u m a -> ParsecT s u m [a]
-- | skipMany p applies the parser p zero or more
-- times, skipping its result.
--
--
-- spaces = skipMany space
--
skipMany :: ParsecT s u m a -> ParsecT s u m ()
manyAccum :: (a -> [a] -> [a]) -> ParsecT s u m a -> ParsecT s u m [a]
runPT :: Stream s m t => ParsecT s u m a -> u -> SourceName -> s -> m (Either ParseError a)
runP :: Stream s Identity t => Parsec s u a -> u -> SourceName -> s -> Either ParseError a
-- | The most general way to run a parser. runParserT p state filePath
-- input runs parser p on the input list of tokens
-- input, obtained from source filePath with the
-- initial user state st. The filePath is only used in
-- error messages and may be the empty string. Returns a computation in
-- the underlying monad m that return either a ParseError
-- (Left) or a value of type a (Right).
runParserT :: Stream s m t => ParsecT s u m a -> u -> SourceName -> s -> m (Either ParseError a)
-- | The most general way to run a parser over the Identity monad.
-- runParser p state filePath input runs parser p on
-- the input list of tokens input, obtained from source
-- filePath with the initial user state st. The
-- filePath is only used in error messages and may be the empty
-- string. Returns either a ParseError (Left) or a value of
-- type a (Right).
--
--
-- parseFromFile p fname
-- = do{ input <- readFile fname
-- ; return (runParser p () fname input)
-- }
--
runParser :: Stream s Identity t => Parsec s u a -> u -> SourceName -> s -> Either ParseError a
-- | parse p filePath input runs a parser p over Identity
-- without user state. The filePath is only used in error
-- messages and may be the empty string. Returns either a
-- ParseError (Left) or a value of type a
-- (Right).
--
--
-- main = case (parse numbers "" "11, 2, 43") of
-- Left err -> print err
-- Right xs -> print (sum xs)
--
-- numbers = commaSep integer
--
parse :: Stream s Identity t => Parsec s () a -> SourceName -> s -> Either ParseError a
-- | The expression parseTest p input applies a parser p
-- against input input and prints the result to stdout. Used for
-- testing parsers.
parseTest :: (Stream s Identity t, Show a) => Parsec s () a -> s -> IO ()
-- | Returns the current source position. See also SourcePos.
getPosition :: Monad m => ParsecT s u m SourcePos
-- | Returns the current input
getInput :: Monad m => ParsecT s u m s
-- | setPosition pos sets the current source position to
-- pos.
setPosition :: Monad m => SourcePos -> ParsecT s u m ()
-- | setInput input continues parsing with input. The
-- getInput and setInput functions can for example be
-- used to deal with #include files.
setInput :: Monad m => s -> ParsecT s u m ()
-- | Returns the full parser state as a State record.
getParserState :: Monad m => ParsecT s u m (State s u)
-- | setParserState st set the full parser state to st.
setParserState :: Monad m => State s u -> ParsecT s u m (State s u)
-- | updateParserState f applies function f to the parser
-- state.
updateParserState :: (State s u -> State s u) -> ParsecT s u m (State s u)
-- | Returns the current user state.
getState :: Monad m => ParsecT s u m u
-- | putState st set the user state to st.
putState :: Monad m => u -> ParsecT s u m ()
-- | updateState f applies function f to the user state.
-- Suppose that we want to count identifiers in a source, we could use
-- the user state as:
--
--
-- expr = do{ x <- identifier
-- ; updateState (+1)
-- ; return (Id x)
-- }
--
modifyState :: Monad m => (u -> u) -> ParsecT s u m ()
-- | An alias for putState for backwards compatibility.
setState :: Monad m => u -> ParsecT s u m ()
-- | An alias for modifyState for backwards compatibility.
updateState :: Monad m => (u -> u) -> ParsecT s u m ()
instance MonadTrans (ParsecT s u)
instance MonadPlus (ParsecT s u m)
instance MonadError e m => MonadError e (ParsecT s u m)
instance MonadCont m => MonadCont (ParsecT s u m)
instance MonadState s m => MonadState s (ParsecT s' u m)
instance MonadReader r m => MonadReader r (ParsecT s u m)
instance MonadIO m => MonadIO (ParsecT s u m)
instance Monad (ParsecT s u m)
instance Alternative (ParsecT s u m)
instance Applicative (ParsecT s u m)
instance Functor (ParsecT s u m)
instance Functor (Reply s u)
instance Functor Consumed
-- | Commonly used character parsers.
module Text.Parsec.Char
-- | oneOf cs succeeds if the current character is in the supplied
-- list of characters cs. Returns the parsed character. See also
-- satisfy.
--
--
-- vowel = oneOf "aeiou"
--
oneOf :: Stream s m Char => [Char] -> ParsecT s u m Char
-- | As the dual of oneOf, noneOf cs succeeds if the
-- current character not in the supplied list of characters
-- cs. Returns the parsed character.
--
--
-- consonant = noneOf "aeiou"
--
noneOf :: Stream s m Char => [Char] -> ParsecT s u m Char
-- | Skips zero or more white space characters. See also
-- skipMany.
spaces :: Stream s m Char => ParsecT s u m ()
-- | Parses a white space character (any character which satisfies
-- isSpace) Returns the parsed character.
space :: Stream s m Char => ParsecT s u m Char
-- | Parses a newline character ('\n'). Returns a newline character.
newline :: Stream s m Char => ParsecT s u m Char
-- | Parses a tab character ('\t'). Returns a tab character.
tab :: Stream s m Char => ParsecT s u m Char
-- | Parses an upper case letter (a character between 'A' and 'Z'). Returns
-- the parsed character.
upper :: Stream s m Char => ParsecT s u m Char
-- | Parses a lower case character (a character between 'a' and 'z').
-- Returns the parsed character.
lower :: Stream s m Char => ParsecT s u m Char
-- | Parses a letter or digit (a character between '0' and '9'). Returns
-- the parsed character.
alphaNum :: Stream s m Char => ParsecT s u m Char
-- | Parses a letter (an upper case or lower case character). Returns the
-- parsed character.
letter :: Stream s m Char => ParsecT s u m Char
-- | Parses a digit. Returns the parsed character.
digit :: Stream s m Char => ParsecT s u m Char
-- | Parses a hexadecimal digit (a digit or a letter between 'a' and 'f' or
-- 'A' and 'F'). Returns the parsed character.
hexDigit :: Stream s m Char => ParsecT s u m Char
-- | Parses an octal digit (a character between '0' and '7'). Returns the
-- parsed character.
octDigit :: Stream s m Char => ParsecT s u m Char
-- | char c parses a single character c. Returns the
-- parsed character (i.e. c).
--
--
-- semiColon = char ';'
--
char :: Stream s m Char => Char -> ParsecT s u m Char
-- | This parser succeeds for any character. Returns the parsed character.
anyChar :: Stream s m Char => ParsecT s u m Char
-- | The parser satisfy f succeeds for any character for which the
-- supplied function f returns True. Returns the
-- character that is actually parsed.
satisfy :: Stream s m Char => (Char -> Bool) -> ParsecT s u m Char
-- | string s parses a sequence of characters given by s.
-- Returns the parsed string (i.e. s).
--
--
-- divOrMod = string "div"
-- <|> string "mod"
--
string :: Stream s m Char => String -> ParsecT s u m String
-- | Commonly used generic combinators
module Text.Parsec.Combinator
-- | choice ps tries to apply the parsers in the list ps
-- in order, until one of them succeeds. Returns the value of the
-- succeeding parser.
choice :: Stream s m t => [ParsecT s u m a] -> ParsecT s u m a
-- | count n p parses n occurrences of p. If
-- n is smaller or equal to zero, the parser equals to
-- return []. Returns a list of n values returned by
-- p.
count :: Stream s m t => Int -> ParsecT s u m a -> ParsecT s u m [a]
-- | between open close p parses open, followed by
-- p and close. Returns the value returned by
-- p.
--
--
-- braces = between (symbol "{") (symbol "}")
--
between :: Stream s m t => ParsecT s u m open -> ParsecT s u m close -> ParsecT s u m a -> ParsecT s u m a
-- | option x p tries to apply parser p. If p
-- fails without consuming input, it returns the value x,
-- otherwise the value returned by p.
--
--
-- priority = option 0 (do{ d <- digit
-- ; return (digitToInt d)
-- })
--
option :: Stream s m t => a -> ParsecT s u m a -> ParsecT s u m a
-- | optionMaybe p tries to apply parser p. If p
-- fails without consuming input, it return Nothing, otherwise it
-- returns Just the value returned by p.
optionMaybe :: Stream s m t => ParsecT s u m a -> ParsecT s u m (Maybe a)
-- | optional p tries to apply parser p. It will parse
-- p or nothing. It only fails if p fails after
-- consuming input. It discards the result of p.
optional :: Stream s m t => ParsecT s u m a -> ParsecT s u m ()
-- | skipMany1 p applies the parser p one or more
-- times, skipping its result.
skipMany1 :: Stream s m t => ParsecT s u m a -> ParsecT s u m ()
-- | many1 p applies the parser p one or more
-- times. Returns a list of the returned values of p.
--
--
-- word = many1 letter
--
many1 :: Stream s m t => ParsecT s u m a -> ParsecT s u m [a]
-- | sepBy p sep parses zero or more occurrences of
-- p, separated by sep. Returns a list of values
-- returned by p.
--
--
-- commaSep p = p `sepBy` (symbol ",")
--
sepBy :: Stream s m t => ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
-- | sepBy1 p sep parses one or more occurrences of
-- p, separated by sep. Returns a list of values
-- returned by p.
sepBy1 :: Stream s m t => ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
-- | endBy p sep parses zero or more occurrences of
-- p, seperated and ended by sep. Returns a list of
-- values returned by p.
--
--
-- cStatements = cStatement `endBy` semi
--
endBy :: Stream s m t => ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
-- | endBy1 p sep parses one or more occurrences of
-- p, seperated and ended by sep. Returns a list of
-- values returned by p.
endBy1 :: Stream s m t => ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
-- | sepEndBy p sep parses zero or more occurrences of
-- p, separated and optionally ended by sep, ie.
-- haskell style statements. Returns a list of values returned by
-- p.
--
--
-- haskellStatements = haskellStatement `sepEndBy` semi
--
sepEndBy :: Stream s m t => ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
-- | sepEndBy1 p sep parses one or more occurrences of
-- p, separated and optionally ended by sep. Returns a
-- list of values returned by p.
sepEndBy1 :: Stream s m t => ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
-- | chainl p op x parser zero or more occurrences of
-- p, separated by op. Returns a value obtained by a
-- left associative application of all functions returned by
-- op to the values returned by p. If there are zero
-- occurrences of p, the value x is returned.
chainl :: Stream s m t => ParsecT s u m a -> ParsecT s u m (a -> a -> a) -> a -> ParsecT s u m a
-- | chainl1 p op x parser one or more occurrences of
-- p, separated by op Returns a value obtained by a
-- left associative application of all functions returned by
-- op to the values returned by p. . This parser can
-- for example be used to eliminate left recursion which typically occurs
-- in expression grammars.
--
--
-- expr = term `chainl1` addop
-- term = factor `chainl1` mulop
-- factor = parens expr <|> integer
--
-- mulop = do{ symbol "*"; return (*) }
-- <|> do{ symbol "/"; return (div) }
--
-- addop = do{ symbol "+"; return (+) }
-- <|> do{ symbol "-"; return (-) }
--
chainl1 :: Stream s m t => ParsecT s u m a -> ParsecT s u m (a -> a -> a) -> ParsecT s u m a
-- | chainr p op x parser zero or more occurrences of
-- p, separated by op Returns a value obtained by a
-- right associative application of all functions returned by
-- op to the values returned by p. If there are no
-- occurrences of p, the value x is returned.
chainr :: Stream s m t => ParsecT s u m a -> ParsecT s u m (a -> a -> a) -> a -> ParsecT s u m a
-- | chainr1 p op x parser one or more occurrences of |p|,
-- separated by op Returns a value obtained by a right
-- associative application of all functions returned by op to
-- the values returned by p.
chainr1 :: Stream s m t => ParsecT s u m a -> ParsecT s u m (a -> a -> a) -> ParsecT s u m a
-- | This parser only succeeds at the end of the input. This is not a
-- primitive parser but it is defined using notFollowedBy.
--
--
-- eof = notFollowedBy anyToken <?> "end of input"
--
eof :: (Stream s m t, Show t) => ParsecT s u m ()
-- | notFollowedBy p only succeeds when parser p fails.
-- This parser does not consume any input. This parser can be used to
-- implement the 'longest match' rule. For example, when recognizing
-- keywords (for example let), we want to make sure that a
-- keyword is not followed by a legal identifier character, in which case
-- the keyword is actually an identifier (for example lets). We
-- can program this behaviour as follows:
--
--
-- keywordLet = try (do{ string "let"
-- ; notFollowedBy alphaNum
-- })
--
notFollowedBy :: (Stream s m t, Show a) => ParsecT s u m a -> ParsecT s u m ()
-- | manyTill p end applies parser p zero or more
-- times until parser end succeeds. Returns the list of values
-- returned by p. This parser can be used to scan comments:
--
--
-- simpleComment = do{ string "<!--"
-- ; manyTill anyChar (try (string "-->"))
-- }
--
--
-- Note the overlapping parsers anyChar and string
-- "-->", and therefore the use of the try combinator.
manyTill :: Stream s m t => ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
-- | lookAhead p parses p without consuming any input.
--
-- If p fails and consumes some input, so does
-- lookAhead. Combine with try if this is undesirable.
lookAhead :: Stream s m t => ParsecT s u m a -> ParsecT s u m a
-- | The parser anyToken accepts any kind of token. It is for
-- example used to implement eof. Returns the accepted token.
anyToken :: (Stream s m t, Show t) => ParsecT s u m t
-- | Parsec compatibility module
module Text.ParserCombinators.Parsec.Combinator
-- | choice ps tries to apply the parsers in the list ps
-- in order, until one of them succeeds. Returns the value of the
-- succeeding parser.
choice :: Stream s m t => [ParsecT s u m a] -> ParsecT s u m a
-- | count n p parses n occurrences of p. If
-- n is smaller or equal to zero, the parser equals to
-- return []. Returns a list of n values returned by
-- p.
count :: Stream s m t => Int -> ParsecT s u m a -> ParsecT s u m [a]
-- | between open close p parses open, followed by
-- p and close. Returns the value returned by
-- p.
--
--
-- braces = between (symbol "{") (symbol "}")
--
between :: Stream s m t => ParsecT s u m open -> ParsecT s u m close -> ParsecT s u m a -> ParsecT s u m a
-- | option x p tries to apply parser p. If p
-- fails without consuming input, it returns the value x,
-- otherwise the value returned by p.
--
--
-- priority = option 0 (do{ d <- digit
-- ; return (digitToInt d)
-- })
--
option :: Stream s m t => a -> ParsecT s u m a -> ParsecT s u m a
-- | optionMaybe p tries to apply parser p. If p
-- fails without consuming input, it return Nothing, otherwise it
-- returns Just the value returned by p.
optionMaybe :: Stream s m t => ParsecT s u m a -> ParsecT s u m (Maybe a)
-- | optional p tries to apply parser p. It will parse
-- p or nothing. It only fails if p fails after
-- consuming input. It discards the result of p.
optional :: Stream s m t => ParsecT s u m a -> ParsecT s u m ()
-- | skipMany1 p applies the parser p one or more
-- times, skipping its result.
skipMany1 :: Stream s m t => ParsecT s u m a -> ParsecT s u m ()
-- | many1 p applies the parser p one or more
-- times. Returns a list of the returned values of p.
--
--
-- word = many1 letter
--
many1 :: Stream s m t => ParsecT s u m a -> ParsecT s u m [a]
-- | sepBy p sep parses zero or more occurrences of
-- p, separated by sep. Returns a list of values
-- returned by p.
--
--
-- commaSep p = p `sepBy` (symbol ",")
--
sepBy :: Stream s m t => ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
-- | sepBy1 p sep parses one or more occurrences of
-- p, separated by sep. Returns a list of values
-- returned by p.
sepBy1 :: Stream s m t => ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
-- | endBy p sep parses zero or more occurrences of
-- p, seperated and ended by sep. Returns a list of
-- values returned by p.
--
--
-- cStatements = cStatement `endBy` semi
--
endBy :: Stream s m t => ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
-- | endBy1 p sep parses one or more occurrences of
-- p, seperated and ended by sep. Returns a list of
-- values returned by p.
endBy1 :: Stream s m t => ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
-- | sepEndBy p sep parses zero or more occurrences of
-- p, separated and optionally ended by sep, ie.
-- haskell style statements. Returns a list of values returned by
-- p.
--
--
-- haskellStatements = haskellStatement `sepEndBy` semi
--
sepEndBy :: Stream s m t => ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
-- | sepEndBy1 p sep parses one or more occurrences of
-- p, separated and optionally ended by sep. Returns a
-- list of values returned by p.
sepEndBy1 :: Stream s m t => ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
-- | chainl p op x parser zero or more occurrences of
-- p, separated by op. Returns a value obtained by a
-- left associative application of all functions returned by
-- op to the values returned by p. If there are zero
-- occurrences of p, the value x is returned.
chainl :: Stream s m t => ParsecT s u m a -> ParsecT s u m (a -> a -> a) -> a -> ParsecT s u m a
-- | chainl1 p op x parser one or more occurrences of
-- p, separated by op Returns a value obtained by a
-- left associative application of all functions returned by
-- op to the values returned by p. . This parser can
-- for example be used to eliminate left recursion which typically occurs
-- in expression grammars.
--
--
-- expr = term `chainl1` addop
-- term = factor `chainl1` mulop
-- factor = parens expr <|> integer
--
-- mulop = do{ symbol "*"; return (*) }
-- <|> do{ symbol "/"; return (div) }
--
-- addop = do{ symbol "+"; return (+) }
-- <|> do{ symbol "-"; return (-) }
--
chainl1 :: Stream s m t => ParsecT s u m a -> ParsecT s u m (a -> a -> a) -> ParsecT s u m a
-- | chainr p op x parser zero or more occurrences of
-- p, separated by op Returns a value obtained by a
-- right associative application of all functions returned by
-- op to the values returned by p. If there are no
-- occurrences of p, the value x is returned.
chainr :: Stream s m t => ParsecT s u m a -> ParsecT s u m (a -> a -> a) -> a -> ParsecT s u m a
-- | chainr1 p op x parser one or more occurrences of |p|,
-- separated by op Returns a value obtained by a right
-- associative application of all functions returned by op to
-- the values returned by p.
chainr1 :: Stream s m t => ParsecT s u m a -> ParsecT s u m (a -> a -> a) -> ParsecT s u m a
-- | This parser only succeeds at the end of the input. This is not a
-- primitive parser but it is defined using notFollowedBy.
--
--
-- eof = notFollowedBy anyToken <?> "end of input"
--
eof :: (Stream s m t, Show t) => ParsecT s u m ()
-- | notFollowedBy p only succeeds when parser p fails.
-- This parser does not consume any input. This parser can be used to
-- implement the 'longest match' rule. For example, when recognizing
-- keywords (for example let), we want to make sure that a
-- keyword is not followed by a legal identifier character, in which case
-- the keyword is actually an identifier (for example lets). We
-- can program this behaviour as follows:
--
--
-- keywordLet = try (do{ string "let"
-- ; notFollowedBy alphaNum
-- })
--
notFollowedBy :: (Stream s m t, Show a) => ParsecT s u m a -> ParsecT s u m ()
-- | manyTill p end applies parser p zero or more
-- times until parser end succeeds. Returns the list of values
-- returned by p. This parser can be used to scan comments:
--
--
-- simpleComment = do{ string "<!--"
-- ; manyTill anyChar (try (string "-->"))
-- }
--
--
-- Note the overlapping parsers anyChar and string
-- "-->", and therefore the use of the try combinator.
manyTill :: Stream s m t => ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
-- | lookAhead p parses p without consuming any input.
--
-- If p fails and consumes some input, so does
-- lookAhead. Combine with try if this is undesirable.
lookAhead :: Stream s m t => ParsecT s u m a -> ParsecT s u m a
-- | The parser anyToken accepts any kind of token. It is for
-- example used to implement eof. Returns the accepted token.
anyToken :: (Stream s m t, Show t) => ParsecT s u m t
-- | Make Strings an instance of Stream with Char token type.
module Text.Parsec.String
type Parser = Parsec String ()
type GenParser tok st = Parsec [tok] st
-- | parseFromFile p filePath runs a string parser p on
-- the input read from filePath using readFile. Returns
-- either a ParseError (Left) or a value of type a
-- (Right).
--
--
-- main = do{ result <- parseFromFile numbers "digits.txt"
-- ; case result of
-- Left err -> print err
-- Right xs -> print (sum xs)
-- }
--
parseFromFile :: Parser a -> String -> IO (Either ParseError a)
instance Monad m => Stream [tok] m tok
-- | Parsec compatibility module
module Text.ParserCombinators.Parsec.Char
type CharParser st = GenParser Char st
-- | Skips zero or more white space characters. See also
-- skipMany.
spaces :: Stream s m Char => ParsecT s u m ()
-- | Parses a white space character (any character which satisfies
-- isSpace) Returns the parsed character.
space :: Stream s m Char => ParsecT s u m Char
-- | Parses a newline character ('\n'). Returns a newline character.
newline :: Stream s m Char => ParsecT s u m Char
-- | Parses a tab character ('\t'). Returns a tab character.
tab :: Stream s m Char => ParsecT s u m Char
-- | Parses an upper case letter (a character between 'A' and 'Z'). Returns
-- the parsed character.
upper :: Stream s m Char => ParsecT s u m Char
-- | Parses a lower case character (a character between 'a' and 'z').
-- Returns the parsed character.
lower :: Stream s m Char => ParsecT s u m Char
-- | Parses a letter or digit (a character between '0' and '9'). Returns
-- the parsed character.
alphaNum :: Stream s m Char => ParsecT s u m Char
-- | Parses a letter (an upper case or lower case character). Returns the
-- parsed character.
letter :: Stream s m Char => ParsecT s u m Char
-- | Parses a digit. Returns the parsed character.
digit :: Stream s m Char => ParsecT s u m Char
-- | Parses a hexadecimal digit (a digit or a letter between 'a' and 'f' or
-- 'A' and 'F'). Returns the parsed character.
hexDigit :: Stream s m Char => ParsecT s u m Char
-- | Parses an octal digit (a character between '0' and '7'). Returns the
-- parsed character.
octDigit :: Stream s m Char => ParsecT s u m Char
-- | char c parses a single character c. Returns the
-- parsed character (i.e. c).
--
--
-- semiColon = char ';'
--
char :: Stream s m Char => Char -> ParsecT s u m Char
-- | string s parses a sequence of characters given by s.
-- Returns the parsed string (i.e. s).
--
--
-- divOrMod = string "div"
-- <|> string "mod"
--
string :: Stream s m Char => String -> ParsecT s u m String
-- | This parser succeeds for any character. Returns the parsed character.
anyChar :: Stream s m Char => ParsecT s u m Char
-- | oneOf cs succeeds if the current character is in the supplied
-- list of characters cs. Returns the parsed character. See also
-- satisfy.
--
--
-- vowel = oneOf "aeiou"
--
oneOf :: Stream s m Char => [Char] -> ParsecT s u m Char
-- | As the dual of oneOf, noneOf cs succeeds if the
-- current character not in the supplied list of characters
-- cs. Returns the parsed character.
--
--
-- consonant = noneOf "aeiou"
--
noneOf :: Stream s m Char => [Char] -> ParsecT s u m Char
-- | The parser satisfy f succeeds for any character for which the
-- supplied function f returns True. Returns the
-- character that is actually parsed.
satisfy :: Stream s m Char => (Char -> Bool) -> ParsecT s u m Char
-- | Make strict ByteStrings an instance of Stream with Char
-- token type.
module Text.Parsec.ByteString
type Parser = Parsec ByteString ()
type GenParser t st = Parsec ByteString st
-- | parseFromFile p filePath runs a strict bytestring parser
-- p on the input read from filePath using
-- readFile. Returns either a ParseError (Left) or a
-- value of type a (Right).
--
--
-- main = do{ result <- parseFromFile numbers "digits.txt"
-- ; case result of
-- Left err -> print err
-- Right xs -> print (sum xs)
-- }
--
parseFromFile :: Parser a -> String -> IO (Either ParseError a)
instance Monad m => Stream ByteString m Char
-- | Make lazy ByteStrings an instance of Stream with Char
-- token type.
module Text.Parsec.ByteString.Lazy
type Parser = Parsec ByteString ()
type GenParser t st = Parsec ByteString st
-- | parseFromFile p filePath runs a lazy bytestring parser
-- p on the input read from filePath using
-- readFile. Returns either a ParseError (Left) or a
-- value of type a (Right).
--
--
-- main = do{ result <- parseFromFile numbers "digits.txt"
-- ; case result of
-- Left err -> print err
-- Right xs -> print (sum xs)
-- }
--
parseFromFile :: Parser a -> String -> IO (Either ParseError a)
instance Monad m => Stream ByteString m Char
-- | Make Text an instance of Stream with Char token type.
module Text.Parsec.Text
type Parser = Parsec Text ()
type GenParser st = Parsec Text st
instance Monad m => Stream Text m Char
-- | Make Text an instance of Stream with Char token type.
module Text.Parsec.Text.Lazy
type Parser = Parsec Text ()
type GenParser st = Parsec Text st
instance Monad m => Stream Text m Char
-- | A helper module to parse lexical elements (tokens). See
-- makeTokenParser for a description of how to use it.
module Text.Parsec.Token
type LanguageDef st = GenLanguageDef String st Identity
-- | The GenLanguageDef type is a record that contains all
-- parameterizable features of the Token module. The module
-- Language contains some default definitions.
data GenLanguageDef s u m
LanguageDef :: String -> String -> String -> Bool -> ParsecT s u m Char -> ParsecT s u m Char -> ParsecT s u m Char -> ParsecT s u m Char -> [String] -> [String] -> Bool -> GenLanguageDef s u m
-- | Describes the start of a block comment. Use the empty string if the
-- language doesn't support block comments. For example "/*".
commentStart :: GenLanguageDef s u m -> String
-- | Describes the end of a block comment. Use the empty string if the
-- language doesn't support block comments. For example "*/".
commentEnd :: GenLanguageDef s u m -> String
-- | Describes the start of a line comment. Use the empty string if the
-- language doesn't support line comments. For example "//".
commentLine :: GenLanguageDef s u m -> String
-- | Set to True if the language supports nested block comments.
nestedComments :: GenLanguageDef s u m -> Bool
-- | This parser should accept any start characters of identifiers. For
-- example letter <|> char "_".
identStart :: GenLanguageDef s u m -> ParsecT s u m Char
-- | This parser should accept any legal tail characters of identifiers.
-- For example alphaNum <|> char "_".
identLetter :: GenLanguageDef s u m -> ParsecT s u m Char
-- | This parser should accept any start characters of operators. For
-- example oneOf ":!#$%&*+./<=>?@\\^|-~"
opStart :: GenLanguageDef s u m -> ParsecT s u m Char
-- | This parser should accept any legal tail characters of operators. Note
-- that this parser should even be defined if the language doesn't
-- support user-defined operators, or otherwise the reservedOp
-- parser won't work correctly.
opLetter :: GenLanguageDef s u m -> ParsecT s u m Char
-- | The list of reserved identifiers.
reservedNames :: GenLanguageDef s u m -> [String]
-- | The list of reserved operators.
reservedOpNames :: GenLanguageDef s u m -> [String]
-- | Set to True if the language is case sensitive.
caseSensitive :: GenLanguageDef s u m -> Bool
type TokenParser st = GenTokenParser String st Identity
-- | The type of the record that holds lexical parsers that work on
-- s streams with state u over a monad m.
data GenTokenParser s u m
TokenParser :: ParsecT s u m String -> (String -> ParsecT s u m ()) -> ParsecT s u m String -> (String -> ParsecT s u m ()) -> ParsecT s u m Char -> ParsecT s u m String -> ParsecT s u m Integer -> ParsecT s u m Integer -> ParsecT s u m Double -> ParsecT s u m (Either Integer Double) -> ParsecT s u m Integer -> ParsecT s u m Integer -> ParsecT s u m Integer -> (String -> ParsecT s u m String) -> (forall a. ParsecT s u m a -> ParsecT s u m a) -> ParsecT s u m () -> (forall a. ParsecT s u m a -> ParsecT s u m a) -> (forall a. ParsecT s u m a -> ParsecT s u m a) -> (forall a. ParsecT s u m a -> ParsecT s u m a) -> (forall a. ParsecT s u m a -> ParsecT s u m a) -> (forall a. ParsecT s u m a -> ParsecT s u m a) -> ParsecT s u m String -> ParsecT s u m String -> ParsecT s u m String -> ParsecT s u m String -> (forall a. ParsecT s u m a -> ParsecT s u m [a]) -> (forall a. ParsecT s u m a -> ParsecT s u m [a]) -> (forall a. ParsecT s u m a -> ParsecT s u m [a]) -> (forall a. ParsecT s u m a -> ParsecT s u m [a]) -> GenTokenParser s u m
-- | This lexeme parser parses a legal identifier. Returns the identifier
-- string. This parser will fail on identifiers that are reserved words.
-- Legal identifier (start) characters and reserved words are defined in
-- the LanguageDef that is passed to makeTokenParser. An
-- identifier is treated as a single token using try.
identifier :: GenTokenParser s u m -> ParsecT s u m String
-- | The lexeme parser reserved name parses symbol name,
-- but it also checks that the name is not a prefix of a valid
-- identifier. A reserved word is treated as a single token
-- using try.
reserved :: GenTokenParser s u m -> String -> ParsecT s u m ()
-- | This lexeme parser parses a legal operator. Returns the name of the
-- operator. This parser will fail on any operators that are reserved
-- operators. Legal operator (start) characters and reserved operators
-- are defined in the LanguageDef that is passed to
-- makeTokenParser. An operator is treated as a single
-- token using try.
operator :: GenTokenParser s u m -> ParsecT s u m String
-- | The lexeme parser reservedOp name parses symbol
-- name, but it also checks that the name is not a prefix
-- of a valid operator. A reservedOp is treated as a single
-- token using try.
reservedOp :: GenTokenParser s u m -> String -> ParsecT s u m ()
-- | This lexeme parser parses a single literal character. Returns the
-- literal character value. This parsers deals correctly with escape
-- sequences. The literal character is parsed according to the grammar
-- rules defined in the Haskell report (which matches most programming
-- languages quite closely).
charLiteral :: GenTokenParser s u m -> ParsecT s u m Char
-- | This lexeme parser parses a literal string. Returns the literal string
-- value. This parsers deals correctly with escape sequences and gaps.
-- The literal string is parsed according to the grammar rules defined in
-- the Haskell report (which matches most programming languages quite
-- closely).
stringLiteral :: GenTokenParser s u m -> ParsecT s u m String
-- | This lexeme parser parses a natural number (a positive whole number).
-- Returns the value of the number. The number can be specified in
-- decimal, hexadecimal or octal. The number is
-- parsed according to the grammar rules in the Haskell report.
natural :: GenTokenParser s u m -> ParsecT s u m Integer
-- | This lexeme parser parses an integer (a whole number). This parser is
-- like natural except that it can be prefixed with sign (i.e. '-'
-- or '+'). Returns the value of the number. The number can be specified
-- in decimal, hexadecimal or octal. The number is
-- parsed according to the grammar rules in the Haskell report.
integer :: GenTokenParser s u m -> ParsecT s u m Integer
-- | This lexeme parser parses a floating point value. Returns the value of
-- the number. The number is parsed according to the grammar rules
-- defined in the Haskell report.
float :: GenTokenParser s u m -> ParsecT s u m Double
-- | This lexeme parser parses either natural or a float.
-- Returns the value of the number. This parsers deals with any overlap
-- in the grammar rules for naturals and floats. The number is parsed
-- according to the grammar rules defined in the Haskell report.
naturalOrFloat :: GenTokenParser s u m -> ParsecT s u m (Either Integer Double)
-- | Parses a positive whole number in the decimal system. Returns the
-- value of the number.
decimal :: GenTokenParser s u m -> ParsecT s u m Integer
-- | Parses a positive whole number in the hexadecimal system. The number
-- should be prefixed with "0x" or "0X". Returns the value of the number.
hexadecimal :: GenTokenParser s u m -> ParsecT s u m Integer
-- | Parses a positive whole number in the octal system. The number should
-- be prefixed with "0o" or "0O". Returns the value of the number.
octal :: GenTokenParser s u m -> ParsecT s u m Integer
-- | Lexeme parser symbol s parses string s and
-- skips trailing white space.
symbol :: GenTokenParser s u m -> String -> ParsecT s u m String
-- | lexeme p first applies parser p and than the
-- whiteSpace parser, returning the value of p. Every
-- lexical token (lexeme) is defined using lexeme, this way
-- every parse starts at a point without white space. Parsers that use
-- lexeme are called lexeme parsers in this document.
--
-- The only point where the whiteSpace parser should be called
-- explicitly is the start of the main parser in order to skip any
-- leading white space.
--
--
-- mainParser = do{ whiteSpace
-- ; ds <- many (lexeme digit)
-- ; eof
-- ; return (sum ds)
-- }
--
lexeme :: GenTokenParser s u m -> forall a. ParsecT s u m a -> ParsecT s u m a
-- | Parses any white space. White space consists of zero or more
-- occurrences of a space, a line comment or a block (multi line)
-- comment. Block comments may be nested. How comments are started and
-- ended is defined in the LanguageDef that is passed to
-- makeTokenParser.
whiteSpace :: GenTokenParser s u m -> ParsecT s u m ()
-- | Lexeme parser parens p parses p enclosed in
-- parenthesis, returning the value of p.
parens :: GenTokenParser s u m -> forall a. ParsecT s u m a -> ParsecT s u m a
-- | Lexeme parser braces p parses p enclosed in braces
-- ('{' and '}'), returning the value of p.
braces :: GenTokenParser s u m -> forall a. ParsecT s u m a -> ParsecT s u m a
-- | Lexeme parser angles p parses p enclosed in angle
-- brackets ('<' and '>'), returning the value of p.
angles :: GenTokenParser s u m -> forall a. ParsecT s u m a -> ParsecT s u m a
-- | Lexeme parser brackets p parses p enclosed in
-- brackets ('[' and ']'), returning the value of p.
brackets :: GenTokenParser s u m -> forall a. ParsecT s u m a -> ParsecT s u m a
-- | DEPRECATED: Use brackets.
squares :: GenTokenParser s u m -> forall a. ParsecT s u m a -> ParsecT s u m a
-- | Lexeme parser |semi| parses the character ';' and skips any trailing
-- white space. Returns the string ";".
semi :: GenTokenParser s u m -> ParsecT s u m String
-- | Lexeme parser comma parses the character ',' and skips any
-- trailing white space. Returns the string ",".
comma :: GenTokenParser s u m -> ParsecT s u m String
-- | Lexeme parser colon parses the character ':' and skips any
-- trailing white space. Returns the string ":".
colon :: GenTokenParser s u m -> ParsecT s u m String
-- | Lexeme parser dot parses the character '.' and skips any
-- trailing white space. Returns the string ".".
dot :: GenTokenParser s u m -> ParsecT s u m String
-- | Lexeme parser semiSep p parses zero or more
-- occurrences of p separated by semi. Returns a list of
-- values returned by p.
semiSep :: GenTokenParser s u m -> forall a. ParsecT s u m a -> ParsecT s u m [a]
-- | Lexeme parser semiSep1 p parses one or more
-- occurrences of p separated by semi. Returns a list of
-- values returned by p.
semiSep1 :: GenTokenParser s u m -> forall a. ParsecT s u m a -> ParsecT s u m [a]
-- | Lexeme parser commaSep p parses zero or more
-- occurrences of p separated by comma. Returns a list of
-- values returned by p.
commaSep :: GenTokenParser s u m -> forall a. ParsecT s u m a -> ParsecT s u m [a]
-- | Lexeme parser commaSep1 p parses one or more
-- occurrences of p separated by comma. Returns a list of
-- values returned by p.
commaSep1 :: GenTokenParser s u m -> forall a. ParsecT s u m a -> ParsecT s u m [a]
-- | The expression makeTokenParser language creates a
-- GenTokenParser record that contains lexical parsers that are
-- defined using the definitions in the language record.
--
-- The use of this function is quite stylized - one imports the
-- appropiate language definition and selects the lexical parsers that
-- are needed from the resulting GenTokenParser.
--
--
-- module Main where
--
-- import Text.Parsec
-- import qualified Text.Parsec.Token as P
-- import Text.Parsec.Language (haskellDef)
--
-- -- The parser
-- ...
--
-- expr = parens expr
-- <|> identifier
-- <|> ...
--
--
-- -- The lexer
-- lexer = P.makeTokenParser haskellDef
--
-- parens = P.parens lexer
-- braces = P.braces lexer
-- identifier = P.identifier lexer
-- reserved = P.reserved lexer
-- ...
--
makeTokenParser :: Stream s m Char => GenLanguageDef s u m -> GenTokenParser s u m
-- | Parsec compatibility module
module Text.ParserCombinators.Parsec.Token
type LanguageDef st = GenLanguageDef String st Identity
-- | The GenLanguageDef type is a record that contains all
-- parameterizable features of the Token module. The module
-- Language contains some default definitions.
data GenLanguageDef s u m
LanguageDef :: String -> String -> String -> Bool -> ParsecT s u m Char -> ParsecT s u m Char -> ParsecT s u m Char -> ParsecT s u m Char -> [String] -> [String] -> Bool -> GenLanguageDef s u m
-- | Describes the start of a block comment. Use the empty string if the
-- language doesn't support block comments. For example "/*".
commentStart :: GenLanguageDef s u m -> String
-- | Describes the end of a block comment. Use the empty string if the
-- language doesn't support block comments. For example "*/".
commentEnd :: GenLanguageDef s u m -> String
-- | Describes the start of a line comment. Use the empty string if the
-- language doesn't support line comments. For example "//".
commentLine :: GenLanguageDef s u m -> String
-- | Set to True if the language supports nested block comments.
nestedComments :: GenLanguageDef s u m -> Bool
-- | This parser should accept any start characters of identifiers. For
-- example letter <|> char "_".
identStart :: GenLanguageDef s u m -> ParsecT s u m Char
-- | This parser should accept any legal tail characters of identifiers.
-- For example alphaNum <|> char "_".
identLetter :: GenLanguageDef s u m -> ParsecT s u m Char
-- | This parser should accept any start characters of operators. For
-- example oneOf ":!#$%&*+./<=>?@\\^|-~"
opStart :: GenLanguageDef s u m -> ParsecT s u m Char
-- | This parser should accept any legal tail characters of operators. Note
-- that this parser should even be defined if the language doesn't
-- support user-defined operators, or otherwise the reservedOp
-- parser won't work correctly.
opLetter :: GenLanguageDef s u m -> ParsecT s u m Char
-- | The list of reserved identifiers.
reservedNames :: GenLanguageDef s u m -> [String]
-- | The list of reserved operators.
reservedOpNames :: GenLanguageDef s u m -> [String]
-- | Set to True if the language is case sensitive.
caseSensitive :: GenLanguageDef s u m -> Bool
type TokenParser st = GenTokenParser String st Identity
-- | The type of the record that holds lexical parsers that work on
-- s streams with state u over a monad m.
data GenTokenParser s u m
TokenParser :: ParsecT s u m String -> (String -> ParsecT s u m ()) -> ParsecT s u m String -> (String -> ParsecT s u m ()) -> ParsecT s u m Char -> ParsecT s u m String -> ParsecT s u m Integer -> ParsecT s u m Integer -> ParsecT s u m Double -> ParsecT s u m (Either Integer Double) -> ParsecT s u m Integer -> ParsecT s u m Integer -> ParsecT s u m Integer -> (String -> ParsecT s u m String) -> (forall a. ParsecT s u m a -> ParsecT s u m a) -> ParsecT s u m () -> (forall a. ParsecT s u m a -> ParsecT s u m a) -> (forall a. ParsecT s u m a -> ParsecT s u m a) -> (forall a. ParsecT s u m a -> ParsecT s u m a) -> (forall a. ParsecT s u m a -> ParsecT s u m a) -> (forall a. ParsecT s u m a -> ParsecT s u m a) -> ParsecT s u m String -> ParsecT s u m String -> ParsecT s u m String -> ParsecT s u m String -> (forall a. ParsecT s u m a -> ParsecT s u m [a]) -> (forall a. ParsecT s u m a -> ParsecT s u m [a]) -> (forall a. ParsecT s u m a -> ParsecT s u m [a]) -> (forall a. ParsecT s u m a -> ParsecT s u m [a]) -> GenTokenParser s u m
-- | This lexeme parser parses a legal identifier. Returns the identifier
-- string. This parser will fail on identifiers that are reserved words.
-- Legal identifier (start) characters and reserved words are defined in
-- the LanguageDef that is passed to makeTokenParser. An
-- identifier is treated as a single token using try.
identifier :: GenTokenParser s u m -> ParsecT s u m String
-- | The lexeme parser reserved name parses symbol name,
-- but it also checks that the name is not a prefix of a valid
-- identifier. A reserved word is treated as a single token
-- using try.
reserved :: GenTokenParser s u m -> String -> ParsecT s u m ()
-- | This lexeme parser parses a legal operator. Returns the name of the
-- operator. This parser will fail on any operators that are reserved
-- operators. Legal operator (start) characters and reserved operators
-- are defined in the LanguageDef that is passed to
-- makeTokenParser. An operator is treated as a single
-- token using try.
operator :: GenTokenParser s u m -> ParsecT s u m String
-- | The lexeme parser reservedOp name parses symbol
-- name, but it also checks that the name is not a prefix
-- of a valid operator. A reservedOp is treated as a single
-- token using try.
reservedOp :: GenTokenParser s u m -> String -> ParsecT s u m ()
-- | This lexeme parser parses a single literal character. Returns the
-- literal character value. This parsers deals correctly with escape
-- sequences. The literal character is parsed according to the grammar
-- rules defined in the Haskell report (which matches most programming
-- languages quite closely).
charLiteral :: GenTokenParser s u m -> ParsecT s u m Char
-- | This lexeme parser parses a literal string. Returns the literal string
-- value. This parsers deals correctly with escape sequences and gaps.
-- The literal string is parsed according to the grammar rules defined in
-- the Haskell report (which matches most programming languages quite
-- closely).
stringLiteral :: GenTokenParser s u m -> ParsecT s u m String
-- | This lexeme parser parses a natural number (a positive whole number).
-- Returns the value of the number. The number can be specified in
-- decimal, hexadecimal or octal. The number is
-- parsed according to the grammar rules in the Haskell report.
natural :: GenTokenParser s u m -> ParsecT s u m Integer
-- | This lexeme parser parses an integer (a whole number). This parser is
-- like natural except that it can be prefixed with sign (i.e. '-'
-- or '+'). Returns the value of the number. The number can be specified
-- in decimal, hexadecimal or octal. The number is
-- parsed according to the grammar rules in the Haskell report.
integer :: GenTokenParser s u m -> ParsecT s u m Integer
-- | This lexeme parser parses a floating point value. Returns the value of
-- the number. The number is parsed according to the grammar rules
-- defined in the Haskell report.
float :: GenTokenParser s u m -> ParsecT s u m Double
-- | This lexeme parser parses either natural or a float.
-- Returns the value of the number. This parsers deals with any overlap
-- in the grammar rules for naturals and floats. The number is parsed
-- according to the grammar rules defined in the Haskell report.
naturalOrFloat :: GenTokenParser s u m -> ParsecT s u m (Either Integer Double)
-- | Parses a positive whole number in the decimal system. Returns the
-- value of the number.
decimal :: GenTokenParser s u m -> ParsecT s u m Integer
-- | Parses a positive whole number in the hexadecimal system. The number
-- should be prefixed with "0x" or "0X". Returns the value of the number.
hexadecimal :: GenTokenParser s u m -> ParsecT s u m Integer
-- | Parses a positive whole number in the octal system. The number should
-- be prefixed with "0o" or "0O". Returns the value of the number.
octal :: GenTokenParser s u m -> ParsecT s u m Integer
-- | Lexeme parser symbol s parses string s and
-- skips trailing white space.
symbol :: GenTokenParser s u m -> String -> ParsecT s u m String
-- | lexeme p first applies parser p and than the
-- whiteSpace parser, returning the value of p. Every
-- lexical token (lexeme) is defined using lexeme, this way
-- every parse starts at a point without white space. Parsers that use
-- lexeme are called lexeme parsers in this document.
--
-- The only point where the whiteSpace parser should be called
-- explicitly is the start of the main parser in order to skip any
-- leading white space.
--
--
-- mainParser = do{ whiteSpace
-- ; ds <- many (lexeme digit)
-- ; eof
-- ; return (sum ds)
-- }
--
lexeme :: GenTokenParser s u m -> forall a. ParsecT s u m a -> ParsecT s u m a
-- | Parses any white space. White space consists of zero or more
-- occurrences of a space, a line comment or a block (multi line)
-- comment. Block comments may be nested. How comments are started and
-- ended is defined in the LanguageDef that is passed to
-- makeTokenParser.
whiteSpace :: GenTokenParser s u m -> ParsecT s u m ()
-- | Lexeme parser parens p parses p enclosed in
-- parenthesis, returning the value of p.
parens :: GenTokenParser s u m -> forall a. ParsecT s u m a -> ParsecT s u m a
-- | Lexeme parser braces p parses p enclosed in braces
-- ('{' and '}'), returning the value of p.
braces :: GenTokenParser s u m -> forall a. ParsecT s u m a -> ParsecT s u m a
-- | Lexeme parser angles p parses p enclosed in angle
-- brackets ('<' and '>'), returning the value of p.
angles :: GenTokenParser s u m -> forall a. ParsecT s u m a -> ParsecT s u m a
-- | Lexeme parser brackets p parses p enclosed in
-- brackets ('[' and ']'), returning the value of p.
brackets :: GenTokenParser s u m -> forall a. ParsecT s u m a -> ParsecT s u m a
-- | DEPRECATED: Use brackets.
squares :: GenTokenParser s u m -> forall a. ParsecT s u m a -> ParsecT s u m a
-- | Lexeme parser |semi| parses the character ';' and skips any trailing
-- white space. Returns the string ";".
semi :: GenTokenParser s u m -> ParsecT s u m String
-- | Lexeme parser comma parses the character ',' and skips any
-- trailing white space. Returns the string ",".
comma :: GenTokenParser s u m -> ParsecT s u m String
-- | Lexeme parser colon parses the character ':' and skips any
-- trailing white space. Returns the string ":".
colon :: GenTokenParser s u m -> ParsecT s u m String
-- | Lexeme parser dot parses the character '.' and skips any
-- trailing white space. Returns the string ".".
dot :: GenTokenParser s u m -> ParsecT s u m String
-- | Lexeme parser semiSep p parses zero or more
-- occurrences of p separated by semi. Returns a list of
-- values returned by p.
semiSep :: GenTokenParser s u m -> forall a. ParsecT s u m a -> ParsecT s u m [a]
-- | Lexeme parser semiSep1 p parses one or more
-- occurrences of p separated by semi. Returns a list of
-- values returned by p.
semiSep1 :: GenTokenParser s u m -> forall a. ParsecT s u m a -> ParsecT s u m [a]
-- | Lexeme parser commaSep p parses zero or more
-- occurrences of p separated by comma. Returns a list of
-- values returned by p.
commaSep :: GenTokenParser s u m -> forall a. ParsecT s u m a -> ParsecT s u m [a]
-- | Lexeme parser commaSep1 p parses one or more
-- occurrences of p separated by comma. Returns a list of
-- values returned by p.
commaSep1 :: GenTokenParser s u m -> forall a. ParsecT s u m a -> ParsecT s u m [a]
-- | The expression makeTokenParser language creates a
-- GenTokenParser record that contains lexical parsers that are
-- defined using the definitions in the language record.
--
-- The use of this function is quite stylized - one imports the
-- appropiate language definition and selects the lexical parsers that
-- are needed from the resulting GenTokenParser.
--
--
-- module Main where
--
-- import Text.Parsec
-- import qualified Text.Parsec.Token as P
-- import Text.Parsec.Language (haskellDef)
--
-- -- The parser
-- ...
--
-- expr = parens expr
-- <|> identifier
-- <|> ...
--
--
-- -- The lexer
-- lexer = P.makeTokenParser haskellDef
--
-- parens = P.parens lexer
-- braces = P.braces lexer
-- identifier = P.identifier lexer
-- reserved = P.reserved lexer
-- ...
--
makeTokenParser :: Stream s m Char => GenLanguageDef s u m -> GenTokenParser s u m
-- | A helper module to parse "expressions". Builds a parser given a table
-- of operators and associativities.
module Text.Parsec.Expr
-- | This data type specifies the associativity of operators: left, right
-- or none.
data Assoc
AssocNone :: Assoc
AssocLeft :: Assoc
AssocRight :: Assoc
-- | This data type specifies operators that work on values of type
-- a. An operator is either binary infix or unary prefix or
-- postfix. A binary operator has also an associated associativity.
data Operator s u m a
Infix :: (ParsecT s u m (a -> a -> a)) -> Assoc -> Operator s u m a
Prefix :: (ParsecT s u m (a -> a)) -> Operator s u m a
Postfix :: (ParsecT s u m (a -> a)) -> Operator s u m a
-- | An OperatorTable s u m a is a list of Operator s u m
-- a lists. The list is ordered in descending precedence. All
-- operators in one list have the same precedence (but may have a
-- different associativity).
type OperatorTable s u m a = [[Operator s u m a]]
-- | buildExpressionParser table term builds an expression parser
-- for terms term with operators from table, taking the
-- associativity and precedence specified in table into account.
-- Prefix and postfix operators of the same precedence can only occur
-- once (i.e. --2 is not allowed if - is prefix
-- negate). Prefix and postfix operators of the same precedence associate
-- to the left (i.e. if ++ is postfix increment, than
-- -2++ equals -1, not -3).
--
-- The buildExpressionParser takes care of all the complexity
-- involved in building expression parser. Here is an example of an
-- expression parser that handles prefix signs, postfix increment and
-- basic arithmetic.
--
--
-- expr = buildExpressionParser table term
-- <?> "expression"
--
-- term = parens expr
-- <|> natural
-- <?> "simple expression"
--
-- table = [ [prefix "-" negate, prefix "+" id ]
-- , [postfix "++" (+1)]
-- , [binary "*" (*) AssocLeft, binary "/" (div) AssocLeft ]
-- , [binary "+" (+) AssocLeft, binary "-" (-) AssocLeft ]
-- ]
--
-- binary name fun assoc = Infix (do{ reservedOp name; return fun }) assoc
-- prefix name fun = Prefix (do{ reservedOp name; return fun })
-- postfix name fun = Postfix (do{ reservedOp name; return fun })
--
buildExpressionParser :: Stream s m t => OperatorTable s u m a -> ParsecT s u m a -> ParsecT s u m a
-- | Parsec compatibility module
module Text.ParserCombinators.Parsec.Prim
-- | The parser p ? msg behaves as parser p, but
-- whenever the parser p fails without consuming any
-- input, it replaces expect error messages with the expect error
-- message msg.
--
-- This is normally used at the end of a set alternatives where we want
-- to return an error message in terms of a higher level construct rather
-- than returning all possible characters. For example, if the
-- expr parser from the try example would fail, the error
-- message is: '...: expecting expression'. Without the
-- (<?>) combinator, the message would be like '...:
-- expecting "let" or letter', which is less friendly.
() :: (ParsecT s u m a) -> String -> (ParsecT s u m a)
-- | This combinator implements choice. The parser p <|> q
-- first applies p. If it succeeds, the value of p is
-- returned. If p fails without consuming any input,
-- parser q is tried. This combinator is defined equal to the
-- mplus member of the MonadPlus class and the
-- (<|>) member of Alternative.
--
-- The parser is called predictive since q is only tried
-- when parser p didn't consume any input (i.e.. the look ahead
-- is 1). This non-backtracking behaviour allows for both an efficient
-- implementation of the parser combinators and the generation of good
-- error messages.
(<|>) :: (ParsecT s u m a) -> (ParsecT s u m a) -> (ParsecT s u m a)
type Parser = Parsec String ()
type GenParser tok st = Parsec [tok] st
runParser :: GenParser tok st a -> st -> SourceName -> [tok] -> Either ParseError a
-- | parse p filePath input runs a parser p over Identity
-- without user state. The filePath is only used in error
-- messages and may be the empty string. Returns either a
-- ParseError (Left) or a value of type a
-- (Right).
--
--
-- main = case (parse numbers "" "11, 2, 43") of
-- Left err -> print err
-- Right xs -> print (sum xs)
--
-- numbers = commaSep integer
--
parse :: Stream s Identity t => Parsec s () a -> SourceName -> s -> Either ParseError a
-- | parseFromFile p filePath runs a string parser p on
-- the input read from filePath using readFile. Returns
-- either a ParseError (Left) or a value of type a
-- (Right).
--
--
-- main = do{ result <- parseFromFile numbers "digits.txt"
-- ; case result of
-- Left err -> print err
-- Right xs -> print (sum xs)
-- }
--
parseFromFile :: Parser a -> String -> IO (Either ParseError a)
-- | The expression parseTest p input applies a parser p
-- against input input and prints the result to stdout. Used for
-- testing parsers.
parseTest :: (Stream s Identity t, Show a) => Parsec s () a -> s -> IO ()
-- | The parser token showTok posFromTok testTok accepts a token
-- t with result x when the function testTok t
-- returns Just x. The source position of the t
-- should be returned by posFromTok t and the token can be shown
-- using showTok t.
--
-- This combinator is expressed in terms of tokenPrim. It is used
-- to accept user defined token streams. For example, suppose that we
-- have a stream of basic tokens tupled with source positions. We can
-- than define a parser that accepts single tokens as:
--
--
-- mytoken x
-- = token showTok posFromTok testTok
-- where
-- showTok (pos,t) = show t
-- posFromTok (pos,t) = pos
-- testTok (pos,t) = if x == t then Just t else Nothing
--
token :: Stream s Identity t => (t -> String) -> (t -> SourcePos) -> (t -> Maybe a) -> Parsec s u a
tokens :: (Stream s m t, Eq t) => ([t] -> String) -> (SourcePos -> [t] -> SourcePos) -> [t] -> ParsecT s u m [t]
-- | The parser tokenPrim showTok nextPos testTok accepts a token
-- t with result x when the function testTok t
-- returns Just x. The token can be shown using
-- showTok t. The position of the next token should be
-- returned when nextPos is called with the current source
-- position pos, the current token t and the rest of
-- the tokens toks, nextPos pos t toks.
--
-- This is the most primitive combinator for accepting tokens. For
-- example, the char parser could be implemented as:
--
--
-- char c
-- = tokenPrim showChar nextPos testChar
-- where
-- showChar x = "'" ++ x ++ "'"
-- testChar x = if x == c then Just x else Nothing
-- nextPos pos x xs = updatePosChar pos x
--
tokenPrim :: Stream s m t => (t -> String) -> (SourcePos -> t -> s -> SourcePos) -> (t -> Maybe a) -> ParsecT s u m a
tokenPrimEx :: Stream s m t => (t -> String) -> (SourcePos -> t -> s -> SourcePos) -> Maybe (SourcePos -> t -> s -> u -> u) -> (t -> Maybe a) -> ParsecT s u m a
try :: GenParser tok st a -> GenParser tok st a
label :: ParsecT s u m a -> String -> ParsecT s u m a
labels :: ParsecT s u m a -> [String] -> ParsecT s u m a
-- | The parser unexpected msg always fails with an unexpected
-- error message msg without consuming any input.
--
-- The parsers fail, (<?>) and unexpected
-- are the three parsers used to generate error messages. Of these, only
-- (<?>) is commonly used. For an example of the use of
-- unexpected, see the definition of notFollowedBy.
unexpected :: Stream s m t => String -> ParsecT s u m a
pzero :: GenParser tok st a
-- | many p applies the parser p zero or more
-- times. Returns a list of the returned values of p.
--
--
-- identifier = do{ c <- letter
-- ; cs <- many (alphaNum <|> char '_')
-- ; return (c:cs)
-- }
--
many :: ParsecT s u m a -> ParsecT s u m [a]
-- | skipMany p applies the parser p zero or more
-- times, skipping its result.
--
--
-- spaces = skipMany space
--
skipMany :: ParsecT s u m a -> ParsecT s u m ()
-- | Returns the current user state.
getState :: Monad m => ParsecT s u m u
-- | An alias for putState for backwards compatibility.
setState :: Monad m => u -> ParsecT s u m ()
-- | An alias for modifyState for backwards compatibility.
updateState :: Monad m => (u -> u) -> ParsecT s u m ()
-- | Returns the current source position. See also SourcePos.
getPosition :: Monad m => ParsecT s u m SourcePos
-- | setPosition pos sets the current source position to
-- pos.
setPosition :: Monad m => SourcePos -> ParsecT s u m ()
-- | Returns the current input
getInput :: Monad m => ParsecT s u m s
-- | setInput input continues parsing with input. The
-- getInput and setInput functions can for example be
-- used to deal with #include files.
setInput :: Monad m => s -> ParsecT s u m ()
data State s u
State :: s -> !SourcePos -> !u -> State s u
stateInput :: State s u -> s
statePos :: State s u -> !SourcePos
stateUser :: State s u -> !u
-- | Returns the full parser state as a State record.
getParserState :: Monad m => ParsecT s u m (State s u)
-- | setParserState st set the full parser state to st.
setParserState :: Monad m => State s u -> ParsecT s u m (State s u)
-- | Parsec compatibility module
module Text.ParserCombinators.Parsec
-- | The abstract data type ParseError represents parse errors. It
-- provides the source position (SourcePos) of the error and a
-- list of error messages (Message). A ParseError can be
-- returned by the function parse. ParseError is an
-- instance of the Show class.
data ParseError
-- | Extracts the source position from the parse error
errorPos :: ParseError -> SourcePos
-- | The abstract data type SourcePos represents source positions.
-- It contains the name of the source (i.e. file name), a line number and
-- a column number. SourcePos is an instance of the Show,
-- Eq and Ord class.
data SourcePos
type SourceName = String
type Line = Int
type Column = Int
-- | Extracts the name of the source from a source position.
sourceName :: SourcePos -> SourceName
-- | Extracts the line number from a source position.
sourceLine :: SourcePos -> Line
-- | Extracts the column number from a source position.
sourceColumn :: SourcePos -> Column
-- | Increments the line number of a source position.
incSourceLine :: SourcePos -> Line -> SourcePos
-- | Increments the column number of a source position.
incSourceColumn :: SourcePos -> Column -> SourcePos
-- | Set the line number of a source position.
setSourceLine :: SourcePos -> Line -> SourcePos
-- | Set the column number of a source position.
setSourceColumn :: SourcePos -> Column -> SourcePos
-- | Set the name of the source.
setSourceName :: SourcePos -> SourceName -> SourcePos
-- | Parsec compatibility module
module Text.ParserCombinators.Parsec.Expr
-- | This data type specifies the associativity of operators: left, right
-- or none.
data Assoc
AssocNone :: Assoc
AssocLeft :: Assoc
AssocRight :: Assoc
data Operator tok st a
Infix :: (GenParser tok st (a -> a -> a)) -> Assoc -> Operator tok st a
Prefix :: (GenParser tok st (a -> a)) -> Operator tok st a
Postfix :: (GenParser tok st (a -> a)) -> Operator tok st a
type OperatorTable tok st a = [[Operator tok st a]]
buildExpressionParser :: OperatorTable tok st a -> GenParser tok st a -> GenParser tok st a
module Text.Parsec
-- | The abstract data type ParseError represents parse errors. It
-- provides the source position (SourcePos) of the error and a
-- list of error messages (Message). A ParseError can be
-- returned by the function parse. ParseError is an
-- instance of the Show class.
data ParseError
-- | Extracts the source position from the parse error
errorPos :: ParseError -> SourcePos
-- | The abstract data type SourcePos represents source positions.
-- It contains the name of the source (i.e. file name), a line number and
-- a column number. SourcePos is an instance of the Show,
-- Eq and Ord class.
data SourcePos
type SourceName = String
type Line = Int
type Column = Int
-- | Extracts the name of the source from a source position.
sourceName :: SourcePos -> SourceName
-- | Extracts the line number from a source position.
sourceLine :: SourcePos -> Line
-- | Extracts the column number from a source position.
sourceColumn :: SourcePos -> Column
-- | Increments the line number of a source position.
incSourceLine :: SourcePos -> Line -> SourcePos
-- | Increments the column number of a source position.
incSourceColumn :: SourcePos -> Column -> SourcePos
-- | Set the line number of a source position.
setSourceLine :: SourcePos -> Line -> SourcePos
-- | Set the column number of a source position.
setSourceColumn :: SourcePos -> Column -> SourcePos
-- | Set the name of the source.
setSourceName :: SourcePos -> SourceName -> SourcePos
-- | A helper module that defines some language definitions that can be
-- used to instantiate a token parser (see Text.Parsec.Token).
module Text.Parsec.Language
-- | The language definition for the Haskell language.
haskellDef :: LanguageDef st
-- | A lexer for the haskell language.
haskell :: TokenParser st
-- | The language definition for the language Mondrian.
mondrianDef :: LanguageDef st
-- | A lexer for the mondrian language.
mondrian :: TokenParser st
emptyDef :: LanguageDef st
-- | This is a minimal token definition for Haskell style languages. It
-- defines the style of comments, valid identifiers and case sensitivity.
-- It does not define any reserved words or operators.
haskellStyle :: LanguageDef st
-- | This is a minimal token definition for Java style languages. It
-- defines the style of comments, valid identifiers and case sensitivity.
-- It does not define any reserved words or operators.
javaStyle :: LanguageDef st
type LanguageDef st = GenLanguageDef String st Identity
-- | The GenLanguageDef type is a record that contains all
-- parameterizable features of the Token module. The module
-- Language contains some default definitions.
data GenLanguageDef s u m
-- | Parsec compatibility module
module Text.ParserCombinators.Parsec.Language
-- | The language definition for the Haskell language.
haskellDef :: LanguageDef st
-- | A lexer for the haskell language.
haskell :: TokenParser st
-- | The language definition for the language Mondrian.
mondrianDef :: LanguageDef st
-- | A lexer for the mondrian language.
mondrian :: TokenParser st
emptyDef :: LanguageDef st
-- | This is a minimal token definition for Haskell style languages. It
-- defines the style of comments, valid identifiers and case sensitivity.
-- It does not define any reserved words or operators.
haskellStyle :: LanguageDef st
-- | This is a minimal token definition for Java style languages. It
-- defines the style of comments, valid identifiers and case sensitivity.
-- It does not define any reserved words or operators.
javaStyle :: LanguageDef st
type LanguageDef st = GenLanguageDef String st Identity
-- | The GenLanguageDef type is a record that contains all
-- parameterizable features of the Token module. The module
-- Language contains some default definitions.
data GenLanguageDef s u m
LanguageDef :: String -> String -> String -> Bool -> ParsecT s u m Char -> ParsecT s u m Char -> ParsecT s u m Char -> ParsecT s u m Char -> [String] -> [String] -> Bool -> GenLanguageDef s u m
-- | Describes the start of a block comment. Use the empty string if the
-- language doesn't support block comments. For example "/*".
commentStart :: GenLanguageDef s u m -> String
-- | Describes the end of a block comment. Use the empty string if the
-- language doesn't support block comments. For example "*/".
commentEnd :: GenLanguageDef s u m -> String
-- | Describes the start of a line comment. Use the empty string if the
-- language doesn't support line comments. For example "//".
commentLine :: GenLanguageDef s u m -> String
-- | Set to True if the language supports nested block comments.
nestedComments :: GenLanguageDef s u m -> Bool
-- | This parser should accept any start characters of identifiers. For
-- example letter <|> char "_".
identStart :: GenLanguageDef s u m -> ParsecT s u m Char
-- | This parser should accept any legal tail characters of identifiers.
-- For example alphaNum <|> char "_".
identLetter :: GenLanguageDef s u m -> ParsecT s u m Char
-- | This parser should accept any start characters of operators. For
-- example oneOf ":!#$%&*+./<=>?@\\^|-~"
opStart :: GenLanguageDef s u m -> ParsecT s u m Char
-- | This parser should accept any legal tail characters of operators. Note
-- that this parser should even be defined if the language doesn't
-- support user-defined operators, or otherwise the reservedOp
-- parser won't work correctly.
opLetter :: GenLanguageDef s u m -> ParsecT s u m Char
-- | The list of reserved identifiers.
reservedNames :: GenLanguageDef s u m -> [String]
-- | The list of reserved operators.
reservedOpNames :: GenLanguageDef s u m -> [String]
-- | Set to True if the language is case sensitive.
caseSensitive :: GenLanguageDef s u m -> Bool
-- | This module implements permutation parsers. The algorithm used is
-- fairly complex since we push the type system to its limits :-) The
-- algorithm is described in:
--
-- Parsing Permutation Phrases, by Arthur Baars, Andres Loh and
-- Doaitse Swierstra. Published as a functional pearl at the Haskell
-- Workshop 2001.
module Text.Parsec.Perm
-- | Provided for backwards compatibility. The tok type is ignored.
type PermParser tok st a = StreamPermParser String st a
-- | The type StreamPermParser s st a denotes a permutation parser
-- that, when converted by the permute function, parses s
-- streams with user state st and returns a value of type
-- a on success.
--
-- Normally, a permutation parser is first build with special operators
-- like (<||>) and than transformed into a normal parser
-- using permute.
data StreamPermParser s st a
-- | The parser permute perm parses a permutation of parser
-- described by perm. For example, suppose we want to parse a
-- permutation of: an optional string of a's, the character
-- b and an optional c. This can be described by:
--
--
-- test = permute (tuple <$?> ("",many1 (char 'a'))
-- <||> char 'b'
-- <|?> ('_',char 'c'))
-- where
-- tuple a b c = (a,b,c)
--
permute :: Stream s Identity tok => StreamPermParser s st a -> Parsec s st a
-- | The expression perm <||> p adds parser p to
-- the permutation parser perm. The parser p is not
-- allowed to accept empty input - use the optional combinator
-- (<|?>) instead. Returns a new permutation parser that
-- includes p.
(<||>) :: Stream s Identity tok => StreamPermParser s st (a -> b) -> Parsec s st a -> StreamPermParser s st b
-- | The expression f <$$> p creates a fresh permutation
-- parser consisting of parser p. The the final result of the
-- permutation parser is the function f applied to the return
-- value of p. The parser p is not allowed to accept
-- empty input - use the optional combinator (<$?>) instead.
--
-- If the function f takes more than one parameter, the type
-- variable b is instantiated to a functional type which
-- combines nicely with the adds parser p to the
-- (<||>) combinator. This results in stylized code where a
-- permutation parser starts with a combining function f
-- followed by the parsers. The function f gets its parameters
-- in the order in which the parsers are specified, but actual input can
-- be in any order.
(<$$>) :: Stream s Identity tok => (a -> b) -> Parsec s st a -> StreamPermParser s st b
-- | The expression perm <||> (x,p) adds parser p
-- to the permutation parser perm. The parser p is
-- optional - if it can not be applied, the default value x will
-- be used instead. Returns a new permutation parser that includes the
-- optional parser p.
(<|?>) :: Stream s Identity tok => StreamPermParser s st (a -> b) -> (a, Parsec s st a) -> StreamPermParser s st b
-- | The expression f <$?> (x,p) creates a fresh permutation
-- parser consisting of parser p. The the final result of the
-- permutation parser is the function f applied to the return
-- value of p. The parser p is optional - if it can not
-- be applied, the default value x will be used instead.
(<$?>) :: Stream s Identity tok => (a -> b) -> (a, Parsec s st a) -> StreamPermParser s st b
-- | Parsec compatibility module
module Text.ParserCombinators.Parsec.Perm
-- | Provided for backwards compatibility. The tok type is ignored.
type PermParser tok st a = StreamPermParser String st a
-- | The parser permute perm parses a permutation of parser
-- described by perm. For example, suppose we want to parse a
-- permutation of: an optional string of a's, the character
-- b and an optional c. This can be described by:
--
--
-- test = permute (tuple <$?> ("",many1 (char 'a'))
-- <||> char 'b'
-- <|?> ('_',char 'c'))
-- where
-- tuple a b c = (a,b,c)
--
permute :: Stream s Identity tok => StreamPermParser s st a -> Parsec s st a
-- | The expression perm <||> p adds parser p to
-- the permutation parser perm. The parser p is not
-- allowed to accept empty input - use the optional combinator
-- (<|?>) instead. Returns a new permutation parser that
-- includes p.
(<||>) :: Stream s Identity tok => StreamPermParser s st (a -> b) -> Parsec s st a -> StreamPermParser s st b
-- | The expression f <$$> p creates a fresh permutation
-- parser consisting of parser p. The the final result of the
-- permutation parser is the function f applied to the return
-- value of p. The parser p is not allowed to accept
-- empty input - use the optional combinator (<$?>) instead.
--
-- If the function f takes more than one parameter, the type
-- variable b is instantiated to a functional type which
-- combines nicely with the adds parser p to the
-- (<||>) combinator. This results in stylized code where a
-- permutation parser starts with a combining function f
-- followed by the parsers. The function f gets its parameters
-- in the order in which the parsers are specified, but actual input can
-- be in any order.
(<$$>) :: Stream s Identity tok => (a -> b) -> Parsec s st a -> StreamPermParser s st b
-- | The expression perm <||> (x,p) adds parser p
-- to the permutation parser perm. The parser p is
-- optional - if it can not be applied, the default value x will
-- be used instead. Returns a new permutation parser that includes the
-- optional parser p.
(<|?>) :: Stream s Identity tok => StreamPermParser s st (a -> b) -> (a, Parsec s st a) -> StreamPermParser s st b
-- | The expression f <$?> (x,p) creates a fresh permutation
-- parser consisting of parser p. The the final result of the
-- permutation parser is the function f applied to the return
-- value of p. The parser p is optional - if it can not
-- be applied, the default value x will be used instead.
(<$?>) :: Stream s Identity tok => (a -> b) -> (a, Parsec s st a) -> StreamPermParser s st b