Language.Haskell.Tools.AST.Match.Decls

UPattern matching on declaration-level AST fragments for refactorings.

Declarations

pattern TypeDecl :: forall dom. DeclHead dom -> Type dom -> Decl dom

A type synonym ( type String = [Char] )

pattern StandaloneDeriving :: forall dom. InstanceRule dom -> Decl dom

Standalone deriving declaration ( deriving instance X T )

pattern FixityDecl :: forall dom. FixitySignature dom -> Decl dom

Fixity declaration ( infixl 5 +, - )

pattern DefaultDecl :: forall dom. TypeList dom -> Decl dom

Default types ( default (T1, T2) )

pattern TypeSigDecl :: forall dom. TypeSignature dom -> Decl dom

Type signature declaration ( f :: Int -> Int )

pattern ValueBinding :: forall dom. ValueBind dom -> Decl dom

Function or value binding ( f x = 12 )

pattern SpliceDecl :: forall dom. Splice dom -> Decl dom

A Template Haskell splice declaration ( $(generateDecls) )

Data type definitions

pattern DataDecl :: forall dom. DataOrNewtypeKeyword dom -> MaybeContext dom -> DeclHead dom -> ConDeclList dom -> MaybeDeriving dom -> Decl dom

A data or newtype declaration. Empty data type declarations without where keyword are always belong to DataDecl.

pattern GADTDataDecl :: forall dom. () => forall dome stage. DataOrNewtypeKeyword dom -> MaybeContext dom -> DeclHead dom -> MaybeKindConstraint dome -> AnnListG UGadtConDecl dom stage -> MaybeDeriving dom -> Decl dom

A GADT-style data or newtype declaration.

pattern GadtConDecl :: forall dom. NameList dom -> Type dom -> GadtConDecl dom

GADT constructor declaration ( D1 :: Int -> T String )

pattern GadtRecordConDecl :: forall dom. NameList dom -> FieldDeclList dom -> Type dom -> GadtConDecl dom

GADT constructor declaration with record syntax ( D1 :: { val :: Int } -> T String )

pattern ConDecl :: forall dom. Name dom -> TypeList dom -> ConDecl dom

Ordinary data constructor ( C t1 t2 )

pattern RecordConDecl :: forall dom. Name dom -> FieldDeclList dom -> ConDecl dom

Creates a record data constructor ( Point { x :: Double, y :: Double } )

pattern InfixConDecl :: forall dom. Type dom -> Operator dom -> Type dom -> ConDecl dom

Infix data constructor ( t1 :+: t2 )

pattern FieldDecl :: forall dom. NameList dom -> Type dom -> FieldDecl dom

Field declaration ( fld :: Int )

pattern DerivingOne :: forall dom. InstanceHead dom -> Deriving dom

A deriving clause without parentheses ( deriving Show .

pattern DerivingMulti :: forall dom. InstanceHeadList dom -> Deriving dom

A deriving clause with parentheses deriving (Show, Eq) )

pattern DataKeyword :: forall dom. DataOrNewtypeKeyword dom

pattern NewtypeKeyword :: forall dom. DataOrNewtypeKeyword dom

pattern FunDeps :: forall dom. FunDepList dom -> FunDeps dom

A list of functional dependencies: | a -> b, c -> d separated by commas

pattern FunDep :: forall dom. NameList dom -> NameList dom -> FunDep dom

A functional dependency, given on the form l1 ... ln -> r1 ... rn

Type class declarations

pattern ClassDecl :: forall dom. MaybeContext dom -> DeclHead dom -> MaybeFunDeps dom -> MaybeClassBody dom -> Decl dom

Type class declaration ( class X a [where f = ...] )

pattern ClassBody :: forall dom. ClassElementList dom -> ClassBody dom

The list of declarations that can appear in a typeclass

pattern ClassElemSig :: forall dom. TypeSignature dom -> ClassElement dom

Type signature: f :: A -> B as a class member

pattern ClassElemDef :: forall dom. ValueBind dom -> ClassElement dom

Default binding: f x = "aaa" as a class member

pattern ClassElemTypeFam :: forall dom. DeclHead dom -> MaybeTypeFamilySpec dom -> ClassElement dom

