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 Prelude hiding (Word)
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, String, 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
| WIf
| WThen
| WElse
| WLet
| WIn
| 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))),
prefix :: (ErrorT (ParseError (Pos String) Derivs)
(State ((Maybe Int)))
((String, 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 = parse1632_0 initialPos
where parse1632_0 pos1631_1 s1633_2 = d144_3
where d144_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 prefix17_20 definition18_21 selection19_22 normalSelection20_23 expressionHs21_24 expressionHsSugar22_25 expressionHsSugar'23_26 expression24_27 nameLeaf_25_28 nameLeaf26_29 nameLeafNoCom27_30 comForErr28_31 leaf29_32 patOp30_33 pat31_34 pat132_35 patList33_36 pats34_37 charLitLs35_38 readFromLs36_39 readFrom37_40 test38_41 hsExpLam39_42 hsExpTyp40_43 hsExpOp41_44 hsOp42_45 hsExpLam'43_46 hsExpTyp'44_47 hsExpOp'45_48 hsOp'46_49 hsExp47_50 hsExp148_51 hsExpTpl49_52 hsTypeArr50_53 hsType51_54 hsType152_55 hsTypeTpl53_56 wrd54_57 hsw55_58 word56_59 hsWord57_60 bras58_61 typ59_62 var60_63 strLit61_64 escChar62_65 space63_66 space'64_67 lineComment65_68 comment66_69 comments67_70 comStr68_71 semiColon69_72 notSemiColon70_73 chars1634_74 (return (pos1631_1,
d144_3))
pegFile1_4 = runStateT pegFile71_75 d144_3
pragma2_5 = runStateT pragma72_76 d144_3
pragmaStr3_6 = runStateT pragmaStr73_77 d144_3
pragmaItems4_7 = runStateT pragmaItems74_78 d144_3
moduleDec5_8 = runStateT moduleDec75_79 d144_3
moduleName6_9 = runStateT moduleName76_80 d144_3
moduleDecStr7_10 = runStateT moduleDecStr77_81 d144_3
whr8_11 = runStateT whr78_82 d144_3
preImpPap9_12 = runStateT preImpPap79_83 d144_3
prePeg10_13 = runStateT prePeg80_84 d144_3
afterPeg11_14 = runStateT afterPeg81_85 d144_3
importPapillon12_15 = runStateT importPapillon82_86 d144_3
peg13_16 = runStateT peg83_87 d144_3
peg_14_17 = runStateT peg_84_88 d144_3
monadType15_18 = runStateT monadType85_89 d144_3
sourceType16_19 = runStateT sourceType86_90 d144_3
prefix17_20 = runStateT prefix87_91 d144_3
definition18_21 = runStateT definition88_92 d144_3
selection19_22 = runStateT selection89_93 d144_3
normalSelection20_23 = runStateT normalSelection90_94 d144_3
expressionHs21_24 = runStateT expressionHs91_95 d144_3
expressionHsSugar22_25 = runStateT expressionHsSugar92_96 d144_3
expressionHsSugar'23_26 = runStateT expressionHsSugar'93_97 d144_3
expression24_27 = runStateT expression94_98 d144_3
nameLeaf_25_28 = runStateT nameLeaf_95_99 d144_3
nameLeaf26_29 = runStateT nameLeaf96_100 d144_3
nameLeafNoCom27_30 = runStateT nameLeafNoCom97_101 d144_3
comForErr28_31 = runStateT comForErr98_102 d144_3
leaf29_32 = runStateT leaf99_103 d144_3
patOp30_33 = runStateT patOp100_104 d144_3
pat31_34 = runStateT pat101_105 d144_3
pat132_35 = runStateT pat1102_106 d144_3
patList33_36 = runStateT patList103_107 d144_3
pats34_37 = runStateT pats104_108 d144_3
charLitLs35_38 = runStateT charLitLs105_109 d144_3
readFromLs36_39 = runStateT readFromLs106_110 d144_3
readFrom37_40 = runStateT readFrom107_111 d144_3
test38_41 = runStateT test108_112 d144_3
hsExpLam39_42 = runStateT hsExpLam109_113 d144_3
hsExpTyp40_43 = runStateT hsExpTyp110_114 d144_3
hsExpOp41_44 = runStateT hsExpOp111_115 d144_3
hsOp42_45 = runStateT hsOp112_116 d144_3
hsExpLam'43_46 = runStateT hsExpLam'113_117 d144_3
hsExpTyp'44_47 = runStateT hsExpTyp'114_118 d144_3
hsExpOp'45_48 = runStateT hsExpOp'115_119 d144_3
hsOp'46_49 = runStateT hsOp'116_120 d144_3
hsExp47_50 = runStateT hsExp117_121 d144_3
hsExp148_51 = runStateT hsExp1118_122 d144_3
hsExpTpl49_52 = runStateT hsExpTpl119_123 d144_3
hsTypeArr50_53 = runStateT hsTypeArr120_124 d144_3
hsType51_54 = runStateT hsType121_125 d144_3
hsType152_55 = runStateT hsType1122_126 d144_3
hsTypeTpl53_56 = runStateT hsTypeTpl123_127 d144_3
wrd54_57 = runStateT wrd124_128 d144_3
hsw55_58 = runStateT hsw125_129 d144_3
word56_59 = runStateT word126_130 d144_3
hsWord57_60 = runStateT hsWord127_131 d144_3
bras58_61 = runStateT bras128_132 d144_3
typ59_62 = runStateT typ129_133 d144_3
var60_63 = runStateT var130_134 d144_3
strLit61_64 = runStateT strLit131_135 d144_3
escChar62_65 = runStateT escChar132_136 d144_3
space63_66 = runStateT space133_137 d144_3
space'64_67 = runStateT space'134_138 d144_3
lineComment65_68 = runStateT lineComment135_139 d144_3
comment66_69 = runStateT comment136_140 d144_3
comments67_70 = runStateT comments137_141 d144_3
comStr68_71 = runStateT comStr138_142 d144_3
semiColon69_72 = runStateT semiColon139_143 d144_3
notSemiColon70_73 = runStateT notSemiColon140_144 d144_3
chars1634_74 = runStateT (case getToken s1633_2 of
Just (c1616_145,
s'1630_146) -> do put (parse1632_0 (updatePos c1616_145 pos1631_1) s'1630_146)
return c1616_145
_ -> StateT position >>= (throwError . mkParseError "" "end of input" "" undefined [])) d144_3
pegFile71_75 = foldl1 mplus [do pr <- list142_147 (StateT pragma)
md <- StateT moduleDec
pip <- StateT preImpPap
_ <- StateT importPapillon
return ()
pp <- StateT prePeg
d149_148 <- get
t648_149 <- StateT hsw
case t648_149 of
(WOQuasiQuote "papillon") -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WOQuasiQuote \"papillon\")" "not match pattern: " "" d149_148 ["hsw"])
let (WOQuasiQuote "papillon") = t648_149
return ()
p <- StateT peg_
d151_150 <- get
t650_151 <- StateT hsw
case t650_151 of
WCQuasiQuote -> return ()
_ -> StateT position >>= (throwError . mkParseError "WCQuasiQuote" "not match pattern: " "" d151_150 ["hsw"])
let WCQuasiQuote = t650_151
return ()
atp <- StateT afterPeg
lift (lift (return $ mkPegFile pr md pip pp p atp)),
do pr <- list142_147 (StateT pragma)
md <- StateT moduleDec
pp <- StateT prePeg
d156_152 <- get
t655_153 <- StateT hsw
case t655_153 of
(WOQuasiQuote "papillon") -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WOQuasiQuote \"papillon\")" "not match pattern: " "" d156_152 ["hsw"])
let (WOQuasiQuote "papillon") = t655_153
return ()
p <- StateT peg_
d158_154 <- get
t657_155 <- StateT hsw
case t657_155 of
WCQuasiQuote -> return ()
_ -> StateT position >>= (throwError . mkParseError "WCQuasiQuote" "not match pattern: " "" d158_154 ["hsw"])
let WCQuasiQuote = t657_155
return ()
atp <- StateT afterPeg
lift (lift (return $ mkPegFile pr md [] pp p atp))]
pragma72_76 = foldl1 mplus [do d160_156 <- get
t659_157 <- StateT hsw
case t659_157 of
WOComment -> return ()
_ -> StateT position >>= (throwError . mkParseError "WOComment" "not match pattern: " "" d160_156 ["hsw"])
let WOComment = t659_157
return ()
d161_158 <- get
t660_159 <- StateT hsw
case t660_159 of
(WType [] "LANGUAGE") -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WType [] \"LANGUAGE\")" "not match pattern: " "" d161_158 ["hsw"])
let (WType [] "LANGUAGE") = t660_159
return ()
s <- StateT pragmaItems
d163_160 <- get
t662_161 <- StateT hsw
case t662_161 of
WCComment -> return ()
_ -> StateT position >>= (throwError . mkParseError "WCComment" "not match pattern: " "" d163_160 ["hsw"])
let WCComment = t662_161
return ()
lift (lift (return $ LanguagePragma s)),
do d164_162 <- get
t663_163 <- StateT hsw
case t663_163 of
WOComment -> return ()
_ -> StateT position >>= (throwError . mkParseError "WOComment" "not match pattern: " "" d164_162 ["hsw"])
let WOComment = t663_163
return ()
s <- StateT pragmaStr
d166_164 <- get
t665_165 <- StateT hsw
case t665_165 of
WCComment -> return ()
_ -> StateT position >>= (throwError . mkParseError "WCComment" "not match pattern: " "" d166_164 ["hsw"])
let WCComment = t665_165
return ()
lift (lift (return $ OtherPragma s))]
pragmaStr73_77 = foldl1 mplus [do d168_166 <- get
do err1604_167 <- ((do d167_168 <- get
t666_169 <- StateT hsw
case t666_169 of
WCComment -> return ()
_ -> StateT position >>= (throwError . mkParseError "WCComment" "not match pattern: " "" d167_168 ["hsw"])
let WCComment = t666_169
return ()) >> return False) `catchError` const (return True)
unless err1604_167 (StateT position >>= (throwError . mkParseError "!WCComment:hsw" "not match: " "" d168_166 ["hsw"]))
put d168_166
c <- StateT char
s <- StateT pragmaStr
lift (lift (return $ c : s)),
lift (lift (return ""))]
pragmaItems74_78 = foldl1 mplus [do d171_170 <- get
t669_171 <- StateT hsw
case t669_171 of
(WType [] _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WType [] t)" "not match pattern: " "" d171_170 ["hsw"])
let (WType [] t) = t669_171
return ()
d172_172 <- get
t670_173 <- StateT hsw
case t670_173 of
WComma -> return ()
_ -> StateT position >>= (throwError . mkParseError "WComma" "not match pattern: " "" d172_172 ["hsw"])
let WComma = t670_173
return ()
i <- StateT pragmaItems
lift (lift (return $ t : i)),
do d174_174 <- get
t672_175 <- StateT hsw
case t672_175 of
(WType [] _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WType [] t)" "not match pattern: " "" d174_174 ["hsw"])
let (WType [] t) = t672_175
return ()
lift (lift (return [t]))]
moduleDec75_79 = foldl1 mplus [do d175_176 <- get
t673_177 <- StateT hsw
case t673_177 of
WModule -> return ()
_ -> StateT position >>= (throwError . mkParseError "WModule" "not match pattern: " "" d175_176 ["hsw"])
let WModule = t673_177
return ()
n <- StateT moduleName
d177_178 <- get
t675_179 <- StateT hsw
case t675_179 of
WOParen -> return ()
_ -> StateT position >>= (throwError . mkParseError "WOParen" "not match pattern: " "" d177_178 ["hsw"])
let WOParen = t675_179
return ()
s <- StateT moduleDecStr
_ <- StateT whr
return ()
lift (lift (return $ Just (n, Just s))),
do d180_180 <- get
t678_181 <- StateT hsw
case t678_181 of
WModule -> return ()
_ -> StateT position >>= (throwError . mkParseError "WModule" "not match pattern: " "" d180_180 ["hsw"])
let WModule = t678_181
return ()
n <- StateT moduleName
d182_182 <- get
t680_183 <- StateT hsw
case t680_183 of
WWhere -> return ()
_ -> StateT position >>= (throwError . mkParseError "WWhere" "not match pattern: " "" d182_182 ["hsw"])
let WWhere = t680_183
return ()
lift (lift (return $ Just (n, Nothing))),
lift (lift (return Nothing))]
moduleName76_80 = foldl1 mplus [do d183_184 <- get
t681_185 <- StateT hsw
case t681_185 of
(WType _ _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WType m t)" "not match pattern: " "" d183_184 ["hsw"])
let (WType m t) = t681_185
return ()
lift (lift (return $ m ++ [t]))]
moduleDecStr77_81 = foldl1 mplus [do d185_186 <- get
do err1605_187 <- ((do _ <- StateT whr
return ()) >> return False) `catchError` const (return True)
unless err1605_187 (StateT position >>= (throwError . mkParseError "!_:whr" "not match: " "" d185_186 ["whr"]))
put d185_186
c <- StateT char
s <- StateT moduleDecStr
lift (lift (return $ c : s)),
lift (lift (return ""))]
whr78_82 = foldl1 mplus [do d188_188 <- get
t685_189 <- StateT hsw
case t685_189 of
WCParen -> return ()
_ -> StateT position >>= (throwError . mkParseError "WCParen" "not match pattern: " "" d188_188 ["hsw"])
let WCParen = t685_189
return ()
d189_190 <- get
t686_191 <- StateT hsw
case t686_191 of
WWhere -> return ()
_ -> StateT position >>= (throwError . mkParseError "WWhere" "not match pattern: " "" d189_190 ["hsw"])
let WWhere = t686_191
return ()
return ()]
preImpPap79_83 = foldl1 mplus [do d191_192 <- get
do err1606_193 <- ((do _ <- StateT importPapillon
return ()) >> return False) `catchError` const (return True)
unless err1606_193 (StateT position >>= (throwError . mkParseError "!_:importPapillon" "not match: " "" d191_192 ["importPapillon"]))
put d191_192
d193_194 <- get
do err1607_195 <- ((do d192_196 <- get
t688_197 <- StateT hsw
case t688_197 of
(WOQuasiQuote "papillon") -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WOQuasiQuote \"papillon\")" "not match pattern: " "" d192_196 ["hsw"])
let (WOQuasiQuote "papillon") = t688_197
return ()) >> return False) `catchError` const (return True)
unless err1607_195 (StateT position >>= (throwError . mkParseError "!(WOQuasiQuote \"papillon\"):hsw" "not match: " "" d193_194 ["hsw"]))
put d193_194
c <- StateT char
pip <- StateT preImpPap
lift (lift (return $ c : pip)),
lift (lift (return ""))]
prePeg80_84 = foldl1 mplus [do d197_198 <- get
do err1608_199 <- ((do d196_200 <- get
t691_201 <- StateT hsw
case t691_201 of
(WOQuasiQuote "papillon") -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WOQuasiQuote \"papillon\")" "not match pattern: " "" d196_200 ["hsw"])
let (WOQuasiQuote "papillon") = t691_201
return ()) >> return False) `catchError` const (return True)
unless err1608_199 (StateT position >>= (throwError . mkParseError "!(WOQuasiQuote \"papillon\"):hsw" "not match: " "" d197_198 ["hsw"]))
put d197_198
c <- StateT char
pp <- StateT prePeg
lift (lift (return $ c : pp)),
lift (lift (return ""))]
afterPeg81_85 = foldl1 mplus [do c <- StateT char
atp <- StateT afterPeg
lift (lift (return $ c : atp)),
lift (lift (return ""))]
importPapillon82_86 = foldl1 mplus [do d202_202 <- get
t696_203 <- StateT hsw
case t696_203 of
WImport -> return ()
_ -> StateT position >>= (throwError . mkParseError "WImport" "not match pattern: " "" d202_202 ["hsw"])
let WImport = t696_203
return ()
d203_204 <- get
t697_205 <- StateT hsw
case t697_205 of
(WType ["Text"] "Papillon") -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WType [\"Text\"] \"Papillon\")" "not match pattern: " "" d203_204 ["hsw"])
let (WType ["Text"] "Papillon") = t697_205
return ()
return ()]
peg83_87 = foldl1 mplus [do _ <- list142_147 (StateT space)
return ()
p <- StateT peg_
lift (lift (return p))]
peg_84_88 = foldl1 mplus [do mt <- optional141_206 (StateT monadType)
st <- optional141_206 (StateT sourceType)
prfx <- optional141_206 (StateT prefix)
p <- list142_147 (StateT definition)
lift (lift (return (mt,
fromMaybe (ConT $ mkName "String") st,
fromMaybe "" prfx,
p)))]
monadType85_89 = foldl1 mplus [do d210_207 <- get
t704_208 <- StateT position
let (!(ListPos (CharPos (_, x)))) = t704_208
b1189_209 <- lift (lift (put (Just x) >> return True))
unless b1189_209 (StateT position >>= (throwError . mkParseError "put (Just x) >> return True" "not match: " "" d210_207 ["position"]))
d211_210 <- get
t705_211 <- StateT wrd
case t705_211 of
(WSymbol "monad") -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WSymbol \"monad\")" "not match pattern: " "" d211_210 ["wrd"])
let (WSymbol "monad") = t705_211
return ()
d212_212 <- get
t706_213 <- StateT wrd
case t706_213 of
WColon -> return ()
_ -> StateT position >>= (throwError . mkParseError "WColon" "not match pattern: " "" d212_212 ["wrd"])
let WColon = t706_213
return ()
t <- StateT hsTypeArr
d214_214 <- get
t708_215 <- StateT wrd
case t708_215 of
WSemiColon -> return ()
_ -> StateT position >>= (throwError . mkParseError "WSemiColon" "not match pattern: " "" d214_214 ["wrd"])
let WSemiColon = t708_215
return ()
lift (lift (put Nothing >> return t))]
sourceType86_90 = foldl1 mplus [do d215_216 <- get
t709_217 <- StateT position
let (!(ListPos (CharPos (_, x)))) = t709_217
b1194_218 <- lift (lift (put (Just x) >> return True))
unless b1194_218 (StateT position >>= (throwError . mkParseError "put (Just x) >> return True" "not match: " "" d215_216 ["position"]))
d216_219 <- get
t710_220 <- StateT wrd
case t710_220 of
(WSymbol "source") -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WSymbol \"source\")" "not match pattern: " "" d216_219 ["wrd"])
let (WSymbol "source") = t710_220
return ()
d217_221 <- get
t711_222 <- StateT wrd
case t711_222 of
WColon -> return ()
_ -> StateT position >>= (throwError . mkParseError "WColon" "not match pattern: " "" d217_221 ["wrd"])
let WColon = t711_222
return ()
t <- StateT hsTypeArr
d219_223 <- get
t713_224 <- StateT wrd
case t713_224 of
WSemiColon -> return ()
_ -> StateT position >>= (throwError . mkParseError "WSemiColon" "not match pattern: " "" d219_223 ["wrd"])
let WSemiColon = t713_224
return ()
lift (lift (put Nothing >> return t))]
prefix87_91 = foldl1 mplus [do d220_225 <- get
t714_226 <- StateT position
let (!(ListPos (CharPos (_, x)))) = t714_226
b1199_227 <- lift (lift (put (Just x) >> return True))
unless b1199_227 (StateT position >>= (throwError . mkParseError "put (Just x) >> return True" "not match: " "" d220_225 ["position"]))
d221_228 <- get
t715_229 <- StateT wrd
case t715_229 of
(WSymbol "prefix") -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WSymbol \"prefix\")" "not match pattern: " "" d221_228 ["wrd"])
let (WSymbol "prefix") = t715_229
return ()
d222_230 <- get
t716_231 <- StateT wrd
case t716_231 of
WColon -> return ()
_ -> StateT position >>= (throwError . mkParseError "WColon" "not match pattern: " "" d222_230 ["wrd"])
let WColon = t716_231
return ()
d223_232 <- get
t717_233 <- StateT hsw
case t717_233 of
(WString _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WString prfx)" "not match pattern: " "" d223_232 ["hsw"])
let (WString prfx) = t717_233
return ()
d224_234 <- get
t718_235 <- StateT wrd
case t718_235 of
WSemiColon -> return ()
_ -> StateT position >>= (throwError . mkParseError "WSemiColon" "not match pattern: " "" d224_234 ["wrd"])
let WSemiColon = t718_235
return ()
lift (lift (put Nothing >> return prfx))]
definition88_92 = foldl1 mplus [do d225_236 <- get
t719_237 <- StateT position
let (!(ListPos (CharPos (_, x)))) = t719_237
b1204_238 <- lift (lift (put (Just x) >> return True))
unless b1204_238 (StateT position >>= (throwError . mkParseError "put (Just x) >> return True" "not match: " "" d225_236 ["position"]))
d226_239 <- get
t720_240 <- StateT wrd
case t720_240 of
(WSymbol _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WSymbol v)" "not match pattern: " "" d226_239 ["wrd"])
let (WSymbol v) = t720_240
return ()
mt <- optional141_206 (foldl1 mplus [do d228_241 <- get
t722_242 <- StateT hsw
case t722_242 of
WTypeDef -> return ()
_ -> StateT position >>= (throwError . mkParseError "WTypeDef" "not match pattern: " "" d228_241 ["hsw"])
let WTypeDef = t722_242
return ()
t <- StateT hsTypeArr
lift (lift (return t))])
d230_243 <- get
t724_244 <- StateT wrd
case t724_244 of
WEqual -> return ()
_ -> StateT position >>= (throwError . mkParseError "WEqual" "not match pattern: " "" d230_243 ["wrd"])
let WEqual = t724_244
return ()
sel <- StateT selection
d232_245 <- get
t726_246 <- StateT wrd
case t726_246 of
WSemiColon -> return ()
_ -> StateT position >>= (throwError . mkParseError "WSemiColon" "not match pattern: " "" d232_245 ["wrd"])
let WSemiColon = t726_246
return ()
lift (lift (put Nothing >> return (v, mt, sel)))]
selection89_93 = foldl1 mplus [do ns <- StateT normalSelection
lift (lift (return ns))]
normalSelection90_94 = foldl1 mplus [do ex <- StateT expressionHs
d235_247 <- get
t729_248 <- StateT wrd
case t729_248 of
WSlash -> return ()
_ -> StateT position >>= (throwError . mkParseError "WSlash" "not match pattern: " "" d235_247 ["wrd"])
let WSlash = t729_248
return ()
sel <- StateT normalSelection
lift (lift (return $ ex : sel)),
do ex <- StateT expressionHs
lift (lift (return [ex]))]
expressionHs91_95 = foldl1 mplus [do e <- StateT expressionHsSugar
lift (lift (return e)),
do e <- StateT expression
mh <- optional141_206 (foldl1 mplus [do d241_249 <- get
t735_250 <- StateT wrd
case t735_250 of
WOBrace -> return ()
_ -> StateT position >>= (throwError . mkParseError "WOBrace" "not match pattern: " "" d241_249 ["wrd"])
let WOBrace = t735_250
return ()
h <- StateT hsExpLam
d243_251 <- get
t737_252 <- StateT wrd
case t737_252 of
WCBrace -> return ()
_ -> StateT position >>= (throwError . mkParseError "WCBrace" "not match pattern: " "" d243_251 ["wrd"])
let WCBrace = t737_252
return ()
lift (lift (return h))])
lift (lift (return $ Left (e, mh)))]
expressionHsSugar92_96 = foldl1 mplus [do d244_253 <- get
t738_254 <- StateT wrd
case t738_254 of
WLT -> return ()
_ -> StateT position >>= (throwError . mkParseError "WLT" "not match pattern: " "" d244_253 ["wrd"])
let WLT = t738_254
return ()
h <- StateT hsExpLam
d246_255 <- get
t740_256 <- StateT wrd
case t740_256 of
WGT -> return ()
_ -> StateT position >>= (throwError . mkParseError "WGT" "not match pattern: " "" d246_255 ["wrd"])
let WGT = t740_256
return ()
lift (lift (return $ Right h))]
expressionHsSugar'93_97 = foldl1 mplus [do d247_257 <- get
t741_258 <- StateT wrd
case t741_258 of
WLT -> return ()
_ -> StateT position >>= (throwError . mkParseError "WLT" "not match pattern: " "" d247_257 ["wrd"])
let WLT = t741_258
return ()
h <- StateT hsExpLam'
d249_259 <- get
t743_260 <- StateT wrd
case t743_260 of
WGT -> return ()
_ -> StateT position >>= (throwError . mkParseError "WGT" "not match pattern: " "" d249_259 ["wrd"])
let WGT = t743_260
return ()
lift (lift (return $ Right h))]
expression94_98 = foldl1 mplus [do l <- StateT nameLeaf_
e <- StateT expression
lift (lift (return $ l : e)),
lift (lift (return []))]
nameLeaf_95_99 = foldl1 mplus [do d252_261 <- get
t746_262 <- StateT wrd
case t746_262 of
WBang -> return ()
_ -> StateT position >>= (throwError . mkParseError "WBang" "not match pattern: " "" d252_261 ["wrd"])
let WBang = t746_262
return ()
nl <- StateT nameLeafNoCom
com <- optional141_206 (StateT comForErr)
lift (lift (return (NAhead $ maybe "" id com,
nl))),
do d255_263 <- get
t749_264 <- StateT wrd
case t749_264 of
WAmp -> return ()
_ -> StateT position >>= (throwError . mkParseError "WAmp" "not match pattern: " "" d255_263 ["wrd"])
let WAmp = t749_264
return ()
nl <- StateT nameLeaf
lift (lift (return (Ahead, nl))),
do nl <- StateT nameLeaf
lift (lift (return (Here, nl)))]
nameLeaf96_100 = foldl1 mplus [do cl <- StateT charLitLs
lift (lift (return cl)),
do n <- StateT pat1
com <- optional141_206 (StateT comForErr)
d261_265 <- get
t755_266 <- StateT wrd
case t755_266 of
WColon -> return ()
_ -> StateT position >>= (throwError . mkParseError "WColon" "not match pattern: " "" d261_265 ["wrd"])
let WColon = t755_266
return ()
(rf, p) <- StateT leaf
lift (lift (return $ Left ((n, maybe "" id com),
rf,
p))),
do n <- StateT pat1
com <- optional141_206 (StateT comForErr)
lift (lift (return $ Left ((n, maybe "" id com),
FromVariable Nothing,
Nothing)))]
nameLeafNoCom97_101 = foldl1 mplus [do cl <- StateT charLitLs
lift (lift (return cl)),
do n <- StateT pat1
com <- optional141_206 (StateT comForErr)
d268_267 <- get
t762_268 <- StateT wrd
case t762_268 of
WColon -> return ()
_ -> StateT position >>= (throwError . mkParseError "WColon" "not match pattern: " "" d268_267 ["wrd"])
let WColon = t762_268
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)))]
comForErr98_102 = foldl1 mplus [do d271_269 <- get
t765_270 <- StateT hsw
case t765_270 of
WOComment -> return ()
_ -> StateT position >>= (throwError . mkParseError "WOComment" "not match pattern: " "" d271_269 ["hsw"])
let WOComment = t765_270
return ()
d272_271 <- get
t766_272 <- StateT hsw
case t766_272 of
(WString _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WString s)" "not match pattern: " "" d272_271 ["hsw"])
let (WString s) = t766_272
return ()
d273_273 <- get
t767_274 <- StateT hsw
case t767_274 of
WCComment -> return ()
_ -> StateT position >>= (throwError . mkParseError "WCComment" "not match pattern: " "" d273_273 ["hsw"])
let WCComment = t767_274
return ()
lift (lift (return s))]
leaf99_103 = 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)))]
patOp100_104 = foldl1 mplus [do p <- StateT pat
d279_275 <- get
t773_276 <- StateT hsw
case t773_276 of
(WOpCon _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WOpCon o)" "not match pattern: " "" d279_275 ["hsw"])
let (WOpCon o) = t773_276
return ()
po <- StateT patOp
lift (lift (return $ UInfixP p (mkName o) po)),
do p <- StateT pat
d282_277 <- get
t776_278 <- StateT hsw
case t776_278 of
WBackQuote -> return ()
_ -> StateT position >>= (throwError . mkParseError "WBackQuote" "not match pattern: " "" d282_277 ["hsw"])
let WBackQuote = t776_278
return ()
d283_279 <- get
t777_280 <- StateT hsw
case t777_280 of
(WType [] _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WType [] t)" "not match pattern: " "" d283_279 ["hsw"])
let (WType [] t) = t777_280
return ()
d284_281 <- get
t778_282 <- StateT hsw
case t778_282 of
WBackQuote -> return ()
_ -> StateT position >>= (throwError . mkParseError "WBackQuote" "not match pattern: " "" d284_281 ["hsw"])
let WBackQuote = t778_282
return ()
po <- StateT patOp
lift (lift (return $ UInfixP p (mkName t) po)),
do p <- StateT pat
lift (lift (return p))]
pat101_105 = foldl1 mplus [do d287_283 <- get
t781_284 <- StateT hsw
case t781_284 of
(WType [] _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WType [] t)" "not match pattern: " "" d287_283 ["hsw"])
let (WType [] t) = t781_284
return ()
ps <- StateT pats
lift (lift (return $ ConP (mkName t) ps)),
do d289_285 <- get
t783_286 <- StateT hsw
case t783_286 of
WOParen -> return ()
_ -> StateT position >>= (throwError . mkParseError "WOParen" "not match pattern: " "" d289_285 ["hsw"])
let WOParen = t783_286
return ()
d290_287 <- get
t784_288 <- StateT hsw
case t784_288 of
(WOpCon _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WOpCon o)" "not match pattern: " "" d290_287 ["hsw"])
let (WOpCon o) = t784_288
return ()
d291_289 <- get
t785_290 <- StateT hsw
case t785_290 of
WCParen -> return ()
_ -> StateT position >>= (throwError . mkParseError "WCParen" "not match pattern: " "" d291_289 ["hsw"])
let WCParen = t785_290
return ()
ps <- StateT pats
lift (lift (return $ ConP (mkName o) ps)),
do p <- StateT pat1
lift (lift (return p))]
pat1102_106 = foldl1 mplus [do d294_291 <- get
t788_292 <- StateT hsw
case t788_292 of
(WVar [] _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WVar [] n)" "not match pattern: " "" d294_291 ["hsw"])
let (WVar [] n) = t788_292
return ()
d295_293 <- get
t789_294 <- StateT hsw
case t789_294 of
(WOp "@") -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WOp \"@\")" "not match pattern: " "" d295_293 ["hsw"])
let (WOp "@") = t789_294
return ()
p <- StateT pat1
lift (lift (return $ AsP (mkName n) p)),
do d297_295 <- get
t791_296 <- StateT hsw
case t791_296 of
(WType [] _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WType [] t)" "not match pattern: " "" d297_295 ["hsw"])
let (WType [] t) = t791_296
return ()
lift (lift (return $ ConP (mkName t) [])),
do d298_297 <- get
t792_298 <- StateT hsw
case t792_298 of
(WVar [] "_") -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WVar [] \"_\")" "not match pattern: " "" d298_297 ["hsw"])
let (WVar [] "_") = t792_298
return ()
lift (lift (return WildP)),
do d299_299 <- get
t793_300 <- StateT hsw
case t793_300 of
(WVar [] _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WVar [] n)" "not match pattern: " "" d299_299 ["hsw"])
let (WVar [] n) = t793_300
return ()
lift (lift (return $ VarP $ mkName n)),
do d300_301 <- get
t794_302 <- StateT hsw
case t794_302 of
(WInteger _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WInteger i)" "not match pattern: " "" d300_301 ["hsw"])
let (WInteger i) = t794_302
return ()
lift (lift (return $ LitP (IntegerL i))),
do d301_303 <- get
t795_304 <- StateT hsw
case t795_304 of
(WOp "-") -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WOp \"-\")" "not match pattern: " "" d301_303 ["hsw"])
let (WOp "-") = t795_304
return ()
d302_305 <- get
t796_306 <- StateT hsw
case t796_306 of
(WInteger _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WInteger i)" "not match pattern: " "" d302_305 ["hsw"])
let (WInteger i) = t796_306
return ()
lift (lift (return $ LitP (IntegerL $ negate i))),
do d303_307 <- get
t797_308 <- StateT hsw
case t797_308 of
(WChar _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WChar c)" "not match pattern: " "" d303_307 ["hsw"])
let (WChar c) = t797_308
return ()
lift (lift (return $ LitP $ CharL c)),
do d304_309 <- get
t798_310 <- StateT hsw
case t798_310 of
(WString _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WString s)" "not match pattern: " "" d304_309 ["hsw"])
let (WString s) = t798_310
return ()
lift (lift (return $ LitP $ StringL s)),
do d305_311 <- get
t799_312 <- StateT hsw
case t799_312 of
WOParen -> return ()
_ -> StateT position >>= (throwError . mkParseError "WOParen" "not match pattern: " "" d305_311 ["hsw"])
let WOParen = t799_312
return ()
p <- StateT patList
d307_313 <- get
t801_314 <- StateT hsw
case t801_314 of
WCParen -> return ()
_ -> StateT position >>= (throwError . mkParseError "WCParen" "not match pattern: " "" d307_313 ["hsw"])
let WCParen = t801_314
return ()
lift (lift (return $ TupP p)),
do d308_315 <- get
t802_316 <- StateT hsw
case t802_316 of
WOBracket -> return ()
_ -> StateT position >>= (throwError . mkParseError "WOBracket" "not match pattern: " "" d308_315 ["hsw"])
let WOBracket = t802_316
return ()
p <- StateT patList
d310_317 <- get
t804_318 <- StateT hsw
case t804_318 of
WCBracket -> return ()
_ -> StateT position >>= (throwError . mkParseError "WCBracket" "not match pattern: " "" d310_317 ["hsw"])
let WCBracket = t804_318
return ()
lift (lift (return $ ListP p)),
do d311_319 <- get
t805_320 <- StateT hsw
case t805_320 of
WOParen -> return ()
_ -> StateT position >>= (throwError . mkParseError "WOParen" "not match pattern: " "" d311_319 ["hsw"])
let WOParen = t805_320
return ()
p <- StateT pat
d313_321 <- get
t807_322 <- StateT hsw
case t807_322 of
WCParen -> return ()
_ -> StateT position >>= (throwError . mkParseError "WCParen" "not match pattern: " "" d313_321 ["hsw"])
let WCParen = t807_322
return ()
lift (lift (return p)),
do d314_323 <- get
t808_324 <- StateT hsw
case t808_324 of
(WOp "!") -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WOp \"!\")" "not match pattern: " "" d314_323 ["hsw"])
let (WOp "!") = t808_324
return ()
p <- StateT pat
lift (lift (return $ BangP p))]
patList103_107 = foldl1 mplus [do p <- StateT patOp
d317_325 <- get
t811_326 <- StateT hsw
case t811_326 of
WComma -> return ()
_ -> StateT position >>= (throwError . mkParseError "WComma" "not match pattern: " "" d317_325 ["hsw"])
let WComma = t811_326
return ()
ps <- StateT patList
lift (lift (return $ p : ps)),
do p <- StateT patOp
lift (lift (return [p])),
lift (lift (return []))]
pats104_108 = foldl1 mplus [do p <- StateT pat
ps <- StateT pats
lift (lift (return $ p : ps)),
lift (lift (return []))]
charLitLs105_109 = foldl1 mplus [do d322_327 <- get
t816_328 <- StateT hsw
case t816_328 of
(WChar _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WChar c)" "not match pattern: " "" d322_327 ["hsw"])
let (WChar c) = t816_328
return ()
d323_329 <- get
t817_330 <- StateT wrd
case t817_330 of
WAsterisk -> return ()
_ -> StateT position >>= (throwError . mkParseError "WAsterisk" "not match pattern: " "" d323_329 ["wrd"])
let WAsterisk = t817_330
return ()
lift (lift (return $ Right (c, List))),
do d324_331 <- get
t818_332 <- StateT hsw
case t818_332 of
(WChar _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WChar c)" "not match pattern: " "" d324_331 ["hsw"])
let (WChar c) = t818_332
return ()
d325_333 <- get
t819_334 <- StateT wrd
case t819_334 of
WPlus -> return ()
_ -> StateT position >>= (throwError . mkParseError "WPlus" "not match pattern: " "" d325_333 ["wrd"])
let WPlus = t819_334
return ()
lift (lift (return $ Right (c, List1))),
do d326_335 <- get
t820_336 <- StateT hsw
case t820_336 of
(WChar _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WChar c)" "not match pattern: " "" d326_335 ["hsw"])
let (WChar c) = t820_336
return ()
d327_337 <- get
t821_338 <- StateT wrd
case t821_338 of
WQuestion -> return ()
_ -> StateT position >>= (throwError . mkParseError "WQuestion" "not match pattern: " "" d327_337 ["wrd"])
let WQuestion = t821_338
return ()
lift (lift (return $ Right (c, Optional)))]
readFromLs106_110 = foldl1 mplus [do rf <- StateT readFrom
d329_339 <- get
t823_340 <- StateT wrd
case t823_340 of
WAsterisk -> return ()
_ -> StateT position >>= (throwError . mkParseError "WAsterisk" "not match pattern: " "" d329_339 ["wrd"])
let WAsterisk = t823_340
return ()
lift (lift (return $ FromL List rf)),
do rf <- StateT readFrom
d331_341 <- get
t825_342 <- StateT wrd
case t825_342 of
WPlus -> return ()
_ -> StateT position >>= (throwError . mkParseError "WPlus" "not match pattern: " "" d331_341 ["wrd"])
let WPlus = t825_342
return ()
lift (lift (return $ FromL List1 rf)),
do rf <- StateT readFrom
d333_343 <- get
t827_344 <- StateT wrd
case t827_344 of
WQuestion -> return ()
_ -> StateT position >>= (throwError . mkParseError "WQuestion" "not match pattern: " "" d333_343 ["wrd"])
let WQuestion = t827_344
return ()
lift (lift (return $ FromL Optional rf)),
do rf <- StateT readFrom
lift (lift (return rf))]
readFrom107_111 = foldl1 mplus [do d335_345 <- get
t829_346 <- StateT wrd
case t829_346 of
(WSymbol _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WSymbol v)" "not match pattern: " "" d335_345 ["wrd"])
let (WSymbol v) = t829_346
return ()
lift (lift (return $ FromVariable $ Just v)),
do d336_347 <- get
t830_348 <- StateT wrd
case t830_348 of
WOParen -> return ()
_ -> StateT position >>= (throwError . mkParseError "WOParen" "not match pattern: " "" d336_347 ["wrd"])
let WOParen = t830_348
return ()
s <- StateT selection
d338_349 <- get
t832_350 <- StateT wrd
case t832_350 of
WCParen -> return ()
_ -> StateT position >>= (throwError . mkParseError "WCParen" "not match pattern: " "" d338_349 ["wrd"])
let WCParen = t832_350
return ()
lift (lift (return $ FromSelection s)),
do e <- StateT expressionHsSugar'
lift (lift (return $ FromSelection [e]))]
test108_112 = foldl1 mplus [do d340_351 <- get
t834_352 <- StateT wrd
case t834_352 of
WOBracket -> return ()
_ -> StateT position >>= (throwError . mkParseError "WOBracket" "not match pattern: " "" d340_351 ["wrd"])
let WOBracket = t834_352
return ()
h <- StateT hsExpLam
com <- optional141_206 (StateT comForErr)
d343_353 <- get
t837_354 <- StateT wrd
case t837_354 of
WCBracket -> return ()
_ -> StateT position >>= (throwError . mkParseError "WCBracket" "not match pattern: " "" d343_353 ["wrd"])
let WCBracket = t837_354
return ()
lift (lift (return (h, maybe "" id com)))]
hsExpLam109_113 = foldl1 mplus [do d344_355 <- get
t838_356 <- StateT hsw
case t838_356 of
(WOp "\\") -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WOp \"\\\\\")" "not match pattern: " "" d344_355 ["hsw"])
let (WOp "\\") = t838_356
return ()
ps <- StateT pats
d346_357 <- get
t840_358 <- StateT hsw
case t840_358 of
WRightArrow -> return ()
_ -> StateT position >>= (throwError . mkParseError "WRightArrow" "not match pattern: " "" d346_357 ["hsw"])
let WRightArrow = t840_358
return ()
e <- StateT hsExpTyp
lift (lift (return $ LamE ps e)),
do e <- StateT hsExpTyp
lift (lift (return e))]
hsExpTyp110_114 = foldl1 mplus [do eo <- StateT hsExpOp
d350_359 <- get
t844_360 <- StateT hsw
case t844_360 of
WTypeDef -> return ()
_ -> StateT position >>= (throwError . mkParseError "WTypeDef" "not match pattern: " "" d350_359 ["hsw"])
let WTypeDef = t844_360
return ()
t <- StateT hsTypeArr
lift (lift (return $ SigE eo t)),
do eo <- StateT hsExpOp
lift (lift (return eo))]
hsExpOp111_115 = 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))]
hsOp112_116 = foldl1 mplus [do d357_361 <- get
t851_362 <- StateT hsw
case t851_362 of
(WOp _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WOp op)" "not match pattern: " "" d357_361 ["hsw"])
let (WOp op) = t851_362
return ()
lift (lift (return $ VarE $ mkName op)),
do d358_363 <- get
t852_364 <- StateT hsw
case t852_364 of
(WOpCon _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WOpCon op)" "not match pattern: " "" d358_363 ["hsw"])
let (WOpCon op) = t852_364
return ()
lift (lift (return $ ConE $ mkName op)),
do d359_365 <- get
t853_366 <- StateT hsw
case t853_366 of
WBackQuote -> return ()
_ -> StateT position >>= (throwError . mkParseError "WBackQuote" "not match pattern: " "" d359_365 ["hsw"])
let WBackQuote = t853_366
return ()
d360_367 <- get
t854_368 <- StateT hsw
case t854_368 of
(WVar [] _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WVar [] v)" "not match pattern: " "" d360_367 ["hsw"])
let (WVar [] v) = t854_368
return ()
d361_369 <- get
t855_370 <- StateT hsw
case t855_370 of
WBackQuote -> return ()
_ -> StateT position >>= (throwError . mkParseError "WBackQuote" "not match pattern: " "" d361_369 ["hsw"])
let WBackQuote = t855_370
return ()
lift (lift (return $ VarE $ mkName v)),
do d362_371 <- get
t856_372 <- StateT hsw
case t856_372 of
WBackQuote -> return ()
_ -> StateT position >>= (throwError . mkParseError "WBackQuote" "not match pattern: " "" d362_371 ["hsw"])
let WBackQuote = t856_372
return ()
d363_373 <- get
t857_374 <- StateT hsw
case t857_374 of
(WType [] _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WType [] t)" "not match pattern: " "" d363_373 ["hsw"])
let (WType [] t) = t857_374
return ()
d364_375 <- get
t858_376 <- StateT hsw
case t858_376 of
WBackQuote -> return ()
_ -> StateT position >>= (throwError . mkParseError "WBackQuote" "not match pattern: " "" d364_375 ["hsw"])
let WBackQuote = t858_376
return ()
lift (lift (return $ ConE $ mkName t))]
hsExpLam'113_117 = foldl1 mplus [do d365_377 <- get
t859_378 <- StateT hsw
case t859_378 of
(WOp "\\") -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WOp \"\\\\\")" "not match pattern: " "" d365_377 ["hsw"])
let (WOp "\\") = t859_378
return ()
ps <- StateT pats
d367_379 <- get
t861_380 <- StateT hsw
case t861_380 of
WRightArrow -> return ()
_ -> StateT position >>= (throwError . mkParseError "WRightArrow" "not match pattern: " "" d367_379 ["hsw"])
let WRightArrow = t861_380
return ()
e <- StateT hsExpTyp'
lift (lift (return $ LamE ps e)),
do e <- StateT hsExpTyp'
lift (lift (return e))]
hsExpTyp'114_118 = foldl1 mplus [do eo <- StateT hsExpOp'
d371_381 <- get
t865_382 <- StateT hsw
case t865_382 of
WTypeDef -> return ()
_ -> StateT position >>= (throwError . mkParseError "WTypeDef" "not match pattern: " "" d371_381 ["hsw"])
let WTypeDef = t865_382
return ()
t <- StateT hsTypeArr
lift (lift (return $ SigE eo t)),
do eo <- StateT hsExpOp'
lift (lift (return eo))]
hsExpOp'115_119 = 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'116_120 = foldl1 mplus [do d378_383 <- get
t872_384 <- StateT hsw
case t872_384 of
(WOp _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WOp op)" "not match pattern: " "" d378_383 ["hsw"])
let (WOp op) = t872_384
return ()
b1357_385 <- lift (lift (return $ head op /= '>'))
unless b1357_385 (StateT position >>= (throwError . mkParseError "return $ head op /= '>'" "not match: " "" d378_383 ["hsw"]))
lift (lift (return $ VarE $ mkName op)),
do d379_386 <- get
t873_387 <- StateT hsw
case t873_387 of
(WOpCon _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WOpCon op)" "not match pattern: " "" d379_386 ["hsw"])
let (WOpCon op) = t873_387
return ()
lift (lift (return $ ConE $ mkName op)),
do d380_388 <- get
t874_389 <- StateT hsw
case t874_389 of
WBackQuote -> return ()
_ -> StateT position >>= (throwError . mkParseError "WBackQuote" "not match pattern: " "" d380_388 ["hsw"])
let WBackQuote = t874_389
return ()
v <- StateT var
d382_390 <- get
t876_391 <- StateT hsw
case t876_391 of
WBackQuote -> return ()
_ -> StateT position >>= (throwError . mkParseError "WBackQuote" "not match pattern: " "" d382_390 ["hsw"])
let WBackQuote = t876_391
return ()
lift (lift (return $ VarE $ mkName v)),
do d383_392 <- get
t877_393 <- StateT hsw
case t877_393 of
WBackQuote -> return ()
_ -> StateT position >>= (throwError . mkParseError "WBackQuote" "not match pattern: " "" d383_392 ["hsw"])
let WBackQuote = t877_393
return ()
t <- StateT typ
d385_394 <- get
t879_395 <- StateT hsw
case t879_395 of
WBackQuote -> return ()
_ -> StateT position >>= (throwError . mkParseError "WBackQuote" "not match pattern: " "" d385_394 ["hsw"])
let WBackQuote = t879_395
return ()
lift (lift (return $ ConE $ mkName t))]
hsExp117_121 = 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)))]
hsExp1118_122 = foldl1 mplus [do d389_396 <- get
t883_397 <- StateT hsw
case t883_397 of
WOParen -> return ()
_ -> StateT position >>= (throwError . mkParseError "WOParen" "not match pattern: " "" d389_396 ["hsw"])
let WOParen = t883_397
return ()
l <- optional141_206 (StateT hsExpOp)
o <- StateT hsOp
r <- optional141_206 (StateT hsExpOp)
d393_398 <- get
t887_399 <- StateT hsw
case t887_399 of
WCParen -> return ()
_ -> StateT position >>= (throwError . mkParseError "WCParen" "not match pattern: " "" d393_398 ["hsw"])
let WCParen = t887_399
return ()
lift (lift (return $ InfixE l o r)),
do d394_400 <- get
t888_401 <- StateT hsw
case t888_401 of
WOParen -> return ()
_ -> StateT position >>= (throwError . mkParseError "WOParen" "not match pattern: " "" d394_400 ["hsw"])
let WOParen = t888_401
return ()
et <- StateT hsExpTpl
d396_402 <- get
t890_403 <- StateT hsw
case t890_403 of
WCParen -> return ()
_ -> StateT position >>= (throwError . mkParseError "WCParen" "not match pattern: " "" d396_402 ["hsw"])
let WCParen = t890_403
return ()
lift (lift (return $ TupE et)),
do d397_404 <- get
t891_405 <- StateT hsw
case t891_405 of
WOBracket -> return ()
_ -> StateT position >>= (throwError . mkParseError "WOBracket" "not match pattern: " "" d397_404 ["hsw"])
let WOBracket = t891_405
return ()
et <- StateT hsExpTpl
d399_406 <- get
t893_407 <- StateT hsw
case t893_407 of
WCBracket -> return ()
_ -> StateT position >>= (throwError . mkParseError "WCBracket" "not match pattern: " "" d399_406 ["hsw"])
let WCBracket = t893_407
return ()
lift (lift (return $ ListE et)),
do d400_408 <- get
t894_409 <- StateT hsw
case t894_409 of
WOBracket -> return ()
_ -> StateT position >>= (throwError . mkParseError "WOBracket" "not match pattern: " "" d400_408 ["hsw"])
let WOBracket = t894_409
return ()
b <- StateT hsExpOp
d402_410 <- get
t896_411 <- StateT hsw
case t896_411 of
WDotDot -> return ()
_ -> StateT position >>= (throwError . mkParseError "WDotDot" "not match pattern: " "" d402_410 ["hsw"])
let WDotDot = t896_411
return ()
e <- StateT hsExpOp
d404_412 <- get
t898_413 <- StateT hsw
case t898_413 of
WCBracket -> return ()
_ -> StateT position >>= (throwError . mkParseError "WCBracket" "not match pattern: " "" d404_412 ["hsw"])
let WCBracket = t898_413
return ()
lift (lift (return $ ArithSeqE $ FromToR b e)),
do d405_414 <- get
t899_415 <- StateT hsw
case t899_415 of
(WVar [] _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WVar [] v)" "not match pattern: " "" d405_414 ["hsw"])
let (WVar [] v) = t899_415
return ()
lift (lift (return $ VarE $ mkName v)),
do d406_416 <- get
t900_417 <- StateT hsw
case t900_417 of
(WType [] _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WType [] t)" "not match pattern: " "" d406_416 ["hsw"])
let (WType [] t) = t900_417
return ()
lift (lift (return $ ConE $ mkName t)),
do d407_418 <- get
t901_419 <- StateT hsw
case t901_419 of
(WInteger _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WInteger i)" "not match pattern: " "" d407_418 ["hsw"])
let (WInteger i) = t901_419
return ()
lift (lift (return $ LitE $ integerL i)),
do d408_420 <- get
t902_421 <- StateT hsw
case t902_421 of
(WChar _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WChar c)" "not match pattern: " "" d408_420 ["hsw"])
let (WChar c) = t902_421
return ()
lift (lift (return $ LitE $ charL c)),
do d409_422 <- get
t903_423 <- StateT hsw
case t903_423 of
(WString _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WString s)" "not match pattern: " "" d409_422 ["hsw"])
let (WString s) = t903_423
return ()
lift (lift (return $ LitE $ stringL s)),
do d410_424 <- get
t904_425 <- StateT hsw
case t904_425 of
(WOp "-") -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WOp \"-\")" "not match pattern: " "" d410_424 ["hsw"])
let (WOp "-") = t904_425
return ()
e <- StateT hsExp1
lift (lift (return $ AppE (VarE $ mkName "negate") e)),
do d412_426 <- get
t906_427 <- StateT hsw
case t906_427 of
WIf -> return ()
_ -> StateT position >>= (throwError . mkParseError "WIf" "not match pattern: " "" d412_426 ["hsw"])
let WIf = t906_427
return ()
p <- StateT hsExpLam
d414_428 <- get
t908_429 <- StateT hsw
case t908_429 of
WThen -> return ()
_ -> StateT position >>= (throwError . mkParseError "WThen" "not match pattern: " "" d414_428 ["hsw"])
let WThen = t908_429
return ()
t <- StateT hsExpLam
d416_430 <- get
t910_431 <- StateT hsw
case t910_431 of
WElse -> return ()
_ -> StateT position >>= (throwError . mkParseError "WElse" "not match pattern: " "" d416_430 ["hsw"])
let WElse = t910_431
return ()
e <- StateT hsExpLam
lift (lift (return $ CondE p t e)),
do d418_432 <- get
t912_433 <- StateT hsw
case t912_433 of
WLet -> return ()
_ -> StateT position >>= (throwError . mkParseError "WLet" "not match pattern: " "" d418_432 ["hsw"])
let WLet = t912_433
return ()
d419_434 <- get
t913_435 <- StateT hsw
case t913_435 of
(WVar [] _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WVar [] v)" "not match pattern: " "" d419_434 ["hsw"])
let (WVar [] v) = t913_435
return ()
d420_436 <- get
t914_437 <- StateT hsw
case t914_437 of
(WOp "=") -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WOp \"=\")" "not match pattern: " "" d420_436 ["hsw"])
let (WOp "=") = t914_437
return ()
e <- StateT hsExpLam
d422_438 <- get
t916_439 <- StateT hsw
case t916_439 of
WIn -> return ()
_ -> StateT position >>= (throwError . mkParseError "WIn" "not match pattern: " "" d422_438 ["hsw"])
let WIn = t916_439
return ()
b <- StateT hsExpLam
lift (lift (return $ LetE [ValD (VarP $ mkName v) (NormalB e) []] b))]
hsExpTpl119_123 = foldl1 mplus [do e <- StateT hsExpLam
d425_440 <- get
t919_441 <- StateT hsw
case t919_441 of
WComma -> return ()
_ -> StateT position >>= (throwError . mkParseError "WComma" "not match pattern: " "" d425_440 ["hsw"])
let WComma = t919_441
return ()
et <- StateT hsExpTpl
lift (lift (return $ e : et)),
do e <- StateT hsExpLam
lift (lift (return [e])),
lift (lift (return []))]
hsTypeArr120_124 = foldl1 mplus [do l <- StateT hsType
d429_442 <- get
t923_443 <- StateT hsw
case t923_443 of
WRightArrow -> return ()
_ -> StateT position >>= (throwError . mkParseError "WRightArrow" "not match pattern: " "" d429_442 ["hsw"])
let WRightArrow = t923_443
return ()
r <- StateT hsTypeArr
lift (lift (return $ AppT (AppT ArrowT $ l id) r)),
do t <- StateT hsType
lift (lift (return $ t id))]
hsType121_125 = 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)))]
hsType1122_126 = foldl1 mplus [do d435_444 <- get
t929_445 <- StateT hsw
case t929_445 of
WOBracket -> return ()
_ -> StateT position >>= (throwError . mkParseError "WOBracket" "not match pattern: " "" d435_444 ["hsw"])
let WOBracket = t929_445
return ()
d436_446 <- get
t930_447 <- StateT hsw
case t930_447 of
WCBracket -> return ()
_ -> StateT position >>= (throwError . mkParseError "WCBracket" "not match pattern: " "" d436_446 ["hsw"])
let WCBracket = t930_447
return ()
lift (lift (return ListT)),
do d437_448 <- get
t931_449 <- StateT hsw
case t931_449 of
WOBracket -> return ()
_ -> StateT position >>= (throwError . mkParseError "WOBracket" "not match pattern: " "" d437_448 ["hsw"])
let WOBracket = t931_449
return ()
t <- StateT hsTypeArr
d439_450 <- get
t933_451 <- StateT hsw
case t933_451 of
WCBracket -> return ()
_ -> StateT position >>= (throwError . mkParseError "WCBracket" "not match pattern: " "" d439_450 ["hsw"])
let WCBracket = t933_451
return ()
lift (lift (return $ ListT `AppT` t)),
do d440_452 <- get
t934_453 <- StateT hsw
case t934_453 of
WOParen -> return ()
_ -> StateT position >>= (throwError . mkParseError "WOParen" "not match pattern: " "" d440_452 ["hsw"])
let WOParen = t934_453
return ()
tt <- StateT hsTypeTpl
d442_454 <- get
t936_455 <- StateT hsw
case t936_455 of
WCParen -> return ()
_ -> StateT position >>= (throwError . mkParseError "WCParen" "not match pattern: " "" d442_454 ["hsw"])
let WCParen = t936_455
return ()
lift (lift (return $ foldl AppT (TupleT $ length tt) tt)),
do d443_456 <- get
t937_457 <- StateT hsw
case t937_457 of
(WType [] _) -> return ()
_ -> StateT position >>= (throwError . mkParseError "(WType [] t)" "not match pattern: " "" d443_456 ["hsw"])
let (WType [] t) = t937_457
return ()
lift (lift (return $ ConT $ mkName t)),
do d444_458 <- get
t938_459 <- StateT hsw
case t938_459 of
WOParen -> return ()
_ -> StateT position >>= (throwError . mkParseError "WOParen" "not match pattern: " "" d444_458 ["hsw"])
let WOParen = t938_459
return ()
d445_460 <- get
t939_461 <- StateT hsw
case t939_461 of
WRightArrow -> return ()
_ -> StateT position >>= (throwError . mkParseError "WRightArrow" "not match pattern: " "" d445_460 ["hsw"])
let WRightArrow = t939_461
return ()
d446_462 <- get
t940_463 <- StateT hsw
case t940_463 of
WCParen -> return ()
_ -> StateT position >>= (throwError . mkParseError "WCParen" "not match pattern: " "" d446_462 ["hsw"])
let WCParen = t940_463
return ()
lift (lift (return ArrowT))]
hsTypeTpl123_127 = foldl1 mplus [do t <- StateT hsTypeArr
d448_464 <- get
t942_465 <- StateT hsw
case t942_465 of
WComma -> return ()
_ -> StateT position >>= (throwError . mkParseError "WComma" "not match pattern: " "" d448_464 ["hsw"])
let WComma = t942_465
return ()
tt <- StateT hsTypeTpl
lift (lift (return $ t : tt)),
do t <- StateT hsTypeArr
lift (lift (return [t])),
lift (lift (return []))]
wrd124_128 = foldl1 mplus [do w <- StateT word
_ <- list142_147 (StateT space)
return ()
lift (lift (return w)),
do _ <- StateT semiColon
return ()
_ <- list142_147 (StateT space')
return ()
lift (lift (return WSemiColon))]
hsw125_129 = foldl1 mplus [do w <- StateT hsWord
_ <- list142_147 (StateT space)
return ()
lift (lift (return w))]
word126_130 = foldl1 mplus [do v <- list1143_466 (foldl1 mplus [do d458_467 <- get
t952_468 <- StateT char
let c1616_145 = t952_468
b1437_469 <- return (((||) <$> isAlphaNum <*> (`elem` "_'")) c1616_145)
unless b1437_469 (StateT position >>= (throwError . mkParseError "((||) <$> isAlphaNum <*> (`elem` \"_'\")) c1616_0" "not match: " "" d458_467 ["char"]))
return c1616_145])
lift (lift (return $ WSymbol v)),
do d459_470 <- get
t953_471 <- StateT char
case t953_471 of
'!' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'!'" "not match pattern: " "" d459_470 ["char"])
let '!' = t953_471
return ()
lift (lift (return WBang)),
do d460_472 <- get
t954_473 <- StateT char
case t954_473 of
'&' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'&'" "not match pattern: " "" d460_472 ["char"])
let '&' = t954_473
return ()
lift (lift (return WAmp)),
do d461_474 <- get
t955_475 <- StateT char
case t955_475 of
'*' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'*'" "not match pattern: " "" d461_474 ["char"])
let '*' = t955_475
return ()
lift (lift (return WAsterisk)),
do d462_476 <- get
t956_477 <- StateT char
case t956_477 of
'+' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'+'" "not match pattern: " "" d462_476 ["char"])
let '+' = t956_477
return ()
lift (lift (return WPlus)),
do d463_478 <- get
t957_479 <- StateT char
case t957_479 of
'?' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'?'" "not match pattern: " "" d463_478 ["char"])
let '?' = t957_479
return ()
lift (lift (return WQuestion)),
do d464_480 <- get
t958_481 <- StateT char
case t958_481 of
'=' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'='" "not match pattern: " "" d464_480 ["char"])
let '=' = t958_481
return ()
lift (lift (return WEqual)),
do d465_482 <- get
t959_483 <- StateT char
case t959_483 of
'/' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'/'" "not match pattern: " "" d465_482 ["char"])
let '/' = t959_483
return ()
lift (lift (return WSlash)),
do d466_484 <- get
t960_485 <- StateT char
case t960_485 of
':' -> return ()
_ -> StateT position >>= (throwError . mkParseError "':'" "not match pattern: " "" d466_484 ["char"])
let ':' = t960_485
return ()
lift (lift (return WColon)),
do d467_486 <- get
t961_487 <- StateT char
case t961_487 of
'<' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'<'" "not match pattern: " "" d467_486 ["char"])
let '<' = t961_487
return ()
lift (lift (return WLT)),
do d468_488 <- get
t962_489 <- StateT char
case t962_489 of
'>' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'>'" "not match pattern: " "" d468_488 ["char"])
let '>' = t962_489
return ()
lift (lift (return WGT)),
do b <- StateT bras
lift (lift (return b))]
hsWord127_131 = foldl1 mplus [do d470_490 <- get
t964_491 <- StateT char
case t964_491 of
'm' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'m'" "not match pattern: " "" d470_490 ["char"])
let 'm' = t964_491
return ()
d471_492 <- get
t965_493 <- StateT char
case t965_493 of
'o' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'o'" "not match pattern: " "" d471_492 ["char"])
let 'o' = t965_493
return ()
d472_494 <- get
t966_495 <- StateT char
case t966_495 of
'd' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'d'" "not match pattern: " "" d472_494 ["char"])
let 'd' = t966_495
return ()
d473_496 <- get
t967_497 <- StateT char
case t967_497 of
'u' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'u'" "not match pattern: " "" d473_496 ["char"])
let 'u' = t967_497
return ()
d474_498 <- get
t968_499 <- StateT char
case t968_499 of
'l' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'l'" "not match pattern: " "" d474_498 ["char"])
let 'l' = t968_499
return ()
d475_500 <- get
t969_501 <- StateT char
case t969_501 of
'e' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'e'" "not match pattern: " "" d475_500 ["char"])
let 'e' = t969_501
return ()
lift (lift (return $ WModule)),
do d476_502 <- get
t970_503 <- StateT char
case t970_503 of
'w' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'w'" "not match pattern: " "" d476_502 ["char"])
let 'w' = t970_503
return ()
d477_504 <- get
t971_505 <- StateT char
case t971_505 of
'h' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'h'" "not match pattern: " "" d477_504 ["char"])
let 'h' = t971_505
return ()
d478_506 <- get
t972_507 <- StateT char
case t972_507 of
'e' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'e'" "not match pattern: " "" d478_506 ["char"])
let 'e' = t972_507
return ()
d479_508 <- get
t973_509 <- StateT char
case t973_509 of
'r' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'r'" "not match pattern: " "" d479_508 ["char"])
let 'r' = t973_509
return ()
d480_510 <- get
t974_511 <- StateT char
case t974_511 of
'e' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'e'" "not match pattern: " "" d480_510 ["char"])
let 'e' = t974_511
return ()
lift (lift (return $ WWhere)),
do d481_512 <- get
t975_513 <- StateT char
case t975_513 of
'i' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'i'" "not match pattern: " "" d481_512 ["char"])
let 'i' = t975_513
return ()
d482_514 <- get
t976_515 <- StateT char
case t976_515 of
'm' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'m'" "not match pattern: " "" d482_514 ["char"])
let 'm' = t976_515
return ()
d483_516 <- get
t977_517 <- StateT char
case t977_517 of
'p' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'p'" "not match pattern: " "" d483_516 ["char"])
let 'p' = t977_517
return ()
d484_518 <- get
t978_519 <- StateT char
case t978_519 of
'o' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'o'" "not match pattern: " "" d484_518 ["char"])
let 'o' = t978_519
return ()
d485_520 <- get
t979_521 <- StateT char
case t979_521 of
'r' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'r'" "not match pattern: " "" d485_520 ["char"])
let 'r' = t979_521
return ()
d486_522 <- get
t980_523 <- StateT char
case t980_523 of
't' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'t'" "not match pattern: " "" d486_522 ["char"])
let 't' = t980_523
return ()
lift (lift (return $ WImport)),
do d487_524 <- get
t981_525 <- StateT char
case t981_525 of
'i' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'i'" "not match pattern: " "" d487_524 ["char"])
let 'i' = t981_525
return ()
d488_526 <- get
t982_527 <- StateT char
case t982_527 of
'f' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'f'" "not match pattern: " "" d488_526 ["char"])
let 'f' = t982_527
return ()
lift (lift (return $ WIf)),
do d489_528 <- get
t983_529 <- StateT char
case t983_529 of
't' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'t'" "not match pattern: " "" d489_528 ["char"])
let 't' = t983_529
return ()
d490_530 <- get
t984_531 <- StateT char
case t984_531 of
'h' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'h'" "not match pattern: " "" d490_530 ["char"])
let 'h' = t984_531
return ()
d491_532 <- get
t985_533 <- StateT char
case t985_533 of
'e' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'e'" "not match pattern: " "" d491_532 ["char"])
let 'e' = t985_533
return ()
d492_534 <- get
t986_535 <- StateT char
case t986_535 of
'n' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'n'" "not match pattern: " "" d492_534 ["char"])
let 'n' = t986_535
return ()
lift (lift (return $ WThen)),
do d493_536 <- get
t987_537 <- StateT char
case t987_537 of
'e' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'e'" "not match pattern: " "" d493_536 ["char"])
let 'e' = t987_537
return ()
d494_538 <- get
t988_539 <- StateT char
case t988_539 of
'l' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'l'" "not match pattern: " "" d494_538 ["char"])
let 'l' = t988_539
return ()
d495_540 <- get
t989_541 <- StateT char
case t989_541 of
's' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'s'" "not match pattern: " "" d495_540 ["char"])
let 's' = t989_541
return ()
d496_542 <- get
t990_543 <- StateT char
case t990_543 of
'e' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'e'" "not match pattern: " "" d496_542 ["char"])
let 'e' = t990_543
return ()
lift (lift (return $ WElse)),
do d497_544 <- get
t991_545 <- StateT char
case t991_545 of
'l' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'l'" "not match pattern: " "" d497_544 ["char"])
let 'l' = t991_545
return ()
d498_546 <- get
t992_547 <- StateT char
case t992_547 of
'e' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'e'" "not match pattern: " "" d498_546 ["char"])
let 'e' = t992_547
return ()
d499_548 <- get
t993_549 <- StateT char
case t993_549 of
't' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'t'" "not match pattern: " "" d499_548 ["char"])
let 't' = t993_549
return ()
lift (lift (return $ WLet)),
do d500_550 <- get
t994_551 <- StateT char
case t994_551 of
'i' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'i'" "not match pattern: " "" d500_550 ["char"])
let 'i' = t994_551
return ()
d501_552 <- get
t995_553 <- StateT char
case t995_553 of
'n' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'n'" "not match pattern: " "" d501_552 ["char"])
let 'n' = t995_553
return ()
lift (lift (return $ WIn)),
do d502_554 <- get
t996_555 <- StateT char
case t996_555 of
'[' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'['" "not match pattern: " "" d502_554 ["char"])
let '[' = t996_555
return ()
v <- StateT var
d504_556 <- get
t998_557 <- StateT char
case t998_557 of
'|' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'|'" "not match pattern: " "" d504_556 ["char"])
let '|' = t998_557
return ()
lift (lift (return $ WOQuasiQuote v)),
do d505_558 <- get
t999_559 <- StateT char
case t999_559 of
'|' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'|'" "not match pattern: " "" d505_558 ["char"])
let '|' = t999_559
return ()
d506_560 <- get
t1000_561 <- StateT char
case t1000_561 of
']' -> return ()
_ -> StateT position >>= (throwError . mkParseError "']'" "not match pattern: " "" d506_560 ["char"])
let ']' = t1000_561
return ()
lift (lift (return WCQuasiQuote)),
do d507_562 <- get
t1001_563 <- StateT char
case t1001_563 of
':' -> return ()
_ -> StateT position >>= (throwError . mkParseError "':'" "not match pattern: " "" d507_562 ["char"])
let ':' = t1001_563
return ()
d508_564 <- get
t1002_565 <- StateT char
case t1002_565 of
':' -> return ()
_ -> StateT position >>= (throwError . mkParseError "':'" "not match pattern: " "" d508_564 ["char"])
let ':' = t1002_565
return ()
lift (lift (return WTypeDef)),
do d509_566 <- get
t1003_567 <- StateT char
case t1003_567 of
'-' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'-'" "not match pattern: " "" d509_566 ["char"])
let '-' = t1003_567
return ()
d510_568 <- get
t1004_569 <- StateT char
case t1004_569 of
'>' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'>'" "not match pattern: " "" d510_568 ["char"])
let '>' = t1004_569
return ()
lift (lift (return WRightArrow)),
do d511_570 <- get
t1005_571 <- StateT char
case t1005_571 of
'.' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'.'" "not match pattern: " "" d511_570 ["char"])
let '.' = t1005_571
return ()
d512_572 <- get
t1006_573 <- StateT char
case t1006_573 of
'.' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'.'" "not match pattern: " "" d512_572 ["char"])
let '.' = t1006_573
return ()
lift (lift (return WDotDot)),
do d513_574 <- get
t1007_575 <- StateT char
case t1007_575 of
'{' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'{'" "not match pattern: " "" d513_574 ["char"])
let '{' = t1007_575
return ()
d514_576 <- get
t1008_577 <- StateT char
case t1008_577 of
'-' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'-'" "not match pattern: " "" d514_576 ["char"])
let '-' = t1008_577
return ()
d515_578 <- get
t1009_579 <- StateT char
case t1009_579 of
'#' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'#'" "not match pattern: " "" d515_578 ["char"])
let '#' = t1009_579
return ()
lift (lift (return WOComment)),
do d516_580 <- get
t1010_581 <- StateT char
case t1010_581 of
'#' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'#'" "not match pattern: " "" d516_580 ["char"])
let '#' = t1010_581
return ()
d517_582 <- get
t1011_583 <- StateT char
case t1011_583 of
'-' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'-'" "not match pattern: " "" d517_582 ["char"])
let '-' = t1011_583
return ()
d518_584 <- get
t1012_585 <- StateT char
case t1012_585 of
'}' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'}'" "not match pattern: " "" d518_584 ["char"])
let '}' = t1012_585
return ()
lift (lift (return WCComment)),
do m <- list142_147 (foldl1 mplus [do t <- StateT typ
d521_586 <- get
t1015_587 <- StateT char
case t1015_587 of
'.' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'.'" "not match pattern: " "" d521_586 ["char"])
let '.' = t1015_587
return ()
lift (lift (return t))])
t1 <- StateT typ
lift (lift (return $ WType m t1)),
do m <- list142_147 (foldl1 mplus [do t <- StateT typ
d525_588 <- get
t1019_589 <- StateT char
case t1019_589 of
'.' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'.'" "not match pattern: " "" d525_588 ["char"])
let '.' = t1019_589
return ()
lift (lift (return t))])
v1 <- StateT var
lift (lift (return $ WVar m v1)),
do d527_590 <- get
t1021_591 <- StateT char
case t1021_591 of
':' -> return ()
_ -> StateT position >>= (throwError . mkParseError "':'" "not match pattern: " "" d527_590 ["char"])
let ':' = t1021_591
return ()
w <- list142_147 (foldl1 mplus [do d529_592 <- get
t1023_593 <- StateT char
let c1617_594 = t1023_593
b1508_595 <- return ((`elem` opChars) c1617_594)
unless b1508_595 (StateT position >>= (throwError . mkParseError "(`elem` opChars) c1617_0" "not match: " "" d529_592 ["char"]))
return c1617_594])
lift (lift (return $ WOpCon $ ':' : w)),
do w <- list1143_466 (foldl1 mplus [do d531_596 <- get
t1025_597 <- StateT char
let c1618_598 = t1025_597
b1510_599 <- return ((`elem` opChars) c1618_598)
unless b1510_599 (StateT position >>= (throwError . mkParseError "(`elem` opChars) c1618_0" "not match: " "" d531_596 ["char"]))
return c1618_598])
lift (lift (return $ WOp w)),
do d532_600 <- get
t1026_601 <- StateT char
case t1026_601 of
'\'' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'\\''" "not match pattern: " "" d532_600 ["char"])
let '\'' = t1026_601
return ()
c <- foldl1 mplus [do d534_602 <- get
t1028_603 <- StateT char
let c1619_604 = t1028_603
b1513_605 <- return ((`notElem` "\\'") c1619_604)
unless b1513_605 (StateT position >>= (throwError . mkParseError "(`notElem` \"\\\\'\") c1619_0" "not match: " "" d534_602 ["char"]))
return c1619_604]
d535_606 <- get
t1029_607 <- StateT char
case t1029_607 of
'\'' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'\\''" "not match pattern: " "" d535_606 ["char"])
let '\'' = t1029_607
return ()
lift (lift (return $ WChar c)),
do d536_608 <- get
t1030_609 <- StateT char
case t1030_609 of
'\'' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'\\''" "not match pattern: " "" d536_608 ["char"])
let '\'' = t1030_609
return ()
d537_610 <- get
t1031_611 <- StateT char
case t1031_611 of
'\\' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'\\\\'" "not match pattern: " "" d537_610 ["char"])
let '\\' = t1031_611
return ()
c <- StateT escChar
d539_612 <- get
t1033_613 <- StateT char
case t1033_613 of
'\'' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'\\''" "not match pattern: " "" d539_612 ["char"])
let '\'' = t1033_613
return ()
lift (lift (return $ WChar c)),
do d540_614 <- get
t1034_615 <- StateT char
case t1034_615 of
'"' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'\"'" "not match pattern: " "" d540_614 ["char"])
let '"' = t1034_615
return ()
s <- StateT strLit
d542_616 <- get
t1036_617 <- StateT char
case t1036_617 of
'"' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'\"'" "not match pattern: " "" d542_616 ["char"])
let '"' = t1036_617
return ()
lift (lift (return $ WString s)),
do d <- list1143_466 (foldl1 mplus [do d544_618 <- get
t1038_619 <- StateT char
let c1620_620 = t1038_619
b1523_621 <- return (isDigit c1620_620)
unless b1523_621 (StateT position >>= (throwError . mkParseError "isDigit c1620_0" "not match: " "" d544_618 ["char"]))
return c1620_620])
lift (lift (return $ WInteger $ read d)),
do b <- StateT bras
lift (lift (return b)),
do d546_622 <- get
t1040_623 <- StateT char
case t1040_623 of
',' -> return ()
_ -> StateT position >>= (throwError . mkParseError "','" "not match pattern: " "" d546_622 ["char"])
let ',' = t1040_623
return ()
lift (lift (return WComma)),
do d547_624 <- get
t1041_625 <- StateT char
case t1041_625 of
'`' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'`'" "not match pattern: " "" d547_624 ["char"])
let '`' = t1041_625
return ()
lift (lift (return WBackQuote))]
bras128_132 = foldl1 mplus [do d548_626 <- get
t1042_627 <- StateT char
case t1042_627 of
'[' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'['" "not match pattern: " "" d548_626 ["char"])
let '[' = t1042_627
return ()
lift (lift (return WOBracket)),
do d549_628 <- get
t1043_629 <- StateT char
case t1043_629 of
']' -> return ()
_ -> StateT position >>= (throwError . mkParseError "']'" "not match pattern: " "" d549_628 ["char"])
let ']' = t1043_629
return ()
lift (lift (return WCBracket)),
do d550_630 <- get
t1044_631 <- StateT char
case t1044_631 of
'{' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'{'" "not match pattern: " "" d550_630 ["char"])
let '{' = t1044_631
return ()
lift (lift (return WOBrace)),
do d551_632 <- get
t1045_633 <- StateT char
case t1045_633 of
'}' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'}'" "not match pattern: " "" d551_632 ["char"])
let '}' = t1045_633
return ()
lift (lift (return WCBrace)),
do d552_634 <- get
t1046_635 <- StateT char
case t1046_635 of
'(' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'('" "not match pattern: " "" d552_634 ["char"])
let '(' = t1046_635
return ()
lift (lift (return WOParen)),
do d553_636 <- get
t1047_637 <- StateT char
case t1047_637 of
')' -> return ()
_ -> StateT position >>= (throwError . mkParseError "')'" "not match pattern: " "" d553_636 ["char"])
let ')' = t1047_637
return ()
lift (lift (return WCParen))]
typ129_133 = foldl1 mplus [do u <- foldl1 mplus [do d555_638 <- get
t1049_639 <- StateT char
let c1621_640 = t1049_639
b1534_641 <- return (isUpper c1621_640)
unless b1534_641 (StateT position >>= (throwError . mkParseError "isUpper c1621_0" "not match: " "" d555_638 ["char"]))
return c1621_640]
cs <- list142_147 (foldl1 mplus [do d557_642 <- get
t1051_643 <- StateT char
let c1622_644 = t1051_643
b1536_645 <- return (((||) <$> isAlphaNum <*> (`elem` "_'")) c1622_644)
unless b1536_645 (StateT position >>= (throwError . mkParseError "((||) <$> isAlphaNum <*> (`elem` \"_'\")) c1622_0" "not match: " "" d557_642 ["char"]))
return c1622_644])
lift (lift (return $ u : cs))]
var130_134 = foldl1 mplus [do l <- foldl1 mplus [do d559_646 <- get
t1053_647 <- StateT char
let c1623_648 = t1053_647
b1538_649 <- return (((||) <$> isLower <*> (== '_')) c1623_648)
unless b1538_649 (StateT position >>= (throwError . mkParseError "((||) <$> isLower <*> (== '_')) c1623_0" "not match: " "" d559_646 ["char"]))
return c1623_648]
cs <- list142_147 (foldl1 mplus [do d561_650 <- get
t1055_651 <- StateT char
let c1624_652 = t1055_651
b1540_653 <- return (((||) <$> isAlphaNum <*> (`elem` "_'")) c1624_652)
unless b1540_653 (StateT position >>= (throwError . mkParseError "((||) <$> isAlphaNum <*> (`elem` \"_'\")) c1624_0" "not match: " "" d561_650 ["char"]))
return c1624_652])
lift (lift (return $ l : cs))]
strLit131_135 = foldl1 mplus [do c0 <- foldl1 mplus [do d563_654 <- get
t1057_655 <- StateT char
case t1057_655 of
'\\' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'\\\\'" "not match pattern: " "" d563_654 ["char"])
let '\\' = t1057_655
return ()
c <- StateT escChar
lift (lift (return c)),
do d565_656 <- get
t1059_657 <- StateT char
let c1625_658 = t1059_657
b1544_659 <- return ((`notElem` "\"\\") c1625_658)
unless b1544_659 (StateT position >>= (throwError . mkParseError "(`notElem` \"\\\"\\\\\") c1625_0" "not match: " "" d565_656 ["char"]))
return c1625_658]
s <- StateT strLit
lift (lift (return $ c0 : s)),
lift (lift (return ""))]
escChar132_136 = foldl1 mplus [do d567_660 <- get
t1061_661 <- StateT char
case t1061_661 of
'\\' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'\\\\'" "not match pattern: " "" d567_660 ["char"])
let '\\' = t1061_661
return ()
lift (lift (return '\\')),
do d568_662 <- get
t1062_663 <- StateT char
case t1062_663 of
'\'' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'\\''" "not match pattern: " "" d568_662 ["char"])
let '\'' = t1062_663
return ()
lift (lift (return '\'')),
do d569_664 <- get
t1063_665 <- StateT char
case t1063_665 of
'"' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'\"'" "not match pattern: " "" d569_664 ["char"])
let '"' = t1063_665
return ()
lift (lift (return '"')),
do d570_666 <- get
t1064_667 <- StateT char
case t1064_667 of
'n' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'n'" "not match pattern: " "" d570_666 ["char"])
let 'n' = t1064_667
return ()
lift (lift (return '\n')),
do d571_668 <- get
t1065_669 <- StateT char
case t1065_669 of
'r' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'r'" "not match pattern: " "" d571_668 ["char"])
let 'r' = t1065_669
return ()
lift (lift (return '\r')),
do d572_670 <- get
t1066_671 <- StateT char
case t1066_671 of
't' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'t'" "not match pattern: " "" d572_670 ["char"])
let 't' = t1066_671
return ()
lift (lift (return '\t')),
do d573_672 <- get
t1067_673 <- StateT char
case t1067_673 of
'x' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'x'" "not match pattern: " "" d573_672 ["char"])
let 'x' = t1067_673
return ()
ds <- list1143_466 (foldl1 mplus [do d575_674 <- get
t1069_675 <- StateT char
let c1626_676 = t1069_675
b1554_677 <- return (isHexDigit c1626_676)
unless b1554_677 (StateT position >>= (throwError . mkParseError "isHexDigit c1626_0" "not match: " "" d575_674 ["char"]))
return c1626_676])
lift (lift (return $ chr $ fst $ head $ readHex ds))]
space133_137 = foldl1 mplus [do _ <- foldl1 mplus [do d577_678 <- get
t1071_679 <- StateT char
let c1627_680 = t1071_679
b1556_681 <- return ((`elem` " \t") c1627_680)
unless b1556_681 (StateT position >>= (throwError . mkParseError "(`elem` \" \\t\") c1627_0" "not match: " "" d577_678 ["char"]))
return c1627_680]
return ()
return (),
do _ <- StateT notSemiColon
return ()
return (),
do _ <- StateT comment
return ()
return (),
do _ <- StateT lineComment
return ()
return ()]
space'134_138 = foldl1 mplus [do _ <- foldl1 mplus [do d582_682 <- get
t1076_683 <- StateT char
let c1628_684 = t1076_683
b1561_685 <- return ((`elem` " \t") c1628_684)
unless b1561_685 (StateT position >>= (throwError . mkParseError "(`elem` \" \\t\") c1628_0" "not match: " "" d582_682 ["char"]))
return c1628_684]
return ()
return (),
do _ <- list1143_466 (foldl1 mplus [do d584_686 <- get
t1078_687 <- StateT char
case t1078_687 of
'\n' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'\\n'" "not match pattern: " "" d584_686 ["char"])
let '\n' = t1078_687
return ()
lift (lift (return ()))])
return ()
return (),
do _ <- StateT comment
return ()
return (),
do _ <- StateT lineComment
return ()
return ()]
lineComment135_139 = foldl1 mplus [do d587_688 <- get
t1081_689 <- StateT char
case t1081_689 of
'-' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'-'" "not match pattern: " "" d587_688 ["char"])
let '-' = t1081_689
return ()
d588_690 <- get
t1082_691 <- StateT char
case t1082_691 of
'-' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'-'" "not match pattern: " "" d588_690 ["char"])
let '-' = t1082_691
return ()
_ <- list142_147 (foldl1 mplus [do d590_692 <- get
t1084_693 <- StateT char
let c1629_694 = t1084_693
b1569_695 <- return ((/= '\n') c1629_694)
unless b1569_695 (StateT position >>= (throwError . mkParseError "(/= '\\n') c1629_0" "not match: " "" d590_692 ["char"]))
return c1629_694])
return ()
d592_696 <- get
_ <- do d591_697 <- get
t1085_698 <- StateT char
case t1085_698 of
'\n' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'\\n'" "not match pattern: " "" d591_697 ["char"])
let '\n' = t1085_698
return ()
put d592_696
return ()]
comment136_140 = foldl1 mplus [do d593_699 <- get
t1086_700 <- StateT char
case t1086_700 of
'{' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'{'" "not match pattern: " "" d593_699 ["char"])
let '{' = t1086_700
return ()
d594_701 <- get
t1087_702 <- StateT char
case t1087_702 of
'-' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'-'" "not match pattern: " "" d594_701 ["char"])
let '-' = t1087_702
return ()
d596_703 <- get
do err1609_704 <- ((do d595_705 <- get
t1088_706 <- StateT char
case t1088_706 of
'#' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'#'" "not match pattern: " "" d595_705 ["char"])
let '#' = t1088_706
return ()) >> return False) `catchError` const (return True)
unless err1609_704 (StateT position >>= (throwError . mkParseError "!'#':" "not match: " "" d596_703 ["char"]))
put d596_703
_ <- StateT comments
return ()
d598_707 <- get
t1090_708 <- StateT char
case t1090_708 of
'-' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'-'" "not match pattern: " "" d598_707 ["char"])
let '-' = t1090_708
return ()
d599_709 <- get
t1091_710 <- StateT char
case t1091_710 of
'}' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'}'" "not match pattern: " "" d599_709 ["char"])
let '}' = t1091_710
return ()
return ()]
comments137_141 = foldl1 mplus [do _ <- StateT comStr
return ()
_ <- StateT comment
return ()
_ <- StateT comments
return ()
return (),
do _ <- StateT comStr
return ()
return ()]
comStr138_142 = foldl1 mplus [do d605_711 <- get
do err1610_712 <- ((do _ <- StateT comment
return ()) >> return False) `catchError` const (return True)
unless err1610_712 (StateT position >>= (throwError . mkParseError "!_:comment" "not match: " "" d605_711 ["comment"]))
put d605_711
d609_713 <- get
do err1611_714 <- ((do _ <- foldl1 mplus [do d607_715 <- get
t1098_716 <- StateT char
case t1098_716 of
'-' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'-'" "not match pattern: " "" d607_715 ["char"])
let '-' = t1098_716
return ()
d608_717 <- get
t1099_718 <- StateT char
case t1099_718 of
'}' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'}'" "not match pattern: " "" d608_717 ["char"])
let '}' = t1099_718
return ()
return ()]
return ()) >> return False) `catchError` const (return True)
unless err1611_714 (StateT position >>= (throwError . mkParseError "!_:('-': '}': {})" "not match: " "" d609_713 ["char"]))
put d609_713
_ <- StateT char
return ()
_ <- StateT comStr
return ()
return (),
return ()]
semiColon139_143 = foldl1 mplus [do d612_719 <- get
t1102_720 <- StateT char
case t1102_720 of
';' -> return ()
_ -> StateT position >>= (throwError . mkParseError "';'" "not match pattern: " "" d612_719 ["char"])
let ';' = t1102_720
return ()
return (),
do _ <- list1143_466 (foldl1 mplus [do d614_721 <- get
t1104_722 <- StateT char
case t1104_722 of
'\n' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'\\n'" "not match pattern: " "" d614_721 ["char"])
let '\n' = t1104_722
return ()
lift (lift (return ()))])
return ()
_ <- list142_147 (foldl1 mplus [do d616_723 <- get
t1106_724 <- StateT char
case t1106_724 of
'\t' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'\\t'" "not match pattern: " "" d616_723 ["char"])
let '\t' = t1106_724
return ()
return (),
do d617_725 <- get
t1107_726 <- StateT char
case t1107_726 of
' ' -> return ()
_ -> StateT position >>= (throwError . mkParseError "' '" "not match pattern: " "" d617_725 ["char"])
let ' ' = t1107_726
return ()
return ()])
return ()
d618_727 <- get
t1108_728 <- StateT position
let (!(ListPos (CharPos (_, x)))) = t1108_728
b1593_729 <- lift (lift (maybe False (x <=) <$> get))
unless b1593_729 (StateT position >>= (throwError . mkParseError "maybe False (x <=) <$> get" "not match: " "" d618_727 ["position"]))
d620_730 <- get
do err1612_731 <- ((do _ <- StateT lineComment
return ()) >> return False) `catchError` const (return True)
unless err1612_731 (StateT position >>= (throwError . mkParseError "!_:lineComment" "not match: " "" d620_730 ["lineComment"]))
put d620_730
d622_732 <- get
do err1613_733 <- ((do _ <- StateT comment
return ()) >> return False) `catchError` const (return True)
unless err1613_733 (StateT position >>= (throwError . mkParseError "!_:comment" "not match: " "" d622_732 ["comment"]))
put d622_732
d624_734 <- get
do err1614_735 <- ((do d623_736 <- get
t1111_737 <- StateT char
case t1111_737 of
';' -> return ()
_ -> StateT position >>= (throwError . mkParseError "';'" "not match pattern: " "" d623_736 ["char"])
let ';' = t1111_737
return ()) >> return False) `catchError` const (return True)
unless err1614_735 (StateT position >>= (throwError . mkParseError "!';':" "not match: " "" d624_734 ["char"]))
put d624_734
return (),
do d626_738 <- get
do err1615_739 <- ((do d625_740 <- get
_ <- StateT char
b1597_741 <- lift (lift (return True))
unless b1597_741 (StateT position >>= (throwError . mkParseError "return True" "not match: " "" d625_740 ["char"]))) >> return False) `catchError` const (return True)
unless err1615_739 (StateT position >>= (throwError . mkParseError "!_:[return True]" "not match: " "" d626_738 ["char"]))
put d626_738
return ()]
notSemiColon140_144 = foldl1 mplus [do _ <- list1143_466 (foldl1 mplus [do d628_742 <- get
t1114_743 <- StateT char
case t1114_743 of
'\n' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'\\n'" "not match pattern: " "" d628_742 ["char"])
let '\n' = t1114_743
return ()
lift (lift (return ()))])
return ()
_ <- list142_147 (foldl1 mplus [do d630_744 <- get
t1116_745 <- StateT char
case t1116_745 of
'\t' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'\\t'" "not match pattern: " "" d630_744 ["char"])
let '\t' = t1116_745
return ()
return (),
do d631_746 <- get
t1117_747 <- StateT char
case t1117_747 of
' ' -> return ()
_ -> StateT position >>= (throwError . mkParseError "' '" "not match pattern: " "" d631_746 ["char"])
let ' ' = t1117_747
return ()
return ()])
return ()
d632_748 <- get
t1118_749 <- StateT position
let (!(ListPos (CharPos (_, x)))) = t1118_749
b1603_750 <- lift (lift (maybe True (x >) <$> get))
unless b1603_750 (StateT position >>= (throwError . mkParseError "maybe True (x >) <$> get" "not match: " "" d632_748 ["position"]))
return (),
do _ <- list1143_466 (foldl1 mplus [do d634_751 <- get
t1120_752 <- StateT char
case t1120_752 of
'\n' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'\\n'" "not match pattern: " "" d634_751 ["char"])
let '\n' = t1120_752
return ()
lift (lift (return ()))])
return ()
_ <- StateT lineComment
return ()
return (),
do _ <- list1143_466 (foldl1 mplus [do d637_753 <- get
t1123_754 <- StateT char
case t1123_754 of
'\n' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'\\n'" "not match pattern: " "" d637_753 ["char"])
let '\n' = t1123_754
return ()
lift (lift (return ()))])
return ()
_ <- StateT comment
return ()
return (),
do _ <- list1143_466 (foldl1 mplus [do d640_755 <- get
t1126_756 <- StateT char
case t1126_756 of
'\n' -> return ()
_ -> StateT position >>= (throwError . mkParseError "'\\n'" "not match pattern: " "" d640_755 ["char"])
let '\n' = t1126_756
return ()
lift (lift (return ()))])
return ()
d642_757 <- get
_ <- do d641_758 <- get
t1127_759 <- StateT char
case t1127_759 of
';' -> return ()
_ -> StateT position >>= (throwError . mkParseError "';'" "not match pattern: " "" d641_758 ["char"])
let ';' = t1127_759
return ()
put d642_757
return ()]
list142_147 :: forall m a . (MonadPlus m, Applicative m) =>
m a -> m ([a])
list1143_466 :: forall m a . (MonadPlus m, Applicative m) =>
m a -> m ([a])
list142_147 p = list1143_466 p `mplus` return []
list1143_466 p = ((:) <$> p) <*> list142_147 p
optional141_206 :: forall m a . (MonadPlus m, Applicative m) =>
m a -> m (Maybe a)
optional141_206 p = (Just <$> p) `mplus` return Nothing