ghc/lib/std/PrelRead.lhs

   1 % ------------------------------------------------------------------------------
   2 % $Id: PrelRead.lhs,v 1.18 2001/02/28 00:01:03 qrczak Exp $
   3 %
   4 % (c) The University of Glasgow, 1994-2000
   5 %
   6
   7 \section[PrelRead]{Module @PrelRead@}
   8
   9 Instances of the Read class.
  10
  11 \begin{code}
  12 {-# OPTIONS -fno-implicit-prelude #-}
  13
  14 module PrelRead where
  15
  16 import PrelErr          ( error )
  17 import PrelEnum         ( Enum(..), maxBound )
  18 import PrelNum
  19 import PrelReal
  20 import PrelFloat
  21 import PrelList
  22 import PrelMaybe
  23 import PrelShow         -- isAlpha etc
  24 import PrelBase
  25
  26 -- needed for readIO and instance Read Buffermode
  27 import PrelIOBase ( IO, userError, BufferMode(..) )
  28 import PrelException ( ioError )
  29 \end{code}
  30
  31 %*********************************************************
  32 %*                                                      *
  33 \subsection{The @Read@ class}
  34 %*                                                      *
  35 %*********************************************************
  36
  37 Note: if you compile this with -DNEW_READS_REP, you'll get
  38 a (simpler) ReadS representation that only allow one valid
  39 parse of a string of characters, instead of a list of
  40 possible ones.
  41
  42 [changing the ReadS rep has implications for the deriving
  43 machinery for Read, a change that hasn't been made, so you
  44 probably won't want to compile in this new rep. except
  45 when in an experimental mood.]
  46
  47 \begin{code}
  48
  49 #ifndef NEW_READS_REP
  50 type  ReadS a   = String -> [(a,String)]
  51 #else
  52 type  ReadS a   = String -> Maybe (a,String)
  53 #endif
  54
  55 class  Read a  where
  56     readsPrec :: Int -> ReadS a
  57
  58     readList  :: ReadS [a]
  59     readList   = readList__ reads
  60 \end{code}
  61
  62 In this module we treat [(a,String)] as a monad in MonadPlus
  63 But MonadPlus isn't defined yet, so we simply give local
  64 declarations for mzero and guard suitable for this particular
  65 type.  It would also be reasonably to move MonadPlus to PrelBase
  66 along with Monad and Functor, but that seems overkill for one
  67 example
  68
  69 \begin{code}
  70 mzero :: [a]
  71 mzero = []
  72
  73 guard :: Bool -> [()]
  74 guard True  = [()]
  75 guard False = []
  76 \end{code}
  77
  78 %*********************************************************
  79 %*                                                      *
  80 \subsection{Utility functions}
  81 %*                                                      *
  82 %*********************************************************
  83
  84 \begin{code}
  85 reads           :: (Read a) => ReadS a
  86 reads           =  readsPrec 0
  87
  88 read            :: (Read a) => String -> a
  89 read s          =
  90    case read_s s of
  91 #ifndef NEW_READS_REP
  92       [x]     -> x
  93       []      -> error "Prelude.read: no parse"
  94       _       -> error "Prelude.read: ambiguous parse"
  95 #else
  96       Just x  -> x
  97       Nothing -> error "Prelude.read: no parse"
  98 #endif
  99  where
 100   read_s str = do
 101     (x,str1) <- reads str
 102     ("","")  <- lex str1
 103     return x
 104
 105   -- raises an exception instead of an error
 106 readIO          :: Read a => String -> IO a
 107 readIO s        =  case (do { (x,t) <- reads s ; ("","") <- lex t ; return x }) of
 108 #ifndef NEW_READS_REP
 109                         [x]    -> return x
 110                         []     -> ioError (userError "Prelude.readIO: no parse")
 111                         _      -> ioError (userError "Prelude.readIO: ambiguous parse")
 112 #else
 113                         Just x -> return x
 114                         Nothing  -> ioError (userError "Prelude.readIO: no parse")
 115 #endif
 116
 117 \end{code}
 118
 119 \begin{code}
 120 readParen       :: Bool -> ReadS a -> ReadS a
 121 readParen b g   =  if b then mandatory else optional
 122                    where optional r  = g r ++ mandatory r
 123                          mandatory r = do
 124                                 ("(",s) <- lex r
 125                                 (x,t)   <- optional s
 126                                 (")",u) <- lex t
 127                                 return (x,u)
 128
 129
 130 readList__ :: ReadS a -> ReadS [a]
 131
 132 readList__ readx
 133   = readParen False (\r -> do
 134                        ("[",s) <- lex r
 135                        readl s)
 136   where readl  s =
 137            (do { ("]",t) <- lex s ; return ([],t) }) ++
 138            (do { (x,t) <- readx s ; (xs,u) <- readl2 t ; return (x:xs,u) })
 139
 140         readl2 s =
 141            (do { ("]",t) <- lex s ; return ([],t) }) ++
 142            (do { (",",t) <- lex s ; (x,u) <- readx t ; (xs,v) <- readl2 u ; return (x:xs,v) })
 143
 144 \end{code}
 145
 146
 147 %*********************************************************
 148 %*                                                      *
 149 \subsection{Lexical analysis}
 150 %*                                                      *
 151 %*********************************************************
 152
 153 This lexer is not completely faithful to the Haskell lexical syntax.
 154 Current limitations:
 155    Qualified names are not handled properly
 156    A `--' does not terminate a symbol
 157    Octal and hexidecimal numerics are not recognized as a single token
 158
 159 \begin{code}
 160 lex                   :: ReadS String
 161
 162 lex ""                = return ("","")
 163 lex (c:s) | isSpace c = lex (dropWhile isSpace s)
 164 lex ('\'':s)          = do
 165             (ch, '\'':t) <- lexLitChar s
 166             guard (ch /= "'")
 167             return ('\'':ch++"'", t)
 168 lex ('"':s)           = do
 169             (str,t) <- lexString s
 170             return ('"':str, t)
 171
 172           where
 173             lexString ('"':s) = return ("\"",s)
 174             lexString s = do
 175                     (ch,t)  <- lexStrItem s
 176                     (str,u) <- lexString t
 177                     return (ch++str, u)
 178
 179
 180             lexStrItem ('\\':'&':s) = return ("\\&",s)
 181             lexStrItem ('\\':c:s) | isSpace c = do
 182                         ('\\':t) <- return (dropWhile isSpace s)
 183                         return ("\\&",t)
 184             lexStrItem s            = lexLitChar s
 185
 186 lex (c:s) | isSingle c = return ([c],s)
 187           | isSym c    = do
 188                 (sym,t) <- return (span isSym s)
 189                 return (c:sym,t)
 190           | isAlpha c  = do
 191                 (nam,t) <- return (span isIdChar s)
 192                 return (c:nam, t)
 193           | isDigit c  = do
 194 {- Removed, 13/03/2000 by SDM.
 195    Doesn't work, and not required by Haskell report.
 196                  let
 197                   (pred, s', isDec) =
 198                     case s of
 199                       ('o':rs) -> (isOctDigit, rs, False)
 200                       ('O':rs) -> (isOctDigit, rs, False)
 201                       ('x':rs) -> (isHexDigit, rs, False)
 202                       ('X':rs) -> (isHexDigit, rs, False)
 203                       _        -> (isDigit, s, True)
 204 -}
 205                  (ds,s)  <- return (span isDigit s)
 206                  (fe,t)  <- lexFracExp s
 207                  return (c:ds++fe,t)
 208           | otherwise  = mzero    -- bad character
 209              where
 210               isSingle c =  c `elem` ",;()[]{}_`"
 211               isSym c    =  c `elem` "!@#$%&*+./<=>?\\^|:-~"
 212               isIdChar c =  isAlphaNum c || c `elem` "_'"
 213
 214               lexFracExp ('.':c:cs) | isDigit c = do
 215                         (ds,t) <- lex0Digits cs
 216                         (e,u)  <- lexExp t
 217                         return ('.':c:ds++e,u)
 218               lexFracExp s        = return ("",s)
 219
 220               lexExp (e:s) | e `elem` "eE" =
 221                   (do
 222                     (c:t) <- return s
 223                     guard (c `elem` "+-")
 224                     (ds,u) <- lexDecDigits t
 225                     return (e:c:ds,u))      ++
 226                   (do
 227                     (ds,t) <- lexDecDigits s
 228                     return (e:ds,t))
 229
 230               lexExp s = return ("",s)
 231
 232 lexDigits            :: ReadS String
 233 lexDigits            = lexDecDigits
 234
 235 lexDecDigits            :: ReadS String
 236 lexDecDigits            =  nonnull isDigit
 237
 238 lexOctDigits            :: ReadS String
 239 lexOctDigits            =  nonnull isOctDigit
 240
 241 lexHexDigits            :: ReadS String
 242 lexHexDigits            =  nonnull isHexDigit
 243
 244 -- 0 or more digits
 245 lex0Digits               :: ReadS String
 246 lex0Digits  s            =  return (span isDigit s)
 247
 248 nonnull                 :: (Char -> Bool) -> ReadS String
 249 nonnull p s             = do
 250             (cs@(_:_),t) <- return (span p s)
 251             return (cs,t)
 252
 253 lexLitChar              :: ReadS String
 254 lexLitChar ('\\':s)     =  do
 255             (esc,t) <- lexEsc s
 256             return ('\\':esc, t)
 257        where
 258         lexEsc (c:s)     | c `elem` escChars = return ([c],s)
 259         lexEsc s@(d:_)   | isDigit d         = checkSize 10 lexDecDigits s
 260         lexEsc ('o':d:s) | isOctDigit d      = checkSize  8 lexOctDigits (d:s)
 261         lexEsc ('O':d:s) | isOctDigit d      = checkSize  8 lexOctDigits (d:s)
 262         lexEsc ('x':d:s) | isHexDigit d      = checkSize 16 lexHexDigits (d:s)
 263         lexEsc ('X':d:s) | isHexDigit d      = checkSize 16 lexHexDigits (d:s)
 264         lexEsc ('^':c:s) | c >= '@' && c <= '_' = [(['^',c],s)] -- cf. cntrl in 2.6 of H. report.
 265         lexEsc s@(c:_)   | isUpper c            = fromAsciiLab s
 266         lexEsc _                                = mzero
 267
 268         escChars = "abfnrtv\\\"'"
 269
 270         fromAsciiLab (x:y:z:ls) | isUpper y && (isUpper z || isDigit z) &&
 271                                    [x,y,z] `elem` asciiEscTab = return ([x,y,z], ls)
 272         fromAsciiLab (x:y:ls)   | isUpper y &&
 273                                    [x,y]   `elem` asciiEscTab = return ([x,y], ls)
 274         fromAsciiLab _                                        = mzero
 275
 276         asciiEscTab = "DEL" : asciiTab
 277
 278          {-
 279            Check that the numerically escaped char literals are
 280            within accepted boundaries.
 281
 282            Note: this allows char lits with leading zeros, i.e.,
 283                  \0000000000000000000000000000001.
 284          -}
 285         checkSize base f str = do
 286            (num, res) <- f str
 287            if toAnInteger base num > toInteger (ord maxBound) then
 288               mzero
 289             else
 290               case base of
 291                  8  -> return ('o':num, res)
 292                  16 -> return ('x':num, res)
 293                  _  -> return (num, res)
 294
 295         toAnInteger base = foldl (\ acc n -> acc*base + toInteger (digitToInt n)) 0
 296
 297
 298 lexLitChar (c:s)        =  return ([c],s)
 299 lexLitChar ""           =  mzero
 300
 301 digitToInt :: Char -> Int
 302 digitToInt c
 303  | isDigit c            =  fromEnum c - fromEnum '0'
 304  | c >= 'a' && c <= 'f' =  fromEnum c - fromEnum 'a' + 10
 305  | c >= 'A' && c <= 'F' =  fromEnum c - fromEnum 'A' + 10
 306  | otherwise            =  error ("Char.digitToInt: not a digit " ++ show c) -- sigh
 307 \end{code}
 308
 309 %*********************************************************
 310 %*                                                      *
 311 \subsection{Instances of @Read@}
 312 %*                                                      *
 313 %*********************************************************
 314
 315 \begin{code}
 316 instance  Read Char  where
 317     readsPrec _      = readParen False
 318                             (\r -> do
 319                                 ('\'':s,t) <- lex r
 320                                 (c,"\'")   <- readLitChar s
 321                                 return (c,t))
 322
 323     readList = readParen False (\r -> do
 324                                 ('"':s,t) <- lex r
 325                                 (l,_)     <- readl s
 326                                 return (l,t))
 327                where readl ('"':s)      = return ("",s)
 328                      readl ('\\':'&':s) = readl s
 329                      readl s            = do
 330                             (c,t)  <- readLitChar s
 331                             (cs,u) <- readl t
 332                             return (c:cs,u)
 333
 334 instance Read Bool where
 335     readsPrec _ = readParen False
 336                         (\r ->
 337                            lex r >>= \ lr ->
 338                            (do { ("True", rest)  <- return lr ; return (True,  rest) }) ++
 339                            (do { ("False", rest) <- return lr ; return (False, rest) }))
 340
 341
 342 instance Read Ordering where
 343     readsPrec _ = readParen False
 344                         (\r ->
 345                            lex r >>= \ lr ->
 346                            (do { ("LT", rest) <- return lr ; return (LT,  rest) }) ++
 347                            (do { ("EQ", rest) <- return lr ; return (EQ, rest) })  ++
 348                            (do { ("GT", rest) <- return lr ; return (GT, rest) }))
 349
 350 instance Read a => Read (Maybe a) where
 351     readsPrec _ = readParen False
 352                         (\r ->
 353                             lex r >>= \ lr ->
 354                             (do { ("Nothing", rest) <- return lr ; return (Nothing, rest)}) ++
 355                             (do
 356                                 ("Just", rest1) <- return lr
 357                                 (x, rest2)      <- reads rest1
 358                                 return (Just x, rest2)))
 359
 360 instance (Read a, Read b) => Read (Either a b) where
 361     readsPrec _ = readParen False
 362                         (\r ->
 363                             lex r >>= \ lr ->
 364                             (do
 365                                 ("Left", rest1) <- return lr
 366                                 (x, rest2)      <- reads rest1
 367                                 return (Left x, rest2)) ++
 368                             (do
 369                                 ("Right", rest1) <- return lr
 370                                 (x, rest2)      <- reads rest1
 371                                 return (Right x, rest2)))
 372
 373 instance  Read Int  where
 374     readsPrec _ x = readSigned readDec x
 375
 376 instance  Read Integer  where
 377     readsPrec _ x = readSigned readDec x
 378
 379 instance  Read Float  where
 380     readsPrec _ x = readSigned readFloat x
 381
 382 instance  Read Double  where
 383     readsPrec _ x = readSigned readFloat x
 384
 385 instance  (Integral a, Read a)  => Read (Ratio a)  where
 386     readsPrec p  =  readParen (p > ratio_prec)
 387                               (\r -> do
 388                                 (x,s)   <- reads r
 389                                 ("%",t) <- lex s
 390                                 (y,u)   <- reads t
 391                                 return (x%y,u))
 392
 393 instance  (Read a) => Read [a]  where
 394     readsPrec _         = readList
 395
 396 instance Read () where
 397     readsPrec _    = readParen False
 398                             (\r -> do
 399                                 ("(",s) <- lex r
 400                                 (")",t) <- lex s
 401                                 return ((),t))
 402
 403 instance  (Read a, Read b) => Read (a,b)  where
 404     readsPrec _ = readParen False
 405                             (\r -> do
 406                                 ("(",s) <- lex r
 407                                 (x,t)   <- readsPrec 0 s
 408                                 (",",u) <- lex t
 409                                 (y,v)   <- readsPrec 0 u
 410                                 (")",w) <- lex v
 411                                 return ((x,y), w))
 412
 413 instance (Read a, Read b, Read c) => Read (a, b, c) where
 414     readsPrec _ = readParen False
 415                             (\a -> do
 416                                 ("(",b) <- lex a
 417                                 (x,c)   <- readsPrec 0 b
 418                                 (",",d) <- lex c
 419                                 (y,e)   <- readsPrec 0 d
 420                                 (",",f) <- lex e
 421                                 (z,g)   <- readsPrec 0 f
 422                                 (")",h) <- lex g
 423                                 return ((x,y,z), h))
 424
 425 instance (Read a, Read b, Read c, Read d) => Read (a, b, c, d) where
 426     readsPrec _ = readParen False
 427                             (\a -> do
 428                                 ("(",b) <- lex a
 429                                 (w,c)   <- readsPrec 0 b
 430                                 (",",d) <- lex c
 431                                 (x,e)   <- readsPrec 0 d
 432                                 (",",f) <- lex e
 433                                 (y,g)   <- readsPrec 0 f
 434                                 (",",h) <- lex g
 435                                 (z,h)   <- readsPrec 0 h
 436                                 (")",i) <- lex h
 437                                 return ((w,x,y,z), i))
 438
 439 instance (Read a, Read b, Read c, Read d, Read e) => Read (a, b, c, d, e) where
 440     readsPrec _ = readParen False
 441                             (\a -> do
 442                                 ("(",b) <- lex a
 443                                 (v,c)   <- readsPrec 0 b
 444                                 (",",d) <- lex c
 445                                 (w,e)   <- readsPrec 0 d
 446                                 (",",f) <- lex e
 447                                 (x,g)   <- readsPrec 0 f
 448                                 (",",h) <- lex g
 449                                 (y,i)   <- readsPrec 0 h
 450                                 (",",j) <- lex i
 451                                 (z,k)   <- readsPrec 0 j
 452                                 (")",l) <- lex k
 453                                 return ((v,w,x,y,z), l))
 454 \end{code}
 455
 456
 457 %*********************************************************
 458 %*                                                      *
 459 \subsection{Reading characters}
 460 %*                                                      *
 461 %*********************************************************
 462
 463 \begin{code}
 464 readLitChar             :: ReadS Char
 465
 466 readLitChar []          =  mzero
 467 readLitChar ('\\':s)    =  readEsc s
 468         where
 469         readEsc ('a':s)  = return ('\a',s)
 470         readEsc ('b':s)  = return ('\b',s)
 471         readEsc ('f':s)  = return ('\f',s)
 472         readEsc ('n':s)  = return ('\n',s)
 473         readEsc ('r':s)  = return ('\r',s)
 474         readEsc ('t':s)  = return ('\t',s)
 475         readEsc ('v':s)  = return ('\v',s)
 476         readEsc ('\\':s) = return ('\\',s)
 477         readEsc ('"':s)  = return ('"',s)
 478         readEsc ('\'':s) = return ('\'',s)
 479         readEsc ('^':c:s) | c >= '@' && c <= '_'
 480                          = return (chr (ord c - ord '@'), s)
 481         readEsc s@(d:_) | isDigit d
 482                          = do
 483                           (n,t) <- readDec s
 484                           return (chr n,t)
 485         readEsc ('o':s)  = do
 486                           (n,t) <- readOct s
 487                           return (chr n,t)
 488         readEsc ('x':s)  = do
 489                           (n,t) <- readHex s
 490                           return (chr n,t)
 491
 492         readEsc s@(c:_) | isUpper c
 493                          = let table = ('\DEL', "DEL") : zip ['\NUL'..] asciiTab
 494                            in case [(c,s') | (c, mne) <- table,
 495                                              ([],s') <- [match mne s]]
 496                               of (pr:_) -> return pr
 497                                  []     -> mzero
 498         readEsc _        = mzero
 499
 500 readLitChar (c:s)       =  return (c,s)
 501
 502 match                   :: (Eq a) => [a] -> [a] -> ([a],[a])
 503 match (x:xs) (y:ys) | x == y  =  match xs ys
 504 match xs     ys               =  (xs,ys)
 505
 506 \end{code}
 507
 508
 509 %*********************************************************
 510 %*                                                      *
 511 \subsection{Reading numbers}
 512 %*                                                      *
 513 %*********************************************************
 514
 515 Note: reading numbers at bases different than 10, does not
 516 include lexing common prefixes such as '0x' or '0o' etc.
 517
 518 \begin{code}
 519 {-# SPECIALISE readDec ::
 520                 ReadS Int,
 521                 ReadS Integer #-}
 522 readDec :: (Integral a) => ReadS a
 523 readDec = readInt 10 isDigit (\d -> ord d - ord '0')
 524
 525 {-# SPECIALISE readOct ::
 526                 ReadS Int,
 527                 ReadS Integer #-}
 528 readOct :: (Integral a) => ReadS a
 529 readOct = readInt 8 isOctDigit (\d -> ord d - ord '0')
 530
 531 {-# SPECIALISE readHex ::
 532                 ReadS Int,
 533                 ReadS Integer #-}
 534 readHex :: (Integral a) => ReadS a
 535 readHex = readInt 16 isHexDigit hex
 536             where hex d = ord d - (if isDigit d then ord '0'
 537                                    else ord (if isUpper d then 'A' else 'a') - 10)
 538
 539 readInt :: (Integral a) => a -> (Char -> Bool) -> (Char -> Int) -> ReadS a
 540 readInt radix isDig digToInt s = do
 541     (ds,r) <- nonnull isDig s
 542     return (foldl1 (\n d -> n * radix + d)
 543                    (map (fromInteger . toInteger . digToInt) ds), r)
 544
 545 {-# SPECIALISE readSigned ::
 546                 ReadS Int     -> ReadS Int,
 547                 ReadS Integer -> ReadS Integer,
 548                 ReadS Double  -> ReadS Double       #-}
 549 readSigned :: (Real a) => ReadS a -> ReadS a
 550 readSigned readPos = readParen False read'
 551                      where read' r  = read'' r ++
 552                                       (do
 553                                         ("-",s) <- lex r
 554                                         (x,t)   <- read'' s
 555                                         return (-x,t))
 556                            read'' r = do
 557                                (str,s) <- lex r
 558                                (n,"")  <- readPos str
 559                                return (n,s)
 560 \end{code}
 561
 562 The functions readFloat below uses rational arithmetic
 563 to ensure correct conversion between the floating-point radix and
 564 decimal.  It is often possible to use a higher-precision floating-
 565 point type to obtain the same results.
 566
 567 \begin{code}
 568 {-# SPECIALISE readFloat ::
 569                     ReadS Double,
 570                     ReadS Float     #-}
 571 readFloat :: (RealFloat a) => ReadS a
 572 readFloat r = do
 573     (x,t) <- readRational r
 574     return (fromRational x,t)
 575
 576 readRational :: ReadS Rational -- NB: doesn't handle leading "-"
 577
 578 readRational r =
 579    (do
 580       (n,d,s) <- readFix r
 581       (k,t)   <- readExp s
 582       return ((n%1)*10^^(k-d), t )) ++
 583    (do
 584       ("NaN",t) <- lex r
 585       return (0/0,t) ) ++
 586    (do
 587       ("Infinity",t) <- lex r
 588       return (1/0,t) )
 589  where
 590      readFix r = do
 591         (ds,s)  <- lexDecDigits r
 592         (ds',t) <- lexDotDigits s
 593         return (read (ds++ds'), length ds', t)
 594
 595      readExp (e:s) | e `elem` "eE" = readExp' s
 596      readExp s                     = return (0,s)
 597
 598      readExp' ('+':s) = readDec s
 599      readExp' ('-':s) = do
 600                         (k,t) <- readDec s
 601                         return (-k,t)
 602      readExp' s       = readDec s
 603
 604      lexDotDigits ('.':s) = lex0Digits s
 605      lexDotDigits s       = return ("",s)
 606
 607 readRational__ :: String -> Rational -- we export this one (non-std)
 608                                     -- NB: *does* handle a leading "-"
 609 readRational__ top_s
 610   = case top_s of
 611       '-' : xs -> - (read_me xs)
 612       xs       -> read_me xs
 613   where
 614     read_me s
 615       = case (do { (x,t) <- readRational s ; ("","") <- lex t ; return x }) of
 616 #ifndef NEW_READS_REP
 617           [x] -> x
 618           []  -> error ("readRational__: no parse:"        ++ top_s)
 619           _   -> error ("readRational__: ambiguous parse:" ++ top_s)
 620 #else
 621           Just x  -> x
 622           Nothing -> error ("readRational__: no parse:"        ++ top_s)
 623 #endif
 624
 625 \end{code}
 626
 627 %*********************************************************
 628 %*                                                      *
 629 \subsection{Reading BufferMode}
 630 %*                                                      *
 631 %*********************************************************
 632
 633 This instance decl is here rather than somewhere more appropriate in
 634 order that we can avoid both orphan-instance modules and recursive
 635 dependencies.
 636
 637 \begin{code}
 638 instance Read BufferMode where
 639     readsPrec _ =
 640       readParen False
 641         (\r ->  let lr = lex r
 642                 in
 643                 [(NoBuffering, rest)       | ("NoBuffering", rest) <- lr] ++
 644                 [(LineBuffering,rest)      | ("LineBuffering",rest) <- lr] ++
 645                 [(BlockBuffering mb,rest2) | ("BlockBuffering",rest1) <- lr,
 646                                              (mb, rest2) <- reads rest1])
 647
 648 \end{code}