Copyright	(c) Niklas Broberg 2004-2009 (c) The GHC Team 1997-2000
License	BSD-style (see the file LICENSE.txt)
Maintainer	Niklas Broberg, d00nibro@chalmers.se
Stability	stable
Portability	portable
Safe Haskell	Safe
Language	Haskell98

Language.Haskell.Exts.Syntax

Contents

Modules
Declarations
Class Assertions and Contexts
Types
Expressions
Patterns
Literals
Variables, Constructors and Operators
Template Haskell
FFI
Pragmas
Builtin names
Source coordinates
Annotated trees

Description

A suite of datatypes describing the (semi-concrete) abstract syntax of Haskell 98 http://www.haskell.org/onlinereport/ plus registered extensions, including:

multi-parameter type classes with functional dependencies (MultiParamTypeClasses, FunctionalDependencies)
parameters of type class assertions are unrestricted (FlexibleContexts)
forall types as universal and existential quantification (RankNTypes, ExistentialQuantification, etc)
pattern guards (PatternGuards)
implicit parameters (ImplicitParameters)
generalised algebraic data types (GADTs)
template haskell (TemplateHaskell)
empty data type declarations (EmptyDataDecls)
unboxed tuples (UnboxedTuples)
regular patterns (RegularPatterns)
HSP-style XML expressions and patterns (XmlSyntax)

All nodes in the syntax tree are annotated with something of a user-definable data type. When parsing, this annotation will contain information about the source location that the particular node comes from.

Synopsis

