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

Safe HaskellSafe
LanguageHaskell2010

Language.Haskell.Exts.Simple.Syntax

Contents

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

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!

Synopsis

Datatypes and Constructors

ModuleName

SpecialCon

pattern UnitCon :: SpecialCon #

pattern ListCon :: SpecialCon #

pattern FunCon :: SpecialCon #

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

pattern Cons :: 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

ExportSpecList

ExportSpec

pattern EVar :: QName -> ExportSpec #

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

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

EWildcard

pattern EWildcard :: Int -> EWildcard #

Namespace

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

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 TypeInsDecl :: Type -> Type -> Decl #

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

pattern DefaultDecl :: [Type] -> Decl #

pattern SpliceDecl :: Exp -> Decl #

pattern TypeSig :: [Name] -> 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 SpecSig :: Maybe Activation -> QName -> [Type] -> Decl #

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

pattern InstSig :: InstRule -> Decl #

pattern AnnPragma :: Annotation -> Decl #

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

PatternSynDirection

TypeEqn

type TypeEqn = TypeEqn () #

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

Annotation

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

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

pattern ModuleAnn :: Exp -> Annotation #

BooleanFormula

Role

type Role = Role () #

pattern Nominal :: Role #

pattern Phantom :: Role #

pattern RoleWildcard :: Role #

DataOrNew

pattern DataType :: DataOrNew #

pattern NewType :: DataOrNew #

InjectivityInfo

ResultSig

pattern KindSig :: Kind -> 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 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

ConDecl

type ConDecl = ConDecl () #

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

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

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

FieldDecl

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

GadtDecl

type GadtDecl = GadtDecl () #

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

ClassDecl

pattern ClsDecl :: Decl -> ClassDecl #

pattern ClsTyDef :: TypeEqn -> ClassDecl #

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

InstDecl

type InstDecl = InstDecl () #

pattern InsDecl :: Decl -> InstDecl #

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

BangType

type BangType = BangType () #

pattern BangedTy :: BangType #

pattern LazyTy :: BangType #

Unpackedness

pattern Unpack :: Unpackedness #

Rhs

type Rhs = Rhs () #

pattern UnGuardedRhs :: Exp -> Rhs #

pattern GuardedRhss :: [GuardedRhs] -> Rhs #

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 PromotedCon :: Bool -> QName -> Promoted #

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

pattern PromotedTuple :: [Type] -> Promoted #

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 #

pattern String :: String -> Literal #

pattern Int :: Integer -> Literal #

pattern Frac :: Rational -> Literal #

pattern PrimInt :: Integer -> Literal #

pattern PrimWord :: Integer -> Literal #

pattern PrimFloat :: Rational -> Literal #

pattern PrimChar :: Char -> Literal #

pattern PrimString :: 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 #

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

Overlap

type Overlap = Overlap () #

pattern NoOverlap :: Overlap #

pattern Overlap :: Overlap #

pattern Incoherent :: Overlap #

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

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 #

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

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

pattern FieldPun :: QName -> FieldUpdate #

Alt

type Alt = Alt () #

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

Functions