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-Inferred
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)
- | TSpliceDecl l (Exp l)
- | TypeSig l [Name l] (Type l)
- | PatSynSig l [Name l] (Maybe [TyVarBind l]) (Maybe (Context l)) (Maybe [TyVarBind 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
- | DerivVia l (Type 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 [TyVarBind l]) (Maybe (Context 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
- = TypeA l (Type l)
- | IParam l (IPName l) (Type l)
- | ParenA l (Asst l)
data Type l
- = TyForall l (Maybe [TyVarBind l]) (Maybe (Context l)) (Type l)
- | TyStar 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
type Kind = Type
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)
- | ArrOp 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)
- | TExpBracket l (Exp l)
- | PatBracket l (Pat l)
- | TypeBracket l (Type l)
- | DeclBracket l [Decl l]
data Splice l
- = IdSplice l String
- | TIdSplice l String
- | ParenSplice l (Exp l)
- | TParenSplice 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_con_name :: l -> 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
via_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

Instances details

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 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 :: MonadFail 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 :: forall r r'. (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.23.0-HDJqfY1ItZ576ObW4UQhzC" '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

Instances details

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 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 :: forall r r'. (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.23.0-HDJqfY1ItZ576ObW4UQhzC" '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

Instances details

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 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 :: forall r r'. (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.23.0-HDJqfY1ItZ576ObW4UQhzC" '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

Instances details

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 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 :: forall r r'. (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.23.0-HDJqfY1ItZ576ObW4UQhzC" '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

Instances details

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 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 :: forall r r'. (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.23.0-HDJqfY1ItZ576ObW4UQhzC" '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

Instances details

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 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 :: forall r r'. (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.23.0-HDJqfY1ItZ576ObW4UQhzC" '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

Instances details

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 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 :: forall r r'. (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.23.0-HDJqfY1ItZ576ObW4UQhzC" '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]

A list of import specifications. The Bool is True if the names are excluded by hiding.

Instances

Instances details

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 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 :: forall r r'. (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.23.0-HDJqfY1ItZ576ObW4UQhzC" '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

Instances details

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 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 :: forall r r'. (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.23.0-HDJqfY1ItZ576ObW4UQhzC" '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

Instances details

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 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 :: forall r r'. (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.23.0-HDJqfY1ItZ576ObW4UQhzC" '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

Instances details

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 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 :: forall r r'. (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.23.0-HDJqfY1ItZ576ObW4UQhzC" '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
TSpliceDecl l (Exp l)	A typed 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 [TyVarBind 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

Instances details

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 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 :: MonadFail 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 :: forall r r'. (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.23.0-HDJqfY1ItZ576ObW4UQhzC" '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) :: 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))) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [TypeEqn l])))) :+: C1 ('MetaCons "DataDecl" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (DataOrNew l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (Context l))))) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (DeclHead l)) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [QualConDecl l]) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Deriving l])))))) :+: ((C1 ('MetaCons "GDataDecl" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (DataOrNew l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (Context l))))) :: ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (DeclHead l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (Kind l)))) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [GadtDecl l]) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Deriving l])))) :+: C1 ('MetaCons "DataFamDecl" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (Context l)))) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (DeclHead l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (ResultSig l)))))) :+: (C1 ('MetaCons "TypeInsDecl" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Type l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Type l)))) :+: C1 ('MetaCons "DataInsDecl" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (DataOrNew l))) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Type l)) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [QualConDecl l]) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Deriving l]))))))) :+: (((C1 ('MetaCons "GDataInsDecl" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (DataOrNew l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Type l)))) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (Kind l))) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [GadtDecl l]) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Deriving l])))) :+: C1 ('MetaCons "ClassDecl" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (Context l)))) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (DeclHead l)) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [FunDep l]) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe [ClassDecl l])))))) :+: (C1 ('MetaCons "InstDecl" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (Overlap l)))) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (InstRule l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe [InstDecl l])))) :+: C1 ('MetaCons "DerivDecl" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (DerivStrategy l)))) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (Overlap l))) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (InstRule l)))))) :+: ((C1 ('MetaCons "InfixDecl" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Assoc l))) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Int)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Op l]))) :+: C1 ('MetaCons "DefaultDecl" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Type l]))) :+: (C1 ('MetaCons "SpliceDecl" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l))) :+: (C1 ('MetaCons "TSpliceDecl" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l))) :+: C1 ('MetaCons "TypeSig" '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 (Type l))))))))) :+: ((((C1 ('MetaCons "PatSynSig" '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 (Maybe [TyVarBind l])))) :: ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (Context l))) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe [TyVarBind l]))) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (Context l))) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Type l))))) :+: C1 ('MetaCons "FunBind" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Match l]))) :+: (C1 ('MetaCons "PatBind" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Pat l))) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Rhs l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (Binds l))))) :+: C1 ('MetaCons "PatSyn" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Pat l))) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Pat l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (PatternSynDirection l)))))) :+: ((C1 ('MetaCons "ForImp" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (CallConv l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (Safety l))))) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe String)) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Name l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Type l))))) :+: C1 ('MetaCons "ForExp" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (CallConv l))) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe String)) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Name l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Type l)))))) :+: (C1 ('MetaCons "RulePragmaDecl" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Rule l])) :+: (C1 ('MetaCons "DeprPragmaDecl" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [([Name l], String)])) :+: C1 ('MetaCons "WarnPragmaDecl" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [([Name l], String)])))))) :+: (((C1 ('MetaCons "InlineSig" '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 (Maybe (Activation l))) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (QName l)))) :+: C1 ('MetaCons "InlineConlikeSig" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (Activation l))) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (QName l))))) :+: (C1 ('MetaCons "SpecSig" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (Activation l)))) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (QName l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Type l]))) :+: C1 ('MetaCons "SpecInlineSig" '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 (Maybe (Activation l))) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (QName l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Type l])))))) :+: ((C1 ('MetaCons "InstSig" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (InstRule l))) :+: C1 ('MetaCons "AnnPragma" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Annotation l)))) :+: (C1 ('MetaCons "MinimalPragma" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (BooleanFormula l)))) :+: (C1 ('MetaCons "RoleAnnotDecl" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (QName l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Role l]))) :+: C1 ('MetaCons "CompletePragma" '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 (Maybe (QName l)))))))))))

data DeclHead l #

The head of a type or class declaration, which consists of the type or class name applied to some type variables

class C a b is represented as

DHApp
   ()
   (DHApp
      () (DHead () (Ident () "C")) (UnkindedVar () (Ident () "a")))
   (UnkindedVar () (Ident () "b"))

(where the annotation type l is instantiated with ())

class (a :< b) c is represented as

DHApp
   ()
   (DHParen
      ()
      (DHApp
         ()
         (DHInfix () (UnkindedVar () (Ident () "a")) (Symbol () ":<"))
         (UnkindedVar () (Ident () "b"))))
   (UnkindedVar () (Ident () "c"))

Constructors

DHead l (Name l)	type or class name
DHInfix l (TyVarBind l) (Name l)	infix application of the type/class name to the left operand
DHParen l (DeclHead l)	parenthesized declaration head
DHApp l (DeclHead l) (TyVarBind l)	application to one more type variable

Instances

Instances details

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

data InstRule l #

The instance declaration rule, which is, roughly, the part of the instance declaration before the where keyword.

Example: instance Ord a => Ord (Maybe a) is represented as

IRule
   ()
   Nothing
   (Just
      (CxSingle
         ()
         (ClassA
            () (UnQual () (Ident () "Ord")) [ TyVar () (Ident () "a") ])))
   (IHApp
      ()
      (IHCon () (UnQual () (Ident () "Ord")))
      (TyParen
         ()
         (TyApp
            ()
            (TyCon () (UnQual () (Ident () "Maybe")))
            (TyVar () (Ident () "a")))))

An optional explicit forall after instance is supported: instance forall a . Ord a => Ord (Maybe a) where becomes

IRule
   ()
   (Just [ UnkindedVar () (Ident () "a") ])
   ...

Constructors

IRule l (Maybe [TyVarBind l]) (Maybe (Context l)) (InstHead l)
IParen l (InstRule l)

Instances

Instances details

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

data InstHead l #

The instance head. The split between rule/head allow us to represent instance (Bounded a => Bounded [a]) where faithfully.

The structure of InstHead follows one of DeclHead.

For example, instance C (Maybe a) Int where is represented as

IHApp
   ()
   (IHApp
      ()
      (IHCon () (UnQual () (Ident () "C")))
      (TyParen
         ()
         (TyApp
            ()
            (TyCon () (UnQual () (Ident () "Maybe")))
            (TyVar () (Ident () "a")))))
   (TyCon () (UnQual () (Ident () "Int")))))

