Language.Haskell.Exts.Simple.Syntax

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

This works nicely for all datatypes with two exception:

• ImportDecl has a record constructor. Record type synonyms are only supported ghc-8.0 and later, so for ghc-7.10 and earlier, the constructor is exported as a plain constructor, and the record fields as function.
• Literal has constructors with an extra String argument that is not used by Pretty. This module uses explicitly bidirectional pattern synonyms to support this type, but support for that is only available in ghc-7.10 and later.

IMPORTANT: if you require compatiblity with ghc 7.8, you should use the functions charL, stringL etc. for constructing Literal values!

Datatypes and Constructors

ModuleName

type ModuleName = ModuleName ()

pattern ModuleName :: String -> ModuleName

SpecialCon

type SpecialCon = SpecialCon ()

pattern UnitCon :: SpecialCon

pattern ListCon :: SpecialCon

pattern FunCon :: SpecialCon

pattern TupleCon :: Boxed -> Int -> SpecialCon

pattern Cons :: SpecialCon

pattern UnboxedSingleCon :: SpecialCon

QName

type QName = QName ()

pattern Qual :: ModuleName -> Name -> QName

pattern UnQual :: Name -> QName

pattern Special :: SpecialCon -> QName

Name

type Name = Name ()

pattern Ident :: String -> Name

pattern Symbol :: String -> Name

IPName

type IPName = IPName ()

pattern IPDup :: String -> IPName

pattern IPLin :: String -> IPName

QOp

type QOp = QOp ()

pattern QVarOp :: QName -> QOp

pattern QConOp :: QName -> QOp

Op

type Op = Op ()

pattern VarOp :: Name -> Op

pattern ConOp :: Name -> Op

CName

type CName = CName ()

pattern VarName :: Name -> CName

pattern ConName :: Name -> CName

Module

type Module = Module ()

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

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

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

ModuleHead

type ModuleHead = ModuleHead ()

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

ExportSpecList

type ExportSpecList = ExportSpecList ()

pattern ExportSpecList :: [ExportSpec] -> ExportSpecList

ExportSpec

type ExportSpec = ExportSpec ()

pattern EVar :: QName -> ExportSpec

pattern EAbs :: Namespace -> QName -> ExportSpec

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

pattern EModuleContents :: ModuleName -> ExportSpec

EWildcard

type EWildcard = EWildcard ()

pattern NoWildcard :: EWildcard

pattern EWildcard :: Int -> EWildcard

Namespace

type Namespace = Namespace ()

pattern NoNamespace :: Namespace

pattern TypeNamespace :: Namespace

pattern PatternNamespace :: Namespace

ImportDecl

type ImportDecl = ImportDecl ()

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

Note, this is originally a record constructor, and we use a pattern record synonym for ghc-8.0. But for earlier ghc versions, ImportDecl is a plain pattern synonym, and the selectors are exported as functions.

ImportSpecList

type ImportSpecList = ImportSpecList ()

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

ImportSpec

type ImportSpec = ImportSpec ()

pattern IVar :: Name -> ImportSpec

pattern IAbs :: Namespace -> Name -> ImportSpec

pattern IThingAll :: Name -> ImportSpec

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

Assoc

type Assoc = Assoc ()

pattern AssocNone :: Assoc

pattern AssocLeft :: Assoc

pattern AssocRight :: Assoc

Decl

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] -> Maybe Deriving -> Decl

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

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

pattern TypeInsDecl :: Type -> Type -> Decl

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

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

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

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

pattern DerivDecl :: Maybe Overlap -> InstRule -> Decl

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

pattern DefaultDecl :: [Type] -> Decl

pattern SpliceDecl :: Exp -> Decl

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

pattern PatSynSig :: Name -> Maybe [TyVarBind] -> Maybe Context -> 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

PatternSynDirection

type PatternSynDirection = PatternSynDirection ()

pattern Unidirectional :: PatternSynDirection

pattern ImplicitBidirectional :: PatternSynDirection

pattern ExplicitBidirectional :: [Decl] -> PatternSynDirection

TypeEqn

type TypeEqn = TypeEqn ()

pattern TypeEqn :: Type -> Type -> TypeEqn

Annotation

type Annotation = Annotation ()

pattern Ann :: Name -> Exp -> Annotation

pattern TypeAnn :: Name -> Exp -> Annotation

pattern ModuleAnn :: Exp -> Annotation

BooleanFormula

type BooleanFormula = BooleanFormula ()

pattern VarFormula :: Name -> BooleanFormula

pattern AndFormula :: [BooleanFormula] -> BooleanFormula

pattern OrFormula :: [BooleanFormula] -> BooleanFormula

pattern ParenFormula :: BooleanFormula -> BooleanFormula

