cea761b0b88fa7fb33d73123bf75512be3383cb3
[packages/base.git] / GHC / Read.lhs
1 \begin{code}
2 {-# LANGUAGE Trustworthy #-}
3 {-# LANGUAGE CPP, NoImplicitPrelude, StandaloneDeriving #-}
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 -- #hide
21 module GHC.Read
22   ( Read(..)   -- class
23
24   -- ReadS type
25   , ReadS      -- :: *; = String -> [(a,String)]
26
27   -- H98 compatibility
28   , lex         -- :: ReadS String
29   , lexLitChar  -- :: ReadS String
30   , readLitChar -- :: ReadS Char
31   , lexDigits   -- :: ReadS String
32
33   -- defining readers
34   , lexP       -- :: ReadPrec Lexeme
35   , paren      -- :: ReadPrec a -> ReadPrec a
36   , parens     -- :: ReadPrec a -> ReadPrec a
37   , list       -- :: ReadPrec a -> ReadPrec [a]
38   , choose     -- :: [(String, ReadPrec a)] -> ReadPrec a
39   , readListDefault, readListPrecDefault
40
41   -- Temporary
42   , readParen
43
44   -- XXX Can this be removed?
45   , readp
46   )
47  where
48
49 import qualified Text.ParserCombinators.ReadP as P
50
51 import Text.ParserCombinators.ReadP
52   ( ReadP
53   , ReadS
54   , readP_to_S
55   )
56
57 import qualified Text.Read.Lex as L
58 -- Lex exports 'lex', which is also defined here,
59 -- hence the qualified import.
60 -- We can't import *anything* unqualified, because that
61 -- confuses Haddock.
62
63 import Text.ParserCombinators.ReadPrec
64
65 import Data.Maybe
66
67 import {-# SOURCE #-} GHC.Unicode       ( isDigit )
68 import GHC.Num
69 import GHC.Real
70 import GHC.Float ()
71 import GHC.Show
72 import GHC.Base
73 import GHC.Arr
74 -- For defining instances for the generic deriving mechanism
75 import GHC.Generics (Arity(..), Associativity(..), Fixity(..))
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.Int i) = return (fromInteger i)
472 convertInt _         = pfail
473
474 convertFrac :: Fractional a => L.Lexeme -> ReadPrec a
475 convertFrac (L.Int i) = return (fromInteger i)
476 convertFrac (L.Rat r) = return (fromRational r)
477 convertFrac _         = pfail
478
479 instance Read Int where
480   readPrec     = readNumber convertInt
481   readListPrec = readListPrecDefault
482   readList     = readListDefault
483
484 instance Read Integer where
485   readPrec     = readNumber convertInt
486   readListPrec = readListPrecDefault
487   readList     = readListDefault
488
489 instance Read Float where
490   readPrec     = readNumber convertFrac
491   readListPrec = readListPrecDefault
492   readList     = readListDefault
493
494 instance Read Double where
495   readPrec     = readNumber convertFrac
496   readListPrec = readListPrecDefault
497   readList     = readListDefault
498
499 instance (Integral a, Read a) => Read (Ratio a) where
500   readPrec =
501     parens
502     ( prec ratioPrec
503       ( do x            <- step readPrec
504            L.Symbol "%" <- lexP
505            y            <- step readPrec
506            return (x % y)
507       )
508     )
509
510   readListPrec = readListPrecDefault
511   readList     = readListDefault
512 \end{code}
513
514
515 %*********************************************************
516 %*                                                      *
517         Tuple instances of Read, up to size 15
518 %*                                                      *
519 %*********************************************************
520
521 \begin{code}
522 instance Read () where
523   readPrec =
524     parens
525     ( paren
526       ( return ()
527       )
528     )
529
530   readListPrec = readListPrecDefault
531   readList     = readListDefault
532
533 instance (Read a, Read b) => Read (a,b) where
534   readPrec = wrap_tup read_tup2
535   readListPrec = readListPrecDefault
536   readList     = readListDefault
537
538 wrap_tup :: ReadPrec a -> ReadPrec a
539 wrap_tup p = parens (paren p)
540
541 read_comma :: ReadPrec ()
542 read_comma = do { L.Punc "," <- lexP; return () }
543
544 read_tup2 :: (Read a, Read b) => ReadPrec (a,b)
545 -- Reads "a , b"  no parens!
546 read_tup2 = do x <- readPrec
547                read_comma
548                y <- readPrec
549                return (x,y)
550
551 read_tup4 :: (Read a, Read b, Read c, Read d) => ReadPrec (a,b,c,d)
552 read_tup4 = do  (a,b) <- read_tup2
553                 read_comma
554                 (c,d) <- read_tup2
555                 return (a,b,c,d)
556
557
558 read_tup8 :: (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h)
559           => ReadPrec (a,b,c,d,e,f,g,h)
560 read_tup8 = do  (a,b,c,d) <- read_tup4
561                 read_comma
562                 (e,f,g,h) <- read_tup4
563                 return (a,b,c,d,e,f,g,h)
564
565
566 instance (Read a, Read b, Read c) => Read (a, b, c) where
567   readPrec = wrap_tup (do { (a,b) <- read_tup2; read_comma 
568                           ; c <- readPrec 
569                           ; return (a,b,c) })
570   readListPrec = readListPrecDefault
571   readList     = readListDefault
572
573 instance (Read a, Read b, Read c, Read d) => Read (a, b, c, d) where
574   readPrec = wrap_tup read_tup4
575   readListPrec = readListPrecDefault
576   readList     = readListDefault
577
578 instance (Read a, Read b, Read c, Read d, Read e) => Read (a, b, c, d, e) where
579   readPrec = wrap_tup (do { (a,b,c,d) <- read_tup4; read_comma
580                           ; e <- readPrec
581                           ; return (a,b,c,d,e) })
582   readListPrec = readListPrecDefault
583   readList     = readListDefault
584
585 instance (Read a, Read b, Read c, Read d, Read e, Read f)
586         => Read (a, b, c, d, e, f) where
587   readPrec = wrap_tup (do { (a,b,c,d) <- read_tup4; read_comma
588                           ; (e,f) <- read_tup2
589                           ; return (a,b,c,d,e,f) })
590   readListPrec = readListPrecDefault
591   readList     = readListDefault
592
593 instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g)
594         => Read (a, b, c, d, e, f, g) where
595   readPrec = wrap_tup (do { (a,b,c,d) <- read_tup4; read_comma
596                           ; (e,f) <- read_tup2; read_comma
597                           ; g <- readPrec
598                           ; return (a,b,c,d,e,f,g) })
599   readListPrec = readListPrecDefault
600   readList     = readListDefault
601
602 instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h)
603         => Read (a, b, c, d, e, f, g, h) where
604   readPrec     = wrap_tup read_tup8
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 i)
610         => Read (a, b, c, d, e, f, g, h, i) where
611   readPrec = wrap_tup (do { (a,b,c,d,e,f,g,h) <- read_tup8; read_comma
612                           ; i <- readPrec
613                           ; return (a,b,c,d,e,f,g,h,i) })
614   readListPrec = readListPrecDefault
615   readList     = readListDefault
616
617 instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
618           Read i, Read j)
619         => Read (a, b, c, d, e, f, g, h, i, j) where
620   readPrec = wrap_tup (do { (a,b,c,d,e,f,g,h) <- read_tup8; read_comma
621                           ; (i,j) <- read_tup2
622                           ; return (a,b,c,d,e,f,g,h,i,j) })
623   readListPrec = readListPrecDefault
624   readList     = readListDefault
625
626 instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
627           Read i, Read j, Read k)
628         => Read (a, b, c, d, e, f, g, h, i, j, k) where
629   readPrec = wrap_tup (do { (a,b,c,d,e,f,g,h) <- read_tup8; read_comma
630                           ; (i,j) <- read_tup2; read_comma
631                           ; k <- readPrec
632                           ; return (a,b,c,d,e,f,g,h,i,j,k) })
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, Read l)
638         => Read (a, b, c, d, e, f, g, h, i, j, k, l) where
639   readPrec = wrap_tup (do { (a,b,c,d,e,f,g,h) <- read_tup8; read_comma
640                           ; (i,j,k,l) <- read_tup4
641                           ; return (a,b,c,d,e,f,g,h,i,j,k,l) })
642   readListPrec = readListPrecDefault
643   readList     = readListDefault
644
645 instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
646           Read i, Read j, Read k, Read l, Read m)
647         => Read (a, b, c, d, e, f, g, h, i, j, k, l, m) where
648   readPrec = wrap_tup (do { (a,b,c,d,e,f,g,h) <- read_tup8; read_comma
649                           ; (i,j,k,l) <- read_tup4; read_comma
650                           ; m <- readPrec
651                           ; return (a,b,c,d,e,f,g,h,i,j,k,l,m) })
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, Read n)
657         => Read (a, b, c, d, e, f, g, h, i, j, k, l, m, n) 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,n) <- read_tup2
661                           ; return (a,b,c,d,e,f,g,h,i,j,k,l,m,n) })
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, Read o)
667         => Read (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) 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; read_comma
671                           ; o <- readPrec
672                           ; return (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) })
673   readListPrec = readListPrecDefault
674   readList     = readListDefault
675 \end{code}
676
677 \begin{code}
678 -- XXX Can this be removed?
679
680 readp :: Read a => ReadP a
681 readp = readPrec_to_P readPrec minPrec
682 \end{code}
683
684 Instances for types of the generic deriving mechanism.
685
686 \begin{code}
687 deriving instance Read Arity
688 deriving instance Read Associativity
689 deriving instance Read Fixity
690 \end{code}