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