module Text.Papillon.Parser (
Lookahead(..),
Lists(..),
Peg,
Definition,
Selection,
Expression,
Check,
ReadFrom(..),
hsw,
pprCheck,
parse,
Source(..),
SourceList(..),
Derivs(pegFile, peg, char),
ParseError(..),
mkParseError,
pePositionS,
Pos(..),
ListPos(..),
PPragma(..),
ModuleName,
Exports,
Code,
runError,
dvCharsN
) where
import Text.Papillon.Papillon
import "monads-tf" Control.Monad.State
import "monads-tf" Control.Monad.Error
import Control.Applicative(Applicative, (<$>), (<*>))
import Language.Haskell.TH
import Data.Char (isDigit, isUpper, isLower, isAlphaNum, isHexDigit, chr)
import Numeric (readHex)
import Language.Haskell.TH.PprLib
((<>), hsep, colon, brackets, text, braces, Doc, parens, (<+>), quotes)
import qualified Language.Haskell.TH.PprLib as P
import Control.Arrow ((***))
import Data.List
import Data.Maybe
data Lookahead = Here | Ahead | NAhead String deriving (Show, Eq)
data Lists = List | List1 | Optional deriving (Show, Eq)
type PegFile = ([PPragma], ModuleName, Maybe Exports, Code, STPeg, Code)
data PPragma = LanguagePragma [String] | OtherPragma String deriving Show
type ModuleName = [String]
type Exports = String
type Code = String
type STPeg = (Maybe Type, Type, Peg)
type Peg = [Definition]
type Definition = (String, Maybe Type, Selection)
type Selection = [Expression]
type Expression = Either ([(Lookahead, Check)], Maybe Exp) Exp
type Check = Either ((Pat, String), ReadFrom, Maybe (Exp, String)) (Char, Lists)
data ReadFrom
= FromVariable (Maybe String)
| FromSelection Selection
| FromL Lists ReadFrom
deriving Show
pprCheck :: Check -> Doc
pprCheck (Left ((pt, _), rf, tst)) =
ppr pt <> colon <> ppr rf <> maybe P.empty (brackets . ppr . fst) tst
pprCheck (Right (c, l)) = quotes (P.char c) <> ppr l
instance Ppr ReadFrom where
ppr (FromVariable (Just v)) = text v
ppr (FromVariable _) = P.empty
ppr (FromL l rf) = ppr rf <> ppr l
ppr (FromSelection sel) = parens $ ps sel
where
ps = hsep . intersperse (P.char '/') . map pe
pe (Left (ex, hs)) = (<+> braces (maybe P.empty ppr hs)) $ hsep $
map (uncurry ($) . (((<>) . ppr) *** pprCheck)) ex
pe (Right ex) = P.char '<' <> ppr ex <> P.char '>'
instance Ppr Lookahead where
ppr Here = P.empty
ppr Ahead = P.char '&'
ppr (NAhead _) = P.char '!'
instance Ppr Lists where
ppr List = P.char '*'
ppr List1 = P.char '+'
ppr Optional = P.char '?'
mkPegFile :: [PPragma] -> Maybe ([String], Maybe String) -> String -> String ->
STPeg -> String -> PegFile
mkPegFile ps (Just md) x y z w = (ps, fst md, snd md, x ++ "\n" ++ y, z, w)
mkPegFile ps Nothing x y z w = (ps, [], Nothing, x ++ "\n" ++ y, z, w)
dvCharsN :: String
dvCharsN = "char"
opChars :: String
opChars = ":!#$%&*+./<=>?@\\^|-~"
data Word
= WSymbol String
| WType [String] String
| WVar [String] String
| WOpCon String
| WOp String
| WChar Char
| WString String
| WInteger Integer
| WOQuasiQuote String
| WCQuasiQuote
| WModule
| WWhere
| WImport
| WTypeDef
| WRightArrow
| WDotDot
| WOComment
| WCComment
| WBang
| WAmp
| WAsterisk
| WPlus
| WQuestion
| WEqual
| WSlash
| WColon
| WLT
| WGT
| WOBracket
| WCBracket
| WOBrace
| WCBrace
| WOParen
| WCParen
| WComma
| WSemiColon
| WBackQuote
deriving Show
data Derivs
= Derivs {pegFile :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((PegFile, Derivs))),
pragma :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((PPragma, Derivs))),
pragmaStr :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((String, Derivs))),
pragmaItems :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
(([String], Derivs))),
moduleDec :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((Maybe (([String], Maybe String)), Derivs))),
moduleName :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((ModuleName, Derivs))),
moduleDecStr :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((String, Derivs))),
whr :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
(((), Derivs))),
preImpPap :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((String, Derivs))),
prePeg :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((String, Derivs))),
afterPeg :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((String, Derivs))),
importPapillon :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
(((), Derivs))),
peg :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((STPeg, Derivs))),
peg_ :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((STPeg, Derivs))),
monadType :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((Type, Derivs))),
sourceType :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((Type, Derivs))),
definition :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((Definition, Derivs))),
selection :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
(([Expression], Derivs))),
normalSelection :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
(([Expression], Derivs))),
expressionHs :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((Expression, Derivs))),
expressionHsSugar :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((Expression, Derivs))),
expressionHsSugar' :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((Expression, Derivs))),
expression :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
(([(Lookahead, Check)], Derivs))),
nameLeaf_ :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
(((Lookahead, Check), Derivs))),
nameLeaf :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((Check, Derivs))),
nameLeafNoCom :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((Check, Derivs))),
comForErr :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((String, Derivs))),
leaf :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
(((ReadFrom, Maybe ((Exp, String))), Derivs))),
patOp :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((Pat, Derivs))),
pat :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((Pat, Derivs))),
pat1 :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((Pat, Derivs))),
patList :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
(([Pat], Derivs))),
pats :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
(([Pat], Derivs))),
charLitLs :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((Check, Derivs))),
readFromLs :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((ReadFrom, Derivs))),
readFrom :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((ReadFrom, Derivs))),
test :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
(((Exp, String), Derivs))),
hsExpLam :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((Exp, Derivs))),
hsExpTyp :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((Exp, Derivs))),
hsExpOp :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((Exp, Derivs))),
hsOp :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((Exp, Derivs))),
hsExpLam' :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((Exp, Derivs))),
hsExpTyp' :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((Exp, Derivs))),
hsExpOp' :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((Exp, Derivs))),
hsOp' :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((Exp, Derivs))),
hsExp :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
(((Exp -> Exp) -> Exp, Derivs))),
hsExp1 :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((Exp, Derivs))),
hsExpTpl :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
(([Exp], Derivs))),
hsTypeArr :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((Type, Derivs))),
hsType :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
(((Type -> Type) -> Type, Derivs))),
hsType1 :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((Type, Derivs))),
hsTypeTpl :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
(([Type], Derivs))),
wrd :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((Word, Derivs))),
hsw :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((Word, Derivs))),
word :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((Word, Derivs))),
hsWord :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((Word, Derivs))),
bras :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((Word, Derivs))),
typ :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((String, Derivs))),
var :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((String, Derivs))),
strLit :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((String, Derivs))),
escChar :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((Char, Derivs))),
space :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
(((), Derivs))),
space' :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
(((), Derivs))),
lineComment :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
(((), Derivs))),
comment :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
(((), Derivs))),
comments :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
(((), Derivs))),
comStr :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
(((), Derivs))),
semiColon :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
(((), Derivs))),
notSemiColon :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
(((), Derivs))),
char :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((Token String, Derivs))),
position :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((Pos String, Derivs)))}
parse :: String -> Derivs
parse = parse1522_0 initialPos
where parse1522_0 pos1521_1 s1523_2 = d142_3
where d142_3 = Derivs pegFile1_4 pragma2_5 pragmaStr3_6 pragmaItems4_7 moduleDec5_8 moduleName6_9 moduleDecStr7_10 whr8_11 preImpPap9_12 prePeg10_13 afterPeg11_14 importPapillon12_15 peg13_16 peg_14_17 monadType15_18 sourceType16_19 definition17_20 selection18_21 normalSelection19_22 expressionHs20_23 expressionHsSugar21_24 expressionHsSugar'22_25 expression23_26 nameLeaf_24_27 nameLeaf25_28 nameLeafNoCom26_29 comForErr27_30 leaf28_31 patOp29_32 pat30_33 pat131_34 patList32_35 pats33_36 charLitLs34_37 readFromLs35_38 readFrom36_39 test37_40 hsExpLam38_41 hsExpTyp39_42 hsExpOp40_43 hsOp41_44 hsExpLam'42_45 hsExpTyp'43_46 hsExpOp'44_47 hsOp'45_48 hsExp46_49 hsExp147_50 hsExpTpl48_51 hsTypeArr49_52 hsType50_53 hsType151_54 hsTypeTpl52_55 wrd53_56 hsw54_57 word55_58 hsWord56_59 bras57_60 typ58_61 var59_62 strLit60_63 escChar61_64 space62_65 space'63_66 lineComment64_67 comment65_68 comments66_69 comStr67_70 semiColon68_71 notSemiColon69_72 chars1524_73 (return (pos1521_1,
d142_3))
pegFile1_4 = runStateT pegFile70_74 d142_3
pragma2_5 = runStateT pragma71_75 d142_3
pragmaStr3_6 = runStateT pragmaStr72_76 d142_3
pragmaItems4_7 = runStateT pragmaItems73_77 d142_3
moduleDec5_8 = runStateT moduleDec74_78 d142_3
moduleName6_9 = runStateT moduleName75_79 d142_3
moduleDecStr7_10 = runStateT moduleDecStr76_80 d142_3
whr8_11 = runStateT whr77_81 d142_3
preImpPap9_12 = runStateT preImpPap78_82 d142_3
prePeg10_13 = runStateT prePeg79_83 d142_3
afterPeg11_14 = runStateT afterPeg80_84 d142_3
importPapillon12_15 = runStateT importPapillon81_85 d142_3
peg13_16 = runStateT peg82_86 d142_3
peg_14_17 = runStateT peg_83_87 d142_3
monadType15_18 = runStateT monadType84_88 d142_3
sourceType16_19 = runStateT sourceType85_89 d142_3
definition17_20 = runStateT definition86_90 d142_3
selection18_21 = runStateT selection87_91 d142_3
normalSelection19_22 = runStateT normalSelection88_92 d142_3
expressionHs20_23 = runStateT expressionHs89_93 d142_3
expressionHsSugar21_24 = runStateT expressionHsSugar90_94 d142_3
expressionHsSugar'22_25 = runStateT expressionHsSugar'91_95 d142_3
expression23_26 = runStateT expression92_96 d142_3
nameLeaf_24_27 = runStateT nameLeaf_93_97 d142_3
nameLeaf25_28 = runStateT nameLeaf94_98 d142_3
nameLeafNoCom26_29 = runStateT nameLeafNoCom95_99 d142_3
comForErr27_30 = runStateT comForErr96_100 d142_3
leaf28_31 = runStateT leaf97_101 d142_3
patOp29_32 = runStateT patOp98_102 d142_3
pat30_33 = runStateT pat99_103 d142_3
pat131_34 = runStateT pat1100_104 d142_3
patList32_35 = runStateT patList101_105 d142_3
pats33_36 = runStateT pats102_106 d142_3
charLitLs34_37 = runStateT charLitLs103_107 d142_3
readFromLs35_38 = runStateT readFromLs104_108 d142_3
readFrom36_39 = runStateT readFrom105_109 d142_3
test37_40 = runStateT test106_110 d142_3
hsExpLam38_41 = runStateT hsExpLam107_111 d142_3
hsExpTyp39_42 = runStateT hsExpTyp108_112 d142_3
hsExpOp40_43 = runStateT hsExpOp109_113 d142_3
hsOp41_44 = runStateT hsOp110_114 d142_3
hsExpLam'42_45 = runStateT hsExpLam'111_115 d142_3
hsExpTyp'43_46 = runStateT hsExpTyp'112_116 d142_3
hsExpOp'44_47 = runStateT hsExpOp'113_117 d142_3
hsOp'45_48 = runStateT hsOp'114_118 d142_3
hsExp46_49 = runStateT hsExp115_119 d142_3
hsExp147_50 = runStateT hsExp1116_120 d142_3
hsExpTpl48_51 = runStateT hsExpTpl117_121 d142_3
hsTypeArr49_52 = runStateT hsTypeArr118_122 d142_3
hsType50_53 = runStateT hsType119_123 d142_3
hsType151_54 = runStateT hsType1120_124 d142_3
hsTypeTpl52_55 = runStateT hsTypeTpl121_125 d142_3
wrd53_56 = runStateT wrd122_126 d142_3
hsw54_57 = runStateT hsw123_127 d142_3
word55_58 = runStateT word124_128 d142_3
hsWord56_59 = runStateT hsWord125_129 d142_3
bras57_60 = runStateT bras126_130 d142_3
typ58_61 = runStateT typ127_131 d142_3
var59_62 = runStateT var128_132 d142_3
strLit60_63 = runStateT strLit129_133 d142_3
escChar61_64 = runStateT escChar130_134 d142_3
space62_65 = runStateT space131_135 d142_3
space'63_66 = runStateT space'132_136 d142_3
lineComment64_67 = runStateT lineComment133_137 d142_3
comment65_68 = runStateT comment134_138 d142_3
comments66_69 = runStateT comments135_139 d142_3
comStr67_70 = runStateT comStr136_140 d142_3
semiColon68_71 = runStateT semiColon137_141 d142_3
notSemiColon69_72 = runStateT notSemiColon138_142 d142_3
chars1524_73 = runStateT (case getToken s1523_2 of
Just (c1506_143,
s'1520_144) -> do put (parse1522_0 (updatePos c1506_143 pos1521_1) s'1520_144)
return c1506_143
_ -> StateT position >>= (throwError . mkParseError "" "end of input" "" undefined [])) d142_3
pegFile70_74 = foldl1 mplus [do pr <- list140_145 (StateT pragma)
md <- StateT moduleDec
pip <- StateT preImpPap
_ <- StateT importPapillon
return ()
pp <- StateT prePeg
d147_146 <- get
t610_147 <- StateT hsw
case t610_147 of
(WOQuasiQuote "papillon") -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WOQuasiQuote \"papillon\")" "not match pattern: " "" d147_146 ["hsw"])
let (WOQuasiQuote "papillon") = t610_147
return ()
p <- StateT peg_
d149_148 <- get
t612_149 <- StateT hsw
case t612_149 of
WCQuasiQuote -> return ()
_ -> StateT position >>= (throwError . mkParseError "WCQuasiQuote" "not match pattern: " "" d149_148 ["hsw"])
let WCQuasiQuote = t612_149
return ()
atp <- StateT afterPeg
lift (lift (return $ mkPegFile pr md pip pp p atp)),
do pr <- list140_145 (StateT pragma)
md <- StateT moduleDec
pp <- StateT prePeg
d154_150 <- get
t617_151 <- StateT hsw
case t617_151 of
(WOQuasiQuote "papillon") -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WOQuasiQuote \"papillon\")" "not match pattern: " "" d154_150 ["hsw"])
let (WOQuasiQuote "papillon") = t617_151
return ()
p <- StateT peg_
d156_152 <- get
t619_153 <- StateT hsw
case t619_153 of
WCQuasiQuote -> return ()
_ -> StateT position >>= (throwError . mkParseError "WCQuasiQuote" "not match pattern: " "" d156_152 ["hsw"])
let WCQuasiQuote = t619_153
return ()
atp <- StateT afterPeg
lift (lift (return $ mkPegFile pr md [] pp p atp))]
pragma71_75 = foldl1 mplus [do d158_154 <- get
t621_155 <- StateT hsw
case t621_155 of
WOComment -> return ()
_ -> StateT position >>= (throwError . mkParseError "WOComment" "not match pattern: " "" d158_154 ["hsw"])
let WOComment = t621_155
return ()
d159_156 <- get
t622_157 <- StateT hsw
case t622_157 of
(WType [] "LANGUAGE") -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WType [] \"LANGUAGE\")" "not match pattern: " "" d159_156 ["hsw"])
let (WType [] "LANGUAGE") = t622_157
return ()
s <- StateT pragmaItems
d161_158 <- get
t624_159 <- StateT hsw
case t624_159 of
WCComment -> return ()
_ -> StateT position >>= (throwError . mkParseError "WCComment" "not match pattern: " "" d161_158 ["hsw"])
let WCComment = t624_159
return ()
lift (lift (return $ LanguagePragma s)),
do d162_160 <- get
t625_161 <- StateT hsw
case t625_161 of
WOComment -> return ()
_ -> StateT position >>= (throwError . mkParseError "WOComment" "not match pattern: " "" d162_160 ["hsw"])
let WOComment = t625_161
return ()
s <- StateT pragmaStr
d164_162 <- get
t627_163 <- StateT hsw
case t627_163 of
WCComment -> return ()
_ -> StateT position >>= (throwError . mkParseError "WCComment" "not match pattern: " "" d164_162 ["hsw"])
let WCComment = t627_163
return ()
lift (lift (return $ OtherPragma s))]
pragmaStr72_76 = foldl1 mplus [do d166_164 <- get
do err1494_165 <- ((do d165_166 <- get
t628_167 <- StateT hsw
case t628_167 of
WCComment -> return ()
_ -> StateT position >>= (throwError . mkParseError "WCComment" "not match pattern: " "" d165_166 ["hsw"])
let WCComment = t628_167
return ()) >> return False) `catchError` const (return True)
unless err1494_165 (StateT position >>= (throwError . mkParseError "!WCComment:hsw" "not match: " "" d166_164 ["hsw"]))
put d166_164
c <- StateT char
s <- StateT pragmaStr
lift (lift (return $ c : s)),
lift (lift (return ""))]
pragmaItems73_77 = foldl1 mplus [do d169_168 <- get
t631_169 <- StateT hsw
case t631_169 of
(WType [] _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WType [] t)" "not match pattern: " "" d169_168 ["hsw"])
let (WType [] t) = t631_169
return ()
d170_170 <- get
t632_171 <- StateT hsw
case t632_171 of
WComma -> return ()
_ -> StateT position >>= (throwError . mkParseError "WComma" "not match pattern: " "" d170_170 ["hsw"])
let WComma = t632_171
return ()
i <- StateT pragmaItems
lift (lift (return $ t : i)),
do d172_172 <- get
t634_173 <- StateT hsw
case t634_173 of
(WType [] _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WType [] t)" "not match pattern: " "" d172_172 ["hsw"])
let (WType [] t) = t634_173
return ()
lift (lift (return [t]))]
moduleDec74_78 = foldl1 mplus [do d173_174 <- get
t635_175 <- StateT hsw
case t635_175 of
WModule -> return ()
_ -> StateT position >>= (throwError . mkParseError "WModule" "not match pattern: " "" d173_174 ["hsw"])
let WModule = t635_175
return ()
n <- StateT moduleName
d175_176 <- get
t637_177 <- StateT hsw
case t637_177 of
WOParen -> return ()
_ -> StateT position >>= (throwError . mkParseError "WOParen" "not match pattern: " "" d175_176 ["hsw"])
let WOParen = t637_177
return ()
s <- StateT moduleDecStr
_ <- StateT whr
return ()
lift (lift (return $ Just (n, Just s))),
do d178_178 <- get
t640_179 <- StateT hsw
case t640_179 of
WModule -> return ()
_ -> StateT position >>= (throwError . mkParseError "WModule" "not match pattern: " "" d178_178 ["hsw"])
let WModule = t640_179
return ()
n <- StateT moduleName
d180_180 <- get
t642_181 <- StateT hsw
case t642_181 of
WWhere -> return ()
_ -> StateT position >>= (throwError . mkParseError "WWhere" "not match pattern: " "" d180_180 ["hsw"])
let WWhere = t642_181
return ()
lift (lift (return $ Just (n, Nothing))),
lift (lift (return Nothing))]
moduleName75_79 = foldl1 mplus [do d181_182 <- get
t643_183 <- StateT hsw
case t643_183 of
(WType _ _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WType m t)" "not match pattern: " "" d181_182 ["hsw"])
let (WType m t) = t643_183
return ()
lift (lift (return $ m ++ [t]))]
moduleDecStr76_80 = foldl1 mplus [do d183_184 <- get
do err1495_185 <- ((do _ <- StateT whr
return ()) >> return False) `catchError` const (return True)
unless err1495_185 (StateT position >>= (throwError . mkParseError "!_:whr" "not match: " "" d183_184 ["whr"]))
put d183_184
c <- StateT char
s <- StateT moduleDecStr
lift (lift (return $ c : s)),
lift (lift (return ""))]
whr77_81 = foldl1 mplus [do d186_186 <- get
t647_187 <- StateT hsw
case t647_187 of
WCParen -> return ()
_ -> StateT position >>= (throwError . mkParseError "WCParen" "not match pattern: " "" d186_186 ["hsw"])
let WCParen = t647_187
return ()
d187_188 <- get
t648_189 <- StateT hsw
case t648_189 of
WWhere -> return ()
_ -> StateT position >>= (throwError . mkParseError "WWhere" "not match pattern: " "" d187_188 ["hsw"])
let WWhere = t648_189
return ()
return ()]
preImpPap78_82 = foldl1 mplus [do d189_190 <- get
do err1496_191 <- ((do _ <- StateT importPapillon
return ()) >> return False) `catchError` const (return True)
unless err1496_191 (StateT position >>= (throwError . mkParseError "!_:importPapillon" "not match: " "" d189_190 ["importPapillon"]))
put d189_190
d191_192 <- get
do err1497_193 <- ((do d190_194 <- get
t650_195 <- StateT hsw
case t650_195 of
(WOQuasiQuote "papillon") -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WOQuasiQuote \"papillon\")" "not match pattern: " "" d190_194 ["hsw"])
let (WOQuasiQuote "papillon") = t650_195
return ()) >> return False) `catchError` const (return True)
unless err1497_193 (StateT position >>= (throwError . mkParseError "!(WOQuasiQuote \"papillon\"):hsw" "not match: " "" d191_192 ["hsw"]))
put d191_192
c <- StateT char
pip <- StateT preImpPap
lift (lift (return $ c : pip)),
lift (lift (return ""))]
prePeg79_83 = foldl1 mplus [do d195_196 <- get
do err1498_197 <- ((do d194_198 <- get
t653_199 <- StateT hsw
case t653_199 of
(WOQuasiQuote "papillon") -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WOQuasiQuote \"papillon\")" "not match pattern: " "" d194_198 ["hsw"])
let (WOQuasiQuote "papillon") = t653_199
return ()) >> return False) `catchError` const (return True)
unless err1498_197 (StateT position >>= (throwError . mkParseError "!(WOQuasiQuote \"papillon\"):hsw" "not match: " "" d195_196 ["hsw"]))
put d195_196
c <- StateT char
pp <- StateT prePeg
lift (lift (return $ c : pp)),
lift (lift (return ""))]
afterPeg80_84 = foldl1 mplus [do c <- StateT char
atp <- StateT afterPeg
lift (lift (return $ c : atp)),
lift (lift (return ""))]
importPapillon81_85 = foldl1 mplus [do d200_200 <- get
t658_201 <- StateT hsw
case t658_201 of
WImport -> return ()
_ -> StateT position >>= (throwError . mkParseError "WImport" "not match pattern: " "" d200_200 ["hsw"])
let WImport = t658_201
return ()
d201_202 <- get
t659_203 <- StateT hsw
case t659_203 of
(WType ["Text"] "Papillon") -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WType [\"Text\"] \"Papillon\")" "not match pattern: " "" d201_202 ["hsw"])
let (WType ["Text"] "Papillon") = t659_203
return ()
return ()]
peg82_86 = foldl1 mplus [do _ <- list140_145 (StateT space)
return ()
p <- StateT peg_
lift (lift (return p))]
peg_83_87 = foldl1 mplus [do mt <- optional139_204 (StateT monadType)
st <- optional139_204 (StateT sourceType)
p <- list140_145 (StateT definition)
lift (lift (return (mt,
fromMaybe (ConT $ mkName "String") st,
p)))]
monadType84_88 = foldl1 mplus [do d207_205 <- get
t665_206 <- StateT position
let (!(ListPos (CharPos (_, x)))) = t665_206
b1114_207 <- lift (lift (put (Just x) >> return True))
unless b1114_207 (StateT position >>= (throwError . mkParseError "put (Just x) >> return True" "not match: " "" d207_205 ["position"]))
d208_208 <- get
t666_209 <- StateT wrd
case t666_209 of
(WSymbol "monad") -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WSymbol \"monad\")" "not match pattern: " "" d208_208 ["wrd"])
let (WSymbol "monad") = t666_209
return ()
d209_210 <- get
t667_211 <- StateT wrd
case t667_211 of
WColon -> return ()
_ -> StateT position >>= (throwError . mkParseError "WColon" "not match pattern: " "" d209_210 ["wrd"])
let WColon = t667_211
return ()
t <- StateT hsTypeArr
d211_212 <- get
t669_213 <- StateT wrd
case t669_213 of
WSemiColon -> return ()
_ -> StateT position >>= (throwError . mkParseError "WSemiColon" "not match pattern: " "" d211_212 ["wrd"])
let WSemiColon = t669_213
return ()
lift (lift (put Nothing >> return t))]
sourceType85_89 = foldl1 mplus [do d212_214 <- get
t670_215 <- StateT position
let (!(ListPos (CharPos (_, x)))) = t670_215
b1119_216 <- lift (lift (put (Just x) >> return True))
unless b1119_216 (StateT position >>= (throwError . mkParseError "put (Just x) >> return True" "not match: " "" d212_214 ["position"]))
d213_217 <- get
t671_218 <- StateT wrd
case t671_218 of
(WSymbol "source") -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WSymbol \"source\")" "not match pattern: " "" d213_217 ["wrd"])
let (WSymbol "source") = t671_218
return ()
d214_219 <- get
t672_220 <- StateT wrd
case t672_220 of
WColon -> return ()
_ -> StateT position >>= (throwError . mkParseError "WColon" "not match pattern: " "" d214_219 ["wrd"])
let WColon = t672_220
return ()
t <- StateT hsTypeArr
d216_221 <- get
t674_222 <- StateT wrd
case t674_222 of
WSemiColon -> return ()
_ -> StateT position >>= (throwError . mkParseError "WSemiColon" "not match pattern: " "" d216_221 ["wrd"])
let WSemiColon = t674_222
return ()
lift (lift (put Nothing >> return t))]
definition86_90 = foldl1 mplus [do d217_223 <- get
t675_224 <- StateT position
let (!(ListPos (CharPos (_, x)))) = t675_224
b1124_225 <- lift (lift (put (Just x) >> return True))
unless b1124_225 (StateT position >>= (throwError . mkParseError "put (Just x) >> return True" "not match: " "" d217_223 ["position"]))
d218_226 <- get
t676_227 <- StateT wrd
case t676_227 of
(WSymbol _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WSymbol v)" "not match pattern: " "" d218_226 ["wrd"])
let (WSymbol v) = t676_227
return ()
mt <- optional139_204 (foldl1 mplus [do d220_228 <- get
t678_229 <- StateT hsw
case t678_229 of
WTypeDef -> return ()
_ -> StateT position >>= (throwError . mkParseError "WTypeDef" "not match pattern: " "" d220_228 ["hsw"])
let WTypeDef = t678_229
return ()
t <- StateT hsTypeArr
lift (lift (return t))])
d222_230 <- get
t680_231 <- StateT wrd
case t680_231 of
WEqual -> return ()
_ -> StateT position >>= (throwError . mkParseError "WEqual" "not match pattern: " "" d222_230 ["wrd"])
let WEqual = t680_231
return ()
sel <- StateT selection
d224_232 <- get
t682_233 <- StateT wrd
case t682_233 of
WSemiColon -> return ()
_ -> StateT position >>= (throwError . mkParseError "WSemiColon" "not match pattern: " "" d224_232 ["wrd"])
let WSemiColon = t682_233
return ()
lift (lift (put Nothing >> return (v, mt, sel)))]
selection87_91 = foldl1 mplus [do ns <- StateT normalSelection
lift (lift (return ns))]
normalSelection88_92 = foldl1 mplus [do ex <- StateT expressionHs
d227_234 <- get
t685_235 <- StateT wrd
case t685_235 of
WSlash -> return ()
_ -> StateT position >>= (throwError . mkParseError "WSlash" "not match pattern: " "" d227_234 ["wrd"])
let WSlash = t685_235
return ()
sel <- StateT normalSelection
lift (lift (return $ ex : sel)),
do ex <- StateT expressionHs
lift (lift (return [ex]))]
expressionHs89_93 = foldl1 mplus [do e <- StateT expressionHsSugar
lift (lift (return e)),
do e <- StateT expression
mh <- optional139_204 (foldl1 mplus [do d233_236 <- get
t691_237 <- StateT wrd
case t691_237 of
WOBrace -> return ()
_ -> StateT position >>= (throwError . mkParseError "WOBrace" "not match pattern: " "" d233_236 ["wrd"])
let WOBrace = t691_237
return ()
h <- StateT hsExpLam
d235_238 <- get
t693_239 <- StateT wrd
case t693_239 of
WCBrace -> return ()
_ -> StateT position >>= (throwError . mkParseError "WCBrace" "not match pattern: " "" d235_238 ["wrd"])
let WCBrace = t693_239
return ()
lift (lift (return h))])
lift (lift (return $ Left (e, mh)))]
expressionHsSugar90_94 = foldl1 mplus [do d236_240 <- get
t694_241 <- StateT wrd
case t694_241 of
WLT -> return ()
_ -> StateT position >>= (throwError . mkParseError "WLT" "not match pattern: " "" d236_240 ["wrd"])
let WLT = t694_241
return ()
h <- StateT hsExpLam
d238_242 <- get
t696_243 <- StateT wrd
case t696_243 of
WGT -> return ()
_ -> StateT position >>= (throwError . mkParseError "WGT" "not match pattern: " "" d238_242 ["wrd"])
let WGT = t696_243
return ()
lift (lift (return $ Right h))]
expressionHsSugar'91_95 = foldl1 mplus [do d239_244 <- get
t697_245 <- StateT wrd
case t697_245 of
WLT -> return ()
_ -> StateT position >>= (throwError . mkParseError "WLT" "not match pattern: " "" d239_244 ["wrd"])
let WLT = t697_245
return ()
h <- StateT hsExpLam'
d241_246 <- get
t699_247 <- StateT wrd
case t699_247 of
WGT -> return ()
_ -> StateT position >>= (throwError . mkParseError "WGT" "not match pattern: " "" d241_246 ["wrd"])
let WGT = t699_247
return ()
lift (lift (return $ Right h))]
expression92_96 = foldl1 mplus [do l <- StateT nameLeaf_
e <- StateT expression
lift (lift (return $ l : e)),
lift (lift (return []))]
nameLeaf_93_97 = foldl1 mplus [do d244_248 <- get
t702_249 <- StateT wrd
case t702_249 of
WBang -> return ()
_ -> StateT position >>= (throwError . mkParseError "WBang" "not match pattern: " "" d244_248 ["wrd"])
let WBang = t702_249
return ()
nl <- StateT nameLeafNoCom
com <- optional139_204 (StateT comForErr)
lift (lift (return (NAhead $ maybe "" id com,
nl))),
do d247_250 <- get
t705_251 <- StateT wrd
case t705_251 of
WAmp -> return ()
_ -> StateT position >>= (throwError . mkParseError "WAmp" "not match pattern: " "" d247_250 ["wrd"])
let WAmp = t705_251
return ()
nl <- StateT nameLeaf
lift (lift (return (Ahead, nl))),
do nl <- StateT nameLeaf
lift (lift (return (Here, nl)))]
nameLeaf94_98 = foldl1 mplus [do cl <- StateT charLitLs
lift (lift (return cl)),
do n <- StateT pat1
com <- optional139_204 (StateT comForErr)
d253_252 <- get
t711_253 <- StateT wrd
case t711_253 of
WColon -> return ()
_ -> StateT position >>= (throwError . mkParseError "WColon" "not match pattern: " "" d253_252 ["wrd"])
let WColon = t711_253
return ()
(rf, p) <- StateT leaf
lift (lift (return $ Left ((n, maybe "" id com),
rf,
p))),
do n <- StateT pat1
com <- optional139_204 (StateT comForErr)
lift (lift (return $ Left ((n, maybe "" id com),
FromVariable Nothing,
Nothing)))]
nameLeafNoCom95_99 = foldl1 mplus [do cl <- StateT charLitLs
lift (lift (return cl)),
do n <- StateT pat1
com <- optional139_204 (StateT comForErr)
d260_254 <- get
t718_255 <- StateT wrd
case t718_255 of
WColon -> return ()
_ -> StateT position >>= (throwError . mkParseError "WColon" "not match pattern: " "" d260_254 ["wrd"])
let WColon = t718_255
return ()
(rf, p) <- StateT leaf
lift (lift (return $ Left ((n,
maybe "" id com),
rf,
p))),
do n <- StateT pat1
lift (lift (return $ Left ((n, ""),
FromVariable Nothing,
Nothing)))]
comForErr96_100 = foldl1 mplus [do d263_256 <- get
t721_257 <- StateT hsw
case t721_257 of
WOComment -> return ()
_ -> StateT position >>= (throwError . mkParseError "WOComment" "not match pattern: " "" d263_256 ["hsw"])
let WOComment = t721_257
return ()
d264_258 <- get
t722_259 <- StateT hsw
case t722_259 of
(WString _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WString s)" "not match pattern: " "" d264_258 ["hsw"])
let (WString s) = t722_259
return ()
d265_260 <- get
t723_261 <- StateT hsw
case t723_261 of
WCComment -> return ()
_ -> StateT position >>= (throwError . mkParseError "WCComment" "not match pattern: " "" d265_260 ["hsw"])
let WCComment = t723_261
return ()
lift (lift (return s))]
leaf97_101 = foldl1 mplus [do rf <- StateT readFromLs
t <- StateT test
lift (lift (return (rf, Just t))),
do rf <- StateT readFromLs
lift (lift (return (rf, Nothing))),
do t <- StateT test
lift (lift (return (FromVariable Nothing, Just t)))]
patOp98_102 = foldl1 mplus [do p <- StateT pat
d271_262 <- get
t729_263 <- StateT hsw
case t729_263 of
(WOpCon _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WOpCon o)" "not match pattern: " "" d271_262 ["hsw"])
let (WOpCon o) = t729_263
return ()
po <- StateT patOp
lift (lift (return $ UInfixP p (mkName o) po)),
do p <- StateT pat
d274_264 <- get
t732_265 <- StateT hsw
case t732_265 of
WBackQuote -> return ()
_ -> StateT position >>= (throwError . mkParseError "WBackQuote" "not match pattern: " "" d274_264 ["hsw"])
let WBackQuote = t732_265
return ()
d275_266 <- get
t733_267 <- StateT hsw
case t733_267 of
(WType [] _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WType [] t)" "not match pattern: " "" d275_266 ["hsw"])
let (WType [] t) = t733_267
return ()
d276_268 <- get
t734_269 <- StateT hsw
case t734_269 of
WBackQuote -> return ()
_ -> StateT position >>= (throwError . mkParseError "WBackQuote" "not match pattern: " "" d276_268 ["hsw"])
let WBackQuote = t734_269
return ()
po <- StateT patOp
lift (lift (return $ UInfixP p (mkName t) po)),
do p <- StateT pat
lift (lift (return p))]
pat99_103 = foldl1 mplus [do d279_270 <- get
t737_271 <- StateT hsw
case t737_271 of
(WType [] _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WType [] t)" "not match pattern: " "" d279_270 ["hsw"])
let (WType [] t) = t737_271
return ()
ps <- StateT pats
lift (lift (return $ ConP (mkName t) ps)),
do d281_272 <- get
t739_273 <- StateT hsw
case t739_273 of
WOParen -> return ()
_ -> StateT position >>= (throwError . mkParseError "WOParen" "not match pattern: " "" d281_272 ["hsw"])
let WOParen = t739_273
return ()
d282_274 <- get
t740_275 <- StateT hsw
case t740_275 of
(WOpCon _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WOpCon o)" "not match pattern: " "" d282_274 ["hsw"])
let (WOpCon o) = t740_275
return ()
d283_276 <- get
t741_277 <- StateT hsw
case t741_277 of
WCParen -> return ()
_ -> StateT position >>= (throwError . mkParseError "WCParen" "not match pattern: " "" d283_276 ["hsw"])
let WCParen = t741_277
return ()
ps <- StateT pats
lift (lift (return $ ConP (mkName o) ps)),
do p <- StateT pat1
lift (lift (return p))]
pat1100_104 = foldl1 mplus [do d286_278 <- get
t744_279 <- StateT hsw
case t744_279 of
(WType [] _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WType [] t)" "not match pattern: " "" d286_278 ["hsw"])
let (WType [] t) = t744_279
return ()
lift (lift (return $ ConP (mkName t) [])),
do d287_280 <- get
t745_281 <- StateT hsw
case t745_281 of
(WVar [] "_") -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WVar [] \"_\")" "not match pattern: " "" d287_280 ["hsw"])
let (WVar [] "_") = t745_281
return ()
lift (lift (return WildP)),
do d288_282 <- get
t746_283 <- StateT hsw
case t746_283 of
(WVar [] _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WVar [] n)" "not match pattern: " "" d288_282 ["hsw"])
let (WVar [] n) = t746_283
return ()
lift (lift (return $ VarP $ mkName n)),
do d289_284 <- get
t747_285 <- StateT hsw
case t747_285 of
(WInteger _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WInteger i)" "not match pattern: " "" d289_284 ["hsw"])
let (WInteger i) = t747_285
return ()
lift (lift (return $ LitP (IntegerL i))),
do d290_286 <- get
t748_287 <- StateT hsw
case t748_287 of
(WOp "-") -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WOp \"-\")" "not match pattern: " "" d290_286 ["hsw"])
let (WOp "-") = t748_287
return ()
d291_288 <- get
t749_289 <- StateT hsw
case t749_289 of
(WInteger _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WInteger i)" "not match pattern: " "" d291_288 ["hsw"])
let (WInteger i) = t749_289
return ()
lift (lift (return $ LitP (IntegerL $ negate i))),
do d292_290 <- get
t750_291 <- StateT hsw
case t750_291 of
(WChar _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WChar c)" "not match pattern: " "" d292_290 ["hsw"])
let (WChar c) = t750_291
return ()
lift (lift (return $ LitP $ CharL c)),
do d293_292 <- get
t751_293 <- StateT hsw
case t751_293 of
(WString _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WString s)" "not match pattern: " "" d293_292 ["hsw"])
let (WString s) = t751_293
return ()
lift (lift (return $ LitP $ StringL s)),
do d294_294 <- get
t752_295 <- StateT hsw
case t752_295 of
WOParen -> return ()
_ -> StateT position >>= (throwError . mkParseError "WOParen" "not match pattern: " "" d294_294 ["hsw"])
let WOParen = t752_295
return ()
p <- StateT patList
d296_296 <- get
t754_297 <- StateT hsw
case t754_297 of
WCParen -> return ()
_ -> StateT position >>= (throwError . mkParseError "WCParen" "not match pattern: " "" d296_296 ["hsw"])
let WCParen = t754_297
return ()
lift (lift (return $ TupP p)),
do d297_298 <- get
t755_299 <- StateT hsw
case t755_299 of
WOBracket -> return ()
_ -> StateT position >>= (throwError . mkParseError "WOBracket" "not match pattern: " "" d297_298 ["hsw"])
let WOBracket = t755_299
return ()
p <- StateT patList
d299_300 <- get
t757_301 <- StateT hsw
case t757_301 of
WCBracket -> return ()
_ -> StateT position >>= (throwError . mkParseError "WCBracket" "not match pattern: " "" d299_300 ["hsw"])
let WCBracket = t757_301
return ()
lift (lift (return $ ListP p)),
do d300_302 <- get
t758_303 <- StateT hsw
case t758_303 of
WOParen -> return ()
_ -> StateT position >>= (throwError . mkParseError "WOParen" "not match pattern: " "" d300_302 ["hsw"])
let WOParen = t758_303
return ()
p <- StateT pat
d302_304 <- get
t760_305 <- StateT hsw
case t760_305 of
WCParen -> return ()
_ -> StateT position >>= (throwError . mkParseError "WCParen" "not match pattern: " "" d302_304 ["hsw"])
let WCParen = t760_305
return ()
lift (lift (return p)),
do d303_306 <- get
t761_307 <- StateT hsw
case t761_307 of
(WOp "!") -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WOp \"!\")" "not match pattern: " "" d303_306 ["hsw"])
let (WOp "!") = t761_307
return ()
p <- StateT pat
lift (lift (return $ BangP p))]
patList101_105 = foldl1 mplus [do p <- StateT patOp
d306_308 <- get
t764_309 <- StateT hsw
case t764_309 of
WComma -> return ()
_ -> StateT position >>= (throwError . mkParseError "WComma" "not match pattern: " "" d306_308 ["hsw"])
let WComma = t764_309
return ()
ps <- StateT patList
lift (lift (return $ p : ps)),
do p <- StateT patOp
lift (lift (return [p])),
lift (lift (return []))]
pats102_106 = foldl1 mplus [do p <- StateT pat
ps <- StateT pats
lift (lift (return $ p : ps)),
lift (lift (return []))]
charLitLs103_107 = foldl1 mplus [do d311_310 <- get
t769_311 <- StateT hsw
case t769_311 of
(WChar _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WChar c)" "not match pattern: " "" d311_310 ["hsw"])
let (WChar c) = t769_311
return ()
d312_312 <- get
t770_313 <- StateT wrd
case t770_313 of
WAsterisk -> return ()
_ -> StateT position >>= (throwError . mkParseError "WAsterisk" "not match pattern: " "" d312_312 ["wrd"])
let WAsterisk = t770_313
return ()
lift (lift (return $ Right (c, List))),
do d313_314 <- get
t771_315 <- StateT hsw
case t771_315 of
(WChar _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WChar c)" "not match pattern: " "" d313_314 ["hsw"])
let (WChar c) = t771_315
return ()
d314_316 <- get
t772_317 <- StateT wrd
case t772_317 of
WPlus -> return ()
_ -> StateT position >>= (throwError . mkParseError "WPlus" "not match pattern: " "" d314_316 ["wrd"])
let WPlus = t772_317
return ()
lift (lift (return $ Right (c, List1))),
do d315_318 <- get
t773_319 <- StateT hsw
case t773_319 of
(WChar _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WChar c)" "not match pattern: " "" d315_318 ["hsw"])
let (WChar c) = t773_319
return ()
d316_320 <- get
t774_321 <- StateT wrd
case t774_321 of
WQuestion -> return ()
_ -> StateT position >>= (throwError . mkParseError "WQuestion" "not match pattern: " "" d316_320 ["wrd"])
let WQuestion = t774_321
return ()
lift (lift (return $ Right (c, Optional)))]
readFromLs104_108 = foldl1 mplus [do rf <- StateT readFrom
d318_322 <- get
t776_323 <- StateT wrd
case t776_323 of
WAsterisk -> return ()
_ -> StateT position >>= (throwError . mkParseError "WAsterisk" "not match pattern: " "" d318_322 ["wrd"])
let WAsterisk = t776_323
return ()
lift (lift (return $ FromL List rf)),
do rf <- StateT readFrom
d320_324 <- get
t778_325 <- StateT wrd
case t778_325 of
WPlus -> return ()
_ -> StateT position >>= (throwError . mkParseError "WPlus" "not match pattern: " "" d320_324 ["wrd"])
let WPlus = t778_325
return ()
lift (lift (return $ FromL List1 rf)),
do rf <- StateT readFrom
d322_326 <- get
t780_327 <- StateT wrd
case t780_327 of
WQuestion -> return ()
_ -> StateT position >>= (throwError . mkParseError "WQuestion" "not match pattern: " "" d322_326 ["wrd"])
let WQuestion = t780_327
return ()
lift (lift (return $ FromL Optional rf)),
do rf <- StateT readFrom
lift (lift (return rf))]
readFrom105_109 = foldl1 mplus [do d324_328 <- get
t782_329 <- StateT wrd
case t782_329 of
(WSymbol _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WSymbol v)" "not match pattern: " "" d324_328 ["wrd"])
let (WSymbol v) = t782_329
return ()
lift (lift (return $ FromVariable $ Just v)),
do d325_330 <- get
t783_331 <- StateT wrd
case t783_331 of
WOParen -> return ()
_ -> StateT position >>= (throwError . mkParseError "WOParen" "not match pattern: " "" d325_330 ["wrd"])
let WOParen = t783_331
return ()
s <- StateT selection
d327_332 <- get
t785_333 <- StateT wrd
case t785_333 of
WCParen -> return ()
_ -> StateT position >>= (throwError . mkParseError "WCParen" "not match pattern: " "" d327_332 ["wrd"])
let WCParen = t785_333
return ()
lift (lift (return $ FromSelection s)),
do e <- StateT expressionHsSugar'
lift (lift (return $ FromSelection [e]))]
test106_110 = foldl1 mplus [do d329_334 <- get
t787_335 <- StateT wrd
case t787_335 of
WOBracket -> return ()
_ -> StateT position >>= (throwError . mkParseError "WOBracket" "not match pattern: " "" d329_334 ["wrd"])
let WOBracket = t787_335
return ()
h <- StateT hsExpLam
com <- optional139_204 (StateT comForErr)
d332_336 <- get
t790_337 <- StateT wrd
case t790_337 of
WCBracket -> return ()
_ -> StateT position >>= (throwError . mkParseError "WCBracket" "not match pattern: " "" d332_336 ["wrd"])
let WCBracket = t790_337
return ()
lift (lift (return (h, maybe "" id com)))]
hsExpLam107_111 = foldl1 mplus [do d333_338 <- get
t791_339 <- StateT hsw
case t791_339 of
(WOp "\\") -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WOp \"\\\\\")" "not match pattern: " "" d333_338 ["hsw"])
let (WOp "\\") = t791_339
return ()
ps <- StateT pats
d335_340 <- get
t793_341 <- StateT hsw
case t793_341 of
WRightArrow -> return ()
_ -> StateT position >>= (throwError . mkParseError "WRightArrow" "not match pattern: " "" d335_340 ["hsw"])
let WRightArrow = t793_341
return ()
e <- StateT hsExpTyp
lift (lift (return $ LamE ps e)),
do e <- StateT hsExpTyp
lift (lift (return e))]
hsExpTyp108_112 = foldl1 mplus [do eo <- StateT hsExpOp
d339_342 <- get
t797_343 <- StateT hsw
case t797_343 of
WTypeDef -> return ()
_ -> StateT position >>= (throwError . mkParseError "WTypeDef" "not match pattern: " "" d339_342 ["hsw"])
let WTypeDef = t797_343
return ()
t <- StateT hsTypeArr
lift (lift (return $ SigE eo t)),
do eo <- StateT hsExpOp
lift (lift (return eo))]
hsExpOp109_113 = foldl1 mplus [do l <- StateT hsExp
o <- StateT hsOp
r <- StateT hsExpOp
lift (lift (return $ UInfixE (l id) o r)),
do e <- StateT hsExp
lift (lift (return $ e id))]
hsOp110_114 = foldl1 mplus [do d346_344 <- get
t804_345 <- StateT hsw
case t804_345 of
(WOp _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WOp op)" "not match pattern: " "" d346_344 ["hsw"])
let (WOp op) = t804_345
return ()
lift (lift (return $ VarE $ mkName op)),
do d347_346 <- get
t805_347 <- StateT hsw
case t805_347 of
(WOpCon _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WOpCon op)" "not match pattern: " "" d347_346 ["hsw"])
let (WOpCon op) = t805_347
return ()
lift (lift (return $ ConE $ mkName op)),
do d348_348 <- get
t806_349 <- StateT hsw
case t806_349 of
WBackQuote -> return ()
_ -> StateT position >>= (throwError . mkParseError "WBackQuote" "not match pattern: " "" d348_348 ["hsw"])
let WBackQuote = t806_349
return ()
d349_350 <- get
t807_351 <- StateT hsw
case t807_351 of
(WVar [] _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WVar [] v)" "not match pattern: " "" d349_350 ["hsw"])
let (WVar [] v) = t807_351
return ()
d350_352 <- get
t808_353 <- StateT hsw
case t808_353 of
WBackQuote -> return ()
_ -> StateT position >>= (throwError . mkParseError "WBackQuote" "not match pattern: " "" d350_352 ["hsw"])
let WBackQuote = t808_353
return ()
lift (lift (return $ VarE $ mkName v)),
do d351_354 <- get
t809_355 <- StateT hsw
case t809_355 of
WBackQuote -> return ()
_ -> StateT position >>= (throwError . mkParseError "WBackQuote" "not match pattern: " "" d351_354 ["hsw"])
let WBackQuote = t809_355
return ()
d352_356 <- get
t810_357 <- StateT hsw
case t810_357 of
(WType [] _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WType [] t)" "not match pattern: " "" d352_356 ["hsw"])
let (WType [] t) = t810_357
return ()
d353_358 <- get
t811_359 <- StateT hsw
case t811_359 of
WBackQuote -> return ()
_ -> StateT position >>= (throwError . mkParseError "WBackQuote" "not match pattern: " "" d353_358 ["hsw"])
let WBackQuote = t811_359
return ()
lift (lift (return $ ConE $ mkName t))]
hsExpLam'111_115 = foldl1 mplus [do d354_360 <- get
t812_361 <- StateT hsw
case t812_361 of
(WOp "\\") -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WOp \"\\\\\")" "not match pattern: " "" d354_360 ["hsw"])
let (WOp "\\") = t812_361
return ()
ps <- StateT pats
d356_362 <- get
t814_363 <- StateT hsw
case t814_363 of
WRightArrow -> return ()
_ -> StateT position >>= (throwError . mkParseError "WRightArrow" "not match pattern: " "" d356_362 ["hsw"])
let WRightArrow = t814_363
return ()
e <- StateT hsExpTyp'
lift (lift (return $ LamE ps e)),
do e <- StateT hsExpTyp'
lift (lift (return e))]
hsExpTyp'112_116 = foldl1 mplus [do eo <- StateT hsExpOp'
d360_364 <- get
t818_365 <- StateT hsw
case t818_365 of
WTypeDef -> return ()
_ -> StateT position >>= (throwError . mkParseError "WTypeDef" "not match pattern: " "" d360_364 ["hsw"])
let WTypeDef = t818_365
return ()
t <- StateT hsTypeArr
lift (lift (return $ SigE eo t)),
do eo <- StateT hsExpOp'
lift (lift (return eo))]
hsExpOp'113_117 = foldl1 mplus [do l <- StateT hsExp
o <- StateT hsOp'
r <- StateT hsExpOp'
lift (lift (return $ UInfixE (l id) o r)),
do e <- StateT hsExp
lift (lift (return $ e id))]
hsOp'114_118 = foldl1 mplus [do d367_366 <- get
t825_367 <- StateT hsw
case t825_367 of
(WOp _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WOp op)" "not match pattern: " "" d367_366 ["hsw"])
let (WOp op) = t825_367
return ()
b1274_368 <- lift (lift (return $ head op /= '>'))
unless b1274_368 (StateT position >>= (throwError . mkParseError "return $ head op /= '>'" "not match: " "" d367_366 ["hsw"]))
lift (lift (return $ VarE $ mkName op)),
do d368_369 <- get
t826_370 <- StateT hsw
case t826_370 of
(WOpCon _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WOpCon op)" "not match pattern: " "" d368_369 ["hsw"])
let (WOpCon op) = t826_370
return ()
lift (lift (return $ ConE $ mkName op)),
do d369_371 <- get
t827_372 <- StateT hsw
case t827_372 of
WBackQuote -> return ()
_ -> StateT position >>= (throwError . mkParseError "WBackQuote" "not match pattern: " "" d369_371 ["hsw"])
let WBackQuote = t827_372
return ()
v <- StateT var
d371_373 <- get
t829_374 <- StateT hsw
case t829_374 of
WBackQuote -> return ()
_ -> StateT position >>= (throwError . mkParseError "WBackQuote" "not match pattern: " "" d371_373 ["hsw"])
let WBackQuote = t829_374
return ()
lift (lift (return $ VarE $ mkName v)),
do d372_375 <- get
t830_376 <- StateT hsw
case t830_376 of
WBackQuote -> return ()
_ -> StateT position >>= (throwError . mkParseError "WBackQuote" "not match pattern: " "" d372_375 ["hsw"])
let WBackQuote = t830_376
return ()
t <- StateT typ
d374_377 <- get
t832_378 <- StateT hsw
case t832_378 of
WBackQuote -> return ()
_ -> StateT position >>= (throwError . mkParseError "WBackQuote" "not match pattern: " "" d374_377 ["hsw"])
let WBackQuote = t832_378
return ()
lift (lift (return $ ConE $ mkName t))]
hsExp115_119 = foldl1 mplus [do e <- StateT hsExp1
h <- StateT hsExp
lift (lift (return (\f -> h (f e `AppE`)))),
do e <- StateT hsExp1
lift (lift (return (\f -> f e)))]
hsExp1116_120 = foldl1 mplus [do d378_379 <- get
t836_380 <- StateT hsw
case t836_380 of
WOParen -> return ()
_ -> StateT position >>= (throwError . mkParseError "WOParen" "not match pattern: " "" d378_379 ["hsw"])
let WOParen = t836_380
return ()
l <- optional139_204 (StateT hsExpOp)
o <- StateT hsOp
r <- optional139_204 (StateT hsExpOp)
d382_381 <- get
t840_382 <- StateT hsw
case t840_382 of
WCParen -> return ()
_ -> StateT position >>= (throwError . mkParseError "WCParen" "not match pattern: " "" d382_381 ["hsw"])
let WCParen = t840_382
return ()
lift (lift (return $ InfixE l o r)),
do d383_383 <- get
t841_384 <- StateT hsw
case t841_384 of
WOParen -> return ()
_ -> StateT position >>= (throwError . mkParseError "WOParen" "not match pattern: " "" d383_383 ["hsw"])
let WOParen = t841_384
return ()
et <- StateT hsExpTpl
d385_385 <- get
t843_386 <- StateT hsw
case t843_386 of
WCParen -> return ()
_ -> StateT position >>= (throwError . mkParseError "WCParen" "not match pattern: " "" d385_385 ["hsw"])
let WCParen = t843_386
return ()
lift (lift (return $ TupE et)),
do d386_387 <- get
t844_388 <- StateT hsw
case t844_388 of
WOBracket -> return ()
_ -> StateT position >>= (throwError . mkParseError "WOBracket" "not match pattern: " "" d386_387 ["hsw"])
let WOBracket = t844_388
return ()
et <- StateT hsExpTpl
d388_389 <- get
t846_390 <- StateT hsw
case t846_390 of
WCBracket -> return ()
_ -> StateT position >>= (throwError . mkParseError "WCBracket" "not match pattern: " "" d388_389 ["hsw"])
let WCBracket = t846_390
return ()
lift (lift (return $ ListE et)),
do d389_391 <- get
t847_392 <- StateT hsw
case t847_392 of
WOBracket -> return ()
_ -> StateT position >>= (throwError . mkParseError "WOBracket" "not match pattern: " "" d389_391 ["hsw"])
let WOBracket = t847_392
return ()
b <- StateT hsExpOp
d391_393 <- get
t849_394 <- StateT hsw
case t849_394 of
WDotDot -> return ()
_ -> StateT position >>= (throwError . mkParseError "WDotDot" "not match pattern: " "" d391_393 ["hsw"])
let WDotDot = t849_394
return ()
e <- StateT hsExpOp
d393_395 <- get
t851_396 <- StateT hsw
case t851_396 of
WCBracket -> return ()
_ -> StateT position >>= (throwError . mkParseError "WCBracket" "not match pattern: " "" d393_395 ["hsw"])
let WCBracket = t851_396
return ()
lift (lift (return $ ArithSeqE $ FromToR b e)),
do d394_397 <- get
t852_398 <- StateT hsw
case t852_398 of
(WVar [] _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WVar [] v)" "not match pattern: " "" d394_397 ["hsw"])
let (WVar [] v) = t852_398
return ()
lift (lift (return $ VarE $ mkName v)),
do d395_399 <- get
t853_400 <- StateT hsw
case t853_400 of
(WType [] _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WType [] t)" "not match pattern: " "" d395_399 ["hsw"])
let (WType [] t) = t853_400
return ()
lift (lift (return $ ConE $ mkName t)),
do d396_401 <- get
t854_402 <- StateT hsw
case t854_402 of
(WInteger _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WInteger i)" "not match pattern: " "" d396_401 ["hsw"])
let (WInteger i) = t854_402
return ()
lift (lift (return $ LitE $ integerL i)),
do d397_403 <- get
t855_404 <- StateT hsw
case t855_404 of
(WChar _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WChar c)" "not match pattern: " "" d397_403 ["hsw"])
let (WChar c) = t855_404
return ()
lift (lift (return $ LitE $ charL c)),
do d398_405 <- get
t856_406 <- StateT hsw
case t856_406 of
(WString _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WString s)" "not match pattern: " "" d398_405 ["hsw"])
let (WString s) = t856_406
return ()
lift (lift (return $ LitE $ stringL s)),
do d399_407 <- get
t857_408 <- StateT hsw
case t857_408 of
(WOp "-") -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WOp \"-\")" "not match pattern: " "" d399_407 ["hsw"])
let (WOp "-") = t857_408
return ()
e <- StateT hsExp1
lift (lift (return $ AppE (VarE $ mkName "negate") e))]
hsExpTpl117_121 = foldl1 mplus [do e <- StateT hsExpLam
d402_409 <- get
t860_410 <- StateT hsw
case t860_410 of
WComma -> return ()
_ -> StateT position >>= (throwError . mkParseError "WComma" "not match pattern: " "" d402_409 ["hsw"])
let WComma = t860_410
return ()
et <- StateT hsExpTpl
lift (lift (return $ e : et)),
do e <- StateT hsExpLam
lift (lift (return [e])),
lift (lift (return []))]
hsTypeArr118_122 = foldl1 mplus [do l <- StateT hsType
d406_411 <- get
t864_412 <- StateT hsw
case t864_412 of
WRightArrow -> return ()
_ -> StateT position >>= (throwError . mkParseError "WRightArrow" "not match pattern: " "" d406_411 ["hsw"])
let WRightArrow = t864_412
return ()
r <- StateT hsTypeArr
lift (lift (return $ AppT (AppT ArrowT $ l id) r)),
do t <- StateT hsType
lift (lift (return $ t id))]
hsType119_123 = foldl1 mplus [do t <- StateT hsType1
ts <- StateT hsType
lift (lift (return $ (\f -> ts (f t `AppT`)))),
do t <- StateT hsType1
lift (lift (return ($ t)))]
hsType1120_124 = foldl1 mplus [do d412_413 <- get
t870_414 <- StateT hsw
case t870_414 of
WOBracket -> return ()
_ -> StateT position >>= (throwError . mkParseError "WOBracket" "not match pattern: " "" d412_413 ["hsw"])
let WOBracket = t870_414
return ()
d413_415 <- get
t871_416 <- StateT hsw
case t871_416 of
WCBracket -> return ()
_ -> StateT position >>= (throwError . mkParseError "WCBracket" "not match pattern: " "" d413_415 ["hsw"])
let WCBracket = t871_416
return ()
lift (lift (return ListT)),
do d414_417 <- get
t872_418 <- StateT hsw
case t872_418 of
WOBracket -> return ()
_ -> StateT position >>= (throwError . mkParseError "WOBracket" "not match pattern: " "" d414_417 ["hsw"])
let WOBracket = t872_418
return ()
t <- StateT hsTypeArr
d416_419 <- get
t874_420 <- StateT hsw
case t874_420 of
WCBracket -> return ()
_ -> StateT position >>= (throwError . mkParseError "WCBracket" "not match pattern: " "" d416_419 ["hsw"])
let WCBracket = t874_420
return ()
lift (lift (return $ ListT `AppT` t)),
do d417_421 <- get
t875_422 <- StateT hsw
case t875_422 of
WOParen -> return ()
_ -> StateT position >>= (throwError . mkParseError "WOParen" "not match pattern: " "" d417_421 ["hsw"])
let WOParen = t875_422
return ()
tt <- StateT hsTypeTpl
d419_423 <- get
t877_424 <- StateT hsw
case t877_424 of
WCParen -> return ()
_ -> StateT position >>= (throwError . mkParseError "WCParen" "not match pattern: " "" d419_423 ["hsw"])
let WCParen = t877_424
return ()
lift (lift (return $ foldl AppT (TupleT $ length tt) tt)),
do d420_425 <- get
t878_426 <- StateT hsw
case t878_426 of
(WType [] _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WType [] t)" "not match pattern: " "" d420_425 ["hsw"])
let (WType [] t) = t878_426
return ()
lift (lift (return $ ConT $ mkName t)),
do d421_427 <- get
t879_428 <- StateT hsw
case t879_428 of
WOParen -> return ()
_ -> StateT position >>= (throwError . mkParseError "WOParen" "not match pattern: " "" d421_427 ["hsw"])
let WOParen = t879_428
return ()
d422_429 <- get
t880_430 <- StateT hsw
case t880_430 of
WRightArrow -> return ()
_ -> StateT position >>= (throwError . mkParseError "WRightArrow" "not match pattern: " "" d422_429 ["hsw"])
let WRightArrow = t880_430
return ()
d423_431 <- get
t881_432 <- StateT hsw
case t881_432 of
WCParen -> return ()
_ -> StateT position >>= (throwError . mkParseError "WCParen" "not match pattern: " "" d423_431 ["hsw"])
let WCParen = t881_432
return ()
lift (lift (return ArrowT))]
hsTypeTpl121_125 = foldl1 mplus [do t <- StateT hsTypeArr
d425_433 <- get
t883_434 <- StateT hsw
case t883_434 of
WComma -> return ()
_ -> StateT position >>= (throwError . mkParseError "WComma" "not match pattern: " "" d425_433 ["hsw"])
let WComma = t883_434
return ()
tt <- StateT hsTypeTpl
lift (lift (return $ t : tt)),
do t <- StateT hsTypeArr
lift (lift (return [t])),
lift (lift (return []))]
wrd122_126 = foldl1 mplus [do w <- StateT word
_ <- list140_145 (StateT space)
return ()
lift (lift (return w)),
do _ <- StateT semiColon
return ()
_ <- list140_145 (StateT space')
return ()
lift (lift (return WSemiColon))]
hsw123_127 = foldl1 mplus [do w <- StateT hsWord
_ <- list140_145 (StateT space)
return ()
lift (lift (return w))]
word124_128 = foldl1 mplus [do v <- list1141_435 (foldl1 mplus [do d435_436 <- get
t893_437 <- StateT char
let c1506_143 = t893_437
b1342_438 <- return (((||) <$> isAlphaNum <*> (`elem` "_'")) c1506_143)
unless b1342_438 (StateT position >>= (throwError . mkParseError "((||) <$> isAlphaNum <*> (`elem` \"_'\")) c1506_0" "not match: " "" d435_436 ["char"]))
return c1506_143])
lift (lift (return $ WSymbol v)),
do d436_439 <- get
t894_440 <- StateT char
case t894_440 of
'!' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'!'" "not match pattern: " "" d436_439 ["char"])
let '!' = t894_440
return ()
lift (lift (return WBang)),
do d437_441 <- get
t895_442 <- StateT char
case t895_442 of
'&' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'&'" "not match pattern: " "" d437_441 ["char"])
let '&' = t895_442
return ()
lift (lift (return WAmp)),
do d438_443 <- get
t896_444 <- StateT char
case t896_444 of
'*' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'*'" "not match pattern: " "" d438_443 ["char"])
let '*' = t896_444
return ()
lift (lift (return WAsterisk)),
do d439_445 <- get
t897_446 <- StateT char
case t897_446 of
'+' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'+'" "not match pattern: " "" d439_445 ["char"])
let '+' = t897_446
return ()
lift (lift (return WPlus)),
do d440_447 <- get
t898_448 <- StateT char
case t898_448 of
'?' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'?'" "not match pattern: " "" d440_447 ["char"])
let '?' = t898_448
return ()
lift (lift (return WQuestion)),
do d441_449 <- get
t899_450 <- StateT char
case t899_450 of
'=' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'='" "not match pattern: " "" d441_449 ["char"])
let '=' = t899_450
return ()
lift (lift (return WEqual)),
do d442_451 <- get
t900_452 <- StateT char
case t900_452 of
'/' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'/'" "not match pattern: " "" d442_451 ["char"])
let '/' = t900_452
return ()
lift (lift (return WSlash)),
do d443_453 <- get
t901_454 <- StateT char
case t901_454 of
':' -> return ()
_ -> StateT position >>= (throwError . mkParseError "':'" "not match pattern: " "" d443_453 ["char"])
let ':' = t901_454
return ()
lift (lift (return WColon)),
do d444_455 <- get
t902_456 <- StateT char
case t902_456 of
'<' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'<'" "not match pattern: " "" d444_455 ["char"])
let '<' = t902_456
return ()
lift (lift (return WLT)),
do d445_457 <- get
t903_458 <- StateT char
case t903_458 of
'>' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'>'" "not match pattern: " "" d445_457 ["char"])
let '>' = t903_458
return ()
lift (lift (return WGT)),
do b <- StateT bras
lift (lift (return b))]
hsWord125_129 = foldl1 mplus [do d447_459 <- get
t905_460 <- StateT char
case t905_460 of
'm' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'m'" "not match pattern: " "" d447_459 ["char"])
let 'm' = t905_460
return ()
d448_461 <- get
t906_462 <- StateT char
case t906_462 of
'o' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'o'" "not match pattern: " "" d448_461 ["char"])
let 'o' = t906_462
return ()
d449_463 <- get
t907_464 <- StateT char
case t907_464 of
'd' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'d'" "not match pattern: " "" d449_463 ["char"])
let 'd' = t907_464
return ()
d450_465 <- get
t908_466 <- StateT char
case t908_466 of
'u' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'u'" "not match pattern: " "" d450_465 ["char"])
let 'u' = t908_466
return ()
d451_467 <- get
t909_468 <- StateT char
case t909_468 of
'l' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'l'" "not match pattern: " "" d451_467 ["char"])
let 'l' = t909_468
return ()
d452_469 <- get
t910_470 <- StateT char
case t910_470 of
'e' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'e'" "not match pattern: " "" d452_469 ["char"])
let 'e' = t910_470
return ()
lift (lift (return $ WModule)),
do d453_471 <- get
t911_472 <- StateT char
case t911_472 of
'w' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'w'" "not match pattern: " "" d453_471 ["char"])
let 'w' = t911_472
return ()
d454_473 <- get
t912_474 <- StateT char
case t912_474 of
'h' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'h'" "not match pattern: " "" d454_473 ["char"])
let 'h' = t912_474
return ()
d455_475 <- get
t913_476 <- StateT char
case t913_476 of
'e' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'e'" "not match pattern: " "" d455_475 ["char"])
let 'e' = t913_476
return ()
d456_477 <- get
t914_478 <- StateT char
case t914_478 of
'r' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'r'" "not match pattern: " "" d456_477 ["char"])
let 'r' = t914_478
return ()
d457_479 <- get
t915_480 <- StateT char
case t915_480 of
'e' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'e'" "not match pattern: " "" d457_479 ["char"])
let 'e' = t915_480
return ()
lift (lift (return $ WWhere)),
do d458_481 <- get
t916_482 <- StateT char
case t916_482 of
'i' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'i'" "not match pattern: " "" d458_481 ["char"])
let 'i' = t916_482
return ()
d459_483 <- get
t917_484 <- StateT char
case t917_484 of
'm' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'m'" "not match pattern: " "" d459_483 ["char"])
let 'm' = t917_484
return ()
d460_485 <- get
t918_486 <- StateT char
case t918_486 of
'p' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'p'" "not match pattern: " "" d460_485 ["char"])
let 'p' = t918_486
return ()
d461_487 <- get
t919_488 <- StateT char
case t919_488 of
'o' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'o'" "not match pattern: " "" d461_487 ["char"])
let 'o' = t919_488
return ()
d462_489 <- get
t920_490 <- StateT char
case t920_490 of
'r' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'r'" "not match pattern: " "" d462_489 ["char"])
let 'r' = t920_490
return ()
d463_491 <- get
t921_492 <- StateT char
case t921_492 of
't' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'t'" "not match pattern: " "" d463_491 ["char"])
let 't' = t921_492
return ()
lift (lift (return $ WImport)),
do d464_493 <- get
t922_494 <- StateT char
case t922_494 of
'[' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'['" "not match pattern: " "" d464_493 ["char"])
let '[' = t922_494
return ()
v <- StateT var
d466_495 <- get
t924_496 <- StateT char
case t924_496 of
'|' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'|'" "not match pattern: " "" d466_495 ["char"])
let '|' = t924_496
return ()
lift (lift (return $ WOQuasiQuote v)),
do d467_497 <- get
t925_498 <- StateT char
case t925_498 of
'|' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'|'" "not match pattern: " "" d467_497 ["char"])
let '|' = t925_498
return ()
d468_499 <- get
t926_500 <- StateT char
case t926_500 of
']' -> return ()
_ -> StateT position >>= (throwError . mkParseError "']'" "not match pattern: " "" d468_499 ["char"])
let ']' = t926_500
return ()
lift (lift (return WCQuasiQuote)),
do d469_501 <- get
t927_502 <- StateT char
case t927_502 of
':' -> return ()
_ -> StateT position >>= (throwError . mkParseError "':'" "not match pattern: " "" d469_501 ["char"])
let ':' = t927_502
return ()
d470_503 <- get
t928_504 <- StateT char
case t928_504 of
':' -> return ()
_ -> StateT position >>= (throwError . mkParseError "':'" "not match pattern: " "" d470_503 ["char"])
let ':' = t928_504
return ()
lift (lift (return WTypeDef)),
do d471_505 <- get
t929_506 <- StateT char
case t929_506 of
'-' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'-'" "not match pattern: " "" d471_505 ["char"])
let '-' = t929_506
return ()
d472_507 <- get
t930_508 <- StateT char
case t930_508 of
'>' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'>'" "not match pattern: " "" d472_507 ["char"])
let '>' = t930_508
return ()
lift (lift (return WRightArrow)),
do d473_509 <- get
t931_510 <- StateT char
case t931_510 of
'.' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'.'" "not match pattern: " "" d473_509 ["char"])
let '.' = t931_510
return ()
d474_511 <- get
t932_512 <- StateT char
case t932_512 of
'.' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'.'" "not match pattern: " "" d474_511 ["char"])
let '.' = t932_512
return ()
lift (lift (return WDotDot)),
do d475_513 <- get
t933_514 <- StateT char
case t933_514 of
'{' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'{'" "not match pattern: " "" d475_513 ["char"])
let '{' = t933_514
return ()
d476_515 <- get
t934_516 <- StateT char
case t934_516 of
'-' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'-'" "not match pattern: " "" d476_515 ["char"])
let '-' = t934_516
return ()
d477_517 <- get
t935_518 <- StateT char
case t935_518 of
'#' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'#'" "not match pattern: " "" d477_517 ["char"])
let '#' = t935_518
return ()
lift (lift (return WOComment)),
do d478_519 <- get
t936_520 <- StateT char
case t936_520 of
'#' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'#'" "not match pattern: " "" d478_519 ["char"])
let '#' = t936_520
return ()
d479_521 <- get
t937_522 <- StateT char
case t937_522 of
'-' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'-'" "not match pattern: " "" d479_521 ["char"])
let '-' = t937_522
return ()
d480_523 <- get
t938_524 <- StateT char
case t938_524 of
'}' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'}'" "not match pattern: " "" d480_523 ["char"])
let '}' = t938_524
return ()
lift (lift (return WCComment)),
do m <- list140_145 (foldl1 mplus [do t <- StateT typ
d483_525 <- get
t941_526 <- StateT char
case t941_526 of
'.' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'.'" "not match pattern: " "" d483_525 ["char"])
let '.' = t941_526
return ()
lift (lift (return t))])
t1 <- StateT typ
lift (lift (return $ WType m t1)),
do m <- list140_145 (foldl1 mplus [do t <- StateT typ
d487_527 <- get
t945_528 <- StateT char
case t945_528 of
'.' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'.'" "not match pattern: " "" d487_527 ["char"])
let '.' = t945_528
return ()
lift (lift (return t))])
v1 <- StateT var
lift (lift (return $ WVar m v1)),
do d489_529 <- get
t947_530 <- StateT char
case t947_530 of
':' -> return ()
_ -> StateT position >>= (throwError . mkParseError "':'" "not match pattern: " "" d489_529 ["char"])
let ':' = t947_530
return ()
w <- list140_145 (foldl1 mplus [do d491_531 <- get
t949_532 <- StateT char
let c1507_533 = t949_532
b1398_534 <- return ((`elem` opChars) c1507_533)
unless b1398_534 (StateT position >>= (throwError . mkParseError "(`elem` opChars) c1507_0" "not match: " "" d491_531 ["char"]))
return c1507_533])
lift (lift (return $ WOpCon $ ':' : w)),
do w <- list1141_435 (foldl1 mplus [do d493_535 <- get
t951_536 <- StateT char
let c1508_537 = t951_536
b1400_538 <- return ((`elem` opChars) c1508_537)
unless b1400_538 (StateT position >>= (throwError . mkParseError "(`elem` opChars) c1508_0" "not match: " "" d493_535 ["char"]))
return c1508_537])
lift (lift (return $ WOp w)),
do d494_539 <- get
t952_540 <- StateT char
case t952_540 of
'\'' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'\\''" "not match pattern: " "" d494_539 ["char"])
let '\'' = t952_540
return ()
c <- foldl1 mplus [do d496_541 <- get
t954_542 <- StateT char
let c1509_543 = t954_542
b1403_544 <- return ((`notElem` "\\'") c1509_543)
unless b1403_544 (StateT position >>= (throwError . mkParseError "(`notElem` \"\\\\'\") c1509_0" "not match: " "" d496_541 ["char"]))
return c1509_543]
d497_545 <- get
t955_546 <- StateT char
case t955_546 of
'\'' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'\\''" "not match pattern: " "" d497_545 ["char"])
let '\'' = t955_546
return ()
lift (lift (return $ WChar c)),
do d498_547 <- get
t956_548 <- StateT char
case t956_548 of
'\'' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'\\''" "not match pattern: " "" d498_547 ["char"])
let '\'' = t956_548
return ()
d499_549 <- get
t957_550 <- StateT char
case t957_550 of
'\\' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'\\\\'" "not match pattern: " "" d499_549 ["char"])
let '\\' = t957_550
return ()
c <- StateT escChar
d501_551 <- get
t959_552 <- StateT char
case t959_552 of
'\'' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'\\''" "not match pattern: " "" d501_551 ["char"])
let '\'' = t959_552
return ()
lift (lift (return $ WChar c)),
do d502_553 <- get
t960_554 <- StateT char
case t960_554 of
'"' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'\"'" "not match pattern: " "" d502_553 ["char"])
let '"' = t960_554
return ()
s <- StateT strLit
d504_555 <- get
t962_556 <- StateT char
case t962_556 of
'"' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'\"'" "not match pattern: " "" d504_555 ["char"])
let '"' = t962_556
return ()
lift (lift (return $ WString s)),
do d <- list1141_435 (foldl1 mplus [do d506_557 <- get
t964_558 <- StateT char
let c1510_559 = t964_558
b1413_560 <- return (isDigit c1510_559)
unless b1413_560 (StateT position >>= (throwError . mkParseError "isDigit c1510_0" "not match: " "" d506_557 ["char"]))
return c1510_559])
lift (lift (return $ WInteger $ read d)),
do b <- StateT bras
lift (lift (return b)),
do d508_561 <- get
t966_562 <- StateT char
case t966_562 of
',' -> return ()
_ -> StateT position >>= (throwError . mkParseError "','" "not match pattern: " "" d508_561 ["char"])
let ',' = t966_562
return ()
lift (lift (return WComma)),
do d509_563 <- get
t967_564 <- StateT char
case t967_564 of
'`' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'`'" "not match pattern: " "" d509_563 ["char"])
let '`' = t967_564
return ()
lift (lift (return WBackQuote))]
bras126_130 = foldl1 mplus [do d510_565 <- get
t968_566 <- StateT char
case t968_566 of
'[' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'['" "not match pattern: " "" d510_565 ["char"])
let '[' = t968_566
return ()
lift (lift (return WOBracket)),
do d511_567 <- get
t969_568 <- StateT char
case t969_568 of
']' -> return ()
_ -> StateT position >>= (throwError . mkParseError "']'" "not match pattern: " "" d511_567 ["char"])
let ']' = t969_568
return ()
lift (lift (return WCBracket)),
do d512_569 <- get
t970_570 <- StateT char
case t970_570 of
'{' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'{'" "not match pattern: " "" d512_569 ["char"])
let '{' = t970_570
return ()
lift (lift (return WOBrace)),
do d513_571 <- get
t971_572 <- StateT char
case t971_572 of
'}' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'}'" "not match pattern: " "" d513_571 ["char"])
let '}' = t971_572
return ()
lift (lift (return WCBrace)),
do d514_573 <- get
t972_574 <- StateT char
case t972_574 of
'(' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'('" "not match pattern: " "" d514_573 ["char"])
let '(' = t972_574
return ()
lift (lift (return WOParen)),
do d515_575 <- get
t973_576 <- StateT char
case t973_576 of
')' -> return ()
_ -> StateT position >>= (throwError . mkParseError "')'" "not match pattern: " "" d515_575 ["char"])
let ')' = t973_576
return ()
lift (lift (return WCParen))]
typ127_131 = foldl1 mplus [do u <- foldl1 mplus [do d517_577 <- get
t975_578 <- StateT char
let c1511_579 = t975_578
b1424_580 <- return (isUpper c1511_579)
unless b1424_580 (StateT position >>= (throwError . mkParseError "isUpper c1511_0" "not match: " "" d517_577 ["char"]))
return c1511_579]
cs <- list140_145 (foldl1 mplus [do d519_581 <- get
t977_582 <- StateT char
let c1512_583 = t977_582
b1426_584 <- return (((||) <$> isAlphaNum <*> (`elem` "_'")) c1512_583)
unless b1426_584 (StateT position >>= (throwError . mkParseError "((||) <$> isAlphaNum <*> (`elem` \"_'\")) c1512_0" "not match: " "" d519_581 ["char"]))
return c1512_583])
lift (lift (return $ u : cs))]
var128_132 = foldl1 mplus [do l <- foldl1 mplus [do d521_585 <- get
t979_586 <- StateT char
let c1513_587 = t979_586
b1428_588 <- return (((||) <$> isLower <*> (== '_')) c1513_587)
unless b1428_588 (StateT position >>= (throwError . mkParseError "((||) <$> isLower <*> (== '_')) c1513_0" "not match: " "" d521_585 ["char"]))
return c1513_587]
cs <- list140_145 (foldl1 mplus [do d523_589 <- get
t981_590 <- StateT char
let c1514_591 = t981_590
b1430_592 <- return (((||) <$> isAlphaNum <*> (`elem` "_'")) c1514_591)
unless b1430_592 (StateT position >>= (throwError . mkParseError "((||) <$> isAlphaNum <*> (`elem` \"_'\")) c1514_0" "not match: " "" d523_589 ["char"]))
return c1514_591])
lift (lift (return $ l : cs))]
strLit129_133 = foldl1 mplus [do c0 <- foldl1 mplus [do d525_593 <- get
t983_594 <- StateT char
case t983_594 of
'\\' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'\\\\'" "not match pattern: " "" d525_593 ["char"])
let '\\' = t983_594
return ()
c <- StateT escChar
lift (lift (return c)),
do d527_595 <- get
t985_596 <- StateT char
let c1515_597 = t985_596
b1434_598 <- return ((`notElem` "\"\\") c1515_597)
unless b1434_598 (StateT position >>= (throwError . mkParseError "(`notElem` \"\\\"\\\\\") c1515_0" "not match: " "" d527_595 ["char"]))
return c1515_597]
s <- StateT strLit
lift (lift (return $ c0 : s)),
lift (lift (return ""))]
escChar130_134 = foldl1 mplus [do d529_599 <- get
t987_600 <- StateT char
case t987_600 of
'\\' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'\\\\'" "not match pattern: " "" d529_599 ["char"])
let '\\' = t987_600
return ()
lift (lift (return '\\')),
do d530_601 <- get
t988_602 <- StateT char
case t988_602 of
'\'' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'\\''" "not match pattern: " "" d530_601 ["char"])
let '\'' = t988_602
return ()
lift (lift (return '\'')),
do d531_603 <- get
t989_604 <- StateT char
case t989_604 of
'"' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'\"'" "not match pattern: " "" d531_603 ["char"])
let '"' = t989_604
return ()
lift (lift (return '"')),
do d532_605 <- get
t990_606 <- StateT char
case t990_606 of
'n' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'n'" "not match pattern: " "" d532_605 ["char"])
let 'n' = t990_606
return ()
lift (lift (return '\n')),
do d533_607 <- get
t991_608 <- StateT char
case t991_608 of
'r' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'r'" "not match pattern: " "" d533_607 ["char"])
let 'r' = t991_608
return ()
lift (lift (return '\r')),
do d534_609 <- get
t992_610 <- StateT char
case t992_610 of
't' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'t'" "not match pattern: " "" d534_609 ["char"])
let 't' = t992_610
return ()
lift (lift (return '\t')),
do d535_611 <- get
t993_612 <- StateT char
case t993_612 of
'x' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'x'" "not match pattern: " "" d535_611 ["char"])
let 'x' = t993_612
return ()
ds <- list1141_435 (foldl1 mplus [do d537_613 <- get
t995_614 <- StateT char
let c1516_615 = t995_614
b1444_616 <- return (isHexDigit c1516_615)
unless b1444_616 (StateT position >>= (throwError . mkParseError "isHexDigit c1516_0" "not match: " "" d537_613 ["char"]))
return c1516_615])
lift (lift (return $ chr $ fst $ head $ readHex ds))]
space131_135 = foldl1 mplus [do _ <- foldl1 mplus [do d539_617 <- get
t997_618 <- StateT char
let c1517_619 = t997_618
b1446_620 <- return ((`elem` " \t") c1517_619)
unless b1446_620 (StateT position >>= (throwError . mkParseError "(`elem` \" \\t\") c1517_0" "not match: " "" d539_617 ["char"]))
return c1517_619]
return ()
return (),
do _ <- StateT notSemiColon
return ()
return (),
do _ <- StateT comment
return ()
return (),
do _ <- StateT lineComment
return ()
return ()]
space'132_136 = foldl1 mplus [do _ <- foldl1 mplus [do d544_621 <- get
t1002_622 <- StateT char
let c1518_623 = t1002_622
b1451_624 <- return ((`elem` " \t") c1518_623)
unless b1451_624 (StateT position >>= (throwError . mkParseError "(`elem` \" \\t\") c1518_0" "not match: " "" d544_621 ["char"]))
return c1518_623]
return ()
return (),
do _ <- list1141_435 (foldl1 mplus [do d546_625 <- get
t1004_626 <- StateT char
case t1004_626 of
'\n' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'\\n'" "not match pattern: " "" d546_625 ["char"])
let '\n' = t1004_626
return ()
lift (lift (return ()))])
return ()
return (),
do _ <- StateT comment
return ()
return (),
do _ <- StateT lineComment
return ()
return ()]
lineComment133_137 = foldl1 mplus [do d549_627 <- get
t1007_628 <- StateT char
case t1007_628 of
'-' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'-'" "not match pattern: " "" d549_627 ["char"])
let '-' = t1007_628
return ()
d550_629 <- get
t1008_630 <- StateT char
case t1008_630 of
'-' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'-'" "not match pattern: " "" d550_629 ["char"])
let '-' = t1008_630
return ()
_ <- list140_145 (foldl1 mplus [do d552_631 <- get
t1010_632 <- StateT char
let c1519_633 = t1010_632
b1459_634 <- return ((/= '\n') c1519_633)
unless b1459_634 (StateT position >>= (throwError . mkParseError "(/= '\\n') c1519_0" "not match: " "" d552_631 ["char"]))
return c1519_633])
return ()
d554_635 <- get
_ <- do d553_636 <- get
t1011_637 <- StateT char
case t1011_637 of
'\n' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'\\n'" "not match pattern: " "" d553_636 ["char"])
let '\n' = t1011_637
return ()
put d554_635
return ()]
comment134_138 = foldl1 mplus [do d555_638 <- get
t1012_639 <- StateT char
case t1012_639 of
'{' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'{'" "not match pattern: " "" d555_638 ["char"])
let '{' = t1012_639
return ()
d556_640 <- get
t1013_641 <- StateT char
case t1013_641 of
'-' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'-'" "not match pattern: " "" d556_640 ["char"])
let '-' = t1013_641
return ()
d558_642 <- get
do err1499_643 <- ((do d557_644 <- get
t1014_645 <- StateT char
case t1014_645 of
'#' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'#'" "not match pattern: " "" d557_644 ["char"])
let '#' = t1014_645
return ()) >> return False) `catchError` const (return True)
unless err1499_643 (StateT position >>= (throwError . mkParseError "!'#':" "not match: " "" d558_642 ["char"]))
put d558_642
_ <- StateT comments
return ()
d560_646 <- get
t1016_647 <- StateT char
case t1016_647 of
'-' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'-'" "not match pattern: " "" d560_646 ["char"])
let '-' = t1016_647
return ()
d561_648 <- get
t1017_649 <- StateT char
case t1017_649 of
'}' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'}'" "not match pattern: " "" d561_648 ["char"])
let '}' = t1017_649
return ()
return ()]
comments135_139 = foldl1 mplus [do _ <- StateT comStr
return ()
_ <- StateT comment
return ()
_ <- StateT comments
return ()
return (),
do _ <- StateT comStr
return ()
return ()]
comStr136_140 = foldl1 mplus [do d567_650 <- get
do err1500_651 <- ((do _ <- StateT comment
return ()) >> return False) `catchError` const (return True)
unless err1500_651 (StateT position >>= (throwError . mkParseError "!_:comment" "not match: " "" d567_650 ["comment"]))
put d567_650
d571_652 <- get
do err1501_653 <- ((do _ <- foldl1 mplus [do d569_654 <- get
t1024_655 <- StateT char
case t1024_655 of
'-' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'-'" "not match pattern: " "" d569_654 ["char"])
let '-' = t1024_655
return ()
d570_656 <- get
t1025_657 <- StateT char
case t1025_657 of
'}' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'}'" "not match pattern: " "" d570_656 ["char"])
let '}' = t1025_657
return ()
return ()]
return ()) >> return False) `catchError` const (return True)
unless err1501_653 (StateT position >>= (throwError . mkParseError "!_:('-': '}': {})" "not match: " "" d571_652 ["char"]))
put d571_652
_ <- StateT char
return ()
_ <- StateT comStr
return ()
return (),
return ()]
semiColon137_141 = foldl1 mplus [do d574_658 <- get
t1028_659 <- StateT char
case t1028_659 of
';' -> return ()
_ -> StateT position >>= (throwError . mkParseError "';'" "not match pattern: " "" d574_658 ["char"])
let ';' = t1028_659
return ()
return (),
do _ <- list1141_435 (foldl1 mplus [do d576_660 <- get
t1030_661 <- StateT char
case t1030_661 of
'\n' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'\\n'" "not match pattern: " "" d576_660 ["char"])
let '\n' = t1030_661
return ()
lift (lift (return ()))])
return ()
_ <- list140_145 (foldl1 mplus [do d578_662 <- get
t1032_663 <- StateT char
case t1032_663 of
'\t' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'\\t'" "not match pattern: " "" d578_662 ["char"])
let '\t' = t1032_663
return ()
return (),
do d579_664 <- get
t1033_665 <- StateT char
case t1033_665 of
' ' -> return ()
_ -> StateT position >>= (throwError . mkParseError "' '" "not match pattern: " "" d579_664 ["char"])
let ' ' = t1033_665
return ()
return ()])
return ()
d580_666 <- get
t1034_667 <- StateT position
let (!(ListPos (CharPos (_, x)))) = t1034_667
b1483_668 <- lift (lift (maybe False (x <=) <$> get))
unless b1483_668 (StateT position >>= (throwError . mkParseError "maybe False (x <=) <$> get" "not match: " "" d580_666 ["position"]))
d582_669 <- get
do err1502_670 <- ((do _ <- StateT lineComment
return ()) >> return False) `catchError` const (return True)
unless err1502_670 (StateT position >>= (throwError . mkParseError "!_:lineComment" "not match: " "" d582_669 ["lineComment"]))
put d582_669
d584_671 <- get
do err1503_672 <- ((do _ <- StateT comment
return ()) >> return False) `catchError` const (return True)
unless err1503_672 (StateT position >>= (throwError . mkParseError "!_:comment" "not match: " "" d584_671 ["comment"]))
put d584_671
d586_673 <- get
do err1504_674 <- ((do d585_675 <- get
t1037_676 <- StateT char
case t1037_676 of
';' -> return ()
_ -> StateT position >>= (throwError . mkParseError "';'" "not match pattern: " "" d585_675 ["char"])
let ';' = t1037_676
return ()) >> return False) `catchError` const (return True)
unless err1504_674 (StateT position >>= (throwError . mkParseError "!';':" "not match: " "" d586_673 ["char"]))
put d586_673
return (),
do d588_677 <- get
do err1505_678 <- ((do d587_679 <- get
_ <- StateT char
b1487_680 <- lift (lift (return True))
unless b1487_680 (StateT position >>= (throwError . mkParseError "return True" "not match: " "" d587_679 ["char"]))) >> return False) `catchError` const (return True)
unless err1505_678 (StateT position >>= (throwError . mkParseError "!_:[return True]" "not match: " "" d588_677 ["char"]))
put d588_677
return ()]
notSemiColon138_142 = foldl1 mplus [do _ <- list1141_435 (foldl1 mplus [do d590_681 <- get
t1040_682 <- StateT char
case t1040_682 of
'\n' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'\\n'" "not match pattern: " "" d590_681 ["char"])
let '\n' = t1040_682
return ()
lift (lift (return ()))])
return ()
_ <- list140_145 (foldl1 mplus [do d592_683 <- get
t1042_684 <- StateT char
case t1042_684 of
'\t' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'\\t'" "not match pattern: " "" d592_683 ["char"])
let '\t' = t1042_684
return ()
return (),
do d593_685 <- get
t1043_686 <- StateT char
case t1043_686 of
' ' -> return ()
_ -> StateT position >>= (throwError . mkParseError "' '" "not match pattern: " "" d593_685 ["char"])
let ' ' = t1043_686
return ()
return ()])
return ()
d594_687 <- get
t1044_688 <- StateT position
let (!(ListPos (CharPos (_, x)))) = t1044_688
b1493_689 <- lift (lift (maybe True (x >) <$> get))
unless b1493_689 (StateT position >>= (throwError . mkParseError "maybe True (x >) <$> get" "not match: " "" d594_687 ["position"]))
return (),
do _ <- list1141_435 (foldl1 mplus [do d596_690 <- get
t1046_691 <- StateT char
case t1046_691 of
'\n' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'\\n'" "not match pattern: " "" d596_690 ["char"])
let '\n' = t1046_691
return ()
lift (lift (return ()))])
return ()
_ <- StateT lineComment
return ()
return (),
do _ <- list1141_435 (foldl1 mplus [do d599_692 <- get
t1049_693 <- StateT char
case t1049_693 of
'\n' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'\\n'" "not match pattern: " "" d599_692 ["char"])
let '\n' = t1049_693
return ()
lift (lift (return ()))])
return ()
_ <- StateT comment
return ()
return (),
do _ <- list1141_435 (foldl1 mplus [do d602_694 <- get
t1052_695 <- StateT char
case t1052_695 of
'\n' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'\\n'" "not match pattern: " "" d602_694 ["char"])
let '\n' = t1052_695
return ()
lift (lift (return ()))])
return ()
d604_696 <- get
_ <- do d603_697 <- get
t1053_698 <- StateT char
case t1053_698 of
';' -> return ()
_ -> StateT position >>= (throwError . mkParseError "';'" "not match pattern: " "" d603_697 ["char"])
let ';' = t1053_698
return ()
put d604_696
return ()]
list140_145 :: forall m a . (MonadPlus m, Applicative m) =>
m a -> m ([a])
list1141_435 :: forall m a . (MonadPlus m, Applicative m) =>
m a -> m ([a])
list140_145 p = list1141_435 p `mplus` return []
list1141_435 p = ((:) <$> p) <*> list140_145 p
optional139_204 :: forall m a . (MonadPlus m, Applicative m) =>
m a -> m (Maybe a)
optional139_204 p = (Just <$> p) `mplus` return Nothing