Constructors

IHCon l (QName l)	type or class name
IHInfix l (Type l) (QName l)	infix application of the type/class name to the left operand
IHParen l (InstHead l)	parenthesized instance head
IHApp l (InstHead l) (Type l)	application to one more type

Instances

Instances details

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

data Binds l #

A binding group inside a let or where clause.

Constructors

BDecls l [Decl l]	An ordinary binding group
IPBinds l [IPBind l]	A binding group for implicit parameters

Instances

Instances details

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

data IPBind l #

A binding of an implicit parameter.

Constructors

IPBind l (IPName l) (Exp l)

Instances

Instances details

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

data PatternSynDirection l #

Constructors

Unidirectional	A unidirectional pattern synonym with "<-"
ImplicitBidirectional	A bidirectional pattern synonym with "="
ExplicitBidirectional l [Decl l]	A birectional pattern synonym with the construction specified.

Instances

Instances details

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

data InjectivityInfo l #

Injectivity info for injective type families

Constructors

InjectivityInfo l (Name l) [Name l]

Instances

Instances details

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

data ResultSig l #

Constructors

KindSig l (Kind l)
TyVarSig l (TyVarBind l)

Instances

Instances details

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

Type classes and instances

data ClassDecl l #

Declarations inside a class declaration.

Constructors

ClsDecl l (Decl l)	ordinary declaration
ClsDataFam l (Maybe (Context l)) (DeclHead l) (Maybe (ResultSig l))	declaration of an associated data type
ClsTyFam l (DeclHead l) (Maybe (ResultSig l)) (Maybe (InjectivityInfo l))	declaration of an associated type synonym
ClsTyDef l (TypeEqn l)	default choice for an associated type synonym
ClsDefSig l (Name l) (Type l)	default signature

Instances

Instances details

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

data InstDecl l #

Declarations inside an instance declaration.

Constructors

InsDecl l (Decl l)	ordinary declaration
InsType l (Type l) (Type l)	an associated type definition
InsData l (DataOrNew l) (Type l) [QualConDecl l] [Deriving l]	an associated data type implementation
InsGData l (DataOrNew l) (Type l) (Maybe (Kind l)) [GadtDecl l] [Deriving l]	an associated data type implemented using GADT style

Instances

Instances details

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

data Deriving l #

A deriving clause following a data type declaration.

Constructors

Deriving l (Maybe (DerivStrategy l)) [InstRule l]

Instances

Instances details

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

data DerivStrategy l #

Which technique the user explicitly requested when deriving an instance.

Constructors

DerivStock l	GHC's "standard" strategy, which is to implement a custom instance for the data type. This only works for certain types that GHC knows about (e.g., `Eq`, `Show`, `Functor` when `-XDeriveFunctor` is enabled, etc.)
DerivAnyclass l	-XDeriveAnyClass
DerivNewtype l	-XGeneralizedNewtypeDeriving
DerivVia l (Type l)	-XDerivingVia

Instances

Instances details

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

Data type declarations

data DataOrNew l #

A flag stating whether a declaration is a data or newtype declaration.

Constructors

DataType l
NewType l

Instances

Instances details

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

data ConDecl l #

Declaration of an ordinary data constructor.

Constructors

ConDecl l (Name l) [Type l]	ordinary data constructor
InfixConDecl l (Type l) (Name l) (Type l)	infix data constructor
RecDecl l (Name l) [FieldDecl l]	record constructor

Instances

Instances details

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

data FieldDecl l #

Declaration of a (list of) named field(s).

Constructors

FieldDecl l [Name l] (Type l)

Instances

Instances details

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

data QualConDecl l #

A single constructor declaration within a data type declaration, which may have an existential quantification binding.

Constructors

QualConDecl l (Maybe [TyVarBind l]) (Maybe (Context l)) (ConDecl l)

Instances

Instances details

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

data GadtDecl l #

A single constructor declaration in a GADT data type declaration.

If the GADT is declared using the record syntax, e.g.

data Ty where
  TCon :: { field1 :: Int, field2 :: Bool } -> Ty

then the fields are stored as a list of FieldDecls, and the final type (Ty in the above example) is stored in the last Type field.

If the GADT is declared using the ordinary syntax, e.g.

data Ty where
  TCon :: Int -> Bool -> Ty

then Maybe [FieldDecl l] is Nothing, and the whole constructor's type (such as Int -> Bool -> Ty) is stored in the last Type field.

Constructors

GadtDecl l (Name l) (Maybe [TyVarBind l]) (Maybe (Context l)) (Maybe [FieldDecl l]) (Type l)

Instances

Instances details

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

data BangType l #

The type of a constructor argument or field, optionally including a strictness annotation.

Constructors

BangedTy l	strict component, marked with "`!`"
LazyTy l	lazy component, marked with "`~`"
NoStrictAnnot l	No strictness information

Instances

Instances details

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

data Unpackedness l #

Constructors

Unpack l	"`{-# UNPACK #-}`"
NoUnpack l	"`{-# NOUNPACK #-}`"
NoUnpackPragma l	No unpack pragma

Instances

Instances details

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

Function bindings

data Match l #

Clauses of a function binding.

Constructors

Match l (Name l) [Pat l] (Rhs l) (Maybe (Binds l))	A clause defined with prefix notation, i.e. the function name followed by its argument patterns, the right-hand side and an optional where clause.
InfixMatch l (Pat l) (Name l) [Pat l] (Rhs l) (Maybe (Binds l))	A clause defined with infix notation, i.e. first its first argument pattern, then the function name, then its following argument(s), the right-hand side and an optional where clause. Note that there can be more than two arguments to a function declared infix, hence the list of pattern arguments.

Instances

Instances details

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

data Rhs l #

The right hand side of a function binding, pattern binding, or a case alternative.

Constructors

UnGuardedRhs l (Exp l)	unguarded right hand side (exp)
GuardedRhss l [GuardedRhs l]	guarded right hand side (gdrhs)

Instances

Instances details

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

data GuardedRhs l #

A guarded right hand side | stmts = exp, or | stmts -> exp for case alternatives. The guard is a series of statements when using pattern guards, otherwise it will be a single qualifier expression.

Constructors

GuardedRhs l [Stmt l] (Exp l)

Instances

Instances details

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

Class Assertions and Contexts

data Context l #

A context is a set of assertions

Constructors

CxSingle l (Asst l)
CxTuple l [Asst l]
CxEmpty l

Instances

Instances details

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

data FunDep l #

A functional dependency, given on the form l1 l2 ... ln -> r2 r3 .. rn

Constructors

FunDep l [Name l] [Name l]

Instances

Instances details

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

data Asst l #

Class assertions.

Constructors

TypeA l (Type l)	type assertion
IParam l (IPName l) (Type l)	implicit parameter assertion
ParenA l (Asst l)	parenthesised class assertion

Instances

Instances details

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

Types

data Type l #

A type qualified with a context. An unqualified type has an empty context.

Constructors

