Movatterモバイル変換

{-# LANGUAGE Trustworthy #-}{-# LANGUAGE CPP, NoImplicitPrelude, StandaloneDeriving #-}{-# OPTIONS_HADDOCK hide #-}------------------------------------------------------------------------------- |-- 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.--------------------------------------------------------------------------------- #hidemoduleGHC.Read(Read(..)-- class-- ReadS type,ReadS-- :: *; = String -> [(a,String)]-- H98 compatibility,lex-- :: ReadS String,lexLitChar-- :: ReadS String,readLitChar-- :: ReadS Char,lexDigits-- :: ReadS String-- defining readers,lexP-- :: ReadPrec Lexeme,paren-- :: ReadPrec a -> ReadPrec a,parens-- :: ReadPrec a -> ReadPrec a,list-- :: ReadPrec a -> ReadPrec [a],choose-- :: [(String, ReadPrec a)] -> ReadPrec a,readListDefault,readListPrecDefault-- Temporary,readParen-- XXX Can this be removed?,readp)whereimportqualifiedText.ParserCombinators.ReadPasPimportText.ParserCombinators.ReadP(ReadP,ReadS,readP_to_S)importqualifiedText.Read.LexasL-- Lex exports 'lex', which is also defined here,-- hence the qualified import.-- We can't import *anything* unqualified, because that-- confuses Haddock.importText.ParserCombinators.ReadPrecimportData.Maybe#ifndef __HADDOCK__import{-# SOURCE #-}GHC.Unicode(isDigit)#endifimportGHC.NumimportGHC.RealimportGHC.Float()importGHC.ShowimportGHC.BaseimportGHC.Arr-- For defining instances for the generic deriving mechanismimportGHC.Generics(Arity(..),Associativity(..),Fixity(..))

-- | @'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->ReadSa->ReadSa-- A Haskell 98 functionreadParenbg=ifbthenmandatoryelseoptionalwhereoptionalr=gr++mandatoryrmandatoryr=do("(",s)<-lexr(x,t)<-optionals(")",u)<-lextreturn(x,u)

-------------------------------------------------------------------------- class Read-- | Parsing of 'String's, producing values.---- Minimal complete definition: 'readsPrec' (or, for GHC only, 'readPrec')---- 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 98 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 = readListPrecDefaultclassReadawhere-- | 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@.->ReadSa-- | 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::ReadPreca-- | 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 definitionsreadsPrec=readPrec_to_SreadPrecreadList=readPrec_to_S(listreadPrec)0readPrec=readS_to_PrecreadsPrecreadListPrec=readS_to_Prec(\_->readList)readListDefault::Reada=>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=readPrec_to_SreadListPrec0readListPrecDefault::Reada=>ReadPrec[a]-- ^ A possible replacement definition for the 'readListPrec' method,--   defined using 'readPrec' (GHC only).readListPrecDefault=listreadPrec-------------------------------------------------------------------------- H98 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 properlylex::ReadSString-- As defined by H98lexs=readP_to_SL.hsLexs-- | Read a string representation of a character, using Haskell-- source-language escape conventions.  For example:---- > lexLitChar  "\\nHello"  =  [("\\n", "Hello")]--lexLitChar::ReadSString-- As defined by H98lexLitChar=readP_to_S(do{(s,_)<-P.gatherL.lexChar;returns})-- 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::ReadSChar-- As defined by H98readLitChar=readP_to_SL.lexChar-- | Reads a non-empty string of decimal digits.lexDigits::ReadSStringlexDigits=readP_to_S(P.munch1isDigit)-------------------------------------------------------------------------- utility parserslexP::ReadPrecL.Lexeme-- ^ Parse a single lexemelexP=liftL.lexparen::ReadPreca->ReadPreca-- ^ @(paren p)@ parses \"(P0)\"--      where @p@ parses \"P0\" in precedence context zeroparenp=doL.Punc"("<-lexPx<-resetpL.Punc")"<-lexPreturnxparens::ReadPreca->ReadPreca-- ^ @(parens p)@ parses \"P\", \"(P0)\", \"((P0))\", etc,--      where @p@ parses \"P\"  in the current precedence context--          and parses \"P0\" in precedence context zeroparensp=optionalwhereoptional=p+++mandatorymandatory=parenoptionallist::ReadPreca->ReadPrec[a]-- ^ @(list p)@ parses a list of things parsed by @p@,-- using the usual square-bracket syntax.listreadx=parens(doL.Punc"["<-lexP(listRestFalse+++listNext))wherelistReststarted=doL.Puncc<-lexPcasecof"]"->return[]","|started->listNext_->pfaillistNext=dox<-resetreadxxs<-listRestTruereturn(x:xs)choose::[(String,ReadPreca)]->ReadPreca-- ^ 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 (:=:)choosesps=foldr((+++).try_one)pfailspswheretry_one(s,p)=do{token<-lexP;casetokenofL.Idents'|s==s'->pL.Symbols'|s==s'->p_other->pfail}

instanceReadCharwherereadPrec=parens(doL.Charc<-lexPreturnc)readListPrec=parens(doL.Strings<-lexP-- Looks for "foo"returns+++readListPrecDefault-- Looks for ['f','o','o'])-- (more generous than H98 spec)readList=readListDefaultinstanceReadBoolwherereadPrec=parens(doL.Idents<-lexPcasesof"True"->returnTrue"False"->returnFalse_->pfail)readListPrec=readListPrecDefaultreadList=readListDefaultinstanceReadOrderingwherereadPrec=parens(doL.Idents<-lexPcasesof"LT"->returnLT"EQ"->returnEQ"GT"->returnGT_->pfail)readListPrec=readListPrecDefaultreadList=readListDefault

instanceReada=>Read(Maybea)wherereadPrec=parens(doL.Ident"Nothing"<-lexPreturnNothing+++precappPrec(doL.Ident"Just"<-lexPx<-stepreadPrecreturn(Justx)))readListPrec=readListPrecDefaultreadList=readListDefaultinstanceReada=>Read[a]wherereadPrec=readListPrecreadListPrec=readListPrecDefaultreadList=readListDefaultinstance(Ixa,Reada,Readb)=>Read(Arrayab)wherereadPrec=parens$precappPrec$doL.Ident"array"<-lexPtheBounds<-stepreadPrecvals<-stepreadPrecreturn(arraytheBoundsvals)readListPrec=readListPrecDefaultreadList=readListDefaultinstanceReadL.LexemewherereadPrec=lexPreadListPrec=readListPrecDefaultreadList=readListDefault

readNumber::Numa=>(L.Lexeme->ReadPreca)->ReadPreca-- Read a signed numberreadNumberconvert=parens(dox<-lexPcasexofL.Symbol"-"->doy<-lexPn<-convertyreturn(negaten)_->convertx)convertInt::Numa=>L.Lexeme->ReadPrecaconvertInt(L.Inti)=return(fromIntegeri)convertInt_=pfailconvertFrac::Fractionala=>L.Lexeme->ReadPrecaconvertFrac(L.Inti)=return(fromIntegeri)convertFrac(L.Ratr)=return(fromRationalr)convertFrac_=pfailinstanceReadIntwherereadPrec=readNumberconvertIntreadListPrec=readListPrecDefaultreadList=readListDefaultinstanceReadIntegerwherereadPrec=readNumberconvertIntreadListPrec=readListPrecDefaultreadList=readListDefaultinstanceReadFloatwherereadPrec=readNumberconvertFracreadListPrec=readListPrecDefaultreadList=readListDefaultinstanceReadDoublewherereadPrec=readNumberconvertFracreadListPrec=readListPrecDefaultreadList=readListDefaultinstance(Integrala,Reada)=>Read(Ratioa)wherereadPrec=parens(precratioPrec(dox<-stepreadPrecL.Symbol"%"<-lexPy<-stepreadPrecreturn(x%y)))readListPrec=readListPrecDefaultreadList=readListDefault

instanceRead()wherereadPrec=parens(paren(return()))readListPrec=readListPrecDefaultreadList=readListDefaultinstance(Reada,Readb)=>Read(a,b)wherereadPrec=wrap_tupread_tup2readListPrec=readListPrecDefaultreadList=readListDefaultwrap_tup::ReadPreca->ReadPrecawrap_tupp=parens(parenp)read_comma::ReadPrec()read_comma=do{L.Punc","<-lexP;return()}read_tup2::(Reada,Readb)=>ReadPrec(a,b)-- Reads "a , b"  no parens!read_tup2=dox<-readPrecread_commay<-readPrecreturn(x,y)read_tup4::(Reada,Readb,Readc,Readd)=>ReadPrec(a,b,c,d)read_tup4=do(a,b)<-read_tup2read_comma(c,d)<-read_tup2return(a,b,c,d)read_tup8::(Reada,Readb,Readc,Readd,Reade,Readf,Readg,Readh)=>ReadPrec(a,b,c,d,e,f,g,h)read_tup8=do(a,b,c,d)<-read_tup4read_comma(e,f,g,h)<-read_tup4return(a,b,c,d,e,f,g,h)instance(Reada,Readb,Readc)=>Read(a,b,c)wherereadPrec=wrap_tup(do{(a,b)<-read_tup2;read_comma;c<-readPrec;return(a,b,c)})readListPrec=readListPrecDefaultreadList=readListDefaultinstance(Reada,Readb,Readc,Readd)=>Read(a,b,c,d)wherereadPrec=wrap_tupread_tup4readListPrec=readListPrecDefaultreadList=readListDefaultinstance(Reada,Readb,Readc,Readd,Reade)=>Read(a,b,c,d,e)wherereadPrec=wrap_tup(do{(a,b,c,d)<-read_tup4;read_comma;e<-readPrec;return(a,b,c,d,e)})readListPrec=readListPrecDefaultreadList=readListDefaultinstance(Reada,Readb,Readc,Readd,Reade,Readf)=>Read(a,b,c,d,e,f)wherereadPrec=wrap_tup(do{(a,b,c,d)<-read_tup4;read_comma;(e,f)<-read_tup2;return(a,b,c,d,e,f)})readListPrec=readListPrecDefaultreadList=readListDefaultinstance(Reada,Readb,Readc,Readd,Reade,Readf,Readg)=>Read(a,b,c,d,e,f,g)wherereadPrec=wrap_tup(do{(a,b,c,d)<-read_tup4;read_comma;(e,f)<-read_tup2;read_comma;g<-readPrec;return(a,b,c,d,e,f,g)})readListPrec=readListPrecDefaultreadList=readListDefaultinstance(Reada,Readb,Readc,Readd,Reade,Readf,Readg,Readh)=>Read(a,b,c,d,e,f,g,h)wherereadPrec=wrap_tupread_tup8readListPrec=readListPrecDefaultreadList=readListDefaultinstance(Reada,Readb,Readc,Readd,Reade,Readf,Readg,Readh,Readi)=>Read(a,b,c,d,e,f,g,h,i)wherereadPrec=wrap_tup(do{(a,b,c,d,e,f,g,h)<-read_tup8;read_comma;i<-readPrec;return(a,b,c,d,e,f,g,h,i)})readListPrec=readListPrecDefaultreadList=readListDefaultinstance(Reada,Readb,Readc,Readd,Reade,Readf,Readg,Readh,Readi,Readj)=>Read(a,b,c,d,e,f,g,h,i,j)wherereadPrec=wrap_tup(do{(a,b,c,d,e,f,g,h)<-read_tup8;read_comma;(i,j)<-read_tup2;return(a,b,c,d,e,f,g,h,i,j)})readListPrec=readListPrecDefaultreadList=readListDefaultinstance(Reada,Readb,Readc,Readd,Reade,Readf,Readg,Readh,Readi,Readj,Readk)=>Read(a,b,c,d,e,f,g,h,i,j,k)wherereadPrec=wrap_tup(do{(a,b,c,d,e,f,g,h)<-read_tup8;read_comma;(i,j)<-read_tup2;read_comma;k<-readPrec;return(a,b,c,d,e,f,g,h,i,j,k)})readListPrec=readListPrecDefaultreadList=readListDefaultinstance(Reada,Readb,Readc,Readd,Reade,Readf,Readg,Readh,Readi,Readj,Readk,Readl)=>Read(a,b,c,d,e,f,g,h,i,j,k,l)wherereadPrec=wrap_tup(do{(a,b,c,d,e,f,g,h)<-read_tup8;read_comma;(i,j,k,l)<-read_tup4;return(a,b,c,d,e,f,g,h,i,j,k,l)})readListPrec=readListPrecDefaultreadList=readListDefaultinstance(Reada,Readb,Readc,Readd,Reade,Readf,Readg,Readh,Readi,Readj,Readk,Readl,Readm)=>Read(a,b,c,d,e,f,g,h,i,j,k,l,m)wherereadPrec=wrap_tup(do{(a,b,c,d,e,f,g,h)<-read_tup8;read_comma;(i,j,k,l)<-read_tup4;read_comma;m<-readPrec;return(a,b,c,d,e,f,g,h,i,j,k,l,m)})readListPrec=readListPrecDefaultreadList=readListDefaultinstance(Reada,Readb,Readc,Readd,Reade,Readf,Readg,Readh,Readi,Readj,Readk,Readl,Readm,Readn)=>Read(a,b,c,d,e,f,g,h,i,j,k,l,m,n)wherereadPrec=wrap_tup(do{(a,b,c,d,e,f,g,h)<-read_tup8;read_comma;(i,j,k,l)<-read_tup4;read_comma;(m,n)<-read_tup2;return(a,b,c,d,e,f,g,h,i,j,k,l,m,n)})readListPrec=readListPrecDefaultreadList=readListDefaultinstance(Reada,Readb,Readc,Readd,Reade,Readf,Readg,Readh,Readi,Readj,Readk,Readl,Readm,Readn,Reado)=>Read(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o)wherereadPrec=wrap_tup(do{(a,b,c,d,e,f,g,h)<-read_tup8;read_comma;(i,j,k,l)<-read_tup4;read_comma;(m,n)<-read_tup2;read_comma;o<-readPrec;return(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o)})readListPrec=readListPrecDefaultreadList=readListDefault

-- XXX Can this be removed?readp::Reada=>ReadPareadp=readPrec_to_PreadPrecminPrec

derivinginstanceReadArityderivinginstanceReadAssociativityderivinginstanceReadFixity