Read.hs 26.2 KB
Newer Older
1
{-# LANGUAGE Trustworthy #-}
2
{-# LANGUAGE CPP, NoImplicitPrelude, StandaloneDeriving, ScopedTypeVariables #-}
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
12
13
14
15
16
17
-- Maintainer  :  cvs-ghc@haskell.org
-- Stability   :  internal
-- Portability :  non-portable (GHC Extensions)
--
-- The 'Read' class and instances for basic data types.
--
-----------------------------------------------------------------------------
18

Don Stewart's avatar
Don Stewart committed
19
module GHC.Read
20
  ( Read(..)   -- class
Don Stewart's avatar
Don Stewart committed
21

22
  -- ReadS type
23
  , ReadS
Don Stewart's avatar
Don Stewart committed
24

25
  -- H2010 compatibility
26
27
28
29
  , lex
  , lexLitChar
  , readLitChar
  , lexDigits
Don Stewart's avatar
Don Stewart committed
30

31
  -- defining readers
32
  , lexP, expectP
33
34
35
36
  , paren
  , parens
  , list
  , choose
37
  , readListDefault, readListPrecDefault
38
  , readNumber
Tobias Dammers's avatar
Tobias Dammers committed
39
40
  , readField
  , readSymField
41
42
43
44
45
46

  -- Temporary
  , readParen
  )
 where

47
48
#include "MachDeps.h"

49
50
51
import qualified Text.ParserCombinators.ReadP as P

import Text.ParserCombinators.ReadP
ian@well-typed.com's avatar
ian@well-typed.com committed
52
  ( ReadS
53
54
55
56
  , readP_to_S
  )

import qualified Text.Read.Lex as L
57
58
59
60
-- Lex exports 'lex', which is also defined here,
-- hence the qualified import.
-- We can't import *anything* unqualified, because that
-- confuses Haddock.
61
62

import Text.ParserCombinators.ReadPrec
63

64
65
import Data.Maybe

66
import GHC.Unicode
67
68
import GHC.Num
import GHC.Real
69
import GHC.Float
70
import GHC.Show
71
import GHC.Base
72
import GHC.Arr
73
import GHC.Word
74

75

ross's avatar
ross committed
76
77
78
79
80
-- | @'readParen' 'True' p@ parses what @p@ parses, but surrounded with
-- parentheses.
--
-- @'readParen' 'False' p@ parses what @p@ parses, but optionally
-- surrounded with parentheses.
81
readParen       :: Bool -> ReadS a -> ReadS a
82
-- A Haskell 2010 function
83
84
85
readParen b g   =  if b then mandatory else optional
                   where optional r  = g r ++ mandatory r
                         mandatory r = do
Don Stewart's avatar
Don Stewart committed
86
87
88
89
                                ("(",s) <- lex r
                                (x,t)   <- optional s
                                (")",u) <- lex t
                                return (x,u)
90

ross's avatar
ross committed
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
-- | Parsing of 'String's, producing values.
--
-- Derived instances of 'Read' make the following assumptions, which
-- derived instances of 'Text.Show.Show' obey:
--
-- * If the constructor is defined to be an infix operator, then the
--   derived 'Read' instance will parse only infix applications of
--   the constructor (not the prefix form).
--
-- * Associativity is not used to reduce the occurrence of parentheses,
--   although precedence may be.
--
-- * If the constructor is defined using record syntax, the derived 'Read'
--   will parse only the record-syntax form, and furthermore, the fields
--   must be given in the same order as the original declaration.
--
-- * The derived 'Read' instance allows arbitrary Haskell whitespace
--   between tokens of the input string.  Extra parentheses are also
--   allowed.
--
-- For example, given the declarations
--
-- > infixr 5 :^:
-- > data Tree a =  Leaf a  |  Tree a :^: Tree a
--
116
-- the derived instance of 'Read' in Haskell 2010 is equivalent to
ross's avatar
ross committed
117
118
119
--
-- > instance (Read a) => Read (Tree a) where
-- >
ross's avatar
ross committed
120
121
122
123
124
125
-- >         readsPrec d r =  readParen (d > app_prec)
-- >                          (\r -> [(Leaf m,t) |
-- >                                  ("Leaf",s) <- lex r,
-- >                                  (m,t) <- readsPrec (app_prec+1) s]) r
-- >
-- >                       ++ readParen (d > up_prec)
ross's avatar
ross committed
126
127
128
129
130
-- >                          (\r -> [(u:^:v,w) |
-- >                                  (u,s) <- readsPrec (up_prec+1) r,
-- >                                  (":^:",t) <- lex s,
-- >                                  (v,w) <- readsPrec (up_prec+1) t]) r
-- >
ross's avatar
ross committed
131
132
-- >           where app_prec = 10
-- >                 up_prec = 5
ross's avatar
ross committed
133
134
--
-- Note that right-associativity of @:^:@ is unused.
ross's avatar
ross committed
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
--
-- The derived instance in GHC is equivalent to
--
-- > instance (Read a) => Read (Tree a) where
-- >
-- >         readPrec = parens $ (prec app_prec $ do
-- >                                  Ident "Leaf" <- lexP
-- >                                  m <- step readPrec
-- >                                  return (Leaf m))
-- >
-- >                      +++ (prec up_prec $ do
-- >                                  u <- step readPrec
-- >                                  Symbol ":^:" <- lexP
-- >                                  v <- step readPrec
-- >                                  return (u :^: v))
-- >
-- >           where app_prec = 10
-- >                 up_prec = 5
-- >
-- >         readListPrec = readListPrecDefault
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
--
-- Why do both 'readsPrec' and 'readPrec' exist, and why does GHC opt to
-- implement 'readPrec' in derived 'Read' instances instead of 'readsPrec'?
-- The reason is that 'readsPrec' is based on the 'ReadS' type, and although
-- 'ReadS' is mentioned in the Haskell 2010 Report, it is not a very efficient
-- parser data structure.
--
-- 'readPrec', on the other hand, is based on a much more efficient 'ReadPrec'
-- datatype (a.k.a \"new-style parsers\"), but its definition relies on the use
-- of the @RankNTypes@ language extension. Therefore, 'readPrec' (and its
-- cousin, 'readListPrec') are marked as GHC-only. Nevertheless, it is
-- recommended to use 'readPrec' instead of 'readsPrec' whenever possible
-- for the efficiency improvements it brings.
--
-- As mentioned above, derived 'Read' instances in GHC will implement
-- 'readPrec' instead of 'readsPrec'. The default implementations of
-- 'readsPrec' (and its cousin, 'readList') will simply use 'readPrec' under
-- the hood. If you are writing a 'Read' instance by hand, it is recommended
-- to write it like so:
--
-- @
-- instance 'Read' T where
--   'readPrec'     = ...
--   'readListPrec' = 'readListPrecDefault'
-- @
ross's avatar
ross committed
180

181
class Read a where
182
183
  {-# MINIMAL readsPrec | readPrec #-}

ross's avatar
ross committed
184
185
186
187
188
189
190
191
192
193
194
195
196
  -- | attempts to parse a value from the front of the string, returning
  -- a list of (parsed value, remaining string) pairs.  If there is no
  -- successful parse, the returned list is empty.
  --
  -- Derived instances of 'Read' and 'Text.Show.Show' satisfy the following:
  --
  -- * @(x,\"\")@ is an element of
  --   @('readsPrec' d ('Text.Show.showsPrec' d x \"\"))@.
  --
  -- That is, 'readsPrec' parses the string produced by
  -- 'Text.Show.showsPrec', and delivers the value that
  -- 'Text.Show.showsPrec' started with.

Don Stewart's avatar
Don Stewart committed
197
198
199
200
  readsPrec    :: Int   -- ^ the operator precedence of the enclosing
                        -- context (a number from @0@ to @11@).
                        -- Function application has precedence @10@.
                -> ReadS a
ross's avatar
ross committed
201
202
203
204
205
206

  -- | The method 'readList' is provided to allow the programmer to
  -- give a specialised way of parsing lists of values.
  -- For example, this is used by the predefined 'Read' instance of
  -- the 'Char' type, where values of type 'String' should be are
  -- expected to use double quotes, rather than square brackets.
207
  readList     :: ReadS [a]
ross's avatar
ross committed
208

ross's avatar
ross committed
209
  -- | Proposed replacement for 'readsPrec' using new-style parsers (GHC only).
210
  readPrec     :: ReadPrec a
ross's avatar
ross committed
211

ross's avatar
ross committed
212
  -- | Proposed replacement for 'readList' using new-style parsers (GHC only).
ross's avatar
ross committed
213
214
  -- The default definition uses 'readList'.  Instances that define 'readPrec'
  -- should also define 'readListPrec' as 'readListPrecDefault'.
215
  readListPrec :: ReadPrec [a]
216

217
218
219
220
221
222
223
  -- default definitions
  readsPrec    = readPrec_to_S readPrec
  readList     = readPrec_to_S (list readPrec) 0
  readPrec     = readS_to_Prec readsPrec
  readListPrec = readS_to_Prec (\_ -> readList)

readListDefault :: Read a => ReadS [a]
ross's avatar
ross committed
224
225
226
-- ^ A possible replacement definition for the 'readList' method (GHC only).
--   This is only needed for GHC, and even then only for 'Read' instances
--   where 'readListPrec' isn't defined as 'readListPrecDefault'.
227
228
229
readListDefault = readPrec_to_S readListPrec 0

readListPrecDefault :: Read a => ReadPrec [a]
ross's avatar
ross committed
230
231
-- ^ A possible replacement definition for the 'readListPrec' method,
--   defined using 'readPrec' (GHC only).
232
233
234
readListPrecDefault = list readPrec

------------------------------------------------------------------------
235
-- H2010 compatibility
236

ross's avatar
ross committed
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
-- | The 'lex' function reads a single lexeme from the input, discarding
-- initial white space, and returning the characters that constitute the
-- lexeme.  If the input string contains only white space, 'lex' returns a
-- single successful \`lexeme\' consisting of the empty string.  (Thus
-- @'lex' \"\" = [(\"\",\"\")]@.)  If there is no legal lexeme at the
-- beginning of the input string, 'lex' fails (i.e. returns @[]@).
--
-- This lexer is not completely faithful to the Haskell lexical syntax
-- in the following respects:
--
-- * Qualified names are not handled properly
--
-- * Octal and hexadecimal numerics are not recognized as a single token
--
-- * Comments are not treated properly
252
lex :: ReadS String             -- As defined by H2010
253
lex s  = readP_to_S L.hsLex s
254

ross's avatar
ross committed
255
256
257
258
259
-- | Read a string representation of a character, using Haskell
-- source-language escape conventions.  For example:
--
-- > lexLitChar  "\\nHello"  =  [("\\n", "Hello")]
--
260
lexLitChar :: ReadS String      -- As defined by H2010
261
lexLitChar = readP_to_S (do { (s, _) <- P.gather L.lexChar ;
262
263
264
265
266
267
268
                              let s' = removeNulls s in
                              return s' })
    where
    -- remove nulls from end of the character if they exist
    removeNulls [] = []
    removeNulls ('\\':'&':xs) = removeNulls xs
    removeNulls (first:rest) = first : removeNulls rest
Don Stewart's avatar
Don Stewart committed
269
270
        -- There was a skipSpaces before the P.gather L.lexChar,
        -- but that seems inconsistent with readLitChar
271

ross's avatar
ross committed
272
273
274
275
276
277
-- | Read a string representation of a character, using Haskell
-- source-language escape conventions, and convert it to the character
-- that it encodes.  For example:
--
-- > readLitChar "\\nHello"  =  [('\n', "Hello")]
--
278
readLitChar :: ReadS Char       -- As defined by H2010
279
readLitChar = readP_to_S L.lexChar
280

ross's avatar
ross committed
281
-- | Reads a non-empty string of decimal digits.
282
283
284
285
286
287
lexDigits :: ReadS String
lexDigits = readP_to_S (P.munch1 isDigit)

------------------------------------------------------------------------
-- utility parsers

288
289
lexP :: ReadPrec L.Lexeme
-- ^ Parse a single lexeme
290
291
lexP = lift L.lex

292
293
294
expectP :: L.Lexeme -> ReadPrec ()
expectP lexeme = lift (L.expect lexeme)

David Feuer's avatar
David Feuer committed
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
expectCharP :: Char -> ReadPrec a -> ReadPrec a
expectCharP c a = do
  q <- get
  if q == c
    then a
    else pfail
{-# INLINE expectCharP #-}

skipSpacesThenP :: ReadPrec a -> ReadPrec a
skipSpacesThenP m =
  do s <- look
     skip s
 where
   skip (c:s) | isSpace c = get *> skip s
   skip _ = m

311
paren :: ReadPrec a -> ReadPrec a
312
-- ^ @(paren p)@ parses \"(P0)\"
Don Stewart's avatar
Don Stewart committed
313
--      where @p@ parses \"P0\" in precedence context zero
David Feuer's avatar
David Feuer committed
314
315
316
317
318
paren p = skipSpacesThenP (paren' p)

paren' :: ReadPrec a -> ReadPrec a
paren' p = expectCharP '(' $ reset p >>= \x ->
              skipSpacesThenP (expectCharP ')' (pure x))
319
320

parens :: ReadPrec a -> ReadPrec a
321
-- ^ @(parens p)@ parses \"P\", \"(P0)\", \"((P0))\", etc,
Don Stewart's avatar
Don Stewart committed
322
323
--      where @p@ parses \"P\"  in the current precedence context
--          and parses \"P0\" in precedence context zero
324
parens p = optional
David Feuer's avatar
David Feuer committed
325
326
327
  where
    optional = skipSpacesThenP (p +++ mandatory)
    mandatory = paren' optional
328
329

list :: ReadPrec a -> ReadPrec [a]
330
331
-- ^ @(list p)@ parses a list of things parsed by @p@,
-- using the usual square-bracket syntax.
332
333
list readx =
  parens
334
  ( do expectP (L.Punc "[")
335
336
337
338
       (listRest False +++ listNext)
  )
 where
  listRest started =
339
    do L.Punc c <- lexP
340
       case c of
341
342
         "]"           -> return []
         "," | started -> listNext
343
         _             -> pfail
344

345
346
347
348
349
350
  listNext =
    do x  <- reset readx
       xs <- listRest True
       return (x:xs)

choose :: [(String, ReadPrec a)] -> ReadPrec a
351
352
-- ^ Parse the specified lexeme and continue as specified.
-- Esp useful for nullary constructors; e.g.
353
--    @choose [(\"A\", return A), (\"B\", return B)]@
354
-- We match both Ident and Symbol because the constructor
355
-- might be an operator eg @(:~:)@
356
choose sps = foldr ((+++) . try_one) pfail sps
Don Stewart's avatar
Don Stewart committed
357
           where
358
359
360
361
362
             try_one (s,p) = do { token <- lexP ;
                                  case token of
                                    L.Ident s'  | s==s' -> p
                                    L.Symbol s' | s==s' -> p
                                    _other              -> pfail }
363

Tobias Dammers's avatar
Tobias Dammers committed
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
-- See Note [Why readField]

-- | 'Read' parser for a record field, of the form @fieldName=value@. The
-- @fieldName@ must be an alphanumeric identifier; for symbols (operator-style)
-- field names, e.g. @(#)@, use 'readSymField'). The second argument is a
-- parser for the field value.
readField :: String -> ReadPrec a -> ReadPrec a
readField fieldName readVal = do
        expectP (L.Ident fieldName)
        expectP (L.Punc "=")
        readVal
{-# NOINLINE readField #-}

-- See Note [Why readField]

-- | 'Read' parser for a symbol record field, of the form @(###)=value@ (where
-- @###@ is the field name). The field name must be a symbol (operator-style),
-- e.g. @(#)@. For regular (alphanumeric) field names, use 'readField'. The
-- second argument is a parser for the field value.
readSymField :: String -> ReadPrec a -> ReadPrec a
readSymField fieldName readVal = do
        expectP (L.Punc "(")
        expectP (L.Symbol fieldName)
        expectP (L.Punc ")")
        expectP (L.Punc "=")
        readVal
{-# NOINLINE readSymField #-}


-- Note [Why readField]
--
Gabor Greif's avatar
Gabor Greif committed
395
-- Previously, the code for automatically deriving Read instance (in
Tobias Dammers's avatar
Tobias Dammers committed
396
397
398
399
400
401
402
403
404
405
406
407
-- typecheck/TcGenDeriv.hs) would generate inline code for parsing fields;
-- this, however, turned out to produce massive amounts of intermediate code,
-- and produced a considerable performance hit in the code generator.
-- Since Read instances are not generally supposed to be perfomance critical,
-- the readField and readSymField functions have been factored out, and the
-- code generator now just generates calls rather than manually inlining the
-- parsers. For large record types (e.g. 500 fields), this produces a
-- significant performance boost.
--
-- See also Trac #14364.


408
409
410
--------------------------------------------------------------
-- Simple instances of Read
--------------------------------------------------------------
411

412
413
deriving instance Read GeneralCategory

414
-- | @since 2.01
415
416
417
instance Read Char where
  readPrec =
    parens
418
    ( do L.Char c <- lexP
419
420
421
422
423
         return c
    )

  readListPrec =
    parens
Don Stewart's avatar
Don Stewart committed
424
    ( do L.String s <- lexP     -- Looks for "foo"
425
426
         return s
     +++
Don Stewart's avatar
Don Stewart committed
427
      readListPrecDefault       -- Looks for ['f','o','o']
428
    )                           -- (more generous than H2010 spec)
429
430

  readList = readListDefault
431

432
-- | @since 2.01
433
instance Read Bool where
434
435
  readPrec =
    parens
436
    ( do L.Ident s <- lexP
437
438
439
440
441
442
443
444
         case s of
           "True"  -> return True
           "False" -> return False
           _       -> pfail
    )

  readListPrec = readListPrecDefault
  readList     = readListDefault
445

446
-- | @since 2.01
447
instance Read Ordering where
448
449
  readPrec =
    parens
450
    ( do L.Ident s <- lexP
451
452
453
454
455
456
457
458
459
         case s of
           "LT" -> return LT
           "EQ" -> return EQ
           "GT" -> return GT
           _    -> pfail
    )

  readListPrec = readListPrecDefault
  readList     = readListDefault
460

461
462
deriving instance Read a => Read (NonEmpty a)

463
464
465
--------------------------------------------------------------
-- Structure instances of Read: Maybe, List etc
--------------------------------------------------------------
466

467
{-
468
469
470
471
472
For structured instances of Read we start using the precedences.  The
idea is then that 'parens (prec k p)' will fail immediately when trying
to parse it in a context with a higher precedence level than k. But if
there is one parenthesis parsed, then the required precedence level
drops to 0 again, and parsing inside p may succeed.
473

474
475
476
477
'appPrec' is just the precedence level of function application.  So,
if we are parsing function application, we'd better require the
precedence level to be at least 'appPrec'. Otherwise, we have to put
parentheses around it.
478

479
480
481
482
'step' is used to increase the precedence levels inside a
parser, and can be used to express left- or right- associativity. For
example, % is defined to be left associative, so we only increase
precedence on the right hand side.
483

484
485
486
487
Note how step is used in for example the Maybe parser to increase the
precedence beyond appPrec, so that basically only literals and
parenthesis-like objects such as (...) and [...] can be an argument to
'Just'.
488
-}
489

490
-- | @since 2.01
491
492
493
instance Read a => Read (Maybe a) where
  readPrec =
    parens
494
    (do expectP (L.Ident "Nothing")
495
496
497
        return Nothing
     +++
     prec appPrec (
498
499
        do expectP (L.Ident "Just")
           x <- step readPrec
500
           return (Just x))
501
502
503
504
505
    )

  readListPrec = readListPrecDefault
  readList     = readListDefault

506
-- | @since 2.01
507
instance Read a => Read [a] where
508
509
510
  {-# SPECIALISE instance Read [String] #-}
  {-# SPECIALISE instance Read [Char] #-}
  {-# SPECIALISE instance Read [Int] #-}
511
512
513
514
  readPrec     = readListPrec
  readListPrec = readListPrecDefault
  readList     = readListDefault

515
-- | @since 2.01
516
517
instance  (Ix a, Read a, Read b) => Read (Array a b)  where
    readPrec = parens $ prec appPrec $
518
               do expectP (L.Ident "array")
Ian Lynagh's avatar
Ian Lynagh committed
519
                  theBounds <- step readPrec
Don Stewart's avatar
Don Stewart committed
520
                  vals   <- step readPrec
Ian Lynagh's avatar
Ian Lynagh committed
521
                  return (array theBounds vals)
522
523
524
525

    readListPrec = readListPrecDefault
    readList     = readListDefault

526
-- | @since 2.01
527
instance Read L.Lexeme where
528
529
530
  readPrec     = lexP
  readListPrec = readListPrecDefault
  readList     = readListDefault
531

532
533
534
--------------------------------------------------------------
-- Numeric instances of Read
--------------------------------------------------------------
535

536
readNumber :: Num a => (L.Lexeme -> ReadPrec a) -> ReadPrec a
537
538
539
540
541
-- Read a signed number
readNumber convert =
  parens
  ( do x <- lexP
       case x of
542
543
         L.Symbol "-" -> do y <- lexP
                            n <- convert y
544
                            return (negate n)
545
546

         _   -> convert x
547
548
  )

549

550
convertInt :: Num a => L.Lexeme -> ReadPrec a
551
552
553
convertInt (L.Number n)
 | Just i <- L.numberToInteger n = return (fromInteger i)
convertInt _ = pfail
554

555
convertFrac :: forall a . RealFloat a => L.Lexeme -> ReadPrec a
556
557
convertFrac (L.Ident "NaN")      = return (0 / 0)
convertFrac (L.Ident "Infinity") = return (1 / 0)
558
559
560
561
convertFrac (L.Number n) = let resRange = floatRange (undefined :: a)
                           in case L.numberToRangedRational resRange n of
                              Nothing -> return (1 / 0)
                              Just rat -> return $ fromRational rat
562
convertFrac _            = pfail
sof's avatar
sof committed
563

564
-- | @since 2.01
565
instance Read Int where
566
  readPrec     = readNumber convertInt
567
568
569
  readListPrec = readListPrecDefault
  readList     = readListDefault

570
-- | @since 4.5.0.0
571
572
573
instance Read Word where
    readsPrec p s = [(fromInteger x, r) | (x, r) <- readsPrec p s]

574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
-- | @since 2.01
instance Read Word8 where
    readsPrec p s = [(fromIntegral (x::Int), r) | (x, r) <- readsPrec p s]

-- | @since 2.01
instance Read Word16 where
    readsPrec p s = [(fromIntegral (x::Int), r) | (x, r) <- readsPrec p s]

-- | @since 2.01
instance Read Word32 where
#if WORD_SIZE_IN_BITS < 33
    readsPrec p s = [(fromInteger x, r) | (x, r) <- readsPrec p s]
#else
    readsPrec p s = [(fromIntegral (x::Int), r) | (x, r) <- readsPrec p s]
#endif

-- | @since 2.01
instance Read Word64 where
    readsPrec p s = [(fromInteger x, r) | (x, r) <- readsPrec p s]

594
-- | @since 2.01
595
instance Read Integer where
596
  readPrec     = readNumber convertInt
597
598
599
  readListPrec = readListPrecDefault
  readList     = readListDefault

600
-- | @since 2.01
601
instance Read Float where
602
  readPrec     = readNumber convertFrac
603
604
605
  readListPrec = readListPrecDefault
  readList     = readListDefault

606
-- | @since 2.01
607
instance Read Double where
608
  readPrec     = readNumber convertFrac
609
610
611
  readListPrec = readListPrecDefault
  readList     = readListDefault

612
-- | @since 2.01
613
614
615
616
instance (Integral a, Read a) => Read (Ratio a) where
  readPrec =
    parens
    ( prec ratioPrec
617
618
619
      ( do x <- step readPrec
           expectP (L.Symbol "%")
           y <- step readPrec
620
621
622
623
624
625
           return (x % y)
      )
    )

  readListPrec = readListPrecDefault
  readList     = readListDefault
626
627


628
629
630
------------------------------------------------------------------------
-- Tuple instances of Read, up to size 15
------------------------------------------------------------------------
631

632
-- | @since 2.01
633
634
635
636
637
638
639
640
641
642
643
instance Read () where
  readPrec =
    parens
    ( paren
      ( return ()
      )
    )

  readListPrec = readListPrecDefault
  readList     = readListDefault

644
-- | @since 2.01
645
instance (Read a, Read b) => Read (a,b) where
646
  readPrec = wrap_tup read_tup2
647
648
  readListPrec = readListPrecDefault
  readList     = readListDefault
649

650
651
652
653
wrap_tup :: ReadPrec a -> ReadPrec a
wrap_tup p = parens (paren p)

read_comma :: ReadPrec ()
654
read_comma = expectP (L.Punc ",")
655
656
657
658

read_tup2 :: (Read a, Read b) => ReadPrec (a,b)
-- Reads "a , b"  no parens!
read_tup2 = do x <- readPrec
Don Stewart's avatar
Don Stewart committed
659
660
661
               read_comma
               y <- readPrec
               return (x,y)
662
663

read_tup4 :: (Read a, Read b, Read c, Read d) => ReadPrec (a,b,c,d)
Don Stewart's avatar
Don Stewart committed
664
665
666
667
read_tup4 = do  (a,b) <- read_tup2
                read_comma
                (c,d) <- read_tup2
                return (a,b,c,d)
668

669

670
read_tup8 :: (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h)
Don Stewart's avatar
Don Stewart committed
671
672
673
674
675
          => ReadPrec (a,b,c,d,e,f,g,h)
read_tup8 = do  (a,b,c,d) <- read_tup4
                read_comma
                (e,f,g,h) <- read_tup4
                return (a,b,c,d,e,f,g,h)
676
677


678
-- | @since 2.01
679
instance (Read a, Read b, Read c) => Read (a, b, c) where
680
681
  readPrec = wrap_tup (do { (a,b) <- read_tup2; read_comma
                          ; c <- readPrec
Don Stewart's avatar
Don Stewart committed
682
                          ; return (a,b,c) })
683
684
685
  readListPrec = readListPrecDefault
  readList     = readListDefault

686
-- | @since 2.01
687
instance (Read a, Read b, Read c, Read d) => Read (a, b, c, d) where
688
  readPrec = wrap_tup read_tup4
689
690
  readListPrec = readListPrecDefault
  readList     = readListDefault
691

692
-- | @since 2.01
693
instance (Read a, Read b, Read c, Read d, Read e) => Read (a, b, c, d, e) where
694
  readPrec = wrap_tup (do { (a,b,c,d) <- read_tup4; read_comma
Don Stewart's avatar
Don Stewart committed
695
696
                          ; e <- readPrec
                          ; return (a,b,c,d,e) })
697
698
699
  readListPrec = readListPrecDefault
  readList     = readListDefault

700
-- | @since 2.01
701
instance (Read a, Read b, Read c, Read d, Read e, Read f)
Don Stewart's avatar
Don Stewart committed
702
        => Read (a, b, c, d, e, f) where
703
  readPrec = wrap_tup (do { (a,b,c,d) <- read_tup4; read_comma
Don Stewart's avatar
Don Stewart committed
704
705
                          ; (e,f) <- read_tup2
                          ; return (a,b,c,d,e,f) })
706
707
708
  readListPrec = readListPrecDefault
  readList     = readListDefault

709
-- | @since 2.01
710
instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g)
Don Stewart's avatar
Don Stewart committed
711
        => Read (a, b, c, d, e, f, g) where
712
  readPrec = wrap_tup (do { (a,b,c,d) <- read_tup4; read_comma
Don Stewart's avatar
Don Stewart committed
713
714
715
                          ; (e,f) <- read_tup2; read_comma
                          ; g <- readPrec
                          ; return (a,b,c,d,e,f,g) })
716
717
718
  readListPrec = readListPrecDefault
  readList     = readListDefault

719
-- | @since 2.01
720
instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h)
Don Stewart's avatar
Don Stewart committed
721
        => Read (a, b, c, d, e, f, g, h) where
722
723
724
725
  readPrec     = wrap_tup read_tup8
  readListPrec = readListPrecDefault
  readList     = readListDefault

726
-- | @since 2.01
727
instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
Don Stewart's avatar
Don Stewart committed
728
729
          Read i)
        => Read (a, b, c, d, e, f, g, h, i) where
730
  readPrec = wrap_tup (do { (a,b,c,d,e,f,g,h) <- read_tup8; read_comma
Don Stewart's avatar
Don Stewart committed
731
732
                          ; i <- readPrec
                          ; return (a,b,c,d,e,f,g,h,i) })
733
734
735
  readListPrec = readListPrecDefault
  readList     = readListDefault

736
-- | @since 2.01
737
instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
Don Stewart's avatar
Don Stewart committed
738
739
          Read i, Read j)
        => Read (a, b, c, d, e, f, g, h, i, j) where
740
  readPrec = wrap_tup (do { (a,b,c,d,e,f,g,h) <- read_tup8; read_comma
Don Stewart's avatar
Don Stewart committed
741
742
                          ; (i,j) <- read_tup2
                          ; return (a,b,c,d,e,f,g,h,i,j) })
743
744
745
  readListPrec = readListPrecDefault
  readList     = readListDefault

746
-- | @since 2.01
747
instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
Don Stewart's avatar
Don Stewart committed
748
749
          Read i, Read j, Read k)
        => Read (a, b, c, d, e, f, g, h, i, j, k) where
750
  readPrec = wrap_tup (do { (a,b,c,d,e,f,g,h) <- read_tup8; read_comma
Don Stewart's avatar
Don Stewart committed
751
752
753
                          ; (i,j) <- read_tup2; read_comma
                          ; k <- readPrec
                          ; return (a,b,c,d,e,f,g,h,i,j,k) })
754
755
756
  readListPrec = readListPrecDefault
  readList     = readListDefault

757
-- | @since 2.01
758
instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
Don Stewart's avatar
Don Stewart committed
759
760
          Read i, Read j, Read k, Read l)
        => Read (a, b, c, d, e, f, g, h, i, j, k, l) where
761
  readPrec = wrap_tup (do { (a,b,c,d,e,f,g,h) <- read_tup8; read_comma
Don Stewart's avatar
Don Stewart committed
762
763
                          ; (i,j,k,l) <- read_tup4
                          ; return (a,b,c,d,e,f,g,h,i,j,k,l) })
764
765
766
  readListPrec = readListPrecDefault
  readList     = readListDefault

767
-- | @since 2.01
768
instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
Don Stewart's avatar
Don Stewart committed
769
770
          Read i, Read j, Read k, Read l, Read m)
        => Read (a, b, c, d, e, f, g, h, i, j, k, l, m) where
771
  readPrec = wrap_tup (do { (a,b,c,d,e,f,g,h) <- read_tup8; read_comma
Don Stewart's avatar
Don Stewart committed
772
773
774
                          ; (i,j,k,l) <- read_tup4; read_comma
                          ; m <- readPrec
                          ; return (a,b,c,d,e,f,g,h,i,j,k,l,m) })
775
776
777
  readListPrec = readListPrecDefault
  readList     = readListDefault

778
-- | @since 2.01
779
instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
Don Stewart's avatar
Don Stewart committed
780
781
          Read i, Read j, Read k, Read l, Read m, Read n)
        => Read (a, b, c, d, e, f, g, h, i, j, k, l, m, n) where
782
  readPrec = wrap_tup (do { (a,b,c,d,e,f,g,h) <- read_tup8; read_comma
Don Stewart's avatar
Don Stewart committed
783
784
785
                          ; (i,j,k,l) <- read_tup4; read_comma
                          ; (m,n) <- read_tup2
                          ; return (a,b,c,d,e,f,g,h,i,j,k,l,m,n) })
786
787
  readListPrec = readListPrecDefault
  readList     = readListDefault
788

789
-- | @since 2.01
790
instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
Don Stewart's avatar
Don Stewart committed
791
792
          Read i, Read j, Read k, Read l, Read m, Read n, Read o)
        => Read (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) where
793
  readPrec = wrap_tup (do { (a,b,c,d,e,f,g,h) <- read_tup8; read_comma
Don Stewart's avatar
Don Stewart committed
794
795
796
797
                          ; (i,j,k,l) <- read_tup4; read_comma
                          ; (m,n) <- read_tup2; read_comma
                          ; o <- readPrec
                          ; return (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) })
798
799
  readListPrec = readListPrecDefault
  readList     = readListDefault