haskell-src-exts-simple-1.23.1.0: A simplified view on the haskell-src-exts AST

Safe Haskell | Safe-Inferred
Language | Haskell2010

Language.Haskell.Exts.Simple.Syntax

Description

This module reexports a simplified view on Language.Haskell.Exts.Syntax. The idea is to expose datatypes like

    data Name l = Ident l String | Symbol l String

using ghc's pattern synonyms:

    type Name = H.Name ()
    pattern Ident a = H.Ident () a
    pattern Symbol a = H.Symbol () a

Synopsis

- pattern Int :: Integer -> Literal
- pattern Char :: Char -> Literal
- pattern List :: [Exp] -> Exp
- pattern Symbol :: String -> Name
- pattern TyCon :: QName -> Type
- type Module = Module ()
- pattern Module :: Maybe ModuleHead -> [ModulePragma] -> [ImportDecl] -> [Decl] -> Module
- type Type = Type ()
- pattern String :: String -> Literal
- pattern If :: Exp -> Exp -> Exp -> Exp
- pattern Ident :: String -> Name
- type Alt = Alt ()
- pattern Alt :: Pat -> Rhs -> Maybe Binds -> Alt
- pattern Con :: QName -> Exp
- pattern App :: Exp -> Exp -> Exp
- pattern DataType :: DataOrNew
- type Op = Op ()
- type FieldUpdate = FieldUpdate ()
- pattern FieldUpdate :: QName -> Exp -> FieldUpdate
- pattern FieldPun :: QName -> FieldUpdate
- pattern FieldWildcard :: FieldUpdate
- type QualStmt = QualStmt ()
- pattern QualStmt :: Stmt -> QualStmt
- pattern ThenTrans :: Exp -> QualStmt
- pattern ThenBy :: Exp -> Exp -> QualStmt
- pattern GroupBy :: Exp -> QualStmt
- pattern GroupUsing :: Exp -> QualStmt
- pattern GroupByUsing :: Exp -> Exp -> QualStmt
- type Stmt = Stmt ()
- pattern Generator :: Pat -> Exp -> Stmt
- pattern Qualifier :: Exp -> Stmt
- pattern LetStmt :: Binds -> Stmt
- pattern RecStmt :: [Stmt] -> Stmt
- type PatField = PatField ()
- pattern PFieldPat :: QName -> Pat -> PatField
- pattern PFieldPun :: QName -> PatField
- pattern PFieldWildcard :: PatField
- type RPat = RPat ()
- pattern RPOp :: RPat -> RPatOp -> RPat
- pattern RPEither :: RPat -> RPat -> RPat
- pattern RPSeq :: [RPat] -> RPat
- pattern RPGuard :: Pat -> [Stmt] -> RPat
- pattern RPCAs :: Name -> RPat -> RPat
- pattern RPAs :: Name -> RPat -> RPat
- pattern RPParen :: RPat -> RPat
- pattern RPPat :: Pat -> RPat
- type RPatOp = RPatOp ()
- pattern RPStar :: RPatOp
- pattern RPStarG :: RPatOp
- pattern RPPlus :: RPatOp
- pattern RPPlusG :: RPatOp
- pattern RPOpt :: RPatOp
- pattern RPOptG :: RPatOp
- type PXAttr = PXAttr ()
- pattern PXAttr :: XName -> Pat -> PXAttr
- type Pat = Pat ()
- pattern PVar :: Name -> Pat
- pattern PLit :: Sign -> Literal -> Pat
- pattern PNPlusK :: Name -> Integer -> Pat
- pattern PInfixApp :: Pat -> QName -> Pat -> Pat
- pattern PApp :: QName -> [Pat] -> Pat
- pattern PTuple :: Boxed -> [Pat] -> Pat
- pattern PUnboxedSum :: Int -> Int -> Pat -> Pat
- pattern PList :: [Pat] -> Pat
- pattern PParen :: Pat -> Pat
- pattern PRec :: QName -> [PatField] -> Pat
- pattern PAsPat :: Name -> Pat -> Pat
- pattern PWildCard :: Pat
- pattern PIrrPat :: Pat -> Pat
- pattern PatTypeSig :: Pat -> Type -> Pat
- pattern PViewPat :: Exp -> Pat -> Pat
- pattern PRPat :: [RPat] -> Pat
- pattern PXTag :: XName -> [PXAttr] -> Maybe Pat -> [Pat] -> Pat
- pattern PXETag :: XName -> [PXAttr] -> Maybe Pat -> Pat
- pattern PXPcdata :: String -> Pat
- pattern PXPatTag :: Pat -> Pat
- pattern PXRPats :: [RPat] -> Pat
- pattern PSplice :: Splice -> Pat
- pattern PQuasiQuote :: String -> String -> Pat
- pattern PBangPat :: Pat -> Pat
- type WarningText = WarningText ()
- pattern DeprText :: String -> WarningText
- pattern WarnText :: String -> WarningText
- type RuleVar = RuleVar ()
- pattern RuleVar :: Name -> RuleVar
- pattern TypedRuleVar :: Name -> Type -> RuleVar
- type Rule = Rule ()
- pattern Rule :: String -> Maybe Activation -> Maybe [RuleVar] -> Exp -> Exp -> Rule
- type Activation = Activation ()
- pattern ActiveFrom :: Int -> Activation
- pattern ActiveUntil :: Int -> Activation
- type Overlap = Overlap ()
- pattern Overlap :: Overlap
- pattern NoOverlap :: Overlap
- pattern Overlapping :: Overlap
- pattern Overlaps :: Overlap
- pattern Overlappable :: Overlap
- pattern Incoherent :: Overlap
- type ModulePragma = ModulePragma ()
- pattern LanguagePragma :: [Name] -> ModulePragma
- pattern OptionsPragma :: Maybe Tool -> String -> ModulePragma
- pattern AnnModulePragma :: Annotation -> ModulePragma
- type CallConv = CallConv ()
- pattern StdCall :: CallConv
- pattern CCall :: CallConv
- pattern CPlusPlus :: CallConv
- pattern DotNet :: CallConv
- pattern Jvm :: CallConv
- pattern Js :: CallConv
- pattern JavaScript :: CallConv
- pattern CApi :: CallConv
- type Safety = Safety ()
- pattern PlayRisky :: Safety
- pattern PlaySafe :: Bool -> Safety
- pattern PlayInterruptible :: Safety
- type Splice = Splice ()
- pattern IdSplice :: String -> Splice
- pattern TIdSplice :: String -> Splice
- pattern ParenSplice :: Exp -> Splice
- pattern TParenSplice :: Exp -> Splice
- type Bracket = Bracket ()
- pattern ExpBracket :: Exp -> Bracket
- pattern TExpBracket :: Exp -> Bracket
- pattern PatBracket :: Pat -> Bracket
- pattern TypeBracket :: Type -> Bracket
- pattern DeclBracket :: [Decl] -> Bracket
- type XAttr = XAttr ()
- pattern XAttr :: XName -> Exp -> XAttr
- type XName = XName ()
- pattern XName :: String -> XName
- pattern XDomName :: String -> String -> XName
- type Exp = Exp ()
- pattern Var :: QName -> Exp
- pattern OverloadedLabel :: String -> Exp
- pattern IPVar :: IPName -> Exp
- pattern Lit :: Literal -> Exp
- pattern InfixApp :: Exp -> QOp -> Exp -> Exp
- pattern NegApp :: Exp -> Exp
- pattern Lambda :: [Pat] -> Exp -> Exp
- pattern Let :: Binds -> Exp -> Exp
- pattern MultiIf :: [GuardedRhs] -> Exp
- pattern Case :: Exp -> [Alt] -> Exp
- pattern Do :: [Stmt] -> Exp
- pattern MDo :: [Stmt] -> Exp
- pattern Tuple :: Boxed -> [Exp] -> Exp
- pattern UnboxedSum :: Int -> Int -> Exp -> Exp
- pattern TupleSection :: Boxed -> [Maybe Exp] -> Exp
- pattern ParArray :: [Exp] -> Exp
- pattern Paren :: Exp -> Exp
- pattern LeftSection :: Exp -> QOp -> Exp
- pattern RightSection :: QOp -> Exp -> Exp
- pattern RecConstr :: QName -> [FieldUpdate] -> Exp
- pattern RecUpdate :: Exp -> [FieldUpdate] -> Exp
- pattern EnumFrom :: Exp -> Exp
- pattern EnumFromTo :: Exp -> Exp -> Exp
- pattern EnumFromThen :: Exp -> Exp -> Exp
- pattern EnumFromThenTo :: Exp -> Exp -> Exp -> Exp
- pattern ParArrayFromTo :: Exp -> Exp -> Exp
- pattern ParArrayFromThenTo :: Exp -> Exp -> Exp -> Exp
- pattern ListComp :: Exp -> [QualStmt] -> Exp
- pattern ParComp :: Exp -> [[QualStmt]] -> Exp
- pattern ParArrayComp :: Exp -> [[QualStmt]] -> Exp
- pattern ExpTypeSig :: Exp -> Type -> Exp
- pattern VarQuote :: QName -> Exp
- pattern TypQuote :: QName -> Exp
- pattern BracketExp :: Bracket -> Exp
- pattern SpliceExp :: Splice -> Exp
- pattern QuasiQuote :: String -> String -> Exp
- pattern TypeApp :: Type -> Exp
- pattern XTag :: XName -> [XAttr] -> Maybe Exp -> [Exp] -> Exp
- pattern XETag :: XName -> [XAttr] -> Maybe Exp -> Exp
- pattern XPcdata :: String -> Exp
- pattern XExpTag :: Exp -> Exp
- pattern XChildTag :: [Exp] -> Exp
- pattern CorePragma :: String -> Exp -> Exp
- pattern SCCPragma :: String -> Exp -> Exp
- pattern GenPragma :: String -> (Int, Int) -> (Int, Int) -> Exp -> Exp
- pattern Proc :: Pat -> Exp -> Exp
- pattern LeftArrApp :: Exp -> Exp -> Exp
- pattern RightArrApp :: Exp -> Exp -> Exp
- pattern LeftArrHighApp :: Exp -> Exp -> Exp
- pattern RightArrHighApp :: Exp -> Exp -> Exp
- pattern ArrOp :: Exp -> Exp
- pattern LCase :: [Alt] -> Exp
- type Sign = Sign ()
- pattern Signless :: Sign
- pattern Negative :: Sign
- type Literal = Literal ()
- pattern Frac :: Rational -> Literal
- pattern PrimInt :: Integer -> Literal
- pattern PrimWord :: Integer -> Literal
- pattern PrimFloat :: Rational -> Literal
- pattern PrimDouble :: Rational -> Literal
- pattern PrimChar :: Char -> Literal
- pattern PrimString :: String -> Literal
- type Asst = Asst ()
- pattern TypeA :: Type -> Asst
- pattern IParam :: IPName -> Type -> Asst
- pattern ParenA :: Asst -> Asst
- type Context = Context ()
- pattern CxSingle :: Asst -> Context
- pattern CxTuple :: [Asst] -> Context
- pattern CxEmpty :: Context
- type FunDep = FunDep ()
- pattern FunDep :: [Name] -> [Name] -> FunDep
- type Kind = Kind ()
- type TyVarBind = TyVarBind ()
- pattern KindedVar :: Name -> Kind -> TyVarBind
- pattern UnkindedVar :: Name -> TyVarBind
- type Promoted = Promoted ()
- pattern PromotedInteger :: Integer -> String -> Promoted
- pattern PromotedString :: String -> String -> Promoted
- pattern PromotedCon :: Bool -> QName -> Promoted
- pattern PromotedList :: Bool -> [Type] -> Promoted
- pattern PromotedTuple :: [Type] -> Promoted
- pattern PromotedUnit :: Promoted
- type MaybePromotedName = MaybePromotedName ()
- pattern PromotedName :: QName -> MaybePromotedName
- pattern UnpromotedName :: QName -> MaybePromotedName
- pattern TyForall :: Maybe [TyVarBind] -> Maybe Context -> Type -> Type
- pattern TyStar :: Type
- pattern TyFun :: Type -> Type -> Type
- pattern TyTuple :: Boxed -> [Type] -> Type
- pattern TyUnboxedSum :: [Type] -> Type
- pattern TyList :: Type -> Type
- pattern TyParArray :: Type -> Type
- pattern TyApp :: Type -> Type -> Type
- pattern TyVar :: Name -> Type
- pattern TyParen :: Type -> Type
- pattern TyInfix :: Type -> MaybePromotedName -> Type -> Type
- pattern TyKind :: Type -> Kind -> Type
- pattern TyPromoted :: Promoted -> Type
- pattern TyEquals :: Type -> Type -> Type
- pattern TySplice :: Splice -> Type
- pattern TyBang :: BangType -> Unpackedness -> Type -> Type
- pattern TyWildCard :: Maybe Name -> Type
- pattern TyQuasiQuote :: String -> String -> Type
- type GuardedRhs = GuardedRhs ()
- pattern GuardedRhs :: [Stmt] -> Exp -> GuardedRhs
- type Rhs = Rhs ()
- pattern UnGuardedRhs :: Exp -> Rhs
- pattern GuardedRhss :: [GuardedRhs] -> Rhs
- type Unpackedness = Unpackedness ()
- pattern Unpack :: Unpackedness
- pattern NoUnpack :: Unpackedness
- pattern NoUnpackPragma :: Unpackedness
- type BangType = BangType ()
- pattern BangedTy :: BangType
- pattern LazyTy :: BangType
- pattern NoStrictAnnot :: BangType
- type InstDecl = InstDecl ()
- pattern InstDecl :: Maybe Overlap -> InstRule -> Maybe [InstDecl] -> Decl
- pattern InsDecl :: Decl -> InstDecl
- pattern InsType :: Type -> Type -> InstDecl
- pattern InsData :: DataOrNew -> Type -> [QualConDecl] -> [Deriving] -> InstDecl
- pattern InsGData :: DataOrNew -> Type -> Maybe Kind -> [GadtDecl] -> [Deriving] -> InstDecl
- type ClassDecl = ClassDecl ()
- pattern ClassDecl :: Maybe Context -> DeclHead -> [FunDep] -> Maybe [ClassDecl] -> Decl
- pattern ClsDecl :: Decl -> ClassDecl
- pattern ClsDataFam :: Maybe Context -> DeclHead -> Maybe ResultSig -> ClassDecl
- pattern ClsTyFam :: DeclHead -> Maybe ResultSig -> Maybe InjectivityInfo -> ClassDecl
- pattern ClsTyDef :: TypeEqn -> ClassDecl
- pattern ClsDefSig :: Name -> Type -> ClassDecl
- type GadtDecl = GadtDecl ()
- pattern GadtDecl :: Name -> Maybe [TyVarBind] -> Maybe Context -> Maybe [FieldDecl] -> Type -> GadtDecl
- type FieldDecl = FieldDecl ()
- pattern FieldDecl :: [Name] -> Type -> FieldDecl
- type ConDecl = ConDecl ()
- pattern ConDecl :: Name -> [Type] -> ConDecl
- pattern InfixConDecl :: Type -> Name -> Type -> ConDecl
- pattern RecDecl :: Name -> [FieldDecl] -> ConDecl
- type QualConDecl = QualConDecl ()
- pattern QualConDecl :: Maybe [TyVarBind] -> Maybe Context -> ConDecl -> QualConDecl
- type Match = Match ()
- pattern Match :: Name -> [Pat] -> Rhs -> Maybe Binds -> Match
- pattern InfixMatch :: Pat -> Name -> [Pat] -> Rhs -> Maybe Binds -> Match
- type IPBind = IPBind ()
- pattern IPBind :: IPName -> Exp -> IPBind
- type Binds = Binds ()
- pattern BDecls :: [Decl] -> Binds
- pattern IPBinds :: [IPBind] -> Binds
- type DerivStrategy = DerivStrategy ()
- pattern DerivStock :: DerivStrategy
- pattern DerivAnyclass :: DerivStrategy
- pattern DerivNewtype :: DerivStrategy
- pattern DerivVia :: Type -> DerivStrategy
- type Deriving = Deriving ()
- pattern Deriving :: Maybe DerivStrategy -> [InstRule] -> Deriving
- type InstHead = InstHead ()
- pattern IHCon :: QName -> InstHead
- pattern IHInfix :: Type -> QName -> InstHead
- pattern IHParen :: InstHead -> InstHead
- pattern IHApp :: InstHead -> Type -> InstHead
- type InstRule = InstRule ()
- pattern IRule :: Maybe [TyVarBind] -> Maybe Context -> InstHead -> InstRule
- pattern IParen :: InstRule -> InstRule
- type DeclHead = DeclHead ()
- pattern DHead :: Name -> DeclHead
- pattern DHInfix :: TyVarBind -> Name -> DeclHead
- pattern DHParen :: DeclHead -> DeclHead
- pattern DHApp :: DeclHead -> TyVarBind -> DeclHead
- type ResultSig = ResultSig ()
- pattern KindSig :: Kind -> ResultSig
- pattern TyVarSig :: TyVarBind -> ResultSig
- type InjectivityInfo = InjectivityInfo ()
- pattern InjectivityInfo :: Name -> [Name] -> InjectivityInfo
- type DataOrNew = DataOrNew ()
- pattern NewType :: DataOrNew
- type Role = Role ()
- pattern Nominal :: Role
- pattern Representational :: Role
- pattern Phantom :: Role
- pattern RoleWildcard :: Role
- type BooleanFormula = BooleanFormula ()
- pattern VarFormula :: Name -> BooleanFormula
- pattern AndFormula :: [BooleanFormula] -> BooleanFormula
- pattern OrFormula :: [BooleanFormula] -> BooleanFormula
- pattern ParenFormula :: BooleanFormula -> BooleanFormula
- type Annotation = Annotation ()
- pattern Ann :: Name -> Exp -> Annotation
- pattern TypeAnn :: Name -> Exp -> Annotation
- pattern ModuleAnn :: Exp -> Annotation
- type TypeEqn = TypeEqn ()
- pattern TypeEqn :: Type -> Type -> TypeEqn
- type PatternSynDirection = PatternSynDirection ()
- pattern Unidirectional :: PatternSynDirection
- pattern ImplicitBidirectional :: PatternSynDirection
- pattern ExplicitBidirectional :: [Decl] -> PatternSynDirection
- type Decl = Decl ()
- pattern TypeDecl :: DeclHead -> Type -> Decl
- pattern TypeFamDecl :: DeclHead -> Maybe ResultSig -> Maybe InjectivityInfo -> Decl
- pattern ClosedTypeFamDecl :: DeclHead -> Maybe ResultSig -> Maybe InjectivityInfo -> [TypeEqn] -> Decl
- pattern DataDecl :: DataOrNew -> Maybe Context -> DeclHead -> [QualConDecl] -> [Deriving] -> Decl
- pattern GDataDecl :: DataOrNew -> Maybe Context -> DeclHead -> Maybe Kind -> [GadtDecl] -> [Deriving] -> Decl
- pattern DataFamDecl :: Maybe Context -> DeclHead -> Maybe ResultSig -> Decl
- pattern TypeInsDecl :: Type -> Type -> Decl
- pattern DataInsDecl :: DataOrNew -> Type -> [QualConDecl] -> [Deriving] -> Decl
- pattern GDataInsDecl :: DataOrNew -> Type -> Maybe Kind -> [GadtDecl] -> [Deriving] -> Decl
- pattern DerivDecl :: Maybe DerivStrategy -> Maybe Overlap -> InstRule -> Decl
- pattern InfixDecl :: Assoc -> Maybe Int -> [Op] -> Decl
- pattern DefaultDecl :: [Type] -> Decl
- pattern SpliceDecl :: Exp -> Decl
- pattern TSpliceDecl :: Exp -> Decl
- pattern TypeSig :: [Name] -> Type -> Decl
- pattern PatSynSig :: [Name] -> Maybe [TyVarBind] -> Maybe Context -> Maybe [TyVarBind] -> Maybe Context -> Type -> Decl
- pattern FunBind :: [Match] -> Decl
- pattern PatBind :: Pat -> Rhs -> Maybe Binds -> Decl
- pattern PatSyn :: Pat -> Pat -> PatternSynDirection -> Decl
- pattern ForImp :: CallConv -> Maybe Safety -> Maybe String -> Name -> Type -> Decl
- pattern ForExp :: CallConv -> Maybe String -> Name -> Type -> Decl
- pattern RulePragmaDecl :: [Rule] -> Decl
- pattern DeprPragmaDecl :: [([Name], String)] -> Decl
- pattern WarnPragmaDecl :: [([Name], String)] -> Decl
- pattern InlineSig :: Bool -> Maybe Activation -> QName -> Decl
- pattern InlineConlikeSig :: Maybe Activation -> QName -> Decl
- pattern SpecSig :: Maybe Activation -> QName -> [Type] -> Decl
- pattern SpecInlineSig :: Bool -> Maybe Activation -> QName -> [Type] -> Decl
- pattern InstSig :: InstRule -> Decl
- pattern AnnPragma :: Annotation -> Decl
- pattern MinimalPragma :: Maybe BooleanFormula -> Decl
- pattern RoleAnnotDecl :: QName -> [Role] -> Decl
- pattern CompletePragma :: [Name] -> Maybe QName -> Decl
- type Assoc = Assoc ()
- pattern AssocNone :: Assoc
- pattern AssocLeft :: Assoc
- pattern AssocRight :: Assoc
- type ImportSpec = ImportSpec ()
- pattern IVar :: Name -> ImportSpec
- pattern IAbs :: Namespace -> Name -> ImportSpec
- pattern IThingAll :: Name -> ImportSpec
- pattern IThingWith :: Name -> [CName] -> ImportSpec
- type ImportSpecList = ImportSpecList ()
- pattern ImportSpecList :: Bool -> [ImportSpec] -> ImportSpecList
- type ImportDecl = ImportDecl ()
- pattern ImportDecl :: ModuleName () -> Bool -> Bool -> Bool -> Maybe String -> Maybe (ModuleName ()) -> Maybe (ImportSpecList ()) -> ImportDecl
- importSpecs :: ImportDecl -> Maybe (ImportSpecList ())
- importAs :: ImportDecl -> Maybe (ModuleName ())
- importPkg :: ImportDecl -> Maybe String
- importSafe :: ImportDecl -> Bool
- importSrc :: ImportDecl -> Bool
- importQualified :: ImportDecl -> Bool
- importModule :: ImportDecl -> ModuleName ()
- type Namespace = Namespace ()
- pattern NoNamespace :: Namespace
- pattern TypeNamespace :: Namespace
- pattern PatternNamespace :: Namespace
- type EWildcard = EWildcard ()
- pattern EWildcard :: Int -> EWildcard
- pattern NoWildcard :: EWildcard
- type ExportSpec = ExportSpec ()
- pattern EVar :: QName -> ExportSpec
- pattern EAbs :: Namespace -> QName -> ExportSpec
- pattern EThingWith :: EWildcard -> QName -> [CName] -> ExportSpec
- pattern EModuleContents :: ModuleName -> ExportSpec
- type ExportSpecList = ExportSpecList ()
- pattern ExportSpecList :: [ExportSpec] -> ExportSpecList
- type ModuleHead = ModuleHead ()
- pattern ModuleHead :: ModuleName -> Maybe WarningText -> Maybe ExportSpecList -> ModuleHead
- pattern XmlPage :: ModuleName -> [ModulePragma] -> XName -> [XAttr] -> Maybe Exp -> [Exp] -> Module
- pattern XmlHybrid :: Maybe ModuleHead -> [ModulePragma] -> [ImportDecl] -> [Decl] -> XName -> [XAttr] -> Maybe Exp -> [Exp] -> Module
- type CName = CName ()
- pattern VarName :: Name -> CName
- pattern ConName :: Name -> CName
- pattern VarOp :: Name -> Op
- pattern ConOp :: Name -> Op
- type QOp = QOp ()
- pattern QVarOp :: QName -> QOp
- pattern QConOp :: QName -> QOp
- type IPName = IPName ()
- pattern IPDup :: String -> IPName
- pattern IPLin :: String -> IPName
- type Name = Name ()
- type QName = QName ()
- pattern Qual :: ModuleName -> Name -> QName
- pattern UnQual :: Name -> QName
- pattern Special :: SpecialCon -> QName
- type SpecialCon = SpecialCon ()
- pattern UnitCon :: SpecialCon
- pattern ListCon :: SpecialCon
- pattern FunCon :: SpecialCon
- pattern TupleCon :: Boxed -> Int -> SpecialCon
- pattern Cons :: SpecialCon
- pattern UnboxedSingleCon :: SpecialCon
- pattern ExprHole :: SpecialCon
- type ModuleName = ModuleName ()
- pattern ModuleName :: String -> ModuleName
- prelude_mod :: ModuleName
- main_mod :: ModuleName
- main_name :: Name
- unit_con_name :: QName
- tuple_con_name :: Boxed -> Int -> QName
- list_con_name :: QName
- list_cons_name :: QName
- unboxed_singleton_con_name :: QName
- unit_con :: Exp
- tuple_con :: Boxed -> Int -> Exp
- unboxed_singleton_con :: Exp
- as_name :: Name
- qualified_name :: Name
- hiding_name :: Name
- minus_name :: Name
- bang_name :: Name
- dot_name :: Name
- star_name :: Name
- hole_name :: QName
- export_name :: Name
- safe_name :: Name
- unsafe_name :: Name
- interruptible_name :: Name
- threadsafe_name :: Name
- stdcall_name :: Name
- ccall_name :: Name
- cplusplus_name :: Name
- dotnet_name :: Name
- jvm_name :: Name
- js_name :: Name
- javascript_name :: Name
- capi_name :: Name
- forall_name :: Name
- family_name :: Name
- role_name :: Name
- stock_name :: Name
- anyclass_name :: Name
- via_name :: Name
- unit_tycon_name :: QName
- fun_tycon_name :: QName
- list_tycon_name :: QName
- unboxed_singleton_tycon_name :: QName
- tuple_tycon_name :: Boxed -> Int -> QName
- unit_tycon :: Type
- fun_tycon :: Type
- list_tycon :: Type
- unboxed_singleton_tycon :: Type
- tuple_tycon :: Boxed -> Int -> Type
- charL :: Char -> Literal
- stringL :: String -> Literal
- intL :: Integer -> Literal
- fracL :: Rational -> Literal
- primIntL :: Integer -> Literal
- primWordL :: Integer -> Literal
- primFloatL :: Rational -> Literal
- primDoubleL :: Rational -> Literal
- primCharL :: Char -> Literal
- primStringL :: String -> Literal
- data Tool
  - = GHC
  - | HUGS
  - | NHC98
  - | YHC
  - | HADDOCK
  - | UnknownTool String