Declaration of an associated type synonym: type T x :: * in a class

pattern ClassElemDataFam :: forall dom. () => forall dome. DeclHead dom -> MaybeKindConstraint dome -> ClassElement dom

Declaration of an associated data synonym: data T x :: * in a class

pattern ClsDefaultType :: forall dom. DeclHead dom -> Type dom -> ClassElement dom

Default choice for type synonym: type T x = TE or type instance T x = TE in a class

pattern ClsDefaultSig :: forall dom. Name dom -> Type dom -> ClassElement dom

Default signature (by using DefaultSignatures): default enum :: (Generic a, GEnum (Rep a)) => [a]

pattern ClsMinimal :: forall dom. MinimalFormula dom -> ClassElement dom

Minimal pragma: {-# MINIMAL (==) | (/=) #-} in a class

pattern MinimalName :: forall dom. Name dom -> MinimalFormula dom

pattern MinimalParen :: forall dom. MinimalFormula dom -> MinimalFormula dom

pattern MinimalOr :: forall dom. MinimalFormulaList dom -> MinimalFormula dom

One of the minimal formulas are needed ( min1 | min2 )

pattern MinimalAnd :: forall dom. MinimalFormulaList dom -> MinimalFormula dom

Both of the minimal formulas are needed ( min1 , min2 )

Declaration heads

pattern NameDeclHead :: forall dom. Name dom -> DeclHead dom

Type or class name as a declaration head

pattern ParenDeclHead :: forall dom. DeclHead dom -> DeclHead dom

Parenthesized type as a declaration head

pattern DeclHeadApp :: forall dom. DeclHead dom -> TyVar dom -> DeclHead dom

Type application as a declaration head

pattern InfixDeclHead :: forall dom. TyVar dom -> Operator dom -> TyVar dom -> DeclHead dom

Infix type application as a declaration head

Type class instance declarations

pattern InstanceDecl :: forall dom. InstanceRule dom -> MaybeInstBody dom -> Decl dom

Instance declaration ( instance X T [where f = ...] )

pattern InstanceBody :: forall dom. InstBodyDeclList dom -> InstBody dom

Instance body is the implementation of the class functions ( where a x = 1; b x = 2 )

pattern InstanceBind :: forall dom. ValueBind dom -> InstBodyDecl dom

A normal value binding ( f x = 12 ) inside a class instance

pattern InstanceTypeSig :: forall dom. TypeSignature dom -> InstBodyDecl dom

Type signature in instance definition with InstanceSigs

pattern InstanceTypeFamilyDef :: forall dom. TypeEqn dom -> InstBodyDecl dom

An associated type definition ( type A X = B ) in a class instance

pattern InstanceDataFamilyDef :: forall dom. DataOrNewtypeKeyword dom -> InstanceRule dom -> ConDeclList dom -> MaybeDeriving dom -> InstBodyDecl dom

An associated data definition ( data A X = B Int | C ) in a class instance

pattern InstanceDataFamilyGADTDef :: forall dom. () => forall dome stage. DataOrNewtypeKeyword dom -> InstanceRule dom -> MaybeKindConstraint dome -> AnnListG UGadtConDecl dom stage -> MaybeDeriving dom -> InstBodyDecl dom

An associated data definition as a GADT ( data A X where B :: Int -> A X ) in a class instance

pattern InstanceSpecializePragma :: forall dom. Type dom -> InstBodyDecl dom

Specialize instance pragma in a class instance (no phase selection is allowed)

pattern InstanceRule :: forall dom. () => forall stage. AnnMaybeG (AnnListG UTyVar) dom stage -> MaybeContext dom -> InstanceHead dom -> InstanceRule dom

Instance head as an instance rule ( X a => Y a )

pattern InstanceHead :: forall dom. Name dom -> InstanceHead dom

Type or class name as an instance head

pattern InfixInstanceHead :: forall dom. Type dom -> Name dom -> InstanceHead dom

Infix application of the type/class name to the left operand as an instance head

pattern ParenInstanceHead :: forall dom. InstanceHead dom -> InstanceHead dom

Parenthesized instance head

pattern AppInstanceHead :: forall dom. InstanceHead dom -> Type dom -> InstanceHead dom

Type application as an instance head

pattern EnableOverlap :: forall dom. OverlapPragma dom

OVERLAP pragma

pattern DisableOverlap :: forall dom. OverlapPragma dom

NO_OVERLAP pragma

pattern Overlappable :: forall dom. OverlapPragma dom

OVERLAPPABLE pragma

pattern Overlapping :: forall dom. OverlapPragma dom

OVERLAPPING pragma

pattern Overlaps :: forall dom. OverlapPragma dom

OVERLAPS pragma

pattern IncoherentOverlap :: forall dom. OverlapPragma dom

INCOHERENT pragma

Type roles

pattern RoleDecl :: forall dom. QualifiedName dom -> RoleList dom -> Decl dom

Role annotations ( type role Ptr representational )

pattern NominalRole :: forall dom. Role dom

pattern RepresentationalRole :: forall dom. Role dom

pattern PhantomRole :: forall dom. Role dom

Foreign imports and exports

pattern ForeignImport :: forall dom. CallConv dom -> MaybeSafety dom -> Name dom -> Type dom -> Decl dom

Foreign import ( foreign import foo :: Int -> IO Int )

pattern ForeignExport :: forall dom. CallConv dom -> Name dom -> Type dom -> Decl dom

Foreign export ( foreign export ccall foo :: Int -> IO Int )

pattern StdCall :: forall dom. CallConv dom

Specifies stdcall calling convention for foreign import/export.

pattern CCall :: forall dom. CallConv dom

Specifies ccall calling convention for foreign import/export.

pattern CApi :: forall dom. CallConv dom

Specifies capi calling convention for foreign import/export.

pattern Unsafe :: forall dom. Safety dom

Specifies that the given foreign import is unsafe.

Pattern synonyms

pattern PatternSynonym :: forall dom. PatSynLhs dom -> PatSynRhs dom -> Decl dom

Pattern synonyms ( pattern Arrow t1 t2 = App "->" [t1, t2] )

pattern ConPatSyn :: forall dom. Name dom -> NameList dom -> PatSynLhs dom

A left hand side with a constructor name and arguments ( Arrow t1 t2 )

pattern InfixPatSyn :: forall dom. Name dom -> Operator dom -> Name dom -> PatSynLhs dom

An infix pattern synonym left-hand side ( t1 :+: t2 )

pattern RecordPatSyn :: forall dom. Name dom -> NameList dom -> PatSynLhs dom

A record-style pattern synonym left-hand side ( Arrow { arrowFrom, arrowTo } )

pattern SymmetricPatSyn :: forall dom. Pattern dom -> PatSynRhs dom

An automatically two-way pattern synonym ( = App "Int" [] )

pattern OneWayPatSyn :: forall dom. Pattern dom -> PatSynRhs dom

A pattern synonym that can be only used for pattenr matching but not for combining ( <- App "Int" [] )

pattern TwoWayPatSyn :: forall dom. Pattern dom -> MatchList dom -> PatSynRhs dom

A pattern synonym with the other direction explicitely specified ( <- App "Int" [] where Int = App "Int" [] )

pattern PatternSignatureDecl :: forall dom. PatternSignature dom -> Decl dom

Pattern type signature declaration ( pattern Succ :: Int -> Int )

pattern PatternSignature :: forall dom. Name dom -> Type dom -> PatternSignature dom

Type families

pattern TypeFamily :: forall dom. DeclHead dom -> MaybeTypeFamilySpec dom -> Decl dom

Type family declaration ( type family A a :: * -> * )

pattern DataFamily :: forall dom. DeclHead dom -> MaybeKindConstraint dom -> Decl dom

Data family declaration ( data family A a :: * -> * )

pattern TypeInstance :: forall dom. InstanceRule dom -> Type dom -> Decl dom

Type family instance declaration ( type instance Fam T = AssignedT )

pattern DataInstance :: forall dom. DataOrNewtypeKeyword dom -> InstanceRule dom -> ConDeclList dom -> MaybeDeriving dom -> Decl dom

Data instance declaration ( data instance Fam T = Con1 | Con2 )

pattern GadtDataInstance :: forall dom. () => forall dome. DataOrNewtypeKeyword dom -> InstanceRule dom -> MaybeKindConstraint dome -> GadtConDeclList dom -> Decl dom

GADT-style data instance declaration ( data instance Fam T where ... )

pattern ClosedTypeFamily :: forall dom. DeclHead dom -> MaybeKindConstraint dom -> TypeEqnList dom -> Decl dom

A closed type family declaration

pattern TypeFamilyKindSpec :: forall dom. KindConstraint dom -> TypeFamilySpec dom

Specifies the kind of a type family ( :: * -> * )

pattern TypeFamilyInjectivitySpec :: forall dom. Name dom -> NameList dom -> TypeFamilySpec dom

Specifies the injectivity of a type family ( = r | r -> a )

pattern TypeEqn :: forall dom. Type dom -> Type dom -> TypeEqn dom

Type equations as found in closed type families ( T A = S )

Top level pragmas

pattern PragmaDecl :: forall dom. TopLevelPragma dom -> Decl dom

Top-level pragmas

pattern RulePragma :: forall dom. RuleList dom -> TopLevelPragma dom

A pragma that introduces source rewrite rules ( {-# RULES "map/map" [2] forall f g xs. map f (map g xs) = map (f.g) xs #-} )

pattern DeprPragma :: forall dom. NameList dom -> String -> TopLevelPragma dom

A pragma that marks definitions as deprecated ( {-# DEPRECATED f "f will be replaced by g" #-} )

pattern WarningPragma :: forall dom. NameList dom -> String -> TopLevelPragma dom

A pragma that marks definitions as deprecated ( {-# WARNING unsafePerformIO "you should know what you are doing" #-} )

pattern AnnPragma :: forall dom. AnnotationSubject dom -> Expr dom -> TopLevelPragma dom

A pragma that annotates a definition with an arbitrary value ( {-# ANN f 42 #-} )

pattern InlinePragma :: forall dom. MaybeConlikeAnnot dom -> MaybePhaseControl dom -> Name dom -> TopLevelPragma dom

A pragma that marks a function for inlining to the compiler ( {-# INLINE thenUs #-} )

pattern NoInlinePragma :: forall dom. Name dom -> TopLevelPragma dom

A pragma that forbids a function from being inlined by the compiler ( {-# NOINLINE f #-} )

pattern InlinablePragma :: forall dom. MaybePhaseControl dom -> Name dom -> TopLevelPragma dom

A pragma that marks a function that it may be inlined by the compiler ( {-# INLINABLE thenUs #-} )

pattern LinePragma :: forall dom. Int -> MaybeStringNode dom -> TopLevelPragma dom

A pragma for maintaining line numbers in generated sources ( {-# LINE 123 "somefile" #-} )

pattern SpecializePragma :: forall dom. MaybePhaseControl dom -> Name dom -> TypeList dom -> TopLevelPragma dom

A pragma that tells the compiler that a polymorph function should be optimized for a given type ( {-# SPECIALISE f :: Int -> b -> b #-} )

pattern PhaseControlFrom :: forall dom. Integer -> PhaseControl dom

Marks that the pragma should be applied from a given compile phase ( [2] )

pattern PhaseControlUntil :: forall dom. Integer -> PhaseControl dom

Marks that the pragma should be applied until a given compile phase ( [~2] )

pattern RewriteRule :: forall dom. String -> MaybePhaseControl dom -> TyVarList dom -> Expr dom -> Expr dom -> Rule dom

A rewrite rule ( "map/map" forall f g xs. map f (map g xs) = map (f.g) xs )

pattern NameAnnotation :: forall dom. Name dom -> AnnotationSubject dom

The definition with the given name is annotated

pattern TypeAnnotation :: forall dom. Name dom -> AnnotationSubject dom

A type with the given name is annotated

pattern ModuleAnnotation :: forall dom. AnnotationSubject dom

The whole module is annotated

pattern ConlikeAnnotation :: forall dom. ConlikeAnnot dom

A CONLIKE modifier for an INLINE pragma.