data Module l
- = Module l (Maybe (ModuleHead l)) [ModulePragma l] [ImportDecl l] [Decl l]
- | XmlPage l (ModuleName l) [ModulePragma l] (XName l) [XAttr l] (Maybe (Exp l)) [Exp l]
- | XmlHybrid l (Maybe (ModuleHead l)) [ModulePragma l] [ImportDecl l] [Decl l] (XName l) [XAttr l] (Maybe (Exp l)) [Exp l]
data ModuleHead l = ModuleHead l (ModuleName l) (Maybe (WarningText l)) (Maybe (ExportSpecList l))
data WarningText l
- = DeprText l String
- | WarnText l String
data ExportSpecList l = ExportSpecList l [ExportSpec l]
data ExportSpec l
- = EVar l (QName l)
- | EAbs l (Namespace l) (QName l)
- | EThingWith l (EWildcard l) (QName l) [CName l]
- | EModuleContents l (ModuleName l)
data EWildcard l
- = NoWildcard l
- | EWildcard l Int
data ImportDecl l = ImportDecl {
- importAnn :: l
- importModule :: ModuleName l
- importQualified :: Bool
- importSrc :: Bool
- importSafe :: Bool
- importPkg :: Maybe String
- importAs :: Maybe (ModuleName l)
- importSpecs :: Maybe (ImportSpecList l)
}
data ImportSpecList l = ImportSpecList l Bool [ImportSpec l]
data ImportSpec l
- = IVar l (Name l)
- | IAbs l (Namespace l) (Name l)
- | IThingAll l (Name l)
- | IThingWith l (Name l) [CName l]
data Assoc l
- = AssocNone l
- | AssocLeft l
- | AssocRight l
data Namespace l
- = NoNamespace l
- | TypeNamespace l
- | PatternNamespace l
data Decl l
- = TypeDecl l (DeclHead l) (Type l)
- | TypeFamDecl l (DeclHead l) (Maybe (ResultSig l)) (Maybe (InjectivityInfo l))
- | ClosedTypeFamDecl l (DeclHead l) (Maybe (ResultSig l)) (Maybe (InjectivityInfo l)) [TypeEqn l]
- | DataDecl l (DataOrNew l) (Maybe (Context l)) (DeclHead l) [QualConDecl l] [Deriving l]
- | GDataDecl l (DataOrNew l) (Maybe (Context l)) (DeclHead l) (Maybe (Kind l)) [GadtDecl l] [Deriving l]
- | DataFamDecl l (Maybe (Context l)) (DeclHead l) (Maybe (ResultSig l))
- | TypeInsDecl l (Type l) (Type l)
- | DataInsDecl l (DataOrNew l) (Type l) [QualConDecl l] [Deriving l]
- | GDataInsDecl l (DataOrNew l) (Type l) (Maybe (Kind l)) [GadtDecl l] [Deriving l]
- | ClassDecl l (Maybe (Context l)) (DeclHead l) [FunDep l] (Maybe [ClassDecl l])
- | InstDecl l (Maybe (Overlap l)) (InstRule l) (Maybe [InstDecl l])
- | DerivDecl l (Maybe (DerivStrategy l)) (Maybe (Overlap l)) (InstRule l)
- | InfixDecl l (Assoc l) (Maybe Int) [Op l]
- | DefaultDecl l [Type l]
- | SpliceDecl l (Exp l)
- | TypeSig l [Name l] (Type l)
- | PatSynSig l [Name l] (Maybe [TyVarBind l]) (Maybe (Context l)) (Maybe (Context l)) (Type l)
- | FunBind l [Match l]
- | PatBind l (Pat l) (Rhs l) (Maybe (Binds l))
- | PatSyn l (Pat l) (Pat l) (PatternSynDirection l)
- | ForImp l (CallConv l) (Maybe (Safety l)) (Maybe String) (Name l) (Type l)
- | ForExp l (CallConv l) (Maybe String) (Name l) (Type l)
- | RulePragmaDecl l [Rule l]
- | DeprPragmaDecl l [([Name l], String)]
- | WarnPragmaDecl l [([Name l], String)]
- | InlineSig l Bool (Maybe (Activation l)) (QName l)
- | InlineConlikeSig l (Maybe (Activation l)) (QName l)
- | SpecSig l (Maybe (Activation l)) (QName l) [Type l]
- | SpecInlineSig l Bool (Maybe (Activation l)) (QName l) [Type l]
- | InstSig l (InstRule l)
- | AnnPragma l (Annotation l)
- | MinimalPragma l (Maybe (BooleanFormula l))
- | RoleAnnotDecl l (QName l) [Role l]
- | CompletePragma l [Name l] (Maybe (QName l))
data DeclHead l
- = DHead l (Name l)
- | DHInfix l (TyVarBind l) (Name l)
- | DHParen l (DeclHead l)
- | DHApp l (DeclHead l) (TyVarBind l)
data InstRule l
- = IRule l (Maybe [TyVarBind l]) (Maybe (Context l)) (InstHead l)
- | IParen l (InstRule l)
data InstHead l
- = IHCon l (QName l)
- | IHInfix l (Type l) (QName l)
- | IHParen l (InstHead l)
- | IHApp l (InstHead l) (Type l)
data Binds l
- = BDecls l [Decl l]
- | IPBinds l [IPBind l]
data IPBind l = IPBind l (IPName l) (Exp l)
data PatternSynDirection l
- = Unidirectional
- | ImplicitBidirectional
- | ExplicitBidirectional l [Decl l]
data InjectivityInfo l = InjectivityInfo l (Name l) [Name l]
data ResultSig l
- = KindSig l (Kind l)
- | TyVarSig l (TyVarBind l)
data ClassDecl l
- = ClsDecl l (Decl l)
- | ClsDataFam l (Maybe (Context l)) (DeclHead l) (Maybe (ResultSig l))
- | ClsTyFam l (DeclHead l) (Maybe (ResultSig l)) (Maybe (InjectivityInfo l))
- | ClsTyDef l (TypeEqn l)
- | ClsDefSig l (Name l) (Type l)
data InstDecl l
- = InsDecl l (Decl l)
- | InsType l (Type l) (Type l)
- | InsData l (DataOrNew l) (Type l) [QualConDecl l] [Deriving l]
- | InsGData l (DataOrNew l) (Type l) (Maybe (Kind l)) [GadtDecl l] [Deriving l]
data Deriving l = Deriving l (Maybe (DerivStrategy l)) [InstRule l]
data DerivStrategy l
- = DerivStock l
- | DerivAnyclass l
- | DerivNewtype l
data DataOrNew l
- = DataType l
- | NewType l
data ConDecl l
- = ConDecl l (Name l) [Type l]
- | InfixConDecl l (Type l) (Name l) (Type l)
- | RecDecl l (Name l) [FieldDecl l]
data FieldDecl l = FieldDecl l [Name l] (Type l)
data QualConDecl l = QualConDecl l (Maybe [TyVarBind l]) (Maybe (Context l)) (ConDecl l)
data GadtDecl l = GadtDecl l (Name l) (Maybe [FieldDecl l]) (Type l)
data BangType l
- = BangedTy l
- | LazyTy l
- | NoStrictAnnot l
data Unpackedness l
- = Unpack l
- | NoUnpack l
- | NoUnpackPragma l
data Match l
- = Match l (Name l) [Pat l] (Rhs l) (Maybe (Binds l))
- | InfixMatch l (Pat l) (Name l) [Pat l] (Rhs l) (Maybe (Binds l))
data Rhs l
- = UnGuardedRhs l (Exp l)
- | GuardedRhss l [GuardedRhs l]
data GuardedRhs l = GuardedRhs l [Stmt l] (Exp l)
data Context l
- = CxSingle l (Asst l)
- | CxTuple l [Asst l]
- | CxEmpty l
data FunDep l = FunDep l [Name l] [Name l]
data Asst l
- = ClassA l (QName l) [Type l]
- | AppA l (Name l) [Type l]
- | InfixA l (Type l) (QName l) (Type l)
- | IParam l (IPName l) (Type l)
- | EqualP l (Type l) (Type l)
- | ParenA l (Asst l)
- | WildCardA l (Maybe (Name l))
data Type l
- = TyForall l (Maybe [TyVarBind l]) (Maybe (Context l)) (Type l)
- | TyFun l (Type l) (Type l)
- | TyTuple l Boxed [Type l]
- | TyUnboxedSum l [Type l]
- | TyList l (Type l)
- | TyParArray l (Type l)
- | TyApp l (Type l) (Type l)
- | TyVar l (Name l)
- | TyCon l (QName l)
- | TyParen l (Type l)
- | TyInfix l (Type l) (MaybePromotedName l) (Type l)
- | TyKind l (Type l) (Kind l)
- | TyPromoted l (Promoted l)
- | TyEquals l (Type l) (Type l)
- | TySplice l (Splice l)
- | TyBang l (BangType l) (Unpackedness l) (Type l)
- | TyWildCard l (Maybe (Name l))
- | TyQuasiQuote l String String
data Boxed
- = Boxed
- | Unboxed
data Kind l
- = KindStar l
- | KindFn l (Kind l) (Kind l)
- | KindParen l (Kind l)
- | KindVar l (QName l)
- | KindApp l (Kind l) (Kind l)
- | KindTuple l [Kind l]
- | KindList l (Kind l)
data TyVarBind l
- = KindedVar l (Name l) (Kind l)
- | UnkindedVar l (Name l)
data Promoted l
- = PromotedInteger l Integer String
- | PromotedString l String String
- | PromotedCon l Bool (QName l)
- | PromotedList l Bool [Type l]
- | PromotedTuple l [Type l]
- | PromotedUnit l
data TypeEqn l = TypeEqn l (Type l) (Type l)
data Exp l
- = Var l (QName l)
- | OverloadedLabel l String
- | IPVar l (IPName l)
- | Con l (QName l)
- | Lit l (Literal l)
- | InfixApp l (Exp l) (QOp l) (Exp l)
- | App l (Exp l) (Exp l)
- | NegApp l (Exp l)
- | Lambda l [Pat l] (Exp l)
- | Let l (Binds l) (Exp l)
- | If l (Exp l) (Exp l) (Exp l)
- | MultiIf l [GuardedRhs l]
- | Case l (Exp l) [Alt l]
- | Do l [Stmt l]
- | MDo l [Stmt l]
- | Tuple l Boxed [Exp l]
- | UnboxedSum l Int Int (Exp l)
- | TupleSection l Boxed [Maybe (Exp l)]
- | List l [Exp l]
- | ParArray l [Exp l]
- | Paren l (Exp l)
- | LeftSection l (Exp l) (QOp l)
- | RightSection l (QOp l) (Exp l)
- | RecConstr l (QName l) [FieldUpdate l]
- | RecUpdate l (Exp l) [FieldUpdate l]
- | EnumFrom l (Exp l)
- | EnumFromTo l (Exp l) (Exp l)
- | EnumFromThen l (Exp l) (Exp l)
- | EnumFromThenTo l (Exp l) (Exp l) (Exp l)
- | ParArrayFromTo l (Exp l) (Exp l)
- | ParArrayFromThenTo l (Exp l) (Exp l) (Exp l)
- | ListComp l (Exp l) [QualStmt l]
- | ParComp l (Exp l) [[QualStmt l]]
- | ParArrayComp l (Exp l) [[QualStmt l]]
- | ExpTypeSig l (Exp l) (Type l)
- | VarQuote l (QName l)
- | TypQuote l (QName l)
- | BracketExp l (Bracket l)
- | SpliceExp l (Splice l)
- | QuasiQuote l String String
- | TypeApp l (Type l)
- | XTag l (XName l) [XAttr l] (Maybe (Exp l)) [Exp l]
- | XETag l (XName l) [XAttr l] (Maybe (Exp l))
- | XPcdata l String
- | XExpTag l (Exp l)
- | XChildTag l [Exp l]
- | CorePragma l String (Exp l)
- | SCCPragma l String (Exp l)
- | GenPragma l String (Int, Int) (Int, Int) (Exp l)
- | Proc l (Pat l) (Exp l)
- | LeftArrApp l (Exp l) (Exp l)
- | RightArrApp l (Exp l) (Exp l)
- | LeftArrHighApp l (Exp l) (Exp l)
- | RightArrHighApp l (Exp l) (Exp l)
- | LCase l [Alt l]
data Stmt l
- = Generator l (Pat l) (Exp l)
- | Qualifier l (Exp l)
- | LetStmt l (Binds l)
- | RecStmt l [Stmt l]
data QualStmt l
- = QualStmt l (Stmt l)
- | ThenTrans l (Exp l)
- | ThenBy l (Exp l) (Exp l)
- | GroupBy l (Exp l)
- | GroupUsing l (Exp l)
- | GroupByUsing l (Exp l) (Exp l)
data FieldUpdate l
- = FieldUpdate l (QName l) (Exp l)
- | FieldPun l (QName l)
- | FieldWildcard l
data Alt l = Alt l (Pat l) (Rhs l) (Maybe (Binds l))
data XAttr l = XAttr l (XName l) (Exp l)
data Pat l
- = PVar l (Name l)
- | PLit l (Sign l) (Literal l)
- | PNPlusK l (Name l) Integer
- | PInfixApp l (Pat l) (QName l) (Pat l)
- | PApp l (QName l) [Pat l]
- | PTuple l Boxed [Pat l]
- | PUnboxedSum l Int Int (Pat l)
- | PList l [Pat l]
- | PParen l (Pat l)
- | PRec l (QName l) [PatField l]
- | PAsPat l (Name l) (Pat l)
- | PWildCard l
- | PIrrPat l (Pat l)
- | PatTypeSig l (Pat l) (Type l)
- | PViewPat l (Exp l) (Pat l)
- | PRPat l [RPat l]
- | PXTag l (XName l) [PXAttr l] (Maybe (Pat l)) [Pat l]
- | PXETag l (XName l) [PXAttr l] (Maybe (Pat l))
- | PXPcdata l String
- | PXPatTag l (Pat l)
- | PXRPats l [RPat l]
- | PSplice l (Splice l)
- | PQuasiQuote l String String
- | PBangPat l (Pat l)
data PatField l
- = PFieldPat l (QName l) (Pat l)
- | PFieldPun l (QName l)
- | PFieldWildcard l
data PXAttr l = PXAttr l (XName l) (Pat l)
data RPat l
- = RPOp l (RPat l) (RPatOp l)
- | RPEither l (RPat l) (RPat l)
- | RPSeq l [RPat l]
- | RPGuard l (Pat l) [Stmt l]
- | RPCAs l (Name l) (RPat l)
- | RPAs l (Name l) (RPat l)
- | RPParen l (RPat l)
- | RPPat l (Pat l)
data RPatOp l
- = RPStar l
- | RPStarG l
- | RPPlus l
- | RPPlusG l
- | RPOpt l
- | RPOptG l
data Literal l
- = Char l Char String
- | String l String String
- | Int l Integer String
- | Frac l Rational String
- | PrimInt l Integer String
- | PrimWord l Integer String
- | PrimFloat l Rational String
- | PrimDouble l Rational String
- | PrimChar l Char String
- | PrimString l String String
data Sign l
- = Signless l
- | Negative l
data ModuleName l = ModuleName l String
data QName l
- = Qual l (ModuleName l) (Name l)
- | UnQual l (Name l)
- | Special l (SpecialCon l)
data Name l
- = Ident l String
- | Symbol l String
data QOp l
- = QVarOp l (QName l)
- | QConOp l (QName l)
data Op l
- = VarOp l (Name l)
- | ConOp l (Name l)
data SpecialCon l
- = UnitCon l
- | ListCon l
- | FunCon l
- | TupleCon l Boxed Int
- | Cons l
- | UnboxedSingleCon l
- | ExprHole l
data CName l
- = VarName l (Name l)
- | ConName l (Name l)
data IPName l
- = IPDup l String
- | IPLin l String
data XName l
- = XName l String
- | XDomName l String String
data Role l
- = Nominal l
- | Representational l
- | Phantom l
- | RoleWildcard l
data MaybePromotedName l
- = PromotedName l (QName l)
- | UnpromotedName l (QName l)
data Bracket l
- = ExpBracket l (Exp l)
- | PatBracket l (Pat l)
- | TypeBracket l (Type l)
- | DeclBracket l [Decl l]
data Splice l
- = IdSplice l String
- | ParenSplice l (Exp l)
data Safety l
- = PlayRisky l
- | PlaySafe l Bool
- | PlayInterruptible l
data CallConv l
- = StdCall l
- | CCall l
- | CPlusPlus l
- | DotNet l
- | Jvm l
- | Js l
- | JavaScript l
- | CApi l
data ModulePragma l
- = LanguagePragma l [Name l]
- | OptionsPragma l (Maybe Tool) String
- | AnnModulePragma l (Annotation l)
data Tool
- = GHC
- | HUGS
- | NHC98
- | YHC
- | HADDOCK
- | UnknownTool String
data Overlap l
- = NoOverlap l
- | Overlap l
- | Overlapping l
- | Overlaps l
- | Overlappable l
- | Incoherent l
data Rule l = Rule l String (Maybe (Activation l)) (Maybe [RuleVar l]) (Exp l) (Exp l)
data RuleVar l
- = RuleVar l (Name l)
- | TypedRuleVar l (Name l) (Type l)
data Activation l
- = ActiveFrom l Int
- | ActiveUntil l Int
data Annotation l
- = Ann l (Name l) (Exp l)
- | TypeAnn l (Name l) (Exp l)
- | ModuleAnn l (Exp l)
data BooleanFormula l
- = VarFormula l (Name l)
- | AndFormula l [BooleanFormula l]
- | OrFormula l [BooleanFormula l]
- | ParenFormula l (BooleanFormula l)
prelude_mod :: l -> ModuleName l
main_mod :: l -> ModuleName l
main_name :: l -> Name l
unit_con_name :: l -> QName l
tuple_con_name :: l -> Boxed -> Int -> QName l
list_cons_name :: l -> QName l
unboxed_singleton_con_name :: l -> QName l
unit_con :: l -> Exp l
tuple_con :: l -> Boxed -> Int -> Exp l
unboxed_singleton_con :: l -> Exp l
as_name :: l -> Name l
qualified_name :: l -> Name l
hiding_name :: l -> Name l
minus_name :: l -> Name l
bang_name :: l -> Name l
dot_name :: l -> Name l
star_name :: l -> Name l
export_name :: l -> Name l
safe_name :: l -> Name l
unsafe_name :: l -> Name l
interruptible_name :: l -> Name l
threadsafe_name :: l -> Name l
stdcall_name :: l -> Name l
ccall_name :: l -> Name l
cplusplus_name :: l -> Name l
dotnet_name :: l -> Name l
jvm_name :: l -> Name l
js_name :: l -> Name l
javascript_name :: l -> Name l
capi_name :: l -> Name l
forall_name :: l -> Name l
family_name :: l -> Name l
role_name :: l -> Name l
hole_name :: l -> QName l
stock_name :: l -> Name l
anyclass_name :: l -> Name l
unit_tycon_name :: l -> QName l
fun_tycon_name :: l -> QName l
list_tycon_name :: l -> QName l
tuple_tycon_name :: l -> Boxed -> Int -> QName l
unboxed_singleton_tycon_name :: l -> QName l
unit_tycon :: l -> Type l
fun_tycon :: l -> Type l
list_tycon :: l -> Type l
tuple_tycon :: l -> Boxed -> Int -> Type l
unboxed_singleton_tycon :: l -> Type l
class Functor ast => Annotated ast where
- ann :: ast l -> l
- amap :: (l -> l) -> ast l -> ast l
(=~=) :: (Annotated a, Eq (a ())) => a l1 -> a l2 -> Bool