- data Boxed
  - = Boxed
  - | Unboxed

# Documentation

pattern Int :: Integer -> Literal Source #

pattern Char :: Char -> Literal Source #

pattern List :: [Exp] -> Exp Source #

pattern Symbol :: String -> Name Source #

pattern TyCon :: QName -> Type Source #

type Module = Module () Source #

pattern Module :: Maybe ModuleHead -> [ModulePragma] -> [ImportDecl] -> [Decl] -> Module Source #

type Type = Type () Source #

pattern String :: String -> Literal Source #

pattern If :: Exp -> Exp -> Exp -> Exp Source #

pattern Ident :: String -> Name Source #

type Alt = Alt () Source #

pattern Alt :: Pat -> Rhs -> Maybe Binds -> Alt Source #

pattern Con :: QName -> Exp Source #

pattern App :: Exp -> Exp -> Exp Source #

pattern DataType :: DataOrNew Source #

type Op = Op () Source #

type FieldUpdate = FieldUpdate () Source #

pattern FieldUpdate :: QName -> Exp -> FieldUpdate Source #

pattern FieldPun :: QName -> FieldUpdate Source #

pattern FieldWildcard :: FieldUpdate Source #

type QualStmt = QualStmt () Source #

pattern QualStmt :: Stmt -> QualStmt Source #

