Typo
[packages/base.git] / GHC / Read.lhs
1 \begin{code}
2 {-# LANGUAGE Trustworthy #-}
3 {-# LANGUAGE NoImplicitPrelude, StandaloneDeriving, ScopedTypeVariables #-}
4 {-# OPTIONS_HADDOCK hide #-}
5
6 -----------------------------------------------------------------------------
7 -- |
8 -- Module      :  GHC.Read
9 -- Copyright   :  (c) The University of Glasgow, 1994-2002
10 -- License     :  see libraries/base/LICENSE
11 -- 
12 -- Maintainer  :  cvs-ghc@haskell.org
13 -- Stability   :  internal
14 -- Portability :  non-portable (GHC Extensions)
15 --
16 -- The 'Read' class and instances for basic data types.
17 --
18 -----------------------------------------------------------------------------
19
20 module GHC.Read
21   ( Read(..)   -- class
22
23   -- ReadS type
24   , ReadS
25
26   -- H2010 compatibility
27   , lex
28   , lexLitChar
29   , readLitChar
30   , lexDigits
31
32   -- defining readers
33   , lexP, expectP
34   , paren
35   , parens
36   , list
37   , choose
38   , readListDefault, readListPrecDefault
39   , readNumber
40
41   -- Temporary
42   , readParen
43   )
44  where
45
46 import qualified Text.ParserCombinators.ReadP as P
47
48 import Text.ParserCombinators.ReadP
49   ( ReadS
50   , readP_to_S
51   )
52
53 import qualified Text.Read.Lex as L
54 -- Lex exports 'lex', which is also defined here,
55 -- hence the qualified import.
56 -- We can't import *anything* unqualified, because that
57 -- confuses Haddock.
58
59 import Text.ParserCombinators.ReadPrec
60
61 import Data.Maybe
62
63 import {-# SOURCE #-} GHC.Unicode       ( isDigit )
64 import GHC.Num
65 import GHC.Real
66 import GHC.Float
67 import GHC.Show
68 import GHC.Base
69 import GHC.Arr
70 \end{code}
71
72
73 \begin{code}
74 -- | @'readParen' 'True' p@ parses what @p@ parses, but surrounded with
75 -- parentheses.
76 --
77 -- @'readParen' 'False' p@ parses what @p@ parses, but optionally
78 -- surrounded with parentheses.
79 readParen       :: Bool -> ReadS a -> ReadS a
80 -- A Haskell 2010 function
81 readParen b g   =  if b then mandatory else optional
82                    where optional r  = g r ++ mandatory r
83                          mandatory r = do
84                                 ("(",s) <- lex r
85                                 (x,t)   <- optional s
86                                 (")",u) <- lex t
87                                 return (x,u)
88 \end{code}
89
90
91 %*********************************************************
92 %*                                                      *
93 \subsection{The @Read@ class}
94 %*                                                      *
95 %*********************************************************
96
97 \begin{code}
98 ------------------------------------------------------------------------
99 -- class Read
100
101 -- | Parsing of 'String's, producing values.
102 --
103 -- Minimal complete definition: 'readsPrec' (or, for GHC only, 'readPrec')
104 --
105 -- Derived instances of 'Read' make the following assumptions, which
106 -- derived instances of 'Text.Show.Show' obey:
107 --
108 -- * If the constructor is defined to be an infix operator, then the
109 --   derived 'Read' instance will parse only infix applications of
110 --   the constructor (not the prefix form).
111 --
112 -- * Associativity is not used to reduce the occurrence of parentheses,
113 --   although precedence may be.
114 --
115 -- * If the constructor is defined using record syntax, the derived 'Read'
116 --   will parse only the record-syntax form, and furthermore, the fields
117 --   must be given in the same order as the original declaration.
118 --
119 -- * The derived 'Read' instance allows arbitrary Haskell whitespace
120 --   between tokens of the input string.  Extra parentheses are also
121 --   allowed.
122 --
123 -- For example, given the declarations
124 --
125 -- > infixr 5 :^:
126 -- > data Tree a =  Leaf a  |  Tree a :^: Tree a
127 --
128 -- the derived instance of 'Read' in Haskell 2010 is equivalent to
129 --
130 -- > instance (Read a) => Read (Tree a) where
131 -- >
132 -- >         readsPrec d r =  readParen (d > app_prec)
133 -- >                          (\r -> [(Leaf m,t) |
134 -- >                                  ("Leaf",s) <- lex r,
135 -- >                                  (m,t) <- readsPrec (app_prec+1) s]) r
136 -- >
137 -- >                       ++ readParen (d > up_prec)
138 -- >                          (\r -> [(u:^:v,w) |
139 -- >                                  (u,s) <- readsPrec (up_prec+1) r,
140 -- >                                  (":^:",t) <- lex s,
141 -- >                                  (v,w) <- readsPrec (up_prec+1) t]) r
142 -- >
143 -- >           where app_prec = 10
144 -- >                 up_prec = 5
145 --
146 -- Note that right-associativity of @:^:@ is unused.
147 --
148 -- The derived instance in GHC is equivalent to
149 --
150 -- > instance (Read a) => Read (Tree a) where
151 -- >
152 -- >         readPrec = parens $ (prec app_prec $ do
153 -- >                                  Ident "Leaf" <- lexP
154 -- >                                  m <- step readPrec
155 -- >                                  return (Leaf m))
156 -- >
157 -- >                      +++ (prec up_prec $ do
158 -- >                                  u <- step readPrec
159 -- >                                  Symbol ":^:" <- lexP
160 -- >                                  v <- step readPrec
161 -- >                                  return (u :^: v))
162 -- >
163 -- >           where app_prec = 10
164 -- >                 up_prec = 5
165 -- >
166 -- >         readListPrec = readListPrecDefault
167
168 class Read a where
169   -- | attempts to parse a value from the front of the string, returning
170   -- a list of (parsed value, remaining string) pairs.  If there is no
171   -- successful parse, the returned list is empty.
172   --
173   -- Derived instances of 'Read' and 'Text.Show.Show' satisfy the following:
174   --
175   -- * @(x,\"\")@ is an element of
176   --   @('readsPrec' d ('Text.Show.showsPrec' d x \"\"))@.
177   --
178   -- That is, 'readsPrec' parses the string produced by
179   -- 'Text.Show.showsPrec', and delivers the value that
180   -- 'Text.Show.showsPrec' started with.
181
182   readsPrec    :: Int   -- ^ the operator precedence of the enclosing
183                         -- context (a number from @0@ to @11@).
184                         -- Function application has precedence @10@.
185                 -> ReadS a
186
187   -- | The method 'readList' is provided to allow the programmer to
188   -- give a specialised way of parsing lists of values.
189   -- For example, this is used by the predefined 'Read' instance of
190   -- the 'Char' type, where values of type 'String' should be are
191   -- expected to use double quotes, rather than square brackets.
192   readList     :: ReadS [a]
193
194   -- | Proposed replacement for 'readsPrec' using new-style parsers (GHC only).
195   readPrec     :: ReadPrec a
196
197   -- | Proposed replacement for 'readList' using new-style parsers (GHC only).
198   -- The default definition uses 'readList'.  Instances that define 'readPrec'
199   -- should also define 'readListPrec' as 'readListPrecDefault'.
200   readListPrec :: ReadPrec [a]
201   
202   -- default definitions
203   readsPrec    = readPrec_to_S readPrec
204   readList     = readPrec_to_S (list readPrec) 0
205   readPrec     = readS_to_Prec readsPrec
206   readListPrec = readS_to_Prec (\_ -> readList)
207   {-# MINIMAL readsPrec | readPrec #-}
208
209 readListDefault :: Read a => ReadS [a]
210 -- ^ A possible replacement definition for the 'readList' method (GHC only).
211 --   This is only needed for GHC, and even then only for 'Read' instances
212 --   where 'readListPrec' isn't defined as 'readListPrecDefault'.
213 readListDefault = readPrec_to_S readListPrec 0
214
215 readListPrecDefault :: Read a => ReadPrec [a]
216 -- ^ A possible replacement definition for the 'readListPrec' method,
217 --   defined using 'readPrec' (GHC only).
218 readListPrecDefault = list readPrec
219
220 ------------------------------------------------------------------------
221 -- H2010 compatibility
222
223 -- | The 'lex' function reads a single lexeme from the input, discarding
224 -- initial white space, and returning the characters that constitute the
225 -- lexeme.  If the input string contains only white space, 'lex' returns a
226 -- single successful \`lexeme\' consisting of the empty string.  (Thus
227 -- @'lex' \"\" = [(\"\",\"\")]@.)  If there is no legal lexeme at the
228 -- beginning of the input string, 'lex' fails (i.e. returns @[]@).
229 --
230 -- This lexer is not completely faithful to the Haskell lexical syntax
231 -- in the following respects:
232 --
233 -- * Qualified names are not handled properly
234 --
235 -- * Octal and hexadecimal numerics are not recognized as a single token
236 --
237 -- * Comments are not treated properly
238 lex :: ReadS String             -- As defined by H2010
239 lex s  = readP_to_S L.hsLex s
240
241 -- | Read a string representation of a character, using Haskell
242 -- source-language escape conventions.  For example:
243 --
244 -- > lexLitChar  "\\nHello"  =  [("\\n", "Hello")]
245 --
246 lexLitChar :: ReadS String      -- As defined by H2010
247 lexLitChar = readP_to_S (do { (s, _) <- P.gather L.lexChar ;
248                               return s })
249         -- There was a skipSpaces before the P.gather L.lexChar,
250         -- but that seems inconsistent with readLitChar
251
252 -- | Read a string representation of a character, using Haskell
253 -- source-language escape conventions, and convert it to the character
254 -- that it encodes.  For example:
255 --
256 -- > readLitChar "\\nHello"  =  [('\n', "Hello")]
257 --
258 readLitChar :: ReadS Char       -- As defined by H2010
259 readLitChar = readP_to_S L.lexChar
260
261 -- | Reads a non-empty string of decimal digits.
262 lexDigits :: ReadS String
263 lexDigits = readP_to_S (P.munch1 isDigit)
264
265 ------------------------------------------------------------------------
266 -- utility parsers
267
268 lexP :: ReadPrec L.Lexeme
269 -- ^ Parse a single lexeme
270 lexP = lift L.lex
271
272 expectP :: L.Lexeme -> ReadPrec ()
273 expectP lexeme = lift (L.expect lexeme)
274
275 paren :: ReadPrec a -> ReadPrec a
276 -- ^ @(paren p)@ parses \"(P0)\"
277 --      where @p@ parses \"P0\" in precedence context zero
278 paren p = do expectP (L.Punc "(")
279              x <- reset p
280              expectP (L.Punc ")")
281              return x
282
283 parens :: ReadPrec a -> ReadPrec a
284 -- ^ @(parens p)@ parses \"P\", \"(P0)\", \"((P0))\", etc, 
285 --      where @p@ parses \"P\"  in the current precedence context
286 --          and parses \"P0\" in precedence context zero
287 parens p = optional
288  where
289   optional  = p +++ mandatory
290   mandatory = paren optional
291
292 list :: ReadPrec a -> ReadPrec [a]
293 -- ^ @(list p)@ parses a list of things parsed by @p@,
294 -- using the usual square-bracket syntax.
295 list readx =
296   parens
297   ( do expectP (L.Punc "[")
298        (listRest False +++ listNext)
299   )
300  where
301   listRest started =
302     do L.Punc c <- lexP
303        case c of
304          "]"           -> return []
305          "," | started -> listNext
306          _             -> pfail
307   
308   listNext =
309     do x  <- reset readx
310        xs <- listRest True
311        return (x:xs)
312
313 choose :: [(String, ReadPrec a)] -> ReadPrec a
314 -- ^ Parse the specified lexeme and continue as specified.
315 -- Esp useful for nullary constructors; e.g.
316 --    @choose [(\"A\", return A), (\"B\", return B)]@
317 -- We match both Ident and Symbol because the constructor
318 -- might be an operator eg @(:~:)@
319 choose sps = foldr ((+++) . try_one) pfail sps
320            where
321              try_one (s,p) = do { token <- lexP ;
322                                   case token of
323                                     L.Ident s'  | s==s' -> p
324                                     L.Symbol s' | s==s' -> p
325                                     _other              -> pfail }
326 \end{code}
327
328
329 %*********************************************************
330 %*                                                      *
331 \subsection{Simple instances of Read}
332 %*                                                      *
333 %*********************************************************
334
335 \begin{code}
336 instance Read Char where
337   readPrec =
338     parens
339     ( do L.Char c <- lexP
340          return c
341     )
342
343   readListPrec =
344     parens
345     ( do L.String s <- lexP     -- Looks for "foo"
346          return s
347      +++
348       readListPrecDefault       -- Looks for ['f','o','o']
349     )                           -- (more generous than H2010 spec)
350
351   readList = readListDefault
352
353 instance Read Bool where
354   readPrec =
355     parens
356     ( do L.Ident s <- lexP
357          case s of
358            "True"  -> return True
359            "False" -> return False
360            _       -> pfail
361     )
362
363   readListPrec = readListPrecDefault
364   readList     = readListDefault
365
366 instance Read Ordering where
367   readPrec =
368     parens
369     ( do L.Ident s <- lexP
370          case s of
371            "LT" -> return LT
372            "EQ" -> return EQ
373            "GT" -> return GT
374            _    -> pfail
375     )
376
377   readListPrec = readListPrecDefault
378   readList     = readListDefault
379 \end{code}
380
381
382 %*********************************************************
383 %*                                                      *
384 \subsection{Structure instances of Read: Maybe, List etc}
385 %*                                                      *
386 %*********************************************************
387
388 For structured instances of Read we start using the precedences.  The
389 idea is then that 'parens (prec k p)' will fail immediately when trying
390 to parse it in a context with a higher precedence level than k. But if
391 there is one parenthesis parsed, then the required precedence level
392 drops to 0 again, and parsing inside p may succeed.
393
394 'appPrec' is just the precedence level of function application.  So,
395 if we are parsing function application, we'd better require the
396 precedence level to be at least 'appPrec'. Otherwise, we have to put
397 parentheses around it.
398
399 'step' is used to increase the precedence levels inside a
400 parser, and can be used to express left- or right- associativity. For
401 example, % is defined to be left associative, so we only increase
402 precedence on the right hand side.
403
404 Note how step is used in for example the Maybe parser to increase the
405 precedence beyond appPrec, so that basically only literals and
406 parenthesis-like objects such as (...) and [...] can be an argument to
407 'Just'.
408
409 \begin{code}
410 instance Read a => Read (Maybe a) where
411   readPrec =
412     parens
413     (do expectP (L.Ident "Nothing")
414         return Nothing
415      +++
416      prec appPrec (
417         do expectP (L.Ident "Just")
418            x <- step readPrec
419            return (Just x))
420     )
421
422   readListPrec = readListPrecDefault
423   readList     = readListDefault
424
425 instance Read a => Read [a] where
426   readPrec     = readListPrec
427   readListPrec = readListPrecDefault
428   readList     = readListDefault
429
430 instance  (Ix a, Read a, Read b) => Read (Array a b)  where
431     readPrec = parens $ prec appPrec $
432                do expectP (L.Ident "array")
433                   theBounds <- step readPrec
434                   vals   <- step readPrec
435                   return (array theBounds vals)
436
437     readListPrec = readListPrecDefault
438     readList     = readListDefault
439
440 instance Read L.Lexeme where
441   readPrec     = lexP
442   readListPrec = readListPrecDefault
443   readList     = readListDefault
444 \end{code}
445
446
447 %*********************************************************
448 %*                                                      *
449 \subsection{Numeric instances of Read}
450 %*                                                      *
451 %*********************************************************
452
453 \begin{code}
454 readNumber :: Num a => (L.Lexeme -> ReadPrec a) -> ReadPrec a
455 -- Read a signed number
456 readNumber convert =
457   parens
458   ( do x <- lexP
459        case x of
460          L.Symbol "-" -> do y <- lexP
461                             n <- convert y
462                             return (negate n)
463
464          _   -> convert x
465   )
466
467
468 convertInt :: Num a => L.Lexeme -> ReadPrec a
469 convertInt (L.Number n)
470  | Just i <- L.numberToInteger n = return (fromInteger i)
471 convertInt _ = pfail
472
473 convertFrac :: forall a . RealFloat a => L.Lexeme -> ReadPrec a
474 convertFrac (L.Ident "NaN")      = return (0 / 0)
475 convertFrac (L.Ident "Infinity") = return (1 / 0)
476 convertFrac (L.Number n) = let resRange = floatRange (undefined :: a)
477                            in case L.numberToRangedRational resRange n of
478                               Nothing -> return (1 / 0)
479                               Just rat -> return $ fromRational rat
480 convertFrac _            = pfail
481
482 instance Read Int where
483   readPrec     = readNumber convertInt
484   readListPrec = readListPrecDefault
485   readList     = readListDefault
486
487 instance Read Word where
488     readsPrec p s = [(fromInteger x, r) | (x, r) <- readsPrec p s]
489
490 instance Read Integer where
491   readPrec     = readNumber convertInt
492   readListPrec = readListPrecDefault
493   readList     = readListDefault
494
495 instance Read Float where
496   readPrec     = readNumber convertFrac
497   readListPrec = readListPrecDefault
498   readList     = readListDefault
499
500 instance Read Double where
501   readPrec     = readNumber convertFrac
502   readListPrec = readListPrecDefault
503   readList     = readListDefault
504
505 instance (Integral a, Read a) => Read (Ratio a) where
506   readPrec =
507     parens
508     ( prec ratioPrec
509       ( do x <- step readPrec
510            expectP (L.Symbol "%")
511            y <- step readPrec
512            return (x % y)
513       )
514     )
515
516   readListPrec = readListPrecDefault
517   readList     = readListDefault
518 \end{code}
519
520
521 %*********************************************************
522 %*                                                      *
523         Tuple instances of Read, up to size 15
524 %*                                                      *
525 %*********************************************************
526
527 \begin{code}
528 instance Read () where
529   readPrec =
530     parens
531     ( paren
532       ( return ()
533       )
534     )
535
536   readListPrec = readListPrecDefault
537   readList     = readListDefault
538
539 instance (Read a, Read b) => Read (a,b) where
540   readPrec = wrap_tup read_tup2
541   readListPrec = readListPrecDefault
542   readList     = readListDefault
543
544 wrap_tup :: ReadPrec a -> ReadPrec a
545 wrap_tup p = parens (paren p)
546
547 read_comma :: ReadPrec ()
548 read_comma = expectP (L.Punc ",")
549
550 read_tup2 :: (Read a, Read b) => ReadPrec (a,b)
551 -- Reads "a , b"  no parens!
552 read_tup2 = do x <- readPrec
553                read_comma
554                y <- readPrec
555                return (x,y)
556
557 read_tup4 :: (Read a, Read b, Read c, Read d) => ReadPrec (a,b,c,d)
558 read_tup4 = do  (a,b) <- read_tup2
559                 read_comma
560                 (c,d) <- read_tup2
561                 return (a,b,c,d)
562
563
564 read_tup8 :: (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h)
565           => ReadPrec (a,b,c,d,e,f,g,h)
566 read_tup8 = do  (a,b,c,d) <- read_tup4
567                 read_comma
568                 (e,f,g,h) <- read_tup4
569                 return (a,b,c,d,e,f,g,h)
570
571
572 instance (Read a, Read b, Read c) => Read (a, b, c) where
573   readPrec = wrap_tup (do { (a,b) <- read_tup2; read_comma 
574                           ; c <- readPrec 
575                           ; return (a,b,c) })
576   readListPrec = readListPrecDefault
577   readList     = readListDefault
578
579 instance (Read a, Read b, Read c, Read d) => Read (a, b, c, d) where
580   readPrec = wrap_tup read_tup4
581   readListPrec = readListPrecDefault
582   readList     = readListDefault
583
584 instance (Read a, Read b, Read c, Read d, Read e) => Read (a, b, c, d, e) where
585   readPrec = wrap_tup (do { (a,b,c,d) <- read_tup4; read_comma
586                           ; e <- readPrec
587                           ; return (a,b,c,d,e) })
588   readListPrec = readListPrecDefault
589   readList     = readListDefault
590
591 instance (Read a, Read b, Read c, Read d, Read e, Read f)
592         => Read (a, b, c, d, e, f) where
593   readPrec = wrap_tup (do { (a,b,c,d) <- read_tup4; read_comma
594                           ; (e,f) <- read_tup2
595                           ; return (a,b,c,d,e,f) })
596   readListPrec = readListPrecDefault
597   readList     = readListDefault
598
599 instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g)
600         => Read (a, b, c, d, e, f, g) where
601   readPrec = wrap_tup (do { (a,b,c,d) <- read_tup4; read_comma
602                           ; (e,f) <- read_tup2; read_comma
603                           ; g <- readPrec
604                           ; return (a,b,c,d,e,f,g) })
605   readListPrec = readListPrecDefault
606   readList     = readListDefault
607
608 instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h)
609         => Read (a, b, c, d, e, f, g, h) where
610   readPrec     = wrap_tup read_tup8
611   readListPrec = readListPrecDefault
612   readList     = readListDefault
613
614 instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
615           Read i)
616         => Read (a, b, c, d, e, f, g, h, i) where
617   readPrec = wrap_tup (do { (a,b,c,d,e,f,g,h) <- read_tup8; read_comma
618                           ; i <- readPrec
619                           ; return (a,b,c,d,e,f,g,h,i) })
620   readListPrec = readListPrecDefault
621   readList     = readListDefault
622
623 instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
624           Read i, Read j)
625         => Read (a, b, c, d, e, f, g, h, i, j) where
626   readPrec = wrap_tup (do { (a,b,c,d,e,f,g,h) <- read_tup8; read_comma
627                           ; (i,j) <- read_tup2
628                           ; return (a,b,c,d,e,f,g,h,i,j) })
629   readListPrec = readListPrecDefault
630   readList     = readListDefault
631
632 instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
633           Read i, Read j, Read k)
634         => Read (a, b, c, d, e, f, g, h, i, j, k) where
635   readPrec = wrap_tup (do { (a,b,c,d,e,f,g,h) <- read_tup8; read_comma
636                           ; (i,j) <- read_tup2; read_comma
637                           ; k <- readPrec
638                           ; return (a,b,c,d,e,f,g,h,i,j,k) })
639   readListPrec = readListPrecDefault
640   readList     = readListDefault
641
642 instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
643           Read i, Read j, Read k, Read l)
644         => Read (a, b, c, d, e, f, g, h, i, j, k, l) where
645   readPrec = wrap_tup (do { (a,b,c,d,e,f,g,h) <- read_tup8; read_comma
646                           ; (i,j,k,l) <- read_tup4
647                           ; return (a,b,c,d,e,f,g,h,i,j,k,l) })
648   readListPrec = readListPrecDefault
649   readList     = readListDefault
650
651 instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
652           Read i, Read j, Read k, Read l, Read m)
653         => Read (a, b, c, d, e, f, g, h, i, j, k, l, m) where
654   readPrec = wrap_tup (do { (a,b,c,d,e,f,g,h) <- read_tup8; read_comma
655                           ; (i,j,k,l) <- read_tup4; read_comma
656                           ; m <- readPrec
657                           ; return (a,b,c,d,e,f,g,h,i,j,k,l,m) })
658   readListPrec = readListPrecDefault
659   readList     = readListDefault
660
661 instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
662           Read i, Read j, Read k, Read l, Read m, Read n)
663         => Read (a, b, c, d, e, f, g, h, i, j, k, l, m, n) where
664   readPrec = wrap_tup (do { (a,b,c,d,e,f,g,h) <- read_tup8; read_comma
665                           ; (i,j,k,l) <- read_tup4; read_comma
666                           ; (m,n) <- read_tup2
667                           ; return (a,b,c,d,e,f,g,h,i,j,k,l,m,n) })
668   readListPrec = readListPrecDefault
669   readList     = readListDefault
670
671 instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
672           Read i, Read j, Read k, Read l, Read m, Read n, Read o)
673         => Read (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) where
674   readPrec = wrap_tup (do { (a,b,c,d,e,f,g,h) <- read_tup8; read_comma
675                           ; (i,j,k,l) <- read_tup4; read_comma
676                           ; (m,n) <- read_tup2; read_comma
677                           ; o <- readPrec
678                           ; return (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) })
679   readListPrec = readListPrecDefault
680   readList     = readListDefault
681 \end{code}
682