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

Safe HaskellSafe
LanguageHaskell2010

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

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

Documentation

type Alt = Alt () #

type FieldUpdate = FieldUpdate () #

type QualStmt = QualStmt () #

type Stmt = Stmt () #

type PatField = PatField () #

type RPat = RPat () #

type RPatOp = RPatOp () #

type PXAttr = PXAttr () #

type Pat = Pat () #

type WarningText = WarningText () #

type RuleVar = RuleVar () #

type Rule = Rule () #

type Activation = Activation () #

type Overlap = Overlap () #

type ModulePragma = ModulePragma () #

type CallConv = CallConv () #

type Safety = Safety () #

type Splice = Splice () #

type Bracket = Bracket () #

type XAttr = XAttr () #

type XName = XName () #

type Exp = Exp () #

type Sign = Sign () #

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.

type Asst = Asst () #

type Context = Context () #

type FunDep = FunDep () #

type Kind = Kind () #

type TyVarBind = TyVarBind () #

type Promoted = Promoted () #

type MaybePromotedName = MaybePromotedName () #

type Type = Type () #

type GuardedRhs = GuardedRhs () #

type Rhs = Rhs () #

type Unpackedness = Unpackedness () #

type BangType = BangType () #

type InstDecl = InstDecl () #

type ClassDecl = ClassDecl () #

type GadtDecl = GadtDecl () #

type FieldDecl = FieldDecl () #

type ConDecl = ConDecl () #

type QualConDecl = QualConDecl () #

type Match = Match () #

type IPBind = IPBind () #

type Binds = Binds () #

type DerivStrategy = DerivStrategy () #

type Deriving = Deriving () #

type InstHead = InstHead () #

type InstRule = InstRule () #

type DeclHead = DeclHead () #

type ResultSig = ResultSig () #

type InjectivityInfo = InjectivityInfo () #

type DataOrNew = DataOrNew () #

type Role = Role () #

type BooleanFormula = BooleanFormula () #

type Annotation = Annotation () #

type TypeEqn = TypeEqn () #

type PatternSynDirection = PatternSynDirection () #

type Decl = Decl () #

type Assoc = Assoc () #

type ImportSpec = ImportSpec () #

type ImportSpecList = ImportSpecList () #

type ImportDecl = ImportDecl () #

type Namespace = Namespace () #

type EWildcard = EWildcard () #

type ExportSpec = ExportSpec () #

type ExportSpecList = ExportSpecList () #

type ModuleHead = ModuleHead () #

type Module = Module () #

type CName = CName () #

type Op = Op () #

type QOp = QOp () #

type IPName = IPName () #

type Name = Name () #

type QName = QName () #

type SpecialCon = SpecialCon () #

type ModuleName = ModuleName () #

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

pattern FieldWildcard :: FieldUpdate #

pattern FieldPun :: QName -> FieldUpdate #

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

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

pattern GroupUsing :: Exp -> QualStmt #

pattern GroupBy :: Exp -> QualStmt #

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

pattern ThenTrans :: Exp -> QualStmt #

pattern QualStmt :: Stmt -> QualStmt #

pattern RecStmt :: [Stmt] -> Stmt #

pattern LetStmt :: Binds -> Stmt #

pattern Qualifier :: Exp -> Stmt #

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

pattern PFieldWildcard :: PatField #

pattern PFieldPun :: QName -> PatField #

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

pattern RPPat :: Pat -> RPat #

pattern RPParen :: RPat -> RPat #

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

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

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

pattern RPSeq :: [RPat] -> RPat #

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

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

pattern RPOptG :: RPatOp #

pattern RPOpt :: RPatOp #

pattern RPPlusG :: RPatOp #

pattern RPPlus :: RPatOp #

pattern RPStarG :: RPatOp #

pattern RPStar :: RPatOp #

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

pattern PBangPat :: Pat -> Pat #

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

pattern PSplice :: Splice -> Pat #

pattern PXRPats :: [RPat] -> Pat #

pattern PXPatTag :: Pat -> Pat #

pattern PXPcdata :: String -> Pat #

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

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

