{-# LANGUAGE Trustworthy #-}
{-# LANGUAGE CPP, NoImplicitPrelude, StandaloneDeriving, ScopedTypeVariables #-}
{-# OPTIONS_HADDOCK not-home #-}

-----------------------------------------------------------------------------
-- |
-- Module      :  GHC.Read
-- Copyright   :  (c) The University of Glasgow, 1994-2002
-- License     :  see libraries/base/LICENSE
--
-- Maintainer  :  cvs-ghc@haskell.org
-- Stability   :  internal
-- Portability :  non-portable (GHC Extensions)
--
-- The 'Read' class and instances for basic data types.
--
-----------------------------------------------------------------------------

module GHC.Read
  ( Read(..)   -- class

  -- ReadS type
  , ReadS

  -- H2010 compatibility
  , lex
  , lexLitChar
  , readLitChar
  , lexDigits

  -- defining readers
  , lexP, expectP
  , paren
  , parens
  , list
  , choose
  , readListDefault, readListPrecDefault
  , readNumber
  , readField
  , readFieldHash
  , readSymField

  -- Temporary
  , readParen
  )
 where

#include "MachDeps.h"

import qualified Text.ParserCombinators.ReadP as P

import Text.ParserCombinators.ReadP
  ( ReadS
  , readP_to_S
  )

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

import Text.ParserCombinators.ReadPrec

import Data.Maybe

import GHC.Unicode
import GHC.Num
import GHC.Real
import GHC.Float
import GHC.Show
import GHC.Base
import GHC.Arr
import GHC.Word
import GHC.List (filter)


-- | @'readParen' 'True' p@ parses what @p@ parses, but surrounded with
-- parentheses.
--
-- @'readParen' 'False' p@ parses what @p@ parses, but optionally
-- surrounded with parentheses.
readParen       :: Bool -> ReadS a -> ReadS a
-- A Haskell 2010 function
readParen :: Bool -> ReadS a -> ReadS a
readParen Bool
b ReadS a
g   =  if Bool
b then ReadS a
mandatory else ReadS a
optional
                   where optional :: ReadS a
optional String
r  = ReadS a
g String
r [(a, String)] -> [(a, String)] -> [(a, String)]
forall a. [a] -> [a] -> [a]
++ ReadS a
mandatory String
r
                         mandatory :: ReadS a
mandatory String
r = do
                                (String
"(",String
s) <- ReadS String
lex String
r
                                (a
x,String
t)   <- ReadS a
optional String
s
                                (String
")",String
u) <- ReadS String
lex String
t
                                (a, String) -> [(a, String)]
forall (m :: * -> *) a. Monad m => a -> m a
External instance of the constraint type Monad []
return (a
x,String
u)

-- | 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
--
-- the derived instance of 'Read' in Haskell 2010 is equivalent to
--
-- > instance (Read a) => Read (Tree a) where
-- >
-- >         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)
-- >                          (\r -> [(u:^:v,w) |
-- >                                  (u,s) <- readsPrec (up_prec+1) r,
-- >                                  (":^:",t) <- lex s,
-- >                                  (v,w) <- readsPrec (up_prec+1) t]) r
-- >
-- >           where app_prec = 10
-- >                 up_prec = 5
--
-- Note that right-associativity of @:^:@ is unused.
--
-- 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
--
-- 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'
-- @

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

  -- | 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.

  readsPrec    :: Int   -- ^ the operator precedence of the enclosing
                        -- context (a number from @0@ to @11@).
                        -- Function application has precedence @10@.
                -> ReadS a

  -- | 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.
  readList     :: ReadS [a]

  -- | Proposed replacement for 'readsPrec' using new-style parsers (GHC only).
  readPrec     :: ReadPrec a

  -- | Proposed replacement for 'readList' using new-style parsers (GHC only).
  -- The default definition uses 'readList'.  Instances that define 'readPrec'
  -- should also define 'readListPrec' as 'readListPrecDefault'.
  readListPrec :: ReadPrec [a]

  -- default definitions
  readsPrec    = ReadPrec a -> Int -> ReadS a
forall a. ReadPrec a -> Int -> ReadS a
readPrec_to_S ReadPrec a
forall a. Read a => ReadPrec a
Evidence bound by a type signature of the constraint type Read a
readPrec
  readList     = ReadPrec [a] -> Int -> ReadS [a]
forall a. ReadPrec a -> Int -> ReadS a
readPrec_to_S (ReadPrec a -> ReadPrec [a]
forall a. ReadPrec a -> ReadPrec [a]
list ReadPrec a
forall a. Read a => ReadPrec a
Evidence bound by a type signature of the constraint type Read a
readPrec) Int
0
  readPrec     = (Int -> ReadS a) -> ReadPrec a
forall a. (Int -> ReadS a) -> ReadPrec a
readS_to_Prec Int -> ReadS a
forall a. Read a => Int -> ReadS a
Evidence bound by a type signature of the constraint type Read a
readsPrec
  readListPrec = (Int -> ReadS [a]) -> ReadPrec [a]
forall a. (Int -> ReadS a) -> ReadPrec a
readS_to_Prec (\Int
_ -> ReadS [a]
forall a. Read a => ReadS [a]
Evidence bound by a type signature of the constraint type Read a
readList)

readListDefault :: Read a => ReadS [a]
-- ^ 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'.
readListDefault :: ReadS [a]
readListDefault = ReadPrec [a] -> Int -> ReadS [a]
forall a. ReadPrec a -> Int -> ReadS a
readPrec_to_S ReadPrec [a]
forall a. Read a => ReadPrec [a]
Evidence bound by a type signature of the constraint type Read a
readListPrec Int
0

readListPrecDefault :: Read a => ReadPrec [a]
-- ^ A possible replacement definition for the 'readListPrec' method,
--   defined using 'readPrec' (GHC only).
readListPrecDefault :: ReadPrec [a]
readListPrecDefault = ReadPrec a -> ReadPrec [a]
forall a. ReadPrec a -> ReadPrec [a]
list ReadPrec a
forall a. Read a => ReadPrec a
Evidence bound by a type signature of the constraint type Read a
readPrec

------------------------------------------------------------------------
-- H2010 compatibility

-- | 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
lex :: ReadS String             -- As defined by H2010
lex :: ReadS String
lex String
s  = ReadP String -> ReadS String
forall a. ReadP a -> ReadS a
readP_to_S ReadP String
L.hsLex String
s

-- | Read a string representation of a character, using Haskell
-- source-language escape conventions.  For example:
--
-- > lexLitChar  "\\nHello"  =  [("\\n", "Hello")]
--
lexLitChar :: ReadS String      -- As defined by H2010
lexLitChar :: ReadS String
lexLitChar = ReadP String -> ReadS String
forall a. ReadP a -> ReadS a
readP_to_S (do { (String
s, Char
_) <- ReadP Char -> ReadP (String, Char)
forall a. ReadP a -> ReadP (String, a)
P.gather ReadP Char
L.lexChar ;
                              let s' :: String
s' = String -> String
removeNulls String
s in
                              String -> ReadP String
forall (m :: * -> *) a. Monad m => a -> m a
External instance of the constraint type Monad ReadP
return String
s' })
    where
    -- remove nulls from end of the character if they exist
    removeNulls :: String -> String
removeNulls [] = []
    removeNulls (Char
'\\':Char
'&':String
xs) = String -> String
removeNulls String
xs
    removeNulls (Char
first:String
rest) = Char
first Char -> String -> String
forall a. a -> [a] -> [a]
: String -> String
removeNulls String
rest
        -- There was a skipSpaces before the P.gather L.lexChar,
        -- but that seems inconsistent with readLitChar

-- | 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")]
--
readLitChar :: ReadS Char       -- As defined by H2010
readLitChar :: ReadS Char
readLitChar = ReadP Char -> ReadS Char
forall a. ReadP a -> ReadS a
readP_to_S ReadP Char
L.lexChar

-- | Reads a non-empty string of decimal digits.
lexDigits :: ReadS String
lexDigits :: ReadS String
lexDigits = ReadP String -> ReadS String
forall a. ReadP a -> ReadS a
readP_to_S ((Char -> Bool) -> ReadP String
P.munch1 Char -> Bool
isDigit)

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

lexP :: ReadPrec L.Lexeme
-- ^ Parse a single lexeme
lexP :: ReadPrec Lexeme
lexP = ReadP Lexeme -> ReadPrec Lexeme
forall a. ReadP a -> ReadPrec a
lift ReadP Lexeme
L.lex

expectP :: L.Lexeme -> ReadPrec ()
expectP :: Lexeme -> ReadPrec ()
expectP Lexeme
lexeme = ReadP () -> ReadPrec ()
forall a. ReadP a -> ReadPrec a
lift (Lexeme -> ReadP ()
L.expect Lexeme
lexeme)

expectCharP :: Char -> ReadPrec a -> ReadPrec a
expectCharP :: Char -> ReadPrec a -> ReadPrec a
expectCharP Char
c ReadPrec a
a = do
  Char
q <- ReadPrec Char
get
  if Char
q Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
External instance of the constraint type Eq Char
== Char
c
    then ReadPrec a
a
    else ReadPrec a
forall a. ReadPrec a
pfail
{-# INLINE expectCharP #-}

skipSpacesThenP :: ReadPrec a -> ReadPrec a
skipSpacesThenP :: ReadPrec a -> ReadPrec a
skipSpacesThenP ReadPrec a
m =
  do String
s <- ReadPrec String
look
     String -> ReadPrec a
skip String
s
 where
   skip :: String -> ReadPrec a
skip (Char
c:String
s) | Char -> Bool
isSpace Char
c = ReadPrec Char
get ReadPrec Char -> ReadPrec a -> ReadPrec a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
External instance of the constraint type Applicative ReadPrec
*> String -> ReadPrec a
skip String
s
   skip String
_ = ReadPrec a
m

paren :: ReadPrec a -> ReadPrec a
-- ^ @(paren p)@ parses \"(P0)\"
--      where @p@ parses \"P0\" in precedence context zero
paren :: ReadPrec a -> ReadPrec a
paren ReadPrec a
p = ReadPrec a -> ReadPrec a
forall a. ReadPrec a -> ReadPrec a
skipSpacesThenP (ReadPrec a -> ReadPrec a
forall a. ReadPrec a -> ReadPrec a
paren' ReadPrec a
p)

paren' :: ReadPrec a -> ReadPrec a
paren' :: ReadPrec a -> ReadPrec a
paren' ReadPrec a
p = Char -> ReadPrec a -> ReadPrec a
forall a. Char -> ReadPrec a -> ReadPrec a
expectCharP Char
'(' (ReadPrec a -> ReadPrec a) -> ReadPrec a -> ReadPrec a
forall a b. (a -> b) -> a -> b
$ ReadPrec a -> ReadPrec a
forall a. ReadPrec a -> ReadPrec a
reset ReadPrec a
p ReadPrec a -> (a -> ReadPrec a) -> ReadPrec a
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
External instance of the constraint type Monad ReadPrec
>>= \a
x ->
              ReadPrec a -> ReadPrec a
forall a. ReadPrec a -> ReadPrec a
skipSpacesThenP (Char -> ReadPrec a -> ReadPrec a
forall a. Char -> ReadPrec a -> ReadPrec a
expectCharP Char
')' (a -> ReadPrec a
forall (f :: * -> *) a. Applicative f => a -> f a
External instance of the constraint type Applicative ReadPrec
pure a
x))

parens :: ReadPrec a -> ReadPrec a
-- ^ @(parens p)@ parses \"P\", \"(P0)\", \"((P0))\", etc,
--      where @p@ parses \"P\"  in the current precedence context
--          and parses \"P0\" in precedence context zero
parens :: ReadPrec a -> ReadPrec a
parens ReadPrec a
p = ReadPrec a
optional
  where
    optional :: ReadPrec a
optional = ReadPrec a -> ReadPrec a
forall a. ReadPrec a -> ReadPrec a
skipSpacesThenP (ReadPrec a
p ReadPrec a -> ReadPrec a -> ReadPrec a
forall a. ReadPrec a -> ReadPrec a -> ReadPrec a
+++ ReadPrec a
mandatory)
    mandatory :: ReadPrec a
mandatory = ReadPrec a -> ReadPrec a
forall a. ReadPrec a -> ReadPrec a
paren' ReadPrec a
optional

list :: ReadPrec a -> ReadPrec [a]
-- ^ @(list p)@ parses a list of things parsed by @p@,
-- using the usual square-bracket syntax.
list :: ReadPrec a -> ReadPrec [a]
list ReadPrec a
readx =
  ReadPrec [a] -> ReadPrec [a]
forall a. ReadPrec a -> ReadPrec a
parens
  ( do Lexeme -> ReadPrec ()
expectP (String -> Lexeme
L.Punc String
"[")
       (Bool -> ReadPrec [a]
listRest Bool
False ReadPrec [a] -> ReadPrec [a] -> ReadPrec [a]
forall a. ReadPrec a -> ReadPrec a -> ReadPrec a
+++ ReadPrec [a]
listNext)
  )
 where
  listRest :: Bool -> ReadPrec [a]
listRest Bool
started =
    do L.Punc String
c <- ReadPrec Lexeme
lexP
       case String
c of
         String
"]"           -> [a] -> ReadPrec [a]
forall (m :: * -> *) a. Monad m => a -> m a
External instance of the constraint type Monad ReadPrec
return []
         String
"," | Bool
started -> ReadPrec [a]
listNext
         String
_             -> ReadPrec [a]
forall a. ReadPrec a
pfail

  listNext :: ReadPrec [a]
listNext =
    do a
x  <- ReadPrec a -> ReadPrec a
forall a. ReadPrec a -> ReadPrec a
reset ReadPrec a
readx
       [a]
xs <- Bool -> ReadPrec [a]
listRest Bool
True
       [a] -> ReadPrec [a]
forall (m :: * -> *) a. Monad m => a -> m a
External instance of the constraint type Monad ReadPrec
return (a
xa -> [a] -> [a]
forall a. a -> [a] -> [a]
:[a]
xs)

choose :: [(String, ReadPrec a)] -> ReadPrec a
-- ^ Parse the specified lexeme and continue as specified.
-- Esp useful for nullary constructors; e.g.
--    @choose [(\"A\", return A), (\"B\", return B)]@
-- We match both Ident and Symbol because the constructor
-- might be an operator eg @(:~:)@
choose :: [(String, ReadPrec a)] -> ReadPrec a
choose [(String, ReadPrec a)]
sps = ((String, ReadPrec a) -> ReadPrec a -> ReadPrec a)
-> ReadPrec a -> [(String, ReadPrec a)] -> ReadPrec a
forall a b. (a -> b -> b) -> b -> [a] -> b
foldr (ReadPrec a -> ReadPrec a -> ReadPrec a
forall a. ReadPrec a -> ReadPrec a -> ReadPrec a
(+++) (ReadPrec a -> ReadPrec a -> ReadPrec a)
-> ((String, ReadPrec a) -> ReadPrec a)
-> (String, ReadPrec a)
-> ReadPrec a
-> ReadPrec a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String, ReadPrec a) -> ReadPrec a
forall {b}. (String, ReadPrec b) -> ReadPrec b
try_one) ReadPrec a
forall a. ReadPrec a
pfail [(String, ReadPrec a)]
sps
           where
             try_one :: (String, ReadPrec b) -> ReadPrec b
try_one (String
s,ReadPrec b
p) = do { Lexeme
token <- ReadPrec Lexeme
lexP ;
                                  case Lexeme
token of
                                    L.Ident String
s'  | String
sString -> String -> Bool
forall a. Eq a => a -> a -> Bool
External instance of the constraint type forall a. Eq a => Eq [a]
External instance of the constraint type Eq Char
==String
s' -> ReadPrec b
p
                                    L.Symbol String
s' | String
sString -> String -> Bool
forall a. Eq a => a -> a -> Bool
External instance of the constraint type forall a. Eq a => Eq [a]
External instance of the constraint type Eq Char
==String
s' -> ReadPrec b
p
                                    Lexeme
_other              -> ReadPrec b
forall a. ReadPrec a
pfail }

-- 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 :: String -> ReadPrec a -> ReadPrec a
readField String
fieldName ReadPrec a
readVal = do
        Lexeme -> ReadPrec ()
expectP (String -> Lexeme
L.Ident String
fieldName)
        Lexeme -> ReadPrec ()
expectP (String -> Lexeme
L.Punc String
"=")
        ReadPrec a
readVal
{-# NOINLINE readField #-}

-- See Note [Why readField]

-- | 'Read' parser for a record field, of the form @fieldName#=value@. That is,
-- an alphanumeric identifier @fieldName@ followed by the symbol @#@. The
-- second argument is a parser for the field value.
--
-- Note that 'readField' does not suffice for this purpose due to
-- <https://gitlab.haskell.org/ghc/ghc/issues/5041 #5041>.
readFieldHash :: String -> ReadPrec a -> ReadPrec a
readFieldHash :: String -> ReadPrec a -> ReadPrec a
readFieldHash String
fieldName ReadPrec a
readVal = do
        Lexeme -> ReadPrec ()
expectP (String -> Lexeme
L.Ident String
fieldName)
        Lexeme -> ReadPrec ()
expectP (String -> Lexeme
L.Symbol String
"#")
        Lexeme -> ReadPrec ()
expectP (String -> Lexeme
L.Punc String
"=")
        ReadPrec a
readVal
{-# NOINLINE readFieldHash #-}

-- 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 :: String -> ReadPrec a -> ReadPrec a
readSymField String
fieldName ReadPrec a
readVal = do
        Lexeme -> ReadPrec ()
expectP (String -> Lexeme
L.Punc String
"(")
        Lexeme -> ReadPrec ()
expectP (String -> Lexeme
L.Symbol String
fieldName)
        Lexeme -> ReadPrec ()
expectP (String -> Lexeme
L.Punc String
")")
        Lexeme -> ReadPrec ()
expectP (String -> Lexeme
L.Punc String
"=")
        ReadPrec a
readVal
{-# NOINLINE readSymField #-}


-- Note [Why readField]
--
-- Previously, the code for automatically deriving Read instance (in
-- typecheck/GHC.Tc.Deriv.Generate.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 performance 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 #14364.


--------------------------------------------------------------
-- Simple instances of Read
--------------------------------------------------------------

-- | @since 2.01
deriving instance Read GeneralCategory

-- | @since 2.01
instance Read Char where
  readPrec :: ReadPrec Char
readPrec =
    ReadPrec Char -> ReadPrec Char
forall a. ReadPrec a -> ReadPrec a
parens
    ( do L.Char Char
c <- ReadPrec Lexeme
lexP
         Char -> ReadPrec Char
forall (m :: * -> *) a. Monad m => a -> m a
External instance of the constraint type Monad ReadPrec
return Char
c
    )

  readListPrec :: ReadPrec String
readListPrec =
    ReadPrec String -> ReadPrec String
forall a. ReadPrec a -> ReadPrec a
parens
    ( do L.String String
s <- ReadPrec Lexeme
lexP     -- Looks for "foo"
         String -> ReadPrec String
forall (m :: * -> *) a. Monad m => a -> m a
External instance of the constraint type Monad ReadPrec
return String
s
     ReadPrec String -> ReadPrec String -> ReadPrec String
forall a. ReadPrec a -> ReadPrec a -> ReadPrec a
+++
      ReadPrec String
forall a. Read a => ReadPrec [a]
Instance of class: Read of the constraint type Read Char
readListPrecDefault       -- Looks for ['f','o','o']
    )                           -- (more generous than H2010 spec)

  readList :: ReadS String
readList = ReadS String
forall a. Read a => ReadS [a]
Instance of class: Read of the constraint type Read Char
readListDefault

-- | @since 2.01
instance Read Bool where
  readPrec :: ReadPrec Bool
readPrec =
    ReadPrec Bool -> ReadPrec Bool
forall a. ReadPrec a -> ReadPrec a
parens
    ( do L.Ident String
s <- ReadPrec Lexeme
lexP
         case String
s of
           String
"True"  -> Bool -> ReadPrec Bool
forall (m :: * -> *) a. Monad m => a -> m a
External instance of the constraint type Monad ReadPrec
return Bool
True
           String
"False" -> Bool -> ReadPrec Bool
forall (m :: * -> *) a. Monad m => a -> m a
External instance of the constraint type Monad ReadPrec
return Bool
False
           String
_       -> ReadPrec Bool
forall a. ReadPrec a
pfail
    )

  readListPrec :: ReadPrec [Bool]
readListPrec = ReadPrec [Bool]
forall a. Read a => ReadPrec [a]
Instance of class: Read of the constraint type Read Bool
readListPrecDefault
  readList :: ReadS [Bool]
readList     = ReadS [Bool]
forall a. Read a => ReadS [a]
Instance of class: Read of the constraint type Read Bool
readListDefault

-- | @since 2.01
instance Read Ordering where
  readPrec :: ReadPrec Ordering
readPrec =
    ReadPrec Ordering -> ReadPrec Ordering
forall a. ReadPrec a -> ReadPrec a
parens
    ( do L.Ident String
s <- ReadPrec Lexeme
lexP
         case String
s of
           String
"LT" -> Ordering -> ReadPrec Ordering
forall (m :: * -> *) a. Monad m => a -> m a
External instance of the constraint type Monad ReadPrec
return Ordering
LT
           String
"EQ" -> Ordering -> ReadPrec Ordering
forall (m :: * -> *) a. Monad m => a -> m a
External instance of the constraint type Monad ReadPrec
return Ordering
EQ
           String
"GT" -> Ordering -> ReadPrec Ordering
forall (m :: * -> *) a. Monad m => a -> m a
External instance of the constraint type Monad ReadPrec
return Ordering
GT
           String
_    -> ReadPrec Ordering
forall a. ReadPrec a
pfail
    )

  readListPrec :: ReadPrec [Ordering]
readListPrec = ReadPrec [Ordering]
forall a. Read a => ReadPrec [a]
Instance of class: Read of the constraint type Read Ordering
readListPrecDefault
  readList :: ReadS [Ordering]
readList     = ReadS [Ordering]
forall a. Read a => ReadS [a]
Instance of class: Read of the constraint type Read Ordering
readListDefault

-- | @since 4.11.0.0
deriving instance Read a => Read (NonEmpty a)

--------------------------------------------------------------
-- Structure instances of Read: Maybe, List etc
--------------------------------------------------------------

{-
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.

'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.

'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.

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'.
-}

-- | @since 2.01
instance Read a => Read (Maybe a) where
  readPrec :: ReadPrec (Maybe a)
readPrec =
    ReadPrec (Maybe a) -> ReadPrec (Maybe a)
forall a. ReadPrec a -> ReadPrec a
parens
    (do Lexeme -> ReadPrec ()
expectP (String -> Lexeme
L.Ident String
"Nothing")
        Maybe a -> ReadPrec (Maybe a)
forall (m :: * -> *) a. Monad m => a -> m a
External instance of the constraint type Monad ReadPrec
return Maybe a
forall a. Maybe a
Nothing
     ReadPrec (Maybe a) -> ReadPrec (Maybe a) -> ReadPrec (Maybe a)
forall a. ReadPrec a -> ReadPrec a -> ReadPrec a
+++
     Int -> ReadPrec (Maybe a) -> ReadPrec (Maybe a)
forall a. Int -> ReadPrec a -> ReadPrec a
prec Int
appPrec (
        do Lexeme -> ReadPrec ()
expectP (String -> Lexeme
L.Ident String
"Just")
           a
x <- ReadPrec a -> ReadPrec a
forall a. ReadPrec a -> ReadPrec a
step ReadPrec a
forall a. Read a => ReadPrec a
Evidence bound by a type signature of the constraint type Read a
readPrec
           Maybe a -> ReadPrec (Maybe a)
forall (m :: * -> *) a. Monad m => a -> m a
External instance of the constraint type Monad ReadPrec
return (a -> Maybe a
forall a. a -> Maybe a
Just a
x))
    )

  readListPrec :: ReadPrec [Maybe a]
readListPrec = ReadPrec [Maybe a]
forall a. Read a => ReadPrec [a]
Instance of class: Read of the constraint type forall a. Read a => Read (Maybe a)
Evidence bound by a type signature of the constraint type Read a
readListPrecDefault
  readList :: ReadS [Maybe a]
readList     = ReadS [Maybe a]
forall a. Read a => ReadS [a]
Instance of class: Read of the constraint type forall a. Read a => Read (Maybe a)
Evidence bound by a type signature of the constraint type Read a
readListDefault

-- | @since 2.01
instance Read a => Read [a] where
  {-# SPECIALISE instance Read [String] #-}
  {-# SPECIALISE instance Read [Char] #-}
  {-# SPECIALISE instance Read [Int] #-}
  readPrec :: ReadPrec [a]
readPrec     = ReadPrec [a]
forall a. Read a => ReadPrec [a]
Evidence bound by a type signature of the constraint type Read a
readListPrec
  readListPrec :: ReadPrec [[a]]
readListPrec = ReadPrec [[a]]
forall a. Read a => ReadPrec [a]
Instance of class: Read of the constraint type forall a. Read a => Read [a]
Evidence bound by a type signature of the constraint type Read a
readListPrecDefault
  readList :: ReadS [[a]]
readList     = ReadS [[a]]
forall a. Read a => ReadS [a]
Instance of class: Read of the constraint type forall a. Read a => Read [a]
Evidence bound by a type signature of the constraint type Read a
readListDefault

-- | @since 2.01
instance  (Ix a, Read a, Read b) => Read (Array a b)  where
    readPrec :: ReadPrec (Array a b)
readPrec = ReadPrec (Array a b) -> ReadPrec (Array a b)
forall a. ReadPrec a -> ReadPrec a
parens (ReadPrec (Array a b) -> ReadPrec (Array a b))
-> ReadPrec (Array a b) -> ReadPrec (Array a b)
forall a b. (a -> b) -> a -> b
$ Int -> ReadPrec (Array a b) -> ReadPrec (Array a b)
forall a. Int -> ReadPrec a -> ReadPrec a
prec Int
appPrec (ReadPrec (Array a b) -> ReadPrec (Array a b))
-> ReadPrec (Array a b) -> ReadPrec (Array a b)
forall a b. (a -> b) -> a -> b
$
               do Lexeme -> ReadPrec ()
expectP (String -> Lexeme
L.Ident String
"array")
                  (a, a)
theBounds <- ReadPrec (a, a) -> ReadPrec (a, a)
forall a. ReadPrec a -> ReadPrec a
step ReadPrec (a, a)
forall a. Read a => ReadPrec a
Instance of class: Read of the constraint type forall a b. (Read a, Read b) => Read (a, b)
Evidence bound by a type signature of the constraint type Read a
readPrec
                  [(a, b)]
vals   <- ReadPrec [(a, b)] -> ReadPrec [(a, b)]
forall a. ReadPrec a -> ReadPrec a
step ReadPrec [(a, b)]
forall a. Read a => ReadPrec a
Instance of class: Read of the constraint type forall a. Read a => Read [a]
Instance of class: Read of the constraint type forall a b. (Read a, Read b) => Read (a, b)
Evidence bound by a type signature of the constraint type Read a
Evidence bound by a type signature of the constraint type Read b
readPrec
                  Array a b -> ReadPrec (Array a b)
forall (m :: * -> *) a. Monad m => a -> m a
External instance of the constraint type Monad ReadPrec
return ((a, a) -> [(a, b)] -> Array a b
forall i e. Ix i => (i, i) -> [(i, e)] -> Array i e
Evidence bound by a type signature of the constraint type Ix a
array (a, a)
theBounds [(a, b)]
vals)

    readListPrec :: ReadPrec [Array a b]
readListPrec = ReadPrec [Array a b]
forall a. Read a => ReadPrec [a]
Instance of class: Read of the constraint type forall a b. (Ix a, Read a, Read b) => Read (Array a b)
Evidence bound by a type signature of the constraint type Ix a
Evidence bound by a type signature of the constraint type Read a
Evidence bound by a type signature of the constraint type Read b
readListPrecDefault
    readList :: ReadS [Array a b]
readList     = ReadS [Array a b]
forall a. Read a => ReadS [a]
Instance of class: Read of the constraint type forall a b. (Ix a, Read a, Read b) => Read (Array a b)
Evidence bound by a type signature of the constraint type Ix a
Evidence bound by a type signature of the constraint type Read a
Evidence bound by a type signature of the constraint type Read b
readListDefault

-- | @since 2.01
instance Read L.Lexeme where
  readPrec :: ReadPrec Lexeme
readPrec     = ReadPrec Lexeme
lexP
  readListPrec :: ReadPrec [Lexeme]
readListPrec = ReadPrec [Lexeme]
forall a. Read a => ReadPrec [a]
Instance of class: Read of the constraint type Read Lexeme
readListPrecDefault
  readList :: ReadS [Lexeme]
readList     = ReadS [Lexeme]
forall a. Read a => ReadS [a]
Instance of class: Read of the constraint type Read Lexeme
readListDefault

--------------------------------------------------------------
-- Numeric instances of Read
--------------------------------------------------------------

readNumber :: Num a => (L.Lexeme -> ReadPrec a) -> ReadPrec a
-- Read a signed number
readNumber :: (Lexeme -> ReadPrec a) -> ReadPrec a
readNumber Lexeme -> ReadPrec a
convert =
  ReadPrec a -> ReadPrec a
forall a. ReadPrec a -> ReadPrec a
parens
  ( do Lexeme
x <- ReadPrec Lexeme
lexP
       case Lexeme
x of
         L.Symbol String
"-" -> do Lexeme
y <- ReadPrec Lexeme
lexP
                            a
n <- Lexeme -> ReadPrec a
convert Lexeme
y
                            a -> ReadPrec a
forall (m :: * -> *) a. Monad m => a -> m a
External instance of the constraint type Monad ReadPrec
return (a -> a
forall a. Num a => a -> a
Evidence bound by a type signature of the constraint type Num a
negate a
n)

         Lexeme
_   -> Lexeme -> ReadPrec a
convert Lexeme
x
  )


convertInt :: Num a => L.Lexeme -> ReadPrec a
convertInt :: Lexeme -> ReadPrec a
convertInt (L.Number Number
n)
 | Just Integer
i <- Number -> Maybe Integer
L.numberToInteger Number
n = a -> ReadPrec a
forall (m :: * -> *) a. Monad m => a -> m a
External instance of the constraint type Monad ReadPrec
return (Integer -> a
forall a. Num a => Integer -> a
Evidence bound by a type signature of the constraint type Num a
fromInteger Integer
i)
convertInt Lexeme
_ = ReadPrec a
forall a. ReadPrec a
pfail

convertFrac :: forall a . RealFloat a => L.Lexeme -> ReadPrec a
convertFrac :: Lexeme -> ReadPrec a
convertFrac (L.Ident String
"NaN")      = a -> ReadPrec a
forall (m :: * -> *) a. Monad m => a -> m a
External instance of the constraint type Monad ReadPrec
return (a
0 a -> a -> a
forall a. Fractional a => a -> a -> a
External instance of the constraint type forall a. RealFrac a => Fractional a
External instance of the constraint type forall a. RealFloat a => RealFrac a
Evidence bound by a type signature of the constraint type RealFloat a
/ a
0)
convertFrac (L.Ident String
"Infinity") = a -> ReadPrec a
forall (m :: * -> *) a. Monad m => a -> m a
External instance of the constraint type Monad ReadPrec
return (a
1 a -> a -> a
forall a. Fractional a => a -> a -> a
External instance of the constraint type forall a. RealFrac a => Fractional a
External instance of the constraint type forall a. RealFloat a => RealFrac a
Evidence bound by a type signature of the constraint type RealFloat a
/ a
0)
convertFrac (L.Number Number
n) = let resRange :: (Int, Int)
resRange = a -> (Int, Int)
forall a. RealFloat a => a -> (Int, Int)
Evidence bound by a type signature of the constraint type RealFloat a
floatRange (a
forall a. HasCallStack => a
undefined :: a)
                           in case (Int, Int) -> Number -> Maybe Rational
L.numberToRangedRational (Int, Int)
resRange Number
n of
                              Maybe Rational
Nothing -> a -> ReadPrec a
forall (m :: * -> *) a. Monad m => a -> m a
External instance of the constraint type Monad ReadPrec
return (a
1 a -> a -> a
forall a. Fractional a => a -> a -> a
External instance of the constraint type forall a. RealFrac a => Fractional a
External instance of the constraint type forall a. RealFloat a => RealFrac a
Evidence bound by a type signature of the constraint type RealFloat a
/ a
0)
                              Just Rational
rat -> a -> ReadPrec a
forall (m :: * -> *) a. Monad m => a -> m a
External instance of the constraint type Monad ReadPrec
return (a -> ReadPrec a) -> a -> ReadPrec a
forall a b. (a -> b) -> a -> b
$ Rational -> a
forall a. Fractional a => Rational -> a
External instance of the constraint type forall a. RealFrac a => Fractional a
External instance of the constraint type forall a. RealFloat a => RealFrac a
Evidence bound by a type signature of the constraint type RealFloat a
fromRational Rational
rat
convertFrac Lexeme
_            = ReadPrec a
forall a. ReadPrec a
pfail

-- | @since 2.01
instance Read Int where
  readPrec :: ReadPrec Int
readPrec     = (Lexeme -> ReadPrec Int) -> ReadPrec Int
forall a. Num a => (Lexeme -> ReadPrec a) -> ReadPrec a
External instance of the constraint type Num Int
readNumber Lexeme -> ReadPrec Int
forall a. Num a => Lexeme -> ReadPrec a
External instance of the constraint type Num Int
convertInt
  readListPrec :: ReadPrec [Int]
readListPrec = ReadPrec [Int]
forall a. Read a => ReadPrec [a]
Instance of class: Read of the constraint type Read Int
readListPrecDefault
  readList :: ReadS [Int]
readList     = ReadS [Int]
forall a. Read a => ReadS [a]
Instance of class: Read of the constraint type Read Int
readListDefault

-- | @since 4.5.0.0
instance Read Word where
    readsPrec :: Int -> ReadS Word
readsPrec Int
p String
s = [(Integer -> Word
forall a. Num a => Integer -> a
External instance of the constraint type Num Word
fromInteger Integer
x, String
r) | (Integer
x, String
r) <- Int -> ReadS Integer
forall a. Read a => Int -> ReadS a
Instance of class: Read of the constraint type Read Integer
readsPrec Int
p String
s]

-- | @since 2.01
instance Read Word8 where
    readsPrec :: Int -> ReadS Word8
readsPrec Int
p String
s = [(Int -> Word8
forall a b. (Integral a, Num b) => a -> b
External instance of the constraint type Num Word8
External instance of the constraint type Integral Int
fromIntegral (Int
x::Int), String
r) | (Int
x, String
r) <- Int -> ReadS Int
forall a. Read a => Int -> ReadS a
Instance of class: Read of the constraint type Read Int
readsPrec Int
p String
s]

-- | @since 2.01
instance Read Word16 where
    readsPrec :: Int -> ReadS Word16
readsPrec Int
p String
s = [(Int -> Word16
forall a b. (Integral a, Num b) => a -> b
External instance of the constraint type Num Word16
External instance of the constraint type Integral Int
fromIntegral (Int
x::Int), String
r) | (Int
x, String
r) <- Int -> ReadS Int
forall a. Read a => Int -> ReadS a
Instance of class: Read of the constraint type Read Int
readsPrec Int
p String
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 :: Int -> ReadS Word32
readsPrec Int
p String
s = [(Int -> Word32
forall a b. (Integral a, Num b) => a -> b
External instance of the constraint type Num Word32
External instance of the constraint type Integral Int
fromIntegral (Int
x::Int), String
r) | (Int
x, String
r) <- Int -> ReadS Int
forall a. Read a => Int -> ReadS a
Instance of class: Read of the constraint type Read Int
readsPrec Int
p String
s]
#endif

-- | @since 2.01
instance Read Word64 where
    readsPrec :: Int -> ReadS Word64
readsPrec Int
p String
s = [(Integer -> Word64
forall a. Num a => Integer -> a
External instance of the constraint type Num Word64
fromInteger Integer
x, String
r) | (Integer
x, String
r) <- Int -> ReadS Integer
forall a. Read a => Int -> ReadS a
Instance of class: Read of the constraint type Read Integer
readsPrec Int
p String
s]

-- | @since 2.01
instance Read Integer where
  readPrec :: ReadPrec Integer
readPrec     = (Lexeme -> ReadPrec Integer) -> ReadPrec Integer
forall a. Num a => (Lexeme -> ReadPrec a) -> ReadPrec a
External instance of the constraint type Num Integer
readNumber Lexeme -> ReadPrec Integer
forall a. Num a => Lexeme -> ReadPrec a
External instance of the constraint type Num Integer
convertInt
  readListPrec :: ReadPrec [Integer]
readListPrec = ReadPrec [Integer]
forall a. Read a => ReadPrec [a]
Instance of class: Read of the constraint type Read Integer
readListPrecDefault
  readList :: ReadS [Integer]
readList     = ReadS [Integer]
forall a. Read a => ReadS [a]
Instance of class: Read of the constraint type Read Integer
readListDefault


-- | @since 4.8.0.0
instance Read Natural where
  readsPrec :: Int -> ReadS Natural
readsPrec Int
d = ((Integer, String) -> (Natural, String))
-> [(Integer, String)] -> [(Natural, String)]
forall a b. (a -> b) -> [a] -> [b]
map (\(Integer
n, String
s) -> (Integer -> Natural
forall a. Num a => Integer -> a
External instance of the constraint type Num Natural
fromInteger Integer
n, String
s))
                  ([(Integer, String)] -> [(Natural, String)])
-> ReadS Integer -> ReadS Natural
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Integer, String) -> Bool)
-> [(Integer, String)] -> [(Integer, String)]
forall a. (a -> Bool) -> [a] -> [a]
filter ((Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
External instance of the constraint type Ord Integer
>= Integer
0) (Integer -> Bool)
-> ((Integer, String) -> Integer) -> (Integer, String) -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\(Integer
x,String
_)->Integer
x)) ([(Integer, String)] -> [(Integer, String)])
-> ReadS Integer -> ReadS Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> ReadS Integer
forall a. Read a => Int -> ReadS a
Instance of class: Read of the constraint type Read Integer
readsPrec Int
d

-- | @since 2.01
instance Read Float where
  readPrec :: ReadPrec Float
readPrec     = (Lexeme -> ReadPrec Float) -> ReadPrec Float
forall a. Num a => (Lexeme -> ReadPrec a) -> ReadPrec a
External instance of the constraint type Num Float
readNumber Lexeme -> ReadPrec Float
forall a. RealFloat a => Lexeme -> ReadPrec a
External instance of the constraint type RealFloat Float
convertFrac
  readListPrec :: ReadPrec [Float]
readListPrec = ReadPrec [Float]
forall a. Read a => ReadPrec [a]
Instance of class: Read of the constraint type Read Float
readListPrecDefault
  readList :: ReadS [Float]
readList     = ReadS [Float]
forall a. Read a => ReadS [a]
Instance of class: Read of the constraint type Read Float
readListDefault

-- | @since 2.01
instance Read Double where
  readPrec :: ReadPrec Double
readPrec     = (Lexeme -> ReadPrec Double) -> ReadPrec Double
forall a. Num a => (Lexeme -> ReadPrec a) -> ReadPrec a
External instance of the constraint type Num Double
readNumber Lexeme -> ReadPrec Double
forall a. RealFloat a => Lexeme -> ReadPrec a
External instance of the constraint type RealFloat Double
convertFrac
  readListPrec :: ReadPrec [Double]
readListPrec = ReadPrec [Double]
forall a. Read a => ReadPrec [a]
Instance of class: Read of the constraint type Read Double
readListPrecDefault
  readList :: ReadS [Double]
readList     = ReadS [Double]
forall a. Read a => ReadS [a]
Instance of class: Read of the constraint type Read Double
readListDefault

-- | @since 2.01
instance (Integral a, Read a) => Read (Ratio a) where
  readPrec :: ReadPrec (Ratio a)
readPrec =
    ReadPrec (Ratio a) -> ReadPrec (Ratio a)
forall a. ReadPrec a -> ReadPrec a
parens
    ( Int -> ReadPrec (Ratio a) -> ReadPrec (Ratio a)
forall a. Int -> ReadPrec a -> ReadPrec a
prec Int
ratioPrec
      ( do a
x <- ReadPrec a -> ReadPrec a
forall a. ReadPrec a -> ReadPrec a
step ReadPrec a
forall a. Read a => ReadPrec a
Evidence bound by a type signature of the constraint type Read a
readPrec
           Lexeme -> ReadPrec ()
expectP (String -> Lexeme
L.Symbol String
"%")
           a
y <- ReadPrec a -> ReadPrec a
forall a. ReadPrec a -> ReadPrec a
step ReadPrec a
forall a. Read a => ReadPrec a
Evidence bound by a type signature of the constraint type Read a
readPrec
           Ratio a -> ReadPrec (Ratio a)
forall (m :: * -> *) a. Monad m => a -> m a
External instance of the constraint type Monad ReadPrec
return (a
x a -> a -> Ratio a
forall a. Integral a => a -> a -> Ratio a
Evidence bound by a type signature of the constraint type Integral a
% a
y)
      )
    )

  readListPrec :: ReadPrec [Ratio a]
readListPrec = ReadPrec [Ratio a]
forall a. Read a => ReadPrec [a]
Instance of class: Read of the constraint type forall a. (Integral a, Read a) => Read (Ratio a)
Evidence bound by a type signature of the constraint type Integral a
Evidence bound by a type signature of the constraint type Read a
readListPrecDefault
  readList :: ReadS [Ratio a]
readList     = ReadS [Ratio a]
forall a. Read a => ReadS [a]
Instance of class: Read of the constraint type forall a. (Integral a, Read a) => Read (Ratio a)
Evidence bound by a type signature of the constraint type Integral a
Evidence bound by a type signature of the constraint type Read a
readListDefault


------------------------------------------------------------------------
-- Tuple instances of Read, up to size 15
------------------------------------------------------------------------

-- | @since 2.01
instance Read () where
  readPrec :: ReadPrec ()
readPrec =
    ReadPrec () -> ReadPrec ()
forall a. ReadPrec a -> ReadPrec a
parens
    ( ReadPrec () -> ReadPrec ()
forall a. ReadPrec a -> ReadPrec a
paren
      ( () -> ReadPrec ()
forall (m :: * -> *) a. Monad m => a -> m a
External instance of the constraint type Monad ReadPrec
return ()
      )
    )

  readListPrec :: ReadPrec [()]
readListPrec = ReadPrec [()]
forall a. Read a => ReadPrec [a]
Instance of class: Read of the constraint type Read ()
readListPrecDefault
  readList :: ReadS [()]
readList     = ReadS [()]
forall a. Read a => ReadS [a]
Instance of class: Read of the constraint type Read ()
readListDefault

-- | @since 2.01
instance (Read a, Read b) => Read (a,b) where
  readPrec :: ReadPrec (a, b)
readPrec = ReadPrec (a, b) -> ReadPrec (a, b)
forall a. ReadPrec a -> ReadPrec a
wrap_tup ReadPrec (a, b)
forall a b. (Read a, Read b) => ReadPrec (a, b)
Evidence bound by a type signature of the constraint type Read b
Evidence bound by a type signature of the constraint type Read a
read_tup2
  readListPrec :: ReadPrec [(a, b)]
readListPrec = ReadPrec [(a, b)]
forall a. Read a => ReadPrec [a]
Instance of class: Read of the constraint type forall a b. (Read a, Read b) => Read (a, b)
Evidence bound by a type signature of the constraint type Read a
Evidence bound by a type signature of the constraint type Read b
readListPrecDefault
  readList :: ReadS [(a, b)]
readList     = ReadS [(a, b)]
forall a. Read a => ReadS [a]
Instance of class: Read of the constraint type forall a b. (Read a, Read b) => Read (a, b)
Evidence bound by a type signature of the constraint type Read a
Evidence bound by a type signature of the constraint type Read b
readListDefault

wrap_tup :: ReadPrec a -> ReadPrec a
wrap_tup :: ReadPrec a -> ReadPrec a
wrap_tup ReadPrec a
p = ReadPrec a -> ReadPrec a
forall a. ReadPrec a -> ReadPrec a
parens (ReadPrec a -> ReadPrec a
forall a. ReadPrec a -> ReadPrec a
paren ReadPrec a
p)

read_comma :: ReadPrec ()
read_comma :: ReadPrec ()
read_comma = Lexeme -> ReadPrec ()
expectP (String -> Lexeme
L.Punc String
",")

read_tup2 :: (Read a, Read b) => ReadPrec (a,b)
-- Reads "a , b"  no parens!
read_tup2 :: ReadPrec (a, b)
read_tup2 = do a
x <- ReadPrec a
forall a. Read a => ReadPrec a
Evidence bound by a type signature of the constraint type Read a
readPrec
               ReadPrec ()
read_comma
               b
y <- ReadPrec b
forall a. Read a => ReadPrec a
Evidence bound by a type signature of the constraint type Read b
readPrec
               (a, b) -> ReadPrec (a, b)
forall (m :: * -> *) a. Monad m => a -> m a
External instance of the constraint type Monad ReadPrec
return (a
x,b
y)

read_tup4 :: (Read a, Read b, Read c, Read d) => ReadPrec (a,b,c,d)
read_tup4 :: ReadPrec (a, b, c, d)
read_tup4 = do  (a
a,b
b) <- ReadPrec (a, b)
forall a b. (Read a, Read b) => ReadPrec (a, b)
Evidence bound by a type signature of the constraint type Read b
Evidence bound by a type signature of the constraint type Read a
read_tup2
                ReadPrec ()
read_comma
                (c
c,d
d) <- ReadPrec (c, d)
forall a b. (Read a, Read b) => ReadPrec (a, b)
Evidence bound by a type signature of the constraint type Read d
Evidence bound by a type signature of the constraint type Read c
read_tup2
                (a, b, c, d) -> ReadPrec (a, b, c, d)
forall (m :: * -> *) a. Monad m => a -> m a
External instance of the constraint type Monad ReadPrec
return (a
a,b
b,c
c,d
d)


read_tup8 :: (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h)
          => ReadPrec (a,b,c,d,e,f,g,h)
read_tup8 :: ReadPrec (a, b, c, d, e, f, g, h)
read_tup8 = do  (a
a,b
b,c
c,d
d) <- ReadPrec (a, b, c, d)
forall a b c d.
(Read a, Read b, Read c, Read d) =>
ReadPrec (a, b, c, d)
Evidence bound by a type signature of the constraint type Read d
Evidence bound by a type signature of the constraint type Read c
Evidence bound by a type signature of the constraint type Read b
Evidence bound by a type signature of the constraint type Read a
read_tup4
                ReadPrec ()
read_comma
                (e
e,f
f,g
g,h
h) <- ReadPrec (e, f, g, h)
forall a b c d.
(Read a, Read b, Read c, Read d) =>
ReadPrec (a, b, c, d)
Evidence bound by a type signature of the constraint type Read h
Evidence bound by a type signature of the constraint type Read g
Evidence bound by a type signature of the constraint type Read f
Evidence bound by a type signature of the constraint type Read e
read_tup4
                (a, b, c, d, e, f, g, h) -> ReadPrec (a, b, c, d, e, f, g, h)
forall (m :: * -> *) a. Monad m => a -> m a
External instance of the constraint type Monad ReadPrec
return (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h)


-- | @since 2.01
instance (Read a, Read b, Read c) => Read (a, b, c) where
  readPrec :: ReadPrec (a, b, c)
readPrec = ReadPrec (a, b, c) -> ReadPrec (a, b, c)
forall a. ReadPrec a -> ReadPrec a
wrap_tup (do { (a
a,b
b) <- ReadPrec (a, b)
forall a b. (Read a, Read b) => ReadPrec (a, b)
Evidence bound by a type signature of the constraint type Read b
Evidence bound by a type signature of the constraint type Read a
read_tup2; ReadPrec ()
read_comma
                          ; c
c <- ReadPrec c
forall a. Read a => ReadPrec a
Evidence bound by a type signature of the constraint type Read c
readPrec
                          ; (a, b, c) -> ReadPrec (a, b, c)
forall (m :: * -> *) a. Monad m => a -> m a
External instance of the constraint type Monad ReadPrec
return (a
a,b
b,c
c) })
  readListPrec :: ReadPrec [(a, b, c)]
readListPrec = ReadPrec [(a, b, c)]
forall a. Read a => ReadPrec [a]
Instance of class: Read of the constraint type forall a b c. (Read a, Read b, Read c) => Read (a, b, c)
Evidence bound by a type signature of the constraint type Read a
Evidence bound by a type signature of the constraint type Read b
Evidence bound by a type signature of the constraint type Read c
readListPrecDefault
  readList :: ReadS [(a, b, c)]
readList     = ReadS [(a, b, c)]
forall a. Read a => ReadS [a]
Instance of class: Read of the constraint type forall a b c. (Read a, Read b, Read c) => Read (a, b, c)
Evidence bound by a type signature of the constraint type Read a
Evidence bound by a type signature of the constraint type Read b
Evidence bound by a type signature of the constraint type Read c
readListDefault

-- | @since 2.01
instance (Read a, Read b, Read c, Read d) => Read (a, b, c, d) where
  readPrec :: ReadPrec (a, b, c, d)
readPrec = ReadPrec (a, b, c, d) -> ReadPrec (a, b, c, d)
forall a. ReadPrec a -> ReadPrec a
wrap_tup ReadPrec (a, b, c, d)
forall a b c d.
(Read a, Read b, Read c, Read d) =>
ReadPrec (a, b, c, d)
Evidence bound by a type signature of the constraint type Read d
Evidence bound by a type signature of the constraint type Read c
Evidence bound by a type signature of the constraint type Read b
Evidence bound by a type signature of the constraint type Read a
read_tup4
  readListPrec :: ReadPrec [(a, b, c, d)]
readListPrec = ReadPrec [(a, b, c, d)]
forall a. Read a => ReadPrec [a]
Instance of class: Read of the constraint type forall a b c d.
(Read a, Read b, Read c, Read d) =>
Read (a, b, c, d)
Evidence bound by a type signature of the constraint type Read a
Evidence bound by a type signature of the constraint type Read b
Evidence bound by a type signature of the constraint type Read c
Evidence bound by a type signature of the constraint type Read d
readListPrecDefault
  readList :: ReadS [(a, b, c, d)]
readList     = ReadS [(a, b, c, d)]
forall a. Read a => ReadS [a]
Instance of class: Read of the constraint type forall a b c d.
(Read a, Read b, Read c, Read d) =>
Read (a, b, c, d)
Evidence bound by a type signature of the constraint type Read a
Evidence bound by a type signature of the constraint type Read b
Evidence bound by a type signature of the constraint type Read c
Evidence bound by a type signature of the constraint type Read d
readListDefault

-- | @since 2.01
instance (Read a, Read b, Read c, Read d, Read e) => Read (a, b, c, d, e) where
  readPrec :: ReadPrec (a, b, c, d, e)
readPrec = ReadPrec (a, b, c, d, e) -> ReadPrec (a, b, c, d, e)
forall a. ReadPrec a -> ReadPrec a
wrap_tup (do { (a
a,b
b,c
c,d
d) <- ReadPrec (a, b, c, d)
forall a b c d.
(Read a, Read b, Read c, Read d) =>
ReadPrec (a, b, c, d)
Evidence bound by a type signature of the constraint type Read d
Evidence bound by a type signature of the constraint type Read c
Evidence bound by a type signature of the constraint type Read b
Evidence bound by a type signature of the constraint type Read a
read_tup4; ReadPrec ()
read_comma
                          ; e
e <- ReadPrec e
forall a. Read a => ReadPrec a
Evidence bound by a type signature of the constraint type Read e
readPrec
                          ; (a, b, c, d, e) -> ReadPrec (a, b, c, d, e)
forall (m :: * -> *) a. Monad m => a -> m a
External instance of the constraint type Monad ReadPrec
return (a
a,b
b,c
c,d
d,e
e) })
  readListPrec :: ReadPrec [(a, b, c, d, e)]
readListPrec = ReadPrec [(a, b, c, d, e)]
forall a. Read a => ReadPrec [a]
Instance of class: Read of the constraint type forall a b c d e.
(Read a, Read b, Read c, Read d, Read e) =>
Read (a, b, c, d, e)
Evidence bound by a type signature of the constraint type Read a
Evidence bound by a type signature of the constraint type Read b
Evidence bound by a type signature of the constraint type Read c
Evidence bound by a type signature of the constraint type Read d
Evidence bound by a type signature of the constraint type Read e
readListPrecDefault
  readList :: ReadS [(a, b, c, d, e)]
readList     = ReadS [(a, b, c, d, e)]
forall a. Read a => ReadS [a]
Instance of class: Read of the constraint type forall a b c d e.
(Read a, Read b, Read c, Read d, Read e) =>
Read (a, b, c, d, e)
Evidence bound by a type signature of the constraint type Read a
Evidence bound by a type signature of the constraint type Read b
Evidence bound by a type signature of the constraint type Read c
Evidence bound by a type signature of the constraint type Read d
Evidence bound by a type signature of the constraint type Read e
readListDefault

-- | @since 2.01
instance (Read a, Read b, Read c, Read d, Read e, Read f)
        => Read (a, b, c, d, e, f) where
  readPrec :: ReadPrec (a, b, c, d, e, f)
readPrec = ReadPrec (a, b, c, d, e, f) -> ReadPrec (a, b, c, d, e, f)
forall a. ReadPrec a -> ReadPrec a
wrap_tup (do { (a
a,b
b,c
c,d
d) <- ReadPrec (a, b, c, d)
forall a b c d.
(Read a, Read b, Read c, Read d) =>
ReadPrec (a, b, c, d)
Evidence bound by a type signature of the constraint type Read d
Evidence bound by a type signature of the constraint type Read c
Evidence bound by a type signature of the constraint type Read b
Evidence bound by a type signature of the constraint type Read a
read_tup4; ReadPrec ()
read_comma
                          ; (e
e,f
f) <- ReadPrec (e, f)
forall a b. (Read a, Read b) => ReadPrec (a, b)
Evidence bound by a type signature of the constraint type Read f
Evidence bound by a type signature of the constraint type Read e
read_tup2
                          ; (a, b, c, d, e, f) -> ReadPrec (a, b, c, d, e, f)
forall (m :: * -> *) a. Monad m => a -> m a
External instance of the constraint type Monad ReadPrec
return (a
a,b
b,c
c,d
d,e
e,f
f) })
  readListPrec :: ReadPrec [(a, b, c, d, e, f)]
readListPrec = ReadPrec [(a, b, c, d, e, f)]
forall a. Read a => ReadPrec [a]
Instance of class: Read of the constraint type forall a b c d e f.
(Read a, Read b, Read c, Read d, Read e, Read f) =>
Read (a, b, c, d, e, f)
Evidence bound by a type signature of the constraint type Read a
Evidence bound by a type signature of the constraint type Read b
Evidence bound by a type signature of the constraint type Read c
Evidence bound by a type signature of the constraint type Read d
Evidence bound by a type signature of the constraint type Read e
Evidence bound by a type signature of the constraint type Read f
readListPrecDefault
  readList :: ReadS [(a, b, c, d, e, f)]
readList     = ReadS [(a, b, c, d, e, f)]
forall a. Read a => ReadS [a]
Instance of class: Read of the constraint type forall a b c d e f.
(Read a, Read b, Read c, Read d, Read e, Read f) =>
Read (a, b, c, d, e, f)
Evidence bound by a type signature of the constraint type Read a
Evidence bound by a type signature of the constraint type Read b
Evidence bound by a type signature of the constraint type Read c
Evidence bound by a type signature of the constraint type Read d
Evidence bound by a type signature of the constraint type Read e
Evidence bound by a type signature of the constraint type Read f
readListDefault

-- | @since 2.01
instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g)
        => Read (a, b, c, d, e, f, g) where
  readPrec :: ReadPrec (a, b, c, d, e, f, g)
readPrec = ReadPrec (a, b, c, d, e, f, g) -> ReadPrec (a, b, c, d, e, f, g)
forall a. ReadPrec a -> ReadPrec a
wrap_tup (do { (a
a,b
b,c
c,d
d) <- ReadPrec (a, b, c, d)
forall a b c d.
(Read a, Read b, Read c, Read d) =>
ReadPrec (a, b, c, d)
Evidence bound by a type signature of the constraint type Read d
Evidence bound by a type signature of the constraint type Read c
Evidence bound by a type signature of the constraint type Read b
Evidence bound by a type signature of the constraint type Read a
read_tup4; ReadPrec ()
read_comma
                          ; (e
e,f
f) <- ReadPrec (e, f)
forall a b. (Read a, Read b) => ReadPrec (a, b)
Evidence bound by a type signature of the constraint type Read f
Evidence bound by a type signature of the constraint type Read e
read_tup2; ReadPrec ()
read_comma
                          ; g
g <- ReadPrec g
forall a. Read a => ReadPrec a
Evidence bound by a type signature of the constraint type Read g
readPrec
                          ; (a, b, c, d, e, f, g) -> ReadPrec (a, b, c, d, e, f, g)
forall (m :: * -> *) a. Monad m => a -> m a
External instance of the constraint type Monad ReadPrec
return (a
a,b
b,c
c,d
d,e
e,f
f,g
g) })
  readListPrec :: ReadPrec [(a, b, c, d, e, f, g)]
readListPrec = ReadPrec [(a, b, c, d, e, f, g)]
forall a. Read a => ReadPrec [a]
Instance of class: Read of the constraint type forall a b c d e f g.
(Read a, Read b, Read c, Read d, Read e, Read f, Read g) =>
Read (a, b, c, d, e, f, g)
Evidence bound by a type signature of the constraint type Read a
Evidence bound by a type signature of the constraint type Read b
Evidence bound by a type signature of the constraint type Read c
Evidence bound by a type signature of the constraint type Read d
Evidence bound by a type signature of the constraint type Read e
Evidence bound by a type signature of the constraint type Read f
Evidence bound by a type signature of the constraint type Read g
readListPrecDefault
  readList :: ReadS [(a, b, c, d, e, f, g)]
readList     = ReadS [(a, b, c, d, e, f, g)]
forall a. Read a => ReadS [a]
Instance of class: Read of the constraint type forall a b c d e f g.
(Read a, Read b, Read c, Read d, Read e, Read f, Read g) =>
Read (a, b, c, d, e, f, g)
Evidence bound by a type signature of the constraint type Read a
Evidence bound by a type signature of the constraint type Read b
Evidence bound by a type signature of the constraint type Read c
Evidence bound by a type signature of the constraint type Read d
Evidence bound by a type signature of the constraint type Read e
Evidence bound by a type signature of the constraint type Read f
Evidence bound by a type signature of the constraint type Read g
readListDefault

-- | @since 2.01
instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h)
        => Read (a, b, c, d, e, f, g, h) where
  readPrec :: ReadPrec (a, b, c, d, e, f, g, h)
readPrec     = ReadPrec (a, b, c, d, e, f, g, h)
-> ReadPrec (a, b, c, d, e, f, g, h)
forall a. ReadPrec a -> ReadPrec a
wrap_tup ReadPrec (a, b, c, d, e, f, g, h)
forall a b c d e f g h.
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h) =>
ReadPrec (a, b, c, d, e, f, g, h)
Evidence bound by a type signature of the constraint type Read h
Evidence bound by a type signature of the constraint type Read g
Evidence bound by a type signature of the constraint type Read f
Evidence bound by a type signature of the constraint type Read e
Evidence bound by a type signature of the constraint type Read d
Evidence bound by a type signature of the constraint type Read c
Evidence bound by a type signature of the constraint type Read b
Evidence bound by a type signature of the constraint type Read a
read_tup8
  readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h)]
readListPrec = ReadPrec [(a, b, c, d, e, f, g, h)]
forall a. Read a => ReadPrec [a]
Instance of class: Read of the constraint type forall a b c d e f g h.
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h) =>
Read (a, b, c, d, e, f, g, h)
Evidence bound by a type signature of the constraint type Read a
Evidence bound by a type signature of the constraint type Read b
Evidence bound by a type signature of the constraint type Read c
Evidence bound by a type signature of the constraint type Read d
Evidence bound by a type signature of the constraint type Read e
Evidence bound by a type signature of the constraint type Read f
Evidence bound by a type signature of the constraint type Read g
Evidence bound by a type signature of the constraint type Read h
readListPrecDefault
  readList :: ReadS [(a, b, c, d, e, f, g, h)]
readList     = ReadS [(a, b, c, d, e, f, g, h)]
forall a. Read a => ReadS [a]
Instance of class: Read of the constraint type forall a b c d e f g h.
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h) =>
Read (a, b, c, d, e, f, g, h)
Evidence bound by a type signature of the constraint type Read a
Evidence bound by a type signature of the constraint type Read b
Evidence bound by a type signature of the constraint type Read c
Evidence bound by a type signature of the constraint type Read d
Evidence bound by a type signature of the constraint type Read e
Evidence bound by a type signature of the constraint type Read f
Evidence bound by a type signature of the constraint type Read g
Evidence bound by a type signature of the constraint type Read h
readListDefault

-- | @since 2.01
instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
          Read i)
        => Read (a, b, c, d, e, f, g, h, i) where
  readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i)
readPrec = ReadPrec (a, b, c, d, e, f, g, h, i)
-> ReadPrec (a, b, c, d, e, f, g, h, i)
forall a. ReadPrec a -> ReadPrec a
wrap_tup (do { (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h) <- ReadPrec (a, b, c, d, e, f, g, h)
forall a b c d e f g h.
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h) =>
ReadPrec (a, b, c, d, e, f, g, h)
Evidence bound by a type signature of the constraint type Read h
Evidence bound by a type signature of the constraint type Read g
Evidence bound by a type signature of the constraint type Read f
Evidence bound by a type signature of the constraint type Read e
Evidence bound by a type signature of the constraint type Read d
Evidence bound by a type signature of the constraint type Read c
Evidence bound by a type signature of the constraint type Read b
Evidence bound by a type signature of the constraint type Read a
read_tup8; ReadPrec ()
read_comma
                          ; i
i <- ReadPrec i
forall a. Read a => ReadPrec a
Evidence bound by a type signature of the constraint type Read i
readPrec
                          ; (a, b, c, d, e, f, g, h, i) -> ReadPrec (a, b, c, d, e, f, g, h, i)
forall (m :: * -> *) a. Monad m => a -> m a
External instance of the constraint type Monad ReadPrec
return (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i) })
  readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i)]