Modules

data Module l #

A complete Haskell source module.

Constructors

Module l (Maybe (ModuleHead l)) [ModulePragma l] [ImportDecl l] [Decl l]	an ordinary Haskell module
XmlPage l (ModuleName l) [ModulePragma l] (XName l) [XAttr l] (Maybe (Exp l)) [Exp l]	a module consisting of a single XML document. The ModuleName never appears in the source but is needed for semantic purposes, it will be the same as the file name.
XmlHybrid l (Maybe (ModuleHead l)) [ModulePragma l] [ImportDecl l] [Decl l] (XName l) [XAttr l] (Maybe (Exp l)) [Exp l]	a hybrid module combining an XML document with an ordinary module

Instances

Functor Module #
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> Module a -> Module b # (<$) :: a -> Module b -> Module a #
Foldable Module #
Instance details Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Module m -> m # foldMap :: Monoid m => (a -> m) -> Module a -> m # foldr :: (a -> b -> b) -> b -> Module a -> b # foldr' :: (a -> b -> b) -> b -> Module a -> b # foldl :: (b -> a -> b) -> b -> Module a -> b # foldl' :: (b -> a -> b) -> b -> Module a -> b # foldr1 :: (a -> a -> a) -> Module a -> a # foldl1 :: (a -> a -> a) -> Module a -> a # toList :: Module a -> [a] # null :: Module a -> Bool # length :: Module a -> Int # elem :: Eq a => a -> Module a -> Bool # maximum :: Ord a => Module a -> a # minimum :: Ord a => Module a -> a # sum :: Num a => Module a -> a # product :: Num a => Module a -> a #
Traversable Module #
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> Module a -> f (Module b) # sequenceA :: Applicative f => Module (f a) -> f (Module a) # mapM :: Monad m => (a -> m b) -> Module a -> m (Module b) # sequence :: Monad m => Module (m a) -> m (Module a) #
Annotated Module #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Module l -> l # amap :: (l -> l) -> Module l -> Module l #
AppFixity Module #
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> Module SrcSpanInfo -> m (Module SrcSpanInfo) #
ExactP Module #
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Module SrcSpanInfo -> EP ()
Eq l => Eq (Module l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: Module l -> Module l -> Bool # (/=) :: Module l -> Module l -> Bool #
Data l => Data (Module l) #
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) -> Module l -> c (Module l) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Module l) # toConstr :: Module l -> Constr # dataTypeOf :: Module l -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Module l)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Module l)) # gmapT :: (forall b. Data b => b -> b) -> Module l -> Module l # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Module l -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Module l -> r # gmapQ :: (forall d. Data d => d -> u) -> Module l -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Module l -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Module l -> m (Module l) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Module l -> m (Module l) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Module l -> m (Module l) #
Ord l => Ord (Module l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: Module l -> Module l -> Ordering # (<) :: Module l -> Module l -> Bool # (<=) :: Module l -> Module l -> Bool # (>) :: Module l -> Module l -> Bool # (>=) :: Module l -> Module l -> Bool # max :: Module l -> Module l -> Module l # min :: Module l -> Module l -> Module l #
Show l => Show (Module l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> Module l -> ShowS # show :: Module l -> String # showList :: [Module l] -> ShowS #
Generic (Module l) #
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Module l) :: Type -> Type # Methods from :: Module l -> Rep (Module l) x # to :: Rep (Module l) x -> Module l #
Pretty (Module pos) #
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: Module pos -> Doc prettyPrec :: Int -> Module pos -> Doc
Parseable (Module SrcSpanInfo) #
Instance details Defined in Language.Haskell.Exts.Parser Methods parse :: String -> ParseResult (Module SrcSpanInfo) # parseWithMode :: ParseMode -> String -> ParseResult (Module SrcSpanInfo) # parseWithComments :: ParseMode -> String -> ParseResult (Module SrcSpanInfo, [Comment]) # parser :: Maybe [Fixity] -> P (Module SrcSpanInfo)
type Rep (Module l) #
Instance details Defined in Language.Haskell.Exts.Syntax type Rep (Module l) = D1 (MetaData "Module" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "Module" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (ModuleHead l)))) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [ModulePragma l]) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [ImportDecl l]) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Decl l])))) :+: (C1 (MetaCons "XmlPage" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ModuleName l)) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [ModulePragma l]))) :: ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (XName l)) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [XAttr l])) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Exp l))) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Exp l])))) :+: C1 (MetaCons "XmlHybrid" PrefixI False) (((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (ModuleHead l)))) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [ModulePragma l]) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [ImportDecl l]))) :: ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Decl l]) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (XName l))) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [XAttr l]) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Exp l))) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Exp l])))))))

data ModuleHead l #

The head of a module, including the name and export specification.

Constructors

ModuleHead l (ModuleName l) (Maybe (WarningText l)) (Maybe (ExportSpecList l))

Instances