TyForall l (Maybe [TyVarBind l]) (Maybe (Context l)) (Type l)	qualified type
TyStar l	`*`, the type of types
TyFun l (Type l) (Type l)	function type
TyTuple l Boxed [Type l]	tuple type, possibly boxed
TyUnboxedSum l [Type l]	unboxed tuple type
TyList l (Type l)	list syntax, e.g. [a], as opposed to [] a
TyParArray l (Type l)	parallel array syntax, e.g. [:a:]
TyApp l (Type l) (Type l)	application of a type constructor
TyVar l (Name l)	type variable
TyCon l (QName l)	named type or type constructor
TyParen l (Type l)	type surrounded by parentheses
TyInfix l (Type l) (MaybePromotedName l) (Type l)	infix type constructor
TyKind l (Type l) (Kind l)	type with explicit kind signature
TyPromoted l (Promoted l)	`'K`, a promoted data type (-XDataKinds).
TyEquals l (Type l) (Type l)	type equality predicate enabled by ConstraintKinds
TySplice l (Splice l)	template haskell splice type
TyBang l (BangType l) (Unpackedness l) (Type l)	Strict type marked with "`!`" or type marked with UNPACK pragma.
TyWildCard l (Maybe (Name l))	Either an anonymous of named type wildcard
TyQuasiQuote l String String	[$name\| string \|]

Instances

Instances details

