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!

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 ()

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

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 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 TyStar :: 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 [TyVarBind] -> Maybe Context -> 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 DerivVia :: Type -> DerivStrategy

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 [TyVarBind] -> 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_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

data Boxed

Flag denoting whether a tuple is boxed or unboxed.

Constructors

Boxed

Unboxed

Instances

Eq Boxed

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Data Boxed

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

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

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> Boxed -> ShowS

show :: Boxed -> String

showList :: [Boxed] -> ShowS

Generic Boxed

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep Boxed :: Type -> Type

Methods

from :: Boxed -> Rep Boxed x

to :: Rep Boxed x -> Boxed

type Rep Boxed

Defined in Language.Haskell.Exts.Syntax

type Rep Boxed = D1 (MetaData "Boxed" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.21.0-1MqMUIJU7y29AVS9NHxlR4" False) (C1 (MetaCons "Boxed" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "Unboxed" PrefixI False) (U1 :: Type -> Type))

data Tool

Recognised tools for OPTIONS pragmas.

Constructors

GHC

HUGS

NHC98

YHC

HADDOCK

UnknownTool String

Instances

Eq Tool

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Data Tool

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

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

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> Tool -> ShowS

show :: Tool -> String

showList :: [Tool] -> ShowS

Generic Tool

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep Tool :: Type -> Type

Methods

from :: Tool -> Rep Tool x

to :: Rep Tool x -> Tool

Pretty Tool

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Tool -> Doc

prettyPrec :: Int -> Tool -> Doc

type Rep Tool

Defined in Language.Haskell.Exts.Syntax

type Rep Tool = D1 (MetaData "Tool" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.21.0-1MqMUIJU7y29AVS9NHxlR4" 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)))))