-- 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.1 -- | 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 GHC.Classes.Ord Text.ParserCombinators.Parsec.Pos.SourcePos instance GHC.Classes.Eq Text.ParserCombinators.Parsec.Pos.SourcePos instance GHC.Show.Show Text.ParserCombinators.Parsec.Pos.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 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 GHC.Show.Show Text.ParserCombinators.Parsec.Error.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 -- (<|>) 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. (<|>) :: 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 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 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 GHC.Base.Functor (Text.ParserCombinators.Parsec.Prim.GenParser tok st) instance GHC.Base.Monad (Text.ParserCombinators.Parsec.Prim.GenParser tok st) instance GHC.Base.MonadPlus (Text.ParserCombinators.Parsec.Prim.GenParser tok st) instance GHC.Base.Applicative (Text.ParserCombinators.Parsec.Prim.GenParser tok st) instance GHC.Base.Alternative (Text.ParserCombinators.Parsec.Prim.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 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 -- | 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 -- | 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 Token module. The module -- 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 Token module. The module -- 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