Functor Type #
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> Type a -> Type b (<$) :: a -> Type b -> Type a
Foldable Type #
Instance details Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Type m -> m foldMap :: Monoid m => (a -> m) -> Type a -> m foldMap' :: Monoid m => (a -> m) -> Type a -> m foldr :: (a -> b -> b) -> b -> Type a -> b foldr' :: (a -> b -> b) -> b -> Type a -> b foldl :: (b -> a -> b) -> b -> Type a -> b foldl' :: (b -> a -> b) -> b -> Type a -> b foldr1 :: (a -> a -> a) -> Type a -> a foldl1 :: (a -> a -> a) -> Type a -> a toList :: Type a -> [a] null :: Type a -> Bool length :: Type a -> Int elem :: Eq a => a -> Type a -> Bool maximum :: Ord a => Type a -> a minimum :: Ord a => Type a -> a sum :: Num a => Type a -> a product :: Num a => Type a -> a
Traversable Type #
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> Type a -> f (Type b) sequenceA :: Applicative f => Type (f a) -> f (Type a) mapM :: Monad m => (a -> m b) -> Type a -> m (Type b) sequence :: Monad m => Type (m a) -> m (Type a)
Annotated Type #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Type l -> l # amap :: (l -> l) -> Type l -> Type l #
ExactP Type #
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Type SrcSpanInfo -> EP ()
Eq l => Eq (Type l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: Type l -> Type l -> Bool (/=) :: Type l -> Type l -> Bool
Data l => Data (Type 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) -> Type l -> c (Type l) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Type l) toConstr :: Type l -> Constr dataTypeOf :: Type l -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Type l)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Type l)) gmapT :: (forall b. Data b => b -> b) -> Type l -> Type l gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type l -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type l -> r gmapQ :: (forall d. Data d => d -> u) -> Type l -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Type l -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Type l -> m (Type l) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Type l -> m (Type l) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Type l -> m (Type l)
Ord l => Ord (Type l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: Type l -> Type l -> Ordering (<) :: Type l -> Type l -> Bool (<=) :: Type l -> Type l -> Bool (>) :: Type l -> Type l -> Bool (>=) :: Type l -> Type l -> Bool max :: Type l -> Type l -> Type l min :: Type l -> Type l -> Type l
Show l => Show (Type l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> Type l -> ShowS show :: Type l -> String showList :: [Type l] -> ShowS
Generic (Type l) #
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Type l) :: Type -> Type Methods from :: Type l -> Rep (Type l) x to :: Rep (Type l) x -> Type l
Pretty (Type l) #
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: Type l -> Doc prettyPrec :: Int -> Type l -> Doc
Parseable (Type SrcSpanInfo) #
Instance details Defined in Language.Haskell.Exts.Parser Methods parse :: String -> ParseResult (Type SrcSpanInfo) # parseWithMode :: ParseMode -> String -> ParseResult (Type SrcSpanInfo) # parseWithComments :: ParseMode -> String -> ParseResult (Type SrcSpanInfo, [Comment]) # parser :: Maybe [Fixity] -> P (Type SrcSpanInfo)
type Rep (Type l) #
Instance details Defined in Language.Haskell.Exts.Syntax type Rep (Type l) = D1 ('MetaData "Type" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.0-HDJqfY1ItZ576ObW4UQhzC" 'False) ((((C1 ('MetaCons "TyForall" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe [TyVarBind l]))) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (Context l))) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Type l)))) :+: C1 ('MetaCons "TyStar" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l))) :+: (C1 ('MetaCons "TyFun" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Type l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Type l)))) :+: C1 ('MetaCons "TyTuple" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Boxed) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Type l]))))) :+: ((C1 ('MetaCons "TyUnboxedSum" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Type l])) :+: C1 ('MetaCons "TyList" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Type l)))) :+: (C1 ('MetaCons "TyParArray" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Type l))) :+: (C1 ('MetaCons "TyApp" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Type l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Type l)))) :+: C1 ('MetaCons "TyVar" '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 "TyCon" '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 "TyParen" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Type l)))) :+: (C1 ('MetaCons "TyInfix" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Type l))) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (MaybePromotedName l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Type l)))) :+: (C1 ('MetaCons "TyKind" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Type l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Kind l)))) :+: C1 ('MetaCons "TyPromoted" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Promoted l)))))) :+: ((C1 ('MetaCons "TyEquals" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Type l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Type l)))) :+: C1 ('MetaCons "TySplice" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Splice l)))) :+: (C1 ('MetaCons "TyBang" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (BangType l))) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Unpackedness l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Type l)))) :+: (C1 ('MetaCons "TyWildCard" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (Name l)))) :+: C1 ('MetaCons "TyQuasiQuote" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String))))))))

data Boxed #

Flag denoting whether a tuple is boxed or unboxed.

Constructors

Boxed
Unboxed

Instances

Instances details

Eq Boxed #
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: Boxed -> Boxed -> Bool (/=) :: Boxed -> Boxed -> Bool
Data Boxed #
Instance details Defined in Language.Haskell.Exts.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Boxed -> c Boxed gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Boxed toConstr :: Boxed -> Constr dataTypeOf :: Boxed -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Boxed) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Boxed) gmapT :: (forall b. Data b => b -> b) -> Boxed -> Boxed gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Boxed -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Boxed -> r gmapQ :: (forall d. Data d => d -> u) -> Boxed -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Boxed -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Boxed -> m Boxed gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Boxed -> m Boxed gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Boxed -> m Boxed
Ord Boxed #
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: Boxed -> Boxed -> Ordering (<) :: Boxed -> Boxed -> Bool (<=) :: Boxed -> Boxed -> Bool (>) :: Boxed -> Boxed -> Bool (>=) :: Boxed -> Boxed -> Bool max :: Boxed -> Boxed -> Boxed min :: Boxed -> Boxed -> Boxed
Show Boxed #
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> Boxed -> ShowS show :: Boxed -> String showList :: [Boxed] -> ShowS
Generic Boxed #
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep Boxed :: Type -> Type Methods from :: Boxed -> Rep Boxed x to :: Rep Boxed x -> Boxed
type Rep Boxed #
Instance details Defined in Language.Haskell.Exts.Syntax type Rep Boxed = D1 ('MetaData "Boxed" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.0-HDJqfY1ItZ576ObW4UQhzC" 'False) (C1 ('MetaCons "Boxed" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Unboxed" 'PrefixI 'False) (U1 :: Type -> Type))

type Kind = Type #

An explicit kind annotation.

data TyVarBind l #

A type variable declaration, optionally with an explicit kind annotation.

Constructors

KindedVar l (Name l) (Kind l)	variable binding with kind annotation
UnkindedVar l (Name l)	ordinary variable binding

Instances

Instances details

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

data Promoted l #

Bools here are True if there was a leading quote which may be left out. For example '[k1,k2] means the same thing as [k1,k2].

Constructors

PromotedInteger l Integer String	parsed value and raw string
PromotedString l String String	parsed value and raw string
PromotedCon l Bool (QName l)
PromotedList l Bool [Type l]
PromotedTuple l [Type l]
PromotedUnit l

Instances

Instances details

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

data TypeEqn l #

A type equation as found in closed type families.

Constructors

TypeEqn l (Type l) (Type l)

Instances

Instances details

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

Expressions

data Exp l #

Haskell expressions.

Constructors

Var l (QName l)	variable
OverloadedLabel l String	Overloaded label #foo
IPVar l (IPName l)	implicit parameter variable
Con l (QName l)	data constructor
Lit l (Literal l)	literal constant
InfixApp l (Exp l) (QOp l) (Exp l)	infix application
App l (Exp l) (Exp l)	ordinary application
NegApp l (Exp l)	negation expression `-exp` (unary minus)
Lambda l [Pat l] (Exp l)	lambda expression
Let l (Binds l) (Exp l)	local declarations with `let` ... `in` ...
If l (Exp l) (Exp l) (Exp l)	`if` exp `then` exp `else` exp
MultiIf l [GuardedRhs l]	`if` `\|` stmts `->` exp ...
Case l (Exp l) [Alt l]	`case` exp `of` alts
Do l [Stmt l]	`do`-expression: the last statement in the list should be an expression.
MDo l [Stmt l]	`mdo`-expression
Tuple l Boxed [Exp l]	tuple expression
UnboxedSum l Int Int (Exp l)	unboxed sum
TupleSection l Boxed [Maybe (Exp l)]	tuple section expression, e.g. `(,,3)`
List l [Exp l]	list expression
ParArray l [Exp l]	parallel array expression
Paren l (Exp l)	parenthesised expression
LeftSection l (Exp l) (QOp l)	left section `(`exp qop`)`
RightSection l (QOp l) (Exp l)	right section `(`qop exp`)`
RecConstr l (QName l) [FieldUpdate l]	record construction expression
RecUpdate l (Exp l) [FieldUpdate l]	record update expression
EnumFrom l (Exp l)	unbounded arithmetic sequence, incrementing by 1: `[from ..]`
EnumFromTo l (Exp l) (Exp l)	bounded arithmetic sequence, incrementing by 1 `[from .. to]`
EnumFromThen l (Exp l) (Exp l)	unbounded arithmetic sequence, with first two elements given `[from, then ..]`
EnumFromThenTo l (Exp l) (Exp l) (Exp l)	bounded arithmetic sequence, with first two elements given `[from, then .. to]`
ParArrayFromTo l (Exp l) (Exp l)	Parallel array bounded arithmetic sequence, incrementing by 1 `[:from .. to:]`
ParArrayFromThenTo l (Exp l) (Exp l) (Exp l)	bounded arithmetic sequence, with first two elements given `[:from, then .. to:]`
ListComp l (Exp l) [QualStmt l]	ordinary list comprehension
ParComp l (Exp l) [[QualStmt l]]	parallel list comprehension
ParArrayComp l (Exp l) [[QualStmt l]]	parallel array comprehension
ExpTypeSig l (Exp l) (Type l)	expression with explicit type signature
VarQuote l (QName l)	`'x` for template haskell reifying of expressions
TypQuote l (QName l)	`''T` for template haskell reifying of types
BracketExp l (Bracket l)	template haskell bracket expression
SpliceExp l (Splice l)	template haskell splice expression
QuasiQuote l String String	quasi-quotaion: `[$name\| string \|]`
TypeApp l (Type l)	Visible type application
XTag l (XName l) [XAttr l] (Maybe (Exp l)) [Exp l]	xml element, with attributes and children
XETag l (XName l) [XAttr l] (Maybe (Exp l))	empty xml element, with attributes
XPcdata l String	PCDATA child element
XExpTag l (Exp l)	escaped haskell expression inside xml
XChildTag l [Exp l]	children of an xml element
CorePragma l String (Exp l)	CORE pragma
SCCPragma l String (Exp l)	SCC pragma
GenPragma l String (Int, Int) (Int, Int) (Exp l)	GENERATED pragma
Proc l (Pat l) (Exp l)	arrows proc: `proc` pat `->` exp
LeftArrApp l (Exp l) (Exp l)	arrow application (from left): exp `-<` exp
RightArrApp l (Exp l) (Exp l)	arrow application (from right): exp `>-` exp
LeftArrHighApp l (Exp l) (Exp l)	higher-order arrow application (from left): exp `-<<` exp
RightArrHighApp l (Exp l) (Exp l)	higher-order arrow application (from right): exp `>>-` exp
ArrOp l (Exp l)	arrow control operators: `(\| exp \|)`
LCase l [Alt l]	`case` alts

Instances

Instances details

Functor Exp #
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> Exp a -> Exp b (<$) :: a -> Exp b -> Exp a
Foldable Exp #
Instance details Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Exp m -> m foldMap :: Monoid m => (a -> m) -> Exp a -> m foldMap' :: Monoid m => (a -> m) -> Exp a -> m foldr :: (a -> b -> b) -> b -> Exp a -> b foldr' :: (a -> b -> b) -> b -> Exp a -> b foldl :: (b -> a -> b) -> b -> Exp a -> b foldl' :: (b -> a -> b) -> b -> Exp a -> b foldr1 :: (a -> a -> a) -> Exp a -> a foldl1 :: (a -> a -> a) -> Exp a -> a toList :: Exp a -> [a] null :: Exp a -> Bool length :: Exp a -> Int elem :: Eq a => a -> Exp a -> Bool maximum :: Ord a => Exp a -> a minimum :: Ord a => Exp a -> a sum :: Num a => Exp a -> a product :: Num a => Exp a -> a
Traversable Exp #
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> Exp a -> f (Exp b) sequenceA :: Applicative f => Exp (f a) -> f (Exp a) mapM :: Monad m => (a -> m b) -> Exp a -> m (Exp b) sequence :: Monad m => Exp (m a) -> m (Exp a)
Annotated Exp #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Exp l -> l # amap :: (l -> l) -> Exp l -> Exp l #
AppFixity Exp #
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: MonadFail m => [Fixity] -> Exp SrcSpanInfo -> m (Exp SrcSpanInfo) #
ExactP Exp #
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Exp SrcSpanInfo -> EP ()
Eq l => Eq (Exp l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: Exp l -> Exp l -> Bool (/=) :: Exp l -> Exp l -> Bool
Data l => Data (Exp 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) -> Exp l -> c (Exp l) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Exp l) toConstr :: Exp l -> Constr dataTypeOf :: Exp l -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Exp l)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Exp l)) gmapT :: (forall b. Data b => b -> b) -> Exp l -> Exp l gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Exp l -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Exp l -> r gmapQ :: (forall d. Data d => d -> u) -> Exp l -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Exp l -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Exp l -> m (Exp l) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Exp l -> m (Exp l) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Exp l -> m (Exp l)
Ord l => Ord (Exp l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: Exp l -> Exp l -> Ordering (<) :: Exp l -> Exp l -> Bool (<=) :: Exp l -> Exp l -> Bool (>) :: Exp l -> Exp l -> Bool (>=) :: Exp l -> Exp l -> Bool max :: Exp l -> Exp l -> Exp l min :: Exp l -> Exp l -> Exp l
Show l => Show (Exp l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> Exp l -> ShowS show :: Exp l -> String showList :: [Exp l] -> ShowS
Generic (Exp l) #
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Exp l) :: Type -> Type Methods from :: Exp l -> Rep (Exp l) x to :: Rep (Exp l) x -> Exp l
Pretty (Exp l) #
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: Exp l -> Doc prettyPrec :: Int -> Exp l -> Doc
Parseable (Exp SrcSpanInfo) #
Instance details Defined in Language.Haskell.Exts.Parser Methods parse :: String -> ParseResult (Exp SrcSpanInfo) # parseWithMode :: ParseMode -> String -> ParseResult (Exp SrcSpanInfo) # parseWithComments :: ParseMode -> String -> ParseResult (Exp SrcSpanInfo, [Comment]) # parser :: Maybe [Fixity] -> P (Exp SrcSpanInfo)
type Rep (Exp l) #
Instance details Defined in Language.Haskell.Exts.Syntax type Rep (Exp l) = D1 ('MetaData "Exp" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.0-HDJqfY1ItZ576ObW4UQhzC" 'False) (((((C1 ('MetaCons "Var" '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 "OverloadedLabel" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String)) :+: C1 ('MetaCons "IPVar" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (IPName l))))) :+: ((C1 ('MetaCons "Con" '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 "Lit" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Literal l)))) :+: (C1 ('MetaCons "InfixApp" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l))) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (QOp l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l)))) :+: C1 ('MetaCons "App" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l))))))) :+: ((C1 ('MetaCons "NegApp" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l))) :+: (C1 ('MetaCons "Lambda" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Pat l]) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l)))) :+: C1 ('MetaCons "Let" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Binds l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l)))))) :+: ((C1 ('MetaCons "If" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l))) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l)))) :+: C1 ('MetaCons "MultiIf" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [GuardedRhs l]))) :+: (C1 ('MetaCons "Case" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Alt l]))) :+: C1 ('MetaCons "Do" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Stmt l])))))) :+: (((C1 ('MetaCons "MDo" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Stmt l])) :+: (C1 ('MetaCons "Tuple" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Boxed) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Exp l]))) :+: C1 ('MetaCons "UnboxedSum" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int)) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l)))))) :+: ((C1 ('MetaCons "TupleSection" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Boxed) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Maybe (Exp l)]))) :+: C1 ('MetaCons "List" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Exp l]))) :+: (C1 ('MetaCons "ParArray" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Exp l])) :+: C1 ('MetaCons "Paren" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l)))))) :+: ((C1 ('MetaCons "LeftSection" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (QOp l)))) :+: (C1 ('MetaCons "RightSection" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (QOp l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l)))) :+: C1 ('MetaCons "RecConstr" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (QName l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [FieldUpdate l]))))) :+: ((C1 ('MetaCons "RecUpdate" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [FieldUpdate l]))) :+: C1 ('MetaCons "EnumFrom" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l)))) :+: (C1 ('MetaCons "EnumFromTo" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l)))) :+: C1 ('MetaCons "EnumFromThen" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l))))))))) :+: ((((C1 ('MetaCons "EnumFromThenTo" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l))) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l)))) :+: (C1 ('MetaCons "ParArrayFromTo" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l)))) :+: C1 ('MetaCons "ParArrayFromThenTo" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l))) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l)))))) :+: ((C1 ('MetaCons "ListComp" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [QualStmt l]))) :+: C1 ('MetaCons "ParComp" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [[QualStmt l]])))) :+: (C1 ('MetaCons "ParArrayComp" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [[QualStmt l]]))) :+: C1 ('MetaCons "ExpTypeSig" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Type l))))))) :+: ((C1 ('MetaCons "VarQuote" '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 "TypQuote" '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 "BracketExp" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Bracket l))))) :+: ((C1 ('MetaCons "SpliceExp" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Splice l))) :+: C1 ('MetaCons "QuasiQuote" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String)))) :+: (C1 ('MetaCons "TypeApp" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Type l))) :+: C1 ('MetaCons "XTag" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 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 "XETag" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 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))))) :+: (C1 ('MetaCons "XPcdata" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String)) :+: C1 ('MetaCons "XExpTag" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l))))) :+: ((C1 ('MetaCons "XChildTag" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Exp l])) :+: C1 ('MetaCons "CorePragma" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l))))) :+: (C1 ('MetaCons "SCCPragma" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l)))) :+: C1 ('MetaCons "GenPragma" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String)) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Int, Int)) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Int, Int)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l)))))))) :+: ((C1 ('MetaCons "Proc" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Pat l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l)))) :+: (C1 ('MetaCons "LeftArrApp" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l)))) :+: C1 ('MetaCons "RightArrApp" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l)))))) :+: ((C1 ('MetaCons "LeftArrHighApp" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l)))) :+: C1 ('MetaCons "RightArrHighApp" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l))))) :+: (C1 ('MetaCons "ArrOp" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l))) :+: C1 ('MetaCons "LCase" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Alt l]))))))))

data Stmt l #

A statement, representing both a stmt in a do-expression, an ordinary qual in a list comprehension, as well as a stmt in a pattern guard.

Constructors

Generator l (Pat l) (Exp l)	a generator: pat `<-` exp
Qualifier l (Exp l)	an exp by itself: in a `do`-expression, an action whose result is discarded; in a list comprehension and pattern guard, a guard expression
LetStmt l (Binds l)	local bindings
RecStmt l [Stmt l]	a recursive binding group for arrows

Instances

Instances details

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

data QualStmt l #

A general transqual in a list comprehension, which could potentially be a transform of the kind enabled by TransformListComp.

Constructors

QualStmt l (Stmt l)	an ordinary statement
ThenTrans l (Exp l)	`then` exp
ThenBy l (Exp l) (Exp l)	`then` exp `by` exp
GroupBy l (Exp l)	`then` `group` `by` exp
GroupUsing l (Exp l)	`then` `group` `using` exp
GroupByUsing l (Exp l) (Exp l)	`then` `group` `by` exp `using` exp

Instances

Instances details

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

data FieldUpdate l #

An fbind in a labeled construction or update expression.

Constructors

FieldUpdate l (QName l) (Exp l)	ordinary label-expresion pair
FieldPun l (QName l)	record field pun
FieldWildcard l	record field wildcard

Instances

Instances details

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

data Alt l #

An alt alternative in a case expression.

Constructors

Alt l (Pat l) (Rhs l) (Maybe (Binds l))

Instances

Instances details

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

data XAttr l #

An xml attribute, which is a name-expression pair.

Constructors

XAttr l (XName l) (Exp l)

Instances

Instances details

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

Patterns

data Pat l #

A pattern, to be matched against a value.

Constructors

PVar l (Name l)	variable
PLit l (Sign l) (Literal l)	literal constant
PNPlusK l (Name l) Integer	n+k pattern
PInfixApp l (Pat l) (QName l) (Pat l)	pattern with an infix data constructor
PApp l (QName l) [Pat l]	data constructor and argument patterns
PTuple l Boxed [Pat l]	tuple pattern
PUnboxedSum l Int Int (Pat l)	unboxed sum
PList l [Pat l]	list pattern
PParen l (Pat l)	parenthesized pattern
PRec l (QName l) [PatField l]	labelled pattern, record style
PAsPat l (Name l) (Pat l)	`@`-pattern
PWildCard l	wildcard pattern: `_`
PIrrPat l (Pat l)	irrefutable pattern: `~pat`
PatTypeSig l (Pat l) (Type l)	pattern with type signature
PViewPat l (Exp l) (Pat l)	view patterns of the form `(exp -> pat)`
PRPat l [RPat l]	regular list pattern
PXTag l (XName l) [PXAttr l] (Maybe (Pat l)) [Pat l]	XML element pattern
PXETag l (XName l) [PXAttr l] (Maybe (Pat l))	XML singleton element pattern
PXPcdata l String	XML PCDATA pattern
PXPatTag l (Pat l)	XML embedded pattern
PXRPats l [RPat l]	XML regular list pattern
PSplice l (Splice l)	template haskell splice pattern
PQuasiQuote l String String	quasi quote pattern: `[$name\| string \|]`
PBangPat l (Pat l)	strict (bang) pattern: `f !x = ...`

Instances

Instances details

Functor Pat #
Instance details Defined in Language.Haskell.Exts.Syntax Methods fmap :: (a -> b) -> Pat a -> Pat b (<$) :: a -> Pat b -> Pat a
Foldable Pat #
Instance details Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Pat m -> m foldMap :: Monoid m => (a -> m) -> Pat a -> m foldMap' :: Monoid m => (a -> m) -> Pat a -> m foldr :: (a -> b -> b) -> b -> Pat a -> b foldr' :: (a -> b -> b) -> b -> Pat a -> b foldl :: (b -> a -> b) -> b -> Pat a -> b foldl' :: (b -> a -> b) -> b -> Pat a -> b foldr1 :: (a -> a -> a) -> Pat a -> a foldl1 :: (a -> a -> a) -> Pat a -> a toList :: Pat a -> [a] null :: Pat a -> Bool length :: Pat a -> Int elem :: Eq a => a -> Pat a -> Bool maximum :: Ord a => Pat a -> a minimum :: Ord a => Pat a -> a sum :: Num a => Pat a -> a product :: Num a => Pat a -> a
Traversable Pat #
Instance details Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> Pat a -> f (Pat b) sequenceA :: Applicative f => Pat (f a) -> f (Pat a) mapM :: Monad m => (a -> m b) -> Pat a -> m (Pat b) sequence :: Monad m => Pat (m a) -> m (Pat a)
Annotated Pat #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Pat l -> l # amap :: (l -> l) -> Pat l -> Pat l #
AppFixity Pat #
Instance details Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: MonadFail m => [Fixity] -> Pat SrcSpanInfo -> m (Pat SrcSpanInfo) #
ExactP Pat #
Instance details Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Pat SrcSpanInfo -> EP ()
Eq l => Eq (Pat l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: Pat l -> Pat l -> Bool (/=) :: Pat l -> Pat l -> Bool
Data l => Data (Pat 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) -> Pat l -> c (Pat l) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Pat l) toConstr :: Pat l -> Constr dataTypeOf :: Pat l -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Pat l)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Pat l)) gmapT :: (forall b. Data b => b -> b) -> Pat l -> Pat l gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pat l -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pat l -> r gmapQ :: (forall d. Data d => d -> u) -> Pat l -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Pat l -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Pat l -> m (Pat l) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Pat l -> m (Pat l) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Pat l -> m (Pat l)
Ord l => Ord (Pat l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: Pat l -> Pat l -> Ordering (<) :: Pat l -> Pat l -> Bool (<=) :: Pat l -> Pat l -> Bool (>) :: Pat l -> Pat l -> Bool (>=) :: Pat l -> Pat l -> Bool max :: Pat l -> Pat l -> Pat l min :: Pat l -> Pat l -> Pat l
Show l => Show (Pat l) #
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> Pat l -> ShowS show :: Pat l -> String showList :: [Pat l] -> ShowS
Generic (Pat l) #
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep (Pat l) :: Type -> Type Methods from :: Pat l -> Rep (Pat l) x to :: Rep (Pat l) x -> Pat l
Pretty (Pat l) #
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: Pat l -> Doc prettyPrec :: Int -> Pat l -> Doc
Parseable (Pat SrcSpanInfo) #
Instance details Defined in Language.Haskell.Exts.Parser Methods parse :: String -> ParseResult (Pat SrcSpanInfo) # parseWithMode :: ParseMode -> String -> ParseResult (Pat SrcSpanInfo) # parseWithComments :: ParseMode -> String -> ParseResult (Pat SrcSpanInfo, [Comment]) # parser :: Maybe [Fixity] -> P (Pat SrcSpanInfo)
type Rep (Pat l) #
Instance details Defined in Language.Haskell.Exts.Syntax type Rep (Pat l) = D1 ('MetaData "Pat" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.0-HDJqfY1ItZ576ObW4UQhzC" 'False) ((((C1 ('MetaCons "PVar" '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 "PLit" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Sign l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Literal l)))) :+: C1 ('MetaCons "PNPlusK" '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 Integer))))) :+: (C1 ('MetaCons "PInfixApp" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Pat l))) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (QName l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Pat l)))) :+: (C1 ('MetaCons "PApp" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (QName l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Pat l]))) :+: C1 ('MetaCons "PTuple" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Boxed) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Pat l])))))) :+: ((C1 ('MetaCons "PUnboxedSum" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int)) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Pat l)))) :+: (C1 ('MetaCons "PList" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Pat l])) :+: C1 ('MetaCons "PParen" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Pat l))))) :+: (C1 ('MetaCons "PRec" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (QName l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [PatField l]))) :+: (C1 ('MetaCons "PAsPat" '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 (Pat l)))) :+: C1 ('MetaCons "PWildCard" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l)))))) :+: (((C1 ('MetaCons "PIrrPat" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Pat l))) :+: (C1 ('MetaCons "PatTypeSig" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Pat l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Type l)))) :+: C1 ('MetaCons "PViewPat" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp l)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Pat l)))))) :+: (C1 ('MetaCons "PRPat" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [RPat l])) :+: (C1 ('MetaCons "PXTag" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (XName l))) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [PXAttr l]) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (Pat l))) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Pat l])))) :+: C1 ('MetaCons "PXETag" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (XName l))) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [PXAttr l]) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (Pat l)))))))) :+: ((C1 ('MetaCons "PXPcdata" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String)) :+: (C1 ('MetaCons "PXPatTag" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Pat l))) :+: C1 ('MetaCons "PXRPats" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [RPat l])))) :+: (C1 ('MetaCons "PSplice" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Splice l))) :+: (C1 ('MetaCons "PQuasiQuote" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String))) :+: C1 ('MetaCons "PBangPat" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 l) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Pat l))))))))

