haskell-src-exts-1.20.2: Manipulating Haskell source: abstract syntax, lexer, parser, and pretty-printer

Copyright(c) Niklas Broberg 2004-2009
(c) The GHC Team 1997-2000
LicenseBSD-style (see the file LICENSE.txt)
MaintainerNiklas Broberg, d00nibro@chalmers.se
Stabilitystable
Portabilityportable
Safe HaskellSafe
LanguageHaskell98

Language.Haskell.Exts.Syntax

Contents

Description

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

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

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

Synopsis

Modules

data Module l Source #

A complete Haskell source module.

Constructors

Module l (Maybe (ModuleHead l)) [ModulePragma l] [ImportDecl l] [Decl l]

an ordinary Haskell module

XmlPage l (ModuleName l) [ModulePragma l] (XName l) [XAttr l] (Maybe (Exp l)) [Exp l]

a module consisting of a single XML document. The ModuleName never appears in the source but is needed for semantic purposes, it will be the same as the file name.

XmlHybrid l (Maybe (ModuleHead l)) [ModulePragma l] [ImportDecl l] [Decl l] (XName l) [XAttr l] (Maybe (Exp l)) [Exp l]

a hybrid module combining an XML document with an ordinary module

Instances
Functor Module Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Module a -> Module b #

(<$) :: a -> Module b -> Module a #

Foldable Module Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Module m -> m #

foldMap :: Monoid m => (a -> m) -> Module a -> m #

foldr :: (a -> b -> b) -> b -> Module a -> b #

foldr' :: (a -> b -> b) -> b -> Module a -> b #

foldl :: (b -> a -> b) -> b -> Module a -> b #

foldl' :: (b -> a -> b) -> b -> Module a -> b #

foldr1 :: (a -> a -> a) -> Module a -> a #

foldl1 :: (a -> a -> a) -> Module a -> a #

toList :: Module a -> [a] #

null :: Module a -> Bool #

length :: Module a -> Int #

elem :: Eq a => a -> Module a -> Bool #

maximum :: Ord a => Module a -> a #

minimum :: Ord a => Module a -> a #

sum :: Num a => Module a -> a #

product :: Num a => Module a -> a #

Traversable Module Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> Module a -> f (Module b) #

sequenceA :: Applicative f => Module (f a) -> f (Module a) #

mapM :: Monad m => (a -> m b) -> Module a -> m (Module b) #

sequence :: Monad m => Module (m a) -> m (Module a) #

Annotated Module Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Module l -> l Source #

amap :: (l -> l) -> Module l -> Module l Source #

AppFixity Module Source # 
Instance details

Defined in Language.Haskell.Exts.Fixity

ExactP Module Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Module SrcSpanInfo -> EP ()

Eq l => Eq (Module l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: Module l -> Module l -> Bool #

(/=) :: Module l -> Module l -> Bool #

Data l => Data (Module l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Module l -> c (Module l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Module l) #

toConstr :: Module l -> Constr #

dataTypeOf :: Module l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Module l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Module l)) #