Functor ModuleHead #
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> ModuleHead a -> ModuleHead b # (<$) :: a -> ModuleHead b -> ModuleHead a #
Foldable ModuleHead #
Instance details Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => ModuleHead m -> m # foldMap :: Monoid m => (a -> m) -> ModuleHead a -> m # foldr :: (a -> b -> b) -> b -> ModuleHead a -> b # foldr' :: (a -> b -> b) -> b -> ModuleHead a -> b # foldl :: (b -> a -> b) -> b -> ModuleHead a -> b # foldl' :: (b -> a -> b) -> b -> ModuleHead a -> b # foldr1 :: (a -> a -> a) -> ModuleHead a -> a # foldl1 :: (a -> a -> a) -> ModuleHead a -> a # toList :: ModuleHead a -> [a] # null :: ModuleHead a -> Bool # length :: ModuleHead a -> Int # elem :: Eq a => a -> ModuleHead a -> Bool # maximum :: Ord a => ModuleHead a -> a # minimum :: Ord a => ModuleHead a -> a # sum :: Num a => ModuleHead a -> a # product :: Num a => ModuleHead a -> a #
Traversable ModuleHead #
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> ModuleHead a -> f (ModuleHead b) # sequenceA :: Applicative f => ModuleHead (f a) -> f (ModuleHead a) # mapM :: Monad m => (a -> m b) -> ModuleHead a -> m (ModuleHead b) # sequence :: Monad m => ModuleHead (m a) -> m (ModuleHead a) #
Annotated ModuleHead #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: ModuleHead l -> l # amap :: (l -> l) -> ModuleHead l -> ModuleHead l #
ExactP ModuleHead #
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: ModuleHead SrcSpanInfo -> EP ()
Eq l => Eq (ModuleHead l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: ModuleHead l -> ModuleHead l -> Bool # (/=) :: ModuleHead l -> ModuleHead l -> Bool #
Data l => Data (ModuleHead l) #
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) -> ModuleHead l -> c (ModuleHead l) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ModuleHead l) # toConstr :: ModuleHead l -> Constr # dataTypeOf :: ModuleHead l -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ModuleHead l)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ModuleHead l)) # gmapT :: (forall b. Data b => b -> b) -> ModuleHead l -> ModuleHead l # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ModuleHead l -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ModuleHead l -> r # gmapQ :: (forall d. Data d => d -> u) -> ModuleHead l -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ModuleHead l -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ModuleHead l -> m (ModuleHead l) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ModuleHead l -> m (ModuleHead l) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ModuleHead l -> m (ModuleHead l) #
Ord l => Ord (ModuleHead l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: ModuleHead l -> ModuleHead l -> Ordering # (<) :: ModuleHead l -> ModuleHead l -> Bool # (<=) :: ModuleHead l -> ModuleHead l -> Bool # (>) :: ModuleHead l -> ModuleHead l -> Bool # (>=) :: ModuleHead l -> ModuleHead l -> Bool # max :: ModuleHead l -> ModuleHead l -> ModuleHead l # min :: ModuleHead l -> ModuleHead l -> ModuleHead l #
Show l => Show (ModuleHead l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> ModuleHead l -> ShowS # show :: ModuleHead l -> String # showList :: [ModuleHead l] -> ShowS #
Generic (ModuleHead l) #
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (ModuleHead l) :: Type -> Type # Methods from :: ModuleHead l -> Rep (ModuleHead l) x # to :: Rep (ModuleHead l) x -> ModuleHead l #
Pretty (ModuleHead l) #
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: ModuleHead l -> Doc prettyPrec :: Int -> ModuleHead l -> Doc
type Rep (ModuleHead l) #
Instance details Defined in Language.Haskell.Exts.Syntax type Rep (ModuleHead l) = D1 (MetaData "ModuleHead" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "ModuleHead" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ModuleName l))) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (WarningText l))) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (ExportSpecList l))))))

data WarningText l #

Warning text to optionally use in the module header of e.g. a deprecated module.

Constructors

DeprText l String
WarnText l String

Instances

Functor WarningText #
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> WarningText a -> WarningText b # (<$) :: a -> WarningText b -> WarningText a #
Foldable WarningText #
Instance details Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => WarningText m -> m # foldMap :: Monoid m => (a -> m) -> WarningText a -> m # foldr :: (a -> b -> b) -> b -> WarningText a -> b # foldr' :: (a -> b -> b) -> b -> WarningText a -> b # foldl :: (b -> a -> b) -> b -> WarningText a -> b # foldl' :: (b -> a -> b) -> b -> WarningText a -> b # foldr1 :: (a -> a -> a) -> WarningText a -> a # foldl1 :: (a -> a -> a) -> WarningText a -> a # toList :: WarningText a -> [a] # null :: WarningText a -> Bool # length :: WarningText a -> Int # elem :: Eq a => a -> WarningText a -> Bool # maximum :: Ord a => WarningText a -> a # minimum :: Ord a => WarningText a -> a # sum :: Num a => WarningText a -> a # product :: Num a => WarningText a -> a #
Traversable WarningText #
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> WarningText a -> f (WarningText b) # sequenceA :: Applicative f => WarningText (f a) -> f (WarningText a) # mapM :: Monad m => (a -> m b) -> WarningText a -> m (WarningText b) # sequence :: Monad m => WarningText (m a) -> m (WarningText a) #
Annotated WarningText #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: WarningText l -> l # amap :: (l -> l) -> WarningText l -> WarningText l #
ExactP WarningText #
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: WarningText SrcSpanInfo -> EP ()
Eq l => Eq (WarningText l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: WarningText l -> WarningText l -> Bool # (/=) :: WarningText l -> WarningText l -> Bool #
Data l => Data (WarningText l) #
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) -> WarningText l -> c (WarningText l) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (WarningText l) # toConstr :: WarningText l -> Constr # dataTypeOf :: WarningText l -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (WarningText l)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (WarningText l)) # gmapT :: (forall b. Data b => b -> b) -> WarningText l -> WarningText l # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WarningText l -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WarningText l -> r # gmapQ :: (forall d. Data d => d -> u) -> WarningText l -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> WarningText l -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> WarningText l -> m (WarningText l) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WarningText l -> m (WarningText l) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WarningText l -> m (WarningText l) #
Ord l => Ord (WarningText l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: WarningText l -> WarningText l -> Ordering # (<) :: WarningText l -> WarningText l -> Bool # (<=) :: WarningText l -> WarningText l -> Bool # (>) :: WarningText l -> WarningText l -> Bool # (>=) :: WarningText l -> WarningText l -> Bool # max :: WarningText l -> WarningText l -> WarningText l # min :: WarningText l -> WarningText l -> WarningText l #
Show l => Show (WarningText l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> WarningText l -> ShowS # show :: WarningText l -> String # showList :: [WarningText l] -> ShowS #
Generic (WarningText l) #
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (WarningText l) :: Type -> Type # Methods from :: WarningText l -> Rep (WarningText l) x # to :: Rep (WarningText l) x -> WarningText l #
type Rep (WarningText l) #
Instance details Defined in Language.Haskell.Exts.Syntax type Rep (WarningText l) = D1 (MetaData "WarningText" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "DeprText" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)) :+: C1 (MetaCons "WarnText" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)))

data ExportSpecList l #

An explicit export specification.

Constructors

ExportSpecList l [ExportSpec l]

Instances

Functor ExportSpecList #
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> ExportSpecList a -> ExportSpecList b # (<$) :: a -> ExportSpecList b -> ExportSpecList a #
Foldable ExportSpecList #
Instance details Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => ExportSpecList m -> m # foldMap :: Monoid m => (a -> m) -> ExportSpecList a -> m # foldr :: (a -> b -> b) -> b -> ExportSpecList a -> b # foldr' :: (a -> b -> b) -> b -> ExportSpecList a -> b # foldl :: (b -> a -> b) -> b -> ExportSpecList a -> b # foldl' :: (b -> a -> b) -> b -> ExportSpecList a -> b # foldr1 :: (a -> a -> a) -> ExportSpecList a -> a # foldl1 :: (a -> a -> a) -> ExportSpecList a -> a # toList :: ExportSpecList a -> [a] # null :: ExportSpecList a -> Bool # length :: ExportSpecList a -> Int # elem :: Eq a => a -> ExportSpecList a -> Bool # maximum :: Ord a => ExportSpecList a -> a # minimum :: Ord a => ExportSpecList a -> a # sum :: Num a => ExportSpecList a -> a # product :: Num a => ExportSpecList a -> a #
Traversable ExportSpecList #
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> ExportSpecList a -> f (ExportSpecList b) # sequenceA :: Applicative f => ExportSpecList (f a) -> f (ExportSpecList a) # mapM :: Monad m => (a -> m b) -> ExportSpecList a -> m (ExportSpecList b) # sequence :: Monad m => ExportSpecList (m a) -> m (ExportSpecList a) #
Annotated ExportSpecList #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: ExportSpecList l -> l # amap :: (l -> l) -> ExportSpecList l -> ExportSpecList l #
ExactP ExportSpecList #
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: ExportSpecList SrcSpanInfo -> EP ()
Eq l => Eq (ExportSpecList l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: ExportSpecList l -> ExportSpecList l -> Bool # (/=) :: ExportSpecList l -> ExportSpecList l -> Bool #
Data l => Data (ExportSpecList l) #
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) -> ExportSpecList l -> c (ExportSpecList l) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ExportSpecList l) # toConstr :: ExportSpecList l -> Constr # dataTypeOf :: ExportSpecList l -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ExportSpecList l)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ExportSpecList l)) # gmapT :: (forall b. Data b => b -> b) -> ExportSpecList l -> ExportSpecList l # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ExportSpecList l -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ExportSpecList l -> r # gmapQ :: (forall d. Data d => d -> u) -> ExportSpecList l -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ExportSpecList l -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ExportSpecList l -> m (ExportSpecList l) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ExportSpecList l -> m (ExportSpecList l) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ExportSpecList l -> m (ExportSpecList l) #
Ord l => Ord (ExportSpecList l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: ExportSpecList l -> ExportSpecList l -> Ordering # (<) :: ExportSpecList l -> ExportSpecList l -> Bool # (<=) :: ExportSpecList l -> ExportSpecList l -> Bool # (>) :: ExportSpecList l -> ExportSpecList l -> Bool # (>=) :: ExportSpecList l -> ExportSpecList l -> Bool # max :: ExportSpecList l -> ExportSpecList l -> ExportSpecList l # min :: ExportSpecList l -> ExportSpecList l -> ExportSpecList l #
Show l => Show (ExportSpecList l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> ExportSpecList l -> ShowS # show :: ExportSpecList l -> String # showList :: [ExportSpecList l] -> ShowS #
Generic (ExportSpecList l) #
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (ExportSpecList l) :: Type -> Type # Methods from :: ExportSpecList l -> Rep (ExportSpecList l) x # to :: Rep (ExportSpecList l) x -> ExportSpecList l #
Pretty (ExportSpecList l) #
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: ExportSpecList l -> Doc prettyPrec :: Int -> ExportSpecList l -> Doc
type Rep (ExportSpecList l) #
Instance details Defined in Language.Haskell.Exts.Syntax type Rep (ExportSpecList l) = D1 (MetaData "ExportSpecList" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "ExportSpecList" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [ExportSpec l])))