data PatField l #

An fpat in a labeled record pattern.

Constructors

PFieldPat l (QName l) (Pat l)	ordinary label-pattern pair
PFieldPun l (QName l)	record field pun
PFieldWildcard l	record field wildcard

Instances

Instances details

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

data PXAttr l #

An XML attribute in a pattern.

Constructors

PXAttr l (XName l) (Pat l)

Instances

Instances details

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

data RPat l #

An entity in a regular pattern.

Constructors

RPOp l (RPat l) (RPatOp l)	operator pattern, e.g. pat*
RPEither l (RPat l) (RPat l)	choice pattern, e.g. (1 \| 2)
RPSeq l [RPat l]	sequence pattern, e.g. (\| 1, 2, 3 \|)
RPGuard l (Pat l) [Stmt l]	guarded pattern, e.g. (\| p \| p < 3 \|)
RPCAs l (Name l) (RPat l)	non-linear variable binding, e.g. (foo@:(1 \| 2))*
RPAs l (Name l) (RPat l)	linear variable binding, e.g. foo@(1 \| 2)
RPParen l (RPat l)	parenthesised pattern, e.g. (2*)
RPPat l (Pat l)	an ordinary pattern

Instances

Instances details

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

data RPatOp l #

A regular pattern operator.

Constructors