gmapT :: (forall b. Data b => b -> b) -> Module l -> Module l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Module l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Module l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Module l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Module l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Module l -> m (Module l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Module l -> m (Module l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Module l -> m (Module l) #

Ord l => Ord (Module l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: Module l -> Module l -> Ordering #

(<) :: Module l -> Module l -> Bool #

(<=) :: Module l -> Module l -> Bool #

(>) :: Module l -> Module l -> Bool #

(>=) :: Module l -> Module l -> Bool #

max :: Module l -> Module l -> Module l #

min :: Module l -> Module l -> Module l #

Show l => Show (Module l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> Module l -> ShowS #

show :: Module l -> String #

showList :: [Module l] -> ShowS #

Generic (Module l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Module l) :: * -> * #

Methods

from :: Module l -> Rep (Module l) x #

to :: Rep (Module l) x -> Module l #

Pretty (Module pos) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Module pos -> Doc

prettyPrec :: Int -> Module pos -> Doc

Parseable (Module SrcSpanInfo) Source # 
Instance details

Defined in Language.Haskell.Exts.Parser

type Rep (Module l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (Module l) = D1 (MetaData "Module" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.2-2ICFwnD62Z41OwyyQu0OCQ" False) (C1 (MetaCons "Module" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (ModuleHead l)))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [ModulePragma l]) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [ImportDecl l]) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Decl l])))) :+: (C1 (MetaCons "XmlPage" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ModuleName l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [ModulePragma l]))) :*: ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (XName l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [XAttr l])) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Exp l))) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Exp l])))) :+: C1 (MetaCons "XmlHybrid" PrefixI False) (((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (ModuleHead l)))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [ModulePragma l]) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [ImportDecl l]))) :*: ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Decl l]) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (XName l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [XAttr l]) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Exp l))) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Exp l])))))))

data ModuleHead l Source #

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

Constructors

ModuleHead l (ModuleName l) (Maybe (WarningText l)) (Maybe (ExportSpecList l)) 
Instances
Functor ModuleHead Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> ModuleHead a -> ModuleHead b #

(<$) :: a -> ModuleHead b -> ModuleHead a #

Foldable ModuleHead Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => ModuleHead m -> m #

foldMap :: Monoid m => (a -> m) -> ModuleHead a -> m #

foldr :: (a -> b -> b) -> b -> ModuleHead a -> b #

foldr' :: (a -> b -> b) -> b -> ModuleHead a -> b #

foldl :: (b -> a -> b) -> b -> ModuleHead a -> b #

foldl' :: (b -> a -> b) -> b -> ModuleHead a -> b #

foldr1 :: (a -> a -> a) -> ModuleHead a -> a #

foldl1 :: (a -> a -> a) -> ModuleHead a -> a #

toList :: ModuleHead a -> [a] #

null :: ModuleHead a -> Bool #

length :: ModuleHead a -> Int #

elem :: Eq a => a -> ModuleHead a -> Bool #

maximum :: Ord a => ModuleHead a -> a #

minimum :: Ord a => ModuleHead a -> a #

sum :: Num a => ModuleHead a -> a #

product :: Num a => ModuleHead a -> a #

Traversable ModuleHead Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> ModuleHead a -> f (ModuleHead b) #

sequenceA :: Applicative f => ModuleHead (f a) -> f (ModuleHead a) #

mapM :: Monad m => (a -> m b) -> ModuleHead a -> m (ModuleHead b) #

sequence :: Monad m => ModuleHead (m a) -> m (ModuleHead a) #

Annotated ModuleHead Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: ModuleHead l -> l Source #

amap :: (l -> l) -> ModuleHead l -> ModuleHead l Source #

ExactP ModuleHead Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: ModuleHead SrcSpanInfo -> EP ()

Eq l => Eq (ModuleHead l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: ModuleHead l -> ModuleHead l -> Bool #

(/=) :: ModuleHead l -> ModuleHead l -> Bool #

Data l => Data (ModuleHead l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ModuleHead l -> c (ModuleHead l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ModuleHead l) #

toConstr :: ModuleHead l -> Constr #

dataTypeOf :: ModuleHead l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ModuleHead l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ModuleHead l)) #

gmapT :: (forall b. Data b => b -> b) -> ModuleHead l -> ModuleHead l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ModuleHead l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ModuleHead l -> r #

gmapQ :: (forall d. Data d => d -> u) -> ModuleHead l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ModuleHead l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ModuleHead l -> m (ModuleHead l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ModuleHead l -> m (ModuleHead l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ModuleHead l -> m (ModuleHead l) #

Ord l => Ord (ModuleHead l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Show l => Show (ModuleHead l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Generic (ModuleHead l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (ModuleHead l) :: * -> * #

Methods

from :: ModuleHead l -> Rep (ModuleHead l) x #

to :: Rep (ModuleHead l) x -> ModuleHead l #

Pretty (ModuleHead l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: ModuleHead l -> Doc

prettyPrec :: Int -> ModuleHead l -> Doc

type Rep (ModuleHead l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data WarningText l Source #

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

Constructors

DeprText l String 
WarnText l String 
Instances
Functor WarningText Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> WarningText a -> WarningText b #

(<$) :: a -> WarningText b -> WarningText a #

Foldable WarningText Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => WarningText m -> m #

foldMap :: Monoid m => (a -> m) -> WarningText a -> m #

foldr :: (a -> b -> b) -> b -> WarningText a -> b #

foldr' :: (a -> b -> b) -> b -> WarningText a -> b #

foldl :: (b -> a -> b) -> b -> WarningText a -> b #

foldl' :: (b -> a -> b) -> b -> WarningText a -> b #

foldr1 :: (a -> a -> a) -> WarningText a -> a #

foldl1 :: (a -> a -> a) -> WarningText a -> a #

toList :: WarningText a -> [a] #

null :: WarningText a -> Bool #

length :: WarningText a -> Int #

elem :: Eq a => a -> WarningText a -> Bool #

maximum :: Ord a => WarningText a -> a #

minimum :: Ord a => WarningText a -> a #

sum :: Num a => WarningText a -> a #

product :: Num a => WarningText a -> a #

Traversable WarningText Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> WarningText a -> f (WarningText b) #

sequenceA :: Applicative f => WarningText (f a) -> f (WarningText a) #

mapM :: Monad m => (a -> m b) -> WarningText a -> m (WarningText b) #

sequence :: Monad m => WarningText (m a) -> m (WarningText a) #

Annotated WarningText Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: WarningText l -> l Source #

amap :: (l -> l) -> WarningText l -> WarningText l Source #

ExactP WarningText Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: WarningText SrcSpanInfo -> EP ()

Eq l => Eq (WarningText l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Data l => Data (WarningText l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WarningText l -> c (WarningText l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (WarningText l) #

toConstr :: WarningText l -> Constr #

dataTypeOf :: WarningText l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (WarningText l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (WarningText l)) #

gmapT :: (forall b. Data b => b -> b) -> WarningText l -> WarningText l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WarningText l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WarningText l -> r #

gmapQ :: (forall d. Data d => d -> u) -> WarningText l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> WarningText l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> WarningText l -> m (WarningText l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WarningText l -> m (WarningText l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WarningText l -> m (WarningText l) #

Ord l => Ord (WarningText l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Show l => Show (WarningText l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Generic (WarningText l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (WarningText l) :: * -> * #

Methods

from :: WarningText l -> Rep (WarningText l) x #

to :: Rep (WarningText l) x -> WarningText l #

type Rep (WarningText l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data ExportSpecList l Source #

An explicit export specification.

Constructors

ExportSpecList l [ExportSpec l] 
Instances
Functor ExportSpecList Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> ExportSpecList a -> ExportSpecList b #

(<$) :: a -> ExportSpecList b -> ExportSpecList a #

Foldable ExportSpecList Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => ExportSpecList m -> m #

foldMap :: Monoid m => (a -> m) -> ExportSpecList a -> m #

foldr :: (a -> b -> b) -> b -> ExportSpecList a -> b #

foldr' :: (a -> b -> b) -> b -> ExportSpecList a -> b #

foldl :: (b -> a -> b) -> b -> ExportSpecList a -> b #

foldl' :: (b -> a -> b) -> b -> ExportSpecList a -> b #

foldr1 :: (a -> a -> a) -> ExportSpecList a -> a #

foldl1 :: (a -> a -> a) -> ExportSpecList a -> a #

toList :: ExportSpecList a -> [a] #

null :: ExportSpecList a -> Bool #

length :: ExportSpecList a -> Int #

elem :: Eq a => a -> ExportSpecList a -> Bool #

maximum :: Ord a => ExportSpecList a -> a #

minimum :: Ord a => ExportSpecList a -> a #

sum :: Num a => ExportSpecList a -> a #

product :: Num a => ExportSpecList a -> a #

Traversable ExportSpecList Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> ExportSpecList a -> f (ExportSpecList b) #

sequenceA :: Applicative f => ExportSpecList (f a) -> f (ExportSpecList a) #

mapM :: Monad m => (a -> m b) -> ExportSpecList a -> m (ExportSpecList b) #

sequence :: Monad m => ExportSpecList (m a) -> m (ExportSpecList a) #

Annotated ExportSpecList Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: ExportSpecList l -> l Source #

amap :: (l -> l) -> ExportSpecList l -> ExportSpecList l Source #

ExactP ExportSpecList Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: ExportSpecList SrcSpanInfo -> EP ()

Eq l => Eq (ExportSpecList l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Data l => Data (ExportSpecList l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ExportSpecList l -> c (ExportSpecList l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ExportSpecList l) #

toConstr :: ExportSpecList l -> Constr #

dataTypeOf :: ExportSpecList l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ExportSpecList l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ExportSpecList l)) #

gmapT :: (forall b. Data b => b -> b) -> ExportSpecList l -> ExportSpecList l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ExportSpecList l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ExportSpecList l -> r #

gmapQ :: (forall d. Data d => d -> u) -> ExportSpecList l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ExportSpecList l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ExportSpecList l -> m (ExportSpecList l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ExportSpecList l -> m (ExportSpecList l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ExportSpecList l -> m (ExportSpecList l) #

Ord l => Ord (ExportSpecList l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Show l => Show (ExportSpecList l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Generic (ExportSpecList l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (ExportSpecList l) :: * -> * #

Pretty (ExportSpecList l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: ExportSpecList l -> Doc

prettyPrec :: Int -> ExportSpecList l -> Doc

type Rep (ExportSpecList l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (ExportSpecList l) = D1 (MetaData "ExportSpecList" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.2-2ICFwnD62Z41OwyyQu0OCQ" False) (C1 (MetaCons "ExportSpecList" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [ExportSpec l])))

data ExportSpec l Source #

An item in a module's export specification.

Constructors

EVar l (QName l)

variable.

EAbs l (Namespace l) (QName l)

T: a class or datatype exported abstractly, or a type synonym.

EThingWith l (EWildcard l) (QName l) [CName l]

T(C_1,...,C_n): a class exported with some of its methods, or a datatype exported with some of its constructors.

EModuleContents l (ModuleName l)

module M: re-export a module.

Instances
Functor ExportSpec Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> ExportSpec a -> ExportSpec b #

(<$) :: a -> ExportSpec b -> ExportSpec a #

Foldable ExportSpec Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => ExportSpec m -> m #

foldMap :: Monoid m => (a -> m) -> ExportSpec a -> m #

foldr :: (a -> b -> b) -> b -> ExportSpec a -> b #

foldr' :: (a -> b -> b) -> b -> ExportSpec a -> b #

foldl :: (b -> a -> b) -> b -> ExportSpec a -> b #

foldl' :: (b -> a -> b) -> b -> ExportSpec a -> b #

foldr1 :: (a -> a -> a) -> ExportSpec a -> a #

foldl1 :: (a -> a -> a) -> ExportSpec a -> a #

toList :: ExportSpec a -> [a] #

null :: ExportSpec a -> Bool #

length :: ExportSpec a -> Int #

elem :: Eq a => a -> ExportSpec a -> Bool #

maximum :: Ord a => ExportSpec a -> a #

minimum :: Ord a => ExportSpec a -> a #

sum :: Num a => ExportSpec a -> a #

product :: Num a => ExportSpec a -> a #

Traversable ExportSpec Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> ExportSpec a -> f (ExportSpec b) #

sequenceA :: Applicative f => ExportSpec (f a) -> f (ExportSpec a) #

mapM :: Monad m => (a -> m b) -> ExportSpec a -> m (ExportSpec b) #

sequence :: Monad m => ExportSpec (m a) -> m (ExportSpec a) #

Annotated ExportSpec Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: ExportSpec l -> l Source #

amap :: (l -> l) -> ExportSpec l -> ExportSpec l Source #

ExactP ExportSpec Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: ExportSpec SrcSpanInfo -> EP ()

Eq l => Eq (ExportSpec l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: ExportSpec l -> ExportSpec l -> Bool #

(/=) :: ExportSpec l -> ExportSpec l -> Bool #

Data l => Data (ExportSpec l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ExportSpec l -> c (ExportSpec l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ExportSpec l) #

toConstr :: ExportSpec l -> Constr #

dataTypeOf :: ExportSpec l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ExportSpec l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ExportSpec l)) #

gmapT :: (forall b. Data b => b -> b) -> ExportSpec l -> ExportSpec l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ExportSpec l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ExportSpec l -> r #

gmapQ :: (forall d. Data d => d -> u) -> ExportSpec l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ExportSpec l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ExportSpec l -> m (ExportSpec l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ExportSpec l -> m (ExportSpec l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ExportSpec l -> m (ExportSpec l) #

Ord l => Ord (ExportSpec l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Show l => Show (ExportSpec l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Generic (ExportSpec l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (ExportSpec l) :: * -> * #

Methods

from :: ExportSpec l -> Rep (ExportSpec l) x #

to :: Rep (ExportSpec l) x -> ExportSpec l #

Pretty (ExportSpec l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: ExportSpec l -> Doc

prettyPrec :: Int -> ExportSpec l -> Doc

type Rep (ExportSpec l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (ExportSpec l) = D1 (MetaData "ExportSpec" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.2-2ICFwnD62Z41OwyyQu0OCQ" False) ((C1 (MetaCons "EVar" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l))) :+: C1 (MetaCons "EAbs" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Namespace l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l))))) :+: (C1 (MetaCons "EThingWith" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (EWildcard l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [CName l]))) :+: C1 (MetaCons "EModuleContents" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ModuleName l)))))

data EWildcard l Source #

Indicates the position of the wildcard in an export list

Constructors

NoWildcard l 
EWildcard l Int 
Instances
Functor EWildcard Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> EWildcard a -> EWildcard b #

(<$) :: a -> EWildcard b -> EWildcard a #

Foldable EWildcard Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => EWildcard m -> m #

foldMap :: Monoid m => (a -> m) -> EWildcard a -> m #

foldr :: (a -> b -> b) -> b -> EWildcard a -> b #

foldr' :: (a -> b -> b) -> b -> EWildcard a -> b #

foldl :: (b -> a -> b) -> b -> EWildcard a -> b #

foldl' :: (b -> a -> b) -> b -> EWildcard a -> b #

foldr1 :: (a -> a -> a) -> EWildcard a -> a #

foldl1 :: (a -> a -> a) -> EWildcard a -> a #

toList :: EWildcard a -> [a] #

null :: EWildcard a -> Bool #

length :: EWildcard a -> Int #

elem :: Eq a => a -> EWildcard a -> Bool #

maximum :: Ord a => EWildcard a -> a #

minimum :: Ord a => EWildcard a -> a #

sum :: Num a => EWildcard a -> a #

product :: Num a => EWildcard a -> a #

Traversable EWildcard Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> EWildcard a -> f (EWildcard b) #

sequenceA :: Applicative f => EWildcard (f a) -> f (EWildcard a) #

mapM :: Monad m => (a -> m b) -> EWildcard a -> m (EWildcard b) #

sequence :: Monad m => EWildcard (m a) -> m (EWildcard a) #

Annotated EWildcard Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: EWildcard l -> l Source #

amap :: (l -> l) -> EWildcard l -> EWildcard l Source #

Eq l => Eq (EWildcard l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: EWildcard l -> EWildcard l -> Bool #

(/=) :: EWildcard l -> EWildcard l -> Bool #

Data l => Data (EWildcard l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> EWildcard l -> c (EWildcard l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (EWildcard l) #

toConstr :: EWildcard l -> Constr #

dataTypeOf :: EWildcard l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (EWildcard l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (EWildcard l)) #

gmapT :: (forall b. Data b => b -> b) -> EWildcard l -> EWildcard l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> EWildcard l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> EWildcard l -> r #

gmapQ :: (forall d. Data d => d -> u) -> EWildcard l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> EWildcard l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> EWildcard l -> m (EWildcard l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> EWildcard l -> m (EWildcard l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> EWildcard l -> m (EWildcard l) #

Ord l => Ord (EWildcard l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Show l => Show (EWildcard l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Generic (EWildcard l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (EWildcard l) :: * -> * #

Methods

from :: EWildcard l -> Rep (EWildcard l) x #

to :: Rep (EWildcard l) x -> EWildcard l #

type Rep (EWildcard l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data ImportDecl l Source #

An import declaration.

Constructors

ImportDecl 

Fields

Instances
Functor ImportDecl Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> ImportDecl a -> ImportDecl b #

(<$) :: a -> ImportDecl b -> ImportDecl a #

Foldable ImportDecl Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => ImportDecl m -> m #

foldMap :: Monoid m => (a -> m) -> ImportDecl a -> m #

foldr :: (a -> b -> b) -> b -> ImportDecl a -> b #

foldr' :: (a -> b -> b) -> b -> ImportDecl a -> b #

foldl :: (b -> a -> b) -> b -> ImportDecl a -> b #

foldl' :: (b -> a -> b) -> b -> ImportDecl a -> b #

foldr1 :: (a -> a -> a) -> ImportDecl a -> a #

foldl1 :: (a -> a -> a) -> ImportDecl a -> a #

toList :: ImportDecl a -> [a] #

null :: ImportDecl a -> Bool #

length :: ImportDecl a -> Int #

elem :: Eq a => a -> ImportDecl a -> Bool #

maximum :: Ord a => ImportDecl a -> a #

minimum :: Ord a => ImportDecl a -> a #

sum :: Num a => ImportDecl a -> a #

product :: Num a => ImportDecl a -> a #

Traversable ImportDecl Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> ImportDecl a -> f (ImportDecl b) #

sequenceA :: Applicative f => ImportDecl (f a) -> f (ImportDecl a) #

mapM :: Monad m => (a -> m b) -> ImportDecl a -> m (ImportDecl b) #

sequence :: Monad m => ImportDecl (m a) -> m (ImportDecl a) #

Annotated ImportDecl Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: ImportDecl l -> l Source #

amap :: (l -> l) -> ImportDecl l -> ImportDecl l Source #

ExactP ImportDecl Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: ImportDecl SrcSpanInfo -> EP ()

Eq l => Eq (ImportDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: ImportDecl l -> ImportDecl l -> Bool #

(/=) :: ImportDecl l -> ImportDecl l -> Bool #

Data l => Data (ImportDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ImportDecl l -> c (ImportDecl l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ImportDecl l) #

toConstr :: ImportDecl l -> Constr #

dataTypeOf :: ImportDecl l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ImportDecl l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ImportDecl l)) #

gmapT :: (forall b. Data b => b -> b) -> ImportDecl l -> ImportDecl l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ImportDecl l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ImportDecl l -> r #

gmapQ :: (forall d. Data d => d -> u) -> ImportDecl l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ImportDecl l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ImportDecl l -> m (ImportDecl l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportDecl l -> m (ImportDecl l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportDecl l -> m (ImportDecl l) #

Ord l => Ord (ImportDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Show l => Show (ImportDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Generic (ImportDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (ImportDecl l) :: * -> * #

Methods

from :: ImportDecl l -> Rep (ImportDecl l) x #

to :: Rep (ImportDecl l) x -> ImportDecl l #

Pretty (ImportDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: ImportDecl l -> Doc

prettyPrec :: Int -> ImportDecl l -> Doc

Parseable (ImportDecl SrcSpanInfo) Source # 
Instance details

Defined in Language.Haskell.Exts.Parser

type Rep (ImportDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data ImportSpecList l Source #

An explicit import specification list.

Constructors

ImportSpecList l Bool [ImportSpec l] 
Instances
Functor ImportSpecList Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> ImportSpecList a -> ImportSpecList b #

(<$) :: a -> ImportSpecList b -> ImportSpecList a #

Foldable ImportSpecList Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => ImportSpecList m -> m #

foldMap :: Monoid m => (a -> m) -> ImportSpecList a -> m #

foldr :: (a -> b -> b) -> b -> ImportSpecList a -> b #

foldr' :: (a -> b -> b) -> b -> ImportSpecList a -> b #

foldl :: (b -> a -> b) -> b -> ImportSpecList a -> b #

foldl' :: (b -> a -> b) -> b -> ImportSpecList a -> b #

foldr1 :: (a -> a -> a) -> ImportSpecList a -> a #

foldl1 :: (a -> a -> a) -> ImportSpecList a -> a #

toList :: ImportSpecList a -> [a] #

null :: ImportSpecList a -> Bool #

length :: ImportSpecList a -> Int #

elem :: Eq a => a -> ImportSpecList a -> Bool #

maximum :: Ord a => ImportSpecList a -> a #

minimum :: Ord a => ImportSpecList a -> a #

sum :: Num a => ImportSpecList a -> a #

product :: Num a => ImportSpecList a -> a #

Traversable ImportSpecList Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> ImportSpecList a -> f (ImportSpecList b) #

sequenceA :: Applicative f => ImportSpecList (f a) -> f (ImportSpecList a) #

mapM :: Monad m => (a -> m b) -> ImportSpecList a -> m (ImportSpecList b) #

sequence :: Monad m => ImportSpecList (m a) -> m (ImportSpecList a) #

Annotated ImportSpecList Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: ImportSpecList l -> l Source #

amap :: (l -> l) -> ImportSpecList l -> ImportSpecList l Source #

ExactP ImportSpecList Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: ImportSpecList SrcSpanInfo -> EP ()

Eq l => Eq (ImportSpecList l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Data l => Data (ImportSpecList l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ImportSpecList l -> c (ImportSpecList l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ImportSpecList l) #

toConstr :: ImportSpecList l -> Constr #

dataTypeOf :: ImportSpecList l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ImportSpecList l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ImportSpecList l)) #

gmapT :: (forall b. Data b => b -> b) -> ImportSpecList l -> ImportSpecList l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ImportSpecList l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ImportSpecList l -> r #

gmapQ :: (forall d. Data d => d -> u) -> ImportSpecList l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ImportSpecList l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ImportSpecList l -> m (ImportSpecList l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportSpecList l -> m (ImportSpecList l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportSpecList l -> m (ImportSpecList l) #

Ord l => Ord (ImportSpecList l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Show l => Show (ImportSpecList l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Generic (ImportSpecList l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (ImportSpecList l) :: * -> * #

Pretty (ImportSpecList l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: ImportSpecList l -> Doc

prettyPrec :: Int -> ImportSpecList l -> Doc

type Rep (ImportSpecList l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

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)

T: the name of a class, datatype or type synonym.

IThingAll l (Name l)

T(..): a class imported with all of its methods, or a datatype imported with all of its constructors.

IThingWith l (Name l) [CName l]

T(C_1,...,C_n): a class imported with some of its methods, or a datatype imported with some of its constructors.

Instances
Functor ImportSpec Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> ImportSpec a -> ImportSpec b #

(<$) :: a -> ImportSpec b -> ImportSpec a #

Foldable ImportSpec Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => ImportSpec m -> m #

foldMap :: Monoid m => (a -> m) -> ImportSpec a -> m #

foldr :: (a -> b -> b) -> b -> ImportSpec a -> b #

foldr' :: (a -> b -> b) -> b -> ImportSpec a -> b #

foldl :: (b -> a -> b) -> b -> ImportSpec a -> b #

foldl' :: (b -> a -> b) -> b -> ImportSpec a -> b #

foldr1 :: (a -> a -> a) -> ImportSpec a -> a #

foldl1 :: (a -> a -> a) -> ImportSpec a -> a #

toList :: ImportSpec a -> [a] #

null :: ImportSpec a -> Bool #

length :: ImportSpec a -> Int #

elem :: Eq a => a -> ImportSpec a -> Bool #

maximum :: Ord a => ImportSpec a -> a #

minimum :: Ord a => ImportSpec a -> a #

sum :: Num a => ImportSpec a -> a #

product :: Num a => ImportSpec a -> a #

Traversable ImportSpec Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> ImportSpec a -> f (ImportSpec b) #

sequenceA :: Applicative f => ImportSpec (f a) -> f (ImportSpec a) #

mapM :: Monad m => (a -> m b) -> ImportSpec a -> m (ImportSpec b) #

sequence :: Monad m => ImportSpec (m a) -> m (ImportSpec a) #

Annotated ImportSpec Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: ImportSpec l -> l Source #

amap :: (l -> l) -> ImportSpec l -> ImportSpec l Source #

ExactP ImportSpec Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: ImportSpec SrcSpanInfo -> EP ()

Eq l => Eq (ImportSpec l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: ImportSpec l -> ImportSpec l -> Bool #

(/=) :: ImportSpec l -> ImportSpec l -> Bool #

Data l => Data (ImportSpec l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ImportSpec l -> c (ImportSpec l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ImportSpec l) #

toConstr :: ImportSpec l -> Constr #

dataTypeOf :: ImportSpec l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ImportSpec l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ImportSpec l)) #

gmapT :: (forall b. Data b => b -> b) -> ImportSpec l -> ImportSpec l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ImportSpec l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ImportSpec l -> r #

gmapQ :: (forall d. Data d => d -> u) -> ImportSpec l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ImportSpec l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ImportSpec l -> m (ImportSpec l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportSpec l -> m (ImportSpec l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportSpec l -> m (ImportSpec l) #

Ord l => Ord (ImportSpec l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Show l => Show (ImportSpec l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Generic (ImportSpec l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (ImportSpec l) :: * -> * #

Methods

from :: ImportSpec l -> Rep (ImportSpec l) x #

to :: Rep (ImportSpec l) x -> ImportSpec l #

Pretty (ImportSpec l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: ImportSpec l -> Doc

prettyPrec :: Int -> ImportSpec l -> Doc

type Rep (ImportSpec l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data Assoc l Source #

Associativity of an operator.

Constructors

AssocNone l

non-associative operator (declared with infix)

AssocLeft l

left-associative operator (declared with infixl).

AssocRight l

right-associative operator (declared with infixr)

Instances
Functor Assoc Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Assoc a -> Assoc b #

(<$) :: a -> Assoc b -> Assoc a #

Foldable Assoc Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Assoc m -> m #

foldMap :: Monoid m => (a -> m) -> Assoc a -> m #

foldr :: (a -> b -> b) -> b -> Assoc a -> b #

foldr' :: (a -> b -> b) -> b -> Assoc a -> b #

foldl :: (b -> a -> b) -> b -> Assoc a -> b #

foldl' :: (b -> a -> b) -> b -> Assoc a -> b #

foldr1 :: (a -> a -> a) -> Assoc a -> a #

foldl1 :: (a -> a -> a) -> Assoc a -> a #

toList :: Assoc a -> [a] #

null :: Assoc a -> Bool #

length :: Assoc a -> Int #

elem :: Eq a => a -> Assoc a -> Bool #

maximum :: Ord a => Assoc a -> a #

minimum :: Ord a => Assoc a -> a #

sum :: Num a => Assoc a -> a #

product :: Num a => Assoc a -> a #

Traversable Assoc Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> Assoc a -> f (Assoc b) #

sequenceA :: Applicative f => Assoc (f a) -> f (Assoc a) #

mapM :: Monad m => (a -> m b) -> Assoc a -> m (Assoc b) #

sequence :: Monad m => Assoc (m a) -> m (Assoc a) #

Annotated Assoc Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Assoc l -> l Source #

amap :: (l -> l) -> Assoc l -> Assoc l Source #

ExactP Assoc Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Assoc SrcSpanInfo -> EP ()

Eq l => Eq (Assoc l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: Assoc l -> Assoc l -> Bool #

(/=) :: Assoc l -> Assoc l -> Bool #

Data l => Data (Assoc l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Assoc l -> c (Assoc l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Assoc l) #

toConstr :: Assoc l -> Constr #

dataTypeOf :: Assoc l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Assoc l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Assoc l)) #

gmapT :: (forall b. Data b => b -> b) -> Assoc l -> Assoc l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Assoc l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Assoc l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Assoc l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Assoc l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Assoc l -> m (Assoc l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Assoc l -> m (Assoc l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Assoc l -> m (Assoc l) #

Ord l => Ord (Assoc l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: Assoc l -> Assoc l -> Ordering #

(<) :: Assoc l -> Assoc l -> Bool #

(<=) :: Assoc l -> Assoc l -> Bool #

(>) :: Assoc l -> Assoc l -> Bool #

(>=) :: Assoc l -> Assoc l -> Bool #

max :: Assoc l -> Assoc l -> Assoc l #

min :: Assoc l -> Assoc l -> Assoc l #

Show l => Show (Assoc l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> Assoc l -> ShowS #

show :: Assoc l -> String #

showList :: [Assoc l] -> ShowS #

Generic (Assoc l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Assoc l) :: * -> * #

Methods

from :: Assoc l -> Rep (Assoc l) x #

to :: Rep (Assoc l) x -> Assoc l #

Pretty (Assoc l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Assoc l -> Doc

prettyPrec :: Int -> Assoc l -> Doc

type Rep (Assoc l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (Assoc l) = D1 (MetaData "Assoc" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.2-2ICFwnD62Z41OwyyQu0OCQ" False) (C1 (MetaCons "AssocNone" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) :+: (C1 (MetaCons "AssocLeft" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) :+: C1 (MetaCons "AssocRight" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l))))

data Namespace l Source #

Namespaces for imports/exports.

Instances
Functor Namespace Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Namespace a -> Namespace b #

(<$) :: a -> Namespace b -> Namespace a #

Foldable Namespace Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Namespace m -> m #

foldMap :: Monoid m => (a -> m) -> Namespace a -> m #

foldr :: (a -> b -> b) -> b -> Namespace a -> b #

foldr' :: (a -> b -> b) -> b -> Namespace a -> b #

foldl :: (b -> a -> b) -> b -> Namespace a -> b #

foldl' :: (b -> a -> b) -> b -> Namespace a -> b #

foldr1 :: (a -> a -> a) -> Namespace a -> a #

foldl1 :: (a -> a -> a) -> Namespace a -> a #

toList :: Namespace a -> [a] #

null :: Namespace a -> Bool #

length :: Namespace a -> Int #

elem :: Eq a => a -> Namespace a -> Bool #

maximum :: Ord a => Namespace a -> a #

minimum :: Ord a => Namespace a -> a #

sum :: Num a => Namespace a -> a #

product :: Num a => Namespace a -> a #

Traversable Namespace Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> Namespace a -> f (Namespace b) #

sequenceA :: Applicative f => Namespace (f a) -> f (Namespace a) #

mapM :: Monad m => (a -> m b) -> Namespace a -> m (Namespace b) #

sequence :: Monad m => Namespace (m a) -> m (Namespace a) #

Annotated Namespace Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Namespace l -> l Source #

amap :: (l -> l) -> Namespace l -> Namespace l Source #

ExactP Namespace Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Namespace SrcSpanInfo -> EP ()

Eq l => Eq (Namespace l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: Namespace l -> Namespace l -> Bool #

(/=) :: Namespace l -> Namespace l -> Bool #

Data l => Data (Namespace l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Namespace l -> c (Namespace l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Namespace l) #

toConstr :: Namespace l -> Constr #

dataTypeOf :: Namespace l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Namespace l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Namespace l)) #

gmapT :: (forall b. Data b => b -> b) -> Namespace l -> Namespace l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Namespace l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Namespace l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Namespace l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Namespace l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Namespace l -> m (Namespace l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Namespace l -> m (Namespace l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Namespace l -> m (Namespace l) #

Ord l => Ord (Namespace l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Show l => Show (Namespace l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Generic (Namespace l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Namespace l) :: * -> * #

Methods

from :: Namespace l -> Rep (Namespace l) x #

to :: Rep (Namespace l) x -> Namespace l #

Pretty (Namespace l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Namespace l -> Doc

prettyPrec :: Int -> Namespace l -> Doc

type Rep (Namespace l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (Namespace l) = D1 (MetaData "Namespace" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.2-2ICFwnD62Z41OwyyQu0OCQ" False) (C1 (MetaCons "NoNamespace" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) :+: (C1 (MetaCons "TypeNamespace" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) :+: C1 (MetaCons "PatternNamespace" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l))))

Declarations

data Decl l Source #

A top-level declaration.

Constructors

TypeDecl l (DeclHead l) (Type l)

A type declaration

TypeFamDecl l (DeclHead l) (Maybe (ResultSig l)) (Maybe (InjectivityInfo l))

A type family declaration

ClosedTypeFamDecl l (DeclHead l) (Maybe (ResultSig l)) (Maybe (InjectivityInfo l)) [TypeEqn l]

A closed type family declaration

DataDecl l (DataOrNew l) (Maybe (Context l)) (DeclHead l) [QualConDecl l] [Deriving l]

A data OR newtype declaration

GDataDecl l (DataOrNew l) (Maybe (Context l)) (DeclHead l) (Maybe (Kind l)) [GadtDecl l] [Deriving l]

A data OR newtype declaration, GADT style

DataFamDecl l (Maybe (Context l)) (DeclHead l) (Maybe (ResultSig l))

A data family declaration

TypeInsDecl l (Type l) (Type l)

A type family instance declaration

DataInsDecl l (DataOrNew l) (Type l) [QualConDecl l] [Deriving l]

A data family instance declaration

GDataInsDecl l (DataOrNew l) (Type l) (Maybe (Kind l)) [GadtDecl l] [Deriving l]

A data family instance declaration, GADT style

ClassDecl l (Maybe (Context l)) (DeclHead l) [FunDep l] (Maybe [ClassDecl l])

A declaration of a type class

InstDecl l (Maybe (Overlap l)) (InstRule l) (Maybe [InstDecl l])

An declaration of a type class instance

DerivDecl l (Maybe (DerivStrategy l)) (Maybe (Overlap l)) (InstRule l)

A standalone deriving declaration

InfixDecl l (Assoc l) (Maybe Int) [Op l]

A declaration of operator fixity

DefaultDecl l [Type l]

A declaration of default types

SpliceDecl l (Exp l)

A Template Haskell splicing declaration

TypeSig l [Name l] (Type l)

A type signature declaration

PatSynSig l [Name l] (Maybe [TyVarBind l]) (Maybe (Context l)) (Maybe (Context l)) (Type l)

A pattern synonym signature declation

FunBind l [Match l]

A set of function binding clauses

PatBind l (Pat l) (Rhs l) (Maybe (Binds l))

A pattern binding

PatSyn l (Pat l) (Pat l) (PatternSynDirection l)

A pattern synonym binding

ForImp l (CallConv l) (Maybe (Safety l)) (Maybe String) (Name l) (Type l)

A foreign import declaration

ForExp l (CallConv l) (Maybe String) (Name l) (Type l)

A foreign export declaration

RulePragmaDecl l [Rule l]

A RULES pragma

DeprPragmaDecl l [([Name l], String)]

A DEPRECATED pragma

WarnPragmaDecl l [([Name l], String)]

A WARNING pragma

InlineSig l Bool (Maybe (Activation l)) (QName l)

An INLINE pragma

InlineConlikeSig l (Maybe (Activation l)) (QName l)

An INLINE CONLIKE pragma

SpecSig l (Maybe (Activation l)) (QName l) [Type l]

A SPECIALISE pragma

SpecInlineSig l Bool (Maybe (Activation l)) (QName l) [Type l]

A SPECIALISE INLINE pragma

InstSig l (InstRule l)

A SPECIALISE instance pragma

AnnPragma l (Annotation l)

An ANN pragma

MinimalPragma l (Maybe (BooleanFormula l))

A MINIMAL pragma

RoleAnnotDecl l (QName l) [Role l]

A role annotation

CompletePragma l [Name l] (Maybe (QName l))

A COMPLETE pragma

Instances
Functor Decl Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Decl a -> Decl b #

(<$) :: a -> Decl b -> Decl a #

Foldable Decl Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Decl m -> m #

foldMap :: Monoid m => (a -> m) -> Decl a -> m #

foldr :: (a -> b -> b) -> b -> Decl a -> b #

foldr' :: (a -> b -> b) -> b -> Decl a -> b #

foldl :: (b -> a -> b) -> b -> Decl a -> b #

foldl' :: (b -> a -> b) -> b -> Decl a -> b #

foldr1 :: (a -> a -> a) -> Decl a -> a #

foldl1 :: (a -> a -> a) -> Decl a -> a #

toList :: Decl a -> [a] #

null :: Decl a -> Bool #

length :: Decl a -> Int #

elem :: Eq a => a -> Decl a -> Bool #

maximum :: Ord a => Decl a -> a #

minimum :: Ord a => Decl a -> a #

sum :: Num a => Decl a -> a #

product :: Num a => Decl a -> a #

Traversable Decl Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> Decl a -> f (Decl b) #

sequenceA :: Applicative f => Decl (f a) -> f (Decl a) #

mapM :: Monad m => (a -> m b) -> Decl a -> m (Decl b) #

sequence :: Monad m => Decl (m a) -> m (Decl a) #

Annotated Decl Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Decl l -> l Source #

amap :: (l -> l) -> Decl l -> Decl l Source #

AppFixity Decl Source # 
Instance details

Defined in Language.Haskell.Exts.Fixity

ExactP Decl Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Decl SrcSpanInfo -> EP ()

Eq l => Eq (Decl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: Decl l -> Decl l -> Bool #

(/=) :: Decl l -> Decl l -> Bool #

Data l => Data (Decl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Decl l -> c (Decl l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Decl l) #

toConstr :: Decl l -> Constr #

dataTypeOf :: Decl l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Decl l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Decl l)) #

gmapT :: (forall b. Data b => b -> b) -> Decl l -> Decl l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Decl l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Decl l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Decl l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Decl l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Decl l -> m (Decl l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Decl l -> m (Decl l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Decl l -> m (Decl l) #

Ord l => Ord (Decl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: Decl l -> Decl l -> Ordering #

(<) :: Decl l -> Decl l -> Bool #

(<=) :: Decl l -> Decl l -> Bool #

(>) :: Decl l -> Decl l -> Bool #

(>=) :: Decl l -> Decl l -> Bool #

max :: Decl l -> Decl l -> Decl l #

min :: Decl l -> Decl l -> Decl l #

Show l => Show (Decl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> Decl l -> ShowS #

show :: Decl l -> String #

showList :: [Decl l] -> ShowS #

Generic (Decl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Decl l) :: * -> * #

Methods

from :: Decl l -> Rep (Decl l) x #

to :: Rep (Decl l) x -> Decl l #

Pretty (Decl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Decl l -> Doc

prettyPrec :: Int -> Decl l -> Doc

Parseable (Decl SrcSpanInfo) Source # 
Instance details

Defined in Language.Haskell.Exts.Parser

type Rep (Decl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (Decl l) = D1 (MetaData "Decl" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.2-2ICFwnD62Z41OwyyQu0OCQ" False) (((((C1 (MetaCons "TypeDecl" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DeclHead l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)))) :+: C1 (MetaCons "TypeFamDecl" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DeclHead l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (ResultSig l))) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (InjectivityInfo l)))))) :+: (C1 (MetaCons "ClosedTypeFamDecl" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DeclHead l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (ResultSig l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (InjectivityInfo l))) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [TypeEqn l])))) :+: C1 (MetaCons "DataDecl" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DataOrNew l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Context l))))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DeclHead l)) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [QualConDecl l]) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Deriving l])))))) :+: ((C1 (MetaCons "GDataDecl" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DataOrNew l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Context l))))) :*: ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DeclHead l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Kind l)))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [GadtDecl l]) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Deriving l])))) :+: C1 (MetaCons "DataFamDecl" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Context l)))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DeclHead l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (ResultSig l)))))) :+: (C1 (MetaCons "TypeInsDecl" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)))) :+: C1 (MetaCons "DataInsDecl" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DataOrNew l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [QualConDecl l]) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Deriving l]))))))) :+: (((C1 (MetaCons "GDataInsDecl" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DataOrNew l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Kind l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [GadtDecl l]) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Deriving l])))) :+: C1 (MetaCons "ClassDecl" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Context l)))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DeclHead l)) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [FunDep l]) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe [ClassDecl l])))))) :+: (C1 (MetaCons "InstDecl" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Overlap l)))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (InstRule l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe [InstDecl l])))) :+: C1 (MetaCons "DerivDecl" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (DerivStrategy l)))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Overlap l))) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (InstRule l)))))) :+: ((C1 (MetaCons "InfixDecl" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Assoc l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe Int)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Op l]))) :+: C1 (MetaCons "DefaultDecl" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Type l]))) :+: (C1 (MetaCons "SpliceDecl" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l))) :+: (C1 (MetaCons "TypeSig" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Name l]) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)))) :+: C1 (MetaCons "PatSynSig" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Name l]) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe [TyVarBind l])))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Context l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Context l))) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)))))))))) :+: ((((C1 (MetaCons "FunBind" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Match l])) :+: C1 (MetaCons "PatBind" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Pat l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Rhs l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Binds l)))))) :+: (C1 (MetaCons "PatSyn" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Pat l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Pat l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (PatternSynDirection l)))) :+: C1 (MetaCons "ForImp" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (CallConv l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Safety l))))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe String)) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Name l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l))))))) :+: ((C1 (MetaCons "ForExp" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (CallConv l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe String)) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Name l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l))))) :+: C1 (MetaCons "RulePragmaDecl" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Rule l]))) :+: (C1 (MetaCons "DeprPragmaDecl" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [([Name l], String)])) :+: C1 (MetaCons "WarnPragmaDecl" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [([Name l], String)]))))) :+: (((C1 (MetaCons "InlineSig" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Bool)) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Activation l))) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l)))) :+: C1 (MetaCons "InlineConlikeSig" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Activation l))) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l))))) :+: (C1 (MetaCons "SpecSig" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Activation l)))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Type l]))) :+: C1 (MetaCons "SpecInlineSig" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Bool)) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Activation l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Type l])))))) :+: ((C1 (MetaCons "InstSig" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (InstRule l))) :+: C1 (MetaCons "AnnPragma" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Annotation l)))) :+: (C1 (MetaCons "MinimalPragma" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (BooleanFormula l)))) :+: (C1 (MetaCons "RoleAnnotDecl" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Role l]))) :+: C1 (MetaCons "CompletePragma" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Name l]) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (QName l)))))))))))

data DeclHead l Source #

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
Functor DeclHead Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> DeclHead a -> DeclHead b #

(<$) :: a -> DeclHead b -> DeclHead a #

Foldable DeclHead Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => DeclHead m -> m #

foldMap :: Monoid m => (a -> m) -> DeclHead a -> m #

foldr :: (a -> b -> b) -> b -> DeclHead a -> b #

foldr' :: (a -> b -> b) -> b -> DeclHead a -> b #

foldl :: (b -> a -> b) -> b -> DeclHead a -> b #

foldl' :: (b -> a -> b) -> b -> DeclHead a -> b #

foldr1 :: (a -> a -> a) -> DeclHead a -> a #

foldl1 :: (a -> a -> a) -> DeclHead a -> a #

toList :: DeclHead a -> [a] #

null :: DeclHead a -> Bool #

length :: DeclHead a -> Int #

elem :: Eq a => a -> DeclHead a -> Bool #

maximum :: Ord a => DeclHead a -> a #

minimum :: Ord a => DeclHead a -> a #

sum :: Num a => DeclHead a -> a #

product :: Num a => DeclHead a -> a #

Traversable DeclHead Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> DeclHead a -> f (DeclHead b) #

sequenceA :: Applicative f => DeclHead (f a) -> f (DeclHead a) #

mapM :: Monad m => (a -> m b) -> DeclHead a -> m (DeclHead b) #

sequence :: Monad m => DeclHead (m a) -> m (DeclHead a) #

Annotated DeclHead Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: DeclHead l -> l Source #

amap :: (l -> l) -> DeclHead l -> DeclHead l Source #

ExactP DeclHead Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: DeclHead SrcSpanInfo -> EP ()

Eq l => Eq (DeclHead l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: DeclHead l -> DeclHead l -> Bool #

(/=) :: DeclHead l -> DeclHead l -> Bool #

Data l => Data (DeclHead l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DeclHead l -> c (DeclHead l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DeclHead l) #

toConstr :: DeclHead l -> Constr #

dataTypeOf :: DeclHead l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DeclHead l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (DeclHead l)) #

gmapT :: (forall b. Data b => b -> b) -> DeclHead l -> DeclHead l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DeclHead l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DeclHead l -> r #

gmapQ :: (forall d. Data d => d -> u) -> DeclHead l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> DeclHead l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DeclHead l -> m (DeclHead l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DeclHead l -> m (DeclHead l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DeclHead l -> m (DeclHead l) #

Ord l => Ord (DeclHead l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: DeclHead l -> DeclHead l -> Ordering #

(<) :: DeclHead l -> DeclHead l -> Bool #

(<=) :: DeclHead l -> DeclHead l -> Bool #

(>) :: DeclHead l -> DeclHead l -> Bool #

(>=) :: DeclHead l -> DeclHead l -> Bool #

max :: DeclHead l -> DeclHead l -> DeclHead l #

min :: DeclHead l -> DeclHead l -> DeclHead l #

Show l => Show (DeclHead l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> DeclHead l -> ShowS #

show :: DeclHead l -> String #

showList :: [DeclHead l] -> ShowS #

Generic (DeclHead l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (DeclHead l) :: * -> * #

Methods

from :: DeclHead l -> Rep (DeclHead l) x #

to :: Rep (DeclHead l) x -> DeclHead l #

Pretty (DeclHead l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: DeclHead l -> Doc

prettyPrec :: Int -> DeclHead l -> Doc

type Rep (DeclHead l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data InstRule l Source #

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
Functor InstRule Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> InstRule a -> InstRule b #

(<$) :: a -> InstRule b -> InstRule a #

Foldable InstRule Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => InstRule m -> m #

foldMap :: Monoid m => (a -> m) -> InstRule a -> m #

foldr :: (a -> b -> b) -> b -> InstRule a -> b #

foldr' :: (a -> b -> b) -> b -> InstRule a -> b #

foldl :: (b -> a -> b) -> b -> InstRule a -> b #

foldl' :: (b -> a -> b) -> b -> InstRule a -> b #

foldr1 :: (a -> a -> a) -> InstRule a -> a #

foldl1 :: (a -> a -> a) -> InstRule a -> a #

toList :: InstRule a -> [a] #

null :: InstRule a -> Bool #

length :: InstRule a -> Int #

elem :: Eq a => a -> InstRule a -> Bool #

maximum :: Ord a => InstRule a -> a #

minimum :: Ord a => InstRule a -> a #

sum :: Num a => InstRule a -> a #

product :: Num a => InstRule a -> a #

Traversable InstRule Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> InstRule a -> f (InstRule b) #

sequenceA :: Applicative f => InstRule (f a) -> f (InstRule a) #

mapM :: Monad m => (a -> m b) -> InstRule a -> m (InstRule b) #

sequence :: Monad m => InstRule (m a) -> m (InstRule a) #

Annotated InstRule Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: InstRule l -> l Source #

amap :: (l -> l) -> InstRule l -> InstRule l Source #

ExactP InstRule Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: InstRule SrcSpanInfo -> EP ()

Eq l => Eq (InstRule l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: InstRule l -> InstRule l -> Bool #

(/=) :: InstRule l -> InstRule l -> Bool #

Data l => Data (InstRule l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InstRule l -> c (InstRule l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (InstRule l) #

toConstr :: InstRule l -> Constr #

dataTypeOf :: InstRule l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (InstRule l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (InstRule l)) #

gmapT :: (forall b. Data b => b -> b) -> InstRule l -> InstRule l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> InstRule l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> InstRule l -> r #

gmapQ :: (forall d. Data d => d -> u) -> InstRule l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> InstRule l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> InstRule l -> m (InstRule l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InstRule l -> m (InstRule l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InstRule l -> m (InstRule l) #

Ord l => Ord (InstRule l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: InstRule l -> InstRule l -> Ordering #

(<) :: InstRule l -> InstRule l -> Bool #

(<=) :: InstRule l -> InstRule l -> Bool #

(>) :: InstRule l -> InstRule l -> Bool #

(>=) :: InstRule l -> InstRule l -> Bool #

max :: InstRule l -> InstRule l -> InstRule l #

min :: InstRule l -> InstRule l -> InstRule l #

Show l => Show (InstRule l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> InstRule l -> ShowS #

show :: InstRule l -> String #

showList :: [InstRule l] -> ShowS #

Generic (InstRule l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (InstRule l) :: * -> * #

Methods

from :: InstRule l -> Rep (InstRule l) x #

to :: Rep (InstRule l) x -> InstRule l #

Pretty (InstRule l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: InstRule l -> Doc

prettyPrec :: Int -> InstRule l -> Doc

type Rep (InstRule l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data InstHead l Source #

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
Functor InstHead Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> InstHead a -> InstHead b #

(<$) :: a -> InstHead b -> InstHead a #

Foldable InstHead Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => InstHead m -> m #

foldMap :: Monoid m => (a -> m) -> InstHead a -> m #

foldr :: (a -> b -> b) -> b -> InstHead a -> b #

foldr' :: (a -> b -> b) -> b -> InstHead a -> b #

foldl :: (b -> a -> b) -> b -> InstHead a -> b #

foldl' :: (b -> a -> b) -> b -> InstHead a -> b #

foldr1 :: (a -> a -> a) -> InstHead a -> a #

foldl1 :: (a -> a -> a) -> InstHead a -> a #

toList :: InstHead a -> [a] #

null :: InstHead a -> Bool #

length :: InstHead a -> Int #

elem :: Eq a => a -> InstHead a -> Bool #

maximum :: Ord a => InstHead a -> a #

minimum :: Ord a => InstHead a -> a #

sum :: Num a => InstHead a -> a #

product :: Num a => InstHead a -> a #

Traversable InstHead Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> InstHead a -> f (InstHead b) #

sequenceA :: Applicative f => InstHead (f a) -> f (InstHead a) #

mapM :: Monad m => (a -> m b) -> InstHead a -> m (InstHead b) #

sequence :: Monad m => InstHead (m a) -> m (InstHead a) #

Annotated InstHead Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: InstHead l -> l Source #

amap :: (l -> l) -> InstHead l -> InstHead l Source #

ExactP InstHead Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: InstHead SrcSpanInfo -> EP ()

Eq l => Eq (InstHead l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: InstHead l -> InstHead l -> Bool #

(/=) :: InstHead l -> InstHead l -> Bool #

Data l => Data (InstHead l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InstHead l -> c (InstHead l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (InstHead l) #

toConstr :: InstHead l -> Constr #

dataTypeOf :: InstHead l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (InstHead l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (InstHead l)) #

gmapT :: (forall b. Data b => b -> b) -> InstHead l -> InstHead l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> InstHead l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> InstHead l -> r #

gmapQ :: (forall d. Data d => d -> u) -> InstHead l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> InstHead l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> InstHead l -> m (InstHead l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InstHead l -> m (InstHead l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InstHead l -> m (InstHead l) #

Ord l => Ord (InstHead l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: InstHead l -> InstHead l -> Ordering #

(<) :: InstHead l -> InstHead l -> Bool #

(<=) :: InstHead l -> InstHead l -> Bool #

(>) :: InstHead l -> InstHead l -> Bool #

(>=) :: InstHead l -> InstHead l -> Bool #

max :: InstHead l -> InstHead l -> InstHead l #

min :: InstHead l -> InstHead l -> InstHead l #

Show l => Show (InstHead l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> InstHead l -> ShowS #

show :: InstHead l -> String #

showList :: [InstHead l] -> ShowS #

Generic (InstHead l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (InstHead l) :: * -> * #

Methods

from :: InstHead l -> Rep (InstHead l) x #

to :: Rep (InstHead l) x -> InstHead l #

Pretty (InstHead l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: InstHead l -> Doc

prettyPrec :: Int -> InstHead l -> Doc

type Rep (InstHead l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data Binds l Source #

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 # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Binds a -> Binds b #

(<$) :: a -> Binds b -> Binds a #

Foldable Binds Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Binds m -> m #

foldMap :: Monoid m => (a -> m) -> Binds a -> m #

foldr :: (a -> b -> b) -> b -> Binds a -> b #

foldr' :: (a -> b -> b) -> b -> Binds a -> b #

foldl :: (b -> a -> b) -> b -> Binds a -> b #

foldl' :: (b -> a -> b) -> b -> Binds a -> b #

foldr1 :: (a -> a -> a) -> Binds a -> a #

foldl1 :: (a -> a -> a) -> Binds a -> a #

toList :: Binds a -> [a] #

null :: Binds a -> Bool #

length :: Binds a -> Int #

elem :: Eq a => a -> Binds a -> Bool #

maximum :: Ord a => Binds a -> a #

minimum :: Ord a => Binds a -> a #

sum :: Num a => Binds a -> a #

product :: Num a => Binds a -> a #

Traversable Binds Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> Binds a -> f (Binds b) #

sequenceA :: Applicative f => Binds (f a) -> f (Binds a) #

mapM :: Monad m => (a -> m b) -> Binds a -> m (Binds b) #

sequence :: Monad m => Binds (m a) -> m (Binds a) #

Annotated Binds Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Binds l -> l Source #

amap :: (l -> l) -> Binds l -> Binds l Source #

AppFixity Binds Source # 
Instance details

Defined in Language.Haskell.Exts.Fixity

ExactP Binds Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Binds SrcSpanInfo -> EP ()

Eq l => Eq (Binds l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: Binds l -> Binds l -> Bool #

(/=) :: Binds l -> Binds l -> Bool #

Data l => Data (Binds l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Binds l -> c (Binds l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Binds l) #

toConstr :: Binds l -> Constr #

dataTypeOf :: Binds l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Binds l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Binds l)) #

gmapT :: (forall b. Data b => b -> b) -> Binds l -> Binds l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Binds l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Binds l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Binds l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Binds l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Binds l -> m (Binds l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Binds l -> m (Binds l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Binds l -> m (Binds l) #

Ord l => Ord (Binds l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: Binds l -> Binds l -> Ordering #

(<) :: Binds l -> Binds l -> Bool #

(<=) :: Binds l -> Binds l -> Bool #

(>) :: Binds l -> Binds l -> Bool #

(>=) :: Binds l -> Binds l -> Bool #

max :: Binds l -> Binds l -> Binds l #

min :: Binds l -> Binds l -> Binds l #

Show l => Show (Binds l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> Binds l -> ShowS #

show :: Binds l -> String #

showList :: [Binds l] -> ShowS #

Generic (Binds l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Binds l) :: * -> * #

Methods

from :: Binds l -> Rep (Binds l) x #

to :: Rep (Binds l) x -> Binds l #

type Rep (Binds l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data IPBind l Source #

A binding of an implicit parameter.

Constructors

IPBind l (IPName l) (Exp l) 
Instances
Functor IPBind Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> IPBind a -> IPBind b #

(<$) :: a -> IPBind b -> IPBind a #

Foldable IPBind Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => IPBind m -> m #

foldMap :: Monoid m => (a -> m) -> IPBind a -> m #

foldr :: (a -> b -> b) -> b -> IPBind a -> b #

foldr' :: (a -> b -> b) -> b -> IPBind a -> b #

foldl :: (b -> a -> b) -> b -> IPBind a -> b #

foldl' :: (b -> a -> b) -> b -> IPBind a -> b #

foldr1 :: (a -> a -> a) -> IPBind a -> a #

foldl1 :: (a -> a -> a) -> IPBind a -> a #

toList :: IPBind a -> [a] #

null :: IPBind a -> Bool #

length :: IPBind a -> Int #

elem :: Eq a => a -> IPBind a -> Bool #

maximum :: Ord a => IPBind a -> a #

minimum :: Ord a => IPBind a -> a #

sum :: Num a => IPBind a -> a #

product :: Num a => IPBind a -> a #

Traversable IPBind Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> IPBind a -> f (IPBind b) #

sequenceA :: Applicative f => IPBind (f a) -> f (IPBind a) #

mapM :: Monad m => (a -> m b) -> IPBind a -> m (IPBind b) #

sequence :: Monad m => IPBind (m a) -> m (IPBind a) #

Annotated IPBind Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: IPBind l -> l Source #

amap :: (l -> l) -> IPBind l -> IPBind l Source #

AppFixity IPBind Source # 
Instance details

Defined in Language.Haskell.Exts.Fixity

ExactP IPBind Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: IPBind SrcSpanInfo -> EP ()

Eq l => Eq (IPBind l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: IPBind l -> IPBind l -> Bool #

(/=) :: IPBind l -> IPBind l -> Bool #

Data l => Data (IPBind l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IPBind l -> c (IPBind l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (IPBind l) #

toConstr :: IPBind l -> Constr #

dataTypeOf :: IPBind l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (IPBind l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (IPBind l)) #

gmapT :: (forall b. Data b => b -> b) -> IPBind l -> IPBind l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IPBind l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IPBind l -> r #

gmapQ :: (forall d. Data d => d -> u) -> IPBind l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> IPBind l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> IPBind l -> m (IPBind l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IPBind l -> m (IPBind l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IPBind l -> m (IPBind l) #

Ord l => Ord (IPBind l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: IPBind l -> IPBind l -> Ordering #

(<) :: IPBind l -> IPBind l -> Bool #

(<=) :: IPBind l -> IPBind l -> Bool #

(>) :: IPBind l -> IPBind l -> Bool #

(>=) :: IPBind l -> IPBind l -> Bool #

max :: IPBind l -> IPBind l -> IPBind l #

min :: IPBind l -> IPBind l -> IPBind l #

Show l => Show (IPBind l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> IPBind l -> ShowS #

show :: IPBind l -> String #

showList :: [IPBind l] -> ShowS #

Generic (IPBind l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (IPBind l) :: * -> * #

Methods

from :: IPBind l -> Rep (IPBind l) x #

to :: Rep (IPBind l) x -> IPBind l #

Pretty (IPBind l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: IPBind l -> Doc

prettyPrec :: Int -> IPBind l -> Doc

type Rep (IPBind l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

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
Functor PatternSynDirection Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Foldable PatternSynDirection Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => PatternSynDirection m -> m #

foldMap :: Monoid m => (a -> m) -> PatternSynDirection a -> m #

foldr :: (a -> b -> b) -> b -> PatternSynDirection a -> b #

foldr' :: (a -> b -> b) -> b -> PatternSynDirection a -> b #

foldl :: (b -> a -> b) -> b -> PatternSynDirection a -> b #

foldl' :: (b -> a -> b) -> b -> PatternSynDirection a -> b #

foldr1 :: (a -> a -> a) -> PatternSynDirection a -> a #

foldl1 :: (a -> a -> a) -> PatternSynDirection a -> a #

toList :: PatternSynDirection a -> [a] #

null :: PatternSynDirection a -> Bool #

length :: PatternSynDirection a -> Int #

elem :: Eq a => a -> PatternSynDirection a -> Bool #

maximum :: Ord a => PatternSynDirection a -> a #

minimum :: Ord a => PatternSynDirection a -> a #

sum :: Num a => PatternSynDirection a -> a #

product :: Num a => PatternSynDirection a -> a #

Traversable PatternSynDirection Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

AppFixity PatternSynDirection Source # 
Instance details

Defined in Language.Haskell.Exts.Fixity

Eq l => Eq (PatternSynDirection l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Data l => Data (PatternSynDirection l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PatternSynDirection l -> c (PatternSynDirection l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (PatternSynDirection l) #

toConstr :: PatternSynDirection l -> Constr #

dataTypeOf :: PatternSynDirection l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (PatternSynDirection l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (PatternSynDirection l)) #

gmapT :: (forall b. Data b => b -> b) -> PatternSynDirection l -> PatternSynDirection l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PatternSynDirection l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PatternSynDirection l -> r #

gmapQ :: (forall d. Data d => d -> u) -> PatternSynDirection l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> PatternSynDirection l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> PatternSynDirection l -> m (PatternSynDirection l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PatternSynDirection l -> m (PatternSynDirection l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PatternSynDirection l -> m (PatternSynDirection l) #

Ord l => Ord (PatternSynDirection l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Show l => Show (PatternSynDirection l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Generic (PatternSynDirection l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (PatternSynDirection l) :: * -> * #

type Rep (PatternSynDirection l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (PatternSynDirection l) = D1 (MetaData "PatternSynDirection" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.2-2ICFwnD62Z41OwyyQu0OCQ" False) (C1 (MetaCons "Unidirectional" PrefixI False) (U1 :: * -> *) :+: (C1 (MetaCons "ImplicitBidirectional" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "ExplicitBidirectional" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Decl l]))))

data InjectivityInfo l Source #

Injectivity info for injective type families

Constructors

InjectivityInfo l (Name l) [Name l] 
Instances
Functor InjectivityInfo Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> InjectivityInfo a -> InjectivityInfo b #

(<$) :: a -> InjectivityInfo b -> InjectivityInfo a #

Foldable InjectivityInfo Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => InjectivityInfo m -> m #

foldMap :: Monoid m => (a -> m) -> InjectivityInfo a -> m #

foldr :: (a -> b -> b) -> b -> InjectivityInfo a -> b #

foldr' :: (a -> b -> b) -> b -> InjectivityInfo a -> b #

foldl :: (b -> a -> b) -> b -> InjectivityInfo a -> b #

foldl' :: (b -> a -> b) -> b -> InjectivityInfo a -> b #

foldr1 :: (a -> a -> a) -> InjectivityInfo a -> a #

foldl1 :: (a -> a -> a) -> InjectivityInfo a -> a #

toList :: InjectivityInfo a -> [a] #

null :: InjectivityInfo a -> Bool #

length :: InjectivityInfo a -> Int #

elem :: Eq a => a -> InjectivityInfo a -> Bool #

maximum :: Ord a => InjectivityInfo a -> a #

minimum :: Ord a => InjectivityInfo a -> a #

sum :: Num a => InjectivityInfo a -> a #

product :: Num a => InjectivityInfo a -> a #

Traversable InjectivityInfo Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> InjectivityInfo a -> f (InjectivityInfo b) #

sequenceA :: Applicative f => InjectivityInfo (f a) -> f (InjectivityInfo a) #

mapM :: Monad m => (a -> m b) -> InjectivityInfo a -> m (InjectivityInfo b) #

sequence :: Monad m => InjectivityInfo (m a) -> m (InjectivityInfo a) #

Annotated InjectivityInfo Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: InjectivityInfo l -> l Source #

amap :: (l -> l) -> InjectivityInfo l -> InjectivityInfo l Source #

ExactP InjectivityInfo Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Eq l => Eq (InjectivityInfo l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Data l => Data (InjectivityInfo l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InjectivityInfo l -> c (InjectivityInfo l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (InjectivityInfo l) #

toConstr :: InjectivityInfo l ->