pattern ThenTrans :: Exp -> QualStmt Source #

pattern ThenBy :: Exp -> Exp -> QualStmt Source #

pattern GroupBy :: Exp -> QualStmt Source #

pattern GroupUsing :: Exp -> QualStmt Source #

pattern GroupByUsing :: Exp -> Exp -> QualStmt Source #

type Stmt = Stmt () Source #

pattern Generator :: Pat -> Exp -> Stmt Source #

pattern Qualifier :: Exp -> Stmt Source #

pattern LetStmt :: Binds -> Stmt Source #

pattern RecStmt :: [Stmt] -> Stmt Source #

type PatField = PatField () Source #

pattern PFieldPat :: QName -> Pat -> PatField Source #

pattern PFieldPun :: QName -> PatField Source #

pattern PFieldWildcard :: PatField Source #

type RPat = RPat () Source #

pattern RPOp :: RPat -> RPatOp -> RPat Source #

pattern RPEither :: RPat -> RPat -> RPat Source #

pattern RPSeq :: [RPat] -> RPat Source #

pattern RPGuard :: Pat -> [Stmt] -> RPat Source #

pattern RPCAs :: Name -> RPat -> RPat Source #

pattern RPAs :: Name -> RPat -> RPat Source #

pattern RPParen :: RPat -> RPat Source #

