haskell-src-exts-1.18.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 # 

Methods

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

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

Foldable Module Source # 

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 # 

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 # 

Methods

ann :: Module l -> l Source #

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

AppFixity Module Source # 
ExactP Module Source # 

Methods

exactP :: Module SrcSpanInfo -> EP ()

Eq l => Eq (Module l) Source # 

Methods

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

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

Data l => Data (Module l) Source # 

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 # 

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 # 

Methods

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

show :: Module l -> String #

showList :: [Module l] -> ShowS #

Generic (Module l) Source # 

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 # 

Methods

pretty :: Module pos -> Doc

prettyPrec :: Int -> Module pos -> Doc

type Rep (Module l) Source # 
type Rep (Module l) = D1 (MetaData "Module" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.18.2-9JBcaPyJNc23w8BJK1Oi0T" False) ((:+:) (C1 (MetaCons "Module" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (ModuleHead l))))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [ModulePragma l])) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [ImportDecl l])) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Decl l])))))) ((:+:) (C1 (MetaCons "XmlPage" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ModuleName l))) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [ModulePragma l])))) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (XName l))) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [XAttr l]))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Exp l)))) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Exp l])))))) (C1 (MetaCons "XmlHybrid" PrefixI False) ((:*:) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (ModuleHead l))))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [ModulePragma l])) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [ImportDecl l])))) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Decl l])) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (XName l)))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [XAttr l])) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Exp l)))) (S1 (MetaSel (Nothing 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 # 

Methods

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

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

Foldable ModuleHead Source # 

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 # 

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 # 

Methods

ann :: ModuleHead l -> l Source #

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

ExactP ModuleHead Source # 

Methods

exactP :: ModuleHead SrcSpanInfo -> EP ()

Eq l => Eq (ModuleHead l) Source # 

Methods

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

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

Data l => Data (ModuleHead l) Source # 

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 # 
Show l => Show (ModuleHead l) Source # 
Generic (ModuleHead l) Source # 

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 # 

Methods

pretty :: ModuleHead l -> Doc

prettyPrec :: Int -> ModuleHead l -> Doc

type Rep (ModuleHead l) Source # 

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 # 

Methods

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

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

Foldable WarningText Source # 

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 # 

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 # 

Methods

ann :: WarningText l -> l Source #

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

ExactP WarningText Source # 

Methods

exactP :: WarningText SrcSpanInfo -> EP ()

Eq l => Eq (WarningText l) Source # 
Data l => Data (WarningText l) Source # 

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 # 
Show l => Show (WarningText l) Source # 
Generic (WarningText l) Source # 

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 # 

data ExportSpecList l Source #

An explicit export specification.

Constructors

ExportSpecList l [ExportSpec l] 

Instances

Functor ExportSpecList Source # 

Methods

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

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

Foldable ExportSpecList Source # 

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 # 

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 # 

Methods

ann :: ExportSpecList l -> l Source #

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

ExactP ExportSpecList Source # 

Methods

exactP :: ExportSpecList SrcSpanInfo -> EP ()

Eq l => Eq (ExportSpecList l) Source # 
Data l => Data (ExportSpecList l) Source # 

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 # 
Show l => Show (ExportSpecList l) Source # 
Generic (ExportSpecList l) Source # 

Associated Types

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

Pretty (ExportSpecList l) Source # 

Methods

pretty :: ExportSpecList l -> Doc

prettyPrec :: Int -> ExportSpecList l -> Doc

type Rep (ExportSpecList l) Source # 
type Rep (ExportSpecList l) = D1 (MetaData "ExportSpecList" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.18.2-9JBcaPyJNc23w8BJK1Oi0T" False) (C1 (MetaCons "ExportSpecList" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) (S1 (MetaSel (Nothing 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 # 

Methods

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

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

Foldable ExportSpec Source # 

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 # 

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 # 

Methods

ann :: ExportSpec l -> l Source #

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

ExactP ExportSpec Source # 

Methods

exactP :: ExportSpec SrcSpanInfo -> EP ()

Eq l => Eq (ExportSpec l) Source # 

Methods

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

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

Data l => Data (ExportSpec l) Source # 

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 # 
Show l => Show (ExportSpec l) Source # 
Generic (ExportSpec l) Source # 

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 # 

Methods

pretty :: ExportSpec l -> Doc

prettyPrec :: Int -> ExportSpec l -> Doc

type Rep (ExportSpec l) Source # 

data EWildcard l Source #

Indicates the position of the wildcard in an export list

Constructors

NoWildcard l 
EWildcard l Int 

Instances

Functor EWildcard Source # 

Methods

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

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

Foldable EWildcard Source # 

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 # 

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 # 

Methods

ann :: EWildcard l -> l Source #

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

Eq l => Eq (EWildcard l) Source # 

Methods

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

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

Data l => Data (EWildcard l) Source # 

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 # 
Show l => Show (EWildcard l) Source # 
Generic (EWildcard l) Source # 

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 # 
type Rep (EWildcard l) = D1 (MetaData "EWildcard" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.18.2-9JBcaPyJNc23w8BJK1Oi0T" False) ((:+:) (C1 (MetaCons "NoWildcard" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l))) (C1 (MetaCons "EWildcard" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int)))))

data ImportDecl l Source #

An import declaration.

Constructors

ImportDecl 

Fields

Instances

Functor ImportDecl Source # 

Methods

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

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

Foldable ImportDecl Source # 

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 # 

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 # 

Methods

ann :: ImportDecl l -> l Source #

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

ExactP ImportDecl Source # 

Methods

exactP :: ImportDecl SrcSpanInfo -> EP ()

Eq l => Eq (ImportDecl l) Source # 

Methods

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

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

Data l => Data (ImportDecl l) Source # 

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 # 
Show l => Show (ImportDecl l) Source # 
Generic (ImportDecl l) Source # 

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 # 

Methods

pretty :: ImportDecl l -> Doc

prettyPrec :: Int -> ImportDecl l -> Doc

type Rep (ImportDecl l) Source # 

data ImportSpecList l Source #

An explicit import specification list.

Constructors

ImportSpecList l Bool [ImportSpec l] 

Instances

Functor ImportSpecList Source # 

Methods

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

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

Foldable ImportSpecList Source # 

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 # 

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 # 

Methods

ann :: ImportSpecList l -> l Source #

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

ExactP ImportSpecList Source # 

Methods

exactP :: ImportSpecList SrcSpanInfo -> EP ()

Eq l => Eq (ImportSpecList l) Source # 
Data l => Data (ImportSpecList l) Source # 

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 # 
Show l => Show (ImportSpecList l) Source # 
Generic (ImportSpecList l) Source # 

Associated Types

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

Pretty (ImportSpecList l) Source # 

Methods

pretty :: ImportSpecList l -> Doc

prettyPrec :: Int -> ImportSpecList l -> Doc

type Rep (ImportSpecList l) Source # 

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 # 

Methods

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

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

Foldable ImportSpec Source # 

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 # 

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 # 

Methods

ann :: ImportSpec l -> l Source #

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

ExactP ImportSpec Source # 

Methods

exactP :: ImportSpec SrcSpanInfo -> EP ()

Eq l => Eq (ImportSpec l) Source # 

Methods

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

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

Data l => Data (ImportSpec l) Source # 

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 # 
Show l => Show (ImportSpec l) Source # 
Generic (ImportSpec l) Source # 

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 # 

Methods

pretty :: ImportSpec l -> Doc

prettyPrec :: Int -> ImportSpec l -> Doc

type Rep (ImportSpec l) Source # 

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 # 

Methods

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

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

Foldable Assoc Source # 

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 # 

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 # 

Methods

ann :: Assoc l -> l Source #

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

ExactP Assoc Source # 

Methods

exactP :: Assoc SrcSpanInfo -> EP ()

Eq l => Eq (Assoc l) Source # 

Methods

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

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

Data l => Data (Assoc l) Source # 

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 # 

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 # 

Methods

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

show :: Assoc l -> String #

showList :: [Assoc l] -> ShowS #

Generic (Assoc l) Source # 

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 # 

Methods

pretty :: Assoc l -> Doc

prettyPrec :: Int -> Assoc l -> Doc

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

data Namespace l Source #

Namespaces for imports/exports.

Instances

Functor Namespace Source # 

Methods

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

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

Foldable Namespace Source # 

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 # 

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 # 

Methods

ann :: Namespace l -> l Source #

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

ExactP Namespace Source # 

Methods

exactP :: Namespace SrcSpanInfo -> EP ()

Eq l => Eq (Namespace l) Source # 

Methods

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

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

Data l => Data (Namespace l) Source # 

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 # 
Show l => Show (Namespace l) Source # 
Generic (Namespace l) Source # 

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 # 

Methods

pretty :: Namespace l -> Doc

prettyPrec :: Int -> Namespace l -> Doc

type Rep (Namespace l) Source # 
type Rep (Namespace l) = D1 (MetaData "Namespace" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.18.2-9JBcaPyJNc23w8BJK1Oi0T" False) ((:+:) (C1 (MetaCons "NoNamespace" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l))) ((:+:) (C1 (MetaCons "TypeNamespace" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l))) (C1 (MetaCons "PatternNamespace" PrefixI False) (S1 (MetaSel (Nothing 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] (Maybe (Deriving l))

A data OR newtype declaration

GDataDecl l (DataOrNew l) (Maybe (Context l)) (DeclHead l) (Maybe (Kind l)) [GadtDecl l] (Maybe (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] (Maybe (Deriving l))

A data family instance declaration

GDataInsDecl l (DataOrNew l) (Type l) (Maybe (Kind l)) [GadtDecl l] (Maybe (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 (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

Instances

Functor Decl Source # 

Methods

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

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

Foldable Decl Source # 

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 # 

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 # 

Methods

ann :: Decl l -> l Source #

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

AppFixity Decl Source # 
ExactP Decl Source # 

Methods

exactP :: Decl SrcSpanInfo -> EP ()

Eq l => Eq (Decl l) Source # 

Methods

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

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

Data l => Data (Decl l) Source # 

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 # 

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 # 

Methods

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

show :: Decl l -> String #

showList :: [Decl l] -> ShowS #

Generic (Decl l) Source # 

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 # 

Methods

pretty :: Decl l -> Doc

prettyPrec :: Int -> Decl l -> Doc

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

Methods

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

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

Foldable DeclHead Source # 

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 # 

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 # 

Methods

ann :: DeclHead l -> l Source #

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

ExactP DeclHead Source # 

Methods

exactP :: DeclHead SrcSpanInfo -> EP ()

Eq l => Eq (DeclHead l) Source # 

Methods

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

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

Data l => Data (DeclHead l) Source # 

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 # 

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 # 

Methods

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

show :: DeclHead l -> String #

showList :: [DeclHead l] -> ShowS #

Generic (DeclHead l) Source # 

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 # 

Methods

pretty :: DeclHead l -> Doc

prettyPrec :: Int -> DeclHead l -> Doc

type Rep (DeclHead l) Source # 

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 # 

Methods

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

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

Foldable InstRule Source # 

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 # 

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 # 

Methods

ann :: InstRule l -> l Source #

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

ExactP InstRule Source # 

Methods

exactP :: InstRule SrcSpanInfo -> EP ()

Eq l => Eq (InstRule l) Source # 

Methods

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

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

Data l => Data (InstRule l) Source # 

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 # 

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 # 

Methods

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

show :: InstRule l -> String #

showList :: [InstRule l] -> ShowS #

Generic (InstRule l) Source # 

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 # 

Methods

pretty :: InstRule l -> Doc

prettyPrec :: Int -> InstRule l -> Doc

type Rep (InstRule l) Source # 

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 # 

Methods

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

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

Foldable InstHead Source # 

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 # 

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 # 

Methods

ann :: InstHead l -> l Source #

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

ExactP InstHead Source # 

Methods

exactP :: InstHead SrcSpanInfo -> EP ()

Eq l => Eq (InstHead l) Source # 

Methods

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

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

Data l => Data (InstHead l) Source # 

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 # 

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 # 

Methods

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

show :: InstHead l -> String #

showList :: [InstHead l] -> ShowS #

Generic (InstHead l) Source # 

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 # 

Methods

pretty :: InstHead l -> Doc

prettyPrec :: Int -> InstHead l -> Doc

type Rep (InstHead l) Source # 

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 # 

Methods

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

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

Foldable Binds Source # 

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 # 

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 # 

Methods

ann :: Binds l -> l Source #

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

AppFixity Binds Source # 
ExactP Binds Source # 

Methods

exactP :: Binds SrcSpanInfo -> EP ()

Eq l => Eq (Binds l) Source # 

Methods

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

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

Data l => Data (Binds l) Source # 

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 # 

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 # 

Methods

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

show :: Binds l -> String #

showList :: [Binds l] -> ShowS #

Generic (Binds l) Source # 

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 # 

data IPBind l Source #

A binding of an implicit parameter.

Constructors

IPBind l (IPName l) (Exp l) 

Instances

Functor IPBind Source # 

Methods

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

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

Foldable IPBind Source # 

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 # 

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 # 

Methods

ann :: IPBind l -> l Source #

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

AppFixity IPBind Source # 
ExactP IPBind Source # 

Methods

exactP :: IPBind SrcSpanInfo -> EP ()

Eq l => Eq (IPBind l) Source # 

Methods

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

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

Data l => Data (IPBind l) Source # 

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 # 

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 # 

Methods

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

show :: IPBind l -> String #

showList :: [IPBind l] -> ShowS #

Generic (IPBind l) Source # 

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 # 

Methods

pretty :: IPBind l -> Doc

prettyPrec :: Int -> IPBind l -> Doc

type Rep (IPBind l) Source # 

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 # 
Foldable PatternSynDirection Source # 

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 # 
AppFixity PatternSynDirection Source # 
Eq l => Eq (PatternSynDirection l) Source # 
Data l => Data (PatternSynDirection l) Source # 

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 # 
Show l => Show (PatternSynDirection l) Source # 
Generic (PatternSynDirection l) Source # 

Associated Types

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

type Rep (PatternSynDirection l) Source # 
type Rep (PatternSynDirection l) = D1 (MetaData "PatternSynDirection" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.18.2-9JBcaPyJNc23w8BJK1Oi0T" False) ((:+:) (C1 (MetaCons "Unidirectional" PrefixI False) U1) ((:+:) (C1 (MetaCons "ImplicitBidirectional" PrefixI False) U1) (C1 (MetaCons "ExplicitBidirectional" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) (S1 (MetaSel (Nothing 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 # 

Methods

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

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

Foldable InjectivityInfo Source # 

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 # 

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 # 

Methods

ann :: InjectivityInfo l -> l Source #

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

ExactP InjectivityInfo Source # 
Eq l => Eq (InjectivityInfo l) Source # 
Data l => Data (InjectivityInfo l) Source # 

Methods

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

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

toConstr :: InjectivityInfo l -> Constr #

dataTypeOf :: InjectivityInfo l -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (InjectivityInfo l) Source # 
Show l => Show (InjectivityInfo l) Source # 
Generic (InjectivityInfo l) Source # 

Associated Types

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

Pretty (InjectivityInfo l) Source # 

Methods

pretty :: InjectivityInfo l -> Doc

prettyPrec :: Int -> InjectivityInfo l -> Doc

type Rep (InjectivityInfo l) Source # 
type Rep (InjectivityInfo l) = D1 (MetaData "InjectivityInfo" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.18.2-9JBcaPyJNc23w8BJK1Oi0T" False) (C1 (MetaCons "InjectivityInfo" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Name l))) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Name l])))))

data ResultSig l Source #

Constructors

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

Instances

Functor ResultSig Source # 

Methods

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

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

Foldable ResultSig Source # 

Methods

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

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

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

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

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

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

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

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

toList :: ResultSig a -> [a] #

null :: ResultSig a -> Bool #

length :: ResultSig a -> Int #

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

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

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

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

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

Traversable ResultSig Source # 

Methods

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

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

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

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

Annotated ResultSig Source # 

Methods

ann :: ResultSig l -> l Source #

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

ExactP ResultSig Source # 

Methods

exactP :: ResultSig SrcSpanInfo -> EP ()

Eq l => Eq (ResultSig l) Source # 

Methods

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

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

Data l => Data (ResultSig l) Source # 

Methods

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

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

toConstr :: ResultSig l -> Constr #

dataTypeOf :: ResultSig l -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (ResultSig l) Source # 
Show l => Show (ResultSig l) Source # 
Generic (ResultSig l) Source # 

Associated Types

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

Methods

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

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

Pretty (ResultSig l) Source # 

Methods

pretty :: ResultSig l -> Doc

prettyPrec :: Int -> ResultSig l -> Doc

type Rep (ResultSig l) Source # 

Type classes and instances

data ClassDecl l Source #

Declarations inside a class declaration.

Constructors

ClsDecl l (Decl l)

ordinary declaration

ClsDataFam l (Maybe (Context l)) (DeclHead l) (Maybe (ResultSig l))

declaration of an associated data type

ClsTyFam l (DeclHead l) (Maybe (ResultSig l)) (Maybe (InjectivityInfo l))

declaration of an associated type synonym

ClsTyDef l (TypeEqn l)

default choice for an associated type synonym

ClsDefSig l (Name l) (Type l)

default signature

Instances

Functor ClassDecl Source # 

Methods

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

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

Foldable ClassDecl Source # 

Methods

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

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

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

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

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

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

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

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

toList :: ClassDecl a -> [a] #

null :: ClassDecl a -> Bool #

length :: ClassDecl a -> Int #

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

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

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

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

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

Traversable ClassDecl Source # 

Methods

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

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

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

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

Annotated ClassDecl Source # 

Methods

ann :: ClassDecl l -> l Source #

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

AppFixity ClassDecl Source # 
ExactP ClassDecl Source # 

Methods

exactP :: ClassDecl SrcSpanInfo -> EP ()

Eq l => Eq (ClassDecl l) Source # 

Methods

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

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

Data l => Data (ClassDecl l) Source # 

Methods

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

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

toConstr :: ClassDecl l -> Constr #

dataTypeOf :: ClassDecl l -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (ClassDecl l) Source # 
Show l => Show (ClassDecl l) Source # 
Generic (ClassDecl l) Source # 

Associated Types

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

Methods

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

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

Pretty (ClassDecl l) Source # 

Methods

pretty :: ClassDecl l -> Doc

prettyPrec :: Int -> ClassDecl l -> Doc

type Rep (ClassDecl l) Source # 
type Rep (ClassDecl l) = D1 (MetaData "ClassDecl" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.18.2-9JBcaPyJNc23w8BJK1Oi0T" False) ((:+:) ((:+:) (C1 (MetaCons "ClsDecl" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Decl l))))) (C1 (MetaCons "ClsDataFam" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Context l))))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DeclHead l))) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (ResultSig l)))))))) ((:+:) (C1 (MetaCons "ClsTyFam" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DeclHead l)))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (ResultSig l)))) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (InjectivityInfo l))))))) ((:+:) (C1 (MetaCons "ClsTyDef" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (TypeEqn l))))) (C1 (MetaCons "ClsDefSig" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Name l))) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)))))))))

data InstDecl l Source #

Declarations inside an instance declaration.

Constructors

InsDecl l (Decl l)

ordinary declaration

InsType l (Type l) (Type l)

an associated type definition

InsData l (DataOrNew l) (Type l) [QualConDecl l] (Maybe (Deriving l))

an associated data type implementation

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

an associated data type implemented using GADT style

Instances

Functor InstDecl Source # 

Methods

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

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

Foldable InstDecl Source # 

Methods

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

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

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

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

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

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

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

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

toList :: InstDecl a -> [a] #

null :: InstDecl a -> Bool #

length :: InstDecl a -> Int #

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

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

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

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

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

Traversable InstDecl Source # 

Methods

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

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

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

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

Annotated InstDecl Source # 

Methods

ann :: InstDecl l -> l Source #

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

AppFixity InstDecl Source # 
ExactP InstDecl Source # 

Methods

exactP :: InstDecl SrcSpanInfo -> EP ()

Eq l => Eq (InstDecl l) Source # 

Methods

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

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

Data l => Data (InstDecl l) Source # 

Methods

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

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

toConstr :: InstDecl l -> Constr #

dataTypeOf :: InstDecl l -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (InstDecl l) Source # 

Methods

compare :: InstDecl l -> InstDecl l -> Ordering #

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

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

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

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

max :: InstDecl l -> InstDecl l -> InstDecl l #

min :: InstDecl l -> InstDecl l -> InstDecl l #

Show l => Show (InstDecl l) Source # 

Methods

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

show :: InstDecl l -> String #

showList :: [InstDecl l] -> ShowS #

Generic (InstDecl l) Source # 

Associated Types

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

Methods

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

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

Pretty (InstDecl l) Source # 

Methods

pretty :: InstDecl l -> Doc

prettyPrec :: Int -> InstDecl l -> Doc

type Rep (InstDecl l) Source # 
type Rep (InstDecl l) = D1 (MetaData "InstDecl" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.18.2-9JBcaPyJNc23w8BJK1Oi0T" False) ((:+:) ((:+:) (C1 (MetaCons "InsDecl" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Decl l))))) (C1 (MetaCons "InsType" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l))) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l))))))) ((:+:) (C1 (MetaCons "InsData" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DataOrNew l)))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [QualConDecl l])) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Deriving l)))))))) (C1 (MetaCons "InsGData" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DataOrNew l))) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l))))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Kind l)))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [GadtDecl l])) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Deriving l))))))))))

data Deriving l Source #

A deriving clause following a data type declaration.

Constructors

Deriving l [InstRule l] 

Instances

Functor Deriving Source # 

Methods

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

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

Foldable Deriving Source # 

Methods

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

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

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

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

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

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

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

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

toList :: Deriving a -> [a] #

null :: Deriving a -> Bool #

length :: Deriving a -> Int #

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

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

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

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

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

Traversable Deriving Source # 

Methods

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

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

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

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

Annotated Deriving Source # 

Methods

ann :: Deriving l -> l Source #

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

ExactP Deriving Source # 

Methods

exactP :: Deriving SrcSpanInfo -> EP ()

Eq l => Eq (Deriving l) Source # 

Methods

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

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

Data l => Data (Deriving l) Source # 

Methods

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

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

toConstr :: Deriving l -> Constr #

dataTypeOf :: Deriving l -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (Deriving l) Source # 

Methods

compare :: Deriving l -> Deriving l -> Ordering #

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

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

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

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

max :: Deriving l -> Deriving l -> Deriving l #

min :: Deriving l -> Deriving l -> Deriving l #

Show l => Show (Deriving l) Source # 

Methods

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

show :: Deriving l -> String #

showList :: [Deriving l] -> ShowS #

Generic (Deriving l) Source # 

Associated Types

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

Methods

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

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

Pretty (Deriving l) Source # 

Methods

pretty :: Deriving l -> Doc

prettyPrec :: Int -> Deriving l -> Doc

type Rep (Deriving l) Source # 
type Rep (Deriving l) = D1 (MetaData "Deriving" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.18.2-9JBcaPyJNc23w8BJK1Oi0T" False) (C1 (MetaCons "Deriving" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [InstRule l]))))

Data type declarations

data DataOrNew l Source #

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

Constructors

DataType l 
NewType l 

Instances

Functor DataOrNew Source # 

Methods

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

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

Foldable DataOrNew Source # 

Methods

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

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

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

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

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

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

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

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

toList :: DataOrNew a -> [a] #

null :: DataOrNew a -> Bool #

length :: DataOrNew a -> Int #

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

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

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

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

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

Traversable DataOrNew Source # 

Methods

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

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

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

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

Annotated DataOrNew Source # 

Methods

ann :: DataOrNew l -> l Source #

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

ExactP DataOrNew Source # 

Methods

exactP :: DataOrNew SrcSpanInfo -> EP ()

Eq l => Eq (DataOrNew l) Source # 

Methods

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

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

Data l => Data (DataOrNew l) Source # 

Methods

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

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

toConstr :: DataOrNew l -> Constr #

dataTypeOf :: DataOrNew l -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (DataOrNew l) Source # 
Show l => Show (DataOrNew l) Source # 
Generic (DataOrNew l) Source # 

Associated Types

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

Methods

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

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

Pretty (DataOrNew l) Source # 

Methods

pretty :: DataOrNew l -> Doc

prettyPrec :: Int -> DataOrNew l -> Doc

type Rep (DataOrNew l) Source # 
type Rep (DataOrNew l) = D1 (MetaData "DataOrNew" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.18.2-9JBcaPyJNc23w8BJK1Oi0T" False) ((:+:) (C1 (MetaCons "DataType" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l))) (C1 (MetaCons "NewType" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l))))

data ConDecl l Source #

Declaration of an ordinary data constructor.

Constructors

ConDecl l (Name l) [Type l]

ordinary data constructor

InfixConDecl l (Type l) (Name l) (Type l)

infix data constructor

RecDecl l (Name l) [FieldDecl l]

record constructor

Instances

Functor ConDecl Source # 

Methods

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

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

Foldable ConDecl Source # 

Methods

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

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

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

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

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

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

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

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

toList :: ConDecl a -> [a] #

null :: ConDecl a -> Bool #

length :: ConDecl a -> Int #

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

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

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

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

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

Traversable ConDecl Source # 

Methods

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

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

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

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

Annotated ConDecl Source # 

Methods

ann :: ConDecl l -> l Source #

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

ExactP ConDecl Source # 

Methods

exactP :: ConDecl SrcSpanInfo -> EP ()

Eq l => Eq (ConDecl l) Source # 

Methods

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

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

Data l => Data (ConDecl l) Source # 

Methods

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

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

toConstr :: ConDecl l -> Constr #

dataTypeOf :: ConDecl l -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord l => Ord (ConDecl l) Source # 

Methods

compare :: ConDecl l -> ConDecl l -> Ordering #

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

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

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

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

max :: ConDecl l -> ConDecl l -> ConDecl l #

min :: ConDecl l -> ConDecl l -> ConDecl l #

Show l => Show (ConDecl l) Source # 

Methods

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

show :: ConDecl l -> String #

showList :: [ConDecl l] -> ShowS #

Generic (ConDecl l) Source # 

Associated Types

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

Methods

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

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

Pretty (ConDecl l) Source # 

Methods

pretty :: ConDecl l -> Doc

prettyPrec :: Int -> ConDecl l -> Doc

type Rep (ConDecl l) Source # 

data FieldDecl l Source #

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

Constructors

FieldDecl l [Name l] (Type l) 

Instances

Functor FieldDecl Source # 

Methods

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

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

Foldable FieldDecl Source # 

Methods

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

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

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

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

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

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

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

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

toList :: FieldDecl a -> [a] #

null :: FieldDecl a -> Bool #

length :: FieldDecl a -> Int #

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