data ExportSpec l #

An item in a module's export specification.

Constructors

EVar l (QName l)	variable.
EAbs l (Namespace l) (QName l)	`T`: a class or datatype exported abstractly, or a type synonym.
EThingWith l (EWildcard l) (QName l) [CName l]	`T(C_1,...,C_n)`: a class exported with some of its methods, or a datatype exported with some of its constructors.
EModuleContents l (ModuleName l)	`module M`: re-export a module.

Instances

Functor ExportSpec #
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> ExportSpec a -> ExportSpec b # (<$) :: a -> ExportSpec b -> ExportSpec a #
Foldable ExportSpec #
Instance details Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => ExportSpec m -> m # foldMap :: Monoid m => (a -> m) -> ExportSpec a -> m # foldr :: (a -> b -> b) -> b -> ExportSpec a -> b # foldr' :: (a -> b -> b) -> b -> ExportSpec a -> b # foldl :: (b -> a -> b) -> b -> ExportSpec a -> b # foldl' :: (b -> a -> b) -> b -> ExportSpec a -> b # foldr1 :: (a -> a -> a) -> ExportSpec a -> a # foldl1 :: (a -> a -> a) -> ExportSpec a -> a # toList :: ExportSpec a -> [a] # null :: ExportSpec a -> Bool # length :: ExportSpec a -> Int # elem :: Eq a => a -> ExportSpec a -> Bool # maximum :: Ord a => ExportSpec a -> a # minimum :: Ord a => ExportSpec a -> a # sum :: Num a => ExportSpec a -> a # product :: Num a => ExportSpec a -> a #
Traversable ExportSpec #
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> ExportSpec a -> f (ExportSpec b) # sequenceA :: Applicative f => ExportSpec (f a) -> f (ExportSpec a) # mapM :: Monad m => (a -> m b) -> ExportSpec a -> m (ExportSpec b) # sequence :: Monad m => ExportSpec (m a) -> m (ExportSpec a) #
Annotated ExportSpec #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: ExportSpec l -> l # amap :: (l -> l) -> ExportSpec l -> ExportSpec l #
ExactP ExportSpec #
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: ExportSpec SrcSpanInfo -> EP ()
Eq l => Eq (ExportSpec l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: ExportSpec l -> ExportSpec l -> Bool # (/=) :: ExportSpec l -> ExportSpec l -> Bool #
Data l => Data (ExportSpec l) #
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) -> ExportSpec l -> c (ExportSpec l) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ExportSpec l) # toConstr :: ExportSpec l -> Constr # dataTypeOf :: ExportSpec l -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ExportSpec l)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ExportSpec l)) # gmapT :: (forall b. Data b => b -> b) -> ExportSpec l -> ExportSpec l # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ExportSpec l -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ExportSpec l -> r # gmapQ :: (forall d. Data d => d -> u) -> ExportSpec l -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ExportSpec l -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ExportSpec l -> m (ExportSpec l) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ExportSpec l -> m (ExportSpec l) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ExportSpec l -> m (ExportSpec l) #
Ord l => Ord (ExportSpec l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: ExportSpec l -> ExportSpec l -> Ordering # (<) :: ExportSpec l -> ExportSpec l -> Bool # (<=) :: ExportSpec l -> ExportSpec l -> Bool # (>) :: ExportSpec l -> ExportSpec l -> Bool # (>=) :: ExportSpec l -> ExportSpec l -> Bool # max :: ExportSpec l -> ExportSpec l -> ExportSpec l # min :: ExportSpec l -> ExportSpec l -> ExportSpec l #
Show l => Show (ExportSpec l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> ExportSpec l -> ShowS # show :: ExportSpec l -> String # showList :: [ExportSpec l] -> ShowS #
Generic (ExportSpec l) #
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (ExportSpec l) :: Type -> Type # Methods from :: ExportSpec l -> Rep (ExportSpec l) x # to :: Rep (ExportSpec l) x -> ExportSpec l #
Pretty (ExportSpec l) #
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: ExportSpec l -> Doc prettyPrec :: Int -> ExportSpec l -> Doc
type Rep (ExportSpec l) #
Instance details Defined in Language.Haskell.Exts.Syntax type Rep (ExportSpec l) = D1 (MetaData "ExportSpec" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) ((C1 (MetaCons "EVar" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l))) :+: C1 (MetaCons "EAbs" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Namespace l)) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l))))) :+: (C1 (MetaCons "EThingWith" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (EWildcard l))) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l)) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [CName l]))) :+: C1 (MetaCons "EModuleContents" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ModuleName l)))))

data EWildcard l #

Indicates the position of the wildcard in an export list

Constructors

NoWildcard l
EWildcard l Int

Instances

Functor EWildcard #
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> EWildcard a -> EWildcard b # (<$) :: a -> EWildcard b -> EWildcard a #
Foldable EWildcard #
Instance details Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => EWildcard m -> m # foldMap :: Monoid m => (a -> m) -> EWildcard a -> m # foldr :: (a -> b -> b) -> b -> EWildcard a -> b # foldr' :: (a -> b -> b) -> b -> EWildcard a -> b # foldl :: (b -> a -> b) -> b -> EWildcard a -> b # foldl' :: (b -> a -> b) -> b -> EWildcard a -> b # foldr1 :: (a -> a -> a) -> EWildcard a -> a # foldl1 :: (a -> a -> a) -> EWildcard a -> a # toList :: EWildcard a -> [a] # null :: EWildcard a -> Bool # length :: EWildcard a -> Int # elem :: Eq a => a -> EWildcard a -> Bool # maximum :: Ord a => EWildcard a -> a # minimum :: Ord a => EWildcard a -> a # sum :: Num a => EWildcard a -> a # product :: Num a => EWildcard a -> a #
Traversable EWildcard #
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> EWildcard a -> f (EWildcard b) # sequenceA :: Applicative f => EWildcard (f a) -> f (EWildcard a) # mapM :: Monad m => (a -> m b) -> EWildcard a -> m (EWildcard b) # sequence :: Monad m => EWildcard (m a) -> m (EWildcard a) #
Annotated EWildcard #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: EWildcard l -> l # amap :: (l -> l) -> EWildcard l -> EWildcard l #
Eq l => Eq (EWildcard l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: EWildcard l -> EWildcard l -> Bool # (/=) :: EWildcard l -> EWildcard l -> Bool #
Data l => Data (EWildcard l) #
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) -> EWildcard l -> c (EWildcard l) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (EWildcard l) # toConstr :: EWildcard l -> Constr # dataTypeOf :: EWildcard l -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (EWildcard l)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (EWildcard l)) # gmapT :: (forall b. Data b => b -> b) -> EWildcard l -> EWildcard l # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> EWildcard l -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> EWildcard l -> r # gmapQ :: (forall d. Data d => d -> u) -> EWildcard l -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> EWildcard l -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> EWildcard l -> m (EWildcard l) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> EWildcard l -> m (EWildcard l) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> EWildcard l -> m (EWildcard l) #
Ord l => Ord (EWildcard l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: EWildcard l -> EWildcard l -> Ordering # (<) :: EWildcard l -> EWildcard l -> Bool # (<=) :: EWildcard l -> EWildcard l -> Bool # (>) :: EWildcard l -> EWildcard l -> Bool # (>=) :: EWildcard l -> EWildcard l -> Bool # max :: EWildcard l -> EWildcard l -> EWildcard l # min :: EWildcard l -> EWildcard l -> EWildcard l #
Show l => Show (EWildcard l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> EWildcard l -> ShowS # show :: EWildcard l -> String # showList :: [EWildcard l] -> ShowS #
Generic (EWildcard l) #
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (EWildcard l) :: Type -> Type # Methods from :: EWildcard l -> Rep (EWildcard l) x # to :: Rep (EWildcard l) x -> EWildcard l #
type Rep (EWildcard l) #
Instance details Defined in Language.Haskell.Exts.Syntax type Rep (EWildcard l) = D1 (MetaData "EWildcard" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "NoWildcard" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) :+: C1 (MetaCons "EWildcard" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int)))

data ImportDecl l #

An import declaration.

Constructors

ImportDecl

Fields