Role

type Role = Role ()

pattern Nominal :: Role

pattern Representational :: Role

pattern Phantom :: Role

pattern RoleWildcard :: Role

DataOrNew

type DataOrNew = DataOrNew ()

pattern DataType :: DataOrNew

pattern NewType :: DataOrNew

InjectivityInfo

type InjectivityInfo = InjectivityInfo ()

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

ResultSig

type ResultSig = ResultSig ()

pattern KindSig :: Kind -> ResultSig

pattern TyVarSig :: TyVarBind -> ResultSig

DeclHead

type DeclHead = DeclHead ()

pattern DHead :: Name -> DeclHead

pattern DHInfix :: TyVarBind -> Name -> DeclHead

pattern DHParen :: DeclHead -> DeclHead

pattern DHApp :: DeclHead -> TyVarBind -> DeclHead

InstRule

type InstRule = InstRule ()

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

pattern IParen :: InstRule -> InstRule

InstHead

type InstHead = InstHead ()

pattern IHCon :: QName -> InstHead

pattern IHInfix :: Type -> QName -> InstHead

pattern IHParen :: InstHead -> InstHead

pattern IHApp :: InstHead -> Type -> InstHead

Deriving

type Deriving = Deriving ()

pattern Deriving :: [InstRule] -> Deriving

Binds

type Binds = Binds ()

pattern BDecls :: [Decl] -> Binds

pattern IPBinds :: [IPBind] -> Binds

IPBind

type IPBind = IPBind ()

pattern IPBind :: IPName -> Exp -> IPBind

Match

type Match = Match ()

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

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

QualConDecl

type QualConDecl = QualConDecl ()

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

ConDecl

type ConDecl = ConDecl ()

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

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

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

FieldDecl

type FieldDecl = FieldDecl ()

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

GadtDecl

type GadtDecl = GadtDecl ()

pattern GadtDecl :: Name -> Maybe [FieldDecl] -> Type -> GadtDecl

ClassDecl

type ClassDecl = ClassDecl ()

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

InstDecl

type InstDecl = InstDecl ()

pattern InsDecl :: Decl -> InstDecl

pattern InsType :: Type -> Type -> InstDecl

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

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

BangType

type BangType = BangType ()

pattern BangedTy :: BangType

pattern LazyTy :: BangType

pattern NoStrictAnnot :: BangType

Unpackedness

type Unpackedness = Unpackedness ()

pattern Unpack :: Unpackedness

pattern NoUnpack :: Unpackedness

pattern NoUnpackPragma :: Unpackedness

Rhs

type Rhs = Rhs ()

pattern UnGuardedRhs :: Exp -> Rhs

pattern GuardedRhss :: [GuardedRhs] -> Rhs

GuardedRhs

type GuardedRhs = GuardedRhs ()

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

Type

type Type = Type ()

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

pattern TyFun :: Type -> Type -> Type

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

pattern TyList :: Type -> Type

pattern TyParArray :: Type -> Type

pattern TyApp :: Type -> Type -> Type

pattern TyVar :: Name -> Type

pattern TyCon :: QName -> Type

pattern TyParen :: Type -> Type

pattern TyInfix :: Type -> QName -> 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

Promoted

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

TyVarBind

type TyVarBind = TyVarBind ()

pattern KindedVar :: Name -> Kind -> TyVarBind

pattern UnkindedVar :: Name -> TyVarBind

Kind

type Kind = Kind ()

pattern KindStar :: Kind

pattern KindFn :: Kind -> Kind -> Kind

pattern KindParen :: Kind -> Kind

pattern KindVar :: QName -> Kind

pattern KindApp :: Kind -> Kind -> Kind

pattern KindTuple :: [Kind] -> Kind

pattern KindList :: Kind -> Kind

FunDep

type FunDep = FunDep ()

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

Context

type Context = Context ()

pattern CxSingle :: Asst -> Context

pattern CxTuple :: [Asst] -> Context

pattern CxEmpty :: Context

Asst

type Asst = Asst ()

pattern ClassA :: QName -> [Type] -> Asst

pattern AppA :: Name -> [Type] -> Asst

pattern InfixA :: Type -> QName -> Type -> Asst

pattern IParam :: IPName -> Type -> Asst

pattern EqualP :: Type -> Type -> Asst

pattern ParenA :: Asst -> Asst

pattern WildCardA :: Maybe Name -> Asst

Literal

type Literal = Literal ()

Beware that the constructors only work in a pattern context in ghc-7.8, because that version does not support explicitly bidirectional pattern synonyms.

For code that needs to work with ghc-7.8, we provide functions charL, stringL, intL, fracL, etc. for constructing Literal values.

pattern Char :: Char -> Literal