readListPrec = ReadPrec [(a, b, c, d, e, f, g, h, i)]
forall a. Read a => ReadPrec [a]
Instance of class: Read of the constraint type forall a b c d e f g h i.
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
 Read i) =>
Read (a, b, c, d, e, f, g, h, i)
Evidence bound by a type signature of the constraint type Read a
Evidence bound by a type signature of the constraint type Read b
Evidence bound by a type signature of the constraint type Read c
Evidence bound by a type signature of the constraint type Read d
Evidence bound by a type signature of the constraint type Read e
Evidence bound by a type signature of the constraint type Read f
Evidence bound by a type signature of the constraint type Read g
Evidence bound by a type signature of the constraint type Read h
Evidence bound by a type signature of the constraint type Read i
readListPrecDefault
  readList :: ReadS [(a, b, c, d, e, f, g, h, i)]
readList     = ReadS [(a, b, c, d, e, f, g, h, i)]
forall a. Read a => ReadS [a]
Instance of class: Read of the constraint type forall a b c d e f g h i.
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
 Read i) =>
Read (a, b, c, d, e, f, g, h, i)
Evidence bound by a type signature of the constraint type Read a
Evidence bound by a type signature of the constraint type Read b
Evidence bound by a type signature of the constraint type Read c
Evidence bound by a type signature of the constraint type Read d
Evidence bound by a type signature of the constraint type Read e
Evidence bound by a type signature of the constraint type Read f
Evidence bound by a type signature of the constraint type Read g
Evidence bound by a type signature of the constraint type Read h
Evidence bound by a type signature of the constraint type Read i
readListDefault

