SafeHaskell: Added SafeHaskell to base
[ghc.git] / libraries / base / 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 #ifndef __HADDOCK__
68 import {-# SOURCE #-} GHC.Unicode       ( isDigit )
69 #endif
70 import GHC.Num
71 import GHC.Real
72 import GHC.Float ()
73 import GHC.Show
74 import GHC.Base
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.Int i) = return (fromInteger i)
474 convertInt _         = pfail
475
476 convertFrac :: Fractional a => L.Lexeme -> ReadPrec a
477 convertFrac (L.Int i) = return (fromInteger i)
478 convertFrac (L.Rat r) = return (fromRational r)
479 convertFrac _         = pfail
480
481 instance Read Int where
482   readPrec     = readNumber convertInt
483   readListPrec = readListPrecDefault
484   readList     = readListDefault
485
486 instance Read Integer where
487   readPrec     = readNumber convertInt
488   readListPrec = readListPrecDefault
489   readList     = readListDefault
490
491 instance Read Float where
492   readPrec     = readNumber convertFrac
493   readListPrec = readListPrecDefault
494   readList     = readListDefault
495
496 instance Read Double where
497   readPrec     = readNumber convertFrac
498   readListPrec = readListPrecDefault
499   readList     = readListDefault
500
501 instance (Integral a, Read a) => Read (Ratio a) where
502   readPrec =
503     parens
504     ( prec ratioPrec
505       ( do x            <- step readPrec
506            L.Symbol "%" <- lexP
507            y            <- step readPrec
508            return (x % y)
509       )
510     )
511
512   readListPrec = readListPrecDefault
513   readList     = readListDefault
514 \end{code}
515
516
517 %*********************************************************
518 %*                                                      *
519         Tuple instances of Read, up to size 15
520 %*                                                      *
521 %*********************************************************
522
523 \begin{code}
524 instance Read () where
525   readPrec =
526     parens
527     ( paren
528       ( return ()
529       )
530     )
531
532   readListPrec = readListPrecDefault
533   readList     = readListDefault
534
535 instance (Read a, Read b) => Read (a,b) where
536   readPrec = wrap_tup read_tup2
537   readListPrec = readListPrecDefault
538   readList     = readListDefault
539
540 wrap_tup :: ReadPrec a -> ReadPrec a
541 wrap_tup p = parens (paren p)
542
543 read_comma :: ReadPrec ()
544 read_comma = do { L.Punc "," <- lexP; return () }
545
546 read_tup2 :: (Read a, Read b) => ReadPrec (a,b)
547 -- Reads "a , b"  no parens!
548 read_tup2 = do x <- readPrec
549                read_comma
550                y <- readPrec
551                return (x,y)
552
553 read_tup4 :: (Read a, Read b, Read c, Read d) => ReadPrec (a,b,c,d)
554 read_tup4 = do  (a,b) <- read_tup2
555                 read_comma
556                 (c,d) <- read_tup2
557                 return (a,b,c,d)
558
559
560 read_tup8 :: (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h)
561           => ReadPrec (a,b,c,d,e,f,g,h)
562 read_tup8 = do  (a,b,c,d) <- read_tup4
563                 read_comma
564                 (e,f,g,h) <- read_tup4
565                 return (a,b,c,d,e,f,g,h)
566
567
568 instance (Read a, Read b, Read c) => Read (a, b, c) where
569   readPrec = wrap_tup (do { (a,b) <- read_tup2; read_comma 
570                           ; c <- readPrec 
571                           ; return (a,b,c) })
572   readListPrec = readListPrecDefault
573   readList     = readListDefault
574
575 instance (Read a, Read b, Read c, Read d) => Read (a, b, c, d) where
576   readPrec = wrap_tup read_tup4
577   readListPrec = readListPrecDefault
578   readList     = readListDefault
579
580 instance (Read a, Read b, Read c, Read d, Read e) => Read (a, b, c, d, e) where
581   readPrec = wrap_tup (do { (a,b,c,d) <- read_tup4; read_comma
582                           ; e <- readPrec
583                           ; return (a,b,c,d,e) })
584   readListPrec = readListPrecDefault
585   readList     = readListDefault
586
587 instance (Read a, Read b, Read c, Read d, Read e, Read f)
588         => Read (a, b, c, d, e, f) where
589   readPrec = wrap_tup (do { (a,b,c,d) <- read_tup4; read_comma
590                           ; (e,f) <- read_tup2
591                           ; return (a,b,c,d,e,f) })
592   readListPrec = readListPrecDefault
593   readList     = readListDefault
594
595 instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g)
596         => Read (a, b, c, d, e, f, g) where
597   readPrec = wrap_tup (do { (a,b,c,d) <- read_tup4; read_comma
598                           ; (e,f) <- read_tup2; read_comma
599                           ; g <- readPrec
600                           ; return (a,b,c,d,e,f,g) })
601   readListPrec = readListPrecDefault
602   readList     = readListDefault
603
604 instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h)
605         => Read (a, b, c, d, e, f, g, h) where
606   readPrec     = wrap_tup read_tup8
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 i)
612         => Read (a, b, c, d, e, f, g, h, i) where
613   readPrec = wrap_tup (do { (a,b,c,d,e,f,g,h) <- read_tup8; read_comma
614                           ; i <- readPrec
615                           ; return (a,b,c,d,e,f,g,h,i) })
616   readListPrec = readListPrecDefault
617   readList     = readListDefault
618
619 instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
620           Read i, Read j)
621         => Read (a, b, c, d, e, f, g, h, i, j) where
622   readPrec = wrap_tup (do { (a,b,c,d,e,f,g,h) <- read_tup8; read_comma
623                           ; (i,j) <- read_tup2
624                           ; return (a,b,c,d,e,f,g,h,i,j) })
625   readListPrec = readListPrecDefault
626   readList     = readListDefault
627
628 instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
629           Read i, Read j, Read k)
630         => Read (a, b, c, d, e, f, g, h, i, j, k) where
631   readPrec = wrap_tup (do { (a,b,c,d,e,f,g,h) <- read_tup8; read_comma
632                           ; (i,j) <- read_tup2; read_comma
633                           ; k <- readPrec
634                           ; return (a,b,c,d,e,f,g,h,i,j,k) })
635   readListPrec = readListPrecDefault
636   readList     = readListDefault
637
638 instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
639           Read i, Read j, Read k, Read l)
640         => Read (a, b, c, d, e, f, g, h, i, j, k, l) where
641   readPrec = wrap_tup (do { (a,b,c,d,e,f,g,h) <- read_tup8; read_comma
642                           ; (i,j,k,l) <- read_tup4
643                           ; return (a,b,c,d,e,f,g,h,i,j,k,l) })
644   readListPrec = readListPrecDefault
645   readList     = readListDefault
646
647 instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
648           Read i, Read j, Read k, Read l, Read m)
649         => Read (a, b, c, d, e, f, g, h, i, j, k, l, m) where
650   readPrec = wrap_tup (do { (a,b,c,d,e,f,g,h) <- read_tup8; read_comma
651                           ; (i,j,k,l) <- read_tup4; read_comma
652                           ; m <- readPrec
653                           ; return (a,b,c,d,e,f,g,h,i,j,k,l,m) })
654   readListPrec = readListPrecDefault
655   readList     = readListDefault
656
657 instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
658           Read i, Read j, Read k, Read l, Read m, Read n)
659         => Read (a, b, c, d, e, f, g, h, i, j, k, l, m, n) where
660   readPrec = wrap_tup (do { (a,b,c,d,e,f,g,h) <- read_tup8; read_comma
661                           ; (i,j,k,l) <- read_tup4; read_comma
662                           ; (m,n) <- read_tup2
663                           ; return (a,b,c,d,e,f,g,h,i,j,k,l,m,n) })
664   readListPrec = readListPrecDefault
665   readList     = readListDefault
666
667 instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
668           Read i, Read j, Read k, Read l, Read m, Read n, Read o)
669         => Read (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) where
670   readPrec = wrap_tup (do { (a,b,c,d,e,f,g,h) <- read_tup8; read_comma
671                           ; (i,j,k,l) <- read_tup4; read_comma
672                           ; (m,n) <- read_tup2; read_comma
673                           ; o <- readPrec
674                           ; return (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) })
675   readListPrec = readListPrecDefault
676   readList     = readListDefault
677 \end{code}
678
679 \begin{code}
680 -- XXX Can this be removed?
681
682 readp :: Read a => ReadP a
683 readp = readPrec_to_P readPrec minPrec
684 \end{code}
685
686 Instances for types of the generic deriving mechanism.
687
688 \begin{code}
689 deriving instance Read Arity
690 deriving instance Read Associativity
691 deriving instance Read Fixity
692 \end{code}