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

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

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 TParenSplice :: Exp -> Splice

pattern ParenSplice :: Exp -> Splice

pattern TIdSplice :: String -> Splice

pattern IdSplice :: String -> Splice

pattern DeclBracket :: [Decl] -> Bracket

pattern TypeBracket :: Type -> Bracket

pattern PatBracket :: Pat -> Bracket

pattern TExpBracket :: Exp -> Bracket

pattern ExpBracket :: Exp -> Bracket

pattern XAttr :: XName -> Exp -> XAttr

pattern XDomName :: String -> String -> XName

pattern XName :: String -> XName

pattern LCase :: [Alt] -> Exp

pattern ArrOp :: Exp -> 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 ParenA :: Asst -> Asst

pattern IParam :: IPName -> Type -> Asst

pattern TypeA :: 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 TSpliceDecl :: Exp -> 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

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.23.0-IvjfjJasXCo89gWhp1TrsK" 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.23.0-IvjfjJasXCo89gWhp1TrsK" 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)))))