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