Remove redundant "Minimal complete definition"-comments
[ghc.git] / libraries / base / 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 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 -- Derived instances of 'Read' make the following assumptions, which
104 -- derived instances of 'Text.Show.Show' obey:
105 --
106 -- * If the constructor is defined to be an infix operator, then the
107 --   derived 'Read' instance will parse only infix applications of
108 --   the constructor (not the prefix form).
109 --
110 -- * Associativity is not used to reduce the occurrence of parentheses,
111 --   although precedence may be.
112 --
113 -- * If the constructor is defined using record syntax, the derived 'Read'
114 --   will parse only the record-syntax form, and furthermore, the fields
115 --   must be given in the same order as the original declaration.
116 --
117 -- * The derived 'Read' instance allows arbitrary Haskell whitespace
118 --   between tokens of the input string.  Extra parentheses are also
119 --   allowed.
120 --
121 -- For example, given the declarations
122 --
123 -- > infixr 5 :^:
124 -- > data Tree a =  Leaf a  |  Tree a :^: Tree a
125 --
126 -- the derived instance of 'Read' in Haskell 2010 is equivalent to
127 --
128 -- > instance (Read a) => Read (Tree a) where
129 -- >
130 -- >         readsPrec d r =  readParen (d > app_prec)
131 -- >                          (\r -> [(Leaf m,t) |
132 -- >                                  ("Leaf",s) <- lex r,
133 -- >                                  (m,t) <- readsPrec (app_prec+1) s]) r
134 -- >
135 -- >                       ++ readParen (d > up_prec)
136 -- >                          (\r -> [(u:^:v,w) |
137 -- >                                  (u,s) <- readsPrec (up_prec+1) r,
138 -- >                                  (":^:",t) <- lex s,
139 -- >                                  (v,w) <- readsPrec (up_prec+1) t]) r
140 -- >
141 -- >           where app_prec = 10
142 -- >                 up_prec = 5
143 --
144 -- Note that right-associativity of @:^:@ is unused.
145 --
146 -- The derived instance in GHC is equivalent to
147 --
148 -- > instance (Read a) => Read (Tree a) where
149 -- >
150 -- >         readPrec = parens $ (prec app_prec $ do
151 -- >                                  Ident "Leaf" <- lexP
152 -- >                                  m <- step readPrec
153 -- >                                  return (Leaf m))
154 -- >
155 -- >                      +++ (prec up_prec $ do
156 -- >                                  u <- step readPrec
157 -- >                                  Symbol ":^:" <- lexP
158 -- >                                  v <- step readPrec
159 -- >                                  return (u :^: v))
160 -- >
161 -- >           where app_prec = 10
162 -- >                 up_prec = 5
163 -- >
164 -- >         readListPrec = readListPrecDefault
165
166 class Read a where
167   {-# MINIMAL readsPrec | readPrec #-}
168
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
208 readListDefault :: Read a => ReadS [a]
209 -- ^ A possible replacement definition for the 'readList' method (GHC only).
210 --   This is only needed for GHC, and even then only for 'Read' instances
211 --   where 'readListPrec' isn't defined as 'readListPrecDefault'.
212 readListDefault = readPrec_to_S readListPrec 0
213
214 readListPrecDefault :: Read a => ReadPrec [a]
215 -- ^ A possible replacement definition for the 'readListPrec' method,
216 --   defined using 'readPrec' (GHC only).
217 readListPrecDefault = list readPrec
218
219 ------------------------------------------------------------------------
220 -- H2010 compatibility
221
222 -- | The 'lex' function reads a single lexeme from the input, discarding
223 -- initial white space, and returning the characters that constitute the
224 -- lexeme.  If the input string contains only white space, 'lex' returns a
225 -- single successful \`lexeme\' consisting of the empty string.  (Thus
226 -- @'lex' \"\" = [(\"\",\"\")]@.)  If there is no legal lexeme at the
227 -- beginning of the input string, 'lex' fails (i.e. returns @[]@).
228 --
229 -- This lexer is not completely faithful to the Haskell lexical syntax
230 -- in the following respects:
231 --
232 -- * Qualified names are not handled properly
233 --
234 -- * Octal and hexadecimal numerics are not recognized as a single token
235 --
236 -- * Comments are not treated properly
237 lex :: ReadS String             -- As defined by H2010
238 lex s  = readP_to_S L.hsLex s
239
240 -- | Read a string representation of a character, using Haskell
241 -- source-language escape conventions.  For example:
242 --
243 -- > lexLitChar  "\\nHello"  =  [("\\n", "Hello")]
244 --
245 lexLitChar :: ReadS String      -- As defined by H2010
246 lexLitChar = readP_to_S (do { (s, _) <- P.gather L.lexChar ;
247                               return s })
248         -- There was a skipSpaces before the P.gather L.lexChar,
249         -- but that seems inconsistent with readLitChar
250
251 -- | Read a string representation of a character, using Haskell
252 -- source-language escape conventions, and convert it to the character
253 -- that it encodes.  For example:
254 --
255 -- > readLitChar "\\nHello"  =  [('\n', "Hello")]
256 --
257 readLitChar :: ReadS Char       -- As defined by H2010
258 readLitChar = readP_to_S L.lexChar
259
260 -- | Reads a non-empty string of decimal digits.
261 lexDigits :: ReadS String
262 lexDigits = readP_to_S (P.munch1 isDigit)
263
264 ------------------------------------------------------------------------
265 -- utility parsers
266
267 lexP :: ReadPrec L.Lexeme
268 -- ^ Parse a single lexeme
269 lexP = lift L.lex
270
271 expectP :: L.Lexeme -> ReadPrec ()
272 expectP lexeme = lift (L.expect lexeme)
273
274 paren :: ReadPrec a -> ReadPrec a
275 -- ^ @(paren p)@ parses \"(P0)\"
276 --      where @p@ parses \"P0\" in precedence context zero
277 paren p = do expectP (L.Punc "(")
278              x <- reset p
279              expectP (L.Punc ")")
280              return x
281
282 parens :: ReadPrec a -> ReadPrec a
283 -- ^ @(parens p)@ parses \"P\", \"(P0)\", \"((P0))\", etc, 
284 --      where @p@ parses \"P\"  in the current precedence context
285 --          and parses \"P0\" in precedence context zero
286 parens p = optional
287  where
288   optional  = p +++ mandatory
289   mandatory = paren optional
290
291 list :: ReadPrec a -> ReadPrec [a]
292 -- ^ @(list p)@ parses a list of things parsed by @p@,
293 -- using the usual square-bracket syntax.
294 list readx =
295   parens
296   ( do expectP (L.Punc "[")
297        (listRest False +++ listNext)
298   )
299  where
300   listRest started =
301     do L.Punc c <- lexP
302        case c of
303          "]"           -> return []
304          "," | started -> listNext
305          _             -> pfail
306   
307   listNext =
308     do x  <- reset readx
309        xs <- listRest True
310        return (x:xs)
311
312 choose :: [(String, ReadPrec a)] -> ReadPrec a
313 -- ^ Parse the specified lexeme and continue as specified.
314 -- Esp useful for nullary constructors; e.g.
315 --    @choose [(\"A\", return A), (\"B\", return B)]@
316 -- We match both Ident and Symbol because the constructor
317 -- might be an operator eg @(:~:)@
318 choose sps = foldr ((+++) . try_one) pfail sps
319            where
320              try_one (s,p) = do { token <- lexP ;
321                                   case token of
322                                     L.Ident s'  | s==s' -> p
323                                     L.Symbol s' | s==s' -> p
324                                     _other              -> pfail }
325 \end{code}
326
327
328 %*********************************************************
329 %*                                                      *
330 \subsection{Simple instances of Read}
331 %*                                                      *
332 %*********************************************************
333
334 \begin{code}
335 instance Read Char where
336   readPrec =
337     parens
338     ( do L.Char c <- lexP
339          return c
340     )
341
342   readListPrec =
343     parens
344     ( do L.String s <- lexP     -- Looks for "foo"
345          return s
346      +++
347       readListPrecDefault       -- Looks for ['f','o','o']
348     )                           -- (more generous than H2010 spec)
349
350   readList = readListDefault
351
352 instance Read Bool where
353   readPrec =
354     parens
355     ( do L.Ident s <- lexP
356          case s of
357            "True"  -> return True
358            "False" -> return False
359            _       -> pfail
360     )
361
362   readListPrec = readListPrecDefault
363   readList     = readListDefault
364
365 instance Read Ordering where
366   readPrec =
367     parens
368     ( do L.Ident s <- lexP
369          case s of
370            "LT" -> return LT
371            "EQ" -> return EQ
372            "GT" -> return GT
373            _    -> pfail
374     )
375
376   readListPrec = readListPrecDefault
377   readList     = readListDefault
378 \end{code}
379
380
381 %*********************************************************
382 %*                                                      *
383 \subsection{Structure instances of Read: Maybe, List etc}
384 %*                                                      *
385 %*********************************************************
386
387 For structured instances of Read we start using the precedences.  The
388 idea is then that 'parens (prec k p)' will fail immediately when trying
389 to parse it in a context with a higher precedence level than k. But if
390 there is one parenthesis parsed, then the required precedence level
391 drops to 0 again, and parsing inside p may succeed.
392
393 'appPrec' is just the precedence level of function application.  So,
394 if we are parsing function application, we'd better require the
395 precedence level to be at least 'appPrec'. Otherwise, we have to put
396 parentheses around it.
397
398 'step' is used to increase the precedence levels inside a
399 parser, and can be used to express left- or right- associativity. For
400 example, % is defined to be left associative, so we only increase
401 precedence on the right hand side.
402
403 Note how step is used in for example the Maybe parser to increase the
404 precedence beyond appPrec, so that basically only literals and
405 parenthesis-like objects such as (...) and [...] can be an argument to
406 'Just'.
407
408 \begin{code}
409 instance Read a => Read (Maybe a) where
410   readPrec =
411     parens
412     (do expectP (L.Ident "Nothing")
413         return Nothing
414      +++
415      prec appPrec (
416         do expectP (L.Ident "Just")
417            x <- step readPrec
418            return (Just x))
419     )
420
421   readListPrec = readListPrecDefault
422   readList     = readListDefault
423
424 instance Read a => Read [a] where
425   {-# SPECIALISE instance Read [String] #-}
426   {-# SPECIALISE instance Read [Char] #-}
427   {-# SPECIALISE instance Read [Int] #-}
428   readPrec     = readListPrec
429   readListPrec = readListPrecDefault
430   readList     = readListDefault
431
432 instance  (Ix a, Read a, Read b) => Read (Array a b)  where
433     readPrec = parens $ prec appPrec $
434                do expectP (L.Ident "array")
435                   theBounds <- step readPrec
436                   vals   <- step readPrec
437                   return (array theBounds vals)
438
439     readListPrec = readListPrecDefault
440     readList     = readListDefault
441
442 instance Read L.Lexeme where
443   readPrec     = lexP
444   readListPrec = readListPrecDefault
445   readList     = readListDefault
446 \end{code}
447
448
449 %*********************************************************
450 %*                                                      *
451 \subsection{Numeric instances of Read}
452 %*                                                      *
453 %*********************************************************
454
455 \begin{code}
456 readNumber :: Num a => (L.Lexeme -> ReadPrec a) -> ReadPrec a
457 -- Read a signed number
458 readNumber convert =
459   parens
460   ( do x <- lexP
461        case x of
462          L.Symbol "-" -> do y <- lexP
463                             n <- convert y
464                             return (negate n)
465
466          _   -> convert x
467   )
468
469
470 convertInt :: Num a => L.Lexeme -> ReadPrec a
471 convertInt (L.Number n)
472  | Just i <- L.numberToInteger n = return (fromInteger i)
473 convertInt _ = pfail
474
475 convertFrac :: forall a . RealFloat a => L.Lexeme -> ReadPrec a
476 convertFrac (L.Ident "NaN")      = return (0 / 0)
477 convertFrac (L.Ident "Infinity") = return (1 / 0)
478 convertFrac (L.Number n) = let resRange = floatRange (undefined :: a)
479                            in case L.numberToRangedRational resRange n of
480                               Nothing -> return (1 / 0)
481                               Just rat -> return $ fromRational rat
482 convertFrac _            = pfail
483
484 instance Read Int where
485   readPrec     = readNumber convertInt
486   readListPrec = readListPrecDefault
487   readList     = readListDefault
488
489 instance Read Word where
490     readsPrec p s = [(fromInteger x, r) | (x, r) <- readsPrec p s]
491
492 instance Read Integer where
493   readPrec     = readNumber convertInt
494   readListPrec = readListPrecDefault
495   readList     = readListDefault
496
497 instance Read Float where
498   readPrec     = readNumber convertFrac
499   readListPrec = readListPrecDefault
500   readList     = readListDefault
501
502 instance Read Double where
503   readPrec     = readNumber convertFrac
504   readListPrec = readListPrecDefault
505   readList     = readListDefault
506
507 instance (Integral a, Read a) => Read (Ratio a) where
508   readPrec =
509     parens
510     ( prec ratioPrec
511       ( do x <- step readPrec
512            expectP (L.Symbol "%")
513            y <- step readPrec
514            return (x % y)
515       )
516     )
517
518   readListPrec = readListPrecDefault
519   readList     = readListDefault
520 \end{code}
521
522
523 %*********************************************************
524 %*                                                      *
525         Tuple instances of Read, up to size 15
526 %*                                                      *
527 %*********************************************************
528
529 \begin{code}
530 instance Read () where
531   readPrec =
532     parens
533     ( paren
534       ( return ()
535       )
536     )
537
538   readListPrec = readListPrecDefault
539   readList     = readListDefault
540
541 instance (Read a, Read b) => Read (a,b) where
542   readPrec = wrap_tup read_tup2
543   readListPrec = readListPrecDefault
544   readList     = readListDefault
545
546 wrap_tup :: ReadPrec a -> ReadPrec a
547 wrap_tup p = parens (paren p)
548
549 read_comma :: ReadPrec ()
550 read_comma = expectP (L.Punc ",")
551
552 read_tup2 :: (Read a, Read b) => ReadPrec (a,b)
553 -- Reads "a , b"  no parens!
554 read_tup2 = do x <- readPrec
555                read_comma
556                y <- readPrec
557                return (x,y)
558
559 read_tup4 :: (Read a, Read b, Read c, Read d) => ReadPrec (a,b,c,d)
560 read_tup4 = do  (a,b) <- read_tup2
561                 read_comma
562                 (c,d) <- read_tup2
563                 return (a,b,c,d)
564
565
566 read_tup8 :: (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h)
567           => ReadPrec (a,b,c,d,e,f,g,h)
568 read_tup8 = do  (a,b,c,d) <- read_tup4
569                 read_comma
570                 (e,f,g,h) <- read_tup4
571                 return (a,b,c,d,e,f,g,h)
572
573
574 instance (Read a, Read b, Read c) => Read (a, b, c) where
575   readPrec = wrap_tup (do { (a,b) <- read_tup2; read_comma 
576                           ; c <- readPrec 
577                           ; return (a,b,c) })
578   readListPrec = readListPrecDefault
579   readList     = readListDefault
580
581 instance (Read a, Read b, Read c, Read d) => Read (a, b, c, d) where
582   readPrec = wrap_tup read_tup4
583   readListPrec = readListPrecDefault
584   readList     = readListDefault
585
586 instance (Read a, Read b, Read c, Read d, Read e) => Read (a, b, c, d, e) where
587   readPrec = wrap_tup (do { (a,b,c,d) <- read_tup4; read_comma
588                           ; e <- readPrec
589                           ; return (a,b,c,d,e) })
590   readListPrec = readListPrecDefault
591   readList     = readListDefault
592
593 instance (Read a, Read b, Read c, Read d, Read e, Read f)
594         => Read (a, b, c, d, e, f) where
595   readPrec = wrap_tup (do { (a,b,c,d) <- read_tup4; read_comma
596                           ; (e,f) <- read_tup2
597                           ; return (a,b,c,d,e,f) })
598   readListPrec = readListPrecDefault
599   readList     = readListDefault
600
601 instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g)
602         => Read (a, b, c, d, e, f, g) where
603   readPrec = wrap_tup (do { (a,b,c,d) <- read_tup4; read_comma
604                           ; (e,f) <- read_tup2; read_comma
605                           ; g <- readPrec
606                           ; return (a,b,c,d,e,f,g) })
607   readListPrec = readListPrecDefault
608   readList     = readListDefault
609
610 instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h)
611         => Read (a, b, c, d, e, f, g, h) where
612   readPrec     = wrap_tup read_tup8
613   readListPrec = readListPrecDefault
614   readList     = readListDefault
615
616 instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
617           Read i)
618         => Read (a, b, c, d, e, f, g, h, i) where
619   readPrec = wrap_tup (do { (a,b,c,d,e,f,g,h) <- read_tup8; read_comma
620                           ; i <- readPrec
621                           ; return (a,b,c,d,e,f,g,h,i) })
622   readListPrec = readListPrecDefault
623   readList     = readListDefault
624
625 instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
626           Read i, Read j)
627         => Read (a, b, c, d, e, f, g, h, i, j) where
628   readPrec = wrap_tup (do { (a,b,c,d,e,f,g,h) <- read_tup8; read_comma
629                           ; (i,j) <- read_tup2
630                           ; return (a,b,c,d,e,f,g,h,i,j) })
631   readListPrec = readListPrecDefault
632   readList     = readListDefault
633
634 instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
635           Read i, Read j, Read k)
636         => Read (a, b, c, d, e, f, g, h, i, j, k) where
637   readPrec = wrap_tup (do { (a,b,c,d,e,f,g,h) <- read_tup8; read_comma
638                           ; (i,j) <- read_tup2; read_comma
639                           ; k <- readPrec
640                           ; return (a,b,c,d,e,f,g,h,i,j,k) })
641   readListPrec = readListPrecDefault
642   readList     = readListDefault
643
644 instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
645           Read i, Read j, Read k, Read l)
646         => Read (a, b, c, d, e, f, g, h, i, j, k, l) where
647   readPrec = wrap_tup (do { (a,b,c,d,e,f,g,h) <- read_tup8; read_comma
648                           ; (i,j,k,l) <- read_tup4
649                           ; return (a,b,c,d,e,f,g,h,i,j,k,l) })
650   readListPrec = readListPrecDefault
651   readList     = readListDefault
652
653 instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
654           Read i, Read j, Read k, Read l, Read m)
655         => Read (a, b, c, d, e, f, g, h, i, j, k, l, m) where
656   readPrec = wrap_tup (do { (a,b,c,d,e,f,g,h) <- read_tup8; read_comma
657                           ; (i,j,k,l) <- read_tup4; read_comma
658                           ; m <- readPrec
659                           ; return (a,b,c,d,e,f,g,h,i,j,k,l,m) })
660   readListPrec = readListPrecDefault
661   readList     = readListDefault
662
663 instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
664           Read i, Read j, Read k, Read l, Read m, Read n)
665         => Read (a, b, c, d, e, f, g, h, i, j, k, l, m, n) where
666   readPrec = wrap_tup (do { (a,b,c,d,e,f,g,h) <- read_tup8; read_comma
667                           ; (i,j,k,l) <- read_tup4; read_comma
668                           ; (m,n) <- read_tup2
669                           ; return (a,b,c,d,e,f,g,h,i,j,k,l,m,n) })
670   readListPrec = readListPrecDefault
671   readList     = readListDefault
672
673 instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
674           Read i, Read j, Read k, Read l, Read m, Read n, Read o)
675         => Read (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) where
676   readPrec = wrap_tup (do { (a,b,c,d,e,f,g,h) <- read_tup8; read_comma
677                           ; (i,j,k,l) <- read_tup4; read_comma
678                           ; (m,n) <- read_tup2; read_comma
679                           ; o <- readPrec
680                           ; return (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) })
681   readListPrec = readListPrecDefault
682   readList     = readListDefault
683 \end{code}
684