pattern PRPat :: [RPat] -> Pat #

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

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

pattern PIrrPat :: Pat -> Pat #

pattern PWildCard :: Pat #

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

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

pattern PParen :: Pat -> Pat #

pattern PList :: [Pat] -> Pat #

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

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

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

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

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

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

pattern PVar :: Name -> Pat #

pattern WarnText :: String -> WarningText #

pattern DeprText :: String -> WarningText #

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

pattern RuleVar :: Name -> RuleVar #

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

pattern ActiveUntil :: Int -> Activation #

pattern ActiveFrom :: Int -> Activation #

pattern Incoherent :: Overlap #

pattern Overlappable :: Overlap #

pattern Overlaps :: Overlap #

pattern Overlapping :: Overlap #

pattern Overlap :: Overlap #

pattern NoOverlap :: Overlap #

pattern AnnModulePragma :: Annotation -> ModulePragma #

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

pattern LanguagePragma :: [Name] -> ModulePragma #

pattern CApi :: CallConv #

pattern JavaScript :: CallConv #

pattern Js :: CallConv #

pattern Jvm :: CallConv #

pattern DotNet :: CallConv #

pattern CPlusPlus :: CallConv #

pattern CCall :: CallConv #

pattern StdCall :: CallConv #

pattern PlayInterruptible :: Safety #

pattern PlaySafe :: Bool -> Safety #

pattern PlayRisky :: Safety #

pattern ParenSplice :: Exp -> Splice #

pattern IdSplice :: String -> Splice #

pattern DeclBracket :: [Decl] -> Bracket #

pattern TypeBracket :: Type -> Bracket #

pattern PatBracket :: Pat -> Bracket #

pattern ExpBracket :: Exp -> Bracket #

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

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

pattern XName :: String -> XName #

pattern LCase :: [Alt] -> Exp #

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

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

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

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

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

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

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

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

pattern XChildTag :: [Exp] -> Exp #

pattern XExpTag :: Exp -> Exp #

pattern XPcdata :: String -> Exp #

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

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

pattern TypeApp :: Type -> Exp #

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

pattern SpliceExp :: Splice -> Exp #

pattern BracketExp :: Bracket -> Exp #

pattern TypQuote :: QName -> Exp #

pattern VarQuote :: QName -> Exp #

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

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

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

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

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

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

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

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

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

pattern EnumFrom :: Exp -> Exp #

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

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

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

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

pattern Paren :: Exp -> Exp #

pattern ParArray :: [Exp] -> Exp #

pattern List :: [Exp] -> Exp #

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

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

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

pattern MDo :: [Stmt] -> Exp #

pattern Do :: [Stmt] -> Exp #

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

pattern MultiIf :: [GuardedRhs] -> Exp #

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

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

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

pattern NegApp :: Exp -> Exp #

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

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

pattern Lit :: Literal -> Exp #

pattern Con :: QName -> Exp #

pattern IPVar :: IPName -> Exp #

pattern OverloadedLabel :: String -> Exp #

pattern Var :: QName -> Exp #

pattern Negative :: Sign #

pattern Signless :: Sign #

pattern PrimString :: String -> Literal #

pattern PrimChar :: Char -> Literal #

pattern PrimDouble :: Rational -> Literal #

pattern PrimFloat :: Rational -> Literal #

pattern PrimWord :: Integer -> Literal #

pattern PrimInt :: Integer -> Literal #

pattern Frac :: Rational -> Literal #

pattern Int :: Integer -> Literal #

pattern String :: String -> Literal #

pattern Char :: Char -> Literal #

pattern WildCardA :: Maybe Name -> Asst #

pattern ParenA :: Asst -> Asst #

pattern EqualP :: Type -> Type -> Asst #

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

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

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

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

pattern CxEmpty :: Context #

pattern CxTuple :: [Asst] -> Context #

pattern CxSingle :: Asst -> Context #

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

pattern KindList :: Kind -> Kind #

pattern KindTuple :: [Kind] -> Kind #

pattern KindApp :: Kind -> Kind -> Kind #

pattern KindVar :: QName -> Kind #

