[project @ 2003-03-11 18:41:43 by panne]

[ghc-base.git] / GHC / Read.lhs

diff --git a/GHC/Read.lhs b/GHC/Read.lhs
index 68d0521..17a9d81 100644 (file)
--- a/GHC/Read.lhs
+++ b/GHC/Read.lhs
@@ -41,7 +41,6 @@ module GHC.Read
   , readListDefault, readListPrecDefault
 
   -- Temporary
-  , readList__
   , readParen
   )
  where
@@ -75,11 +74,10 @@ import GHC.Base
 import GHC.Arr
 \end{code}
 
--------------------------------------------------------
-       TEMPORARY UNTIL I DO DERIVED READ
 
 \begin{code}
 readParen       :: Bool -> ReadS a -> ReadS a
+-- A Haskell 98 function
 readParen b g   =  if b then mandatory else optional
                    where optional r  = g r ++ mandatory r
                          mandatory r = do
@@ -87,21 +85,6 @@ readParen b g   =  if b then mandatory else optional
                                (x,t)   <- optional s
                                (")",u) <- lex t
                                return (x,u)
-
-
-readList__ :: ReadS a -> ReadS [a]
-
-readList__ readx
-  = readParen False (\r -> do
-                      ("[",s) <- lex r
-                      readl s)
-  where readl  s = 
-           (do { ("]",t) <- lex s ; return ([],t) }) ++
-          (do { (x,t) <- readx s ; (xs,u) <- readl2 t ; return (x:xs,u) })
-
-       readl2 s = 
-          (do { ("]",t) <- lex s ; return ([],t) }) ++
-          (do { (",",t) <- lex s ; (x,u) <- readx t ; (xs,v) <- readl2 u ; return (x:xs,v) })
 \end{code}
 
 
@@ -194,17 +177,17 @@ lexP :: ReadPrec L.Lexeme
 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
@@ -234,7 +217,7 @@ list readx =
 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 ;
@@ -307,10 +290,10 @@ to parse it in a context with a higher precedence level than k. But if
 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
@@ -326,14 +309,13 @@ parenthesis-like objects such as (...) and [...] can be an argument to
 instance Read a => Read (Maybe a) where
   readPrec =
     parens
-    ( prec appPrec
-      ( do L.Ident "Nothing" <- lexP
-           return Nothing
-       +++
-        do L.Ident "Just" <- lexP
-           x            <- step readPrec
-           return (Just x)
-      )
+    (do L.Ident "Nothing" <- lexP
+        return Nothing
+     +++
+     prec appPrec (
+       do L.Ident "Just" <- lexP
+           x              <- step readPrec
+           return (Just x))
     )
 
   readListPrec = readListPrecDefault