-- | @since 2.01
instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
          Read i, Read j)
        => Read (a, b, c, d, e, f, g, h, i, j) where
  readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j)
readPrec = ReadPrec (a, b, c, d, e, f, g, h, i, j)
-> ReadPrec (a, b, c, d, e, f, g, h, i, j)
forall a. ReadPrec a -> ReadPrec a
wrap_tup (do { (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h) <- ReadPrec (a, b, c, d, e, f, g, h)
forall a b c d e f g h.
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h) =>
ReadPrec (a, b, c, d, e, f, g, h)
Evidence bound by a type signature of the constraint type Read h
Evidence bound by a type signature of the constraint type Read g
Evidence bound by a type signature of the constraint type Read f
Evidence bound by a type signature of the constraint type Read e
Evidence bound by a type signature of the constraint type Read d
Evidence bound by a type signature of the constraint type Read c
Evidence bound by a type signature of the constraint type Read b
Evidence bound by a type signature of the constraint type Read a
read_tup8; ReadPrec ()
read_comma
                          ; (i
i,j
j) <- ReadPrec (i, j)
forall a b. (Read a, Read b) => ReadPrec (a, b)
Evidence bound by a type signature of the constraint type Read j
Evidence bound by a type signature of the constraint type Read i
read_tup2
                          ; (a, b, c, d, e, f, g, h, i, j)
-> ReadPrec (a, b, c, d, e, f, g, h, i, j)
forall (m :: * -> *) a. Monad m => a -> m a
External instance of the constraint type Monad ReadPrec
return (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j) })
  readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j)]