RPStar l	`*` = 0 or more
RPStarG l	`*!` = 0 or more, greedy
RPPlus l	`+` = 1 or more
RPPlusG l	`+!` = 1 or more, greedy
RPOpt l	`?` = 0 or 1
RPOptG l	`?!` = 0 or 1, greedy

Instances

Instances details

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

Literals

data Literal l #

literal Values of this type hold the abstract value of the literal, along with the precise string representation used. For example, 10, 0o12 and 0xa have the same value representation, but each carry a different string representation.

Constructors

Char l Char String	character literal
String l String String	string literal
Int l Integer String	integer literal
Frac l Rational String	floating point literal
PrimInt l Integer String	unboxed integer literal
PrimWord l Integer String	unboxed word literal
PrimFloat l Rational String	unboxed float literal
PrimDouble l Rational String	unboxed double literal
PrimChar l Char String	unboxed character literal
PrimString l String String	unboxed string literal

Instances

Instances details

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

data Sign l #

An indication whether a literal pattern has been negated or not.

Constructors

Signless l
Negative l

Instances

Instances details

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

Variables, Constructors and Operators

data ModuleName l #

The name of a Haskell module.

Constructors

ModuleName l String

Instances

Instances details

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

data QName l #

This type is used to represent qualified variables, and also qualified constructors.

Constructors

Qual l (ModuleName l) (Name l)	name qualified with a module name
UnQual l (Name l)	unqualified local name
Special l (SpecialCon l)	built-in constructor with special syntax

Instances

Instances details

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

data Name l #

This type is used to represent variables, and also constructors.

Constructors

Ident l String	varid or conid.
Symbol l String	varsym or consym

Instances

Instances details

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

data QOp l #

Possibly qualified infix operators (qop), appearing in expressions.

Constructors

QVarOp l (QName l)	variable operator (qvarop)
QConOp l (QName l)	constructor operator (qconop)

Instances

Instances details

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

data Op l #

Operators appearing in infix declarations are never qualified.

Constructors

VarOp l (Name l)	variable operator (varop)
ConOp l (Name l)	constructor operator (conop)

Instances

Instances details

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

data SpecialCon l #

Constructors with special syntax. These names are never qualified, and always refer to builtin type or data constructors.

Constructors