pattern RPPat :: Pat -> RPat Source #

type RPatOp = RPatOp () Source #

pattern RPStar :: RPatOp Source #

pattern RPStarG :: RPatOp Source #

pattern RPPlus :: RPatOp Source #

pattern RPPlusG :: RPatOp Source #

pattern RPOpt :: RPatOp Source #

pattern RPOptG :: RPatOp Source #

type PXAttr = PXAttr () Source #

pattern PXAttr :: XName -> Pat -> PXAttr Source #

type Pat = Pat () Source #

pattern PVar :: Name -> Pat Source #

pattern PLit :: Sign -> Literal -> Pat Source #

pattern PNPlusK :: Name -> Integer -> Pat Source #

pattern PInfixApp :: Pat -> QName -> Pat -> Pat Source #

pattern PApp :: QName -> [Pat] -> Pat Source #

pattern PTuple :: Boxed -> [Pat] -> Pat Source #

pattern PUnboxedSum :: Int -> Int -> Pat -> Pat Source #

pattern PList :: [Pat] -> Pat Source #

pattern PParen :: Pat -> Pat Source #

pattern PRec :: QName -> [PatField] -> Pat Source #

pattern PAsPat :: Name -> Pat -> Pat Source #

pattern PWildCard :: Pat Source #

pattern PIrrPat :: Pat -> Pat Source #