readListPrec = ReadPrec [(a, b, c, d, e, f, g, h, i, j)]
forall a. Read a => ReadPrec [a]
Instance of class: Read of the constraint type forall a b c d e f g h i j.
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
 Read i, Read j) =>
Read (a, b, c, d, e, f, g, h, i, j)
Evidence bound by a type signature of the constraint type Read a
Evidence bound by a type signature of the constraint type Read b
Evidence bound by a type signature of the constraint type Read c
Evidence bound by a type signature of the constraint type Read d
Evidence bound by a type signature of the constraint type Read e
Evidence bound by a type signature of the constraint type Read f
Evidence bound by a type signature of the constraint type Read g
Evidence bound by a type signature of the constraint type Read h
Evidence bound by a type signature of the constraint type Read i
Evidence bound by a type signature of the constraint type Read j
readListPrecDefault
  readList :: ReadS [(a, b, c, d, e, f, g, h, i, j)]
readList     = ReadS [(a, b, c, d, e, f, g, h, i, j)]
forall a. Read a => ReadS [a]
Instance of class: Read of the constraint type forall a b c d e f g h i j.
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
 Read i, Read j) =>
Read (a, b, c, d, e, f, g, h, i, j)
Evidence bound by a type signature of the constraint type Read a
Evidence bound by a type signature of the constraint type Read b
Evidence bound by a type signature of the constraint type Read c
Evidence bound by a type signature of the constraint type Read d
Evidence bound by a type signature of the constraint type Read e
Evidence bound by a type signature of the constraint type Read f
Evidence bound by a type signature of the constraint type Read g
Evidence bound by a type signature of the constraint type Read h
Evidence bound by a type signature of the constraint type Read i
Evidence bound by a type signature of the constraint type Read j
readListDefault