importAnn :: l
annotation, used by parser for position of the import keyword.
importModule :: ModuleName l
name of the module imported.
importQualified :: Bool
imported qualified?
importSrc :: Bool
imported with {-# SOURCE #-}?
importSafe :: Bool
Import safe?
importPkg :: Maybe String
imported with explicit package name
importAs :: Maybe (ModuleName l)
optional alias name in an as clause.
importSpecs :: Maybe (ImportSpecList l)
optional list of import specifications.

Instances

Functor ImportDecl #
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> ImportDecl a -> ImportDecl b # (<$) :: a -> ImportDecl b -> ImportDecl a #
Foldable ImportDecl #
Instance details Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => ImportDecl m -> m # foldMap :: Monoid m => (a -> m) -> ImportDecl a -> m # foldr :: (a -> b -> b) -> b -> ImportDecl a -> b # foldr' :: (a -> b -> b) -> b -> ImportDecl a -> b # foldl :: (b -> a -> b) -> b -> ImportDecl a -> b # foldl' :: (b -> a -> b) -> b -> ImportDecl a -> b # foldr1 :: (a -> a -> a) -> ImportDecl a -> a # foldl1 :: (a -> a -> a) -> ImportDecl a -> a # toList :: ImportDecl a -> [a] # null :: ImportDecl a -> Bool # length :: ImportDecl a -> Int # elem :: Eq a => a -> ImportDecl a -> Bool # maximum :: Ord a => ImportDecl a -> a # minimum :: Ord a => ImportDecl a -> a # sum :: Num a => ImportDecl a -> a # product :: Num a => ImportDecl a -> a #
Traversable ImportDecl #
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> ImportDecl a -> f (ImportDecl b) # sequenceA :: Applicative f => ImportDecl (f a) -> f (ImportDecl a) # mapM :: Monad m => (a -> m b) -> ImportDecl a -> m (ImportDecl b) # sequence :: Monad m => ImportDecl (m a) -> m (ImportDecl a) #
Annotated ImportDecl #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: ImportDecl l -> l # amap :: (l -> l) -> ImportDecl l -> ImportDecl l #
ExactP ImportDecl #
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: ImportDecl SrcSpanInfo -> EP ()
Eq l => Eq (ImportDecl l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: ImportDecl l -> ImportDecl l -> Bool # (/=) :: ImportDecl l -> ImportDecl l -> Bool #
Data l => Data (ImportDecl l) #
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) -> ImportDecl l -> c (ImportDecl l) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ImportDecl l) # toConstr :: ImportDecl l -> Constr # dataTypeOf :: ImportDecl l -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ImportDecl l)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ImportDecl l)) # gmapT :: (forall b. Data b => b -> b) -> ImportDecl l -> ImportDecl l # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ImportDecl l -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ImportDecl l -> r # gmapQ :: (forall d. Data d => d -> u) -> ImportDecl l -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ImportDecl l -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ImportDecl l -> m (ImportDecl l) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportDecl l -> m (ImportDecl l) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportDecl l -> m (ImportDecl l) #
Ord l => Ord (ImportDecl l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: ImportDecl l -> ImportDecl l -> Ordering # (<) :: ImportDecl l -> ImportDecl l -> Bool # (<=) :: ImportDecl l -> ImportDecl l -> Bool # (>) :: ImportDecl l -> ImportDecl l -> Bool # (>=) :: ImportDecl l -> ImportDecl l -> Bool # max :: ImportDecl l -> ImportDecl l -> ImportDecl l # min :: ImportDecl l -> ImportDecl l -> ImportDecl l #
Show l => Show (ImportDecl l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> ImportDecl l -> ShowS # show :: ImportDecl l -> String # showList :: [ImportDecl l] -> ShowS #
Generic (ImportDecl l) #
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (ImportDecl l) :: Type -> Type # Methods from :: ImportDecl l -> Rep (ImportDecl l) x # to :: Rep (ImportDecl l) x -> ImportDecl l #
Pretty (ImportDecl l) #
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: ImportDecl l -> Doc prettyPrec :: Int -> ImportDecl l -> Doc
Parseable (ImportDecl SrcSpanInfo) #
Instance details Defined in Language.Haskell.Exts.Parser Methods parse :: String -> ParseResult (ImportDecl SrcSpanInfo) # parseWithMode :: ParseMode -> String -> ParseResult (ImportDecl SrcSpanInfo) # parseWithComments :: ParseMode -> String -> ParseResult (ImportDecl SrcSpanInfo, [Comment]) # parser :: Maybe [Fixity] -> P (ImportDecl SrcSpanInfo)
type Rep (ImportDecl l) #
Instance details Defined in Language.Haskell.Exts.Syntax type Rep (ImportDecl l) = D1 (MetaData "ImportDecl" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "ImportDecl" PrefixI True) (((S1 (MetaSel (Just "importAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :: S1 (MetaSel (Just "importModule") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ModuleName l))) :: (S1 (MetaSel (Just "importQualified") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Bool) :: S1 (MetaSel (Just "importSrc") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Bool))) :: ((S1 (MetaSel (Just "importSafe") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Bool) :: S1 (MetaSel (Just "importPkg") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe String))) :: (S1 (MetaSel (Just "importAs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (ModuleName l))) :*: S1 (MetaSel (Just "importSpecs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (ImportSpecList l)))))))

data ImportSpecList l #

An explicit import specification list.

Constructors

ImportSpecList l Bool [ImportSpec l]

Instances

Functor ImportSpecList #
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> ImportSpecList a -> ImportSpecList b # (<$) :: a -> ImportSpecList b -> ImportSpecList a #
Foldable ImportSpecList #
Instance details Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => ImportSpecList m -> m # foldMap :: Monoid m => (a -> m) -> ImportSpecList a -> m # foldr :: (a -> b -> b) -> b -> ImportSpecList a -> b # foldr' :: (a -> b -> b) -> b -> ImportSpecList a -> b # foldl :: (b -> a -> b) -> b -> ImportSpecList a -> b # foldl' :: (b -> a -> b) -> b -> ImportSpecList a -> b # foldr1 :: (a -> a -> a) -> ImportSpecList a -> a # foldl1 :: (a -> a -> a) -> ImportSpecList a -> a # toList :: ImportSpecList a -> [a] # null :: ImportSpecList a -> Bool # length :: ImportSpecList a -> Int # elem :: Eq a => a -> ImportSpecList a -> Bool # maximum :: Ord a => ImportSpecList a -> a # minimum :: Ord a => ImportSpecList a -> a # sum :: Num a => ImportSpecList a -> a # product :: Num a => ImportSpecList a -> a #
Traversable ImportSpecList #
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> ImportSpecList a -> f (ImportSpecList b) # sequenceA :: Applicative f => ImportSpecList (f a) -> f (ImportSpecList a) # mapM :: Monad m => (a -> m b) -> ImportSpecList a -> m (ImportSpecList b) # sequence :: Monad m => ImportSpecList (m a) -> m (ImportSpecList a) #
Annotated ImportSpecList #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: ImportSpecList l -> l # amap :: (l -> l) -> ImportSpecList l -> ImportSpecList l #
ExactP ImportSpecList #
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: ImportSpecList SrcSpanInfo -> EP ()
Eq l => Eq (ImportSpecList l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: ImportSpecList l -> ImportSpecList l -> Bool # (/=) :: ImportSpecList l -> ImportSpecList l -> Bool #
Data l => Data (ImportSpecList l) #
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) -> ImportSpecList l -> c (ImportSpecList l) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ImportSpecList l) # toConstr :: ImportSpecList l -> Constr # dataTypeOf :: ImportSpecList l -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ImportSpecList l)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ImportSpecList l)) # gmapT :: (forall b. Data b => b -> b) -> ImportSpecList l -> ImportSpecList l # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ImportSpecList l -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ImportSpecList l -> r # gmapQ :: (forall d. Data d => d -> u) -> ImportSpecList l -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ImportSpecList l -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ImportSpecList l -> m (ImportSpecList l) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportSpecList l -> m (ImportSpecList l) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportSpecList l -> m (ImportSpecList l) #
Ord l => Ord (ImportSpecList l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: ImportSpecList l -> ImportSpecList l -> Ordering # (<) :: ImportSpecList l -> ImportSpecList l -> Bool # (<=) :: ImportSpecList l -> ImportSpecList l -> Bool # (>) :: ImportSpecList l -> ImportSpecList l -> Bool # (>=) :: ImportSpecList l -> ImportSpecList l -> Bool # max :: ImportSpecList l -> ImportSpecList l -> ImportSpecList l # min :: ImportSpecList l -> ImportSpecList l -> ImportSpecList l #
Show l => Show (ImportSpecList l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> ImportSpecList l -> ShowS # show :: ImportSpecList l -> String # showList :: [ImportSpecList l] -> ShowS #
Generic (ImportSpecList l) #
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (ImportSpecList l) :: Type -> Type # Methods from :: ImportSpecList l -> Rep (ImportSpecList l) x # to :: Rep (ImportSpecList l) x -> ImportSpecList l #
Pretty (ImportSpecList l) #
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: ImportSpecList l -> Doc prettyPrec :: Int -> ImportSpecList l -> Doc
type Rep (ImportSpecList l) #
Instance details Defined in Language.Haskell.Exts.Syntax type Rep (ImportSpecList l) = D1 (MetaData "ImportSpecList" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "ImportSpecList" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Bool) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [ImportSpec l]))))

data ImportSpec l #

An import specification, representing a single explicit item imported (or hidden) from a module.

Constructors

IVar l (Name l)	variable
IAbs l (Namespace l) (Name l)	`T`: the name of a class, datatype or type synonym.
IThingAll l (Name l)	`T(..)`: a class imported with all of its methods, or a datatype imported with all of its constructors.
IThingWith l (Name l) [CName l]	`T(C_1,...,C_n)`: a class imported with some of its methods, or a datatype imported with some of its constructors.

Instances

Functor ImportSpec #
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> ImportSpec a -> ImportSpec b # (<$) :: a -> ImportSpec b -> ImportSpec a #
Foldable ImportSpec #
Instance details Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => ImportSpec m -> m # foldMap :: Monoid m => (a -> m) -> ImportSpec a -> m # foldr :: (a -> b -> b) -> b -> ImportSpec a -> b # foldr' :: (a -> b -> b) -> b -> ImportSpec a -> b # foldl :: (b -> a -> b) -> b -> ImportSpec a -> b # foldl' :: (b -> a -> b) -> b -> ImportSpec a -> b # foldr1 :: (a -> a -> a) -> ImportSpec a -> a # foldl1 :: (a -> a -> a) -> ImportSpec a -> a # toList :: ImportSpec a -> [a] # null :: ImportSpec a -> Bool # length :: ImportSpec a -> Int # elem :: Eq a => a -> ImportSpec a -> Bool # maximum :: Ord a => ImportSpec a -> a # minimum :: Ord a => ImportSpec a -> a # sum :: Num a => ImportSpec a -> a # product :: Num a => ImportSpec a -> a #
Traversable ImportSpec #
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> ImportSpec a -> f (ImportSpec b) # sequenceA :: Applicative f => ImportSpec (f a) -> f (ImportSpec a) # mapM :: Monad m => (a -> m b) -> ImportSpec a -> m (ImportSpec b) # sequence :: Monad m => ImportSpec (m a) -> m (ImportSpec a) #
Annotated ImportSpec #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: ImportSpec l -> l # amap :: (l -> l) -> ImportSpec l -> ImportSpec l #
ExactP ImportSpec #
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: ImportSpec SrcSpanInfo -> EP ()
Eq l => Eq (ImportSpec l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: ImportSpec l -> ImportSpec l -> Bool # (/=) :: ImportSpec l -> ImportSpec l -> Bool #
Data l => Data (ImportSpec l) #
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) -> ImportSpec l -> c (ImportSpec l) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ImportSpec l) # toConstr :: ImportSpec l -> Constr # dataTypeOf :: ImportSpec l -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ImportSpec l)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ImportSpec l)) # gmapT :: (forall b. Data b => b -> b) -> ImportSpec l -> ImportSpec l # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ImportSpec l -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ImportSpec l -> r # gmapQ :: (forall d. Data d => d -> u) -> ImportSpec l -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ImportSpec l -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ImportSpec l -> m (ImportSpec l) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportSpec l -> m (ImportSpec l) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportSpec l -> m (ImportSpec l) #
Ord l => Ord (ImportSpec l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: ImportSpec l -> ImportSpec l -> Ordering # (<) :: ImportSpec l -> ImportSpec l -> Bool # (<=) :: ImportSpec l -> ImportSpec l -> Bool # (>) :: ImportSpec l -> ImportSpec l -> Bool # (>=) :: ImportSpec l -> ImportSpec l -> Bool # max :: ImportSpec l -> ImportSpec l -> ImportSpec l # min :: ImportSpec l -> ImportSpec l -> ImportSpec l #
Show l => Show (ImportSpec l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> ImportSpec l -> ShowS # show :: ImportSpec l -> String # showList :: [ImportSpec l] -> ShowS #
Generic (ImportSpec l) #
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (ImportSpec l) :: Type -> Type # Methods from :: ImportSpec l -> Rep (ImportSpec l) x # to :: Rep (ImportSpec l) x -> ImportSpec l #
Pretty (ImportSpec l) #
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: ImportSpec l -> Doc prettyPrec :: Int -> ImportSpec l -> Doc
type Rep (ImportSpec l) #
Instance details Defined in Language.Haskell.Exts.Syntax type Rep (ImportSpec l) = D1 (MetaData "ImportSpec" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) ((C1 (MetaCons "IVar" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Name l))) :+: C1 (MetaCons "IAbs" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Namespace l)) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Name l))))) :+: (C1 (MetaCons "IThingAll" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Name l))) :+: C1 (MetaCons "IThingWith" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Name l)) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [CName l])))))