pattern PatTypeSig :: Pat -> Type -> Pat Source #

pattern PViewPat :: Exp -> Pat -> Pat Source #

pattern PRPat :: [RPat] -> Pat Source #

pattern PXTag :: XName -> [PXAttr] -> Maybe Pat -> [Pat] -> Pat Source #

pattern PXETag :: XName -> [PXAttr] -> Maybe Pat -> Pat Source #

pattern PXPcdata :: String -> Pat Source #

pattern PXPatTag :: Pat -> Pat Source #

pattern PXRPats :: [RPat] -> Pat Source #

pattern PSplice :: Splice -> Pat Source #

pattern PQuasiQuote :: String -> String -> Pat Source #

pattern PBangPat :: Pat -> Pat Source #

type WarningText = WarningText () Source #

pattern DeprText :: String -> WarningText Source #

pattern WarnText :: String -> WarningText Source #

type RuleVar = RuleVar () Source #

pattern RuleVar :: Name -> RuleVar Source #

pattern TypedRuleVar :: Name -> Type -> RuleVar Source #

type Rule = Rule () Source #

pattern Rule :: String -> Maybe Activation -> Maybe [RuleVar] -> Exp -> Exp -> Rule Source #

type Activation = Activation () Source #

pattern ActiveFrom :: Int -> Activation Source #

pattern ActiveUntil :: Int -> Activation Source #

type Overlap = Overlap () Source #

pattern Overlap :: Overlap Source #

pattern NoOverlap :: Overlap Source #

pattern Overlapping :: Overlap Source #

pattern Overlaps :: Overlap Source #

pattern Overlappable :: Overlap Source #

pattern Incoherent :: Overlap Source #

type ModulePragma = ModulePragma () Source #

pattern LanguagePragma :: [Name] -> ModulePragma Source #

pattern OptionsPragma :: Maybe Tool -> String -> ModulePragma Source #

pattern AnnModulePragma :: Annotation -> ModulePragma Source #

type CallConv = CallConv () Source #

pattern StdCall :: CallConv Source #

pattern CCall :: CallConv Source #

pattern CPlusPlus :: CallConv Source #

pattern DotNet :: CallConv Source #

pattern Jvm :: CallConv Source #

pattern Js :: CallConv Source #

pattern JavaScript :: CallConv Source #

pattern CApi :: CallConv Source #

type Safety = Safety () Source #

pattern PlayRisky :: Safety Source #

pattern PlaySafe :: Bool -> Safety Source #

pattern PlayInterruptible :: Safety Source #

type Splice = Splice () Source #

pattern IdSplice :: String -> Splice Source #

pattern TIdSplice :: String -> Splice Source #

pattern ParenSplice :: Exp -> Splice Source #

pattern TParenSplice :: Exp -> Splice Source #

type Bracket = Bracket () Source #

pattern ExpBracket :: Exp -> Bracket Source #

pattern TExpBracket :: Exp -> Bracket Source #

pattern PatBracket :: Pat -> Bracket Source #

pattern TypeBracket :: Type -> Bracket Source #

pattern DeclBracket :: [Decl] -> Bracket Source #

type XAttr = XAttr () Source #

pattern XAttr :: XName -> Exp -> XAttr Source #

type XName = XName () Source #

pattern XName :: String -> XName Source #

pattern XDomName :: String -> String -> XName Source #

type Exp = Exp () Source #

pattern Var :: QName -> Exp Source #

pattern OverloadedLabel :: String -> Exp Source #

pattern IPVar :: IPName -> Exp Source #

pattern Lit :: Literal -> Exp Source #

pattern InfixApp :: Exp -> QOp -> Exp -> Exp Source #

pattern NegApp :: Exp -> Exp Source #

pattern Lambda :: [Pat] -> Exp -> Exp Source #

pattern Let :: Binds -> Exp -> Exp Source #

pattern MultiIf :: [GuardedRhs] -> Exp Source #

pattern Case :: Exp -> [Alt] -> Exp Source #

pattern Do :: [Stmt] -> Exp Source #

pattern MDo :: [Stmt] -> Exp Source #

pattern Tuple :: Boxed -> [Exp] -> Exp Source #

pattern UnboxedSum :: Int -> Int -> Exp -> Exp Source #

pattern TupleSection :: Boxed -> [Maybe Exp] -> Exp Source #

pattern ParArray :: [Exp] -> Exp Source #

pattern Paren :: Exp -> Exp Source #

pattern LeftSection :: Exp -> QOp -> Exp Source #

pattern RightSection :: QOp -> Exp -> Exp Source #

pattern RecConstr :: QName -> [FieldUpdate] -> Exp Source #

pattern RecUpdate :: Exp -> [FieldUpdate] -> Exp Source #

pattern EnumFrom :: Exp -> Exp Source #

pattern EnumFromTo :: Exp -> Exp -> Exp Source #

pattern EnumFromThen :: Exp -> Exp -> Exp Source #

pattern EnumFromThenTo :: Exp -> Exp -> Exp -> Exp Source #

pattern ParArrayFromTo :: Exp -> Exp -> Exp Source #

pattern ParArrayFromThenTo :: Exp -> Exp -> Exp -> Exp Source #

pattern ListComp :: Exp -> [QualStmt] -> Exp Source #

pattern ParComp :: Exp -> [[QualStmt]] -> Exp Source #

pattern ParArrayComp :: Exp -> [[QualStmt]] -> Exp Source #

pattern ExpTypeSig :: Exp -> Type -> Exp Source #

pattern VarQuote :: QName -> Exp Source #

pattern TypQuote :: QName -> Exp Source #

pattern BracketExp :: Bracket -> Exp Source #

pattern SpliceExp :: Splice -> Exp Source #

pattern QuasiQuote :: String -> String -> Exp Source #

pattern TypeApp :: Type -> Exp Source #

pattern XTag :: XName -> [XAttr] -> Maybe Exp -> [Exp] -> Exp Source #

pattern XETag :: XName -> [XAttr] -> Maybe Exp -> Exp Source #

pattern XPcdata :: String -> Exp Source #

pattern XExpTag :: Exp -> Exp Source #

pattern XChildTag :: [Exp] -> Exp Source #

pattern CorePragma :: String -> Exp -> Exp Source #

pattern SCCPragma :: String -> Exp -> Exp Source #

pattern GenPragma :: String -> (Int, Int) -> (Int, Int) -> Exp -> Exp Source #

pattern Proc :: Pat -> Exp -> Exp Source #

pattern LeftArrApp :: Exp -> Exp -> Exp Source #

pattern RightArrApp :: Exp -> Exp -> Exp Source #