-- | @since 2.01
instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
          Read i, Read j, Read k)
        => Read (a, b, c, d, e, f, g, h, i, j, k) where
  readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j, k)
readPrec = ReadPrec (a, b, c, d, e, f, g, h, i, j, k)
-> ReadPrec (a, b, c, d, e, f, g, h, i, j, k)
forall a. ReadPrec a -> ReadPrec a
wrap_tup (do { (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h) <- ReadPrec (a, b, c, d, e, f, g, h)
forall a b c d e f g h.
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h) =>
ReadPrec (a, b, c, d, e, f, g, h)
Evidence bound by a type signature of the constraint type Read h
Evidence bound by a type signature of the constraint type Read g
Evidence bound by a type signature of the constraint type Read f
Evidence bound by a type signature of the constraint type Read e
Evidence bound by a type signature of the constraint type Read d
Evidence bound by a type signature of the constraint type Read c
Evidence bound by a type signature of the constraint type Read b
Evidence bound by a type signature of the constraint type Read a
read_tup8; ReadPrec ()
read_comma
                          ; (i
i,j
j) <- ReadPrec (i, j)
forall a b. (Read a, Read b) => ReadPrec (a, b)
Evidence bound by a type signature of the constraint type Read j
Evidence bound by a type signature of the constraint type Read i
read_tup2; ReadPrec ()
read_comma
                          ; k
k <- ReadPrec k
forall a. Read a => ReadPrec a
Evidence bound by a type signature of the constraint type Read k
readPrec
                          ; (a, b, c, d, e, f, g, h, i, j, k)
-> ReadPrec (a, b, c, d, e, f, g, h, i, j, k)
forall (m :: * -> *) a. Monad m => a -> m a
External instance of the constraint type Monad ReadPrec
return (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,k
k) })
  readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j, k)]