UnitCon l	unit type and data constructor `()`
ListCon l	list type and data constructor `[]`
FunCon l	function type constructor `->`
TupleCon l Boxed Int	n-ary tuple type and data constructors `(,)` etc, possibly boxed `(#,#)`
Cons l	list data constructor `(:)`
UnboxedSingleCon l	unboxed singleton tuple constructor `(# #)`
ExprHole l	An expression hole _

Instances

Instances details

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

data CName l #

A name (cname) of a component of a class or data type in an import or export specification.

Constructors

VarName l (Name l)	name of a method or field
ConName l (Name l)	name of a data constructor

Instances

Instances details

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

data IPName l #

An implicit parameter name.

Constructors

IPDup l String	?ident, non-linear implicit parameter
IPLin l String	%ident, linear implicit parameter

Instances

Instances details

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

data XName l #

The name of an xml element or attribute, possibly qualified with a namespace.

Constructors

XName l String
XDomName l String String

Instances

Instances details

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

data Role l #

Constructors

Nominal l
Representational l
Phantom l
RoleWildcard l

Instances

Instances details

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

data MaybePromotedName l #

Constructors

PromotedName l (QName l)
UnpromotedName l (QName l)

Instances

Instances details

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

Template Haskell

data Bracket l #

A template haskell bracket expression.

Constructors

ExpBracket l (Exp l)	expression bracket: `[\| ... \|]`
TExpBracket l (Exp l)	typed expression bracket: `[\|\| ... \|\|]`
PatBracket l (Pat l)	pattern bracket: `[p\| ... \|]`
TypeBracket l (Type l)	type bracket: `[t\| ... \|]`
DeclBracket l [Decl l]	declaration bracket: `[d\| ... \|]`

Instances

Instances details

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

data Splice l #

A template haskell splice expression

Constructors

IdSplice l String	variable splice: `$var`
TIdSplice l String	typed variable splice: `$$var`
ParenSplice l (Exp l)	parenthesised expression splice: `$(exp)`
TParenSplice l (Exp l)	parenthesised typed expression splice: `$$(exp)`

Instances

Instances details

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

FFI

data Safety l #

The safety of a foreign function call.

Constructors

PlayRisky l	unsafe
PlaySafe l Bool	safe (`False`) or threadsafe (`True`)
PlayInterruptible l	interruptible

Instances

Instances details

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

data CallConv l #

The calling convention of a foreign function call.

Constructors

StdCall l
CCall l
CPlusPlus l
DotNet l
Jvm l
Js l
JavaScript l
CApi l

Instances

Instances details

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

Pragmas

data ModulePragma l #

A top level options pragma, preceding the module header.

Constructors

LanguagePragma l [Name l]	LANGUAGE pragma
OptionsPragma l (Maybe Tool) String	OPTIONS pragma, possibly qualified with a tool, e.g. OPTIONS_GHC
AnnModulePragma l (Annotation l)	ANN pragma with module scope

Instances

Instances details

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

data Tool #

Recognised tools for OPTIONS pragmas.

Constructors

GHC
HUGS
NHC98
YHC
HADDOCK
UnknownTool String

Instances

Instances details

Eq Tool #
Instance details Defined in Language.Haskell.Exts.Syntax Methods (==) :: Tool -> Tool -> Bool (/=) :: Tool -> Tool -> Bool
Data Tool #
Instance details Defined in Language.Haskell.Exts.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Tool -> c Tool gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Tool toConstr :: Tool -> Constr dataTypeOf :: Tool -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Tool) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Tool) gmapT :: (forall b. Data b => b -> b) -> Tool -> Tool gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tool -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tool -> r gmapQ :: (forall d. Data d => d -> u) -> Tool -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Tool -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Tool -> m Tool gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Tool -> m Tool gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Tool -> m Tool
Ord Tool #
Instance details Defined in Language.Haskell.Exts.Syntax Methods compare :: Tool -> Tool -> Ordering (<) :: Tool -> Tool -> Bool (<=) :: Tool -> Tool -> Bool (>) :: Tool -> Tool -> Bool (>=) :: Tool -> Tool -> Bool max :: Tool -> Tool -> Tool min :: Tool -> Tool -> Tool
Show Tool #
Instance details Defined in Language.Haskell.Exts.Syntax Methods showsPrec :: Int -> Tool -> ShowS show :: Tool -> String showList :: [Tool] -> ShowS
Generic Tool #
Instance details Defined in Language.Haskell.Exts.Syntax Associated Types type Rep Tool :: Type -> Type Methods from :: Tool -> Rep Tool x to :: Rep Tool x -> Tool
Pretty Tool #
Instance details Defined in Language.Haskell.Exts.Pretty Methods pretty :: Tool -> Doc prettyPrec :: Int -> Tool -> Doc
type Rep Tool #
Instance details Defined in Language.Haskell.Exts.Syntax type Rep Tool = D1 ('MetaData "Tool" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.0-HDJqfY1ItZ576ObW4UQhzC" '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)))))

data Overlap l #

Recognised overlaps for overlap pragmas.

Constructors

NoOverlap l	NO_OVERLAP pragma
Overlap l	OVERLAP pragma
Overlapping l
Overlaps l
Overlappable l
Incoherent l	INCOHERENT pragma

Instances

Instances details

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

data Rule l #

The body of a RULES pragma.

Constructors

Rule l String (Maybe (Activation l)) (Maybe [RuleVar l]) (Exp l) (Exp l)

Instances

Instances details

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

data RuleVar l #

Variables used in a RULES pragma, optionally annotated with types

Constructors

RuleVar l (Name l)
TypedRuleVar l (Name l) (Type l)

Instances

Instances details

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

data Activation l #

Activation clause of a RULES pragma.

Constructors

ActiveFrom l Int
ActiveUntil l Int

Instances

Instances details

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

data Annotation l #

An annotation through an ANN pragma.

Constructors

Ann l (Name l) (Exp l)	An annotation for a declared name.
TypeAnn l (Name l) (Exp l)	An annotation for a declared type.
ModuleAnn l (Exp l)	An annotation for the defining module.

Instances

Instances details

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

data BooleanFormula l #

A boolean formula for MINIMAL pragmas.

Constructors

VarFormula l (Name l)	A variable.
AndFormula l [BooleanFormula l]	And boolean formulas.
OrFormula l [BooleanFormula l]	Or boolean formulas.
ParenFormula l (BooleanFormula l)	Parenthesized boolean formulas.

Instances

Instances details

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

Builtin names

Modules

prelude_mod :: l -> ModuleName l #

main_mod :: l -> ModuleName l #

Main function of a program

main_name :: l -> Name l #

Constructors

unit_con_name :: l -> QName l #

tuple_con_name :: l -> Boxed -> Int -> QName l #

list_con_name :: l -> 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 #

Special identifiers

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 #

via_name :: l -> Name l #

Type constructors

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 #

Source coordinates

Annotated trees

class Functor ast => Annotated ast where #

AST nodes are annotated, and this class allows manipulation of the annotations.

Methods

ann :: ast l -> l #

Retrieve the annotation of an AST node.

amap :: (l -> l) -> ast l -> ast l #

Change the annotation of an AST node. Note that only the annotation of the node itself is affected, and not the annotations of any child nodes. if all nodes in the AST tree are to be affected, use fmap.

Instances

Instances details