pattern LeftArrHighApp :: Exp -> Exp -> Exp Source #

pattern RightArrHighApp :: Exp -> Exp -> Exp Source #

pattern ArrOp :: Exp -> Exp Source #

pattern LCase :: [Alt] -> Exp Source #

type Sign = Sign () Source #

pattern Signless :: Sign Source #

pattern Negative :: Sign Source #

type Literal = Literal () Source #

pattern Frac :: Rational -> Literal Source #

pattern PrimInt :: Integer -> Literal Source #

pattern PrimWord :: Integer -> Literal Source #

pattern PrimFloat :: Rational -> Literal Source #

pattern PrimDouble :: Rational -> Literal Source #

pattern PrimChar :: Char -> Literal Source #

pattern PrimString :: String -> Literal Source #

type Asst = Asst () Source #

pattern TypeA :: Type -> Asst Source #

pattern IParam :: IPName -> Type -> Asst Source #

pattern ParenA :: Asst -> Asst Source #

type Context = Context () Source #

pattern CxSingle :: Asst -> Context Source #

pattern CxTuple :: [Asst] -> Context Source #

pattern CxEmpty :: Context Source #

type FunDep = FunDep () Source #

pattern FunDep :: [Name] -> [Name] -> FunDep Source #

type Kind = Kind () Source #

Note that `Kind` is an alias for `Type` since haskell-src-exts-1.21.

type TyVarBind = TyVarBind () Source #

pattern KindedVar :: Name -> Kind -> TyVarBind Source #

pattern UnkindedVar :: Name -> TyVarBind Source #

type Promoted = Promoted () Source #

pattern PromotedInteger :: Integer -> String -> Promoted Source #

pattern PromotedString :: String -> String -> Promoted Source #

pattern PromotedCon :: Bool -> QName -> Promoted Source #

pattern PromotedList :: Bool -> [Type] -> Promoted Source #

pattern PromotedTuple :: [Type] -> Promoted Source #

pattern PromotedUnit :: Promoted Source #

type MaybePromotedName = MaybePromotedName () Source #

pattern PromotedName :: QName -> MaybePromotedName Source #

pattern UnpromotedName :: QName -> MaybePromotedName Source #

pattern TyForall :: Maybe [TyVarBind] -> Maybe Context -> Type -> Type Source #

pattern TyStar :: Type Source #

pattern TyFun :: Type -> Type -> Type Source #

pattern TyTuple :: Boxed -> [Type] -> Type Source #

pattern TyUnboxedSum :: [Type] -> Type Source #

pattern TyList :: Type -> Type Source #

pattern TyParArray :: Type -> Type Source #

pattern TyApp :: Type -> Type -> Type Source #

pattern TyVar :: Name -> Type Source #

pattern TyParen :: Type -> Type Source #

pattern TyInfix :: Type -> MaybePromotedName -> Type -> Type Source #

pattern TyKind :: Type -> Kind -> Type Source #

pattern TyPromoted :: Promoted -> Type Source #

pattern TyEquals :: Type -> Type -> Type Source #

pattern TySplice :: Splice -> Type Source #

pattern TyBang :: BangType -> Unpackedness -> Type -> Type Source #

pattern TyWildCard :: Maybe Name -> Type Source #

pattern TyQuasiQuote :: String -> String -> Type Source #

type GuardedRhs = GuardedRhs () Source #

pattern GuardedRhs :: [Stmt] -> Exp -> GuardedRhs Source #

type Rhs = Rhs () Source #

pattern UnGuardedRhs :: Exp -> Rhs Source #

pattern GuardedRhss :: [GuardedRhs] -> Rhs Source #

type Unpackedness = Unpackedness () Source #

pattern Unpack :: Unpackedness Source #

pattern NoUnpack :: Unpackedness Source #

pattern NoUnpackPragma :: Unpackedness Source #

type BangType = BangType () Source #

pattern BangedTy :: BangType Source #

pattern LazyTy :: BangType Source #

pattern NoStrictAnnot :: BangType Source #

type InstDecl = InstDecl () Source #

pattern InstDecl :: Maybe Overlap -> InstRule -> Maybe [InstDecl] -> Decl Source #

pattern InsDecl :: Decl -> InstDecl Source #

pattern InsType :: Type -> Type -> InstDecl Source #

pattern InsData :: DataOrNew -> Type -> [QualConDecl] -> [Deriving] -> InstDecl Source #

pattern InsGData :: DataOrNew -> Type -> Maybe Kind -> [GadtDecl] -> [Deriving] -> InstDecl Source #

type ClassDecl = ClassDecl () Source #

pattern ClassDecl :: Maybe Context -> DeclHead -> [FunDep] -> Maybe [ClassDecl] -> Decl Source #

pattern ClsDecl :: Decl -> ClassDecl Source #

pattern ClsDataFam :: Maybe Context -> DeclHead -> Maybe ResultSig -> ClassDecl Source #

pattern ClsTyFam :: DeclHead -> Maybe ResultSig -> Maybe InjectivityInfo -> ClassDecl Source #

pattern ClsTyDef :: TypeEqn -> ClassDecl Source #

pattern ClsDefSig :: Name -> Type -> ClassDecl Source #

type GadtDecl = GadtDecl () Source #

pattern GadtDecl :: Name -> Maybe [TyVarBind] -> Maybe Context -> Maybe [FieldDecl] -> Type -> GadtDecl Source #

type FieldDecl = FieldDecl () Source #

pattern FieldDecl :: [Name] -> Type -> FieldDecl Source #

type ConDecl = ConDecl () Source #

pattern ConDecl :: Name -> [Type] -> ConDecl Source #

pattern InfixConDecl :: Type -> Name -> Type -> ConDecl Source #

pattern RecDecl :: Name -> [FieldDecl] -> ConDecl Source #

type QualConDecl = QualConDecl () Source #

pattern QualConDecl :: Maybe [TyVarBind] -> Maybe Context -> ConDecl -> QualConDecl Source #

type Match = Match () Source #

pattern Match :: Name -> [Pat] -> Rhs -> Maybe Binds -> Match Source #

pattern InfixMatch :: Pat -> Name -> [Pat] -> Rhs -> Maybe Binds -> Match Source #

type IPBind = IPBind () Source #

pattern IPBind :: IPName -> Exp -> IPBind Source #

type Binds = Binds () Source #

pattern BDecls :: [Decl] -> Binds Source #

pattern IPBinds :: [IPBind] -> Binds Source #

type DerivStrategy = DerivStrategy () Source #

pattern DerivStock :: DerivStrategy Source #

pattern DerivAnyclass :: DerivStrategy Source #

pattern DerivNewtype :: DerivStrategy Source #

pattern DerivVia :: Type -> DerivStrategy Source #

type Deriving = Deriving () Source #

pattern Deriving :: Maybe DerivStrategy -> [InstRule] -> Deriving Source #

type InstHead = InstHead () Source #

pattern IHCon :: QName -> InstHead Source #

pattern IHInfix :: Type -> QName -> InstHead Source #

pattern IHParen :: InstHead -> InstHead Source #

pattern IHApp :: InstHead -> Type -> InstHead Source #

type InstRule = InstRule () Source #

pattern IRule :: Maybe [TyVarBind] -> Maybe Context -> InstHead -> InstRule Source #

pattern IParen :: InstRule -> InstRule Source #

type DeclHead = DeclHead () Source #

pattern DHead :: Name -> DeclHead Source #

pattern DHInfix :: TyVarBind -> Name -> DeclHead Source #

pattern DHParen :: DeclHead -> DeclHead Source #