charL :: Char -> Literal

pattern String :: String -> Literal

stringL :: String -> Literal

pattern Int :: Integer -> Literal

intL :: Integer -> Literal

pattern Frac :: Rational -> Literal

fracL :: Rational -> Literal

pattern PrimInt :: Integer -> Literal

primIntL :: Integer -> Literal

pattern PrimWord :: Integer -> Literal

primWordL :: Integer -> Literal

pattern PrimFloat :: Rational -> Literal

primFloatL :: Rational -> Literal

pattern PrimDouble :: Rational -> Literal

primDoubleL :: Rational -> Literal

pattern PrimChar :: Char -> Literal

primCharL :: Char -> Literal

pattern PrimString :: String -> Literal

primStringL :: String -> Literal

Sign

type Sign = Sign ()

pattern Signless :: Sign

pattern Negative :: Sign

Exp

type Exp = Exp ()

pattern Var :: QName -> Exp

pattern OverloadedLabel :: String -> Exp

pattern IPVar :: IPName -> Exp

pattern Con :: QName -> Exp

pattern Lit :: Literal -> Exp

pattern InfixApp :: Exp -> QOp -> Exp -> Exp

pattern App :: Exp -> Exp -> Exp

pattern NegApp :: Exp -> Exp

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

pattern Let :: Binds -> Exp -> Exp

pattern If :: Exp -> Exp -> 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 TupleSection :: Boxed -> [Maybe Exp] -> Exp

pattern List :: [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 LCase :: [Alt] -> Exp

pattern ExprHole :: Exp

XName

type XName = XName ()

pattern XName :: String -> XName

pattern XDomName :: String -> String -> XName

XAttr

type XAttr = XAttr ()

pattern XAttr :: XName -> Exp -> XAttr

Bracket

type Bracket = Bracket ()

pattern ExpBracket :: Exp -> Bracket

pattern PatBracket :: Pat -> Bracket

pattern TypeBracket :: Type -> Bracket

pattern DeclBracket :: [Decl] -> Bracket

Splice

type Splice = Splice ()

pattern IdSplice :: String -> Splice

pattern ParenSplice :: Exp -> Splice

Safety

type Safety = Safety ()

pattern PlayRisky :: Safety

pattern PlaySafe :: Bool -> Safety

pattern PlayInterruptible :: Safety

CallConv

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

ModulePragma

type ModulePragma = ModulePragma ()

pattern LanguagePragma :: [Name] -> ModulePragma

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

pattern AnnModulePragma :: Annotation -> ModulePragma

Overlap

type Overlap = Overlap ()

pattern NoOverlap :: Overlap

pattern Overlap :: Overlap

pattern Incoherent :: Overlap

Activation

type Activation = Activation ()

pattern ActiveFrom :: Int -> Activation

pattern ActiveUntil :: Int -> Activation

Rule

type Rule = Rule ()

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

RuleVar

type RuleVar = RuleVar ()

pattern RuleVar :: Name -> RuleVar

pattern TypedRuleVar :: Name -> Type -> RuleVar

WarningText

type WarningText = WarningText ()

pattern DeprText :: String -> WarningText

pattern WarnText :: String -> WarningText

Pat

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 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 PQuasiQuote :: String -> String -> Pat

pattern PBangPat :: Pat -> Pat

PXAttr

type PXAttr = PXAttr ()

pattern PXAttr :: XName -> Pat -> PXAttr

RPatOp

type RPatOp = RPatOp ()

pattern RPStar :: RPatOp

pattern RPStarG :: RPatOp

pattern RPPlus :: RPatOp

pattern RPPlusG :: RPatOp

pattern RPOpt :: RPatOp

pattern RPOptG :: RPatOp

RPat

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

PatField

type PatField = PatField ()

pattern PFieldPat :: QName -> Pat -> PatField

pattern PFieldPun :: QName -> PatField

pattern PFieldWildcard :: PatField

Stmt

type Stmt = Stmt ()

pattern Generator :: Pat -> Exp -> Stmt

pattern Qualifier :: Exp -> Stmt

pattern LetStmt :: Binds -> Stmt

pattern RecStmt :: [Stmt] -> Stmt

QualStmt

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

FieldUpdate

type FieldUpdate = FieldUpdate ()

pattern FieldUpdate :: QName -> Exp -> FieldUpdate

pattern FieldPun :: QName -> FieldUpdate

pattern FieldWildcard :: FieldUpdate

Alt

type Alt = Alt ()

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

Functions

prelude_mod :: ModuleName

main_mod :: ModuleName

main_name :: Name

unit_con_name :: QName

tuple_con_name :: Boxed -> Int -> 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

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

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

module Language.Haskell.Exts.Syntax