Annotated Alt #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Alt l -> l # amap :: (l -> l) -> Alt l -> Alt l #
Annotated FieldUpdate #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: FieldUpdate l -> l # amap :: (l -> l) -> FieldUpdate l -> FieldUpdate l #
Annotated QualStmt #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: QualStmt l -> l # amap :: (l -> l) -> QualStmt l -> QualStmt l #
Annotated Stmt #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Stmt l -> l # amap :: (l -> l) -> Stmt l -> Stmt l #
Annotated PatField #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: PatField l -> l # amap :: (l -> l) -> PatField l -> PatField l #
Annotated RPat #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: RPat l -> l # amap :: (l -> l) -> RPat l -> RPat l #
Annotated RPatOp #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: RPatOp l -> l # amap :: (l -> l) -> RPatOp l -> RPatOp l #
Annotated PXAttr #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: PXAttr l -> l # amap :: (l -> l) -> PXAttr l -> PXAttr l #
Annotated Pat #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Pat l -> l # amap :: (l -> l) -> Pat l -> Pat l #
Annotated WarningText #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: WarningText l -> l # amap :: (l -> l) -> WarningText l -> WarningText l #
Annotated RuleVar #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: RuleVar l -> l # amap :: (l -> l) -> RuleVar l -> RuleVar l #
Annotated Rule #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Rule l -> l # amap :: (l -> l) -> Rule l -> Rule l #
Annotated Activation #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Activation l -> l # amap :: (l -> l) -> Activation l -> Activation l #
Annotated Overlap #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Overlap l -> l # amap :: (l -> l) -> Overlap l -> Overlap l #
Annotated ModulePragma #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: ModulePragma l -> l # amap :: (l -> l) -> ModulePragma l -> ModulePragma l #
Annotated CallConv #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: CallConv l -> l # amap :: (l -> l) -> CallConv l -> CallConv l #
Annotated Safety #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Safety l -> l # amap :: (l -> l) -> Safety l -> Safety l #
Annotated Splice #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Splice l -> l # amap :: (l -> l) -> Splice l -> Splice l #
Annotated Bracket #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Bracket l -> l # amap :: (l -> l) -> Bracket l -> Bracket l #
Annotated XAttr #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: XAttr l -> l # amap :: (l -> l) -> XAttr l -> XAttr l #
Annotated XName #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: XName l -> l # amap :: (l -> l) -> XName l -> XName l #
Annotated Exp #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Exp l -> l # amap :: (l -> l) -> Exp l -> Exp l #
Annotated Sign #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Sign l -> l # amap :: (l -> l) -> Sign l -> Sign l #
Annotated Literal #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Literal l -> l # amap :: (l -> l) -> Literal l -> Literal l #
Annotated Asst #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Asst l -> l # amap :: (l -> l) -> Asst l -> Asst l #
Annotated Context #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Context l -> l # amap :: (l -> l) -> Context l -> Context l #
Annotated FunDep #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: FunDep l -> l # amap :: (l -> l) -> FunDep l -> FunDep l #
Annotated TyVarBind #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: TyVarBind l -> l # amap :: (l -> l) -> TyVarBind l -> TyVarBind l #
Annotated Promoted #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Promoted l -> l # amap :: (l -> l) -> Promoted l -> Promoted l #
Annotated MaybePromotedName #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: MaybePromotedName l -> l # amap :: (l -> l) -> MaybePromotedName l -> MaybePromotedName l #
Annotated Type #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Type l -> l # amap :: (l -> l) -> Type l -> Type l #
Annotated GuardedRhs #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: GuardedRhs l -> l # amap :: (l -> l) -> GuardedRhs l -> GuardedRhs l #
Annotated Rhs #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Rhs l -> l # amap :: (l -> l) -> Rhs l -> Rhs l #
Annotated Unpackedness #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Unpackedness l -> l # amap :: (l -> l) -> Unpackedness l -> Unpackedness l #
Annotated BangType #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: BangType l -> l # amap :: (l -> l) -> BangType l -> BangType l #
Annotated InstDecl #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: InstDecl l -> l # amap :: (l -> l) -> InstDecl l -> InstDecl l #
Annotated ClassDecl #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: ClassDecl l -> l # amap :: (l -> l) -> ClassDecl l -> ClassDecl l #
Annotated GadtDecl #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: GadtDecl l -> l # amap :: (l -> l) -> GadtDecl l -> GadtDecl l #
Annotated FieldDecl #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: FieldDecl l -> l # amap :: (l -> l) -> FieldDecl l -> FieldDecl l #
Annotated ConDecl #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: ConDecl l -> l # amap :: (l -> l) -> ConDecl l -> ConDecl l #
Annotated QualConDecl #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: QualConDecl l -> l # amap :: (l -> l) -> QualConDecl l -> QualConDecl l #
Annotated Match #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Match l -> l # amap :: (l -> l) -> Match l -> Match l #
Annotated IPBind #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: IPBind l -> l # amap :: (l -> l) -> IPBind l -> IPBind l #
Annotated Binds #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Binds l -> l # amap :: (l -> l) -> Binds l -> Binds l #
Annotated DerivStrategy #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: DerivStrategy l -> l # amap :: (l -> l) -> DerivStrategy l -> DerivStrategy l #
Annotated Deriving #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Deriving l -> l # amap :: (l -> l) -> Deriving l -> Deriving l #
Annotated InstHead #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: InstHead l -> l # amap :: (l -> l) -> InstHead l -> InstHead l #
Annotated InstRule #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: InstRule l -> l # amap :: (l -> l) -> InstRule l -> InstRule l #
Annotated DeclHead #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: DeclHead l -> l # amap :: (l -> l) -> DeclHead l -> DeclHead l #
Annotated ResultSig #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: ResultSig l -> l # amap :: (l -> l) -> ResultSig l -> ResultSig l #
Annotated InjectivityInfo #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: InjectivityInfo l -> l # amap :: (l -> l) -> InjectivityInfo l -> InjectivityInfo l #
Annotated DataOrNew #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: DataOrNew l -> l # amap :: (l -> l) -> DataOrNew l -> DataOrNew l #
Annotated Role #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Role l -> l # amap :: (l -> l) -> Role l -> Role l #
Annotated BooleanFormula #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: BooleanFormula l -> l # amap :: (l -> l) -> BooleanFormula l -> BooleanFormula l #
Annotated Annotation #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Annotation l -> l # amap :: (l -> l) -> Annotation l -> Annotation l #
Annotated TypeEqn #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: TypeEqn l -> l # amap :: (l -> l) -> TypeEqn l -> TypeEqn l #
Annotated Decl #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Decl l -> l # amap :: (l -> l) -> Decl l -> Decl l #
Annotated Assoc #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Assoc l -> l # amap :: (l -> l) -> Assoc l -> Assoc l #
Annotated ImportSpec #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: ImportSpec l -> l # amap :: (l -> l) -> ImportSpec l -> ImportSpec l #
Annotated ImportSpecList #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: ImportSpecList l -> l # amap :: (l -> l) -> ImportSpecList l -> ImportSpecList l #
Annotated ImportDecl #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: ImportDecl l -> l # amap :: (l -> l) -> ImportDecl l -> ImportDecl l #
Annotated Namespace #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Namespace l -> l # amap :: (l -> l) -> Namespace l -> Namespace l #
Annotated EWildcard #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: EWildcard l -> l # amap :: (l -> l) -> EWildcard l -> EWildcard l #
Annotated ExportSpec #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: ExportSpec l -> l # amap :: (l -> l) -> ExportSpec l -> ExportSpec l #
Annotated ExportSpecList #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: ExportSpecList l -> l # amap :: (l -> l) -> ExportSpecList l -> ExportSpecList l #
Annotated ModuleHead #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: ModuleHead l -> l # amap :: (l -> l) -> ModuleHead l -> ModuleHead l #
Annotated Module #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Module l -> l # amap :: (l -> l) -> Module l -> Module l #
Annotated CName #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: CName l -> l # amap :: (l -> l) -> CName l -> CName l #
Annotated Op #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Op l -> l # amap :: (l -> l) -> Op l -> Op l #
Annotated QOp #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: QOp l -> l # amap :: (l -> l) -> QOp l -> QOp l #
Annotated IPName #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: IPName l -> l # amap :: (l -> l) -> IPName l -> IPName l #
Annotated Name #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: Name l -> l # amap :: (l -> l) -> Name l -> Name l #
Annotated QName #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: QName l -> l # amap :: (l -> l) -> QName l -> QName l #
Annotated SpecialCon #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: SpecialCon l -> l # amap :: (l -> l) -> SpecialCon l -> SpecialCon l #
Annotated ModuleName #
Instance details Defined in Language.Haskell.Exts.Syntax Methods ann :: ModuleName l -> l # amap :: (l -> l) -> ModuleName l -> ModuleName l #

(=~=) :: (Annotated a, Eq (a ())) => a l1 -> a l2 -> Bool #

Test if two AST elements are equal modulo annotations.