pattern DHApp :: DeclHead -> TyVarBind -> DeclHead Source #

type ResultSig = ResultSig () Source #

pattern KindSig :: Kind -> ResultSig Source #

pattern TyVarSig :: TyVarBind -> ResultSig Source #

type InjectivityInfo = InjectivityInfo () Source #

pattern InjectivityInfo :: Name -> [Name] -> InjectivityInfo Source #

type DataOrNew = DataOrNew () Source #

pattern NewType :: DataOrNew Source #

type Role = Role () Source #

pattern Nominal :: Role Source #

pattern Representational :: Role Source #

pattern Phantom :: Role Source #

pattern RoleWildcard :: Role Source #

type BooleanFormula = BooleanFormula () Source #

pattern VarFormula :: Name -> BooleanFormula Source #

pattern AndFormula :: [BooleanFormula] -> BooleanFormula Source #

pattern OrFormula :: [BooleanFormula] -> BooleanFormula Source #

pattern ParenFormula :: BooleanFormula -> BooleanFormula Source #

type Annotation = Annotation () Source #

pattern Ann :: Name -> Exp -> Annotation Source #

pattern TypeAnn :: Name -> Exp -> Annotation Source #

pattern ModuleAnn :: Exp -> Annotation Source #

type TypeEqn = TypeEqn () Source #

pattern TypeEqn :: Type -> Type -> TypeEqn Source #

type PatternSynDirection = PatternSynDirection () Source #

pattern Unidirectional :: PatternSynDirection Source #

pattern ImplicitBidirectional :: PatternSynDirection Source #

pattern ExplicitBidirectional :: [Decl] -> PatternSynDirection Source #

type Decl = Decl () Source #

pattern TypeDecl :: DeclHead -> Type -> Decl Source #

pattern TypeFamDecl :: DeclHead -> Maybe ResultSig -> Maybe InjectivityInfo -> Decl Source #

pattern ClosedTypeFamDecl :: DeclHead -> Maybe ResultSig -> Maybe InjectivityInfo -> [TypeEqn] -> Decl Source #

pattern DataDecl :: DataOrNew -> Maybe Context -> DeclHead -> [QualConDecl] -> [Deriving] -> Decl Source #

pattern GDataDecl :: DataOrNew -> Maybe Context -> DeclHead -> Maybe Kind -> [GadtDecl] -> [Deriving] -> Decl Source #

pattern DataFamDecl :: Maybe Context -> DeclHead -> Maybe ResultSig -> Decl Source #

pattern TypeInsDecl :: Type -> Type -> Decl Source #

pattern DataInsDecl :: DataOrNew -> Type -> [QualConDecl] -> [Deriving] -> Decl Source #

pattern GDataInsDecl :: DataOrNew -> Type -> Maybe Kind -> [GadtDecl] -> [Deriving] -> Decl Source #

pattern DerivDecl :: Maybe DerivStrategy -> Maybe Overlap -> InstRule -> Decl Source #

pattern InfixDecl :: Assoc -> Maybe Int -> [Op] -> Decl Source #

pattern DefaultDecl :: [Type] -> Decl Source #

pattern SpliceDecl :: Exp -> Decl Source #

pattern TSpliceDecl :: Exp -> Decl Source #

pattern TypeSig :: [Name] -> Type -> Decl Source #

pattern PatSynSig :: [Name] -> Maybe [TyVarBind] -> Maybe Context -> Maybe [TyVarBind] -> Maybe Context -> Type -> Decl Source #

pattern FunBind :: [Match] -> Decl Source #

pattern PatBind :: Pat -> Rhs -> Maybe Binds -> Decl Source #

pattern PatSyn :: Pat -> Pat -> PatternSynDirection -> Decl Source #

pattern ForImp :: CallConv -> Maybe Safety -> Maybe String -> Name -> Type -> Decl Source #

pattern ForExp :: CallConv -> Maybe String -> Name -> Type -> Decl Source #

pattern RulePragmaDecl :: [Rule] -> Decl Source #

pattern DeprPragmaDecl :: [([Name], String)] -> Decl Source #

pattern WarnPragmaDecl :: [([Name], String)] -> Decl Source #

pattern InlineSig :: Bool -> Maybe Activation -> QName -> Decl Source #

pattern InlineConlikeSig :: Maybe Activation -> QName -> Decl Source #

pattern SpecSig :: Maybe Activation -> QName -> [Type] -> Decl Source #

pattern SpecInlineSig :: Bool -> Maybe Activation -> QName -> [Type] -> Decl Source #

pattern InstSig :: InstRule -> Decl Source #

pattern AnnPragma :: Annotation -> Decl Source #

pattern MinimalPragma :: Maybe BooleanFormula -> Decl Source #

pattern RoleAnnotDecl :: QName -> [Role] -> Decl Source #

pattern CompletePragma :: [Name] -> Maybe QName -> Decl Source #

type Assoc = Assoc () Source #

pattern AssocNone :: Assoc Source #

pattern AssocLeft :: Assoc Source #

pattern AssocRight :: Assoc Source #

type ImportSpec = ImportSpec () Source #

pattern IVar :: Name -> ImportSpec Source #

pattern IAbs :: Namespace -> Name -> ImportSpec Source #

pattern IThingAll :: Name -> ImportSpec Source #

pattern IThingWith :: Name -> [CName] -> ImportSpec Source #

type ImportSpecList = ImportSpecList () Source #

pattern ImportSpecList :: Bool -> [ImportSpec] -> ImportSpecList Source #

type ImportDecl = ImportDecl () Source #

pattern ImportDecl :: ModuleName () -> Bool -> Bool -> Bool -> Maybe String -> Maybe (ModuleName ()) -> Maybe (ImportSpecList ()) -> ImportDecl Source #

importSpecs :: ImportDecl -> Maybe (ImportSpecList ()) Source #

importAs :: ImportDecl -> Maybe (ModuleName ()) Source #

importPkg :: ImportDecl -> Maybe String Source #

importSafe :: ImportDecl -> Bool Source #

importSrc :: ImportDecl -> Bool Source #

importQualified :: ImportDecl -> Bool Source #

importModule :: ImportDecl -> ModuleName () Source #

type Namespace = Namespace () Source #

pattern NoNamespace :: Namespace Source #

pattern TypeNamespace :: Namespace Source #

pattern PatternNamespace :: Namespace Source #

type EWildcard = EWildcard () Source #

pattern EWildcard :: Int -> EWildcard Source #

pattern NoWildcard :: EWildcard Source #

type ExportSpec = ExportSpec () Source #

pattern EVar :: QName -> ExportSpec Source #

pattern EAbs :: Namespace -> QName -> ExportSpec Source #

pattern EThingWith :: EWildcard -> QName -> [CName] -> ExportSpec Source #

pattern EModuleContents :: ModuleName -> ExportSpec Source #

type ExportSpecList = ExportSpecList () Source #

pattern ExportSpecList :: [ExportSpec] -> ExportSpecList Source #

type ModuleHead = ModuleHead () Source #

pattern ModuleHead :: ModuleName -> Maybe WarningText -> Maybe ExportSpecList -> ModuleHead Source #

pattern XmlPage :: ModuleName -> [ModulePragma] -> XName -> [XAttr] -> Maybe Exp -> [Exp] -> Module Source #

pattern XmlHybrid :: Maybe ModuleHead -> [ModulePragma] -> [ImportDecl] -> [Decl] -> XName -> [XAttr] -> Maybe Exp -> [Exp] -> Module Source #

type CName = CName () Source #

pattern VarName :: Name -> CName Source #

pattern ConName :: Name -> CName Source #

