y'      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~(c) The GHC Team, 1997-2000/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalportableNone1r A guarded alternative | exp -> exp/. The first expression will be Boolean-valued.-> expgdpatAn alt in a case expression.An fbind7 in a labeled record construction or update expression.This type represents both stmt in a do-expression, and qual in a list comprehension. a generator pat <- expan exp by itself: in a do_-expression, an action whose result is discarded; in a list comprehension, a guard expressionlocal bindingsAn fpat in a labeled record pattern.)A pattern, to be matched against a value.variableliteral constantnegated pattern#pattern with infix data constructor'data constructor and argument patterns  tuple pattern! list pattern"parenthesized pattern#labelled pattern$@-pattern%wildcard pattern (_)&irrefutable pattern (~)'Haskell expressions.Notes:CBecause it is difficult for parsers to distinguish patterns from expressions, they typically parse them in the same way and then check that they have the appropriate form. Hence the expression type includes some forms that are found only in patterns. After these checks, these constructors should not be used.XThe parser does not take precedence and associativity into account, so it will leave +s associated to the left.The  instance for ') does not add parentheses in printing.(variable)data constructor*literal constant+infix application,ordinary application-negation expression - exp.lambda expression/local declarations with let0if exp then exp else exp1case exp of alts2doF-expression: the last statement in the list should be an expression.3tuple expression4list expression5parenthesized expression6 left section (exp qop)7right section (qop exp)8record construction expression9record update expression:1unbounded arithmetic sequence, incrementing by 1;/bounded arithmetic sequence, incrementing by 1<=unbounded arithmetic sequence, with first two elements given=;bounded arithmetic sequence, with first two elements given>list comprehension?expression type signature@ patterns onlyA patterns onlyB patterns onlyCliteralz. Values of this type hold the abstract value of the literal, not the precise string representation used. For example, 10, 0o12 and 0xa have the same representation.Dcharacter literalEstring literalFinteger literalGfloating point literalHGHC unboxed character literalIGHC unboxed string literalJGHC unboxed integer literalKGHC unboxed float literalLGHC unboxed double literalM<Class assertions. In Haskell 98, the argument would be a tyvarK, but this definition allows multiple parameters, and allows them to be types.O$Haskell types and type constructors.P function typeQ tuple typeR!application of a type constructorS type variableTnamed type or type constructorUMA type qualified with a context. An unqualified type has an empty context.W*Safety level for invoking a foreign entityXcall may generate callbacksY call will not generate callbacksZA guarded right hand side | exp = exp/. The first expression will be Boolean-valued.\5The right hand side of a function or pattern binding.]unguarded right hand side (exp)^guarded right hand side (gdrhs)_[The type of a constructor argument or field, optionally including a strictness annotation.`strict component, marked with "!"anon-strict componentb"Declaration of a data constructor.cordinary data constructordrecord constructoreClauses of a function binding.tAssociativity of an operator.u(non-associative operator (declared with infix)v)left-associative operator (declared with infixl).w*right-associative operator (declared with infixr)xImport specification.yvariablezT1: the name of a class, datatype or type synonym.{T(..)b: a class imported with all of its methods, or a datatype imported with all of its constructors.|T(C_1,...,C_n)d: a class imported with some of its methods, or a datatype imported with some of its constructors.}Import declaration.position of the import keyword.name of the module imported. imported  qualified?optional alias name in an as clause.-optional list of import specifications. The  is  if the names are excluded by hiding.Export specification.variableT?: a class or datatype exported abstractly, or a type synonym.T(..)b: a class exported with all of its methods, or a datatype exported with all of its constructors.T(C_1,...,C_n)d: a class exported with some of its methods, or a datatype exported with some of its constructors.module M: re-export a module.A Haskell source module.A name (cname/) of a component of a class or data type in an import or export specification.name of a method or fieldname of a data constructorOperators, appearing in infix declarations.variable operator (varop)constructor operator (conop)$Possibly qualified infix operators (qop), appearing in expressions.variable operator (qvarop)constructor operator (qconop)@This type is used to represent variables, and also constructors.varid or conidvarsym or consymUThis type is used to represent qualified variables, and also qualified constructors.!name qualified with a module nameunqualified name(built-in constructor with special syntax{Constructors with special syntax. These names are never qualified, and always refer to builtin type or data constructors.unit type and data constructor ()list type constructor []function type constructor ->n)-ary tuple type and data constructors (,) etclist data constructor (:)The name of a Haskell module.A position in the source.  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~}~xyz{|tuvwghijklmnopqrsbcd_`aef\]^Z[WXYUVNMOPQRST'()*+,-./0123456789:;<=>?@AB   !"#$%&CDEFGHIJKL    !"#$%&'()*+,-./0123456789:;<=>?@ABC DEFGHIJKLOPQRSTUVWXYZ[\]^_`abcdefg hijklmnopqrstuvwxyz{|}~+(c) The GHC Team, Noel Winstanley 1997-2000/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalportableNoneKThings that can be pretty-printed, including all the syntactic objects in Language.Haskell.Syntax.$Pretty-print something in isolation./Pretty-print something in a precedence context.;The document type produced by these pretty printers uses a  environment.Pretty printing monadPretty-printing parameters.Note: the &2 must be positive and less than all other indents.!"indentation of a class or instance"indentation of a do -expression#indentation of the body of a case expression$&indentation of the declarations in a let expression%&indentation of the declarations in a where clause&Iindentation added for continuation lines that would otherwise be offside'blank lines between statements?(Pretty-printing style to use)add GHC-style LINE pragmas to output?*not implemented yet,Varieties of layout we can use.-classical layout.classical layout made explicit/(inline decls, with newlines between them0everything on a single line1MThe default mode: pretty-print using the offside rule and sensible defaults.0render the document with a given style and mode.2)pretty-print with a given style and mode.35pretty-print with the default style and a given mode.4(pretty-print with the default style and 1.6"  !"#$%&'()*+,-./01234"234  !"#$%&'()*+,-./01  !"#$%&'()*,-./05(c) The GHC Team, 1997-2000/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalportableNone XMonad for parsingYbStatic parameters governing a parse. More to come later, e.g. literate mode, language extensions.[&original name of the file being parsed_The result of a parse.`&The parse succeeded, yielding a value.aJThe parse failed at the specified source location, with an error message.bQDefault parameters for a parse, currently just a marker for an unknown filename.jHDiscard some input characters (these must not include tabs or newlines).k4Discard the next character, which must be a newline.l0Discard the next character, which must be a tab.vz|}~VWXYZ[\]^_`abcdefghijklmnopqrstX_`ae\]^YZ[bcdfghVWijklmnopqrstVWXYZ[\]^_`a(c) The GHC Team, 1997-2000/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalportableNoneX(c) The GHC Team, 1997-2000/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalportableNoneCCA&(c) Simon Marlow, Sven Panne 1997-2000/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalportableNone;=DeEParse of a string, which should contain a complete Haskell 98 module.EParse of a string, which should contain a complete Haskell 98 module. YZ[_`ab YZ[b_`a9 9             !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZZ[\]^^_`abcdeefgghijklmnopqrstuvwxyz{|}~~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~QS*haskell-src-1.0.3.0-KFM6wwOuWZGJ00S0DD918pLanguage.Haskell.PrettyLanguage.Haskell.SyntaxLanguage.Haskell.ParseMonadLanguage.Haskell.ParseUtilsLanguage.Haskell.LexerLanguage.Haskell.ParserPrettypretty-1.1.3.3#Text.PrettyPrint.Annotated.HughesPJstyleribbonsPerLine lineLengthmodeStyle OneLineModeLeftMode ZigZagModePageModeMode HsGuardedAlt HsGuardedAltsHsUnGuardedAltHsAlt HsFieldUpdateHsStmt HsGenerator HsQualifier HsLetStmt HsPatField HsPFieldPatHsPatHsPVarHsPLitHsPNeg HsPInfixAppHsPAppHsPTupleHsPListHsPParenHsPRecHsPAsPat HsPWildCard HsPIrrPatHsExpHsVarHsConHsLit HsInfixAppHsAppHsNegAppHsLambdaHsLetHsIfHsCaseHsDoHsTupleHsListHsParen HsLeftSectionHsRightSection HsRecConstr HsRecUpdate HsEnumFrom HsEnumFromToHsEnumFromThenHsEnumFromThenTo HsListComp HsExpTypeSigHsAsPat HsWildCardHsIrrPat HsLiteralHsCharHsStringHsIntHsFrac HsCharPrim HsStringPrim HsIntPrim HsFloatPrim HsDoublePrimHsAsst HsContextHsTypeHsTyFun HsTyTupleHsTyAppHsTyVarHsTyCon HsQualTypeHsSafetyHsSafeHsUnsafe HsGuardedRhsHsRhsHsUnGuardedRhs HsGuardedRhss HsBangType HsBangedTy HsUnBangedTy HsConDecl HsRecDeclHsMatchHsDecl HsTypeDecl HsDataDecl HsInfixDecl HsNewTypeDecl HsClassDecl HsInstDecl HsDefaultDecl HsTypeSig HsFunBind HsPatBindHsForeignImportHsForeignExportHsAssoc HsAssocNone HsAssocLeft HsAssocRight HsImportSpecHsIVarHsIAbs HsIThingAll HsIThingWith HsImportDecl importLoc importModuleimportQualifiedimportAs importSpecs HsExportSpecHsEVarHsEAbs HsEThingAll HsEThingWithHsEModuleContentsHsModuleHsCName HsVarName HsConNameHsOpHsVarOpHsConOpHsQOpHsQVarOpHsQConOpHsNameHsIdentHsSymbolHsQNameQualUnQualSpecial HsSpecialCon HsUnitCon HsListConHsFunCon HsTupleConHsConsModuleSrcLoc srcFilenamesrcLine srcColumn prelude_modmain_mod main_name unit_con_nametuple_con_namelist_cons_nameunit_con tuple_conunit_tycon_namefun_tycon_namelist_tycon_nametuple_tycon_name unit_tycon fun_tycon list_tycon tuple_tycon $fEqSrcLoc $fOrdSrcLoc $fShowSrcLoc $fDataSrcLoc $fEqModule $fOrdModule $fShowModule $fDataModule$fEqHsSpecialCon$fOrdHsSpecialCon$fShowHsSpecialCon$fDataHsSpecialCon $fEqHsName $fOrdHsName $fShowHsName $fDataHsName $fEqHsQName $fOrdHsQName $fShowHsQName $fDataHsQName $fEqHsQOp $fOrdHsQOp $fShowHsQOp $fDataHsQOp$fEqHsOp $fOrdHsOp $fShowHsOp $fDataHsOp $fEqHsCName $fOrdHsCName $fShowHsCName $fDataHsCName$fEqHsExportSpec$fShowHsExportSpec$fDataHsExportSpec$fEqHsImportSpec$fShowHsImportSpec$fDataHsImportSpec$fEqHsImportDecl$fShowHsImportDecl$fDataHsImportDecl $fEqHsAssoc $fShowHsAssoc $fDataHsAssoc $fEqHsSafety $fOrdHsSafety$fShowHsSafety$fDataHsSafety $fEqHsType $fShowHsType $fDataHsType$fEqHsBangType$fShowHsBangType$fDataHsBangType $fEqHsConDecl$fShowHsConDecl$fDataHsConDecl$fEqHsQualType$fShowHsQualType$fDataHsQualType $fEqHsLiteral$fShowHsLiteral$fDataHsLiteral$fEqHsPatField$fShowHsPatField$fDataHsPatField $fEqHsPat $fShowHsPat $fDataHsPat$fEqHsGuardedAlt$fShowHsGuardedAlt$fDataHsGuardedAlt $fEqHsExp $fShowHsExp $fDataHsExp $fEqHsAlt $fShowHsAlt $fDataHsAlt$fEqHsGuardedAlts$fShowHsGuardedAlts$fDataHsGuardedAlts $fEqHsDecl $fShowHsDecl $fDataHsDecl $fEqHsRhs $fShowHsRhs $fDataHsRhs$fEqHsGuardedRhs$fShowHsGuardedRhs$fDataHsGuardedRhs $fEqHsMatch $fShowHsMatch $fDataHsMatch$fEqHsFieldUpdate$fShowHsFieldUpdate$fDataHsFieldUpdate $fEqHsStmt $fShowHsStmt $fDataHsStmt$fShowHsModule$fDataHsModulePPHsMode classIndentdoIndent caseIndent letIndent whereIndent onsideIndentspacinglayout linePragmascommentsIndentPPLayout PPOffsideRule PPSemiColonPPInLine PPNoLayout defaultModeprettyPrintStyleModeprettyPrintWithMode prettyPrint $fMonadDocM$fApplicativeDocM $fFunctorDocM$fPrettyHsCName$fPrettyHsName $fPrettyHsOp$fPrettyHsQName $fPrettyHsQOp$fPrettyHsFieldUpdate$fPrettyHsStmt$fPrettyHsGuardedAlt$fPrettyHsGuardedAlts $fPrettyHsAlt$fPrettyHsPatField $fPrettyHsPat $fPrettyHsExp$fPrettyHsLiteral$fPrettyHsGuardedRhs $fPrettyHsRhs$fPrettyHsType$fPrettyHsQualType$fPrettyHsBangType$fPrettyHsConDecl$fPrettyHsMatch$fPrettyHsSafety$fPrettyHsAssoc$fPrettyHsDecl$fPrettyHsImportSpec$fPrettyHsImportDecl$fPrettyHsExportSpec$fPrettyModule$fPrettyHsModule $fEqPPLayoutLexrunLP ParseMode parseFilename LexContextNoLayoutLayout ParseResultParseOk ParseFaileddefaultParseModerunParserWithMode runParseratSrcLoc getSrcLocpushCurrentContext popContextgetInputdiscard lexNewlinelexTablexWhile alternativecheckBOLsetBOL startToken getOffside pushContextL popContextL$fMonoidParseResult$fSemigroupParseResult$fMonadParseResult$fApplicativeParseResult$fFunctorParseResult $fMonadFailP$fMonadP$fApplicativeP $fFunctorP$fMonadFailLex $fMonadLex$fApplicativeLex $fFunctorLex$fShowParseResult$fEqLexContext$fOrdLexContext$fShowLexContext$fShowParseStatus splitTyConApp checkContextcheckAssertioncheckDataHeadercheckClassHeadercheckInstHeader checkPattern checkExpr checkValDefcheckClassBody checkUnQual checkPrecmkRecConstrOrUpdate checkRevDeclsTokenVarIdQVarIdConIdQConIdVarSymConSymQVarSymQConSymIntTokFloatTok Character StringTok LeftParen RightParen SemiColon LeftCurly RightCurly VRightCurly LeftSquare RightSquareComma Underscore BackQuoteDotDotColon DoubleColonEquals BackslashBar LeftArrow RightArrowAtTilde DoubleArrowMinus ExclamationKW_CaseKW_ClassKW_Data KW_Default KW_DerivingKW_DoKW_Else KW_ForeignKW_If KW_ImportKW_InKW_Infix KW_InfixL KW_InfixR KW_InstanceKW_Let KW_Module KW_NewTypeKW_OfKW_ThenKW_TypeKW_WhereKW_As KW_Export KW_Hiding KW_QualifiedKW_Safe KW_UnsafeEOFlexer $fEqToken $fShowToken parseModuleparseModuleWithModeghc-prim GHC.TypesBoolTruepretty prettyPrecDocDocMrenderStyleMode$$$runP ParseStatusOkFailed HappyAddrHappyA#HappyStk Happy_IntList HappyCons HappyAbsSyn