Move GHC.Generics to base
[packages/base.git] / GHC / Read.lhs
1 \begin{code}
2 {-# LANGUAGE Trustworthy #-}
3 {-# LANGUAGE CPP, NoImplicitPrelude, StandaloneDeriving, PatternGuards,
4              ScopedTypeVariables #-}
5 {-# OPTIONS_HADDOCK hide #-}
6
7 -----------------------------------------------------------------------------
8 -- |
9 -- Module      :  GHC.Read
10 -- Copyright   :  (c) The University of Glasgow, 1994-2002
11 -- License     :  see libraries/base/LICENSE
12 -- 
13 -- Maintainer  :  cvs-ghc@haskell.org
14 -- Stability   :  internal
15 -- Portability :  non-portable (GHC Extensions)
16 --
17 -- The 'Read' class and instances for basic data types.
18 --
19 -----------------------------------------------------------------------------
20
21 -- #hide
22 module GHC.Read
23   ( Read(..)   -- class
24
25   -- ReadS type
26   , ReadS      -- :: *; = String -> [(a,String)]
27
28   -- H98 compatibility
29   , lex         -- :: ReadS String
30   , lexLitChar  -- :: ReadS String
31   , readLitChar -- :: ReadS Char
32   , lexDigits   -- :: ReadS String
33
34   -- defining readers
35   , lexP       -- :: ReadPrec Lexeme
36   , paren      -- :: ReadPrec a -> ReadPrec a
37   , parens     -- :: ReadPrec a -> ReadPrec a
38   , list       -- :: ReadPrec a -> ReadPrec [a]
39   , choose     -- :: [(String, ReadPrec a)] -> ReadPrec a
40   , readListDefault, readListPrecDefault
41
42   -- Temporary
43   , readParen
44
45   -- XXX Can this be removed?
46   , readp
47   )
48  where
49
50 import qualified Text.ParserCombinators.ReadP as P
51
52 import Text.ParserCombinators.ReadP
53   ( ReadP
54   , ReadS
55   , readP_to_S
56   )
57
58 import qualified Text.Read.Lex as L
59 -- Lex exports 'lex', which is also defined here,
60 -- hence the qualified import.
61 -- We can't import *anything* unqualified, because that
62 -- confuses Haddock.
63
64 import Text.ParserCombinators.ReadPrec
65
66 import Data.Maybe
67
68 import {-# SOURCE #-} GHC.Unicode       ( isDigit )
69 import GHC.Num
70 import GHC.Real
71 import GHC.Float
72 import GHC.Show
73 import GHC.Base
74 import GHC.Err
75 import GHC.Arr
76 \end{code}
77
78
79 \begin{code}
80 -- | @'readParen' 'True' p@ parses what @p@ parses, but surrounded with
81 -- parentheses.
82 --
83 -- @'readParen' 'False' p@ parses what @p@ parses, but optionally
84 -- surrounded with parentheses.
85 readParen       :: Bool -> ReadS a -> ReadS a
86 -- A Haskell 98 function
87 readParen b g   =  if b then mandatory else optional
88                    where optional r  = g r ++ mandatory r
89                          mandatory r = do
90                                 ("(",s) <- lex r
91                                 (x,t)   <- optional s
92                                 (")",u) <- lex t
93                                 return (x,u)
94 \end{code}
95
96
97 %*********************************************************
98 %*                                                      *
99 \subsection{The @Read@ class}
100 %*                                                      *
101 %*********************************************************
102
103 \begin{code}
104 ------------------------------------------------------------------------
105 -- class Read
106
107 -- | Parsing of 'String's, producing values.
108 --
109 -- Minimal complete definition: 'readsPrec' (or, for GHC only, 'readPrec')
110 --
111 -- Derived instances of 'Read' make the following assumptions, which
112 -- derived instances of 'Text.Show.Show' obey:
113 --
114 -- * If the constructor is defined to be an infix operator, then the
115 --   derived 'Read' instance will parse only infix applications of
116 --   the constructor (not the prefix form).
117 --
118 -- * Associativity is not used to reduce the occurrence of parentheses,
119 --   although precedence may be.
120 --
121 -- * If the constructor is defined using record syntax, the derived 'Read'
122 --   will parse only the record-syntax form, and furthermore, the fields
123 --   must be given in the same order as the original declaration.
124 --
125 -- * The derived 'Read' instance allows arbitrary Haskell whitespace
126 --   between tokens of the input string.  Extra parentheses are also
127 --   allowed.
128 --
129 -- For example, given the declarations
130 --
131 -- > infixr 5 :^:
132 -- > data Tree a =  Leaf a  |  Tree a :^: Tree a
133 --
134 -- the derived instance of 'Read' in Haskell 98 is equivalent to
135 --
136 -- > instance (Read a) => Read (Tree a) where
137 -- >
138 -- >         readsPrec d r =  readParen (d > app_prec)
139 -- >                          (\r -> [(Leaf m,t) |
140 -- >                                  ("Leaf",s) <- lex r,
141 -- >                                  (m,t) <- readsPrec (app_prec+1) s]) r
142 -- >
143 -- >                       ++ readParen (d > up_prec)
144 -- >                          (\r -> [(u:^:v,w) |
145 -- >                                  (u,s) <- readsPrec (up_prec+1) r,
146 -- >                                  (":^:",t) <- lex s,
147 -- >                                  (v,w) <- readsPrec (up_prec+1) t]) r
148 -- >
149 -- >           where app_prec = 10
150 -- >                 up_prec = 5
151 --
152 -- Note that right-associativity of @:^:@ is unused.
153 --
154 -- The derived instance in GHC is equivalent to
155 --
156 -- > instance (Read a) => Read (Tree a) where
157 -- >
158 -- >         readPrec = parens $ (prec app_prec $ do
159 -- >                                  Ident "Leaf" <- lexP
160 -- >                                  m <- step readPrec
161 -- >                                  return (Leaf m))
162 -- >
163 -- >                      +++ (prec up_prec $ do
164 -- >                                  u <- step readPrec
165 -- >                                  Symbol ":^:" <- lexP
166 -- >                                  v <- step readPrec
167 -- >                                  return (u :^: v))
168 -- >
169 -- >           where app_prec = 10
170 -- >                 up_prec = 5
171 -- >
172 -- >         readListPrec = readListPrecDefault
173
174 class Read a where
175   -- | attempts to parse a value from the front of the string, returning
176   -- a list of (parsed value, remaining string) pairs.  If there is no
177   -- successful parse, the returned list is empty.
178   --
179   -- Derived instances of 'Read' and 'Text.Show.Show' satisfy the following:
180   --
181   -- * @(x,\"\")@ is an element of
182   --   @('readsPrec' d ('Text.Show.showsPrec' d x \"\"))@.
183   --
184   -- That is, 'readsPrec' parses the string produced by
185   -- 'Text.Show.showsPrec', and delivers the value that
186   -- 'Text.Show.showsPrec' started with.
187
188   readsPrec    :: Int   -- ^ the operator precedence of the enclosing
189                         -- context (a number from @0@ to @11@).
190                         -- Function application has precedence @10@.
191                 -> ReadS a
192
193   -- | The method 'readList' is provided to allow the programmer to
194   -- give a specialised way of parsing lists of values.
195   -- For example, this is used by the predefined 'Read' instance of
196   -- the 'Char' type, where values of type 'String' should be are
197   -- expected to use double quotes, rather than square brackets.
198   readList     :: ReadS [a]
199
200   -- | Proposed replacement for 'readsPrec' using new-style parsers (GHC only).
201   readPrec     :: ReadPrec a
202
203   -- | Proposed replacement for 'readList' using new-style parsers (GHC only).
204   -- The default definition uses 'readList'.  Instances that define 'readPrec'
205   -- should also define 'readListPrec' as 'readListPrecDefault'.
206   readListPrec :: ReadPrec [a]
207   
208   -- default definitions
209   readsPrec    = readPrec_to_S readPrec
210   readList     = readPrec_to_S (list readPrec) 0
211   readPrec     = readS_to_Prec readsPrec
212   readListPrec = readS_to_Prec (\_ -> readList)
213
214 readListDefault :: Read a => ReadS [a]
215 -- ^ A possible replacement definition for the 'readList' method (GHC only).
216 --   This is only needed for GHC, and even then only for 'Read' instances
217 --   where 'readListPrec' isn't defined as 'readListPrecDefault'.
218 readListDefault = readPrec_to_S readListPrec 0
219
220 readListPrecDefault :: Read a => ReadPrec [a]
221 -- ^ A possible replacement definition for the 'readListPrec' method,
222 --   defined using 'readPrec' (GHC only).
223 readListPrecDefault = list readPrec
224
225 ------------------------------------------------------------------------
226 -- H98 compatibility
227
228 -- | The 'lex' function reads a single lexeme from the input, discarding
229 -- initial white space, and returning the characters that constitute the
230 -- lexeme.  If the input string contains only white space, 'lex' returns a
231 -- single successful \`lexeme\' consisting of the empty string.  (Thus
232 -- @'lex' \"\" = [(\"\",\"\")]@.)  If there is no legal lexeme at the
233 -- beginning of the input string, 'lex' fails (i.e. returns @[]@).
234 --
235 -- This lexer is not completely faithful to the Haskell lexical syntax
236 -- in the following respects:
237 --
238 -- * Qualified names are not handled properly
239 --
240 -- * Octal and hexadecimal numerics are not recognized as a single token
241 --
242 -- * Comments are not treated properly
243 lex :: ReadS String             -- As defined by H98
244 lex s  = readP_to_S L.hsLex s
245
246 -- | Read a string representation of a character, using Haskell
247 -- source-language escape conventions.  For example:
248 --
249 -- > lexLitChar  "\\nHello"  =  [("\\n", "Hello")]
250 --
251 lexLitChar :: ReadS String      -- As defined by H98
252 lexLitChar = readP_to_S (do { (s, _) <- P.gather L.lexChar ;
253                               return s })
254         -- There was a skipSpaces before the P.gather L.lexChar,
255         -- but that seems inconsistent with readLitChar
256
257 -- | Read a string representation of a character, using Haskell
258 -- source-language escape conventions, and convert it to the character
259 -- that it encodes.  For example:
260 --
261 -- > readLitChar "\\nHello"  =  [('\n', "Hello")]
262 --
263 readLitChar :: ReadS Char       -- As defined by H98
264 readLitChar = readP_to_S L.lexChar
265
266 -- | Reads a non-empty string of decimal digits.
267 lexDigits :: ReadS String
268 lexDigits = readP_to_S (P.munch1 isDigit)
269
270 ------------------------------------------------------------------------
271 -- utility parsers
272
273 lexP :: ReadPrec L.Lexeme
274 -- ^ Parse a single lexeme
275 lexP = lift L.lex
276
277 paren :: ReadPrec a -> ReadPrec a
278 -- ^ @(paren p)@ parses \"(P0)\"
279 --      where @p@ parses \"P0\" in precedence context zero
280 paren p = do L.Punc "(" <- lexP
281              x          <- reset p
282              L.Punc ")" <- lexP
283              return x
284
285 parens :: ReadPrec a -> ReadPrec a
286 -- ^ @(parens p)@ parses \"P\", \"(P0)\", \"((P0))\", etc, 
287 --      where @p@ parses \"P\"  in the current precedence context
288 --          and parses \"P0\" in precedence context zero
289 parens p = optional
290  where
291   optional  = p +++ mandatory
292   mandatory = paren optional
293
294 list :: ReadPrec a -> ReadPrec [a]
295 -- ^ @(list p)@ parses a list of things parsed by @p@,
296 -- using the usual square-bracket syntax.
297 list readx =
298   parens
299   ( do L.Punc "[" <- lexP
300        (listRest False +++ listNext)
301   )
302  where
303   listRest started =
304     do L.Punc c <- lexP
305        case c of
306          "]"           -> return []
307          "," | started -> listNext
308          _             -> pfail
309   
310   listNext =
311     do x  <- reset readx
312        xs <- listRest True
313        return (x:xs)
314
315 choose :: [(String, ReadPrec a)] -> ReadPrec a
316 -- ^ Parse the specified lexeme and continue as specified.
317 -- Esp useful for nullary constructors; e.g.
318 --    @choose [(\"A\", return A), (\"B\", return B)]@
319 -- We match both Ident and Symbol because the constructor
320 -- might be an operator eg (:=:)
321 choose sps = foldr ((+++) . try_one) pfail sps
322            where
323              try_one (s,p) = do { token <- lexP ;
324                                   case token of
325                                     L.Ident s'  | s==s' -> p
326                                     L.Symbol s' | s==s' -> p
327                                     _other              -> pfail }
328 \end{code}
329
330
331 %*********************************************************
332 %*                                                      *
333 \subsection{Simple instances of Read}
334 %*                                                      *
335 %*********************************************************
336
337 \begin{code}
338 instance Read Char where
339   readPrec =
340     parens
341     ( do L.Char c <- lexP
342          return c
343     )
344
345   readListPrec =
346     parens
347     ( do L.String s <- lexP     -- Looks for "foo"
348          return s
349      +++
350       readListPrecDefault       -- Looks for ['f','o','o']
351     )                           -- (more generous than H98 spec)
352
353   readList = readListDefault
354
355 instance Read Bool where
356   readPrec =
357     parens
358     ( do L.Ident s <- lexP
359          case s of
360            "True"  -> return True
361            "False" -> return False
362            _       -> pfail
363     )
364
365   readListPrec = readListPrecDefault
366   readList     = readListDefault
367
368 instance Read Ordering where
369   readPrec =
370     parens
371     ( do L.Ident s <- lexP
372          case s of
373            "LT" -> return LT
374            "EQ" -> return EQ
375            "GT" -> return GT
376            _    -> pfail
377     )
378
379   readListPrec = readListPrecDefault
380   readList     = readListDefault
381 \end{code}
382
383
384 %*********************************************************
385 %*                                                      *
386 \subsection{Structure instances of Read: Maybe, List etc}
387 %*                                                      *
388 %*********************************************************
389
390 For structured instances of Read we start using the precedences.  The
391 idea is then that 'parens (prec k p)' will fail immediately when trying
392 to parse it in a context with a higher precedence level than k. But if
393 there is one parenthesis parsed, then the required precedence level
394 drops to 0 again, and parsing inside p may succeed.
395
396 'appPrec' is just the precedence level of function application.  So,
397 if we are parsing function application, we'd better require the
398 precedence level to be at least 'appPrec'. Otherwise, we have to put
399 parentheses around it.
400
401 'step' is used to increase the precedence levels inside a
402 parser, and can be used to express left- or right- associativity. For
403 example, % is defined to be left associative, so we only increase
404 precedence on the right hand side.
405
406 Note how step is used in for example the Maybe parser to increase the
407 precedence beyond appPrec, so that basically only literals and
408 parenthesis-like objects such as (...) and [...] can be an argument to
409 'Just'.
410
411 \begin{code}
412 instance Read a => Read (Maybe a) where
413   readPrec =
414     parens
415     (do L.Ident "Nothing" <- lexP
416         return Nothing
417      +++
418      prec appPrec (
419         do L.Ident "Just" <- lexP
420            x              <- step readPrec
421            return (Just x))
422     )
423
424   readListPrec = readListPrecDefault
425   readList     = readListDefault
426
427 instance Read a => Read [a] where
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 L.Ident "array" <- lexP
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            L.Symbol "%" <- lexP
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 = do { L.Punc "," <- lexP; return () }
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
685 \begin{code}
686 -- XXX Can this be removed?
687
688 readp :: Read a => ReadP a
689 readp = readPrec_to_P readPrec minPrec
690 \end{code}