pattern VarOp :: Name -> Op Source #

pattern ConOp :: Name -> Op Source #

type QOp = QOp () Source #

pattern QVarOp :: QName -> QOp Source #

pattern QConOp :: QName -> QOp Source #

type IPName = IPName () Source #

pattern IPDup :: String -> IPName Source #

pattern IPLin :: String -> IPName Source #

type Name = Name () Source #

type QName = QName () Source #

pattern Qual :: ModuleName -> Name -> QName Source #

pattern UnQual :: Name -> QName Source #

pattern Special :: SpecialCon -> QName Source #

type SpecialCon = SpecialCon () Source #

pattern UnitCon :: SpecialCon Source #

pattern ListCon :: SpecialCon Source #

pattern FunCon :: SpecialCon Source #

pattern TupleCon :: Boxed -> Int -> SpecialCon Source #

pattern Cons :: SpecialCon Source #

pattern UnboxedSingleCon :: SpecialCon Source #

pattern ExprHole :: SpecialCon Source #

type ModuleName = ModuleName () Source #

pattern ModuleName :: String -> ModuleName Source #

prelude_mod :: ModuleName Source #

main_mod :: ModuleName Source #

main_name :: Name Source #

unit_con_name :: QName Source #

tuple_con_name :: Boxed -> Int -> QName Source #

list_con_name :: QName Source #

list_cons_name :: QName Source #

unboxed_singleton_con_name :: QName Source #

unit_con :: Exp Source #

tuple_con :: Boxed -> Int -> Exp Source #

unboxed_singleton_con :: Exp Source #

as_name :: Name Source #

qualified_name :: Name Source #

hiding_name :: Name Source #

minus_name :: Name Source #

bang_name :: Name Source #

dot_name :: Name Source #

star_name :: Name Source #

hole_name :: QName Source #

export_name :: Name Source #

safe_name :: Name Source #

unsafe_name :: Name Source #

interruptible_name :: Name Source #

threadsafe_name :: Name Source #

stdcall_name :: Name Source #

ccall_name :: Name Source #

cplusplus_name :: Name Source #

dotnet_name :: Name Source #

jvm_name :: Name Source #

js_name :: Name Source #

javascript_name :: Name Source #

capi_name :: Name Source #

forall_name :: Name Source #

family_name :: Name Source #

role_name :: Name Source #

stock_name :: Name Source #

anyclass_name :: Name Source #

via_name :: Name Source #

unit_tycon_name :: QName Source #

fun_tycon_name :: QName Source #

list_tycon_name :: QName Source #

unboxed_singleton_tycon_name :: QName Source #

tuple_tycon_name :: Boxed -> Int -> QName Source #

unit_tycon :: Type Source #

fun_tycon :: Type Source #

list_tycon :: Type Source #

unboxed_singleton_tycon :: Type Source #

tuple_tycon :: Boxed -> Int -> Type Source #

charL :: Char -> Literal Source #

stringL :: String -> Literal Source #

intL :: Integer -> Literal Source #

fracL :: Rational -> Literal Source #

primIntL :: Integer -> Literal Source #

primWordL :: Integer -> Literal Source #

primFloatL :: Rational -> Literal Source #

primDoubleL :: Rational -> Literal Source #

primCharL :: Char -> Literal Source #

primStringL :: String -> Literal Source #

data Tool Source #

Recognised tools for OPTIONS pragmas.

Constructors

GHC |
HUGS |
NHC98 |
YHC |
HADDOCK |
UnknownTool String |

#### Instances

Instances details

Data Tool |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Tool -> c Tool Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Tool Source #

toConstr :: Tool -> Constr Source #

dataTypeOf :: Tool -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Tool) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Tool) Source #

gmapT :: (forall b. Data b => b -> b) -> Tool -> Tool Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tool -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tool -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Tool -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Tool -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Tool -> m Tool Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Tool -> m Tool Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Tool -> m Tool Source #

Generic Tool |

Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep Tool |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep Tool = D1 ('MetaData "Tool" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-3xHB6MViBk95bvXB6vMLW9" 'False) ((C1 ('MetaCons "GHC" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "HUGS" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "NHC98" 'PrefixI 'False) (U1 :: Type -> Type))) :+: (C1 ('MetaCons "YHC" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "HADDOCK" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "UnknownTool" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String)))))

Methods

from :: Tool -> Rep Tool x Source #

to :: Rep Tool x -> Tool Source #

Show Tool |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> Tool -> ShowS Source # show :: Tool -> String Source # showList :: [Tool] -> ShowS Source #
Eq Tool |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: Tool -> Tool -> Bool Source # (/=) :: Tool -> Tool -> Bool Source #
Ord Tool |
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: Tool -> Tool -> Ordering Source # (<) :: Tool -> Tool -> Bool Source # (<=) :: Tool -> Tool -> Bool Source # (>) :: Tool -> Tool -> Bool Source # (>=) :: Tool -> Tool -> Bool Source # max :: Tool -> Tool -> Tool Source # min :: Tool -> Tool -> Tool Source #
Pretty Tool |
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: Tool -> Doc prettyPrec :: Int -> Tool -> Doc
type Rep Tool |

Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep Tool = D1 ('MetaData "Tool" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-3xHB6MViBk95bvXB6vMLW9" 'False) ((C1 ('MetaCons "GHC" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "HUGS" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "NHC98" 'PrefixI 'False) (U1 :: Type -> Type))) :+: (C1 ('MetaCons "YHC" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "HADDOCK" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "UnknownTool" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String)))))

data Boxed Source #

Flag denoting whether a tuple is boxed or unboxed.

Constructors

Boxed |
Unboxed |

#### Instances

Instances details

Data Boxed |

Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Boxed -> c Boxed Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Boxed Source #

toConstr :: Boxed -> Constr Source #

dataTypeOf :: Boxed -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Boxed) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Boxed) Source #

gmapT :: (forall b. Data b => b -> b) -> Boxed -> Boxed Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Boxed -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Boxed -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Boxed -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Boxed -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Boxed -> m Boxed Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Boxed -> m Boxed Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Boxed -> m Boxed Source #

Generic Boxed |

Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep Boxed |
Instance details Defined in Language.Haskell.Exts.Syntax type Rep Boxed = D1 ('MetaData "Boxed" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-3xHB6MViBk95bvXB6vMLW9" 'False) (C1 ('MetaCons "Boxed" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Unboxed" 'PrefixI 'False) (U1 :: Type -> Type))

Methods

from :: Boxed -> Rep Boxed x Source #

to :: Rep Boxed x -> Boxed Source #

Show Boxed |
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> Boxed -> ShowS Source # show :: Boxed -> String Source # showList :: [Boxed] -> ShowS Source #
Eq Boxed |
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: Boxed -> Boxed -> Bool Source # (/=) :: Boxed -> Boxed -> Bool Source #
Ord Boxed |
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: Boxed -> Boxed -> Ordering Source # (<) :: Boxed -> Boxed -> Bool Source # (<=) :: Boxed -> Boxed -> Bool Source # (>) :: Boxed -> Boxed -> Bool Source # (>=) :: Boxed -> Boxed -> Bool Source # max :: Boxed -> Boxed -> Boxed Source # min :: Boxed -> Boxed -> Boxed Source #
type Rep Boxed |
Instance details Defined in Language.Haskell.Exts.Syntax type Rep Boxed = D1 ('MetaData "Boxed" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-3xHB6MViBk95bvXB6vMLW9" 'False) (C1 ('MetaCons "Boxed" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Unboxed" 'PrefixI 'False) (U1 :: Type -> Type))