readListPrec = ReadPrec [(a, b, c, d, e, f, g, h, i, j, k)]
forall a. Read a => ReadPrec [a]
Instance of class: Read of the constraint type forall a b c d e f g h i j k.
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
 Read i, Read j, Read k) =>
Read (a, b, c, d, e, f, g, h, i, j, k)
Evidence bound by a type signature of the constraint type Read a
Evidence bound by a type signature of the constraint type Read b
Evidence bound by a type signature of the constraint type Read c
Evidence bound by a type signature of the constraint type Read d
Evidence bound by a type signature of the constraint type Read e
Evidence bound by a type signature of the constraint type Read f
Evidence bound by a type signature of the constraint type Read g
Evidence bound by a type signature of the constraint type Read h
Evidence bound by a type signature of the constraint type Read i
Evidence bound by a type signature of the constraint type Read j
Evidence bound by a type signature of the constraint type Read k
readListPrecDefault
  readList :: ReadS [(a, b, c, d, e, f, g, h, i, j, k)]
readList     = ReadS [(a, b, c, d, e, f, g, h, i, j, k)]
forall a. Read a => ReadS [a]
Instance of class: Read of the constraint type forall a b c d e f g h i j k.
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
 Read i, Read j, Read k) =>
Read (a, b, c, d, e, f, g, h, i, j, k)
Evidence bound by a type signature of the constraint type Read a
Evidence bound by a type signature of the constraint type Read b
Evidence bound by a type signature of the constraint type Read c
Evidence bound by a type signature of the constraint type Read d
Evidence bound by a type signature of the constraint type Read e
Evidence bound by a type signature of the constraint type Read f
Evidence bound by a type signature of the constraint type Read g
Evidence bound by a type signature of the constraint type Read h
Evidence bound by a type signature of the constraint type Read i
Evidence bound by a type signature of the constraint type Read j
Evidence bound by a type signature of the constraint type Read k
readListDefault