pattern KindParen :: Kind -> Kind #

pattern KindFn :: Kind -> Kind -> Kind #

pattern KindStar :: Kind #

pattern UnkindedVar :: Name -> TyVarBind #

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

pattern PromotedUnit :: Promoted #

pattern PromotedTuple :: [Type] -> Promoted #

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

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

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

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

pattern UnpromotedName :: QName -> MaybePromotedName #

pattern PromotedName :: QName -> MaybePromotedName #

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

pattern TyWildCard :: Maybe Name -> Type #

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

pattern TySplice :: Splice -> Type #

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

pattern TyPromoted :: Promoted -> Type #

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

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

pattern TyParen :: Type -> Type #

pattern TyCon :: QName -> Type #

pattern TyVar :: Name -> Type #

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

pattern TyParArray :: Type -> Type #

pattern TyList :: Type -> Type #

pattern TyUnboxedSum :: [Type] -> Type #

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

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

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

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

pattern GuardedRhss :: [GuardedRhs] -> Rhs #

pattern UnGuardedRhs :: Exp -> Rhs #

pattern NoUnpackPragma :: Unpackedness #

pattern NoUnpack :: Unpackedness #

pattern Unpack :: Unpackedness #

pattern NoStrictAnnot :: BangType #

pattern LazyTy :: BangType #

pattern BangedTy :: BangType #

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

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

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

pattern InsDecl :: Decl -> InstDecl #

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

pattern ClsTyDef :: TypeEqn -> ClassDecl #

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

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

pattern ClsDecl :: Decl -> ClassDecl #

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

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

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

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

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

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

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

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

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

pattern IPBinds :: [IPBind] -> Binds #

pattern BDecls :: [Decl] -> Binds #

pattern DerivNewtype :: DerivStrategy #

pattern DerivAnyclass :: DerivStrategy #

pattern DerivStock :: DerivStrategy #

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

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

pattern IHParen :: InstHead -> InstHead #

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

pattern IHCon :: QName -> InstHead #

pattern IParen :: InstRule -> InstRule #

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

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

pattern DHParen :: DeclHead -> DeclHead #

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

pattern DHead :: Name -> DeclHead #

pattern TyVarSig :: TyVarBind -> ResultSig #

pattern KindSig :: Kind -> ResultSig #

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

pattern NewType :: DataOrNew #

pattern DataType :: DataOrNew #

pattern RoleWildcard :: Role #

pattern Phantom :: Role #

pattern Representational :: Role #

pattern Nominal :: Role #

pattern ParenFormula :: BooleanFormula -> BooleanFormula #

pattern OrFormula :: [BooleanFormula] -> BooleanFormula #

pattern AndFormula :: [BooleanFormula] -> BooleanFormula #

pattern VarFormula :: Name -> BooleanFormula #

pattern ModuleAnn :: Exp -> Annotation #

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

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

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

pattern ExplicitBidirectional :: [Decl] -> PatternSynDirection #

pattern ImplicitBidirectional :: PatternSynDirection #

pattern Unidirectional :: PatternSynDirection #

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

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

pattern MinimalPragma :: Maybe BooleanFormula -> Decl #

pattern AnnPragma :: Annotation -> Decl #

pattern InstSig :: InstRule -> Decl #

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

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

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

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

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

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

pattern RulePragmaDecl :: [Rule] -> Decl #

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

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

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

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

pattern FunBind :: [Match] -> Decl #

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

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

pattern SpliceDecl :: Exp -> Decl #

pattern DefaultDecl :: [Type] -> Decl #

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

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

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

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

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

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

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

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

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

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

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

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

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

pattern AssocRight :: Assoc #

pattern AssocLeft :: Assoc #

pattern AssocNone :: Assoc #

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

pattern IThingAll :: Name -> ImportSpec #

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

pattern IVar :: Name -> ImportSpec #

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

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.

importModule :: ImportDecl -> ModuleName () #

importQualified :: ImportDecl -> Bool #

importSrc :: ImportDecl -> Bool #

importSafe :: ImportDecl -> Bool #

