-- 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. -- -- This package is a maintained fork of version 2.1 of the parsec -- package, intended to preserve its simplicity and portability. @package parsec2 @version 1.0.0 -- | Textual source positions. 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 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 Eq SourcePos instance Ord SourcePos instance Show SourcePos -- | Parse errors 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: -- -- 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 Text.Parsec.Prim.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 -- | Language independent show function 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 -- | The primitive parser combinators. 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. () :: GenParser tok st a -> String -> GenParser tok st 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 -- (Control.Applicative.<|>) member of -- Control.Applicative.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. (<|>) :: GenParser tok st a -> GenParser tok st a -> GenParser tok st a type Parser a = GenParser Char () a data GenParser tok st a -- | The most general way to run a parser. 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 :: GenParser tok st a -> st -> SourceName -> [tok] -> Either ParseError a -- | parse p filePath input runs a parser p 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 :: GenParser tok () a -> SourceName -> [tok] -> Either ParseError a parseFromFile :: Parser a -> SourceName -> 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 :: Show a => GenParser tok () a -> [tok] -> 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 :: (tok -> String) -> (tok -> SourcePos) -> (tok -> Maybe a) -> GenParser tok st a tokens :: Eq tok => ([tok] -> String) -> (SourcePos -> [tok] -> SourcePos) -> [tok] -> GenParser tok st [tok] -- | The parser token 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 Text.Parsec.Char.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 :: (tok -> String) -> (SourcePos -> tok -> [tok] -> SourcePos) -> (tok -> Maybe a) -> GenParser tok st a -- | The most primitive token recogniser. The expression tokenPrimEx -- show nextpos mbnextstate test, recognises tokens when -- test returns Just x (and returns the value -- x). Tokens are shown in error messages using show. -- The position is calculated using nextpos, and finally, -- mbnextstate, can hold a function that updates the user state -- on every token recognised (nice to count tokens :-). The function is -- packed into a Maybe type for performance reasons. tokenPrimEx :: (tok -> String) -> (SourcePos -> tok -> [tok] -> SourcePos) -> Maybe (SourcePos -> tok -> [tok] -> st -> st) -> (tok -> Maybe a) -> GenParser tok st a -- | 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 :: GenParser tok st a -> GenParser tok st a label :: GenParser tok st a -> String -> GenParser tok st a labels :: GenParser tok st a -> [String] -> GenParser tok st 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 -- Text.Parsec.Combinator.notFollowedBy. unexpected :: String -> GenParser tok st 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 :: GenParser tok st a -> GenParser tok st [a] -- | skipMany p applies the parser p zero or more -- times, skipping its result. -- -- 
--   spaces  = skipMany space
--
skipMany :: GenParser tok st a -> GenParser tok st () -- | Returns the current user state. getState :: GenParser tok st st -- | setState st set the user state to st. setState :: st -> GenParser tok st () -- | 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)
--             }
--
updateState :: (st -> st) -> GenParser tok st () -- | Returns the current source position. See also SourcePos. getPosition :: GenParser tok st SourcePos -- | setPosition pos sets the current source position to -- pos. setPosition :: SourcePos -> GenParser tok st () -- | Returns the current input getInput :: GenParser tok st [tok] -- | setInput input continues parsing with input. setInput :: [tok] -> GenParser tok st () data State tok st State :: [tok] -> !SourcePos -> !st -> State tok st stateInput :: State tok st -> [tok] statePos :: State tok st -> !SourcePos stateUser :: State tok st -> !st -- | Returns the full parser state as a State record. getParserState :: GenParser tok st (State tok st) -- | setParserState st set the full parser state to st. setParserState :: State tok st -> GenParser tok st (State tok st) instance MonadPlus (GenParser tok st) instance Monad (GenParser tok st) instance Functor (GenParser tok st) -- | Commonly used character parsers. module Text.ParserCombinators.Parsec.Char type CharParser st a = GenParser Char st a -- | Skips zero or more white space characters. See also -- skipMany. spaces :: CharParser st () -- | Parses a white space character (any character which satisfies -- isSpace) Returns the parsed character. space :: CharParser st Char -- | Parses a newline character ('\n'). Returns a newline character. newline :: CharParser st Char -- | Parses a tab character ('\t'). Returns a tab character. tab :: CharParser st Char -- | Parses an upper case letter (a character between 'A' and 'Z'). Returns -- the parsed character. upper :: CharParser st Char -- | Parses a lower case character (a character between 'a' and 'z'). -- Returns the parsed character. lower :: CharParser st Char -- | Parses a letter or digit (a character between '0' and '9'). Returns -- the parsed character. alphaNum :: CharParser st Char -- | Parses a letter (an upper case or lower case character). Returns the -- parsed character. letter :: CharParser st Char -- | Parses a digit. Returns the parsed character. digit :: CharParser st Char -- | Parses a hexadecimal digit (a digit or a letter between 'a' and 'f' or -- 'A' and 'F'). Returns the parsed character. hexDigit :: CharParser st Char -- | Parses an octal digit (a character between '0' and '7'). Returns the -- parsed character. octDigit :: CharParser st Char -- | char c parses a single character c. Returns the -- parsed character (i.e. c). -- -- 
--   semiColon  = char ';'
--
char :: Char -> CharParser st Char -- | string s parses a sequence of characters given by s. -- Returns the parsed string (i.e. s). -- -- 
--   divOrMod    =   string "div"
--               <|> string "mod"
--
string :: String -> CharParser st String -- | This parser succeeds for any character. Returns the parsed character. anyChar :: CharParser st 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 :: [Char] -> CharParser st 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 :: [Char] -> CharParser st Char -- | The parser satisfy f succeeds for any character for which the -- supplied function f returns True. Returns the -- character that is actually parsed. -- -- 
--   digit     = satisfy isDigit
--   oneOf cs  = satisfy (\c -> c `elem` cs)
--
satisfy :: (Char -> Bool) -> CharParser st Char -- | Commonly used generic combinators 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 :: [GenParser tok st a] -> GenParser tok st 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 :: Int -> GenParser tok st a -> GenParser tok st [a] -- | between open close p parses open, followed by -- p and close. Returns the value returned by -- p. -- -- 
--   braces  = between (symbol "{") (symbol "}")
--
between :: GenParser tok st open -> GenParser tok st close -> GenParser tok st a -> GenParser tok st 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 :: a -> GenParser tok st a -> GenParser tok st 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 :: GenParser tok st a -> GenParser tok st (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 :: GenParser tok st a -> GenParser tok st () -- | skipMany1 p applies the parser p one or more -- times, skipping its result. skipMany1 :: GenParser tok st a -> GenParser tok st () -- | many1 p applies the parser p one or more -- times. Returns a list of the returned values of p. -- -- 
--   word  = many1 letter
--
many1 :: GenParser tok st a -> GenParser tok st [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 :: GenParser tok st a -> GenParser tok st sep -> GenParser tok st [a] -- | sepBy1 p sep parses one or more occurrences of -- p, separated by sep. Returns a list of values -- returned by p. sepBy1 :: GenParser tok st a -> GenParser tok st sep -> GenParser tok st [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 :: GenParser tok st a -> GenParser tok st sep -> GenParser tok st [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 :: GenParser tok st a -> GenParser tok st sep -> GenParser tok st [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 :: GenParser tok st a -> GenParser tok st sep -> GenParser tok st [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 :: GenParser tok st a -> GenParser tok st sep -> GenParser tok st [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 :: GenParser tok st a -> GenParser tok st (a -> a -> a) -> a -> GenParser tok st 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 :: GenParser tok st a -> GenParser tok st (a -> a -> a) -> GenParser tok st 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 :: GenParser tok st a -> GenParser tok st (a -> a -> a) -> a -> GenParser tok st 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 :: GenParser tok st a -> GenParser tok st (a -> a -> a) -> GenParser tok st 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 :: Show tok => GenParser tok st () -- | 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 :: Show tok => GenParser tok st tok -> GenParser tok st () -- | 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 :: GenParser tok st a -> GenParser tok st end -> GenParser tok st [a] -- | lookAhead p parses p without consuming any input. lookAhead :: GenParser tok st a -> GenParser tok st a -- | The parser anyToken accepts any kind of token. It is for -- example used to implement eof. Returns the accepted token. anyToken :: Show tok => GenParser tok st tok -- | A helper module to parse "expressions". Builds a parser given a table -- of operators and associativities. 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 -- | 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 t st a Infix :: (GenParser t st (a -> a -> a)) -> Assoc -> Operator t st a Prefix :: (GenParser t st (a -> a)) -> Operator t st a Postfix :: (GenParser t st (a -> a)) -> Operator t st 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 t st a = [[Operator t st 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 :: OperatorTable tok st a -> GenParser tok st a -> GenParser tok st a -- | Parsec, the Fast Monadic Parser combinator library, see -- http://www.cs.uu.nl/people/daan/parsec.html. -- -- Inspired by: -- -- -- -- This helper module exports elements from the basic libraries. 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 Text.Parsec.Prim.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 to parse lexical elements (tokens). module Text.ParserCombinators.Parsec.Token -- | The LanguageDef type is a record that contains all -- parameterizable features of the -- Text.ParserCombinators.Parsec.Token module. The module -- Text.ParserCombinators.Parsec.Language contains some default -- definitions. data LanguageDef st LanguageDef :: String -> String -> String -> Bool -> CharParser st Char -> CharParser st Char -> CharParser st Char -> CharParser st Char -> [String] -> [String] -> Bool -> LanguageDef st -- | Describes the start of a block comment. Use the empty string if the -- language doesn't support block comments. For example "/*". commentStart :: LanguageDef st -> String -- | Describes the end of a block comment. Use the empty string if the -- language doesn't support block comments. For example "*/". commentEnd :: LanguageDef st -> String -- | Describes the start of a line comment. Use the empty string if the -- language doesn't support line comments. For example "//". commentLine :: LanguageDef st -> String -- | Set to True if the language supports nested block comments. nestedComments :: LanguageDef st -> Bool -- | This parser should accept any start characters of identifiers. For -- example letter <|> char "_". identStart :: LanguageDef st -> CharParser st Char -- | This parser should accept any legal tail characters of identifiers. -- For example alphaNum <|> char "_". identLetter :: LanguageDef st -> CharParser st Char -- | This parser should accept any start characters of operators. For -- example oneOf ":!#$%&*+./<=>?@\\^|-~" opStart :: LanguageDef st -> CharParser st 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 :: LanguageDef st -> CharParser st Char -- | The list of reserved identifiers. reservedNames :: LanguageDef st -> [String] -- | The list of reserved operators. reservedOpNames :: LanguageDef st -> [String] -- | Set to True if the language is case sensitive. caseSensitive :: LanguageDef st -> Bool -- | The type of the record that holds lexical parsers. data TokenParser st TokenParser :: CharParser st String -> (String -> CharParser st ()) -> CharParser st String -> (String -> CharParser st ()) -> CharParser st Char -> CharParser st String -> CharParser st Integer -> CharParser st Integer -> CharParser st Double -> CharParser st (Either Integer Double) -> CharParser st Integer -> CharParser st Integer -> CharParser st Integer -> (String -> CharParser st String) -> (forall a. CharParser st a -> CharParser st a) -> CharParser st () -> (forall a. CharParser st a -> CharParser st a) -> (forall a. CharParser st a -> CharParser st a) -> (forall a. CharParser st a -> CharParser st a) -> (forall a. CharParser st a -> CharParser st a) -> (forall a. CharParser st a -> CharParser st a) -> CharParser st String -> CharParser st String -> CharParser st String -> CharParser st String -> (forall a. CharParser st a -> CharParser st [a]) -> (forall a. CharParser st a -> CharParser st [a]) -> (forall a. CharParser st a -> CharParser st [a]) -> (forall a. CharParser st a -> CharParser st [a]) -> TokenParser st -- | 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 :: TokenParser st -> CharParser st 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 :: TokenParser st -> String -> CharParser st () -- | 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 :: TokenParser st -> CharParser st 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 :: TokenParser st -> String -> CharParser st () -- | 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 :: TokenParser st -> CharParser st 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 :: TokenParser st -> CharParser st 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 :: TokenParser st -> CharParser st 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 :: TokenParser st -> CharParser st 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 :: TokenParser st -> CharParser st 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 :: TokenParser st -> CharParser st (Either Integer Double) -- | Parses a positive whole number in the decimal system. Returns the -- value of the number. decimal :: TokenParser st -> CharParser st 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 :: TokenParser st -> CharParser st 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 :: TokenParser st -> CharParser st Integer -- | Lexeme parser symbol s parses string s and -- skips trailing white space. symbol :: TokenParser st -> String -> CharParser st 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 :: TokenParser st -> forall a. CharParser st a -> CharParser st 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 :: TokenParser st -> CharParser st () -- | Lexeme parser parens p parses p enclosed in -- parenthesis, returning the value of p. parens :: TokenParser st -> forall a. CharParser st a -> CharParser st a -- | Lexeme parser braces p parses p enclosed in braces -- ('{' and '}'), returning the value of p. braces :: TokenParser st -> forall a. CharParser st a -> CharParser st a -- | Lexeme parser angles p parses p enclosed in angle -- brackets ('<' and '>'), returning the value of p. angles :: TokenParser st -> forall a. CharParser st a -> CharParser st a -- | Lexeme parser brackets p parses p enclosed in -- brackets ('[' and ']'), returning the value of p. brackets :: TokenParser st -> forall a. CharParser st a -> CharParser st a -- | DEPRECATED: Use brackets. squares :: TokenParser st -> forall a. CharParser st a -> CharParser st a -- | Lexeme parser |semi| parses the character ';' and skips any trailing -- white space. Returns the string ";". semi :: TokenParser st -> CharParser st String -- | Lexeme parser comma parses the character ',' and skips any -- trailing white space. Returns the string ",". comma :: TokenParser st -> CharParser st String -- | Lexeme parser colon parses the character ':' and skips any -- trailing white space. Returns the string ":". colon :: TokenParser st -> CharParser st String -- | Lexeme parser dot parses the character '.' and skips any -- trailing white space. Returns the string ".". dot :: TokenParser st -> CharParser st String -- | Lexeme parser semiSep p parses zero or more -- occurrences of p separated by semi. Returns a list of -- values returned by p. semiSep :: TokenParser st -> forall a. CharParser st a -> CharParser st [a] -- | Lexeme parser semiSep1 p parses one or more -- occurrences of p separated by semi. Returns a list of -- values returned by p. semiSep1 :: TokenParser st -> forall a. CharParser st a -> CharParser st [a] -- | Lexeme parser commaSep p parses zero or more -- occurrences of p separated by comma. Returns a list of -- values returned by p. commaSep :: TokenParser st -> forall a. CharParser st a -> CharParser st [a] -- | Lexeme parser commaSep1 p parses one or more -- occurrences of p separated by comma. Returns a list of -- values returned by p. commaSep1 :: TokenParser st -> forall a. CharParser st a -> CharParser st [a] -- | The expression makeTokenParser language creates a -- TokenParser 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 TokenParser. -- -- 
--   module Main where
--   
--   import Text.ParserCombinators.Parsec
--   import qualified Text.ParserCombinators.Parsec.Token as P
--   import Text.ParserCombinators.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 :: LanguageDef st -> TokenParser st -- | A helper module that defines some language definitions that can be -- used to instantiate a token parser (see -- Text.ParserCombinators.Parsec.Token). 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 -- | The LanguageDef type is a record that contains all -- parameterizable features of the -- Text.ParserCombinators.Parsec.Token module. The module -- Text.ParserCombinators.Parsec.Language contains some default -- definitions. data LanguageDef st LanguageDef :: String -> String -> String -> Bool -> CharParser st Char -> CharParser st Char -> CharParser st Char -> CharParser st Char -> [String] -> [String] -> Bool -> LanguageDef st -- | Describes the start of a block comment. Use the empty string if the -- language doesn't support block comments. For example "/*". commentStart :: LanguageDef st -> String -- | Describes the end of a block comment. Use the empty string if the -- language doesn't support block comments. For example "*/". commentEnd :: LanguageDef st -> String -- | Describes the start of a line comment. Use the empty string if the -- language doesn't support line comments. For example "//". commentLine :: LanguageDef st -> String -- | Set to True if the language supports nested block comments. nestedComments :: LanguageDef st -> Bool -- | This parser should accept any start characters of identifiers. For -- example letter <|> char "_". identStart :: LanguageDef st -> CharParser st Char -- | This parser should accept any legal tail characters of identifiers. -- For example alphaNum <|> char "_". identLetter :: LanguageDef st -> CharParser st Char -- | This parser should accept any start characters of operators. For -- example oneOf ":!#$%&*+./<=>?@\\^|-~" opStart :: LanguageDef st -> CharParser st 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 :: LanguageDef st -> CharParser st Char -- | The list of reserved identifiers. reservedNames :: LanguageDef st -> [String] -- | The list of reserved operators. reservedOpNames :: LanguageDef st -> [String] -- | Set to True if the language is case sensitive. caseSensitive :: LanguageDef st -> 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.ParserCombinators.Parsec.Perm -- | The type PermParser tok st a denotes a permutation parser -- that, when converted by the permute function, parses -- tok tokens 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 PermParser tok 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 :: PermParser tok st a -> GenParser tok 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. (<||>) :: PermParser tok st (a -> b) -> GenParser tok st a -> PermParser tok 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. (<$$>) :: (a -> b) -> GenParser tok st a -> PermParser tok 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. (<|?>) :: PermParser tok st (a -> b) -> (a, GenParser tok st a) -> PermParser tok 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. (<$?>) :: (a -> b) -> (a, GenParser tok st a) -> PermParser tok st b