-- | @since 2.01
instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
          Read i, Read j, Read k, Read l)
        => Read (a, b, c, d, e, f, g, h, i, j, k, l) where
  readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l)
readPrec = ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l)
-> ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l)
forall a. ReadPrec a -> ReadPrec a
wrap_tup (do { (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h) <- ReadPrec (a, b, c, d, e, f, g, h)
forall a b c d e f g h.
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h) =>
ReadPrec (a, b, c, d, e, f, g, h)
Evidence bound by a type signature of the constraint type Read h
Evidence bound by a type signature of the constraint type Read g
Evidence bound by a type signature of the constraint type Read f
Evidence bound by a type signature of the constraint type Read e
Evidence bound by a type signature of the constraint type Read d
Evidence bound by a type signature of the constraint type Read c
Evidence bound by a type signature of the constraint type Read b
Evidence bound by a type signature of the constraint type Read a
read_tup8; ReadPrec ()
read_comma
                          ; (i
i,j
j,k
k,l
l) <- ReadPrec (i, j, k, l)
forall a b c d.
(Read a, Read b, Read c, Read d) =>
ReadPrec (a, b, c, d)
Evidence bound by a type signature of the constraint type Read l
Evidence bound by a type signature of the constraint type Read k
Evidence bound by a type signature of the constraint type Read j
Evidence bound by a type signature of the constraint type Read i
read_tup4
                          ; (a, b, c, d, e, f, g, h, i, j, k, l)
-> ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l)
forall (m :: * -> *) a. Monad m => a -> m a
External instance of the constraint type Monad ReadPrec
return (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,k
k,l
l) })
  readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j, k, l)]
readListPrec = ReadPrec [(a, b, c, d, e, f, g, h, i, j, k, l)]
forall a. Read a => ReadPrec [a]
Instance of class: Read of the constraint type forall a b c d e f g h i j k l.
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
 Read i, Read j, Read k, Read l) =>
Read (a, b, c, d, e, f, g, h, i, j, k, l)
Evidence bound by a type signature of the constraint type Read a
Evidence bound by a type signature of the constraint type Read b
Evidence bound by a type signature of the constraint type Read c
Evidence bound by a type signature of the constraint type Read d
Evidence bound by a type signature of the constraint type Read e
Evidence bound by a type signature of the constraint type Read f
Evidence bound by a type signature of the constraint type Read g
Evidence bound by a type signature of the constraint type Read h
Evidence bound by a type signature of the constraint type Read i
Evidence bound by a type signature of the constraint type Read j
Evidence bound by a type signature of the constraint type Read k
Evidence bound by a type signature of the constraint type Read l
readListPrecDefault
  readList :: ReadS [(a, b, c, d, e, f, g, h, i, j, k, l)]
readList     = ReadS [(a, b, c, d, e, f, g, h, i, j, k, l)]
forall a. Read a => ReadS [a]
Instance of class: Read of the constraint type forall a b c d e f g h i j k l.
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
 Read i, Read j, Read k, Read l) =>
Read (a, b, c, d, e, f, g, h, i, j, k, l)
Evidence bound by a type signature of the constraint type Read a
Evidence bound by a type signature of the constraint type Read b
Evidence bound by a type signature of the constraint type Read c
Evidence bound by a type signature of the constraint type Read d
Evidence bound by a type signature of the constraint type Read e
Evidence bound by a type signature of the constraint type Read f
Evidence bound by a type signature of the constraint type Read g
Evidence bound by a type signature of the constraint type Read h
Evidence bound by a type signature of the constraint type Read i
Evidence bound by a type signature of the constraint type Read j
Evidence bound by a type signature of the constraint type Read k
Evidence bound by a type signature of the constraint type Read l
readListDefault

-- | @since 2.01
instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
          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
  readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l, m)