importPkg :: ImportDecl -> Maybe String #

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

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

pattern PatternNamespace :: Namespace #

pattern TypeNamespace :: Namespace #

pattern NoNamespace :: Namespace #

pattern EWildcard :: Int -> EWildcard #

pattern NoWildcard :: EWildcard #

pattern EModuleContents :: ModuleName -> ExportSpec #

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

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

pattern EVar :: QName -> ExportSpec #

pattern ExportSpecList :: [ExportSpec] -> ExportSpecList #

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

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

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

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

pattern ConName :: Name -> CName #

pattern VarName :: Name -> CName #

pattern ConOp :: Name -> Op #

pattern VarOp :: Name -> Op #

pattern QConOp :: QName -> QOp #

pattern QVarOp :: QName -> QOp #

pattern IPLin :: String -> IPName #

pattern IPDup :: String -> IPName #

pattern Symbol :: String -> Name #

pattern Ident :: String -> Name #

pattern Special :: SpecialCon -> QName #

pattern UnQual :: Name -> QName #

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

pattern ExprHole :: SpecialCon #

pattern UnboxedSingleCon :: SpecialCon #

pattern Cons :: SpecialCon #

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

pattern FunCon :: SpecialCon #

pattern ListCon :: SpecialCon #

pattern UnitCon :: SpecialCon #

pattern ModuleName :: String -> ModuleName #

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 #

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 #

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 #

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 #

data Boxed #

Flag denoting whether a tuple is boxed or unboxed.

Constructors

Boxed 
Unboxed 
Instances
Eq Boxed 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: Boxed -> Boxed -> Bool #

(/=) :: Boxed -> Boxed -> Bool #

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 #

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

toConstr :: Boxed -> Constr #

dataTypeOf :: Boxed -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord Boxed 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: Boxed -> Boxed -> Ordering #

(<) :: Boxed -> Boxed -> Bool #

(<=) :: Boxed -> Boxed -> Bool #

(>) :: Boxed -> Boxed -> Bool #

(>=) :: Boxed -> Boxed -> Bool #

max :: Boxed -> Boxed -> Boxed #

min :: Boxed -> Boxed -> Boxed #

Show Boxed 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> Boxed -> ShowS #

show :: Boxed -> String #

showList :: [Boxed] -> ShowS #

Generic Boxed 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep Boxed :: * -> * #

Methods

from :: Boxed -> Rep Boxed x #

to :: Rep Boxed x -> Boxed #

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.20.2-66wmDqusNtt2tejiOeCDMY" False) (C1 (MetaCons "Boxed" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "Unboxed" PrefixI False) (U1 :: * -> *))

data Tool #

Recognised tools for OPTIONS pragmas.

Constructors

GHC 
HUGS 
NHC98 
YHC 
HADDOCK 
UnknownTool String 
Instances
Eq Tool 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: Tool -> Tool -> Bool #

(/=) :: Tool -> Tool -> Bool #

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 #

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

toConstr :: Tool -> Constr #

dataTypeOf :: Tool -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord Tool 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: Tool -> Tool -> Ordering #

(<) :: Tool -> Tool -> Bool #

(<=) :: Tool -> Tool -> Bool #

(>) :: Tool -> Tool -> Bool #

(>=) :: Tool -> Tool -> Bool #

max :: Tool -> Tool -> Tool #

min :: Tool -> Tool -> Tool #

Show Tool 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> Tool -> ShowS #

show :: Tool -> String #

showList :: [Tool] -> ShowS #

Generic Tool 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep Tool :: * -> * #

Methods

from :: Tool -> Rep Tool x #

to :: Rep Tool x -> Tool #

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.20.2-66wmDqusNtt2tejiOeCDMY" False) ((C1 (MetaCons "GHC" PrefixI False) (U1 :: * -> *) :+: (C1 (MetaCons "HUGS" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "NHC98" PrefixI False) (U1 :: * -> *))) :+: (C1 (MetaCons "YHC" PrefixI False) (U1 :: * -> *) :+: (C1 (MetaCons "HADDOCK" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "UnknownTool" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)))))