data Assoc l #

Associativity of an operator.

Constructors

AssocNone l	non-associative operator (declared with `infix`)
AssocLeft l	left-associative operator (declared with `infixl`).
AssocRight l	right-associative operator (declared with `infixr`)

Instances

Functor Assoc #
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> Assoc a -> Assoc b # (<$) :: a -> Assoc b -> Assoc a #
Foldable Assoc #
Instance details Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Assoc m -> m # foldMap :: Monoid m => (a -> m) -> Assoc a -> m # foldr :: (a -> b -> b) -> b -> Assoc a -> b # foldr' :: (a -> b -> b) -> b -> Assoc a -> b # foldl :: (b -> a -> b) -> b -> Assoc a -> b # foldl' :: (b -> a -> b) -> b -> Assoc a -> b # foldr1 :: (a -> a -> a) -> Assoc a -> a # foldl1 :: (a -> a -> a) -> Assoc a -> a # toList :: Assoc a -> [a] # null :: Assoc a -> Bool # length :: Assoc a -> Int # elem :: Eq a => a -> Assoc a -> Bool # maximum :: Ord a => Assoc a -> a # minimum :: Ord a => Assoc a -> a # sum :: Num a => Assoc a -> a # product :: Num a => Assoc a -> a #
Traversable Assoc #
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> Assoc a -> f (Assoc b) # sequenceA :: Applicative f => Assoc (f a) -> f (Assoc a) # mapM :: Monad m => (a -> m b) -> Assoc a -> m (Assoc b) # sequence :: Monad m => Assoc (m a) -> m (Assoc a) #
Annotated Assoc #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Assoc l -> l # amap :: (l -> l) -> Assoc l -> Assoc l #
ExactP Assoc #
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Assoc SrcSpanInfo -> EP ()
Eq l => Eq (Assoc l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: Assoc l -> Assoc l -> Bool # (/=) :: Assoc l -> Assoc l -> Bool #
Data l => Data (Assoc l) #
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) -> Assoc l -> c (Assoc l) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Assoc l) # toConstr :: Assoc l -> Constr # dataTypeOf :: Assoc l -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Assoc l)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Assoc l)) # gmapT :: (forall b. Data b => b -> b) -> Assoc l -> Assoc l # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Assoc l -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Assoc l -> r # gmapQ :: (forall d. Data d => d -> u) -> Assoc l -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Assoc l -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Assoc l -> m (Assoc l) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Assoc l -> m (Assoc l) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Assoc l -> m (Assoc l) #
Ord l => Ord (Assoc l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: Assoc l -> Assoc l -> Ordering # (<) :: Assoc l -> Assoc l -> Bool # (<=) :: Assoc l -> Assoc l -> Bool # (>) :: Assoc l -> Assoc l -> Bool # (>=) :: Assoc l -> Assoc l -> Bool # max :: Assoc l -> Assoc l -> Assoc l # min :: Assoc l -> Assoc l -> Assoc l #
Show l => Show (Assoc l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> Assoc l -> ShowS # show :: Assoc l -> String # showList :: [Assoc l] -> ShowS #
Generic (Assoc l) #
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Assoc l) :: Type -> Type # Methods from :: Assoc l -> Rep (Assoc l) x # to :: Rep (Assoc l) x -> Assoc l #
Pretty (Assoc l) #
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: Assoc l -> Doc prettyPrec :: Int -> Assoc l -> Doc
type Rep (Assoc l) #
Instance details Defined in Language.Haskell.Exts.Syntax type Rep (Assoc l) = D1 (MetaData "Assoc" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "AssocNone" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) :+: (C1 (MetaCons "AssocLeft" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) :+: C1 (MetaCons "AssocRight" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l))))

data Namespace l #

Namespaces for imports/exports.

Constructors

NoNamespace l
TypeNamespace l
PatternNamespace l

Instances

