Movatterモバイル変換

{-# LANGUAGE Trustworthy #-}{-# LANGUAGE NoImplicitPrelude #-}{-# LANGUAGE RankNTypes #-}{-# LANGUAGE MagicHash #-}{-# LANGUAGE DeriveFunctor #-}------------------------------------------------------------------------------- |-- Module      :  Text.ParserCombinators.ReadP-- Copyright   :  (c) The University of Glasgow 2002-- License     :  BSD-style (see the file libraries/base/LICENSE)---- Maintainer  :  libraries@haskell.org-- Stability   :  provisional-- Portability :  non-portable (local universal quantification)---- This is a library of parser combinators, originally written by Koen Claessen.-- It parses all alternatives in parallel, so it never keeps hold of-- the beginning of the input string, a common source of space leaks with-- other parsers.  The @('+++')@ choice combinator is genuinely commutative;-- it makes no difference which branch is \"shorter\".-----------------------------------------------------------------------------moduleText.ParserCombinators.ReadP(-- * The 'ReadP' typeReadP,-- * Primitive operationsget,look,(+++),(<++),gather,-- * Other operationspfail,eof,satisfy,char,string,munch,munch1,skipSpaces,choice,count,between,option,optional,many,many1,skipMany,skipMany1,sepBy,sepBy1,endBy,endBy1,chainr,chainl,chainl1,chainr1,manyTill,-- * Running a parserReadS,readP_to_S,readS_to_P,-- * Properties-- $properties)whereimportGHC.Unicode(isSpace)importGHC.List(replicate,null)importGHC.Basehiding(many)importControl.Monad.Failinfixr5+++,<++-------------------------------------------------------------------------- ReadS-- | A parser for a type @a@, represented as a function that takes a-- 'String' and returns a list of possible parses as @(a,'String')@ pairs.---- Note that this kind of backtracking parser is very inefficient;-- reading a large structure may be quite slow (cf 'ReadP').typeReadSa=String->[(a,String)]-- ----------------------------------------------------------------------------- The P type-- is representation type -- should be kept abstractdataPa=Get(Char->Pa)|Look(String->Pa)|Fail|Resulta(Pa)|Final(NonEmpty(a,String))derivingFunctor-- ^ @since 4.8.0.0-- Monad, MonadPlus-- | @since 4.5.0.0instanceApplicativePwherepure :: a -> P apureax=a -> P a -> P aforall a. a -> P a -> P aResultaxP aforall a. P aFail<*> :: P (a -> b) -> P a -> P b(<*>)=P (a -> b) -> P a -> P bforall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m bap-- | @since 2.01instanceMonadPlusP-- | @since 2.01instanceMonadPwhere(GetChar -> P af)>>= :: P a -> (a -> P b) -> P b>>=a -> P bk=(Char -> P b) -> P bforall a. (Char -> P a) -> P aGet(\Charc->Char -> P afCharcP a -> (a -> P b) -> P bforall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b>>=a -> P bk)(LookString -> P af)>>=a -> P bk=(String -> P b) -> P bforall a. (String -> P a) -> P aLook(\Strings->String -> P afStringsP a -> (a -> P b) -> P bforall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b>>=a -> P bk)P aFail>>=a -> P b_=P bforall a. P aFail(ResultaxP ap)>>=a -> P bk=a -> P bkaxP b -> P b -> P bforall (f :: * -> *) a. Alternative f => f a -> f a -> f a<|>(P apP a -> (a -> P b) -> P bforall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b>>=a -> P bk)(Final((a, String)r:|[(a, String)]rs))>>=a -> P bk=[(b, String)] -> P bforall a. [(a, String)] -> P afinal[(b, String)ys'|(ax,Strings)<-((a, String)r(a, String) -> [(a, String)] -> [(a, String)]forall a. a -> [a] -> [a]:[(a, String)]rs),(b, String)ys'<-P b -> ReadS bforall a. P a -> ReadS arun(a -> P bkax)Strings]-- | @since 4.9.0.0instanceMonadFailPwherefail :: String -> P afailString_=P aforall a. P aFail-- | @since 4.5.0.0instanceAlternativePwhereempty :: P aempty=P aforall a. P aFail-- most common case: two gets are combinedGetChar -> P af1<|> :: P a -> P a -> P a<|>GetChar -> P af2=(Char -> P a) -> P aforall a. (Char -> P a) -> P aGet(\Charc->Char -> P af1CharcP a -> P a -> P aforall (f :: * -> *) a. Alternative f => f a -> f a -> f a<|>Char -> P af2Charc)-- results are delivered as soon as possibleResultaxP ap<|>P aq=a -> P a -> P aforall a. a -> P a -> P aResultax(P apP a -> P a -> P aforall (f :: * -> *) a. Alternative f => f a -> f a -> f a<|>P aq)P ap<|>ResultaxP aq=a -> P a -> P aforall a. a -> P a -> P aResultax(P apP a -> P a -> P aforall (f :: * -> *) a. Alternative f => f a -> f a -> f a<|>P aq)-- fail disappearsP aFail<|>P ap=P apP ap<|>P aFail=P ap-- two finals are combined-- final + look becomes one look and one final (=optimization)-- final + sthg else becomes one look and one finalFinalNonEmpty (a, String)r<|>FinalNonEmpty (a, String)t=NonEmpty (a, String) -> P aforall a. NonEmpty (a, String) -> P aFinal(NonEmpty (a, String)rNonEmpty (a, String)-> NonEmpty (a, String) -> NonEmpty (a, String)forall a. Semigroup a => a -> a -> a<>NonEmpty (a, String)t)Final((a, String)r:|[(a, String)]rs)<|>LookString -> P af=(String -> P a) -> P aforall a. (String -> P a) -> P aLook(\Strings->NonEmpty (a, String) -> P aforall a. NonEmpty (a, String) -> P aFinal((a, String)r(a, String) -> [(a, String)] -> NonEmpty (a, String)forall a. a -> [a] -> NonEmpty a:|([(a, String)]rs[(a, String)] -> [(a, String)] -> [(a, String)]forall a. [a] -> [a] -> [a]++P a -> ReadS aforall a. P a -> ReadS arun(String -> P afStrings)Strings)))Final((a, String)r:|[(a, String)]rs)<|>P ap=(String -> P a) -> P aforall a. (String -> P a) -> P aLook(\Strings->NonEmpty (a, String) -> P aforall a. NonEmpty (a, String) -> P aFinal((a, String)r(a, String) -> [(a, String)] -> NonEmpty (a, String)forall a. a -> [a] -> NonEmpty a:|([(a, String)]rs[(a, String)] -> [(a, String)] -> [(a, String)]forall a. [a] -> [a] -> [a]++P a -> ReadS aforall a. P a -> ReadS arunP apStrings)))LookString -> P af<|>FinalNonEmpty (a, String)r=(String -> P a) -> P aforall a. (String -> P a) -> P aLook(\Strings->NonEmpty (a, String) -> P aforall a. NonEmpty (a, String) -> P aFinal(caseP a -> ReadS aforall a. P a -> ReadS arun(String -> P afStrings)Stringsof[]->NonEmpty (a, String)r((a, String)x:[(a, String)]xs)->((a, String)x(a, String) -> [(a, String)] -> NonEmpty (a, String)forall a. a -> [a] -> NonEmpty a:|[(a, String)]xs)NonEmpty (a, String)-> NonEmpty (a, String) -> NonEmpty (a, String)forall a. Semigroup a => a -> a -> a<>NonEmpty (a, String)r))P ap<|>FinalNonEmpty (a, String)r=(String -> P a) -> P aforall a. (String -> P a) -> P aLook(\Strings->NonEmpty (a, String) -> P aforall a. NonEmpty (a, String) -> P aFinal(caseP a -> ReadS aforall a. P a -> ReadS arunP apStringsof[]->NonEmpty (a, String)r((a, String)x:[(a, String)]xs)->((a, String)x(a, String) -> [(a, String)] -> NonEmpty (a, String)forall a. a -> [a] -> NonEmpty a:|[(a, String)]xs)NonEmpty (a, String)-> NonEmpty (a, String) -> NonEmpty (a, String)forall a. Semigroup a => a -> a -> a<>NonEmpty (a, String)r))-- two looks are combined (=optimization)-- look + sthg else floats upwardsLookString -> P af<|>LookString -> P ag=(String -> P a) -> P aforall a. (String -> P a) -> P aLook(\Strings->String -> P afStringsP a -> P a -> P aforall (f :: * -> *) a. Alternative f => f a -> f a -> f a<|>String -> P agStrings)LookString -> P af<|>P ap=(String -> P a) -> P aforall a. (String -> P a) -> P aLook(\Strings->String -> P afStringsP a -> P a -> P aforall (f :: * -> *) a. Alternative f => f a -> f a -> f a<|>P ap)P ap<|>LookString -> P af=(String -> P a) -> P aforall a. (String -> P a) -> P aLook(\Strings->P apP a -> P a -> P aforall (f :: * -> *) a. Alternative f => f a -> f a -> f a<|>String -> P afStrings)-- ----------------------------------------------------------------------------- The ReadP typenewtypeReadPa=R(forallb.(a->Pb)->Pb)-- | @since 2.01instanceFunctorReadPwherefmap :: (a -> b) -> ReadP a -> ReadP bfmapa -> bh(Rforall b. (a -> P b) -> P bf)=(forall b. (b -> P b) -> P b) -> ReadP bforall a. (forall b. (a -> P b) -> P b) -> ReadP aR(\b -> P bk->(a -> P b) -> P bforall b. (a -> P b) -> P bf(b -> P bk(b -> P b) -> (a -> b) -> a -> P bforall b c a. (b -> c) -> (a -> b) -> a -> c.a -> bh))-- | @since 4.6.0.0instanceApplicativeReadPwherepure :: a -> ReadP apureax=(forall b. (a -> P b) -> P b) -> ReadP aforall a. (forall b. (a -> P b) -> P b) -> ReadP aR(\a -> P bk->a -> P bkax)<*> :: ReadP (a -> b) -> ReadP a -> ReadP b(<*>)=ReadP (a -> b) -> ReadP a -> ReadP bforall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m bap-- liftA2 = liftM2-- | @since 2.01instanceMonadReadPwhereRforall b. (a -> P b) -> P bm>>= :: ReadP a -> (a -> ReadP b) -> ReadP b>>=a -> ReadP bf=(forall b. (b -> P b) -> P b) -> ReadP bforall a. (forall b. (a -> P b) -> P b) -> ReadP aR(\b -> P bk->(a -> P b) -> P bforall b. (a -> P b) -> P bm(\aa->letRforall b. (b -> P b) -> P bm'=a -> ReadP bfaain(b -> P b) -> P bforall b. (b -> P b) -> P bm'b -> P bk))-- | @since 4.9.0.0instanceMonadFailReadPwherefail :: String -> ReadP afailString_=(forall b. (a -> P b) -> P b) -> ReadP aforall a. (forall b. (a -> P b) -> P b) -> ReadP aR(\a -> P b_->P bforall a. P aFail)-- | @since 4.6.0.0instanceAlternativeReadPwhereempty :: ReadP aempty=ReadP aforall a. ReadP apfail<|> :: ReadP a -> ReadP a -> ReadP a(<|>)=ReadP a -> ReadP a -> ReadP aforall a. ReadP a -> ReadP a -> ReadP a(+++)-- | @since 2.01instanceMonadPlusReadP-- ----------------------------------------------------------------------------- Operations over Pfinal::[(a,String)]->Pafinal :: [(a, String)] -> P afinal[]=P aforall a. P aFailfinal((a, String)r:[(a, String)]rs)=NonEmpty (a, String) -> P aforall a. NonEmpty (a, String) -> P aFinal((a, String)r(a, String) -> [(a, String)] -> NonEmpty (a, String)forall a. a -> [a] -> NonEmpty a:|[(a, String)]rs)run::Pa->ReadSarun :: P a -> ReadS arun(GetChar -> P af)(Charc:Strings)=P a -> ReadS aforall a. P a -> ReadS arun(Char -> P afCharc)Stringsrun(LookString -> P af)Strings=P a -> ReadS aforall a. P a -> ReadS arun(String -> P afStrings)Stringsrun(ResultaxP ap)Strings=(ax,Strings)(a, String) -> [(a, String)] -> [(a, String)]forall a. a -> [a] -> [a]:P a -> ReadS aforall a. P a -> ReadS arunP apStringsrun(Final((a, String)r:|[(a, String)]rs))String_=((a, String)r(a, String) -> [(a, String)] -> [(a, String)]forall a. a -> [a] -> [a]:[(a, String)]rs)runP a_String_=[]-- ----------------------------------------------------------------------------- Operations over ReadPget::ReadPChar-- ^ Consumes and returns the next character.--   Fails if there is no input left.get :: ReadP Charget=(forall a. (Char -> P a) -> P a) -> ReadP Charforall a. (forall b. (a -> P b) -> P b) -> ReadP aRforall a. (Char -> P a) -> P aGetlook::ReadPString-- ^ Look-ahead: returns the part of the input that is left, without--   consuming it.look :: ReadP Stringlook=(forall a. (String -> P a) -> P a) -> ReadP Stringforall a. (forall b. (a -> P b) -> P b) -> ReadP aRforall a. (String -> P a) -> P aLookpfail::ReadPa-- ^ Always fails.pfail :: ReadP apfail=(forall b. (a -> P b) -> P b) -> ReadP aforall a. (forall b. (a -> P b) -> P b) -> ReadP aR(\a -> P b_->P bforall a. P aFail)(+++)::ReadPa->ReadPa->ReadPa-- ^ Symmetric choice.Rforall b. (a -> P b) -> P bf1+++ :: ReadP a -> ReadP a -> ReadP a+++Rforall b. (a -> P b) -> P bf2=(forall b. (a -> P b) -> P b) -> ReadP aforall a. (forall b. (a -> P b) -> P b) -> ReadP aR(\a -> P bk->(a -> P b) -> P bforall b. (a -> P b) -> P bf1a -> P bkP b -> P b -> P bforall (f :: * -> *) a. Alternative f => f a -> f a -> f a<|>(a -> P b) -> P bforall b. (a -> P b) -> P bf2a -> P bk)(<++)::ReadPa->ReadPa->ReadPa-- ^ Local, exclusive, left-biased choice: If left parser--   locally produces any result at all, then right parser is--   not used.Rforall b. (a -> P b) -> P bf0<++ :: ReadP a -> ReadP a -> ReadP a<++ReadP aq=doStrings<-ReadP StringlookP a -> String -> Int# -> ReadP aprobe((a -> P a) -> P aforall b. (a -> P b) -> P bf0a -> P aforall (m :: * -> *) a. Monad m => a -> m areturn)StringsInt#0#whereprobe :: P a -> String -> Int# -> ReadP aprobe(GetChar -> P af)(Charc:Strings)Int#n=P a -> String -> Int# -> ReadP aprobe(Char -> P afCharc)Strings(Int#nInt# -> Int# -> Int#+#Int#1#)probe(LookString -> P af)StringsInt#n=P a -> String -> Int# -> ReadP aprobe(String -> P afStrings)StringsInt#nprobep :: P ap@(Resulta_P a_)String_Int#n=Int# -> ReadP ()discardInt#nReadP () -> ReadP a -> ReadP aforall (m :: * -> *) a b. Monad m => m a -> m b -> m b>>(forall b. (a -> P b) -> P b) -> ReadP aforall a. (forall b. (a -> P b) -> P b) -> ReadP aR(P apP a -> (a -> P b) -> P bforall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b>>=)probe(FinalNonEmpty (a, String)r)String_Int#_=(forall b. (a -> P b) -> P b) -> ReadP aforall a. (forall b. (a -> P b) -> P b) -> ReadP aR(NonEmpty (a, String) -> P aforall a. NonEmpty (a, String) -> P aFinalNonEmpty (a, String)rP a -> (a -> P b) -> P bforall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b>>=)probeP a_String_Int#_=ReadP aqdiscard :: Int# -> ReadP ()discardInt#0#=() -> ReadP ()forall (m :: * -> *) a. Monad m => a -> m areturn()discardInt#n=ReadP ChargetReadP Char -> ReadP () -> ReadP ()forall (m :: * -> *) a b. Monad m => m a -> m b -> m b>>Int# -> ReadP ()discard(Int#nInt# -> Int# -> Int#-#Int#1#)gather::ReadPa->ReadP(String,a)-- ^ Transforms a parser into one that does the same, but--   in addition returns the exact characters read.--   IMPORTANT NOTE: 'gather' gives a runtime error if its first argument--   is built using any occurrences of readS_to_P.gather :: ReadP a -> ReadP (String, a)gather(Rforall b. (a -> P b) -> P bm)=(forall b. ((String, a) -> P b) -> P b) -> ReadP (String, a)forall a. (forall b. (a -> P b) -> P b) -> ReadP aR(\(String, a) -> P bk->(String -> String) -> P (String -> P b) -> P bforall b. (String -> String) -> P (String -> P b) -> P bgathString -> Stringforall a. a -> aid((a -> P (String -> P b)) -> P (String -> P b)forall b. (a -> P b) -> P bm(\aa->(String -> P b) -> P (String -> P b)forall (m :: * -> *) a. Monad m => a -> m areturn(\Strings->(String, a) -> P bk(Strings,aa)))))wheregath::(String->String)->P(String->Pb)->Pbgath :: (String -> String) -> P (String -> P b) -> P bgathString -> Stringl(GetChar -> P (String -> P b)f)=(Char -> P b) -> P bforall a. (Char -> P a) -> P aGet(\Charc->(String -> String) -> P (String -> P b) -> P bforall b. (String -> String) -> P (String -> P b) -> P bgath(String -> Stringl(String -> String) -> (String -> String) -> String -> Stringforall b c a. (b -> c) -> (a -> b) -> a -> c.(CharcChar -> String -> Stringforall a. a -> [a] -> [a]:))(Char -> P (String -> P b)fCharc))gathString -> String_P (String -> P b)Fail=P bforall a. P aFailgathString -> Stringl(LookString -> P (String -> P b)f)=(String -> P b) -> P bforall a. (String -> P a) -> P aLook(\Strings->(String -> String) -> P (String -> P b) -> P bforall b. (String -> String) -> P (String -> P b) -> P bgathString -> Stringl(String -> P (String -> P b)fStrings))gathString -> Stringl(ResultString -> P bkP (String -> P b)p)=String -> P bk(String -> Stringl[])P b -> P b -> P bforall (f :: * -> *) a. Alternative f => f a -> f a -> f a<|>(String -> String) -> P (String -> P b) -> P bforall b. (String -> String) -> P (String -> P b) -> P bgathString -> StringlP (String -> P b)pgathString -> String_(FinalNonEmpty (String -> P b, String)_)=String -> P bforall a. String -> aerrorWithoutStackTraceString"do not use readS_to_P in gather!"-- ----------------------------------------------------------------------------- Derived operationssatisfy::(Char->Bool)->ReadPChar-- ^ Consumes and returns the next character, if it satisfies the--   specified predicate.satisfy :: (Char -> Bool) -> ReadP CharsatisfyChar -> Boolp=doCharc<-ReadP Charget;ifChar -> BoolpCharcthenChar -> ReadP Charforall (m :: * -> *) a. Monad m => a -> m areturnCharcelseReadP Charforall a. ReadP apfailchar::Char->ReadPChar-- ^ Parses and returns the specified character.char :: Char -> ReadP CharcharCharc=(Char -> Bool) -> ReadP Charsatisfy(CharcChar -> Char -> Boolforall a. Eq a => a -> a -> Bool==)eof::ReadP()-- ^ Succeeds iff we are at the end of inputeof :: ReadP ()eof=do{Strings<-ReadP Stringlook;ifString -> Boolforall a. [a] -> BoolnullStringsthen() -> ReadP ()forall (m :: * -> *) a. Monad m => a -> m areturn()elseReadP ()forall a. ReadP apfail}string::String->ReadPString-- ^ Parses and returns the specified string.string :: String -> ReadP StringstringStringthis=doStrings<-ReadP Stringlook;String -> String -> ReadP Stringforall a. Eq a => [a] -> [a] -> ReadP StringscanStringthisStringswherescan :: [a] -> [a] -> ReadP Stringscan[][a]_=doString -> ReadP Stringforall (m :: * -> *) a. Monad m => a -> m areturnStringthisscan(ax:[a]xs)(ay:[a]ys)|axa -> a -> Boolforall a. Eq a => a -> a -> Bool==ay=doChar_<-ReadP Charget;[a] -> [a] -> ReadP Stringscan[a]xs[a]ysscan[a]_[a]_=doReadP Stringforall a. ReadP apfailmunch::(Char->Bool)->ReadPString-- ^ Parses the first zero or more characters satisfying the predicate.--   Always succeeds, exactly once having consumed all the characters--   Hence NOT the same as (many (satisfy p))munch :: (Char -> Bool) -> ReadP StringmunchChar -> Boolp=doStrings<-ReadP StringlookString -> ReadP StringscanStringswherescan :: String -> ReadP Stringscan(Charc:Stringcs)|Char -> BoolpCharc=doChar_<-ReadP Charget;Strings<-String -> ReadP StringscanStringcs;String -> ReadP Stringforall (m :: * -> *) a. Monad m => a -> m areturn(CharcChar -> String -> Stringforall a. a -> [a] -> [a]:Strings)scanString_=doString -> ReadP Stringforall (m :: * -> *) a. Monad m => a -> m areturnString""munch1::(Char->Bool)->ReadPString-- ^ Parses the first one or more characters satisfying the predicate.--   Fails if none, else succeeds exactly once having consumed all the characters--   Hence NOT the same as (many1 (satisfy p))munch1 :: (Char -> Bool) -> ReadP Stringmunch1Char -> Boolp=doCharc<-ReadP ChargetifChar -> BoolpCharcthendoStrings<-(Char -> Bool) -> ReadP StringmunchChar -> Boolp;String -> ReadP Stringforall (m :: * -> *) a. Monad m => a -> m areturn(CharcChar -> String -> Stringforall a. a -> [a] -> [a]:Strings)elseReadP Stringforall a. ReadP apfailchoice::[ReadPa]->ReadPa-- ^ Combines all parsers in the specified list.choice :: [ReadP a] -> ReadP achoice[]=ReadP aforall a. ReadP apfailchoice[ReadP ap]=ReadP apchoice(ReadP ap:[ReadP a]ps)=ReadP apReadP a -> ReadP a -> ReadP aforall a. ReadP a -> ReadP a -> ReadP a+++[ReadP a] -> ReadP aforall a. [ReadP a] -> ReadP achoice[ReadP a]psskipSpaces::ReadP()-- ^ Skips all whitespace.skipSpaces :: ReadP ()skipSpaces=doStrings<-ReadP StringlookString -> ReadP ()skipStringswhereskip :: String -> ReadP ()skip(Charc:Strings)|Char -> BoolisSpaceCharc=doChar_<-ReadP Charget;String -> ReadP ()skipStringsskipString_=do() -> ReadP ()forall (m :: * -> *) a. Monad m => a -> m areturn()count::Int->ReadPa->ReadP[a]-- ^ @count n p@ parses @n@ occurrences of @p@ in sequence. A list of--   results is returned.count :: Int -> ReadP a -> ReadP [a]countIntnReadP ap=[ReadP a] -> ReadP [a]forall (m :: * -> *) a. Monad m => [m a] -> m [a]sequence(Int -> ReadP a -> [ReadP a]forall a. Int -> a -> [a]replicateIntnReadP ap)between::ReadPopen->ReadPclose->ReadPa->ReadPa-- ^ @between open close p@ parses @open@, followed by @p@ and finally--   @close@. Only the value of @p@ is returned.between :: ReadP open -> ReadP close -> ReadP a -> ReadP abetweenReadP openopenReadP closecloseReadP ap=doopen_<-ReadP openopenax<-ReadP apclose_<-ReadP closeclosea -> ReadP aforall (m :: * -> *) a. Monad m => a -> m areturnaxoption::a->ReadPa->ReadPa-- ^ @option x p@ will either parse @p@ or return @x@ without consuming--   any input.option :: a -> ReadP a -> ReadP aoptionaxReadP ap=ReadP apReadP a -> ReadP a -> ReadP aforall a. ReadP a -> ReadP a -> ReadP a+++a -> ReadP aforall (m :: * -> *) a. Monad m => a -> m areturnaxoptional::ReadPa->ReadP()-- ^ @optional p@ optionally parses @p@ and always returns @()@.optional :: ReadP a -> ReadP ()optionalReadP ap=(ReadP apReadP a -> ReadP () -> ReadP ()forall (m :: * -> *) a b. Monad m => m a -> m b -> m b>>() -> ReadP ()forall (m :: * -> *) a. Monad m => a -> m areturn())ReadP () -> ReadP () -> ReadP ()forall a. ReadP a -> ReadP a -> ReadP a+++() -> ReadP ()forall (m :: * -> *) a. Monad m => a -> m areturn()many::ReadPa->ReadP[a]-- ^ Parses zero or more occurrences of the given parser.many :: ReadP a -> ReadP [a]manyReadP ap=[a] -> ReadP [a]forall (m :: * -> *) a. Monad m => a -> m areturn[]ReadP [a] -> ReadP [a] -> ReadP [a]forall a. ReadP a -> ReadP a -> ReadP a+++ReadP a -> ReadP [a]forall a. ReadP a -> ReadP [a]many1ReadP apmany1::ReadPa->ReadP[a]-- ^ Parses one or more occurrences of the given parser.many1 :: ReadP a -> ReadP [a]many1ReadP ap=(a -> [a] -> [a]) -> ReadP a -> ReadP [a] -> ReadP [a]forall (m :: * -> *) a1 a2 r.Monad m =>(a1 -> a2 -> r) -> m a1 -> m a2 -> m rliftM2(:)ReadP ap(ReadP a -> ReadP [a]forall a. ReadP a -> ReadP [a]manyReadP ap)skipMany::ReadPa->ReadP()-- ^ Like 'many', but discards the result.skipMany :: ReadP a -> ReadP ()skipManyReadP ap=ReadP a -> ReadP [a]forall a. ReadP a -> ReadP [a]manyReadP apReadP [a] -> ReadP () -> ReadP ()forall (m :: * -> *) a b. Monad m => m a -> m b -> m b>>() -> ReadP ()forall (m :: * -> *) a. Monad m => a -> m areturn()skipMany1::ReadPa->ReadP()-- ^ Like 'many1', but discards the result.skipMany1 :: ReadP a -> ReadP ()skipMany1ReadP ap=ReadP apReadP a -> ReadP () -> ReadP ()forall (m :: * -> *) a b. Monad m => m a -> m b -> m b>>ReadP a -> ReadP ()forall a. ReadP a -> ReadP ()skipManyReadP apsepBy::ReadPa->ReadPsep->ReadP[a]-- ^ @sepBy p sep@ parses zero or more occurrences of @p@, separated by @sep@.--   Returns a list of values returned by @p@.sepBy :: ReadP a -> ReadP sep -> ReadP [a]sepByReadP apReadP sepsep=ReadP a -> ReadP sep -> ReadP [a]forall a sep. ReadP a -> ReadP sep -> ReadP [a]sepBy1ReadP apReadP sepsepReadP [a] -> ReadP [a] -> ReadP [a]forall a. ReadP a -> ReadP a -> ReadP a+++[a] -> ReadP [a]forall (m :: * -> *) a. Monad m => a -> m areturn[]sepBy1::ReadPa->ReadPsep->ReadP[a]-- ^ @sepBy1 p sep@ parses one or more occurrences of @p@, separated by @sep@.--   Returns a list of values returned by @p@.sepBy1 :: ReadP a -> ReadP sep -> ReadP [a]sepBy1ReadP apReadP sepsep=(a -> [a] -> [a]) -> ReadP a -> ReadP [a] -> ReadP [a]forall (m :: * -> *) a1 a2 r.Monad m =>(a1 -> a2 -> r) -> m a1 -> m a2 -> m rliftM2(:)ReadP ap(ReadP a -> ReadP [a]forall a. ReadP a -> ReadP [a]many(ReadP sepsepReadP sep -> ReadP a -> ReadP aforall (m :: * -> *) a b. Monad m => m a -> m b -> m b>>ReadP ap))endBy::ReadPa->ReadPsep->ReadP[a]-- ^ @endBy p sep@ parses zero or more occurrences of @p@, separated and ended--   by @sep@.endBy :: ReadP a -> ReadP sep -> ReadP [a]endByReadP apReadP sepsep=ReadP a -> ReadP [a]forall a. ReadP a -> ReadP [a]many(doax<-ReadP ap;sep_<-ReadP sepsep;a -> ReadP aforall (m :: * -> *) a. Monad m => a -> m areturnax)endBy1::ReadPa->ReadPsep->ReadP[a]-- ^ @endBy p sep@ parses one or more occurrences of @p@, separated and ended--   by @sep@.endBy1 :: ReadP a -> ReadP sep -> ReadP [a]endBy1ReadP apReadP sepsep=ReadP a -> ReadP [a]forall a. ReadP a -> ReadP [a]many1(doax<-ReadP ap;sep_<-ReadP sepsep;a -> ReadP aforall (m :: * -> *) a. Monad m => a -> m areturnax)chainr::ReadPa->ReadP(a->a->a)->a->ReadPa-- ^ @chainr p op x@ parses zero or more occurrences of @p@, separated by @op@.--   Returns a value produced by a /right/ associative application of all--   functions returned by @op@. If there are no occurrences of @p@, @x@ is--   returned.chainr :: ReadP a -> ReadP (a -> a -> a) -> a -> ReadP achainrReadP apReadP (a -> a -> a)opax=ReadP a -> ReadP (a -> a -> a) -> ReadP aforall a. ReadP a -> ReadP (a -> a -> a) -> ReadP achainr1ReadP apReadP (a -> a -> a)opReadP a -> ReadP a -> ReadP aforall a. ReadP a -> ReadP a -> ReadP a+++a -> ReadP aforall (m :: * -> *) a. Monad m => a -> m areturnaxchainl::ReadPa->ReadP(a->a->a)->a->ReadPa-- ^ @chainl p op x@ parses zero or more occurrences of @p@, separated by @op@.--   Returns a value produced by a /left/ associative application of all--   functions returned by @op@. If there are no occurrences of @p@, @x@ is--   returned.chainl :: ReadP a -> ReadP (a -> a -> a) -> a -> ReadP achainlReadP apReadP (a -> a -> a)opax=ReadP a -> ReadP (a -> a -> a) -> ReadP aforall a. ReadP a -> ReadP (a -> a -> a) -> ReadP achainl1ReadP apReadP (a -> a -> a)opReadP a -> ReadP a -> ReadP aforall a. ReadP a -> ReadP a -> ReadP a+++a -> ReadP aforall (m :: * -> *) a. Monad m => a -> m areturnaxchainr1::ReadPa->ReadP(a->a->a)->ReadPa-- ^ Like 'chainr', but parses one or more occurrences of @p@.chainr1 :: ReadP a -> ReadP (a -> a -> a) -> ReadP achainr1ReadP apReadP (a -> a -> a)op=ReadP ascanwherescan :: ReadP ascan=ReadP apReadP a -> (a -> ReadP a) -> ReadP aforall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b>>=a -> ReadP arestrest :: a -> ReadP arestax=doa -> a -> af<-ReadP (a -> a -> a)opay<-ReadP ascana -> ReadP aforall (m :: * -> *) a. Monad m => a -> m areturn(a -> a -> afaxay)ReadP a -> ReadP a -> ReadP aforall a. ReadP a -> ReadP a -> ReadP a+++a -> ReadP aforall (m :: * -> *) a. Monad m => a -> m areturnaxchainl1::ReadPa->ReadP(a->a->a)->ReadPa-- ^ Like 'chainl', but parses one or more occurrences of @p@.chainl1 :: ReadP a -> ReadP (a -> a -> a) -> ReadP achainl1ReadP apReadP (a -> a -> a)op=ReadP apReadP a -> (a -> ReadP a) -> ReadP aforall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b>>=a -> ReadP arestwhererest :: a -> ReadP arestax=doa -> a -> af<-ReadP (a -> a -> a)opay<-ReadP apa -> ReadP arest(a -> a -> afaxay)ReadP a -> ReadP a -> ReadP aforall a. ReadP a -> ReadP a -> ReadP a+++a -> ReadP aforall (m :: * -> *) a. Monad m => a -> m areturnaxmanyTill::ReadPa->ReadPend->ReadP[a]-- ^ @manyTill p end@ parses zero or more occurrences of @p@, until @end@--   succeeds. Returns a list of values returned by @p@.manyTill :: ReadP a -> ReadP end -> ReadP [a]manyTillReadP apReadP endend=ReadP [a]scanwherescan :: ReadP [a]scan=(ReadP endendReadP end -> ReadP [a] -> ReadP [a]forall (m :: * -> *) a b. Monad m => m a -> m b -> m b>>[a] -> ReadP [a]forall (m :: * -> *) a. Monad m => a -> m areturn[])ReadP [a] -> ReadP [a] -> ReadP [a]forall a. ReadP a -> ReadP a -> ReadP a<++((a -> [a] -> [a]) -> ReadP a -> ReadP [a] -> ReadP [a]forall (m :: * -> *) a1 a2 r.Monad m =>(a1 -> a2 -> r) -> m a1 -> m a2 -> m rliftM2(:)ReadP apReadP [a]scan)-- ----------------------------------------------------------------------------- Converting between ReadP and ReadreadP_to_S::ReadPa->ReadSa-- ^ Converts a parser into a Haskell ReadS-style function.--   This is the main way in which you can \"run\" a 'ReadP' parser:--   the expanded type is-- @ readP_to_S :: ReadP a -> String -> [(a,String)] @readP_to_S :: ReadP a -> ReadS areadP_to_S(Rforall b. (a -> P b) -> P bf)=P a -> ReadS aforall a. P a -> ReadS arun((a -> P a) -> P aforall b. (a -> P b) -> P bfa -> P aforall (m :: * -> *) a. Monad m => a -> m areturn)readS_to_P::ReadSa->ReadPa-- ^ Converts a Haskell ReadS-style function into a parser.--   Warning: This introduces local backtracking in the resulting--   parser, and therefore a possible inefficiency.readS_to_P :: ReadS a -> ReadP areadS_to_PReadS ar=(forall b. (a -> P b) -> P b) -> ReadP aforall a. (forall b. (a -> P b) -> P b) -> ReadP aR(\a -> P bk->(String -> P b) -> P bforall a. (String -> P a) -> P aLook(\Strings->[(b, String)] -> P bforall a. [(a, String)] -> P afinal[(b, String)bs''|(aa,Strings')<-ReadS arStrings,(b, String)bs''<-P b -> ReadS bforall a. P a -> ReadS arun(a -> P bkaa)Strings']))-- ----------------------------------------------------------------------------- QuickCheck properties that hold for the combinators{- $propertiesThe following are QuickCheck specifications of what the combinators do.These can be seen as formal specifications of the behavior of thecombinators.For some values, we only care about the lists contents, not their order,> (=~) :: Ord a => [a] -> [a] -> Bool> xs =~ ys = sort xs == sort ysHere follow the properties:>>> readP_to_S get [][]prop> \c str -> readP_to_S get (c:str) == [(c, str)]prop> \str -> readP_to_S look str == [(str, str)]prop> \str -> readP_to_S pfail str == []prop> \x str -> readP_to_S (return x) s == [(x,s)]> prop_Bind p k s =>    readP_to_S (p >>= k) s =~>      [ ys''>      | (x,s') <- readP_to_S p s>      , ys''   <- readP_to_S (k (x::Int)) s'>      ]> prop_Plus p q s =>   readP_to_S (p +++ q) s =~>     (readP_to_S p s ++ readP_to_S q s)> prop_LeftPlus p q s =>   readP_to_S (p <++ q) s =~>     (readP_to_S p s +<+ readP_to_S q s)>  where>   [] +<+ ys = ys>   xs +<+ _  = xs> prop_Gather s =>   forAll readPWithoutReadS $ \p ->>     readP_to_S (gather p) s =~>       [ ((pre,x::Int),s')>       | (x,s') <- readP_to_S p s>       , let pre = take (length s - length s') s>       ]prop> \this str -> readP_to_S (string this) (this ++ str) == [(this,str)]> prop_String_Maybe this s =>   readP_to_S (string this) s =~>     [(this, drop (length this) s) | this `isPrefixOf` s]> prop_Munch p s =>   readP_to_S (munch p) s =~>     [(takeWhile p s, dropWhile p s)]> prop_Munch1 p s =>   readP_to_S (munch1 p) s =~>     [(res,s') | let (res,s') = (takeWhile p s, dropWhile p s), not (null res)]> prop_Choice ps s =>   readP_to_S (choice ps) s =~>     readP_to_S (foldr (+++) pfail ps) s> prop_ReadS r s =>   readP_to_S (readS_to_P r) s =~ r s-}