| 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
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)
-
foralltypes 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
- 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
-
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
- data InstRule l
- data InstHead l
- data Binds 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
- data ClassDecl l
- data InstDecl 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
- data ConDecl 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
-
data
Rhs
l
- = UnGuardedRhs l ( Exp l)
- | GuardedRhss l [ GuardedRhs l]
- data GuardedRhs l = GuardedRhs l [ Stmt l] ( Exp l)
- data Context l
- data FunDep l = FunDep l [ Name l] [ Name l]
- data 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
- 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
- data QualStmt 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
- data PXAttr l = PXAttr l ( XName l) ( Pat l)
- data RPat l
- data RPatOp l
- data Literal l
- data Sign 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
- data QOp l
- data Op l
- data SpecialCon l
- data CName l
- data IPName l
- data XName l
-
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
-
data
ModulePragma
l
- = LanguagePragma l [ Name l]
- | OptionsPragma l ( Maybe Tool ) String
- | AnnModulePragma l ( Annotation l)
- data Tool
-
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
-
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
- (=~=) :: ( Annotated a, Eq (a ())) => a l1 -> a l2 -> Bool
Modules
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
data ModuleHead l Source #
The head of a module, including the name and export specification.
Constructors
| ModuleHead l ( ModuleName l) ( Maybe ( WarningText l)) ( Maybe ( ExportSpecList l)) |
Instances
data WarningText l Source #
Warning text to optionally use in the module header of e.g. a deprecated module.
Instances
data ExportSpecList l Source #
An explicit export specification.
Constructors
| ExportSpecList l [ ExportSpec l] |
Instances
data ExportSpec l Source #
An item in a module's export specification.
Constructors
| EVar l ( QName l) |
variable. |
| EAbs l ( Namespace l) ( QName l) |
|
| EThingWith l ( EWildcard l) ( QName l) [ CName l] |
|
| EModuleContents l ( ModuleName l) |
|
Instances
Indicates the position of the wildcard in an export list
Constructors
| NoWildcard l | |
| EWildcard l Int |
Instances
data ImportDecl l Source #
An import declaration.
Constructors
| ImportDecl | |
|
Fields
|
|
Instances
data ImportSpecList l Source #
An explicit import specification list.
Constructors
| ImportSpecList l Bool [ ImportSpec l] |
A list of import specifications.
The
|
Instances
data ImportSpec l Source #
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) |
|
| IThingAll l ( Name l) |
|
| IThingWith l ( Name l) [ CName l] |
|
Instances
Associativity of an operator.
Constructors
| AssocNone l |
non-associative operator (declared with
|
| AssocLeft l |
left-associative operator (declared with
|
| AssocRight l |
right-associative operator (declared with
|
Instances
| Functor Assoc Source # | |
| Foldable Assoc Source # | |
|
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Assoc m -> m Source # foldMap :: Monoid m => (a -> m) -> Assoc a -> m Source # foldMap' :: Monoid m => (a -> m) -> Assoc a -> m Source # foldr :: (a -> b -> b) -> b -> Assoc a -> b Source # foldr' :: (a -> b -> b) -> b -> Assoc a -> b Source # foldl :: (b -> a -> b) -> b -> Assoc a -> b Source # foldl' :: (b -> a -> b) -> b -> Assoc a -> b Source # foldr1 :: (a -> a -> a) -> Assoc a -> a Source # foldl1 :: (a -> a -> a) -> Assoc a -> a Source # toList :: Assoc a -> [a] Source # null :: Assoc a -> Bool Source # length :: Assoc a -> Int Source # elem :: Eq a => a -> Assoc a -> Bool Source # maximum :: Ord a => Assoc a -> a Source # minimum :: Ord a => Assoc a -> a Source # |
|
| Traversable Assoc Source # | |
|
Defined in Language.Haskell.Exts.Syntax |
|
| Annotated Assoc Source # | |
| ExactP Assoc Source # | |
|
Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Assoc SrcSpanInfo -> EP () |
|
| Eq l => Eq ( Assoc l) Source # | |
| Data l => Data ( Assoc l) Source # | |
|
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) Source # gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c ( Assoc l) Source # toConstr :: Assoc l -> Constr Source # dataTypeOf :: Assoc l -> DataType Source # dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c ( Assoc l)) Source # dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c ( Assoc l)) Source # gmapT :: ( forall b. Data b => b -> b) -> Assoc l -> Assoc l Source # gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> Assoc l -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> Assoc l -> r Source # gmapQ :: ( forall d. Data d => d -> u) -> Assoc l -> [u] Source # gmapQi :: Int -> ( forall d. Data d => d -> u) -> Assoc l -> u Source # gmapM :: Monad m => ( forall d. Data d => d -> m d) -> Assoc l -> m ( Assoc l) Source # gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> Assoc l -> m ( Assoc l) Source # gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> Assoc l -> m ( Assoc l) Source # |
|
| Ord l => Ord ( Assoc l) Source # | |
|
Defined in Language.Haskell.Exts.Syntax |
|
| Show l => Show ( Assoc l) Source # | |
| Generic ( Assoc l) Source # | |
| Pretty ( Assoc l) Source # | |
|
Defined in Language.Haskell.Exts.Pretty |
|
| type Rep ( Assoc l) Source # | |
|
Defined in Language.Haskell.Exts.Syntax
type
Rep
(
Assoc
l) =
D1
('
MetaData
"Assoc" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-LTqMCpSQH9m4ymWElpQTPo" '
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))))
|
|
Namespaces for imports/exports.
Constructors
| NoNamespace l | |
| TypeNamespace l | |
| PatternNamespace l |
Instances
Declarations
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
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
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
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
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
| Functor Binds Source # | |
| Foldable Binds Source # | |
|
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Binds m -> m Source # foldMap :: Monoid m => (a -> m) -> Binds a -> m Source # foldMap' :: Monoid m => (a -> m) -> Binds a -> m Source # foldr :: (a -> b -> b) -> b -> Binds a -> b Source # foldr' :: (a -> b -> b) -> b -> Binds a -> b Source # foldl :: (b -> a -> b) -> b -> Binds a -> b Source # foldl' :: (b -> a -> b) -> b -> Binds a -> b Source # foldr1 :: (a -> a -> a) -> Binds a -> a Source # foldl1 :: (a -> a -> a) -> Binds a -> a Source # toList :: Binds a -> [a] Source # null :: Binds a -> Bool Source # length :: Binds a -> Int Source # elem :: Eq a => a -> Binds a -> Bool Source # maximum :: Ord a => Binds a -> a Source # minimum :: Ord a => Binds a -> a Source # |
|
| Traversable Binds Source # | |
|
Defined in Language.Haskell.Exts.Syntax |
|
| Annotated Binds Source # | |
| AppFixity Binds Source # | |
|
Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: MonadFail m => [ Fixity ] -> Binds SrcSpanInfo -> m ( Binds SrcSpanInfo ) Source # |
|
| ExactP Binds Source # | |
|
Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Binds SrcSpanInfo -> EP () |
|
| Eq l => Eq ( Binds l) Source # | |
| Data l => Data ( Binds l) Source # | |
|
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) Source # gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c ( Binds l) Source # toConstr :: Binds l -> Constr Source # dataTypeOf :: Binds l -> DataType Source # dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c ( Binds l)) Source # dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c ( Binds l)) Source # gmapT :: ( forall b. Data b => b -> b) -> Binds l -> Binds l Source # gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> Binds l -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> Binds l -> r Source # gmapQ :: ( forall d. Data d => d -> u) -> Binds l -> [u] Source # gmapQi :: Int -> ( forall d. Data d => d -> u) -> Binds l -> u Source # gmapM :: Monad m => ( forall d. Data d => d -> m d) -> Binds l -> m ( Binds l) Source # gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> Binds l -> m ( Binds l) Source # gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> Binds l -> m ( Binds l) Source # |
|
| Ord l => Ord ( Binds l) Source # | |
|
Defined in Language.Haskell.Exts.Syntax |
|
| Show l => Show ( Binds l) Source # | |
| Generic ( Binds l) Source # | |
| type Rep ( Binds l) Source # | |
|
Defined in Language.Haskell.Exts.Syntax
type
Rep
(
Binds
l) =
D1
('
MetaData
"Binds" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-LTqMCpSQH9m4ymWElpQTPo" '
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])))
|
|
A binding of an implicit parameter.
Instances
| Functor IPBind Source # | |
| Foldable IPBind Source # | |
|
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => IPBind m -> m Source # foldMap :: Monoid m => (a -> m) -> IPBind a -> m Source # foldMap' :: Monoid m => (a -> m) -> IPBind a -> m Source # foldr :: (a -> b -> b) -> b -> IPBind a -> b Source # foldr' :: (a -> b -> b) -> b -> IPBind a -> b Source # foldl :: (b -> a -> b) -> b -> IPBind a -> b Source # foldl' :: (b -> a -> b) -> b -> IPBind a -> b Source # foldr1 :: (a -> a -> a) -> IPBind a -> a Source # foldl1 :: (a -> a -> a) -> IPBind a -> a Source # toList :: IPBind a -> [a] Source # null :: IPBind a -> Bool Source # length :: IPBind a -> Int Source # elem :: Eq a => a -> IPBind a -> Bool Source # maximum :: Ord a => IPBind a -> a Source # minimum :: Ord a => IPBind a -> a Source # |
|
| Traversable IPBind Source # | |
|
Defined in Language.Haskell.Exts.Syntax |
|
| Annotated IPBind Source # | |
| AppFixity IPBind Source # | |
|
Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: MonadFail m => [ Fixity ] -> IPBind SrcSpanInfo -> m ( IPBind SrcSpanInfo ) Source # |
|
| ExactP IPBind Source # | |
|
Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: IPBind SrcSpanInfo -> EP () |
|
| Eq l => Eq ( IPBind l) Source # | |
| Data l => Data ( IPBind l) Source # | |
|
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) Source # gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c ( IPBind l) Source # toConstr :: IPBind l -> Constr Source # dataTypeOf :: IPBind l -> DataType Source # dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c ( IPBind l)) Source # dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c ( IPBind l)) Source # gmapT :: ( forall b. Data b => b -> b) -> IPBind l -> IPBind l Source # gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> IPBind l -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> IPBind l -> r Source # gmapQ :: ( forall d. Data d => d -> u) -> IPBind l -> [u] Source # gmapQi :: Int -> ( forall d. Data d => d -> u) -> IPBind l -> u Source # gmapM :: Monad m => ( forall d. Data d => d -> m d) -> IPBind l -> m ( IPBind l) Source # gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> IPBind l -> m ( IPBind l) Source # gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> IPBind l -> m ( IPBind l) Source # |
|
| Ord l => Ord ( IPBind l) Source # | |
|
Defined in Language.Haskell.Exts.Syntax |
|
| Show l => Show ( IPBind l) Source # | |
| Generic ( IPBind l) Source # | |
| Pretty ( IPBind l) Source # | |
|
Defined in Language.Haskell.Exts.Pretty |
|
| type Rep ( IPBind l) Source # | |
|
Defined in Language.Haskell.Exts.Syntax
type
Rep
(
IPBind
l) =
D1
('
MetaData
"IPBind" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-LTqMCpSQH9m4ymWElpQTPo" '
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 Source #
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
data InjectivityInfo l Source #
Injectivity info for injective type families
Constructors
| InjectivityInfo l ( Name l) [ Name l] |
Instances
Instances
Type classes and instances
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
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
A deriving clause following a data type declaration.
Constructors
| Deriving l ( Maybe ( DerivStrategy l)) [ InstRule l] |
Instances
data DerivStrategy l Source #
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.,
|
| DerivAnyclass l |
-XDeriveAnyClass |
| DerivNewtype l |
-XGeneralizedNewtypeDeriving |
| DerivVia l ( Type l) |
-XDerivingVia |
Instances
Data type declarations
A flag stating whether a declaration is a data or newtype declaration.
Instances
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
Declaration of a (list of) named field(s).
Instances
data QualConDecl l Source #
A single constructor declaration within a data type declaration, which may have an existential quantification binding.
Instances
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
FieldDecl
s, 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
is
Maybe
[
FieldDecl
l]
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
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
| Functor BangType Source # | |
| Foldable BangType Source # | |
|
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => BangType m -> m Source # foldMap :: Monoid m => (a -> m) -> BangType a -> m Source # foldMap' :: Monoid m => (a -> m) -> BangType a -> m Source # foldr :: (a -> b -> b) -> b -> BangType a -> b Source # foldr' :: (a -> b -> b) -> b -> BangType a -> b Source # foldl :: (b -> a -> b) -> b -> BangType a -> b Source # foldl' :: (b -> a -> b) -> b -> BangType a -> b Source # foldr1 :: (a -> a -> a) -> BangType a -> a Source # foldl1 :: (a -> a -> a) -> BangType a -> a Source # toList :: BangType a -> [a] Source # null :: BangType a -> Bool Source # length :: BangType a -> Int Source # elem :: Eq a => a -> BangType a -> Bool Source # maximum :: Ord a => BangType a -> a Source # minimum :: Ord a => BangType a -> a Source # |
|
| Traversable BangType Source # | |
|
Defined in Language.Haskell.Exts.Syntax Methods traverse :: Applicative f => (a -> f b) -> BangType a -> f ( BangType b) Source # sequenceA :: Applicative f => BangType (f a) -> f ( BangType a) Source # mapM :: Monad m => (a -> m b) -> BangType a -> m ( BangType b) Source # sequence :: Monad m => BangType (m a) -> m ( BangType a) Source # |
|
| Annotated BangType Source # | |
| ExactP BangType Source # | |
|
Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: BangType SrcSpanInfo -> EP () |
|
| Eq l => Eq ( BangType l) Source # | |
| Data l => Data ( BangType l) Source # | |
|
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) Source # gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c ( BangType l) Source # toConstr :: BangType l -> Constr Source # dataTypeOf :: BangType l -> DataType Source # dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c ( BangType l)) Source # dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c ( BangType l)) Source # gmapT :: ( forall b. Data b => b -> b) -> BangType l -> BangType l Source # gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> BangType l -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> BangType l -> r Source # gmapQ :: ( forall d. Data d => d -> u) -> BangType l -> [u] Source # gmapQi :: Int -> ( forall d. Data d => d -> u) -> BangType l -> u Source # gmapM :: Monad m => ( forall d. Data d => d -> m d) -> BangType l -> m ( BangType l) Source # gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> BangType l -> m ( BangType l) Source # gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> BangType l -> m ( BangType l) Source # |
|
| Ord l => Ord ( BangType l) Source # | |
|
Defined in Language.Haskell.Exts.Syntax Methods compare :: BangType l -> BangType l -> Ordering Source # (<) :: BangType l -> BangType l -> Bool Source # (<=) :: BangType l -> BangType l -> Bool Source # (>) :: BangType l -> BangType l -> Bool Source # (>=) :: BangType l -> BangType l -> Bool Source # |
|
| Show l => Show ( BangType l) Source # | |
| Generic ( BangType l) Source # | |
| Pretty ( BangType l) Source # | |
|
Defined in Language.Haskell.Exts.Pretty |
|
| type Rep ( BangType l) Source # | |
|
Defined in Language.Haskell.Exts.Syntax
type
Rep
(
BangType
l) =
D1
('
MetaData
"BangType" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-LTqMCpSQH9m4ymWElpQTPo" '
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 Source #
Constructors
| Unpack l |
"
|
| NoUnpack l |
"
|
| NoUnpackPragma l |
No unpack pragma |
Instances
Function bindings
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
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
| Functor Rhs Source # | |
| Foldable Rhs Source # | |
|
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Rhs m -> m Source # foldMap :: Monoid m => (a -> m) -> Rhs a -> m Source # foldMap' :: Monoid m => (a -> m) -> Rhs a -> m Source # foldr :: (a -> b -> b) -> b -> Rhs a -> b Source # foldr' :: (a -> b -> b) -> b -> Rhs a -> b Source # foldl :: (b -> a -> b) -> b -> Rhs a -> b Source # foldl' :: (b -> a -> b) -> b -> Rhs a -> b Source # foldr1 :: (a -> a -> a) -> Rhs a -> a Source # foldl1 :: (a -> a -> a) -> Rhs a -> a Source # toList :: Rhs a -> [a] Source # null :: Rhs a -> Bool Source # length :: Rhs a -> Int Source # elem :: Eq a => a -> Rhs a -> Bool Source # maximum :: Ord a => Rhs a -> a Source # minimum :: Ord a => Rhs a -> a Source # |
|
| Traversable Rhs Source # | |
|
Defined in Language.Haskell.Exts.Syntax |
|
| Annotated Rhs Source # | |
| AppFixity Rhs Source # | |
|
Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: MonadFail m => [ Fixity ] -> Rhs SrcSpanInfo -> m ( Rhs SrcSpanInfo ) Source # |
|
| ExactP Rhs Source # | |
|
Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Rhs SrcSpanInfo -> EP () |
|
| Eq l => Eq ( Rhs l) Source # | |
| Data l => Data ( Rhs l) Source # | |
|
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) Source # gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c ( Rhs l) Source # toConstr :: Rhs l -> Constr Source # dataTypeOf :: Rhs l -> DataType Source # dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c ( Rhs l)) Source # dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c ( Rhs l)) Source # gmapT :: ( forall b. Data b => b -> b) -> Rhs l -> Rhs l Source # gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> Rhs l -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> Rhs l -> r Source # gmapQ :: ( forall d. Data d => d -> u) -> Rhs l -> [u] Source # gmapQi :: Int -> ( forall d. Data d => d -> u) -> Rhs l -> u Source # gmapM :: Monad m => ( forall d. Data d => d -> m d) -> Rhs l -> m ( Rhs l) Source # gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> Rhs l -> m ( Rhs l) Source # gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> Rhs l -> m ( Rhs l) Source # |
|
| Ord l => Ord ( Rhs l) Source # | |
|
Defined in Language.Haskell.Exts.Syntax |
|
| Show l => Show ( Rhs l) Source # | |
| Generic ( Rhs l) Source # | |
| Pretty ( Rhs l) Source # | |
|
Defined in Language.Haskell.Exts.Pretty |
|
| type Rep ( Rhs l) Source # | |
|
Defined in Language.Haskell.Exts.Syntax
type
Rep
(
Rhs
l) =
D1
('
MetaData
"Rhs" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-LTqMCpSQH9m4ymWElpQTPo" '
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 Source #
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
Class Assertions and Contexts
A context is a set of assertions
Instances
A functional dependency, given on the form l1 l2 ... ln -> r2 r3 .. rn
Instances
| Functor FunDep Source # | |
| Foldable FunDep Source # | |
|
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => FunDep m -> m Source # foldMap :: Monoid m => (a -> m) -> FunDep a -> m Source # foldMap' :: Monoid m => (a -> m) -> FunDep a -> m Source # foldr :: (a -> b -> b) -> b -> FunDep a -> b Source # foldr' :: (a -> b -> b) -> b -> FunDep a -> b Source # foldl :: (b -> a -> b) -> b -> FunDep a -> b Source # foldl' :: (b -> a -> b) -> b -> FunDep a -> b Source # foldr1 :: (a -> a -> a) -> FunDep a -> a Source # foldl1 :: (a -> a -> a) -> FunDep a -> a Source # toList :: FunDep a -> [a] Source # null :: FunDep a -> Bool Source # length :: FunDep a -> Int Source # elem :: Eq a => a -> FunDep a -> Bool Source # maximum :: Ord a => FunDep a -> a Source # minimum :: Ord a => FunDep a -> a Source # |
|
| Traversable FunDep Source # | |
|
Defined in Language.Haskell.Exts.Syntax |
|
| Annotated FunDep Source # | |
| ExactP FunDep Source # | |
|
Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: FunDep SrcSpanInfo -> EP () |
|
| Eq l => Eq ( FunDep l) Source # | |
| Data l => Data ( FunDep l) Source # | |
|
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) Source # gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c ( FunDep l) Source # toConstr :: FunDep l -> Constr Source # dataTypeOf :: FunDep l -> DataType Source # dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c ( FunDep l)) Source # dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c ( FunDep l)) Source # gmapT :: ( forall b. Data b => b -> b) -> FunDep l -> FunDep l Source # gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> FunDep l -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> FunDep l -> r Source # gmapQ :: ( forall d. Data d => d -> u) -> FunDep l -> [u] Source # gmapQi :: Int -> ( forall d. Data d => d -> u) -> FunDep l -> u Source # gmapM :: Monad m => ( forall d. Data d => d -> m d) -> FunDep l -> m ( FunDep l) Source # gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> FunDep l -> m ( FunDep l) Source # gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> FunDep l -> m ( FunDep l) Source # |
|
| Ord l => Ord ( FunDep l) Source # | |
|
Defined in Language.Haskell.Exts.Syntax |
|
| Show l => Show ( FunDep l) Source # | |
| Generic ( FunDep l) Source # | |
| Pretty ( FunDep l) Source # | |
|
Defined in Language.Haskell.Exts.Pretty |
|
| type Rep ( FunDep l) Source # | |
|
Defined in Language.Haskell.Exts.Syntax
type
Rep
(
FunDep
l) =
D1
('
MetaData
"FunDep" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-LTqMCpSQH9m4ymWElpQTPo" '
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]))))
|
|
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
| Functor Asst Source # | |
| Foldable Asst Source # | |
|
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Asst m -> m Source # foldMap :: Monoid m => (a -> m) -> Asst a -> m Source # foldMap' :: Monoid m => (a -> m) -> Asst a -> m Source # foldr :: (a -> b -> b) -> b -> Asst a -> b Source # foldr' :: (a -> b -> b) -> b -> Asst a -> b Source # foldl :: (b -> a -> b) -> b -> Asst a -> b Source # foldl' :: (b -> a -> b) -> b -> Asst a -> b Source # foldr1 :: (a -> a -> a) -> Asst a -> a Source # foldl1 :: (a -> a -> a) -> Asst a -> a Source # toList :: Asst a -> [a] Source # null :: Asst a -> Bool Source # length :: Asst a -> Int Source # elem :: Eq a => a -> Asst a -> Bool Source # maximum :: Ord a => Asst a -> a Source # minimum :: Ord a => Asst a -> a Source # |
|
| Traversable Asst Source # | |
|
Defined in Language.Haskell.Exts.Syntax |
|
| Annotated Asst Source # | |
| ExactP Asst Source # | |
|
Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Asst SrcSpanInfo -> EP () |
|
| Eq l => Eq ( Asst l) Source # | |
| Data l => Data ( Asst l) Source # | |
|
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) Source # gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c ( Asst l) Source # toConstr :: Asst l -> Constr Source # dataTypeOf :: Asst l -> DataType Source # dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c ( Asst l)) Source # dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c ( Asst l)) Source # gmapT :: ( forall b. Data b => b -> b) -> Asst l -> Asst l Source # gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> Asst l -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> Asst l -> r Source # gmapQ :: ( forall d. Data d => d -> u) -> Asst l -> [u] Source # gmapQi :: Int -> ( forall d. Data d => d -> u) -> Asst l -> u Source # gmapM :: Monad m => ( forall d. Data d => d -> m d) -> Asst l -> m ( Asst l) Source # gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> Asst l -> m ( Asst l) Source # gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> Asst l -> m ( Asst l) Source # |
|
| Ord l => Ord ( Asst l) Source # | |
|
Defined in Language.Haskell.Exts.Syntax |
|
| Show l => Show ( Asst l) Source # | |
| Generic ( Asst l) Source # | |
| Pretty ( Asst l) Source # | |
|
Defined in Language.Haskell.Exts.Pretty |
|
| type Rep ( Asst l) Source # | |
|
Defined in Language.Haskell.Exts.Syntax
type
Rep
(
Asst
l) =
D1
('
MetaData
"Asst" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-LTqMCpSQH9m4ymWElpQTPo" '
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
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 |
|
| 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) |
|
| 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 "
|
| TyWildCard l ( Maybe ( Name l)) |
Either an anonymous of named type wildcard |
| TyQuasiQuote l String String |
[$name| string |] |
Instances
Flag denoting whether a tuple is boxed or unboxed.
Instances
| Eq Boxed Source # | |
| Data Boxed Source # | |
|
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 Source # gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c Boxed Source # toConstr :: Boxed -> Constr Source # dataTypeOf :: Boxed -> DataType Source # dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c Boxed ) Source # dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c Boxed ) Source # gmapT :: ( forall b. Data b => b -> b) -> Boxed -> Boxed Source # gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> Boxed -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> Boxed -> r Source # gmapQ :: ( forall d. Data d => d -> u) -> Boxed -> [u] Source # gmapQi :: Int -> ( forall d. Data d => d -> u) -> Boxed -> u Source # gmapM :: Monad m => ( forall d. Data d => d -> m d) -> Boxed -> m Boxed Source # gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> Boxed -> m Boxed Source # gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> Boxed -> m Boxed Source # |
|
| Ord Boxed Source # | |
|
Defined in Language.Haskell.Exts.Syntax |
|
| Show Boxed Source # | |
| Generic Boxed Source # | |
| type Rep Boxed Source # | |
|
Defined in Language.Haskell.Exts.Syntax |
|
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
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
A type equation as found in closed type families.
Instances
| Functor TypeEqn Source # | |
| Foldable TypeEqn Source # | |
|
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => TypeEqn m -> m Source # foldMap :: Monoid m => (a -> m) -> TypeEqn a -> m Source # foldMap' :: Monoid m => (a -> m) -> TypeEqn a -> m Source # foldr :: (a -> b -> b) -> b -> TypeEqn a -> b Source # foldr' :: (a -> b -> b) -> b -> TypeEqn a -> b Source # foldl :: (b -> a -> b) -> b -> TypeEqn a -> b Source # foldl' :: (b -> a -> b) -> b -> TypeEqn a -> b Source # foldr1 :: (a -> a -> a) -> TypeEqn a -> a Source # foldl1 :: (a -> a -> a) -> TypeEqn a -> a Source # toList :: TypeEqn a -> [a] Source # null :: TypeEqn a -> Bool Source # length :: TypeEqn a -> Int Source # elem :: Eq a => a -> TypeEqn a -> Bool Source # maximum :: Ord a => TypeEqn a -> a Source # minimum :: Ord a => TypeEqn a -> a Source # |
|
| Traversable TypeEqn Source # | |
|
Defined in Language.Haskell.Exts.Syntax |
|
| Annotated TypeEqn Source # | |
| ExactP TypeEqn Source # | |
|
Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: TypeEqn SrcSpanInfo -> EP () |
|
| Eq l => Eq ( TypeEqn l) Source # | |
| Data l => Data ( TypeEqn l) Source # | |
|
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) Source # gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c ( TypeEqn l) Source # toConstr :: TypeEqn l -> Constr Source # dataTypeOf :: TypeEqn l -> DataType Source # dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c ( TypeEqn l)) Source # dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c ( TypeEqn l)) Source # gmapT :: ( forall b. Data b => b -> b) -> TypeEqn l -> TypeEqn l Source # gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> TypeEqn l -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> TypeEqn l -> r Source # gmapQ :: ( forall d. Data d => d -> u) -> TypeEqn l -> [u] Source # gmapQi :: Int -> ( forall d. Data d => d -> u) -> TypeEqn l -> u Source # gmapM :: Monad m => ( forall d. Data d => d -> m d) -> TypeEqn l -> m ( TypeEqn l) Source # gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> TypeEqn l -> m ( TypeEqn l) Source # gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> TypeEqn l -> m ( TypeEqn l) Source # |
|
| Ord l => Ord ( TypeEqn l) Source # | |
|
Defined in Language.Haskell.Exts.Syntax Methods compare :: TypeEqn l -> TypeEqn l -> Ordering Source # (<) :: TypeEqn l -> TypeEqn l -> Bool Source # (<=) :: TypeEqn l -> TypeEqn l -> Bool Source # (>) :: TypeEqn l -> TypeEqn l -> Bool Source # (>=) :: TypeEqn l -> TypeEqn l -> Bool Source # |
|
| Show l => Show ( TypeEqn l) Source # | |
| Generic ( TypeEqn l) Source # | |
| Pretty ( TypeEqn l) Source # | |
|
Defined in Language.Haskell.Exts.Pretty |
|
| type Rep ( TypeEqn l) Source # | |
|
Defined in Language.Haskell.Exts.Syntax
type
Rep
(
TypeEqn
l) =
D1
('
MetaData
"TypeEqn" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-LTqMCpSQH9m4ymWElpQTPo" '
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
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
|
| Lambda l [ Pat l] ( Exp l) |
lambda expression |
| Let l ( Binds l) ( Exp l) |
local declarations with
|
| 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] |
tuple expression |
| UnboxedSum l Int Int ( Exp l) |
unboxed sum |
| TupleSection l Boxed [ Maybe ( Exp l)] |
tuple section expression, e.g.
|
| 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
|
| RightSection l ( QOp l) ( Exp l) |
right section
|
| 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:
|
| EnumFromTo l ( Exp l) ( Exp l) |
bounded arithmetic sequence,
incrementing by 1
|
| EnumFromThen l ( Exp l) ( Exp l) |
unbounded arithmetic sequence,
with first two elements given
|
| EnumFromThenTo l ( Exp l) ( Exp l) ( Exp l) |
bounded arithmetic sequence,
with first two elements given
|
| ParArrayFromTo l ( Exp l) ( Exp l) |
Parallel array bounded arithmetic sequence,
incrementing by 1
|
| ParArrayFromThenTo l ( Exp l) ( Exp l) ( Exp l) |
bounded arithmetic sequence,
with first two elements given
|
| 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) |
|
| TypQuote l ( QName l) |
|
| BracketExp l ( Bracket l) |
template haskell bracket expression |
| SpliceExp l ( Splice l) |
template haskell splice expression |
| QuasiQuote l String String |
quasi-quotaion:
|
| 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:
|
| LeftArrApp l ( Exp l) ( Exp l) |
arrow application (from left):
exp
|
| RightArrApp l ( Exp l) ( Exp l) |
arrow application (from right):
exp
|
| LeftArrHighApp l ( Exp l) ( Exp l) |
higher-order arrow application (from left):
exp
|
| RightArrHighApp l ( Exp l) ( Exp l) |
higher-order arrow application (from right):
exp
|
| ArrOp l ( Exp l) |
arrow control operators:
|
| LCase l [ Alt l] |
|
Instances
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
|
| Qualifier l ( Exp l) |
an
exp
by itself: in a
|
| LetStmt l ( Binds l) |
local bindings |
| RecStmt l [ Stmt l] |
a recursive binding group for arrows |
Instances
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) |
|
| ThenBy l ( Exp l) ( Exp l) |
|
| GroupBy l ( Exp l) |
|
| GroupUsing l ( Exp l) |
|
| GroupByUsing l ( Exp l) ( Exp l) |
|
Instances
data FieldUpdate l Source #
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
An
alt
alternative in a
case
expression.
Instances
| Functor Alt Source # | |
| Foldable Alt Source # | |
|
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Alt m -> m Source # foldMap :: Monoid m => (a -> m) -> Alt a -> m Source # foldMap' :: Monoid m => (a -> m) -> Alt a -> m Source # foldr :: (a -> b -> b) -> b -> Alt a -> b Source # foldr' :: (a -> b -> b) -> b -> Alt a -> b Source # foldl :: (b -> a -> b) -> b -> Alt a -> b Source # foldl' :: (b -> a -> b) -> b -> Alt a -> b Source # foldr1 :: (a -> a -> a) -> Alt a -> a Source # foldl1 :: (a -> a -> a) -> Alt a -> a Source # toList :: Alt a -> [a] Source # null :: Alt a -> Bool Source # length :: Alt a -> Int Source # elem :: Eq a => a -> Alt a -> Bool Source # maximum :: Ord a => Alt a -> a Source # minimum :: Ord a => Alt a -> a Source # |
|
| Traversable Alt Source # | |
|
Defined in Language.Haskell.Exts.Syntax |
|
| Annotated Alt Source # | |
| AppFixity Alt Source # | |
|
Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: MonadFail m => [ Fixity ] -> Alt SrcSpanInfo -> m ( Alt SrcSpanInfo ) Source # |
|
| ExactP Alt Source # | |
|
Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Alt SrcSpanInfo -> EP () |
|
| Eq l => Eq ( Alt l) Source # | |
| Data l => Data ( Alt l) Source # | |
|
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) Source # gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c ( Alt l) Source # toConstr :: Alt l -> Constr Source # dataTypeOf :: Alt l -> DataType Source # dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c ( Alt l)) Source # dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c ( Alt l)) Source # gmapT :: ( forall b. Data b => b -> b) -> Alt l -> Alt l Source # gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> Alt l -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> Alt l -> r Source # gmapQ :: ( forall d. Data d => d -> u) -> Alt l -> [u] Source # gmapQi :: Int -> ( forall d. Data d => d -> u) -> Alt l -> u Source # gmapM :: Monad m => ( forall d. Data d => d -> m d) -> Alt l -> m ( Alt l) Source # gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> Alt l -> m ( Alt l) Source # gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> Alt l -> m ( Alt l) Source # |
|
| Ord l => Ord ( Alt l) Source # | |
|
Defined in Language.Haskell.Exts.Syntax |
|
| Show l => Show ( Alt l) Source # | |
| Generic ( Alt l) Source # | |
| Pretty ( Alt l) Source # | |
|
Defined in Language.Haskell.Exts.Pretty |
|
| type Rep ( Alt l) Source # | |
|
Defined in Language.Haskell.Exts.Syntax
type
Rep
(
Alt
l) =
D1
('
MetaData
"Alt" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-LTqMCpSQH9m4ymWElpQTPo" '
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))))))
|
|
An xml attribute, which is a name-expression pair.
Instances
| Functor XAttr Source # | |
| Foldable XAttr Source # | |
|
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => XAttr m -> m Source # foldMap :: Monoid m => (a -> m) -> XAttr a -> m Source # foldMap' :: Monoid m => (a -> m) -> XAttr a -> m Source # foldr :: (a -> b -> b) -> b -> XAttr a -> b Source # foldr' :: (a -> b -> b) -> b -> XAttr a -> b Source # foldl :: (b -> a -> b) -> b -> XAttr a -> b Source # foldl' :: (b -> a -> b) -> b -> XAttr a -> b Source # foldr1 :: (a -> a -> a) -> XAttr a -> a Source # foldl1 :: (a -> a -> a) -> XAttr a -> a Source # toList :: XAttr a -> [a] Source # null :: XAttr a -> Bool Source # length :: XAttr a -> Int Source # elem :: Eq a => a -> XAttr a -> Bool Source # maximum :: Ord a => XAttr a -> a Source # minimum :: Ord a => XAttr a -> a Source # |
|
| Traversable XAttr Source # | |
|
Defined in Language.Haskell.Exts.Syntax |
|
| Annotated XAttr Source # | |
| AppFixity XAttr Source # | |
|
Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: MonadFail m => [ Fixity ] -> XAttr SrcSpanInfo -> m ( XAttr SrcSpanInfo ) Source # |
|
| ExactP XAttr Source # | |
|
Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: XAttr SrcSpanInfo -> EP () |
|
| Eq l => Eq ( XAttr l) Source # | |
| Data l => Data ( XAttr l) Source # | |
|
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) Source # gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c ( XAttr l) Source # toConstr :: XAttr l -> Constr Source # dataTypeOf :: XAttr l -> DataType Source # dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c ( XAttr l)) Source # dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c ( XAttr l)) Source # gmapT :: ( forall b. Data b => b -> b) -> XAttr l -> XAttr l Source # gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> XAttr l -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> XAttr l -> r Source # gmapQ :: ( forall d. Data d => d -> u) -> XAttr l -> [u] Source # gmapQi :: Int -> ( forall d. Data d => d -> u) -> XAttr l -> u Source # gmapM :: Monad m => ( forall d. Data d => d -> m d) -> XAttr l -> m ( XAttr l) Source # gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> XAttr l -> m ( XAttr l) Source # gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> XAttr l -> m ( XAttr l) Source # |
|
| Ord l => Ord ( XAttr l) Source # | |
|
Defined in Language.Haskell.Exts.Syntax |
|
| Show l => Show ( XAttr l) Source # | |
| Generic ( XAttr l) Source # | |
| Pretty ( XAttr l) Source # | |
|
Defined in Language.Haskell.Exts.Pretty |
|
| type Rep ( XAttr l) Source # | |
|
Defined in Language.Haskell.Exts.Syntax
type
Rep
(
XAttr
l) =
D1
('
MetaData
"XAttr" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-LTqMCpSQH9m4ymWElpQTPo" '
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
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) |
|
| PWildCard l |
wildcard pattern:
|
| PIrrPat l ( Pat l) |
irrefutable pattern:
|
| PatTypeSig l ( Pat l) ( Type l) |
pattern with type signature |
| PViewPat l ( Exp l) ( Pat l) |
view patterns of the form
|
| 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:
|
| PBangPat l ( Pat l) |
strict (bang) pattern:
|
Instances
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
An XML attribute in a pattern.
Instances
| Functor PXAttr Source # | |
| Foldable PXAttr Source # | |
|
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => PXAttr m -> m Source # foldMap :: Monoid m => (a -> m) -> PXAttr a -> m Source # foldMap' :: Monoid m => (a -> m) -> PXAttr a -> m Source # foldr :: (a -> b -> b) -> b -> PXAttr a -> b Source # foldr' :: (a -> b -> b) -> b -> PXAttr a -> b Source # foldl :: (b -> a -> b) -> b -> PXAttr a -> b Source # foldl' :: (b -> a -> b) -> b -> PXAttr a -> b Source # foldr1 :: (a -> a -> a) -> PXAttr a -> a Source # foldl1 :: (a -> a -> a) -> PXAttr a -> a Source # toList :: PXAttr a -> [a] Source # null :: PXAttr a -> Bool Source # length :: PXAttr a -> Int Source # elem :: Eq a => a -> PXAttr a -> Bool Source # maximum :: Ord a => PXAttr a -> a Source # minimum :: Ord a => PXAttr a -> a Source # |
|
| Traversable PXAttr Source # | |
|
Defined in Language.Haskell.Exts.Syntax |
|
| Annotated PXAttr Source # | |
| AppFixity PXAttr Source # | |
|
Defined in Language.Haskell.Exts.Fixity Methods applyFixities :: MonadFail m => [ Fixity ] -> PXAttr SrcSpanInfo -> m ( PXAttr SrcSpanInfo ) Source # |
|
| ExactP PXAttr Source # | |
|
Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: PXAttr SrcSpanInfo -> EP () |
|
| Eq l => Eq ( PXAttr l) Source # | |
| Data l => Data ( PXAttr l) Source # | |
|
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) Source # gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c ( PXAttr l) Source # toConstr :: PXAttr l -> Constr Source # dataTypeOf :: PXAttr l -> DataType Source # dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c ( PXAttr l)) Source # dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c ( PXAttr l)) Source # gmapT :: ( forall b. Data b => b -> b) -> PXAttr l -> PXAttr l Source # gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> PXAttr l -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> PXAttr l -> r Source # gmapQ :: ( forall d. Data d => d -> u) -> PXAttr l -> [u] Source # gmapQi :: Int -> ( forall d. Data d => d -> u) -> PXAttr l -> u Source # gmapM :: Monad m => ( forall d. Data d => d -> m d) -> PXAttr l -> m ( PXAttr l) Source # gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> PXAttr l -> m ( PXAttr l) Source # gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> PXAttr l -> m ( PXAttr l) Source # |
|
| Ord l => Ord ( PXAttr l) Source # | |
|
Defined in Language.Haskell.Exts.Syntax |
|
| Show l => Show ( PXAttr l) Source # | |
| Generic ( PXAttr l) Source # | |
| Pretty ( PXAttr l) Source # | |
|
Defined in Language.Haskell.Exts.Pretty |
|
| type Rep ( PXAttr l) Source # | |
|
Defined in Language.Haskell.Exts.Syntax
type
Rep
(
PXAttr
l) =
D1
('
MetaData
"PXAttr" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-LTqMCpSQH9m4ymWElpQTPo" '
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)))))
|
|
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
A regular pattern operator.
Constructors
| RPStar l |
|
| RPStarG l |
|
| RPPlus l |
|
| RPPlusG l |
|
| RPOpt l |
|
| RPOptG l |
|
Instances
| Functor RPatOp Source # | |
| Foldable RPatOp Source # | |
|
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => RPatOp m -> m Source # foldMap :: Monoid m => (a -> m) -> RPatOp a -> m Source # foldMap' :: Monoid m => (a -> m) -> RPatOp a -> m Source # foldr :: (a -> b -> b) -> b -> RPatOp a -> b Source # foldr' :: (a -> b -> b) -> b -> RPatOp a -> b Source # foldl :: (b -> a -> b) -> b -> RPatOp a -> b Source # foldl' :: (b -> a -> b) -> b -> RPatOp a -> b Source # foldr1 :: (a -> a -> a) -> RPatOp a -> a Source # foldl1 :: (a -> a -> a) -> RPatOp a -> a Source # toList :: RPatOp a -> [a] Source # null :: RPatOp a -> Bool Source # length :: RPatOp a -> Int Source # elem :: Eq a => a -> RPatOp a -> Bool Source # maximum :: Ord a => RPatOp a -> a Source # minimum :: Ord a => RPatOp a -> a Source # |
|
| Traversable RPatOp Source # | |
|
Defined in Language.Haskell.Exts.Syntax |
|
| Annotated RPatOp Source # | |
| ExactP RPatOp Source # | |
|
Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: RPatOp SrcSpanInfo -> EP () |
|
| Eq l => Eq ( RPatOp l) Source # | |
| Data l => Data ( RPatOp l) Source # | |
|
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) Source # gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c ( RPatOp l) Source # toConstr :: RPatOp l -> Constr Source # dataTypeOf :: RPatOp l -> DataType Source # dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c ( RPatOp l)) Source # dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c ( RPatOp l)) Source # gmapT :: ( forall b. Data b => b -> b) -> RPatOp l -> RPatOp l Source # gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> RPatOp l -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> RPatOp l -> r Source # gmapQ :: ( forall d. Data d => d -> u) -> RPatOp l -> [u] Source # gmapQi :: Int -> ( forall d. Data d => d -> u) -> RPatOp l -> u Source # gmapM :: Monad m => ( forall d. Data d => d -> m d) -> RPatOp l -> m ( RPatOp l) Source # gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> RPatOp l -> m ( RPatOp l) Source # gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> RPatOp l -> m ( RPatOp l) Source # |
|
| Ord l => Ord ( RPatOp l) Source # | |
|
Defined in Language.Haskell.Exts.Syntax |
|
| Show l => Show ( RPatOp l) Source # | |
| Generic ( RPatOp l) Source # | |
| Pretty ( RPatOp l) Source # | |
|
Defined in Language.Haskell.Exts.Pretty |
|
| type Rep ( RPatOp l) Source # | |
|
Defined in Language.Haskell.Exts.Syntax
type
Rep
(
RPatOp
l) =
D1
('
MetaData
"RPatOp" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-LTqMCpSQH9m4ymWElpQTPo" '
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
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
An indication whether a literal pattern has been negated or not.
Instances
| Functor Sign Source # | |
| Foldable Sign Source # | |
|
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Sign m -> m Source # foldMap :: Monoid m => (a -> m) -> Sign a -> m Source # foldMap' :: Monoid m => (a -> m) -> Sign a -> m Source # foldr :: (a -> b -> b) -> b -> Sign a -> b Source # foldr' :: (a -> b -> b) -> b -> Sign a -> b Source # foldl :: (b -> a -> b) -> b -> Sign a -> b Source # foldl' :: (b -> a -> b) -> b -> Sign a -> b Source # foldr1 :: (a -> a -> a) -> Sign a -> a Source # foldl1 :: (a -> a -> a) -> Sign a -> a Source # toList :: Sign a -> [a] Source # null :: Sign a -> Bool Source # length :: Sign a -> Int Source # elem :: Eq a => a -> Sign a -> Bool Source # maximum :: Ord a => Sign a -> a Source # minimum :: Ord a => Sign a -> a Source # |
|
| Traversable Sign Source # | |
|
Defined in Language.Haskell.Exts.Syntax |
|
| Annotated Sign Source # | |
| ExactP Sign Source # | |
|
Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Sign SrcSpanInfo -> EP () |
|
| Eq l => Eq ( Sign l) Source # | |
| Data l => Data ( Sign l) Source # | |
|
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) Source # gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c ( Sign l) Source # toConstr :: Sign l -> Constr Source # dataTypeOf :: Sign l -> DataType Source # dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c ( Sign l)) Source # dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c ( Sign l)) Source # gmapT :: ( forall b. Data b => b -> b) -> Sign l -> Sign l Source # gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> Sign l -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> Sign l -> r Source # gmapQ :: ( forall d. Data d => d -> u) -> Sign l -> [u] Source # gmapQi :: Int -> ( forall d. Data d => d -> u) -> Sign l -> u Source # gmapM :: Monad m => ( forall d. Data d => d -> m d) -> Sign l -> m ( Sign l) Source # gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> Sign l -> m ( Sign l) Source # gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> Sign l -> m ( Sign l) Source # |
|
| Ord l => Ord ( Sign l) Source # | |
|
Defined in Language.Haskell.Exts.Syntax |
|
| Show l => Show ( Sign l) Source # | |
| Generic ( Sign l) Source # | |
| type Rep ( Sign l) Source # | |
|
Defined in Language.Haskell.Exts.Syntax
type
Rep
(
Sign
l) =
D1
('
MetaData
"Sign" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-LTqMCpSQH9m4ymWElpQTPo" '
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 Source #
The name of a Haskell module.
Constructors
| ModuleName l String |
Instances
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
This type is used to represent variables, and also constructors.
Instances
| Functor Name Source # | |
| Foldable Name Source # | |
|
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Name m -> m Source # foldMap :: Monoid m => (a -> m) -> Name a -> m Source # foldMap' :: Monoid m => (a -> m) -> Name a -> m Source # foldr :: (a -> b -> b) -> b -> Name a -> b Source # foldr' :: (a -> b -> b) -> b -> Name a -> b Source # foldl :: (b -> a -> b) -> b -> Name a -> b Source # foldl' :: (b -> a -> b) -> b -> Name a -> b Source # foldr1 :: (a -> a -> a) -> Name a -> a Source # foldl1 :: (a -> a -> a) -> Name a -> a Source # toList :: Name a -> [a] Source # null :: Name a -> Bool Source # length :: Name a -> Int Source # elem :: Eq a => a -> Name a -> Bool Source # maximum :: Ord a => Name a -> a Source # minimum :: Ord a => Name a -> a Source # |
|
| Traversable Name Source # | |
|
Defined in Language.Haskell.Exts.Syntax |
|
| Annotated Name Source # | |
| ExactP Name Source # | |
|
Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Name SrcSpanInfo -> EP () |
|
| Eq l => Eq ( Name l) Source # | |
| Data l => Data ( Name l) Source # | |
|
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) Source # gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c ( Name l) Source # toConstr :: Name l -> Constr Source # dataTypeOf :: Name l -> DataType Source # dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c ( Name l)) Source # dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c ( Name l)) Source # gmapT :: ( forall b. Data b => b -> b) -> Name l -> Name l Source # gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> Name l -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> Name l -> r Source # gmapQ :: ( forall d. Data d => d -> u) -> Name l -> [u] Source # gmapQi :: Int -> ( forall d. Data d => d -> u) -> Name l -> u Source # gmapM :: Monad m => ( forall d. Data d => d -> m d) -> Name l -> m ( Name l) Source # gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> Name l -> m ( Name l) Source # gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> Name l -> m ( Name l) Source # |
|
| Ord l => Ord ( Name l) Source # | |
|
Defined in Language.Haskell.Exts.Syntax |
|
| Show l => Show ( Name l) Source # | |
| Generic ( Name l) Source # | |
| Pretty ( Name l) Source # | |
|
Defined in Language.Haskell.Exts.Pretty |
|
| type Rep ( Name l) Source # | |
|
Defined in Language.Haskell.Exts.Syntax
type
Rep
(
Name
l) =
D1
('
MetaData
"Name" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-LTqMCpSQH9m4ymWElpQTPo" '
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
)))
|
|
Possibly qualified infix operators ( qop ), appearing in expressions.
Constructors
| QVarOp l ( QName l) |
variable operator ( qvarop ) |
| QConOp l ( QName l) |
constructor operator ( qconop ) |
Instances
| Functor QOp Source # | |
| Foldable QOp Source # | |
|
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => QOp m -> m Source # foldMap :: Monoid m => (a -> m) -> QOp a -> m Source # foldMap' :: Monoid m => (a -> m) -> QOp a -> m Source # foldr :: (a -> b -> b) -> b -> QOp a -> b Source # foldr' :: (a -> b -> b) -> b -> QOp a -> b Source # foldl :: (b -> a -> b) -> b -> QOp a -> b Source # foldl' :: (b -> a -> b) -> b -> QOp a -> b Source # foldr1 :: (a -> a -> a) -> QOp a -> a Source # foldl1 :: (a -> a -> a) -> QOp a -> a Source # toList :: QOp a -> [a] Source # null :: QOp a -> Bool Source # length :: QOp a -> Int Source # elem :: Eq a => a -> QOp a -> Bool Source # maximum :: Ord a => QOp a -> a Source # minimum :: Ord a => QOp a -> a Source # |
|
| Traversable QOp Source # | |
|
Defined in Language.Haskell.Exts.Syntax |
|
| Annotated QOp Source # | |
| ExactP QOp Source # | |
|
Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: QOp SrcSpanInfo -> EP () |
|
| Eq l => Eq ( QOp l) Source # | |
| Data l => Data ( QOp l) Source # | |
|
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) Source # gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c ( QOp l) Source # toConstr :: QOp l -> Constr Source # dataTypeOf :: QOp l -> DataType Source # dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c ( QOp l)) Source # dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c ( QOp l)) Source # gmapT :: ( forall b. Data b => b -> b) -> QOp l -> QOp l Source # gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> QOp l -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> QOp l -> r Source # gmapQ :: ( forall d. Data d => d -> u) -> QOp l -> [u] Source # gmapQi :: Int -> ( forall d. Data d => d -> u) -> QOp l -> u Source # gmapM :: Monad m => ( forall d. Data d => d -> m d) -> QOp l -> m ( QOp l) Source # gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> QOp l -> m ( QOp l) Source # gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> QOp l -> m ( QOp l) Source # |
|
| Ord l => Ord ( QOp l) Source # | |
|
Defined in Language.Haskell.Exts.Syntax |
|
| Show l => Show ( QOp l) Source # | |
| Generic ( QOp l) Source # | |
| Pretty ( QOp l) Source # | |
|
Defined in Language.Haskell.Exts.Pretty |
|
| type Rep ( QOp l) Source # | |
|
Defined in Language.Haskell.Exts.Syntax
type
Rep
(
QOp
l) =
D1
('
MetaData
"QOp" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-LTqMCpSQH9m4ymWElpQTPo" '
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))))
|
|
Operators appearing in
infix
declarations are never qualified.
Constructors
| VarOp l ( Name l) |
variable operator ( varop ) |
| ConOp l ( Name l) |
constructor operator ( conop ) |
Instances
| Functor Op Source # | |
| Foldable Op Source # | |
|
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Op m -> m Source # foldMap :: Monoid m => (a -> m) -> Op a -> m Source # foldMap' :: Monoid m => (a -> m) -> Op a -> m Source # foldr :: (a -> b -> b) -> b -> Op a -> b Source # foldr' :: (a -> b -> b) -> b -> Op a -> b Source # foldl :: (b -> a -> b) -> b -> Op a -> b Source # foldl' :: (b -> a -> b) -> b -> Op a -> b Source # foldr1 :: (a -> a -> a) -> Op a -> a Source # foldl1 :: (a -> a -> a) -> Op a -> a Source # toList :: Op a -> [a] Source # length :: Op a -> Int Source # elem :: Eq a => a -> Op a -> Bool Source # maximum :: Ord a => Op a -> a Source # minimum :: Ord a => Op a -> a Source # |
|
| Traversable Op Source # | |
| Annotated Op Source # | |
| ExactP Op Source # | |
|
Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Op SrcSpanInfo -> EP () |
|
| Eq l => Eq ( Op l) Source # | |
| Data l => Data ( Op l) Source # | |
|
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) Source # gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c ( Op l) Source # toConstr :: Op l -> Constr Source # dataTypeOf :: Op l -> DataType Source # dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c ( Op l)) Source # dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c ( Op l)) Source # gmapT :: ( forall b. Data b => b -> b) -> Op l -> Op l Source # gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> Op l -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> Op l -> r Source # gmapQ :: ( forall d. Data d => d -> u) -> Op l -> [u] Source # gmapQi :: Int -> ( forall d. Data d => d -> u) -> Op l -> u Source # gmapM :: Monad m => ( forall d. Data d => d -> m d) -> Op l -> m ( Op l) Source # gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> Op l -> m ( Op l) Source # gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> Op l -> m ( Op l) Source # |
|
| Ord l => Ord ( Op l) Source # | |
|
Defined in Language.Haskell.Exts.Syntax |
|
| Show l => Show ( Op l) Source # | |
| Generic ( Op l) Source # | |
| Pretty ( Op l) Source # | |
|
Defined in Language.Haskell.Exts.Pretty |
|
| type Rep ( Op l) Source # | |
|
Defined in Language.Haskell.Exts.Syntax
type
Rep
(
Op
l) =
D1
('
MetaData
"Op" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-LTqMCpSQH9m4ymWElpQTPo" '
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 Source #
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
|
| Cons l |
list data constructor
|
| UnboxedSingleCon l |
unboxed singleton tuple constructor
|
| ExprHole l |
An expression hole _ |
Instances
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
| Functor CName Source # | |
| Foldable CName Source # | |
|
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => CName m -> m Source # foldMap :: Monoid m => (a -> m) -> CName a -> m Source # foldMap' :: Monoid m => (a -> m) -> CName a -> m Source # foldr :: (a -> b -> b) -> b -> CName a -> b Source # foldr' :: (a -> b -> b) -> b -> CName a -> b Source # foldl :: (b -> a -> b) -> b -> CName a -> b Source # foldl' :: (b -> a -> b) -> b -> CName a -> b Source # foldr1 :: (a -> a -> a) -> CName a -> a Source # foldl1 :: (a -> a -> a) -> CName a -> a Source # toList :: CName a -> [a] Source # null :: CName a -> Bool Source # length :: CName a -> Int Source # elem :: Eq a => a -> CName a -> Bool Source # maximum :: Ord a => CName a -> a Source # minimum :: Ord a => CName a -> a Source # |
|
| Traversable CName Source # | |
|
Defined in Language.Haskell.Exts.Syntax |
|
| Annotated CName Source # | |
| ExactP CName Source # | |
|
Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: CName SrcSpanInfo -> EP () |
|
| Eq l => Eq ( CName l) Source # | |
| Data l => Data ( CName l) Source # | |
|
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) Source # gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c ( CName l) Source # toConstr :: CName l -> Constr Source # dataTypeOf :: CName l -> DataType Source # dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c ( CName l)) Source # dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c ( CName l)) Source # gmapT :: ( forall b. Data b => b -> b) -> CName l -> CName l Source # gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> CName l -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> CName l -> r Source # gmapQ :: ( forall d. Data d => d -> u) -> CName l -> [u] Source # gmapQi :: Int -> ( forall d. Data d => d -> u) -> CName l -> u Source # gmapM :: Monad m => ( forall d. Data d => d -> m d) -> CName l -> m ( CName l) Source # gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> CName l -> m ( CName l) Source # gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> CName l -> m ( CName l) Source # |
|
| Ord l => Ord ( CName l) Source # | |
|
Defined in Language.Haskell.Exts.Syntax |
|
| Show l => Show ( CName l) Source # | |
| Generic ( CName l) Source # | |
| Pretty ( CName l) Source # | |
|
Defined in Language.Haskell.Exts.Pretty |
|
| type Rep ( CName l) Source # | |
|
Defined in Language.Haskell.Exts.Syntax
type
Rep
(
CName
l) =
D1
('
MetaData
"CName" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-LTqMCpSQH9m4ymWElpQTPo" '
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))))
|
|
An implicit parameter name.
Constructors
| IPDup l String |
? ident , non-linear implicit parameter |
| IPLin l String |
% ident , linear implicit parameter |
Instances
| Functor IPName Source # | |
| Foldable IPName Source # | |
|
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => IPName m -> m Source # foldMap :: Monoid m => (a -> m) -> IPName a -> m Source # foldMap' :: Monoid m => (a -> m) -> IPName a -> m Source # foldr :: (a -> b -> b) -> b -> IPName a -> b Source # foldr' :: (a -> b -> b) -> b -> IPName a -> b Source # foldl :: (b -> a -> b) -> b -> IPName a -> b Source # foldl' :: (b -> a -> b) -> b -> IPName a -> b Source # foldr1 :: (a -> a -> a) -> IPName a -> a Source # foldl1 :: (a -> a -> a) -> IPName a -> a Source # toList :: IPName a -> [a] Source # null :: IPName a -> Bool Source # length :: IPName a -> Int Source # elem :: Eq a => a -> IPName a -> Bool Source # maximum :: Ord a => IPName a -> a Source # minimum :: Ord a => IPName a -> a Source # |
|
| Traversable IPName Source # | |
|
Defined in Language.Haskell.Exts.Syntax |
|
| Annotated IPName Source # | |
| ExactP IPName Source # | |
|
Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: IPName SrcSpanInfo -> EP () |
|
| Eq l => Eq ( IPName l) Source # | |
| Data l => Data ( IPName l) Source # | |
|
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) Source # gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c ( IPName l) Source # toConstr :: IPName l -> Constr Source # dataTypeOf :: IPName l -> DataType Source # dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c ( IPName l)) Source # dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c ( IPName l)) Source # gmapT :: ( forall b. Data b => b -> b) -> IPName l -> IPName l Source # gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> IPName l -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> IPName l -> r Source # gmapQ :: ( forall d. Data d => d -> u) -> IPName l -> [u] Source # gmapQi :: Int -> ( forall d. Data d => d -> u) -> IPName l -> u Source # gmapM :: Monad m => ( forall d. Data d => d -> m d) -> IPName l -> m ( IPName l) Source # gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> IPName l -> m ( IPName l) Source # gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> IPName l -> m ( IPName l) Source # |
|
| Ord l => Ord ( IPName l) Source # | |
|
Defined in Language.Haskell.Exts.Syntax |
|
| Show l => Show ( IPName l) Source # | |
| Generic ( IPName l) Source # | |
| Pretty ( IPName l) Source # | |
|
Defined in Language.Haskell.Exts.Pretty |
|
| type Rep ( IPName l) Source # | |
|
Defined in Language.Haskell.Exts.Syntax
type
Rep
(
IPName
l) =
D1
('
MetaData
"IPName" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-LTqMCpSQH9m4ymWElpQTPo" '
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
)))
|
|
The name of an xml element or attribute, possibly qualified with a namespace.
Instances
| Functor XName Source # | |
| Foldable XName Source # | |
|
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => XName m -> m Source # foldMap :: Monoid m => (a -> m) -> XName a -> m Source # foldMap' :: Monoid m => (a -> m) -> XName a -> m Source # foldr :: (a -> b -> b) -> b -> XName a -> b Source # foldr' :: (a -> b -> b) -> b -> XName a -> b Source # foldl :: (b -> a -> b) -> b -> XName a -> b Source # foldl' :: (b -> a -> b) -> b -> XName a -> b Source # foldr1 :: (a -> a -> a) -> XName a -> a Source # foldl1 :: (a -> a -> a) -> XName a -> a Source # toList :: XName a -> [a] Source # null :: XName a -> Bool Source # length :: XName a -> Int Source # elem :: Eq a => a -> XName a -> Bool Source # maximum :: Ord a => XName a -> a Source # minimum :: Ord a => XName a -> a Source # |
|
| Traversable XName Source # | |
|
Defined in Language.Haskell.Exts.Syntax |
|
| Annotated XName Source # | |
| ExactP XName Source # | |
|
Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: XName SrcSpanInfo -> EP () |
|
| Eq l => Eq ( XName l) Source # | |
| Data l => Data ( XName l) Source # | |
|
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) Source # gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c ( XName l) Source # toConstr :: XName l -> Constr Source # dataTypeOf :: XName l -> DataType Source # dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c ( XName l)) Source # dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c ( XName l)) Source # gmapT :: ( forall b. Data b => b -> b) -> XName l -> XName l Source # gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> XName l -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> XName l -> r Source # gmapQ :: ( forall d. Data d => d -> u) -> XName l -> [u] Source # gmapQi :: Int -> ( forall d. Data d => d -> u) -> XName l -> u Source # gmapM :: Monad m => ( forall d. Data d => d -> m d) -> XName l -> m ( XName l) Source # gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> XName l -> m ( XName l) Source # gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> XName l -> m ( XName l) Source # |
|
| Ord l => Ord ( XName l) Source # | |
|
Defined in Language.Haskell.Exts.Syntax |
|
| Show l => Show ( XName l) Source # | |
| Generic ( XName l) Source # | |
| Pretty ( XName l) Source # | |
|
Defined in Language.Haskell.Exts.Pretty |
|
| type Rep ( XName l) Source # | |
|
Defined in Language.Haskell.Exts.Syntax
type
Rep
(
XName
l) =
D1
('
MetaData
"XName" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-LTqMCpSQH9m4ymWElpQTPo" '
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
))))
|
|
Constructors
| Nominal l | |
| Representational l | |
| Phantom l | |
| RoleWildcard l |
Instances
| Functor Role Source # | |
| Foldable Role Source # | |
|
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Role m -> m Source # foldMap :: Monoid m => (a -> m) -> Role a -> m Source # foldMap' :: Monoid m => (a -> m) -> Role a -> m Source # foldr :: (a -> b -> b) -> b -> Role a -> b Source # foldr' :: (a -> b -> b) -> b -> Role a -> b Source # foldl :: (b -> a -> b) -> b -> Role a -> b Source # foldl' :: (b -> a -> b) -> b -> Role a -> b Source # foldr1 :: (a -> a -> a) -> Role a -> a Source # foldl1 :: (a -> a -> a) -> Role a -> a Source # toList :: Role a -> [a] Source # null :: Role a -> Bool Source # length :: Role a -> Int Source # elem :: Eq a => a -> Role a -> Bool Source # maximum :: Ord a => Role a -> a Source # minimum :: Ord a => Role a -> a Source # |
|
| Traversable Role Source # | |
|
Defined in Language.Haskell.Exts.Syntax |
|
| Annotated Role Source # | |
| ExactP Role Source # | |
|
Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Role SrcSpanInfo -> EP () |
|
| Eq l => Eq ( Role l) Source # | |
| Data l => Data ( Role l) Source # | |
|
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) Source # gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c ( Role l) Source # toConstr :: Role l -> Constr Source # dataTypeOf :: Role l -> DataType Source # dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c ( Role l)) Source # dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c ( Role l)) Source # gmapT :: ( forall b. Data b => b -> b) -> Role l -> Role l Source # gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> Role l -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> Role l -> r Source # gmapQ :: ( forall d. Data d => d -> u) -> Role l -> [u] Source # gmapQi :: Int -> ( forall d. Data d => d -> u) -> Role l -> u Source # gmapM :: Monad m => ( forall d. Data d => d -> m d) -> Role l -> m ( Role l) Source # gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> Role l -> m ( Role l) Source # gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> Role l -> m ( Role l) Source # |
|
| Ord l => Ord ( Role l) Source # | |
|
Defined in Language.Haskell.Exts.Syntax |
|
| Show l => Show ( Role l) Source # | |
| Generic ( Role l) Source # | |
| Pretty ( Role l) Source # | |
|
Defined in Language.Haskell.Exts.Pretty |
|
| type Rep ( Role l) Source # | |
|
Defined in Language.Haskell.Exts.Syntax
type
Rep
(
Role
l) =
D1
('
MetaData
"Role" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-LTqMCpSQH9m4ymWElpQTPo" '
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 Source #
Constructors
| PromotedName l ( QName l) | |
| UnpromotedName l ( QName l) |
Instances
Template Haskell
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:
|
| TypeBracket l ( Type l) |
type bracket:
|
| DeclBracket l [ Decl l] |
declaration bracket:
|
Instances
A template haskell splice expression
Constructors
| IdSplice l String |
variable splice:
|
| TIdSplice l String |
typed variable splice:
|
| ParenSplice l ( Exp l) |
parenthesised expression splice:
|
| TParenSplice l ( Exp l) |
parenthesised typed expression splice:
|
Instances
FFI
The safety of a foreign function call.
Constructors
| PlayRisky l |
unsafe |
| PlaySafe l Bool | |
| PlayInterruptible l |
interruptible |
Instances
| Functor Safety Source # | |
| Foldable Safety Source # | |
|
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Safety m -> m Source # foldMap :: Monoid m => (a -> m) -> Safety a -> m Source # foldMap' :: Monoid m => (a -> m) -> Safety a -> m Source # foldr :: (a -> b -> b) -> b -> Safety a -> b Source # foldr' :: (a -> b -> b) -> b -> Safety a -> b Source # foldl :: (b -> a -> b) -> b -> Safety a -> b Source # foldl' :: (b -> a -> b) -> b -> Safety a -> b Source # foldr1 :: (a -> a -> a) -> Safety a -> a Source # foldl1 :: (a -> a -> a) -> Safety a -> a Source # toList :: Safety a -> [a] Source # null :: Safety a -> Bool Source # length :: Safety a -> Int Source # elem :: Eq a => a -> Safety a -> Bool Source # maximum :: Ord a => Safety a -> a Source # minimum :: Ord a => Safety a -> a Source # |
|
| Traversable Safety Source # | |
|
Defined in Language.Haskell.Exts.Syntax |
|
| Annotated Safety Source # | |
| ExactP Safety Source # | |
|
Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Safety SrcSpanInfo -> EP () |
|
| Eq l => Eq ( Safety l) Source # | |
| Data l => Data ( Safety l) Source # | |
|
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) Source # gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c ( Safety l) Source # toConstr :: Safety l -> Constr Source # dataTypeOf :: Safety l -> DataType Source # dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c ( Safety l)) Source # dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c ( Safety l)) Source # gmapT :: ( forall b. Data b => b -> b) -> Safety l -> Safety l Source # gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> Safety l -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> Safety l -> r Source # gmapQ :: ( forall d. Data d => d -> u) -> Safety l -> [u] Source # gmapQi :: Int -> ( forall d. Data d => d -> u) -> Safety l -> u Source # gmapM :: Monad m => ( forall d. Data d => d -> m d) -> Safety l -> m ( Safety l) Source # gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> Safety l -> m ( Safety l) Source # gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> Safety l -> m ( Safety l) Source # |
|
| Ord l => Ord ( Safety l) Source # | |
|
Defined in Language.Haskell.Exts.Syntax |
|
| Show l => Show ( Safety l) Source # | |
| Generic ( Safety l) Source # | |
| Pretty ( Safety l) Source # | |
|
Defined in Language.Haskell.Exts.Pretty |
|
| type Rep ( Safety l) Source # | |
|
Defined in Language.Haskell.Exts.Syntax
type
Rep
(
Safety
l) =
D1
('
MetaData
"Safety" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-LTqMCpSQH9m4ymWElpQTPo" '
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))))
|
|
The calling convention of a foreign function call.
Instances
Pragmas
data ModulePragma l Source #
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
Recognised tools for OPTIONS pragmas.
Instances
| Eq Tool Source # | |
| Data Tool Source # | |
|
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 Source # gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c Tool Source # toConstr :: Tool -> Constr Source # dataTypeOf :: Tool -> DataType Source # dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c Tool ) Source # dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c Tool ) Source # gmapT :: ( forall b. Data b => b -> b) -> Tool -> Tool Source # gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> Tool -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> Tool -> r Source # gmapQ :: ( forall d. Data d => d -> u) -> Tool -> [u] Source # gmapQi :: Int -> ( forall d. Data d => d -> u) -> Tool -> u Source # gmapM :: Monad m => ( forall d. Data d => d -> m d) -> Tool -> m Tool Source # gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> Tool -> m Tool Source # gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> Tool -> m Tool Source # |
|
| Ord Tool Source # | |
|
Defined in Language.Haskell.Exts.Syntax |
|
| Show Tool Source # | |
| Generic Tool Source # | |
| Pretty Tool Source # | |
|
Defined in Language.Haskell.Exts.Pretty |
|
| type Rep Tool Source # | |
|
Defined in Language.Haskell.Exts.Syntax
type
Rep
Tool
=
D1
('
MetaData
"Tool" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-LTqMCpSQH9m4ymWElpQTPo" '
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
)))))
|
|
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
The body of a RULES pragma.
Instances
| Functor Rule Source # | |
| Foldable Rule Source # | |
|
Defined in Language.Haskell.Exts.Syntax Methods fold :: Monoid m => Rule m -> m Source # foldMap :: Monoid m => (a -> m) -> Rule a -> m Source # foldMap' :: Monoid m => (a -> m) -> Rule a -> m Source # foldr :: (a -> b -> b) -> b -> Rule a -> b Source # foldr' :: (a -> b -> b) -> b -> Rule a -> b Source # foldl :: (b -> a -> b) -> b -> Rule a -> b Source # foldl' :: (b -> a -> b) -> b -> Rule a -> b Source # foldr1 :: (a -> a -> a) -> Rule a -> a Source # foldl1 :: (a -> a -> a) -> Rule a -> a Source # toList :: Rule a -> [a] Source # null :: Rule a -> Bool Source # length :: Rule a -> Int Source # elem :: Eq a => a -> Rule a -> Bool Source # maximum :: Ord a => Rule a -> a Source # minimum :: Ord a => Rule a -> a Source # |
|
| Traversable Rule Source # | |
|
Defined in Language.Haskell.Exts.Syntax |
|
| Annotated Rule Source # | |
| ExactP Rule Source # | |
|
Defined in Language.Haskell.Exts.ExactPrint Methods exactP :: Rule SrcSpanInfo -> EP () |
|
| Eq l => Eq ( Rule l) Source # | |
| Data l => Data ( Rule l) Source # | |
|
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) Source # gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c ( Rule l) Source # toConstr :: Rule l -> Constr Source # dataTypeOf :: Rule l -> DataType Source # dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c ( Rule l)) Source # dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c ( Rule l)) Source # gmapT :: ( forall b. Data b => b -> b) -> Rule l -> Rule l Source # gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> Rule l -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> Rule l -> r Source # gmapQ :: ( forall d. Data d => d -> u) -> Rule l -> [u] Source # gmapQi :: Int -> ( forall d. Data d => d -> u) -> Rule l -> u Source # gmapM :: Monad m => ( forall d. Data d => d -> m d) -> Rule l -> m ( Rule l) Source # gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> Rule l -> m ( Rule l) Source # gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> Rule l -> m ( Rule l) Source # |
|
| Ord l => Ord ( Rule l) Source # | |
|
Defined in Language.Haskell.Exts.Syntax |
|
| Show l => Show ( Rule l) Source # | |
| Generic ( Rule l) Source # | |
| Pretty ( Rule l) Source # | |
|
Defined in Language.Haskell.Exts.Pretty |
|
| type Rep ( Rule l) Source # | |
|
Defined in Language.Haskell.Exts.Syntax
type
Rep
(
Rule
l) =
D1
('
MetaData
"Rule" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-LTqMCpSQH9m4ymWElpQTPo" '
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))))))
|
|
Variables used in a RULES pragma, optionally annotated with types
Constructors
| RuleVar l ( Name l) | |
| TypedRuleVar l ( Name l) ( Type l) |
Instances
data Activation l Source #
Activation clause of a RULES pragma.
Constructors
| ActiveFrom l Int | |
| ActiveUntil l Int |
Instances
data Annotation l Source #
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
data BooleanFormula l Source #
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
Builtin names
Modules
prelude_mod :: l -> ModuleName l Source #
main_mod :: l -> ModuleName l Source #
Main function of a program
Constructors
unit_con_name :: l -> QName l Source #
list_con_name :: l -> QName l Source #
list_cons_name :: l -> QName l Source #
unboxed_singleton_con_name :: l -> QName l Source #
unboxed_singleton_con :: l -> Exp l Source #
Special identifiers
qualified_name :: l -> Name l Source #
hiding_name :: l -> Name l Source #
minus_name :: l -> Name l Source #
export_name :: l -> Name l Source #
unsafe_name :: l -> Name l Source #
interruptible_name :: l -> Name l Source #
threadsafe_name :: l -> Name l Source #
stdcall_name :: l -> Name l Source #
ccall_name :: l -> Name l Source #
cplusplus_name :: l -> Name l Source #
dotnet_name :: l -> Name l Source #
javascript_name :: l -> Name l Source #
forall_name :: l -> Name l Source #
family_name :: l -> Name l Source #
stock_name :: l -> Name l Source #
anyclass_name :: l -> Name l Source #
Type constructors
unit_tycon_name :: l -> QName l Source #
fun_tycon_name :: l -> QName l Source #
list_tycon_name :: l -> QName l Source #
unboxed_singleton_tycon_name :: l -> QName l Source #
unit_tycon :: l -> Type l Source #
list_tycon :: l -> Type l Source #
unboxed_singleton_tycon :: l -> Type l Source #
Source coordinates
Annotated trees
class Functor ast => Annotated ast where Source #
AST nodes are annotated, and this class allows manipulation of the annotations.
Methods
Retrieve the annotation of an AST node.
amap :: (l -> l) -> ast l -> ast l Source #
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
.