lex s = readP_to_S L.hsLex s
lexLitChar :: ReadS String -- As defined by H98
-lexLitChar = readP_to_S (do { P.skipSpaces ;
- (s, L.Char _) <- P.gather L.lex ;
+lexLitChar = readP_to_S (do { (s, _) <- P.gather L.lexChar ;
return s })
+ -- There was a skipSpaces before the P.gather L.lexChar,
+ -- but that seems inconsistent with readLitChar
readLitChar :: ReadS Char -- As defined by H98
-readLitChar = readP_to_S (do { L.Char c <- L.lex ;
- return c })
+readLitChar = readP_to_S L.lexChar
lexDigits :: ReadS String
lexDigits = readP_to_S (P.munch1 isDigit)
lexP = lift L.lex
paren :: ReadPrec a -> ReadPrec a
--- ^ @(paren p)@ parses "(P0)"
--- where @p@ parses "P0" in precedence context zero
+-- ^ @(paren p)@ parses \"(P0)\"
+-- where @p@ parses \"P0\" in precedence context zero
paren p = do L.Punc "(" <- lexP
x <- reset p
L.Punc ")" <- lexP
return x
parens :: ReadPrec a -> ReadPrec a
--- ^ @(parens p)@ parses "P", "(P0)", "((P0))", etc,
--- where @p@ parses "P" in the current precedence context
--- parses "P0" in precedence context zero
+-- ^ @(parens p)@ parses \"P\", \"(P0)\", \"((P0))\", etc,
+-- where @p@ parses \"P\" in the current precedence context
+-- parses \"P0\" in precedence context zero
parens p = optional
where
optional = p +++ mandatory
choose :: [(String, ReadPrec a)] -> ReadPrec a
-- ^ Parse the specified lexeme and continue as specified.
-- Esp useful for nullary constructors; e.g.
--- @choose [("A", return A), ("B", return B)]@
+-- @choose [(\"A\", return A), (\"B\", return B)]@
choose sps = foldr ((+++) . try_one) pfail sps
where
try_one (s,p) = do { L.Ident s' <- lexP ;
there is one parenthesis parsed, then the required precedence level
drops to 0 again, and parsing inside p may succeed.
-'appPrec' is just the precedence level of function application (maybe
-it should be called 'appPrec' instead). So, if we are parsing
-function application, we'd better require the precedence level to be
-at least 'appPrec'. Otherwise, we have to put parentheses around it.
+'appPrec' is just the precedence level of function application. So,
+if we are parsing function application, we'd better require the
+precedence level to be at least 'appPrec'. Otherwise, we have to put
+parentheses around it.
'step' is used to increase the precedence levels inside a
parser, and can be used to express left- or right- associativity. For