readPrec = ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l, m)
-> ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l, m)
forall a. ReadPrec a -> ReadPrec a
wrap_tup (do { (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h) <- ReadPrec (a, b, c, d, e, f, g, h)
forall a b c d e f g h.
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h) =>
ReadPrec (a, b, c, d, e, f, g, h)
Evidence bound by a type signature of the constraint type Read h
Evidence bound by a type signature of the constraint type Read g
Evidence bound by a type signature of the constraint type Read f
Evidence bound by a type signature of the constraint type Read e
Evidence bound by a type signature of the constraint type Read d
Evidence bound by a type signature of the constraint type Read c
Evidence bound by a type signature of the constraint type Read b
Evidence bound by a type signature of the constraint type Read a
read_tup8; ReadPrec ()
read_comma
                          ; (i
i,j
j,k
k,l
l) <- ReadPrec (i, j, k, l)
forall a b c d.
(Read a, Read b, Read c, Read d) =>
ReadPrec (a, b, c, d)
Evidence bound by a type signature of the constraint type Read l
Evidence bound by a type signature of the constraint type Read k
Evidence bound by a type signature of the constraint type Read j
Evidence bound by a type signature of the constraint type Read i
read_tup4; ReadPrec ()
read_comma
                          ; m
m <- ReadPrec m
forall a. Read a => ReadPrec a
Evidence bound by a type signature of the constraint type Read m
readPrec
                          ; (a, b, c, d, e, f, g, h, i, j, k, l, m)
-> ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l, m)
forall (m :: * -> *) a. Monad m => a -> m a
External instance of the constraint type Monad ReadPrec
return (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,k
k,l
l,m
m) })
  readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j, k, l, m)]
readListPrec = ReadPrec [(a, b, c, d, e, f, g, h, i, j, k, l, m)]
forall a. Read a => ReadPrec [a]
Instance of class: Read of the constraint type forall a b c d e f g h i j k l m.
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
 Read i, Read j, Read k, Read l, Read m) =>
Read (a, b, c, d, e, f, g, h, i, j, k, l, m)
Evidence bound by a type signature of the constraint type Read a
Evidence bound by a type signature of the constraint type Read b
Evidence bound by a type signature of the constraint type Read c
Evidence bound by a type signature of the constraint type Read d
Evidence bound by a type signature of the constraint type Read e
Evidence bound by a type signature of the constraint type Read f
Evidence bound by a type signature of the constraint type Read g
Evidence bound by a type signature of the constraint type Read h
Evidence bound by a type signature of the constraint type Read i
Evidence bound by a type signature of the constraint type Read j
Evidence bound by a type signature of the constraint type Read k
Evidence bound by a type signature of the constraint type Read l
Evidence bound by a type signature of the constraint type Read m
readListPrecDefault
  readList :: ReadS [(a, b, c, d, e, f, g, h, i, j, k, l, m)]
readList     = ReadS [(a, b, c, d, e, f, g, h, i, j, k, l, m)]
forall a. Read a => ReadS [a]
Instance of class: Read of the constraint type forall a b c d e f g h i j k l m.
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
 Read i, Read j, Read k, Read l, Read m) =>
Read (a, b, c, d, e, f, g, h, i, j, k, l, m)
Evidence bound by a type signature of the constraint type Read a
Evidence bound by a type signature of the constraint type Read b
Evidence bound by a type signature of the constraint type Read c
Evidence bound by a type signature of the constraint type Read d
Evidence bound by a type signature of the constraint type Read e
Evidence bound by a type signature of the constraint type Read f
Evidence bound by a type signature of the constraint type Read g
Evidence bound by a type signature of the constraint type Read h
Evidence bound by a type signature of the constraint type Read i
Evidence bound by a type signature of the constraint type Read j
Evidence bound by a type signature of the constraint type Read k
Evidence bound by a type signature of the constraint type Read l
Evidence bound by a type signature of the constraint type Read m
readListDefault

-- | @since 2.01
instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
          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
  readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
readPrec = ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
-> ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
forall a. ReadPrec a -> ReadPrec a
wrap_tup (do { (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h) <- ReadPrec (a, b, c, d, e, f, g, h)
forall a b c d e f g h.
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h) =>
ReadPrec (a, b, c, d, e, f, g, h)
Evidence bound by a type signature of the constraint type Read h
Evidence bound by a type signature of the constraint type Read g
Evidence bound by a type signature of the constraint type Read f
Evidence bound by a type signature of the constraint type Read e
Evidence bound by a type signature of the constraint type Read d
Evidence bound by a type signature of the constraint type Read c
Evidence bound by a type signature of the constraint type Read b
Evidence bound by a type signature of the constraint type Read a
read_tup8; ReadPrec ()
read_comma
                          ; (i
i,j
j,k
k,l
l) <- ReadPrec (i, j, k, l)
forall a b c d.
(Read a, Read b, Read c, Read d) =>
ReadPrec (a, b, c, d)
Evidence bound by a type signature of the constraint type Read l
Evidence bound by a type signature of the constraint type Read k
Evidence bound by a type signature of the constraint type Read j
Evidence bound by a type signature of the constraint type Read i
read_tup4; ReadPrec ()
read_comma
                          ; (m
m,n
n) <- ReadPrec (m, n)
forall a b. (Read a, Read b) => ReadPrec (a, b)
Evidence bound by a type signature of the constraint type Read n
Evidence bound by a type signature of the constraint type Read m
read_tup2
                          ; (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
-> ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
forall (m :: * -> *) a. Monad m => a -> m a
External instance of the constraint type Monad ReadPrec
return (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,k
k,l
l,m
m,n
n) })
  readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)]
readListPrec = ReadPrec [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)]
forall a. Read a => ReadPrec [a]
Instance of class: Read of the constraint type forall a b c d e f g h i j k l m n.
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
 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)
Evidence bound by a type signature of the constraint type Read a
Evidence bound by a type signature of the constraint type Read b
Evidence bound by a type signature of the constraint type Read c
Evidence bound by a type signature of the constraint type Read d
Evidence bound by a type signature of the constraint type Read e
Evidence bound by a type signature of the constraint type Read f
Evidence bound by a type signature of the constraint type Read g
Evidence bound by a type signature of the constraint type Read h
Evidence bound by a type signature of the constraint type Read i
Evidence bound by a type signature of the constraint type Read j
Evidence bound by a type signature of the constraint type Read k
Evidence bound by a type signature of the constraint type Read l
Evidence bound by a type signature of the constraint type Read m
Evidence bound by a type signature of the constraint type Read n
readListPrecDefault
  readList :: ReadS [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)]
readList     = ReadS [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)]
forall a. Read a => ReadS [a]
Instance of class: Read of the constraint type forall a b c d e f g h i j k l m n.
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
 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)
Evidence bound by a type signature of the constraint type Read a
Evidence bound by a type signature of the constraint type Read b
Evidence bound by a type signature of the constraint type Read c
Evidence bound by a type signature of the constraint type Read d
Evidence bound by a type signature of the constraint type Read e
Evidence bound by a type signature of the constraint type Read f
Evidence bound by a type signature of the constraint type Read g
Evidence bound by a type signature of the constraint type Read h
Evidence bound by a type signature of the constraint type Read i
Evidence bound by a type signature of the constraint type Read j
Evidence bound by a type signature of the constraint type Read k
Evidence bound by a type signature of the constraint type Read l
Evidence bound by a type signature of the constraint type Read m
Evidence bound by a type signature of the constraint type Read n
readListDefault

-- | @since 2.01
instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
          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
  readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
readPrec = ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
-> ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
forall a. ReadPrec a -> ReadPrec a
wrap_tup (do { (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h) <- ReadPrec (a, b, c, d, e, f, g, h)
forall a b c d e f g h.
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h) =>
ReadPrec (a, b, c, d, e, f, g, h)
Evidence bound by a type signature of the constraint type Read h
Evidence bound by a type signature of the constraint type Read g
Evidence bound by a type signature of the constraint type Read f
Evidence bound by a type signature of the constraint type Read e
Evidence bound by a type signature of the constraint type Read d
Evidence bound by a type signature of the constraint type Read c
Evidence bound by a type signature of the constraint type Read b
Evidence bound by a type signature of the constraint type Read a
read_tup8; ReadPrec ()
read_comma
                          ; (i
i,j
j,k
k,l
l) <- ReadPrec (i, j, k, l)
forall a b c d.
(Read a, Read b, Read c, Read d) =>
ReadPrec (a, b, c, d)
Evidence bound by a type signature of the constraint type Read l
Evidence bound by a type signature of the constraint type Read k
Evidence bound by a type signature of the constraint type Read j
Evidence bound by a type signature of the constraint type Read i
read_tup4; ReadPrec ()
read_comma
                          ; (m
m,n
n) <- ReadPrec (m, n)
forall a b. (Read a, Read b) => ReadPrec (a, b)
Evidence bound by a type signature of the constraint type Read n
Evidence bound by a type signature of the constraint type Read m
read_tup2; ReadPrec ()
read_comma
                          ; o
o <- ReadPrec o
forall a. Read a => ReadPrec a
Evidence bound by a type signature of the constraint type Read o
readPrec
                          ; (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
-> ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
forall (m :: * -> *) a. Monad m => a -> m a
External instance of the constraint type Monad ReadPrec
return (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,k
k,l
l,m
m,n
n,o
o) })
  readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)]
readListPrec = ReadPrec [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)]
forall a. Read a => ReadPrec [a]
Instance of class: Read of the constraint type forall a b c d e f g h i j k l m n o.
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
 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)
Evidence bound by a type signature of the constraint type Read a
Evidence bound by a type signature of the constraint type Read b
Evidence bound by a type signature of the constraint type Read c
Evidence bound by a type signature of the constraint type Read d
Evidence bound by a type signature of the constraint type Read e
Evidence bound by a type signature of the constraint type Read f
Evidence bound by a type signature of the constraint type Read g
Evidence bound by a type signature of the constraint type Read h
Evidence bound by a type signature of the constraint type Read i
Evidence bound by a type signature of the constraint type Read j
Evidence bound by a type signature of the constraint type Read k
Evidence bound by a type signature of the constraint type Read l
Evidence bound by a type signature of the constraint type Read m
Evidence bound by a type signature of the constraint type Read n
Evidence bound by a type signature of the constraint type Read o
readListPrecDefault
  readList :: ReadS [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)]
readList     = ReadS [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)]
forall a. Read a => ReadS [a]
Instance of class: Read of the constraint type forall a b c d e f g h i j k l m n o.
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h,
 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)
Evidence bound by a type signature of the constraint type Read a
Evidence bound by a type signature of the constraint type Read b
Evidence bound by a type signature of the constraint type Read c
Evidence bound by a type signature of the constraint type Read d
Evidence bound by a type signature of the constraint type Read e
Evidence bound by a type signature of the constraint type Read f
Evidence bound by a type signature of the constraint type Read g
Evidence bound by a type signature of the constraint type Read h
Evidence bound by a type signature of the constraint type Read i
Evidence bound by a type signature of the constraint type Read j
Evidence bound by a type signature of the constraint type Read k
Evidence bound by a type signature of the constraint type Read l
Evidence bound by a type signature of the constraint type Read m
Evidence bound by a type signature of the constraint type Read n
Evidence bound by a type signature of the constraint type Read o
readListDefault