Functor Namespace #
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> Namespace a -> Namespace b # (<$) :: a -> Namespace b -> Namespace a #
Foldable Namespace #
Instance details Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Namespace m -> m # foldMap :: Monoid m => (a -> m) -> Namespace a -> m # foldr :: (a -> b -> b) -> b -> Namespace a -> b # foldr' :: (a -> b -> b) -> b -> Namespace a -> b # foldl :: (b -> a -> b) -> b -> Namespace a -> b # foldl' :: (b -> a -> b) -> b -> Namespace a -> b # foldr1 :: (a -> a -> a) -> Namespace a -> a # foldl1 :: (a -> a -> a) -> Namespace a -> a # toList :: Namespace a -> [a] # null :: Namespace a -> Bool # length :: Namespace a -> Int # elem :: Eq a => a -> Namespace a -> Bool # maximum :: Ord a => Namespace a -> a # minimum :: Ord a => Namespace a -> a # sum :: Num a => Namespace a -> a # product :: Num a => Namespace a -> a #
Traversable Namespace #
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> Namespace a -> f (Namespace b) # sequenceA :: Applicative f => Namespace (f a) -> f (Namespace a) # mapM :: Monad m => (a -> m b) -> Namespace a -> m (Namespace b) # sequence :: Monad m => Namespace (m a) -> m (Namespace a) #
Annotated Namespace #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Namespace l -> l # amap :: (l -> l) -> Namespace l -> Namespace l #
ExactP Namespace #
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Namespace SrcSpanInfo -> EP ()
Eq l => Eq (Namespace l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: Namespace l -> Namespace l -> Bool # (/=) :: Namespace l -> Namespace l -> Bool #
Data l => Data (Namespace l) #
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) -> Namespace l -> c (Namespace l) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Namespace l) # toConstr :: Namespace l -> Constr # dataTypeOf :: Namespace l -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Namespace l)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Namespace l)) # gmapT :: (forall b. Data b => b -> b) -> Namespace l -> Namespace l # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Namespace l -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Namespace l -> r # gmapQ :: (forall d. Data d => d -> u) -> Namespace l -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Namespace l -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Namespace l -> m (Namespace l) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Namespace l -> m (Namespace l) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Namespace l -> m (Namespace l) #
Ord l => Ord (Namespace l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: Namespace l -> Namespace l -> Ordering # (<) :: Namespace l -> Namespace l -> Bool # (<=) :: Namespace l -> Namespace l -> Bool # (>) :: Namespace l -> Namespace l -> Bool # (>=) :: Namespace l -> Namespace l -> Bool # max :: Namespace l -> Namespace l -> Namespace l # min :: Namespace l -> Namespace l -> Namespace l #
Show l => Show (Namespace l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> Namespace l -> ShowS # show :: Namespace l -> String # showList :: [Namespace l] -> ShowS #
Generic (Namespace l) #
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Namespace l) :: Type -> Type # Methods from :: Namespace l -> Rep (Namespace l) x # to :: Rep (Namespace l) x -> Namespace l #
Pretty (Namespace l) #
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: Namespace l -> Doc prettyPrec :: Int -> Namespace l -> Doc
type Rep (Namespace l) #
Instance details Defined in Language.Haskell.Exts.Syntax type Rep (Namespace l) = D1 (MetaData "Namespace" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (C1 (MetaCons "NoNamespace" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) :+: (C1 (MetaCons "TypeNamespace" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) :+: C1 (MetaCons "PatternNamespace" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l))))

Declarations

data Decl l #

A top-level declaration.

Constructors

TypeDecl l (DeclHead l) (Type l)	A type declaration
TypeFamDecl l (DeclHead l) (Maybe (ResultSig l)) (Maybe (InjectivityInfo l))	A type family declaration
ClosedTypeFamDecl l (DeclHead l) (Maybe (ResultSig l)) (Maybe (InjectivityInfo l)) [TypeEqn l]	A closed type family declaration
DataDecl l (DataOrNew l) (Maybe (Context l)) (DeclHead l) [QualConDecl l] [Deriving l]	A data OR newtype declaration
GDataDecl l (DataOrNew l) (Maybe (Context l)) (DeclHead l) (Maybe (Kind l)) [GadtDecl l] [Deriving l]	A data OR newtype declaration, GADT style
DataFamDecl l (Maybe (Context l)) (DeclHead l) (Maybe (ResultSig l))	A data family declaration
TypeInsDecl l (Type l) (Type l)	A type family instance declaration
DataInsDecl l (DataOrNew l) (Type l) [QualConDecl l] [Deriving l]	A data family instance declaration
GDataInsDecl l (DataOrNew l) (Type l) (Maybe (Kind l)) [GadtDecl l] [Deriving l]	A data family instance declaration, GADT style
ClassDecl l (Maybe (Context l)) (DeclHead l) [FunDep l] (Maybe [ClassDecl l])	A declaration of a type class
InstDecl l (Maybe (Overlap l)) (InstRule l) (Maybe [InstDecl l])	An declaration of a type class instance
DerivDecl l (Maybe (DerivStrategy l)) (Maybe (Overlap l)) (InstRule l)	A standalone deriving declaration
InfixDecl l (Assoc l) (Maybe Int) [Op l]	A declaration of operator fixity
DefaultDecl l [Type l]	A declaration of default types
SpliceDecl l (Exp l)	A Template Haskell splicing declaration
TypeSig l [Name l] (Type l)	A type signature declaration
PatSynSig l [Name l] (Maybe [TyVarBind l]) (Maybe (Context l)) (Maybe (Context l)) (Type l)	A pattern synonym signature declation
FunBind l [Match l]	A set of function binding clauses
PatBind l (Pat l) (Rhs l) (Maybe (Binds l))	A pattern binding
PatSyn l (Pat l) (Pat l) (PatternSynDirection l)	A pattern synonym binding
ForImp l (CallConv l) (Maybe (Safety l)) (Maybe String) (Name l) (Type l)	A foreign import declaration
ForExp l (CallConv l) (Maybe String) (Name l) (Type l)	A foreign export declaration
RulePragmaDecl l [Rule l]	A RULES pragma
DeprPragmaDecl l [([Name l], String)]	A DEPRECATED pragma
WarnPragmaDecl l [([Name l], String)]	A WARNING pragma
InlineSig l Bool (Maybe (Activation l)) (QName l)	An INLINE pragma
InlineConlikeSig l (Maybe (Activation l)) (QName l)	An INLINE CONLIKE pragma
SpecSig l (Maybe (Activation l)) (QName l) [Type l]	A SPECIALISE pragma
SpecInlineSig l Bool (Maybe (Activation l)) (QName l) [Type l]	A SPECIALISE INLINE pragma
InstSig l (InstRule l)	A SPECIALISE instance pragma
AnnPragma l (Annotation l)	An ANN pragma
MinimalPragma l (Maybe (BooleanFormula l))	A MINIMAL pragma
RoleAnnotDecl l (QName l) [Role l]	A role annotation
CompletePragma l [Name l] (Maybe (QName l))	A COMPLETE pragma

Instances

Functor Decl #
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> Decl a -> Decl b # (<$) :: a -> Decl b -> Decl a #
Foldable Decl #
Instance details Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Decl m -> m # foldMap :: Monoid m => (a -> m) -> Decl a -> m # foldr :: (a -> b -> b) -> b -> Decl a -> b # foldr' :: (a -> b -> b) -> b -> Decl a -> b # foldl :: (b -> a -> b) -> b -> Decl a -> b # foldl' :: (b -> a -> b) -> b -> Decl a -> b # foldr1 :: (a -> a -> a) -> Decl a -> a # foldl1 :: (a -> a -> a) -> Decl a -> a # toList :: Decl a -> [a] # null :: Decl a -> Bool # length :: Decl a -> Int # elem :: Eq a => a -> Decl a -> Bool # maximum :: Ord a => Decl a -> a # minimum :: Ord a => Decl a -> a # sum :: Num a => Decl a -> a # product :: Num a => Decl a -> a #
Traversable Decl #
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> Decl a -> f (Decl b) # sequenceA :: Applicative f => Decl (f a) -> f (Decl a) # mapM :: Monad m => (a -> m b) -> Decl a -> m (Decl b) # sequence :: Monad m => Decl (m a) -> m (Decl a) #
Annotated Decl #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Decl l -> l # amap :: (l -> l) -> Decl l -> Decl l #
AppFixity Decl #
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: Monad m => [Fixity] -> Decl SrcSpanInfo -> m (Decl SrcSpanInfo) #
ExactP Decl #
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Decl SrcSpanInfo -> EP ()
Eq l => Eq (Decl l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: Decl l -> Decl l -> Bool # (/=) :: Decl l -> Decl l -> Bool #
Data l => Data (Decl l) #
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) -> Decl l -> c (Decl l) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Decl l) # toConstr :: Decl l -> Constr # dataTypeOf :: Decl l -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Decl l)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Decl l)) # gmapT :: (forall b. Data b => b -> b) -> Decl l -> Decl l # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Decl l -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Decl l -> r # gmapQ :: (forall d. Data d => d -> u) -> Decl l -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Decl l -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Decl l -> m (Decl l) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Decl l -> m (Decl l) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Decl l -> m (Decl l) #
Ord l => Ord (Decl l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: Decl l -> Decl l -> Ordering # (<) :: Decl l -> Decl l -> Bool # (<=) :: Decl l -> Decl l -> Bool # (>) :: Decl l -> Decl l -> Bool # (>=) :: Decl l -> Decl l -> Bool # max :: Decl l -> Decl l -> Decl l # min :: Decl l -> Decl l -> Decl l #
Show l => Show (Decl l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> Decl l -> ShowS # show :: Decl l -> String # showList :: [Decl l] -> ShowS #
Generic (Decl l) #
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Decl l) :: Type -> Type # Methods from :: Decl l -> Rep (Decl l) x # to :: Rep (Decl l) x -> Decl l #
Pretty (Decl l) #
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: Decl l -> Doc prettyPrec :: Int -> Decl l -> Doc
Parseable (Decl SrcSpanInfo) #
Instance details Defined in Language.Haskell.Exts.Parser Methods parse :: String -> ParseResult (Decl SrcSpanInfo) # parseWithMode :: ParseMode -> String -> ParseResult (Decl SrcSpanInfo) # parseWithComments :: ParseMode -> String -> ParseResult (Decl SrcSpanInfo, [Comment]) # parser :: Maybe [Fixity] -> P (Decl SrcSpanInfo)
type Rep (Decl l) #
Instance details Defined in Language.Haskell.Exts.Syntax type Rep (Decl l) = D1 (MetaData "Decl" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-2fryh11Yuz7lCtLeeIQn8" False) (((((C1 (MetaCons "TypeDecl" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DeclHead l)) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)))) :+: C1 (MetaCons "TypeFamDecl" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DeclHead l))) :: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (ResultSig l))) :: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (InjectivityInfo l)))))) :+: (C1 (MetaCons "ClosedTypeFamDecl" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) ::