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

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

Language.Haskell.Exts.Syntax

Contents

Description

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

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

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

Synopsis

Modules

data Module l Source #

A complete Haskell source module.

Constructors

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

an ordinary Haskell module

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

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

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

a hybrid module combining an XML document with an ordinary module

Instances
Functor Module Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Foldable Module Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

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

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

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

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

toList :: Module a -> [a] #

null :: Module a -> Bool #

length :: Module a -> Int #

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

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

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

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

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

Traversable Module Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

Annotated Module Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Module l -> l Source #

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

AppFixity Module Source # 
Instance details

Defined in Language.Haskell.Exts.Fixity

ExactP Module Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Module SrcSpanInfo -> EP ()

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

toConstr :: Module l -> Constr #

dataTypeOf :: Module l -> DataType #

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

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

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

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

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

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

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

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

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

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

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

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

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

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

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

show :: Module l -> String #

showList :: [Module l] -> ShowS #

Generic (Module l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

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

Methods

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

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

Pretty (Module pos) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Module pos -> Doc

prettyPrec :: Int -> Module pos -> Doc

Parseable (Module SrcSpanInfo) Source # 
Instance details

Defined in Language.Haskell.Exts.Parser

type Rep (Module l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

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

data ModuleHead l Source #

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

Constructors

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Foldable ModuleHead Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

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

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

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

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

toList :: ModuleHead a -> [a] #

null :: ModuleHead a -> Bool #

length :: ModuleHead a -> Int #

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

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

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

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

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

Traversable ModuleHead Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

Annotated ModuleHead Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: ModuleHead l -> l Source #

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

ExactP ModuleHead Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: ModuleHead SrcSpanInfo -> EP ()

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

toConstr :: ModuleHead l -> Constr #

dataTypeOf :: ModuleHead l -> DataType #

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

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

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

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

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

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

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

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

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

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

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

Defined in Language.Haskell.Exts.Syntax

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

Defined in Language.Haskell.Exts.Syntax

Generic (ModuleHead l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

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

Methods

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

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

Pretty (ModuleHead l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: ModuleHead l -> Doc

prettyPrec :: Int -> ModuleHead l -> Doc

type Rep (ModuleHead l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data WarningText l Source #

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

Constructors

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Foldable WarningText Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

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

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

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

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

toList :: WarningText a -> [a] #

null :: WarningText a -> Bool #

length :: WarningText a -> Int #

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

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

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

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

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

Traversable WarningText Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

Annotated WarningText Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: WarningText l -> l Source #

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

ExactP WarningText Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: WarningText SrcSpanInfo -> EP ()

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

Defined in Language.Haskell.Exts.Syntax

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

toConstr :: WarningText l -> Constr #

dataTypeOf :: WarningText l -> DataType #

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

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

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

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

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

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

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

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

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

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

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

Defined in Language.Haskell.Exts.Syntax

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

Defined in Language.Haskell.Exts.Syntax

Generic (WarningText l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

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

Methods

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

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

type Rep (WarningText l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data ExportSpecList l Source #

An explicit export specification.

Constructors

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Foldable ExportSpecList Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

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

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

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

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

toList :: ExportSpecList a -> [a] #

null :: ExportSpecList a -> Bool #

length :: ExportSpecList a -> Int #

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

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

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

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

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

Traversable ExportSpecList Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

Annotated ExportSpecList Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: ExportSpecList l -> l Source #

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

ExactP ExportSpecList Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: ExportSpecList SrcSpanInfo -> EP ()

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

Defined in Language.Haskell.Exts.Syntax

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

toConstr :: ExportSpecList l -> Constr #

dataTypeOf :: ExportSpecList l -> DataType #

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

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

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

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

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

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

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

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

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

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

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

Defined in Language.Haskell.Exts.Syntax

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

Defined in Language.Haskell.Exts.Syntax

Generic (ExportSpecList l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

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

Pretty (ExportSpecList l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: ExportSpecList l -> Doc

prettyPrec :: Int -> ExportSpecList l -> Doc

type Rep (ExportSpecList l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

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

data ExportSpec l Source #

An item in a module's export specification.

Constructors

EVar l (QName l)

variable.

EAbs l (Namespace l) (QName l)

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

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

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

EModuleContents l (ModuleName l)

module M: re-export a module.

Instances
Functor ExportSpec Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Foldable ExportSpec Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

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

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

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

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

toList :: ExportSpec a -> [a] #

null :: ExportSpec a -> Bool #

length :: ExportSpec a -> Int #

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

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

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

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

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

Traversable ExportSpec Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

Annotated ExportSpec Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: ExportSpec l -> l Source #

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

ExactP ExportSpec Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: ExportSpec SrcSpanInfo -> EP ()

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

toConstr :: ExportSpec l -> Constr #

dataTypeOf :: ExportSpec l -> DataType #

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

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

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

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

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

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

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

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

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

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

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

Defined in Language.Haskell.Exts.Syntax

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

Defined in Language.Haskell.Exts.Syntax

Generic (ExportSpec l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

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

Methods

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

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

Pretty (ExportSpec l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: ExportSpec l -> Doc

prettyPrec :: Int -> ExportSpec l -> Doc

type Rep (ExportSpec l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

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

data EWildcard l Source #

Indicates the position of the wildcard in an export list

Constructors

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Foldable EWildcard Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

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

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

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

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

toList :: EWildcard a -> [a] #

null :: EWildcard a -> Bool #

length :: EWildcard a -> Int #

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

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

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

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

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

Traversable EWildcard Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

Annotated EWildcard Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: EWildcard l -> l Source #

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

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

toConstr :: EWildcard l -> Constr #

dataTypeOf :: EWildcard l -> DataType #

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

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

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

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

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

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

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

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

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

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

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

Defined in Language.Haskell.Exts.Syntax

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

Defined in Language.Haskell.Exts.Syntax

Generic (EWildcard l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

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

Methods

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

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

type Rep (EWildcard l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data ImportDecl l Source #

An import declaration.

Constructors

ImportDecl 

Fields

Instances
Functor ImportDecl Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Foldable ImportDecl Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

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

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

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

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

toList :: ImportDecl a -> [a] #

null :: ImportDecl a -> Bool #

length :: ImportDecl a -> Int #

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

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

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

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

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

Traversable ImportDecl Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

Annotated ImportDecl Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: ImportDecl l -> l Source #

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

ExactP ImportDecl Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: ImportDecl SrcSpanInfo -> EP ()

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

toConstr :: ImportDecl l -> Constr #

dataTypeOf :: ImportDecl l -> DataType #

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

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

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

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

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

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

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

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

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

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

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

Defined in Language.Haskell.Exts.Syntax

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

Defined in Language.Haskell.Exts.Syntax

Generic (ImportDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

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

Methods

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

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

Pretty (ImportDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: ImportDecl l -> Doc

prettyPrec :: Int -> ImportDecl l -> Doc

Parseable (ImportDecl SrcSpanInfo) Source # 
Instance details

Defined in Language.Haskell.Exts.Parser

type Rep (ImportDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data ImportSpecList l Source #

An explicit import specification list.

Constructors

ImportSpecList l Bool [ImportSpec l]

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

Instances
Functor ImportSpecList Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Foldable ImportSpecList Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

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

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

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

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

toList :: ImportSpecList a -> [a] #

null :: ImportSpecList a -> Bool #

length :: ImportSpecList a -> Int #

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

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

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

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

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

Traversable ImportSpecList Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

Annotated ImportSpecList Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: ImportSpecList l -> l Source #

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

ExactP ImportSpecList Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: ImportSpecList SrcSpanInfo -> EP ()

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

Defined in Language.Haskell.Exts.Syntax

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

toConstr :: ImportSpecList l -> Constr #

dataTypeOf :: ImportSpecList l -> DataType #

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

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

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

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

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

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

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

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

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

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

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

Defined in Language.Haskell.Exts.Syntax

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

Defined in Language.Haskell.Exts.Syntax

Generic (ImportSpecList l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

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

Pretty (ImportSpecList l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: ImportSpecList l -> Doc

prettyPrec :: Int -> ImportSpecList l -> Doc

type Rep (ImportSpecList l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data ImportSpec l Source #

An import specification, representing a single explicit item imported (or hidden) from a module.

Constructors

IVar l (Name l)

variable

IAbs l (Namespace l) (Name l)

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

IThingAll l (Name l)

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

IThingWith l (Name l) [CName l]

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

Instances
Functor ImportSpec Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Foldable ImportSpec Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

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

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

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

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

toList :: ImportSpec a -> [a] #

null :: ImportSpec a -> Bool #

length :: ImportSpec a -> Int #

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

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

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

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

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

Traversable ImportSpec Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

Annotated ImportSpec Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: ImportSpec l -> l Source #

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

ExactP ImportSpec Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: ImportSpec SrcSpanInfo -> EP ()

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

toConstr :: ImportSpec l -> Constr #

dataTypeOf :: ImportSpec l -> DataType #

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

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

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

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

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

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

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

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

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

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

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

Defined in Language.Haskell.Exts.Syntax

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

Defined in Language.Haskell.Exts.Syntax

Generic (ImportSpec l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

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

Methods

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

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

Pretty (ImportSpec l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: ImportSpec l -> Doc

prettyPrec :: Int -> ImportSpec l -> Doc

type Rep (ImportSpec l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data Assoc l Source #

Associativity of an operator.

Constructors

AssocNone l

non-associative operator (declared with infix)

AssocLeft l

left-associative operator (declared with infixl).

AssocRight l

right-associative operator (declared with infixr)

Instances
Functor Assoc Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Foldable Assoc Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

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

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

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

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

toList :: Assoc a -> [a] #

null :: Assoc a -> Bool #

length :: Assoc a -> Int #

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

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

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

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

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

Traversable Assoc Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

Annotated Assoc Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Assoc l -> l Source #

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

ExactP Assoc Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Assoc SrcSpanInfo -> EP ()

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

toConstr :: Assoc l -> Constr #

dataTypeOf :: Assoc l -> DataType #

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

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

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

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

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

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

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

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

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

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

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

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

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

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

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

show :: Assoc l -> String #

showList :: [Assoc l] -> ShowS #

Generic (Assoc l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

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

Methods

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

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

Pretty (Assoc l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Assoc l -> Doc

prettyPrec :: Int -> Assoc l -> Doc

type Rep (Assoc l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

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

data Namespace l Source #

Namespaces for imports/exports.

Instances
Functor Namespace Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Foldable Namespace Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

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

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

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

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

toList :: Namespace a -> [a] #

null :: Namespace a -> Bool #

length :: Namespace a -> Int #

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

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

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

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

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

Traversable Namespace Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

Annotated Namespace Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Namespace l -> l Source #

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

ExactP Namespace Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Namespace SrcSpanInfo -> EP ()

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

toConstr :: Namespace l -> Constr #

dataTypeOf :: Namespace l -> DataType #

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

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

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

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

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

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

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

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

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

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

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

Defined in Language.Haskell.Exts.Syntax

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

Defined in Language.Haskell.Exts.Syntax

Generic (Namespace l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

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

Methods

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

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

Pretty (Namespace l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Namespace l -> Doc

prettyPrec :: Int -> Namespace l -> Doc

type Rep (Namespace l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

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

Declarations

data Decl l Source #

A top-level declaration.

Constructors

TypeDecl l (DeclHead l) (Type l)

A type declaration

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

A type family declaration

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

A closed type family declaration

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

A data OR newtype declaration

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

A data OR newtype declaration, GADT style

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

A data family declaration

TypeInsDecl l (Type l) (Type l)

A type family instance declaration

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

A data family instance declaration

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

A data family instance declaration, GADT style

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

A declaration of a type class

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

An declaration of a type class instance

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

A standalone deriving declaration

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

A declaration of operator fixity

DefaultDecl l [Type l]

A declaration of default types

SpliceDecl l (Exp l)

A Template Haskell splicing declaration

TSpliceDecl l (Exp l)

A typed Template Haskell splicing declaration

TypeSig l [Name l] (Type l)

A type signature declaration

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

A pattern synonym signature declation

FunBind l [Match l]

A set of function binding clauses

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

A pattern binding

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

A pattern synonym binding

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

A foreign import declaration

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

A foreign export declaration

RulePragmaDecl l [Rule l]

A RULES pragma

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

A DEPRECATED pragma

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

A WARNING pragma

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

An INLINE pragma

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

An INLINE CONLIKE pragma

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

A SPECIALISE pragma

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

A SPECIALISE INLINE pragma

InstSig l (InstRule l)

A SPECIALISE instance pragma

AnnPragma l (Annotation l)

An ANN pragma

MinimalPragma l (Maybe (BooleanFormula l))

A MINIMAL pragma

RoleAnnotDecl l (QName l) [Role l]

A role annotation

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

A COMPLETE pragma

Instances
Functor Decl Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Foldable Decl Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

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

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

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

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

toList :: Decl a -> [a] #

null :: Decl a -> Bool #

length :: Decl a -> Int #

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

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

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

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

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

Traversable Decl Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

Annotated Decl Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Decl l -> l Source #

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

AppFixity Decl Source # 
Instance details

Defined in Language.Haskell.Exts.Fixity

ExactP Decl Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Decl SrcSpanInfo -> EP ()

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

toConstr :: Decl l -> Constr #

dataTypeOf :: Decl l -> DataType #

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

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

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

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

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

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

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

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

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

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

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

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

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

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

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

show :: Decl l -> String #

showList :: [Decl l] -> ShowS #

Generic (Decl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

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

Methods

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

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

Pretty (Decl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Decl l -> Doc

prettyPrec :: Int -> Decl l -> Doc

Parseable (Decl SrcSpanInfo) Source # 
Instance details

Defined in Language.Haskell.Exts.Parser

type Rep (Decl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

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

data DeclHead l Source #

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

class C a b is represented as

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

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

class (a :< b) c is represented as

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

Constructors

DHead l (Name l)

type or class name

DHInfix l (TyVarBind l) (Name l)

infix application of the type/class name to the left operand

DHParen l (DeclHead l)

parenthesized declaration head

DHApp l (DeclHead l) (TyVarBind l)

application to one more type variable

Instances
Functor DeclHead Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Foldable DeclHead Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

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

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

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

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

toList :: DeclHead a -> [a] #

null :: DeclHead a -> Bool #

length :: DeclHead a -> Int #

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

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

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

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

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

Traversable DeclHead Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

Annotated DeclHead Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: DeclHead l -> l Source #

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

ExactP DeclHead Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: DeclHead SrcSpanInfo -> EP ()

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

toConstr :: DeclHead l -> Constr #

dataTypeOf :: DeclHead l -> DataType #

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

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

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

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

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

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

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

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

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

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

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

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

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

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

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

show :: DeclHead l -> String #

showList :: [DeclHead l] -> ShowS #

Generic (DeclHead l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

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

Methods

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

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

Pretty (DeclHead l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: DeclHead l -> Doc

prettyPrec :: Int -> DeclHead l -> Doc

type Rep (DeclHead l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data InstRule l Source #

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

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

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

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

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

Constructors

IRule l (Maybe [TyVarBind l]) (Maybe (Context l)) (InstHead l) 
IParen l (InstRule l) 
Instances
Functor InstRule Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Foldable InstRule Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

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

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

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

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

toList :: InstRule a -> [a] #

null :: InstRule a -> Bool #

length :: InstRule a -> Int #

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

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

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

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

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

Traversable InstRule Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

Annotated InstRule Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: InstRule l -> l Source #

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

ExactP InstRule Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: InstRule SrcSpanInfo -> EP ()

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

toConstr :: InstRule l -> Constr #

dataTypeOf :: InstRule l -> DataType #

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

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

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

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

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

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

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

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

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

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

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

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

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

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

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

show :: InstRule l -> String #

showList :: [InstRule l] -> ShowS #

Generic (InstRule l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

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

Methods

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

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

Pretty (InstRule l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: InstRule l -> Doc

prettyPrec :: Int -> InstRule l -> Doc

type Rep (InstRule l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data InstHead l Source #

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

The structure of InstHead follows one of DeclHead.

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

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

Constructors

IHCon l (QName l)

type or class name

IHInfix l (Type l) (QName l)

infix application of the type/class name to the left operand

IHParen l (InstHead l)

parenthesized instance head

IHApp l (InstHead l) (Type l)

application to one more type

Instances
Functor InstHead Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Foldable InstHead Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

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

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

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

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

toList :: InstHead a -> [a] #

null :: InstHead a -> Bool #

length :: InstHead a -> Int #

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

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

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

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

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

Traversable InstHead Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

Annotated InstHead Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: InstHead l -> l Source #

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

ExactP InstHead Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: InstHead SrcSpanInfo -> EP ()

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

toConstr :: InstHead l -> Constr #

dataTypeOf :: InstHead l -> DataType #

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

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

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

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

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

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

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

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

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

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

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

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

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

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

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

show :: InstHead l -> String #

showList :: [InstHead l] -> ShowS #

Generic (InstHead l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

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

Methods

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

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

Pretty (InstHead l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: InstHead l -> Doc

prettyPrec :: Int -> InstHead l -> Doc

type Rep (InstHead l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data Binds l Source #

A binding group inside a let or where clause.

Constructors

BDecls l [Decl l]

An ordinary binding group

IPBinds l [IPBind l]

A binding group for implicit parameters

Instances
Functor Binds Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Foldable Binds Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

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

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

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

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

toList :: Binds a -> [a] #

null :: Binds a -> Bool #

length :: Binds a -> Int #

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

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

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

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

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

Traversable Binds Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

Annotated Binds Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Binds l -> l Source #

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

AppFixity Binds Source # 
Instance details

Defined in Language.Haskell.Exts.Fixity

ExactP Binds Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Binds SrcSpanInfo -> EP ()

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

toConstr :: Binds l -> Constr #

dataTypeOf :: Binds l -> DataType #

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

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

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

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

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

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

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

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

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

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

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

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

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

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

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

show :: Binds l -> String #

showList :: [Binds l] -> ShowS #

Generic (Binds l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

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

Methods

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

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

type Rep (Binds l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data IPBind l Source #

A binding of an implicit parameter.

Constructors

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

Foldable IPBind Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

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

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

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

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

toList :: IPBind a -> [a] #

null :: IPBind a -> Bool #

length :: IPBind a -> Int #

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

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

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

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

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

Traversable IPBind Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

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

Annotated IPBind Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: IPBind l -> l Source #

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

AppFixity IPBind Source # 
Instance details

Defined in Language.Haskell.Exts.Fixity

ExactP IPBind Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: IPBind SrcSpanInfo -> EP ()

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

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

Defined in Language.Haskell.Exts.Syntax

Methods

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

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

toConstr :: IPBind l -> Constr #

dataTypeOf :: IPBind l -> DataType #

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

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

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

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

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

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

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

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

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IPBind l -> m (IPBind l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IPBind l -> m (IPBind l) #

Ord l => Ord (IPBind l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: IPBind l -> IPBind l -> Ordering #

(<) :: IPBind l -> IPBind l -> Bool #

(<=) :: IPBind l -> IPBind l -> Bool #

(>) :: IPBind l -> IPBind l -> Bool #

(>=) :: IPBind l -> IPBind l -> Bool #

max :: IPBind l -> IPBind l -> IPBind l #

min :: IPBind l -> IPBind l -> IPBind l #

Show l => Show (IPBind l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> IPBind l -> ShowS #

show :: IPBind l -> String #

showList :: [IPBind l] -> ShowS #

Generic (IPBind l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (IPBind l) :: Type -> Type #

Methods

from :: IPBind l -> Rep (IPBind l) x #

to :: Rep (IPBind l) x -> IPBind l #

Pretty (IPBind l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: IPBind l -> Doc

prettyPrec :: Int -> IPBind l -> Doc

type Rep (IPBind l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data PatternSynDirection l Source #

Constructors

Unidirectional

A unidirectional pattern synonym with "<-"

ImplicitBidirectional

A bidirectional pattern synonym with "="

ExplicitBidirectional l [Decl l]

A birectional pattern synonym with the construction specified.

Instances
Functor PatternSynDirection Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Foldable PatternSynDirection Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => PatternSynDirection m -> m #

foldMap :: Monoid m => (a -> m) -> PatternSynDirection a -> m #

foldr :: (a -> b -> b) -> b -> PatternSynDirection a -> b #

foldr' :: (a -> b -> b) -> b -> PatternSynDirection a -> b #

foldl :: (b -> a -> b) -> b -> PatternSynDirection a -> b #

foldl' :: (b -> a -> b) -> b -> PatternSynDirection a -> b #

foldr1 :: (a -> a -> a) -> PatternSynDirection a -> a #

foldl1 :: (a -> a -> a) -> PatternSynDirection a -> a #

toList :: PatternSynDirection a -> [a] #

null :: PatternSynDirection a -> Bool #

length :: PatternSynDirection a -> Int #

elem :: Eq a => a -> PatternSynDirection a -> Bool #

maximum :: Ord a => PatternSynDirection a -> a #

minimum :: Ord a => PatternSynDirection a -> a #

sum :: Num a => PatternSynDirection a -> a #

product :: Num a => PatternSynDirection a -> a #

Traversable PatternSynDirection Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

AppFixity PatternSynDirection Source # 
Instance details

Defined in Language.Haskell.Exts.Fixity

Eq l => Eq (PatternSynDirection l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Data l => Data (PatternSynDirection l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PatternSynDirection l -> c (PatternSynDirection l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (PatternSynDirection l) #

toConstr :: PatternSynDirection l -> Constr #

dataTypeOf :: PatternSynDirection l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (PatternSynDirection l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (PatternSynDirection l)) #

gmapT :: (forall b. Data b => b -> b) -> PatternSynDirection l -> PatternSynDirection l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PatternSynDirection l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PatternSynDirection l -> r #

gmapQ :: (forall d. Data d => d -> u) -> PatternSynDirection l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> PatternSynDirection l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> PatternSynDirection l -> m (PatternSynDirection l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PatternSynDirection l -> m (PatternSynDirection l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PatternSynDirection l -> m (PatternSynDirection l) #

Ord l => Ord (PatternSynDirection l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Show l => Show (PatternSynDirection l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Generic (PatternSynDirection l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (PatternSynDirection l) :: Type -> Type #

type Rep (PatternSynDirection l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (PatternSynDirection l) = D1 (MetaData "PatternSynDirection" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-Z8xb2tkymYIClPofvAOw3" False) (C1 (MetaCons "Unidirectional" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "ImplicitBidirectional" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "ExplicitBidirectional" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Decl l]))))

data InjectivityInfo l Source #

Injectivity info for injective type families

Constructors

InjectivityInfo l (Name l) [Name l] 
Instances
Functor InjectivityInfo Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> InjectivityInfo a -> InjectivityInfo b #

(<$) :: a -> InjectivityInfo b -> InjectivityInfo a #

Foldable InjectivityInfo Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => InjectivityInfo m -> m #

foldMap :: Monoid m => (a -> m) -> InjectivityInfo a -> m #

foldr :: (a -> b -> b) -> b -> InjectivityInfo a -> b #

foldr' :: (a -> b -> b) -> b -> InjectivityInfo a -> b #

foldl :: (b -> a -> b) -> b -> InjectivityInfo a -> b #

foldl' :: (b -> a -> b) -> b -> InjectivityInfo a -> b #

foldr1 :: (a -> a -> a) -> InjectivityInfo a -> a #

foldl1 :: (a -> a -> a) -> InjectivityInfo a -> a #

toList :: InjectivityInfo a -> [a] #

null :: InjectivityInfo a -> Bool #

length :: InjectivityInfo a -> Int #

elem :: Eq a => a -> InjectivityInfo a -> Bool #

maximum :: Ord a => InjectivityInfo a -> a #

minimum :: Ord a => InjectivityInfo a -> a #

sum :: Num a => InjectivityInfo a -> a #

product :: Num a => InjectivityInfo a -> a #

Traversable InjectivityInfo Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> InjectivityInfo a -> f (InjectivityInfo b) #

sequenceA :: Applicative f => InjectivityInfo (f a) -> f (InjectivityInfo a) #

mapM :: Monad m => (a -> m b) -> InjectivityInfo a -> m (InjectivityInfo b) #

sequence :: Monad m => InjectivityInfo (m a) -> m (InjectivityInfo a) #

Annotated InjectivityInfo Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: InjectivityInfo l -> l Source #

amap :: (l -> l) -> InjectivityInfo l -> InjectivityInfo l Source #

ExactP InjectivityInfo Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Eq l => Eq (InjectivityInfo l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Data l => Data (InjectivityInfo l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InjectivityInfo l -> c (InjectivityInfo l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (InjectivityInfo l) #

toConstr :: InjectivityInfo l -> 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 # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Show l => Show (InjectivityInfo l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Generic (InjectivityInfo l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (InjectivityInfo l) :: Type -> Type #

Pretty (InjectivityInfo l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: InjectivityInfo l -> Doc

prettyPrec :: Int -> InjectivityInfo l -> Doc

type Rep (InjectivityInfo l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (InjectivityInfo l) = D1 (MetaData "InjectivityInfo" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-Z8xb2tkymYIClPofvAOw3" False) (C1 (MetaCons "InjectivityInfo" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Name l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Name l]))))

data ResultSig l Source #

Constructors

KindSig l (Kind l) 
TyVarSig l (TyVarBind l) 
Instances
Functor ResultSig Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> ResultSig a -> ResultSig b #

(<$) :: a -> ResultSig b -> ResultSig a #

Foldable ResultSig Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

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 # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> ResultSig a -> f (ResultSig b) #

sequenceA :: Applicative f => ResultSig (f a) -> f (ResultSig a) #

mapM :: Monad m => (a -> m b) -> ResultSig a -> m (ResultSig b) #

sequence :: Monad m => ResultSig (m a) -> m (ResultSig a) #

Annotated ResultSig Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: ResultSig l -> l Source #

amap :: (l -> l) -> ResultSig l -> ResultSig l Source #

ExactP ResultSig Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: ResultSig SrcSpanInfo -> EP ()

Eq l => Eq (ResultSig l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: ResultSig l -> ResultSig l -> Bool #

(/=) :: ResultSig l -> ResultSig l -> Bool #

Data l => Data (ResultSig l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> 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 # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Show l => Show (ResultSig l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Generic (ResultSig l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (ResultSig l) :: Type -> Type #

Methods

from :: ResultSig l -> Rep (ResultSig l) x #

to :: Rep (ResultSig l) x -> ResultSig l #

Pretty (ResultSig l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: ResultSig l -> Doc

prettyPrec :: Int -> ResultSig l -> Doc

type Rep (ResultSig l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

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 # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> ClassDecl a -> ClassDecl b #

(<$) :: a -> ClassDecl b -> ClassDecl a #

Foldable ClassDecl Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

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 # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> ClassDecl a -> f (ClassDecl b) #

sequenceA :: Applicative f => ClassDecl (f a) -> f (ClassDecl a) #

mapM :: Monad m => (a -> m b) -> ClassDecl a -> m (ClassDecl b) #

sequence :: Monad m => ClassDecl (m a) -> m (ClassDecl a) #

Annotated ClassDecl Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: ClassDecl l -> l Source #

amap :: (l -> l) -> ClassDecl l -> ClassDecl l Source #

AppFixity ClassDecl Source # 
Instance details

Defined in Language.Haskell.Exts.Fixity

ExactP ClassDecl Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: ClassDecl SrcSpanInfo -> EP ()

Eq l => Eq (ClassDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: ClassDecl l -> ClassDecl l -> Bool #

(/=) :: ClassDecl l -> ClassDecl l -> Bool #

Data l => Data (ClassDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> 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 # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Show l => Show (ClassDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Generic (ClassDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (ClassDecl l) :: Type -> Type #

Methods

from :: ClassDecl l -> Rep (ClassDecl l) x #

to :: Rep (ClassDecl l) x -> ClassDecl l #

Pretty (ClassDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: ClassDecl l -> Doc

prettyPrec :: Int -> ClassDecl l -> Doc

type Rep (ClassDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (ClassDecl l) = D1 (MetaData "ClassDecl" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-Z8xb2tkymYIClPofvAOw3" False) ((C1 (MetaCons "ClsDecl" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Decl l))) :+: C1 (MetaCons "ClsDataFam" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Context l)))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DeclHead l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (ResultSig l)))))) :+: (C1 (MetaCons "ClsTyFam" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DeclHead l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (ResultSig l))) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (InjectivityInfo l))))) :+: (C1 (MetaCons "ClsTyDef" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (TypeEqn l))) :+: C1 (MetaCons "ClsDefSig" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Name l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)))))))

data InstDecl l 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] [Deriving l]

an associated data type implementation

InsGData l (DataOrNew l) (Type l) (Maybe (Kind l)) [GadtDecl l] [Deriving l]

an associated data type implemented using GADT style

Instances
Functor InstDecl Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> InstDecl a -> InstDecl b #

(<$) :: a -> InstDecl b -> InstDecl a #

Foldable InstDecl Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

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 # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> InstDecl a -> f (InstDecl b) #

sequenceA :: Applicative f => InstDecl (f a) -> f (InstDecl a) #

mapM :: Monad m => (a -> m b) -> InstDecl a -> m (InstDecl b) #

sequence :: Monad m => InstDecl (m a) -> m (InstDecl a) #

Annotated InstDecl Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: InstDecl l -> l Source #

amap :: (l -> l) -> InstDecl l -> InstDecl l Source #

AppFixity InstDecl Source # 
Instance details

Defined in Language.Haskell.Exts.Fixity

ExactP InstDecl Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: InstDecl SrcSpanInfo -> EP ()

Eq l => Eq (InstDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: InstDecl l -> InstDecl l -> Bool #

(/=) :: InstDecl l -> InstDecl l -> Bool #

Data l => Data (InstDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> 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 # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: InstDecl l -> InstDecl l -> Ordering #

(<) :: InstDecl l -> InstDecl l -> Bool #

(<=) :: InstDecl l -> InstDecl l -> Bool #

(>) :: InstDecl l -> InstDecl l -> Bool #

(>=) :: InstDecl l -> InstDecl l -> Bool #

max :: InstDecl l -> InstDecl l -> InstDecl l #

min :: InstDecl l -> InstDecl l -> InstDecl l #

Show l => Show (InstDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> InstDecl l -> ShowS #

show :: InstDecl l -> String #

showList :: [InstDecl l] -> ShowS #

Generic (InstDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (InstDecl l) :: Type -> Type #

Methods

from :: InstDecl l -> Rep (InstDecl l) x #

to :: Rep (InstDecl l) x -> InstDecl l #

Pretty (InstDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: InstDecl l -> Doc

prettyPrec :: Int -> InstDecl l -> Doc

type Rep (InstDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (InstDecl l) = D1 (MetaData "InstDecl" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-Z8xb2tkymYIClPofvAOw3" False) ((C1 (MetaCons "InsDecl" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Decl l))) :+: C1 (MetaCons "InsType" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l))))) :+: (C1 (MetaCons "InsData" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DataOrNew l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [QualConDecl l]) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Deriving l])))) :+: C1 (MetaCons "InsGData" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DataOrNew l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Kind l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [GadtDecl l]) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Deriving l]))))))

data Deriving l Source #

A deriving clause following a data type declaration.

Constructors

Deriving l (Maybe (DerivStrategy l)) [InstRule l] 
Instances
Functor Deriving Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Deriving a -> Deriving b #

(<$) :: a -> Deriving b -> Deriving a #

Foldable Deriving Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

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 # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> Deriving a -> f (Deriving b) #

sequenceA :: Applicative f => Deriving (f a) -> f (Deriving a) #

mapM :: Monad m => (a -> m b) -> Deriving a -> m (Deriving b) #

sequence :: Monad m => Deriving (m a) -> m (Deriving a) #

Annotated Deriving Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Deriving l -> l Source #

amap :: (l -> l) -> Deriving l -> Deriving l Source #

ExactP Deriving Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Deriving SrcSpanInfo -> EP ()

Eq l => Eq (Deriving l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: Deriving l -> Deriving l -> Bool #

(/=) :: Deriving l -> Deriving l -> Bool #

Data l => Data (Deriving l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> 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 # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: Deriving l -> Deriving l -> Ordering #

(<) :: Deriving l -> Deriving l -> Bool #

(<=) :: Deriving l -> Deriving l -> Bool #

(>) :: Deriving l -> Deriving l -> Bool #

(>=) :: Deriving l -> Deriving l -> Bool #

max :: Deriving l -> Deriving l -> Deriving l #

min :: Deriving l -> Deriving l -> Deriving l #

Show l => Show (Deriving l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> Deriving l -> ShowS #

show :: Deriving l -> String #

showList :: [Deriving l] -> ShowS #

Generic (Deriving l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Deriving l) :: Type -> Type #

Methods

from :: Deriving l -> Rep (Deriving l) x #

to :: Rep (Deriving l) x -> Deriving l #

Pretty (Deriving l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Deriving l -> Doc

prettyPrec :: Int -> Deriving l -> Doc

type Rep (Deriving l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data DerivStrategy l Source #

Which technique the user explicitly requested when deriving an instance.

Constructors

DerivStock l

GHC's "standard" strategy, which is to implement a custom instance for the data type. This only works for certain types that GHC knows about (e.g., Eq, Show, Functor when -XDeriveFunctor is enabled, etc.)

DerivAnyclass l
-XDeriveAnyClass
DerivNewtype l
-XGeneralizedNewtypeDeriving
DerivVia l (Type l)
-XDerivingVia
Instances
Functor DerivStrategy Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> DerivStrategy a -> DerivStrategy b #

(<$) :: a -> DerivStrategy b -> DerivStrategy a #

Foldable DerivStrategy Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => DerivStrategy m -> m #

foldMap :: Monoid m => (a -> m) -> DerivStrategy a -> m #

foldr :: (a -> b -> b) -> b -> DerivStrategy a -> b #

foldr' :: (a -> b -> b) -> b -> DerivStrategy a -> b #

foldl :: (b -> a -> b) -> b -> DerivStrategy a -> b #

foldl' :: (b -> a -> b) -> b -> DerivStrategy a -> b #

foldr1 :: (a -> a -> a) -> DerivStrategy a -> a #

foldl1 :: (a -> a -> a) -> DerivStrategy a -> a #

toList :: DerivStrategy a -> [a] #

null :: DerivStrategy a -> Bool #

length :: DerivStrategy a -> Int #

elem :: Eq a => a -> DerivStrategy a -> Bool #

maximum :: Ord a => DerivStrategy a -> a #

minimum :: Ord a => DerivStrategy a -> a #

sum :: Num a => DerivStrategy a -> a #

product :: Num a => DerivStrategy a -> a #

Traversable DerivStrategy Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> DerivStrategy a -> f (DerivStrategy b) #

sequenceA :: Applicative f => DerivStrategy (f a) -> f (DerivStrategy a) #

mapM :: Monad m => (a -> m b) -> DerivStrategy a -> m (DerivStrategy b) #

sequence :: Monad m => DerivStrategy (m a) -> m (DerivStrategy a) #

Annotated DerivStrategy Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: DerivStrategy l -> l Source #

amap :: (l -> l) -> DerivStrategy l -> DerivStrategy l Source #

ExactP DerivStrategy Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: DerivStrategy SrcSpanInfo -> EP ()

Eq l => Eq (DerivStrategy l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Data l => Data (DerivStrategy l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DerivStrategy l -> c (DerivStrategy l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DerivStrategy l) #

toConstr :: DerivStrategy l -> Constr #

dataTypeOf :: DerivStrategy l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DerivStrategy l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (DerivStrategy l)) #

gmapT :: (forall b. Data b => b -> b) -> DerivStrategy l -> DerivStrategy l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DerivStrategy l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DerivStrategy l -> r #

gmapQ :: (forall d. Data d => d -> u) -> DerivStrategy l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> DerivStrategy l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DerivStrategy l -> m (DerivStrategy l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivStrategy l -> m (DerivStrategy l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivStrategy l -> m (DerivStrategy l) #

Ord l => Ord (DerivStrategy l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Show l => Show (DerivStrategy l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Generic (DerivStrategy l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (DerivStrategy l) :: Type -> Type #

Pretty (DerivStrategy l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: DerivStrategy l -> Doc

prettyPrec :: Int -> DerivStrategy l -> Doc

type Rep (DerivStrategy l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

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 # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> DataOrNew a -> DataOrNew b #

(<$) :: a -> DataOrNew b -> DataOrNew a #

Foldable DataOrNew Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

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 # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> DataOrNew a -> f (DataOrNew b) #

sequenceA :: Applicative f => DataOrNew (f a) -> f (DataOrNew a) #

mapM :: Monad m => (a -> m b) -> DataOrNew a -> m (DataOrNew b) #

sequence :: Monad m => DataOrNew (m a) -> m (DataOrNew a) #

Annotated DataOrNew Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: DataOrNew l -> l Source #

amap :: (l -> l) -> DataOrNew l -> DataOrNew l Source #

ExactP DataOrNew Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: DataOrNew SrcSpanInfo -> EP ()

Eq l => Eq (DataOrNew l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: DataOrNew l -> DataOrNew l -> Bool #

(/=) :: DataOrNew l -> DataOrNew l -> Bool #

Data l => Data (DataOrNew l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> 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 # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Show l => Show (DataOrNew l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Generic (DataOrNew l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (DataOrNew l) :: Type -> Type #

Methods

from :: DataOrNew l -> Rep (DataOrNew l) x #

to :: Rep (DataOrNew l) x -> DataOrNew l #

Pretty (DataOrNew l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: DataOrNew l -> Doc

prettyPrec :: Int -> DataOrNew l -> Doc

type Rep (DataOrNew l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (DataOrNew l) = D1 (MetaData "DataOrNew" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-Z8xb2tkymYIClPofvAOw3" False) (C1 (MetaCons "DataType" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) :+: C1 (MetaCons "NewType" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)))

data ConDecl l 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 # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> ConDecl a -> ConDecl b #

(<$) :: a -> ConDecl b -> ConDecl a #

Foldable ConDecl Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

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 # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> ConDecl a -> f (ConDecl b) #

sequenceA :: Applicative f => ConDecl (f a) -> f (ConDecl a) #

mapM :: Monad m => (a -> m b) -> ConDecl a -> m (ConDecl b) #

sequence :: Monad m => ConDecl (m a) -> m (ConDecl a) #

Annotated ConDecl Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: ConDecl l -> l Source #

amap :: (l -> l) -> ConDecl l -> ConDecl l Source #

ExactP ConDecl Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: ConDecl SrcSpanInfo -> EP ()

Eq l => Eq (ConDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: ConDecl l -> ConDecl l -> Bool #

(/=) :: ConDecl l -> ConDecl l -> Bool #

Data l => Data (ConDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> 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 # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: ConDecl l -> ConDecl l -> Ordering #

(<) :: ConDecl l -> ConDecl l -> Bool #

(<=) :: ConDecl l -> ConDecl l -> Bool #

(>) :: ConDecl l -> ConDecl l -> Bool #

(>=) :: ConDecl l -> ConDecl l -> Bool #

max :: ConDecl l -> ConDecl l -> ConDecl l #

min :: ConDecl l -> ConDecl l -> ConDecl l #

Show l => Show (ConDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> ConDecl l -> ShowS #

show :: ConDecl l -> String #

showList :: [ConDecl l] -> ShowS #

Generic (ConDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (ConDecl l) :: Type -> Type #

Methods

from :: ConDecl l -> Rep (ConDecl l) x #

to :: Rep (ConDecl l) x -> ConDecl l #

Pretty (ConDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: ConDecl l -> Doc

prettyPrec :: Int -> ConDecl l -> Doc

type Rep (ConDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data FieldDecl l Source #

Declaration of a (list of) named field(s).

Constructors

FieldDecl l [Name l] (Type l) 
Instances
Functor FieldDecl Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> FieldDecl a -> FieldDecl b #

(<$) :: a -> FieldDecl b -> FieldDecl a #

Foldable FieldDecl Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

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 #

maximum :: Ord a => FieldDecl a -> a #

minimum :: Ord a => FieldDecl a -> a #

sum :: Num a => FieldDecl a -> a #

product :: Num a => FieldDecl a -> a #

Traversable FieldDecl Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> FieldDecl a -> f (FieldDecl b) #

sequenceA :: Applicative f => FieldDecl (f a) -> f (FieldDecl a) #

mapM :: Monad m => (a -> m b) -> FieldDecl a -> m (FieldDecl b) #

sequence :: Monad m => FieldDecl (m a) -> m (FieldDecl a) #

Annotated FieldDecl Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: FieldDecl l -> l Source #

amap :: (l -> l) -> FieldDecl l -> FieldDecl l Source #

ExactP FieldDecl Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: FieldDecl SrcSpanInfo -> EP ()

Eq l => Eq (FieldDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: FieldDecl l -> FieldDecl l -> Bool #

(/=) :: FieldDecl l -> FieldDecl l -> Bool #

Data l => Data (FieldDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FieldDecl l -> c (FieldDecl l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FieldDecl l) #

toConstr :: FieldDecl l -> Constr #

dataTypeOf :: FieldDecl l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FieldDecl l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FieldDecl l)) #

gmapT :: (forall b. Data b => b -> b) -> FieldDecl l -> FieldDecl l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FieldDecl l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FieldDecl l -> r #

gmapQ :: (forall d. Data d => d -> u) -> FieldDecl l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FieldDecl l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FieldDecl l -> m (FieldDecl l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldDecl l -> m (FieldDecl l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldDecl l -> m (FieldDecl l) #

Ord l => Ord (FieldDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Show l => Show (FieldDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Generic (FieldDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (FieldDecl l) :: Type -> Type #

Methods

from :: FieldDecl l -> Rep (FieldDecl l) x #

to :: Rep (FieldDecl l) x -> FieldDecl l #

Pretty (FieldDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: FieldDecl l -> Doc

prettyPrec :: Int -> FieldDecl l -> Doc

type Rep (FieldDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data QualConDecl l Source #

A single constructor declaration within a data type declaration, which may have an existential quantification binding.

Constructors

QualConDecl l (Maybe [TyVarBind l]) (Maybe (Context l)) (ConDecl l) 
Instances
Functor QualConDecl Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> QualConDecl a -> QualConDecl b #

(<$) :: a -> QualConDecl b -> QualConDecl a #

Foldable QualConDecl Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => QualConDecl m -> m #

foldMap :: Monoid m => (a -> m) -> QualConDecl a -> m #

foldr :: (a -> b -> b) -> b -> QualConDecl a -> b #

foldr' :: (a -> b -> b) -> b -> QualConDecl a -> b #

foldl :: (b -> a -> b) -> b -> QualConDecl a -> b #

foldl' :: (b -> a -> b) -> b -> QualConDecl a -> b #

foldr1 :: (a -> a -> a) -> QualConDecl a -> a #

foldl1 :: (a -> a -> a) -> QualConDecl a -> a #

toList :: QualConDecl a -> [a] #

null :: QualConDecl a -> Bool #

length :: QualConDecl a -> Int #

elem :: Eq a => a -> QualConDecl a -> Bool #

maximum :: Ord a => QualConDecl a -> a #

minimum :: Ord a => QualConDecl a -> a #

sum :: Num a => QualConDecl a -> a #

product :: Num a => QualConDecl a -> a #

Traversable QualConDecl Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> QualConDecl a -> f (QualConDecl b) #

sequenceA :: Applicative f => QualConDecl (f a) -> f (QualConDecl a) #

mapM :: Monad m => (a -> m b) -> QualConDecl a -> m (QualConDecl b) #

sequence :: Monad m => QualConDecl (m a) -> m (QualConDecl a) #

Annotated QualConDecl Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: QualConDecl l -> l Source #

amap :: (l -> l) -> QualConDecl l -> QualConDecl l Source #

ExactP QualConDecl Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: QualConDecl SrcSpanInfo -> EP ()

Eq l => Eq (QualConDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Data l => Data (QualConDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> QualConDecl l -> c (QualConDecl l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (QualConDecl l) #

toConstr :: QualConDecl l -> Constr #

dataTypeOf :: QualConDecl l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (QualConDecl l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (QualConDecl l)) #

gmapT :: (forall b. Data b => b -> b) -> QualConDecl l -> QualConDecl l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> QualConDecl l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> QualConDecl l -> r #

gmapQ :: (forall d. Data d => d -> u) -> QualConDecl l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> QualConDecl l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> QualConDecl l -> m (QualConDecl l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> QualConDecl l -> m (QualConDecl l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> QualConDecl l -> m (QualConDecl l) #

Ord l => Ord (QualConDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Show l => Show (QualConDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Generic (QualConDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (QualConDecl l) :: Type -> Type #

Methods

from :: QualConDecl l -> Rep (QualConDecl l) x #

to :: Rep (QualConDecl l) x -> QualConDecl l #

Pretty (QualConDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: QualConDecl l -> Doc

prettyPrec :: Int -> QualConDecl l -> Doc

type Rep (QualConDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data GadtDecl l Source #

A single constructor declaration in a GADT data type declaration.

If the GADT is declared using the record syntax, e.g.

data Ty where
  TCon :: { field1 :: Int, field2 :: Bool } -> Ty

then the fields are stored as a list of FieldDecls, and the final type (Ty in the above example) is stored in the last Type field.

If the GADT is declared using the ordinary syntax, e.g.

data Ty where
  TCon :: Int -> Bool -> Ty

then Maybe [FieldDecl l] is Nothing, and the whole constructor's type (such as Int -> Bool -> Ty) is stored in the last Type field.

Constructors

GadtDecl l (Name l) (Maybe [TyVarBind l]) (Maybe (Context l)) (Maybe [FieldDecl l]) (Type l) 
Instances
Functor GadtDecl Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> GadtDecl a -> GadtDecl b #

(<$) :: a -> GadtDecl b -> GadtDecl a #

Foldable GadtDecl Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => GadtDecl m -> m #

foldMap :: Monoid m => (a -> m) -> GadtDecl a -> m #

foldr :: (a -> b -> b) -> b -> GadtDecl a -> b #

foldr' :: (a -> b -> b) -> b -> GadtDecl a -> b #

foldl :: (b -> a -> b) -> b -> GadtDecl a -> b #

foldl' :: (b -> a -> b) -> b -> GadtDecl a -> b #

foldr1 :: (a -> a -> a) -> GadtDecl a -> a #

foldl1 :: (a -> a -> a) -> GadtDecl a -> a #

toList :: GadtDecl a -> [a] #

null :: GadtDecl a -> Bool #

length :: GadtDecl a -> Int #

elem :: Eq a => a -> GadtDecl a -> Bool #

maximum :: Ord a => GadtDecl a -> a #

minimum :: Ord a => GadtDecl a -> a #

sum :: Num a => GadtDecl a -> a #

product :: Num a => GadtDecl a -> a #

Traversable GadtDecl Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> GadtDecl a -> f (GadtDecl b) #

sequenceA :: Applicative f => GadtDecl (f a) -> f (GadtDecl a) #

mapM :: Monad m => (a -> m b) -> GadtDecl a -> m (GadtDecl b) #

sequence :: Monad m => GadtDecl (m a) -> m (GadtDecl a) #

Annotated GadtDecl Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: GadtDecl l -> l Source #

amap :: (l -> l) -> GadtDecl l -> GadtDecl l Source #

ExactP GadtDecl Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: GadtDecl SrcSpanInfo -> EP ()

Eq l => Eq (GadtDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: GadtDecl l -> GadtDecl l -> Bool #

(/=) :: GadtDecl l -> GadtDecl l -> Bool #

Data l => Data (GadtDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GadtDecl l -> c (GadtDecl l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (GadtDecl l) #

toConstr :: GadtDecl l -> Constr #

dataTypeOf :: GadtDecl l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (GadtDecl l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (GadtDecl l)) #

gmapT :: (forall b. Data b => b -> b) -> GadtDecl l -> GadtDecl l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GadtDecl l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GadtDecl l -> r #

gmapQ :: (forall d. Data d => d -> u) -> GadtDecl l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> GadtDecl l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GadtDecl l -> m (GadtDecl l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GadtDecl l -> m (GadtDecl l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GadtDecl l -> m (GadtDecl l) #

Ord l => Ord (GadtDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: GadtDecl l -> GadtDecl l -> Ordering #

(<) :: GadtDecl l -> GadtDecl l -> Bool #

(<=) :: GadtDecl l -> GadtDecl l -> Bool #

(>) :: GadtDecl l -> GadtDecl l -> Bool #

(>=) :: GadtDecl l -> GadtDecl l -> Bool #

max :: GadtDecl l -> GadtDecl l -> GadtDecl l #

min :: GadtDecl l -> GadtDecl l -> GadtDecl l #

Show l => Show (GadtDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> GadtDecl l -> ShowS #

show :: GadtDecl l -> String #

showList :: [GadtDecl l] -> ShowS #

Generic (GadtDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (GadtDecl l) :: Type -> Type #

Methods

from :: GadtDecl l -> Rep (GadtDecl l) x #

to :: Rep (GadtDecl l) x -> GadtDecl l #

Pretty (GadtDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: GadtDecl l -> Doc

prettyPrec :: Int -> GadtDecl l -> Doc

type Rep (GadtDecl l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data BangType l Source #

The type of a constructor argument or field, optionally including a strictness annotation.

Constructors

BangedTy l

strict component, marked with "!"

LazyTy l

lazy component, marked with "~"

NoStrictAnnot l

No strictness information

Instances
Functor BangType Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> BangType a -> BangType b #

(<$) :: a -> BangType b -> BangType a #

Foldable BangType Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => BangType m -> m #

foldMap :: Monoid m => (a -> m) -> BangType a -> m #

foldr :: (a -> b -> b) -> b -> BangType a -> b #

foldr' :: (a -> b -> b) -> b -> BangType a -> b #

foldl :: (b -> a -> b) -> b -> BangType a -> b #

foldl' :: (b -> a -> b) -> b -> BangType a -> b #

foldr1 :: (a -> a -> a) -> BangType a -> a #

foldl1 :: (a -> a -> a) -> BangType a -> a #

toList :: BangType a -> [a] #

null :: BangType a -> Bool #

length :: BangType a -> Int #

elem :: Eq a => a -> BangType a -> Bool #

maximum :: Ord a => BangType a -> a #

minimum :: Ord a => BangType a -> a #

sum :: Num a => BangType a -> a #

product :: Num a => BangType a -> a #

Traversable BangType Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> BangType a -> f (BangType b) #

sequenceA :: Applicative f => BangType (f a) -> f (BangType a) #

mapM :: Monad m => (a -> m b) -> BangType a -> m (BangType b) #

sequence :: Monad m => BangType (m a) -> m (BangType a) #

Annotated BangType Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: BangType l -> l Source #

amap :: (l -> l) -> BangType l -> BangType l Source #

ExactP BangType Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: BangType SrcSpanInfo -> EP ()

Eq l => Eq (BangType l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: BangType l -> BangType l -> Bool #

(/=) :: BangType l -> BangType l -> Bool #

Data l => Data (BangType l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> BangType l -> c (BangType l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (BangType l) #

toConstr :: BangType l -> Constr #

dataTypeOf :: BangType l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (BangType l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (BangType l)) #

gmapT :: (forall b. Data b => b -> b) -> BangType l -> BangType l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BangType l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BangType l -> r #

gmapQ :: (forall d. Data d => d -> u) -> BangType l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> BangType l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> BangType l -> m (BangType l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> BangType l -> m (BangType l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> BangType l -> m (BangType l) #

Ord l => Ord (BangType l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: BangType l -> BangType l -> Ordering #

(<) :: BangType l -> BangType l -> Bool #

(<=) :: BangType l -> BangType l -> Bool #

(>) :: BangType l -> BangType l -> Bool #

(>=) :: BangType l -> BangType l -> Bool #

max :: BangType l -> BangType l -> BangType l #

min :: BangType l -> BangType l -> BangType l #

Show l => Show (BangType l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> BangType l -> ShowS #

show :: BangType l -> String #

showList :: [BangType l] -> ShowS #

Generic (BangType l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (BangType l) :: Type -> Type #

Methods

from :: BangType l -> Rep (BangType l) x #

to :: Rep (BangType l) x -> BangType l #

Pretty (BangType l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: BangType l -> Doc

prettyPrec :: Int -> BangType l -> Doc

type Rep (BangType l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (BangType l) = D1 (MetaData "BangType" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-Z8xb2tkymYIClPofvAOw3" False) (C1 (MetaCons "BangedTy" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) :+: (C1 (MetaCons "LazyTy" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) :+: C1 (MetaCons "NoStrictAnnot" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l))))

data Unpackedness l Source #

Constructors

Unpack l

"{-# UNPACK #-}"

NoUnpack l

"{-# NOUNPACK #-}"

NoUnpackPragma l

No unpack pragma

Instances
Functor Unpackedness Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Unpackedness a -> Unpackedness b #

(<$) :: a -> Unpackedness b -> Unpackedness a #

Foldable Unpackedness Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Unpackedness m -> m #

foldMap :: Monoid m => (a -> m) -> Unpackedness a -> m #

foldr :: (a -> b -> b) -> b -> Unpackedness a -> b #

foldr' :: (a -> b -> b) -> b -> Unpackedness a -> b #

foldl :: (b -> a -> b) -> b -> Unpackedness a -> b #

foldl' :: (b -> a -> b) -> b -> Unpackedness a -> b #

foldr1 :: (a -> a -> a) -> Unpackedness a -> a #

foldl1 :: (a -> a -> a) -> Unpackedness a -> a #

toList :: Unpackedness a -> [a] #

null :: Unpackedness a -> Bool #

length :: Unpackedness a -> Int #

elem :: Eq a => a -> Unpackedness a -> Bool #

maximum :: Ord a => Unpackedness a -> a #

minimum :: Ord a => Unpackedness a -> a #

sum :: Num a => Unpackedness a -> a #

product :: Num a => Unpackedness a -> a #

Traversable Unpackedness Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> Unpackedness a -> f (Unpackedness b) #

sequenceA :: Applicative f => Unpackedness (f a) -> f (Unpackedness a) #

mapM :: Monad m => (a -> m b) -> Unpackedness a -> m (Unpackedness b) #

sequence :: Monad m => Unpackedness (m a) -> m (Unpackedness a) #

Annotated Unpackedness Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Unpackedness l -> l Source #

amap :: (l -> l) -> Unpackedness l -> Unpackedness l Source #

ExactP Unpackedness Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Unpackedness SrcSpanInfo -> EP ()

Eq l => Eq (Unpackedness l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Data l => Data (Unpackedness l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Unpackedness l -> c (Unpackedness l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Unpackedness l) #

toConstr :: Unpackedness l -> Constr #

dataTypeOf :: Unpackedness l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Unpackedness l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Unpackedness l)) #

gmapT :: (forall b. Data b => b -> b) -> Unpackedness l -> Unpackedness l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Unpackedness l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Unpackedness l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Unpackedness l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Unpackedness l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Unpackedness l -> m (Unpackedness l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Unpackedness l -> m (Unpackedness l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Unpackedness l -> m (Unpackedness l) #

Ord l => Ord (Unpackedness l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Show l => Show (Unpackedness l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Generic (Unpackedness l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Unpackedness l) :: Type -> Type #

Methods

from :: Unpackedness l -> Rep (Unpackedness l) x #

to :: Rep (Unpackedness l) x -> Unpackedness l #

Pretty (Unpackedness l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Unpackedness l -> Doc

prettyPrec :: Int -> Unpackedness l -> Doc

type Rep (Unpackedness l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (Unpackedness l) = D1 (MetaData "Unpackedness" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-Z8xb2tkymYIClPofvAOw3" False) (C1 (MetaCons "Unpack" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) :+: (C1 (MetaCons "NoUnpack" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) :+: C1 (MetaCons "NoUnpackPragma" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l))))

Function bindings

data Match l Source #

Clauses of a function binding.

Constructors

Match l (Name l) [Pat l] (Rhs l) (Maybe (Binds l))

A clause defined with prefix notation, i.e. the function name followed by its argument patterns, the right-hand side and an optional where clause.

InfixMatch l (Pat l) (Name l) [Pat l] (Rhs l) (Maybe (Binds l))

A clause defined with infix notation, i.e. first its first argument pattern, then the function name, then its following argument(s), the right-hand side and an optional where clause. Note that there can be more than two arguments to a function declared infix, hence the list of pattern arguments.

Instances
Functor Match Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Match a -> Match b #

(<$) :: a -> Match b -> Match a #

Foldable Match Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Match m -> m #

foldMap :: Monoid m => (a -> m) -> Match a -> m #

foldr :: (a -> b -> b) -> b -> Match a -> b #

foldr' :: (a -> b -> b) -> b -> Match a -> b #

foldl :: (b -> a -> b) -> b -> Match a -> b #

foldl' :: (b -> a -> b) -> b -> Match a -> b #

foldr1 :: (a -> a -> a) -> Match a -> a #

foldl1 :: (a -> a -> a) -> Match a -> a #

toList :: Match a -> [a] #

null :: Match a -> Bool #

length :: Match a -> Int #

elem :: Eq a => a -> Match a -> Bool #

maximum :: Ord a => Match a -> a #

minimum :: Ord a => Match a -> a #

sum :: Num a => Match a -> a #

product :: Num a => Match a -> a #

Traversable Match Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> Match a -> f (Match b) #

sequenceA :: Applicative f => Match (f a) -> f (Match a) #

mapM :: Monad m => (a -> m b) -> Match a -> m (Match b) #

sequence :: Monad m => Match (m a) -> m (Match a) #

Annotated Match Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Match l -> l Source #

amap :: (l -> l) -> Match l -> Match l Source #

AppFixity Match Source # 
Instance details

Defined in Language.Haskell.Exts.Fixity

ExactP Match Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Match SrcSpanInfo -> EP ()

Eq l => Eq (Match l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: Match l -> Match l -> Bool #

(/=) :: Match l -> Match l -> Bool #

Data l => Data (Match l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Match l -> c (Match l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Match l) #

toConstr :: Match l -> Constr #

dataTypeOf :: Match l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Match l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Match l)) #

gmapT :: (forall b. Data b => b -> b) -> Match l -> Match l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Match l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Match l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Match l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Match l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Match l -> m (Match l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Match l -> m (Match l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Match l -> m (Match l) #

Ord l => Ord (Match l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: Match l -> Match l -> Ordering #

(<) :: Match l -> Match l -> Bool #

(<=) :: Match l -> Match l -> Bool #

(>) :: Match l -> Match l -> Bool #

(>=) :: Match l -> Match l -> Bool #

max :: Match l -> Match l -> Match l #

min :: Match l -> Match l -> Match l #

Show l => Show (Match l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> Match l -> ShowS #

show :: Match l -> String #

showList :: [Match l] -> ShowS #

Generic (Match l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Match l) :: Type -> Type #

Methods

from :: Match l -> Rep (Match l) x #

to :: Rep (Match l) x -> Match l #

Pretty (Match l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Match l -> Doc

prettyPrec :: Int -> Match l -> Doc

type Rep (Match l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data Rhs l Source #

The right hand side of a function binding, pattern binding, or a case alternative.

Constructors

UnGuardedRhs l (Exp l)

unguarded right hand side (exp)

GuardedRhss l [GuardedRhs l]

guarded right hand side (gdrhs)

Instances
Functor Rhs Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Rhs a -> Rhs b #

(<$) :: a -> Rhs b -> Rhs a #

Foldable Rhs Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Rhs m -> m #

foldMap :: Monoid m => (a -> m) -> Rhs a -> m #

foldr :: (a -> b -> b) -> b -> Rhs a -> b #

foldr' :: (a -> b -> b) -> b -> Rhs a -> b #

foldl :: (b -> a -> b) -> b -> Rhs a -> b #

foldl' :: (b -> a -> b) -> b -> Rhs a -> b #

foldr1 :: (a -> a -> a) -> Rhs a -> a #

foldl1 :: (a -> a -> a) -> Rhs a -> a #

toList :: Rhs a -> [a] #

null :: Rhs a -> Bool #

length :: Rhs a -> Int #

elem :: Eq a => a -> Rhs a -> Bool #

maximum :: Ord a => Rhs a -> a #

minimum :: Ord a => Rhs a -> a #

sum :: Num a => Rhs a -> a #

product :: Num a => Rhs a -> a #

Traversable Rhs Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> Rhs a -> f (Rhs b) #

sequenceA :: Applicative f => Rhs (f a) -> f (Rhs a) #

mapM :: Monad m => (a -> m b) -> Rhs a -> m (Rhs b) #

sequence :: Monad m => Rhs (m a) -> m (Rhs a) #

Annotated Rhs Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Rhs l -> l Source #

amap :: (l -> l) -> Rhs l -> Rhs l Source #

AppFixity Rhs Source # 
Instance details

Defined in Language.Haskell.Exts.Fixity

ExactP Rhs Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Rhs SrcSpanInfo -> EP ()

Eq l => Eq (Rhs l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: Rhs l -> Rhs l -> Bool #

(/=) :: Rhs l -> Rhs l -> Bool #

Data l => Data (Rhs l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Rhs l -> c (Rhs l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Rhs l) #

toConstr :: Rhs l -> Constr #

dataTypeOf :: Rhs l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Rhs l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Rhs l)) #

gmapT :: (forall b. Data b => b -> b) -> Rhs l -> Rhs l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rhs l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rhs l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Rhs l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Rhs l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Rhs l -> m (Rhs l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Rhs l -> m (Rhs l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Rhs l -> m (Rhs l) #

Ord l => Ord (Rhs l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: Rhs l -> Rhs l -> Ordering #

(<) :: Rhs l -> Rhs l -> Bool #

(<=) :: Rhs l -> Rhs l -> Bool #

(>) :: Rhs l -> Rhs l -> Bool #

(>=) :: Rhs l -> Rhs l -> Bool #

max :: Rhs l -> Rhs l -> Rhs l #

min :: Rhs l -> Rhs l -> Rhs l #

Show l => Show (Rhs l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> Rhs l -> ShowS #

show :: Rhs l -> String #

showList :: [Rhs l] -> ShowS #

Generic (Rhs l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Rhs l) :: Type -> Type #

Methods

from :: Rhs l -> Rep (Rhs l) x #

to :: Rep (Rhs l) x -> Rhs l #

Pretty (Rhs l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Rhs l -> Doc

prettyPrec :: Int -> Rhs l -> Doc

type Rep (Rhs l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data GuardedRhs l Source #

A guarded right hand side | stmts = exp, or | stmts -> exp for case alternatives. The guard is a series of statements when using pattern guards, otherwise it will be a single qualifier expression.

Constructors

GuardedRhs l [Stmt l] (Exp l) 
Instances
Functor GuardedRhs Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> GuardedRhs a -> GuardedRhs b #

(<$) :: a -> GuardedRhs b -> GuardedRhs a #

Foldable GuardedRhs Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => GuardedRhs m -> m #

foldMap :: Monoid m => (a -> m) -> GuardedRhs a -> m #

foldr :: (a -> b -> b) -> b -> GuardedRhs a -> b #

foldr' :: (a -> b -> b) -> b -> GuardedRhs a -> b #

foldl :: (b -> a -> b) -> b -> GuardedRhs a -> b #

foldl' :: (b -> a -> b) -> b -> GuardedRhs a -> b #

foldr1 :: (a -> a -> a) -> GuardedRhs a -> a #

foldl1 :: (a -> a -> a) -> GuardedRhs a -> a #

toList :: GuardedRhs a -> [a] #

null :: GuardedRhs a -> Bool #

length :: GuardedRhs a -> Int #

elem :: Eq a => a -> GuardedRhs a -> Bool #

maximum :: Ord a => GuardedRhs a -> a #

minimum :: Ord a => GuardedRhs a -> a #

sum :: Num a => GuardedRhs a -> a #

product :: Num a => GuardedRhs a -> a #

Traversable GuardedRhs Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> GuardedRhs a -> f (GuardedRhs b) #

sequenceA :: Applicative f => GuardedRhs (f a) -> f (GuardedRhs a) #

mapM :: Monad m => (a -> m b) -> GuardedRhs a -> m (GuardedRhs b) #

sequence :: Monad m => GuardedRhs (m a) -> m (GuardedRhs a) #

Annotated GuardedRhs Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: GuardedRhs l -> l Source #

amap :: (l -> l) -> GuardedRhs l -> GuardedRhs l Source #

AppFixity GuardedRhs Source # 
Instance details

Defined in Language.Haskell.Exts.Fixity

ExactP GuardedRhs Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: GuardedRhs SrcSpanInfo -> EP ()

Eq l => Eq (GuardedRhs l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: GuardedRhs l -> GuardedRhs l -> Bool #

(/=) :: GuardedRhs l -> GuardedRhs l -> Bool #

Data l => Data (GuardedRhs l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GuardedRhs l -> c (GuardedRhs l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (GuardedRhs l) #

toConstr :: GuardedRhs l -> Constr #

dataTypeOf :: GuardedRhs l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (GuardedRhs l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (GuardedRhs l)) #

gmapT :: (forall b. Data b => b -> b) -> GuardedRhs l -> GuardedRhs l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GuardedRhs l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GuardedRhs l -> r #

gmapQ :: (forall d. Data d => d -> u) -> GuardedRhs l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> GuardedRhs l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GuardedRhs l -> m (GuardedRhs l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GuardedRhs l -> m (GuardedRhs l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GuardedRhs l -> m (GuardedRhs l) #

Ord l => Ord (GuardedRhs l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Show l => Show (GuardedRhs l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Generic (GuardedRhs l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (GuardedRhs l) :: Type -> Type #

Methods

from :: GuardedRhs l -> Rep (GuardedRhs l) x #

to :: Rep (GuardedRhs l) x -> GuardedRhs l #

Pretty (GuardedRhs l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: GuardedRhs l -> Doc

prettyPrec :: Int -> GuardedRhs l -> Doc

type Rep (GuardedRhs l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (GuardedRhs l) = D1 (MetaData "GuardedRhs" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-Z8xb2tkymYIClPofvAOw3" False) (C1 (MetaCons "GuardedRhs" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Stmt l]) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)))))

Class Assertions and Contexts

data Context l Source #

A context is a set of assertions

Constructors

CxSingle l (Asst l) 
CxTuple l [Asst l] 
CxEmpty l 
Instances
Functor Context Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Context a -> Context b #

(<$) :: a -> Context b -> Context a #

Foldable Context Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Context m -> m #

foldMap :: Monoid m => (a -> m) -> Context a -> m #

foldr :: (a -> b -> b) -> b -> Context a -> b #

foldr' :: (a -> b -> b) -> b -> Context a -> b #

foldl :: (b -> a -> b) -> b -> Context a -> b #

foldl' :: (b -> a -> b) -> b -> Context a -> b #

foldr1 :: (a -> a -> a) -> Context a -> a #

foldl1 :: (a -> a -> a) -> Context a -> a #

toList :: Context a -> [a] #

null :: Context a -> Bool #

length :: Context a -> Int #

elem :: Eq a => a -> Context a -> Bool #

maximum :: Ord a => Context a -> a #

minimum :: Ord a => Context a -> a #

sum :: Num a => Context a -> a #

product :: Num a => Context a -> a #

Traversable Context Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> Context a -> f (Context b) #

sequenceA :: Applicative f => Context (f a) -> f (Context a) #

mapM :: Monad m => (a -> m b) -> Context a -> m (Context b) #

sequence :: Monad m => Context (m a) -> m (Context a) #

Annotated Context Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Context l -> l Source #

amap :: (l -> l) -> Context l -> Context l Source #

ExactP Context Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Context SrcSpanInfo -> EP ()

Eq l => Eq (Context l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: Context l -> Context l -> Bool #

(/=) :: Context l -> Context l -> Bool #

Data l => Data (Context l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Context l -> c (Context l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Context l) #

toConstr :: Context l -> Constr #

dataTypeOf :: Context l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Context l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Context l)) #

gmapT :: (forall b. Data b => b -> b) -> Context l -> Context l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Context l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Context l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Context l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Context l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Context l -> m (Context l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Context l -> m (Context l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Context l -> m (Context l) #

Ord l => Ord (Context l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: Context l -> Context l -> Ordering #

(<) :: Context l -> Context l -> Bool #

(<=) :: Context l -> Context l -> Bool #

(>) :: Context l -> Context l -> Bool #

(>=) :: Context l -> Context l -> Bool #

max :: Context l -> Context l -> Context l #

min :: Context l -> Context l -> Context l #

Show l => Show (Context l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> Context l -> ShowS #

show :: Context l -> String #

showList :: [Context l] -> ShowS #

Generic (Context l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Context l) :: Type -> Type #

Methods

from :: Context l -> Rep (Context l) x #

to :: Rep (Context l) x -> Context l #

Pretty (Context l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Context l -> Doc

prettyPrec :: Int -> Context l -> Doc

type Rep (Context l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data FunDep l Source #

A functional dependency, given on the form l1 l2 ... ln -> r2 r3 .. rn

Constructors

FunDep l [Name l] [Name l] 
Instances
Functor FunDep Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> FunDep a -> FunDep b #

(<$) :: a -> FunDep b -> FunDep a #

Foldable FunDep Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => FunDep m -> m #

foldMap :: Monoid m => (a -> m) -> FunDep a -> m #

foldr :: (a -> b -> b) -> b -> FunDep a -> b #

foldr' :: (a -> b -> b) -> b -> FunDep a -> b #

foldl :: (b -> a -> b) -> b -> FunDep a -> b #

foldl' :: (b -> a -> b) -> b -> FunDep a -> b #

foldr1 :: (a -> a -> a) -> FunDep a -> a #

foldl1 :: (a -> a -> a) -> FunDep a -> a #

toList :: FunDep a -> [a] #

null :: FunDep a -> Bool #

length :: FunDep a -> Int #

elem :: Eq a => a -> FunDep a -> Bool #

maximum :: Ord a => FunDep a -> a #

minimum :: Ord a => FunDep a -> a #

sum :: Num a => FunDep a -> a #

product :: Num a => FunDep a -> a #

Traversable FunDep Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> FunDep a -> f (FunDep b) #

sequenceA :: Applicative f => FunDep (f a) -> f (FunDep a) #

mapM :: Monad m => (a -> m b) -> FunDep a -> m (FunDep b) #

sequence :: Monad m => FunDep (m a) -> m (FunDep a) #

Annotated FunDep Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: FunDep l -> l Source #

amap :: (l -> l) -> FunDep l -> FunDep l Source #

ExactP FunDep Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: FunDep SrcSpanInfo -> EP ()

Eq l => Eq (FunDep l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: FunDep l -> FunDep l -> Bool #

(/=) :: FunDep l -> FunDep l -> Bool #

Data l => Data (FunDep l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FunDep l -> c (FunDep l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FunDep l) #

toConstr :: FunDep l -> Constr #

dataTypeOf :: FunDep l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FunDep l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FunDep l)) #

gmapT :: (forall b. Data b => b -> b) -> FunDep l -> FunDep l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FunDep l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FunDep l -> r #

gmapQ :: (forall d. Data d => d -> u) -> FunDep l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FunDep l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FunDep l -> m (FunDep l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FunDep l -> m (FunDep l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FunDep l -> m (FunDep l) #

Ord l => Ord (FunDep l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: FunDep l -> FunDep l -> Ordering #

(<) :: FunDep l -> FunDep l -> Bool #

(<=) :: FunDep l -> FunDep l -> Bool #

(>) :: FunDep l -> FunDep l -> Bool #

(>=) :: FunDep l -> FunDep l -> Bool #

max :: FunDep l -> FunDep l -> FunDep l #

min :: FunDep l -> FunDep l -> FunDep l #

Show l => Show (FunDep l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> FunDep l -> ShowS #

show :: FunDep l -> String #

showList :: [FunDep l] -> ShowS #

Generic (FunDep l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (FunDep l) :: Type -> Type #

Methods

from :: FunDep l -> Rep (FunDep l) x #

to :: Rep (FunDep l) x -> FunDep l #

Pretty (FunDep l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: FunDep l -> Doc

prettyPrec :: Int -> FunDep l -> Doc

type Rep (FunDep l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data Asst l Source #

Class assertions.

Constructors

TypeA l (Type l)

type assertion

IParam l (IPName l) (Type l)

implicit parameter assertion

ParenA l (Asst l)

parenthesised class assertion

Instances
Functor Asst Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Asst a -> Asst b #

(<$) :: a -> Asst b -> Asst a #

Foldable Asst Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Asst m -> m #

foldMap :: Monoid m => (a -> m) -> Asst a -> m #

foldr :: (a -> b -> b) -> b -> Asst a -> b #

foldr' :: (a -> b -> b) -> b -> Asst a -> b #

foldl :: (b -> a -> b) -> b -> Asst a -> b #

foldl' :: (b -> a -> b) -> b -> Asst a -> b #

foldr1 :: (a -> a -> a) -> Asst a -> a #

foldl1 :: (a -> a -> a) -> Asst a -> a #

toList :: Asst a -> [a] #

null :: Asst a -> Bool #

length :: Asst a -> Int #

elem :: Eq a => a -> Asst a -> Bool #

maximum :: Ord a => Asst a -> a #

minimum :: Ord a => Asst a -> a #

sum :: Num a => Asst a -> a #

product :: Num a => Asst a -> a #

Traversable Asst Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> Asst a -> f (Asst b) #

sequenceA :: Applicative f => Asst (f a) -> f (Asst a) #

mapM :: Monad m => (a -> m b) -> Asst a -> m (Asst b) #

sequence :: Monad m => Asst (m a) -> m (Asst a) #

Annotated Asst Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Asst l -> l Source #

amap :: (l -> l) -> Asst l -> Asst l Source #

ExactP Asst Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Asst SrcSpanInfo -> EP ()

Eq l => Eq (Asst l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: Asst l -> Asst l -> Bool #

(/=) :: Asst l -> Asst l -> Bool #

Data l => Data (Asst l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Asst l -> c (Asst l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Asst l) #

toConstr :: Asst l -> Constr #

dataTypeOf :: Asst l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Asst l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Asst l)) #

gmapT :: (forall b. Data b => b -> b) -> Asst l -> Asst l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Asst l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Asst l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Asst l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Asst l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Asst l -> m (Asst l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Asst l -> m (Asst l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Asst l -> m (Asst l) #

Ord l => Ord (Asst l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: Asst l -> Asst l -> Ordering #

(<) :: Asst l -> Asst l -> Bool #

(<=) :: Asst l -> Asst l -> Bool #

(>) :: Asst l -> Asst l -> Bool #

(>=) :: Asst l -> Asst l -> Bool #

max :: Asst l -> Asst l -> Asst l #

min :: Asst l -> Asst l -> Asst l #

Show l => Show (Asst l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> Asst l -> ShowS #

show :: Asst l -> String #

showList :: [Asst l] -> ShowS #

Generic (Asst l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Asst l) :: Type -> Type #

Methods

from :: Asst l -> Rep (Asst l) x #

to :: Rep (Asst l) x -> Asst l #

Pretty (Asst l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Asst l -> Doc

prettyPrec :: Int -> Asst l -> Doc

type Rep (Asst l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Types

data Type l Source #

A type qualified with a context. An unqualified type has an empty context.

Constructors

TyForall l (Maybe [TyVarBind l]) (Maybe (Context l)) (Type l)

qualified type

TyStar l

*, the type of types

TyFun l (Type l) (Type l)

function type

TyTuple l Boxed [Type l]

tuple type, possibly boxed

TyUnboxedSum l [Type l]

unboxed tuple type

TyList l (Type l)

list syntax, e.g. [a], as opposed to [] a

TyParArray l (Type l)

parallel array syntax, e.g. [:a:]

TyApp l (Type l) (Type l)

application of a type constructor

TyVar l (Name l)

type variable

TyCon l (QName l)

named type or type constructor

TyParen l (Type l)

type surrounded by parentheses

TyInfix l (Type l) (MaybePromotedName l) (Type l)

infix type constructor

TyKind l (Type l) (Kind l)

type with explicit kind signature

TyPromoted l (Promoted l)

'K, a promoted data type (-XDataKinds).

TyEquals l (Type l) (Type l)

type equality predicate enabled by ConstraintKinds

TySplice l (Splice l)

template haskell splice type

TyBang l (BangType l) (Unpackedness l) (Type l)

Strict type marked with "!" or type marked with UNPACK pragma.

TyWildCard l (Maybe (Name l))

Either an anonymous of named type wildcard

TyQuasiQuote l String String
[$name| string |]
Instances
Functor Type Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Type a -> Type b #

(<$) :: a -> Type b -> Type a #

Foldable Type Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Type m -> m #

foldMap :: Monoid m => (a -> m) -> Type a -> m #

foldr :: (a -> b -> b) -> b -> Type a -> b #

foldr' :: (a -> b -> b) -> b -> Type a -> b #

foldl :: (b -> a -> b) -> b -> Type a -> b #

foldl' :: (b -> a -> b) -> b -> Type a -> b #

foldr1 :: (a -> a -> a) -> Type a -> a #

foldl1 :: (a -> a -> a) -> Type a -> a #

toList :: Type a -> [a] #

null :: Type a -> Bool #

length :: Type a -> Int #

elem :: Eq a => a -> Type a -> Bool #

maximum :: Ord a => Type a -> a #

minimum :: Ord a => Type a -> a #

sum :: Num a => Type a -> a #

product :: Num a => Type a -> a #

Traversable Type Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> Type a -> f (Type b) #

sequenceA :: Applicative f => Type (f a) -> f (Type a) #

mapM :: Monad m => (a -> m b) -> Type a -> m (Type b) #

sequence :: Monad m => Type (m a) -> m (Type a) #

Annotated Type Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Type l -> l Source #

amap :: (l -> l) -> Type l -> Type l Source #

ExactP Type Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Type SrcSpanInfo -> EP ()

Eq l => Eq (Type l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: Type l -> Type l -> Bool #

(/=) :: Type l -> Type l -> Bool #

Data l => Data (Type l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Type l -> c (Type l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Type l) #

toConstr :: Type l -> Constr #

dataTypeOf :: Type l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Type l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Type l)) #

gmapT :: (forall b. Data b => b -> b) -> Type l -> Type l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Type l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Type l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Type l -> m (Type l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Type l -> m (Type l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Type l -> m (Type l) #

Ord l => Ord (Type l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: Type l -> Type l -> Ordering #

(<) :: Type l -> Type l -> Bool #

(<=) :: Type l -> Type l -> Bool #

(>) :: Type l -> Type l -> Bool #

(>=) :: Type l -> Type l -> Bool #

max :: Type l -> Type l -> Type l #

min :: Type l -> Type l -> Type l #

Show l => Show (Type l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> Type l -> ShowS #

show :: Type l -> String #

showList :: [Type l] -> ShowS #

Generic (Type l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Type l) :: Type -> Type #

Methods

from :: Type l -> Rep (Type l) x #

to :: Rep (Type l) x -> Type l #

Pretty (Type l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Type l -> Doc

prettyPrec :: Int -> Type l -> Doc

Parseable (Type SrcSpanInfo) Source # 
Instance details

Defined in Language.Haskell.Exts.Parser

type Rep (Type l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (Type l) = D1 (MetaData "Type" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-Z8xb2tkymYIClPofvAOw3" False) ((((C1 (MetaCons "TyForall" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe [TyVarBind l]))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Context l))) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)))) :+: C1 (MetaCons "TyStar" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l))) :+: (C1 (MetaCons "TyFun" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)))) :+: C1 (MetaCons "TyTuple" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Boxed) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Type l]))))) :+: ((C1 (MetaCons "TyUnboxedSum" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Type l])) :+: C1 (MetaCons "TyList" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)))) :+: (C1 (MetaCons "TyParArray" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l))) :+: (C1 (MetaCons "TyApp" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)))) :+: C1 (MetaCons "TyVar" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Name l))))))) :+: (((C1 (MetaCons "TyCon" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l))) :+: C1 (MetaCons "TyParen" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)))) :+: (C1 (MetaCons "TyInfix" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (MaybePromotedName l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)))) :+: (C1 (MetaCons "TyKind" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Kind l)))) :+: C1 (MetaCons "TyPromoted" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Promoted l)))))) :+: ((C1 (MetaCons "TyEquals" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)))) :+: C1 (MetaCons "TySplice" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Splice l)))) :+: (C1 (MetaCons "TyBang" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (BangType l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Unpackedness l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)))) :+: (C1 (MetaCons "TyWildCard" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Name l)))) :+: C1 (MetaCons "TyQuasiQuote" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String))))))))

data Boxed Source #

Flag denoting whether a tuple is boxed or unboxed.

Constructors

Boxed 
Unboxed 
Instances
Eq Boxed Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: Boxed -> Boxed -> Bool #

(/=) :: Boxed -> Boxed -> Bool #

Data Boxed Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Boxed -> c Boxed #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Boxed #

toConstr :: Boxed -> Constr #

dataTypeOf :: Boxed -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Boxed) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Boxed) #

gmapT :: (forall b. Data b => b -> b) -> Boxed -> Boxed #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Boxed -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Boxed -> r #

gmapQ :: (forall d. Data d => d -> u) -> Boxed -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Boxed -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Boxed -> m Boxed #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Boxed -> m Boxed #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Boxed -> m Boxed #

Ord Boxed Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: Boxed -> Boxed -> Ordering #

(<) :: Boxed -> Boxed -> Bool #

(<=) :: Boxed -> Boxed -> Bool #

(>) :: Boxed -> Boxed -> Bool #

(>=) :: Boxed -> Boxed -> Bool #

max :: Boxed -> Boxed -> Boxed #

min :: Boxed -> Boxed -> Boxed #

Show Boxed Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> Boxed -> ShowS #

show :: Boxed -> String #

showList :: [Boxed] -> ShowS #

Generic Boxed Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep Boxed :: Type -> Type #

Methods

from :: Boxed -> Rep Boxed x #

to :: Rep Boxed x -> Boxed #

type Rep Boxed Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep Boxed = D1 (MetaData "Boxed" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-Z8xb2tkymYIClPofvAOw3" False) (C1 (MetaCons "Boxed" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "Unboxed" PrefixI False) (U1 :: Type -> Type))

type Kind = Type Source #

An explicit kind annotation.

data TyVarBind l Source #

A type variable declaration, optionally with an explicit kind annotation.

Constructors

KindedVar l (Name l) (Kind l)

variable binding with kind annotation

UnkindedVar l (Name l)

ordinary variable binding

Instances
Functor TyVarBind Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> TyVarBind a -> TyVarBind b #

(<$) :: a -> TyVarBind b -> TyVarBind a #

Foldable TyVarBind Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => TyVarBind m -> m #

foldMap :: Monoid m => (a -> m) -> TyVarBind a -> m #

foldr :: (a -> b -> b) -> b -> TyVarBind a -> b #

foldr' :: (a -> b -> b) -> b -> TyVarBind a -> b #

foldl :: (b -> a -> b) -> b -> TyVarBind a -> b #

foldl' :: (b -> a -> b) -> b -> TyVarBind a -> b #

foldr1 :: (a -> a -> a) -> TyVarBind a -> a #

foldl1 :: (a -> a -> a) -> TyVarBind a -> a #

toList :: TyVarBind a -> [a] #

null :: TyVarBind a -> Bool #

length :: TyVarBind a -> Int #

elem :: Eq a => a -> TyVarBind a -> Bool #

maximum :: Ord a => TyVarBind a -> a #

minimum :: Ord a => TyVarBind a -> a #

sum :: Num a => TyVarBind a -> a #

product :: Num a => TyVarBind a -> a #

Traversable TyVarBind Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> TyVarBind a -> f (TyVarBind b) #

sequenceA :: Applicative f => TyVarBind (f a) -> f (TyVarBind a) #

mapM :: Monad m => (a -> m b) -> TyVarBind a -> m (TyVarBind b) #

sequence :: Monad m => TyVarBind (m a) -> m (TyVarBind a) #

Annotated TyVarBind Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: TyVarBind l -> l Source #

amap :: (l -> l) -> TyVarBind l -> TyVarBind l Source #

ExactP TyVarBind Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: TyVarBind SrcSpanInfo -> EP ()

Eq l => Eq (TyVarBind l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: TyVarBind l -> TyVarBind l -> Bool #

(/=) :: TyVarBind l -> TyVarBind l -> Bool #

Data l => Data (TyVarBind l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyVarBind l -> c (TyVarBind l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (TyVarBind l) #

toConstr :: TyVarBind l -> Constr #

dataTypeOf :: TyVarBind l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (TyVarBind l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (TyVarBind l)) #

gmapT :: (forall b. Data b => b -> b) -> TyVarBind l -> TyVarBind l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyVarBind l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyVarBind l -> r #

gmapQ :: (forall d. Data d => d -> u) -> TyVarBind l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> TyVarBind l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyVarBind l -> m (TyVarBind l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyVarBind l -> m (TyVarBind l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyVarBind l -> m (TyVarBind l) #

Ord l => Ord (TyVarBind l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Show l => Show (TyVarBind l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Generic (TyVarBind l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (TyVarBind l) :: Type -> Type #

Methods

from :: TyVarBind l -> Rep (TyVarBind l) x #

to :: Rep (TyVarBind l) x -> TyVarBind l #

Pretty (TyVarBind l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: TyVarBind l -> Doc

prettyPrec :: Int -> TyVarBind l -> Doc

type Rep (TyVarBind l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data Promoted l Source #

Bools here are True if there was a leading quote which may be left out. For example '[k1,k2] means the same thing as [k1,k2].

Constructors

PromotedInteger l Integer String

parsed value and raw string

PromotedString l String String

parsed value and raw string

PromotedCon l Bool (QName l) 
PromotedList l Bool [Type l] 
PromotedTuple l [Type l] 
PromotedUnit l 
Instances
Functor Promoted Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Promoted a -> Promoted b #

(<$) :: a -> Promoted b -> Promoted a #

Foldable Promoted Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Promoted m -> m #

foldMap :: Monoid m => (a -> m) -> Promoted a -> m #

foldr :: (a -> b -> b) -> b -> Promoted a -> b #

foldr' :: (a -> b -> b) -> b -> Promoted a -> b #

foldl :: (b -> a -> b) -> b -> Promoted a -> b #

foldl' :: (b -> a -> b) -> b -> Promoted a -> b #

foldr1 :: (a -> a -> a) -> Promoted a -> a #

foldl1 :: (a -> a -> a) -> Promoted a -> a #

toList :: Promoted a -> [a] #

null :: Promoted a -> Bool #

length :: Promoted a -> Int #

elem :: Eq a => a -> Promoted a -> Bool #

maximum :: Ord a => Promoted a -> a #

minimum :: Ord a => Promoted a -> a #

sum :: Num a => Promoted a -> a #

product :: Num a => Promoted a -> a #

Traversable Promoted Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> Promoted a -> f (Promoted b) #

sequenceA :: Applicative f => Promoted (f a) -> f (Promoted a) #

mapM :: Monad m => (a -> m b) -> Promoted a -> m (Promoted b) #

sequence :: Monad m => Promoted (m a) -> m (Promoted a) #

Annotated Promoted Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Promoted l -> l Source #

amap :: (l -> l) -> Promoted l -> Promoted l Source #

ExactP Promoted Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Promoted SrcSpanInfo -> EP ()

Eq l => Eq (Promoted l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: Promoted l -> Promoted l -> Bool #

(/=) :: Promoted l -> Promoted l -> Bool #

Data l => Data (Promoted l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Promoted l -> c (Promoted l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Promoted l) #

toConstr :: Promoted l -> Constr #

dataTypeOf :: Promoted l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Promoted l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Promoted l)) #

gmapT :: (forall b. Data b => b -> b) -> Promoted l -> Promoted l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Promoted l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Promoted l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Promoted l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Promoted l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Promoted l -> m (Promoted l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Promoted l -> m (Promoted l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Promoted l -> m (Promoted l) #

Ord l => Ord (Promoted l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: Promoted l -> Promoted l -> Ordering #

(<) :: Promoted l -> Promoted l -> Bool #

(<=) :: Promoted l -> Promoted l -> Bool #

(>) :: Promoted l -> Promoted l -> Bool #

(>=) :: Promoted l -> Promoted l -> Bool #

max :: Promoted l -> Promoted l -> Promoted l #

min :: Promoted l -> Promoted l -> Promoted l #

Show l => Show (Promoted l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> Promoted l -> ShowS #

show :: Promoted l -> String #

showList :: [Promoted l] -> ShowS #

Generic (Promoted l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Promoted l) :: Type -> Type #

Methods

from :: Promoted l -> Rep (Promoted l) x #

to :: Rep (Promoted l) x -> Promoted l #

Pretty (Promoted l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Promoted l -> Doc

prettyPrec :: Int -> Promoted l -> Doc

type Rep (Promoted l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (Promoted l) = D1 (MetaData "Promoted" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-Z8xb2tkymYIClPofvAOw3" False) ((C1 (MetaCons "PromotedInteger" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Integer) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String))) :+: (C1 (MetaCons "PromotedString" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String))) :+: C1 (MetaCons "PromotedCon" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Bool) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l)))))) :+: (C1 (MetaCons "PromotedList" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Bool) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Type l]))) :+: (C1 (MetaCons "PromotedTuple" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Type l])) :+: C1 (MetaCons "PromotedUnit" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)))))

data TypeEqn l Source #

A type equation as found in closed type families.

Constructors

TypeEqn l (Type l) (Type l) 
Instances
Functor TypeEqn Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> TypeEqn a -> TypeEqn b #

(<$) :: a -> TypeEqn b -> TypeEqn a #

Foldable TypeEqn Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => TypeEqn m -> m #

foldMap :: Monoid m => (a -> m) -> TypeEqn a -> m #

foldr :: (a -> b -> b) -> b -> TypeEqn a -> b #

foldr' :: (a -> b -> b) -> b -> TypeEqn a -> b #

foldl :: (b -> a -> b) -> b -> TypeEqn a -> b #

foldl' :: (b -> a -> b) -> b -> TypeEqn a -> b #

foldr1 :: (a -> a -> a) -> TypeEqn a -> a #

foldl1 :: (a -> a -> a) -> TypeEqn a -> a #

toList :: TypeEqn a -> [a] #

null :: TypeEqn a -> Bool #

length :: TypeEqn a -> Int #

elem :: Eq a => a -> TypeEqn a -> Bool #

maximum :: Ord a => TypeEqn a -> a #

minimum :: Ord a => TypeEqn a -> a #

sum :: Num a => TypeEqn a -> a #

product :: Num a => TypeEqn a -> a #

Traversable TypeEqn Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> TypeEqn a -> f (TypeEqn b) #

sequenceA :: Applicative f => TypeEqn (f a) -> f (TypeEqn a) #

mapM :: Monad m => (a -> m b) -> TypeEqn a -> m (TypeEqn b) #

sequence :: Monad m => TypeEqn (m a) -> m (TypeEqn a) #

Annotated TypeEqn Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: TypeEqn l -> l Source #

amap :: (l -> l) -> TypeEqn l -> TypeEqn l Source #

ExactP TypeEqn Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: TypeEqn SrcSpanInfo -> EP ()

Eq l => Eq (TypeEqn l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: TypeEqn l -> TypeEqn l -> Bool #

(/=) :: TypeEqn l -> TypeEqn l -> Bool #

Data l => Data (TypeEqn l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TypeEqn l -> c (TypeEqn l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (TypeEqn l) #

toConstr :: TypeEqn l -> Constr #

dataTypeOf :: TypeEqn l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (TypeEqn l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (TypeEqn l)) #

gmapT :: (forall b. Data b => b -> b) -> TypeEqn l -> TypeEqn l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TypeEqn l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TypeEqn l -> r #

gmapQ :: (forall d. Data d => d -> u) -> TypeEqn l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> TypeEqn l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TypeEqn l -> m (TypeEqn l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeEqn l -> m (TypeEqn l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeEqn l -> m (TypeEqn l) #

Ord l => Ord (TypeEqn l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: TypeEqn l -> TypeEqn l -> Ordering #

(<) :: TypeEqn l -> TypeEqn l -> Bool #

(<=) :: TypeEqn l -> TypeEqn l -> Bool #

(>) :: TypeEqn l -> TypeEqn l -> Bool #

(>=) :: TypeEqn l -> TypeEqn l -> Bool #

max :: TypeEqn l -> TypeEqn l -> TypeEqn l #

min :: TypeEqn l -> TypeEqn l -> TypeEqn l #

Show l => Show (TypeEqn l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> TypeEqn l -> ShowS #

show :: TypeEqn l -> String #

showList :: [TypeEqn l] -> ShowS #

Generic (TypeEqn l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (TypeEqn l) :: Type -> Type #

Methods

from :: TypeEqn l -> Rep (TypeEqn l) x #

to :: Rep (TypeEqn l) x -> TypeEqn l #

Pretty (TypeEqn l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: TypeEqn l -> Doc

prettyPrec :: Int -> TypeEqn l -> Doc

type Rep (TypeEqn l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Expressions

data Exp l Source #

Haskell expressions.

Constructors

Var l (QName l)

variable

OverloadedLabel l String

Overloaded label #foo

IPVar l (IPName l)

implicit parameter variable

Con l (QName l)

data constructor

Lit l (Literal l)

literal constant

InfixApp l (Exp l) (QOp l) (Exp l)

infix application

App l (Exp l) (Exp l)

ordinary application

NegApp l (Exp l)

negation expression -exp (unary minus)

Lambda l [Pat l] (Exp l)

lambda expression

Let l (Binds l) (Exp l)

local declarations with let ... in ...

If l (Exp l) (Exp l) (Exp l)

if exp then exp else exp

MultiIf l [GuardedRhs l]

if | stmts -> exp ...

Case l (Exp l) [Alt l]

case exp of alts

Do l [Stmt l]

do-expression: the last statement in the list should be an expression.

MDo l [Stmt l]

mdo-expression

Tuple l Boxed [Exp l]

tuple expression

UnboxedSum l Int Int (Exp l)

unboxed sum

TupleSection l Boxed [Maybe (Exp l)]

tuple section expression, e.g. (,,3)

List l [Exp l]

list expression

ParArray l [Exp l]

parallel array expression

Paren l (Exp l)

parenthesised expression

LeftSection l (Exp l) (QOp l)

left section (exp qop)

RightSection l (QOp l) (Exp l)

right section (qop exp)

RecConstr l (QName l) [FieldUpdate l]

record construction expression

RecUpdate l (Exp l) [FieldUpdate l]

record update expression

EnumFrom l (Exp l)

unbounded arithmetic sequence, incrementing by 1: [from ..]

EnumFromTo l (Exp l) (Exp l)

bounded arithmetic sequence, incrementing by 1 [from .. to]

EnumFromThen l (Exp l) (Exp l)

unbounded arithmetic sequence, with first two elements given [from, then ..]

EnumFromThenTo l (Exp l) (Exp l) (Exp l)

bounded arithmetic sequence, with first two elements given [from, then .. to]

ParArrayFromTo l (Exp l) (Exp l)

Parallel array bounded arithmetic sequence, incrementing by 1 [:from .. to:]

ParArrayFromThenTo l (Exp l) (Exp l) (Exp l)

bounded arithmetic sequence, with first two elements given [:from, then .. to:]

ListComp l (Exp l) [QualStmt l]

ordinary list comprehension

ParComp l (Exp l) [[QualStmt l]]

parallel list comprehension

ParArrayComp l (Exp l) [[QualStmt l]]

parallel array comprehension

ExpTypeSig l (Exp l) (Type l)

expression with explicit type signature

VarQuote l (QName l)

'x for template haskell reifying of expressions

TypQuote l (QName l)

''T for template haskell reifying of types

BracketExp l (Bracket l)

template haskell bracket expression

SpliceExp l (Splice l)

template haskell splice expression

QuasiQuote l String String

quasi-quotaion: [$name| string |]

TypeApp l (Type l)

Visible type application

XTag l (XName l) [XAttr l] (Maybe (Exp l)) [Exp l]

xml element, with attributes and children

XETag l (XName l) [XAttr l] (Maybe (Exp l))

empty xml element, with attributes

XPcdata l String

PCDATA child element

XExpTag l (Exp l)

escaped haskell expression inside xml

XChildTag l [Exp l]

children of an xml element

CorePragma l String (Exp l)

CORE pragma

SCCPragma l String (Exp l)

SCC pragma

GenPragma l String (Int, Int) (Int, Int) (Exp l)

GENERATED pragma

Proc l (Pat l) (Exp l)

arrows proc: proc pat -> exp

LeftArrApp l (Exp l) (Exp l)

arrow application (from left): exp -< exp

RightArrApp l (Exp l) (Exp l)

arrow application (from right): exp >- exp

LeftArrHighApp l (Exp l) (Exp l)

higher-order arrow application (from left): exp -<< exp

RightArrHighApp l (Exp l) (Exp l)

higher-order arrow application (from right): exp >>- exp

ArrOp l (Exp l)

arrow control operators: (| exp |)

LCase l [Alt l]

case alts

Instances
Functor Exp Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Exp a -> Exp b #

(<$) :: a -> Exp b -> Exp a #

Foldable Exp Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Exp m -> m #

foldMap :: Monoid m => (a -> m) -> Exp a -> m #

foldr :: (a -> b -> b) -> b -> Exp a -> b #

foldr' :: (a -> b -> b) -> b -> Exp a -> b #

foldl :: (b -> a -> b) -> b -> Exp a -> b #

foldl' :: (b -> a -> b) -> b -> Exp a -> b #

foldr1 :: (a -> a -> a) -> Exp a -> a #

foldl1 :: (a -> a -> a) -> Exp a -> a #

toList :: Exp a -> [a] #

null :: Exp a -> Bool #

length :: Exp a -> Int #

elem :: Eq a => a -> Exp a -> Bool #

maximum :: Ord a => Exp a -> a #

minimum :: Ord a => Exp a -> a #

sum :: Num a => Exp a -> a #

product :: Num a => Exp a -> a #

Traversable Exp Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> Exp a -> f (Exp b) #

sequenceA :: Applicative f => Exp (f a) -> f (Exp a) #

mapM :: Monad m => (a -> m b) -> Exp a -> m (Exp b) #

sequence :: Monad m => Exp (m a) -> m (Exp a) #

Annotated Exp Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Exp l -> l Source #

amap :: (l -> l) -> Exp l -> Exp l Source #

AppFixity Exp Source # 
Instance details

Defined in Language.Haskell.Exts.Fixity

ExactP Exp Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Exp SrcSpanInfo -> EP ()

Eq l => Eq (Exp l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: Exp l -> Exp l -> Bool #

(/=) :: Exp l -> Exp l -> Bool #

Data l => Data (Exp l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Exp l -> c (Exp l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Exp l) #

toConstr :: Exp l -> Constr #

dataTypeOf :: Exp l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Exp l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Exp l)) #

gmapT :: (forall b. Data b => b -> b) -> Exp l -> Exp l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Exp l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Exp l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Exp l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Exp l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Exp l -> m (Exp l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Exp l -> m (Exp l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Exp l -> m (Exp l) #

Ord l => Ord (Exp l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: Exp l -> Exp l -> Ordering #

(<) :: Exp l -> Exp l -> Bool #

(<=) :: Exp l -> Exp l -> Bool #

(>) :: Exp l -> Exp l -> Bool #

(>=) :: Exp l -> Exp l -> Bool #

max :: Exp l -> Exp l -> Exp l #

min :: Exp l -> Exp l -> Exp l #

Show l => Show (Exp l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> Exp l -> ShowS #

show :: Exp l -> String #

showList :: [Exp l] -> ShowS #

Generic (Exp l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Exp l) :: Type -> Type #

Methods

from :: Exp l -> Rep (Exp l) x #

to :: Rep (Exp l) x -> Exp l #

Pretty (Exp l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Exp l -> Doc

prettyPrec :: Int -> Exp l -> Doc

Parseable (Exp SrcSpanInfo) Source # 
Instance details

Defined in Language.Haskell.Exts.Parser

type Rep (Exp l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (Exp l) = D1 (MetaData "Exp" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-Z8xb2tkymYIClPofvAOw3" False) (((((C1 (MetaCons "Var" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l))) :+: (C1 (MetaCons "OverloadedLabel" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)) :+: C1 (MetaCons "IPVar" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (IPName l))))) :+: ((C1 (MetaCons "Con" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l))) :+: C1 (MetaCons "Lit" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Literal l)))) :+: (C1 (MetaCons "InfixApp" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QOp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)))) :+: C1 (MetaCons "App" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l))))))) :+: ((C1 (MetaCons "NegApp" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l))) :+: (C1 (MetaCons "Lambda" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Pat l]) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)))) :+: C1 (MetaCons "Let" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Binds l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)))))) :+: ((C1 (MetaCons "If" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)))) :+: C1 (MetaCons "MultiIf" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [GuardedRhs l]))) :+: (C1 (MetaCons "Case" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Alt l]))) :+: C1 (MetaCons "Do" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Stmt l])))))) :+: (((C1 (MetaCons "MDo" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Stmt l])) :+: (C1 (MetaCons "Tuple" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Boxed) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Exp l]))) :+: C1 (MetaCons "UnboxedSum" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int)) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)))))) :+: ((C1 (MetaCons "TupleSection" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Boxed) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Maybe (Exp l)]))) :+: C1 (MetaCons "List" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Exp l]))) :+: (C1 (MetaCons "ParArray" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Exp l])) :+: C1 (MetaCons "Paren" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)))))) :+: ((C1 (MetaCons "LeftSection" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QOp l)))) :+: (C1 (MetaCons "RightSection" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QOp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)))) :+: C1 (MetaCons "RecConstr" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [FieldUpdate l]))))) :+: ((C1 (MetaCons "RecUpdate" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [FieldUpdate l]))) :+: C1 (MetaCons "EnumFrom" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)))) :+: (C1 (MetaCons "EnumFromTo" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)))) :+: C1 (MetaCons "EnumFromThen" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l))))))))) :+: ((((C1 (MetaCons "EnumFromThenTo" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)))) :+: (C1 (MetaCons "ParArrayFromTo" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)))) :+: C1 (MetaCons "ParArrayFromThenTo" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)))))) :+: ((C1 (MetaCons "ListComp" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [QualStmt l]))) :+: C1 (MetaCons "ParComp" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [[QualStmt l]])))) :+: (C1 (MetaCons "ParArrayComp" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [[QualStmt l]]))) :+: C1 (MetaCons "ExpTypeSig" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l))))))) :+: ((C1 (MetaCons "VarQuote" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l))) :+: (C1 (MetaCons "TypQuote" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l))) :+: C1 (MetaCons "BracketExp" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Bracket l))))) :+: ((C1 (MetaCons "SpliceExp" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Splice l))) :+: C1 (MetaCons "QuasiQuote" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)))) :+: (C1 (MetaCons "TypeApp" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l))) :+: C1 (MetaCons "XTag" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (XName l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [XAttr l]) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Exp l))) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Exp l])))))))) :+: (((C1 (MetaCons "XETag" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (XName l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [XAttr l]) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Exp l))))) :+: (C1 (MetaCons "XPcdata" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)) :+: C1 (MetaCons "XExpTag" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l))))) :+: ((C1 (MetaCons "XChildTag" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Exp l])) :+: C1 (MetaCons "CorePragma" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l))))) :+: (C1 (MetaCons "SCCPragma" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)))) :+: C1 (MetaCons "GenPragma" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Int, Int)) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Int, Int)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)))))))) :+: ((C1 (MetaCons "Proc" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Pat l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)))) :+: (C1 (MetaCons "LeftArrApp" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)))) :+: C1 (MetaCons "RightArrApp" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)))))) :+: ((C1 (MetaCons "LeftArrHighApp" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)))) :+: C1 (MetaCons "RightArrHighApp" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l))))) :+: (C1 (MetaCons "ArrOp" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l))) :+: C1 (MetaCons "LCase" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Alt l]))))))))

data Stmt l Source #

A statement, representing both a stmt in a do-expression, an ordinary qual in a list comprehension, as well as a stmt in a pattern guard.

Constructors

Generator l (Pat l) (Exp l)

a generator: pat <- exp

Qualifier l (Exp l)

an exp by itself: in a do-expression, an action whose result is discarded; in a list comprehension and pattern guard, a guard expression

LetStmt l (Binds l)

local bindings

RecStmt l [Stmt l]

a recursive binding group for arrows

Instances
Functor Stmt Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Stmt a -> Stmt b #

(<$) :: a -> Stmt b -> Stmt a #

Foldable Stmt Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Stmt m -> m #

foldMap :: Monoid m => (a -> m) -> Stmt a -> m #

foldr :: (a -> b -> b) -> b -> Stmt a -> b #

foldr' :: (a -> b -> b) -> b -> Stmt a -> b #

foldl :: (b -> a -> b) -> b -> Stmt a -> b #

foldl' :: (b -> a -> b) -> b -> Stmt a -> b #

foldr1 :: (a -> a -> a) -> Stmt a -> a #

foldl1 :: (a -> a -> a) -> Stmt a -> a #

toList :: Stmt a -> [a] #

null :: Stmt a -> Bool #

length :: Stmt a -> Int #

elem :: Eq a => a -> Stmt a -> Bool #

maximum :: Ord a => Stmt a -> a #

minimum :: Ord a => Stmt a -> a #

sum :: Num a => Stmt a -> a #

product :: Num a => Stmt a -> a #

Traversable Stmt Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> Stmt a -> f (Stmt b) #

sequenceA :: Applicative f => Stmt (f a) -> f (Stmt a) #

mapM :: Monad m => (a -> m b) -> Stmt a -> m (Stmt b) #

sequence :: Monad m => Stmt (m a) -> m (Stmt a) #

Annotated Stmt Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Stmt l -> l Source #

amap :: (l -> l) -> Stmt l -> Stmt l Source #

AppFixity Stmt Source # 
Instance details

Defined in Language.Haskell.Exts.Fixity

ExactP Stmt Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Stmt SrcSpanInfo -> EP ()

Eq l => Eq (Stmt l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: Stmt l -> Stmt l -> Bool #

(/=) :: Stmt l -> Stmt l -> Bool #

Data l => Data (Stmt l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Stmt l -> c (Stmt l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Stmt l) #

toConstr :: Stmt l -> Constr #

dataTypeOf :: Stmt l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Stmt l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Stmt l)) #

gmapT :: (forall b. Data b => b -> b) -> Stmt l -> Stmt l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Stmt l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Stmt l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Stmt l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Stmt l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Stmt l -> m (Stmt l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Stmt l -> m (Stmt l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Stmt l -> m (Stmt l) #

Ord l => Ord (Stmt l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: Stmt l -> Stmt l -> Ordering #

(<) :: Stmt l -> Stmt l -> Bool #

(<=) :: Stmt l -> Stmt l -> Bool #

(>) :: Stmt l -> Stmt l -> Bool #

(>=) :: Stmt l -> Stmt l -> Bool #

max :: Stmt l -> Stmt l -> Stmt l #

min :: Stmt l -> Stmt l -> Stmt l #

Show l => Show (Stmt l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> Stmt l -> ShowS #

show :: Stmt l -> String #

showList :: [Stmt l] -> ShowS #

Generic (Stmt l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Stmt l) :: Type -> Type #

Methods

from :: Stmt l -> Rep (Stmt l) x #

to :: Rep (Stmt l) x -> Stmt l #

Pretty (Stmt l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Stmt l -> Doc

prettyPrec :: Int -> Stmt l -> Doc

Parseable (Stmt SrcSpanInfo) Source # 
Instance details

Defined in Language.Haskell.Exts.Parser

type Rep (Stmt l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data QualStmt l Source #

A general transqual in a list comprehension, which could potentially be a transform of the kind enabled by TransformListComp.

Constructors

QualStmt l (Stmt l)

an ordinary statement

ThenTrans l (Exp l)

then exp

ThenBy l (Exp l) (Exp l)

then exp by exp

GroupBy l (Exp l)

then group by exp

GroupUsing l (Exp l)

then group using exp

GroupByUsing l (Exp l) (Exp l)

then group by exp using exp

Instances
Functor QualStmt Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> QualStmt a -> QualStmt b #

(<$) :: a -> QualStmt b -> QualStmt a #

Foldable QualStmt Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => QualStmt m -> m #

foldMap :: Monoid m => (a -> m) -> QualStmt a -> m #

foldr :: (a -> b -> b) -> b -> QualStmt a -> b #

foldr' :: (a -> b -> b) -> b -> QualStmt a -> b #

foldl :: (b -> a -> b) -> b -> QualStmt a -> b #

foldl' :: (b -> a -> b) -> b -> QualStmt a -> b #

foldr1 :: (a -> a -> a) -> QualStmt a -> a #

foldl1 :: (a -> a -> a) -> QualStmt a -> a #

toList :: QualStmt a -> [a] #

null :: QualStmt a -> Bool #

length :: QualStmt a -> Int #

elem :: Eq a => a -> QualStmt a -> Bool #

maximum :: Ord a => QualStmt a -> a #

minimum :: Ord a => QualStmt a -> a #

sum :: Num a => QualStmt a -> a #

product :: Num a => QualStmt a -> a #

Traversable QualStmt Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> QualStmt a -> f (QualStmt b) #

sequenceA :: Applicative f => QualStmt (f a) -> f (QualStmt a) #

mapM :: Monad m => (a -> m b) -> QualStmt a -> m (QualStmt b) #

sequence :: Monad m => QualStmt (m a) -> m (QualStmt a) #

Annotated QualStmt Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: QualStmt l -> l Source #

amap :: (l -> l) -> QualStmt l -> QualStmt l Source #

AppFixity QualStmt Source # 
Instance details

Defined in Language.Haskell.Exts.Fixity

ExactP QualStmt Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: QualStmt SrcSpanInfo -> EP ()

Eq l => Eq (QualStmt l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: QualStmt l -> QualStmt l -> Bool #

(/=) :: QualStmt l -> QualStmt l -> Bool #

Data l => Data (QualStmt l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> QualStmt l -> c (QualStmt l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (QualStmt l) #

toConstr :: QualStmt l -> Constr #

dataTypeOf :: QualStmt l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (QualStmt l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (QualStmt l)) #

gmapT :: (forall b. Data b => b -> b) -> QualStmt l -> QualStmt l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> QualStmt l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> QualStmt l -> r #

gmapQ :: (forall d. Data d => d -> u) -> QualStmt l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> QualStmt l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> QualStmt l -> m (QualStmt l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> QualStmt l -> m (QualStmt l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> QualStmt l -> m (QualStmt l) #

Ord l => Ord (QualStmt l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: QualStmt l -> QualStmt l -> Ordering #

(<) :: QualStmt l -> QualStmt l -> Bool #

(<=) :: QualStmt l -> QualStmt l -> Bool #

(>) :: QualStmt l -> QualStmt l -> Bool #

(>=) :: QualStmt l -> QualStmt l -> Bool #

max :: QualStmt l -> QualStmt l -> QualStmt l #

min :: QualStmt l -> QualStmt l -> QualStmt l #

Show l => Show (QualStmt l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> QualStmt l -> ShowS #

show :: QualStmt l -> String #

showList :: [QualStmt l] -> ShowS #

Generic (QualStmt l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (QualStmt l) :: Type -> Type #

Methods

from :: QualStmt l -> Rep (QualStmt l) x #

to :: Rep (QualStmt l) x -> QualStmt l #

Pretty (QualStmt l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: QualStmt l -> Doc

prettyPrec :: Int -> QualStmt l -> Doc

type Rep (QualStmt l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (QualStmt l) = D1 (MetaData "QualStmt" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-Z8xb2tkymYIClPofvAOw3" False) ((C1 (MetaCons "QualStmt" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Stmt l))) :+: (C1 (MetaCons "ThenTrans" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l))) :+: C1 (MetaCons "ThenBy" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)))))) :+: (C1 (MetaCons "GroupBy" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l))) :+: (C1 (MetaCons "GroupUsing" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l))) :+: C1 (MetaCons "GroupByUsing" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)))))))

data FieldUpdate l Source #

An fbind in a labeled construction or update expression.

Constructors

FieldUpdate l (QName l) (Exp l)

ordinary label-expresion pair

FieldPun l (QName l)

record field pun

FieldWildcard l

record field wildcard

Instances
Functor FieldUpdate Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> FieldUpdate a -> FieldUpdate b #

(<$) :: a -> FieldUpdate b -> FieldUpdate a #

Foldable FieldUpdate Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => FieldUpdate m -> m #

foldMap :: Monoid m => (a -> m) -> FieldUpdate a -> m #

foldr :: (a -> b -> b) -> b -> FieldUpdate a -> b #

foldr' :: (a -> b -> b) -> b -> FieldUpdate a -> b #

foldl :: (b -> a -> b) -> b -> FieldUpdate a -> b #

foldl' :: (b -> a -> b) -> b -> FieldUpdate a -> b #

foldr1 :: (a -> a -> a) -> FieldUpdate a -> a #

foldl1 :: (a -> a -> a) -> FieldUpdate a -> a #

toList :: FieldUpdate a -> [a] #

null :: FieldUpdate a -> Bool #

length :: FieldUpdate a -> Int #

elem :: Eq a => a -> FieldUpdate a -> Bool #

maximum :: Ord a => FieldUpdate a -> a #

minimum :: Ord a => FieldUpdate a -> a #

sum :: Num a => FieldUpdate a -> a #

product :: Num a => FieldUpdate a -> a #

Traversable FieldUpdate Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> FieldUpdate a -> f (FieldUpdate b) #

sequenceA :: Applicative f => FieldUpdate (f a) -> f (FieldUpdate a) #

mapM :: Monad m => (a -> m b) -> FieldUpdate a -> m (FieldUpdate b) #

sequence :: Monad m => FieldUpdate (m a) -> m (FieldUpdate a) #

Annotated FieldUpdate Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: FieldUpdate l -> l Source #

amap :: (l -> l) -> FieldUpdate l -> FieldUpdate l Source #

AppFixity FieldUpdate Source # 
Instance details

Defined in Language.Haskell.Exts.Fixity

ExactP FieldUpdate Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: FieldUpdate SrcSpanInfo -> EP ()

Eq l => Eq (FieldUpdate l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Data l => Data (FieldUpdate l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FieldUpdate l -> c (FieldUpdate l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FieldUpdate l) #

toConstr :: FieldUpdate l -> Constr #

dataTypeOf :: FieldUpdate l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FieldUpdate l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FieldUpdate l)) #

gmapT :: (forall b. Data b => b -> b) -> FieldUpdate l -> FieldUpdate l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FieldUpdate l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FieldUpdate l -> r #

gmapQ :: (forall d. Data d => d -> u) -> FieldUpdate l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FieldUpdate l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FieldUpdate l -> m (FieldUpdate l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldUpdate l -> m (FieldUpdate l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldUpdate l -> m (FieldUpdate l) #

Ord l => Ord (FieldUpdate l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Show l => Show (FieldUpdate l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Generic (FieldUpdate l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (FieldUpdate l) :: Type -> Type #

Methods

from :: FieldUpdate l -> Rep (FieldUpdate l) x #

to :: Rep (FieldUpdate l) x -> FieldUpdate l #

Pretty (FieldUpdate l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: FieldUpdate l -> Doc

prettyPrec :: Int -> FieldUpdate l -> Doc

type Rep (FieldUpdate l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data Alt l Source #

An alt alternative in a case expression.

Constructors

Alt l (Pat l) (Rhs l) (Maybe (Binds l)) 
Instances
Functor Alt Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Alt a -> Alt b #

(<$) :: a -> Alt b -> Alt a #

Foldable Alt Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Alt m -> m #

foldMap :: Monoid m => (a -> m) -> Alt a -> m #

foldr :: (a -> b -> b) -> b -> Alt a -> b #

foldr' :: (a -> b -> b) -> b -> Alt a -> b #

foldl :: (b -> a -> b) -> b -> Alt a -> b #

foldl' :: (b -> a -> b) -> b -> Alt a -> b #

foldr1 :: (a -> a -> a) -> Alt a -> a #

foldl1 :: (a -> a -> a) -> Alt a -> a #

toList :: Alt a -> [a] #

null :: Alt a -> Bool #

length :: Alt a -> Int #

elem :: Eq a => a -> Alt a -> Bool #

maximum :: Ord a => Alt a -> a #

minimum :: Ord a => Alt a -> a #

sum :: Num a => Alt a -> a #

product :: Num a => Alt a -> a #

Traversable Alt Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> Alt a -> f (Alt b) #

sequenceA :: Applicative f => Alt (f a) -> f (Alt a) #

mapM :: Monad m => (a -> m b) -> Alt a -> m (Alt b) #

sequence :: Monad m => Alt (m a) -> m (Alt a) #

Annotated Alt Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Alt l -> l Source #

amap :: (l -> l) -> Alt l -> Alt l Source #

AppFixity Alt Source # 
Instance details

Defined in Language.Haskell.Exts.Fixity

ExactP Alt Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Alt SrcSpanInfo -> EP ()

Eq l => Eq (Alt l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: Alt l -> Alt l -> Bool #

(/=) :: Alt l -> Alt l -> Bool #

Data l => Data (Alt l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Alt l -> c (Alt l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Alt l) #

toConstr :: Alt l -> Constr #

dataTypeOf :: Alt l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Alt l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Alt l)) #

gmapT :: (forall b. Data b => b -> b) -> Alt l -> Alt l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alt l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Alt l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Alt l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Alt l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Alt l -> m (Alt l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Alt l -> m (Alt l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Alt l -> m (Alt l) #

Ord l => Ord (Alt l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: Alt l -> Alt l -> Ordering #

(<) :: Alt l -> Alt l -> Bool #

(<=) :: Alt l -> Alt l -> Bool #

(>) :: Alt l -> Alt l -> Bool #

(>=) :: Alt l -> Alt l -> Bool #

max :: Alt l -> Alt l -> Alt l #

min :: Alt l -> Alt l -> Alt l #

Show l => Show (Alt l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> Alt l -> ShowS #

show :: Alt l -> String #

showList :: [Alt l] -> ShowS #

Generic (Alt l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Alt l) :: Type -> Type #

Methods

from :: Alt l -> Rep (Alt l) x #

to :: Rep (Alt l) x -> Alt l #

Pretty (Alt l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Alt l -> Doc

prettyPrec :: Int -> Alt l -> Doc

type Rep (Alt l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data XAttr l Source #

An xml attribute, which is a name-expression pair.

Constructors

XAttr l (XName l) (Exp l) 
Instances
Functor XAttr Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> XAttr a -> XAttr b #

(<$) :: a -> XAttr b -> XAttr a #

Foldable XAttr Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => XAttr m -> m #

foldMap :: Monoid m => (a -> m) -> XAttr a -> m #

foldr :: (a -> b -> b) -> b -> XAttr a -> b #

foldr' :: (a -> b -> b) -> b -> XAttr a -> b #

foldl :: (b -> a -> b) -> b -> XAttr a -> b #

foldl' :: (b -> a -> b) -> b -> XAttr a -> b #

foldr1 :: (a -> a -> a) -> XAttr a -> a #

foldl1 :: (a -> a -> a) -> XAttr a -> a #

toList :: XAttr a -> [a] #

null :: XAttr a -> Bool #

length :: XAttr a -> Int #

elem :: Eq a => a -> XAttr a -> Bool #

maximum :: Ord a => XAttr a -> a #

minimum :: Ord a => XAttr a -> a #

sum :: Num a => XAttr a -> a #

product :: Num a => XAttr a -> a #

Traversable XAttr Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> XAttr a -> f (XAttr b) #

sequenceA :: Applicative f => XAttr (f a) -> f (XAttr a) #

mapM :: Monad m => (a -> m b) -> XAttr a -> m (XAttr b) #

sequence :: Monad m => XAttr (m a) -> m (XAttr a) #

Annotated XAttr Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: XAttr l -> l Source #

amap :: (l -> l) -> XAttr l -> XAttr l Source #

AppFixity XAttr Source # 
Instance details

Defined in Language.Haskell.Exts.Fixity

ExactP XAttr Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: XAttr SrcSpanInfo -> EP ()

Eq l => Eq (XAttr l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: XAttr l -> XAttr l -> Bool #

(/=) :: XAttr l -> XAttr l -> Bool #

Data l => Data (XAttr l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> XAttr l -> c (XAttr l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (XAttr l) #

toConstr :: XAttr l -> Constr #

dataTypeOf :: XAttr l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (XAttr l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (XAttr l)) #

gmapT :: (forall b. Data b => b -> b) -> XAttr l -> XAttr l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> XAttr l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> XAttr l -> r #

gmapQ :: (forall d. Data d => d -> u) -> XAttr l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> XAttr l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> XAttr l -> m (XAttr l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> XAttr l -> m (XAttr l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> XAttr l -> m (XAttr l) #

Ord l => Ord (XAttr l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: XAttr l -> XAttr l -> Ordering #

(<) :: XAttr l -> XAttr l -> Bool #

(<=) :: XAttr l -> XAttr l -> Bool #

(>) :: XAttr l -> XAttr l -> Bool #

(>=) :: XAttr l -> XAttr l -> Bool #

max :: XAttr l -> XAttr l -> XAttr l #

min :: XAttr l -> XAttr l -> XAttr l #

Show l => Show (XAttr l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> XAttr l -> ShowS #

show :: XAttr l -> String #

showList :: [XAttr l] -> ShowS #

Generic (XAttr l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (XAttr l) :: Type -> Type #

Methods

from :: XAttr l -> Rep (XAttr l) x #

to :: Rep (XAttr l) x -> XAttr l #

Pretty (XAttr l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: XAttr l -> Doc

prettyPrec :: Int -> XAttr l -> Doc

type Rep (XAttr l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Patterns

data Pat l Source #

A pattern, to be matched against a value.

Constructors

PVar l (Name l)

variable

PLit l (Sign l) (Literal l)

literal constant

PNPlusK l (Name l) Integer

n+k pattern

PInfixApp l (Pat l) (QName l) (Pat l)

pattern with an infix data constructor

PApp l (QName l) [Pat l]

data constructor and argument patterns

PTuple l Boxed [Pat l]

tuple pattern

PUnboxedSum l Int Int (Pat l)

unboxed sum

PList l [Pat l]

list pattern

PParen l (Pat l)

parenthesized pattern

PRec l (QName l) [PatField l]

labelled pattern, record style

PAsPat l (Name l) (Pat l)

@-pattern

PWildCard l

wildcard pattern: _

PIrrPat l (Pat l)

irrefutable pattern: ~pat

PatTypeSig l (Pat l) (Type l)

pattern with type signature

PViewPat l (Exp l) (Pat l)

view patterns of the form (exp -> pat)

PRPat l [RPat l]

regular list pattern

PXTag l (XName l) [PXAttr l] (Maybe (Pat l)) [Pat l]

XML element pattern

PXETag l (XName l) [PXAttr l] (Maybe (Pat l))

XML singleton element pattern

PXPcdata l String

XML PCDATA pattern

PXPatTag l (Pat l)

XML embedded pattern

PXRPats l [RPat l]

XML regular list pattern

PSplice l (Splice l)

template haskell splice pattern

PQuasiQuote l String String

quasi quote pattern: [$name| string |]

PBangPat l (Pat l)

strict (bang) pattern: f !x = ...

Instances
Functor Pat Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Pat a -> Pat b #

(<$) :: a -> Pat b -> Pat a #

Foldable Pat Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Pat m -> m #

foldMap :: Monoid m => (a -> m) -> Pat a -> m #

foldr :: (a -> b -> b) -> b -> Pat a -> b #

foldr' :: (a -> b -> b) -> b -> Pat a -> b #

foldl :: (b -> a -> b) -> b -> Pat a -> b #

foldl' :: (b -> a -> b) -> b -> Pat a -> b #

foldr1 :: (a -> a -> a) -> Pat a -> a #

foldl1 :: (a -> a -> a) -> Pat a -> a #

toList :: Pat a -> [a] #

null :: Pat a -> Bool #

length :: Pat a -> Int #

elem :: Eq a => a -> Pat a -> Bool #

maximum :: Ord a => Pat a -> a #

minimum :: Ord a => Pat a -> a #

sum :: Num a => Pat a -> a #

product :: Num a => Pat a -> a #

Traversable Pat Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> Pat a -> f (Pat b) #

sequenceA :: Applicative f => Pat (f a) -> f (Pat a) #

mapM :: Monad m => (a -> m b) -> Pat a -> m (Pat b) #

sequence :: Monad m => Pat (m a) -> m (Pat a) #

Annotated Pat Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Pat l -> l Source #

amap :: (l -> l) -> Pat l -> Pat l Source #

AppFixity Pat Source # 
Instance details

Defined in Language.Haskell.Exts.Fixity

ExactP Pat Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Pat SrcSpanInfo -> EP ()

Eq l => Eq (Pat l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: Pat l -> Pat l -> Bool #

(/=) :: Pat l -> Pat l -> Bool #

Data l => Data (Pat l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Pat l -> c (Pat l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Pat l) #

toConstr :: Pat l -> Constr #

dataTypeOf :: Pat l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Pat l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Pat l)) #

gmapT :: (forall b. Data b => b -> b) -> Pat l -> Pat l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pat l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pat l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Pat l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Pat l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Pat l -> m (Pat l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Pat l -> m (Pat l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Pat l -> m (Pat l) #

Ord l => Ord (Pat l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: Pat l -> Pat l -> Ordering #

(<) :: Pat l -> Pat l -> Bool #

(<=) :: Pat l -> Pat l -> Bool #

(>) :: Pat l -> Pat l -> Bool #

(>=) :: Pat l -> Pat l -> Bool #

max :: Pat l -> Pat l -> Pat l #

min :: Pat l -> Pat l -> Pat l #

Show l => Show (Pat l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> Pat l -> ShowS #

show :: Pat l -> String #

showList :: [Pat l] -> ShowS #

Generic (Pat l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Pat l) :: Type -> Type #

Methods

from :: Pat l -> Rep (Pat l) x #

to :: Rep (Pat l) x -> Pat l #

Pretty (Pat l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Pat l -> Doc

prettyPrec :: Int -> Pat l -> Doc

Parseable (Pat SrcSpanInfo) Source # 
Instance details

Defined in Language.Haskell.Exts.Parser

type Rep (Pat l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (Pat l) = D1 (MetaData "Pat" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-Z8xb2tkymYIClPofvAOw3" False) ((((C1 (MetaCons "PVar" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Name l))) :+: (C1 (MetaCons "PLit" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Sign l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Literal l)))) :+: C1 (MetaCons "PNPlusK" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Name l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Integer))))) :+: (C1 (MetaCons "PInfixApp" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Pat l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Pat l)))) :+: (C1 (MetaCons "PApp" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Pat l]))) :+: C1 (MetaCons "PTuple" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Boxed) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Pat l])))))) :+: ((C1 (MetaCons "PUnboxedSum" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int)) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Pat l)))) :+: (C1 (MetaCons "PList" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Pat l])) :+: C1 (MetaCons "PParen" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Pat l))))) :+: (C1 (MetaCons "PRec" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (QName l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [PatField l]))) :+: (C1 (MetaCons "PAsPat" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Name l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Pat l)))) :+: C1 (MetaCons "PWildCard" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)))))) :+: (((C1 (MetaCons "PIrrPat" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Pat l))) :+: (C1 (MetaCons "PatTypeSig" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Pat l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Type l)))) :+: C1 (MetaCons "PViewPat" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Exp l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Pat l)))))) :+: (C1 (MetaCons "PRPat" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [RPat l])) :+: (C1 (MetaCons "PXTag" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (XName l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [PXAttr l]) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Pat l))) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Pat l])))) :+: C1 (MetaCons "PXETag" PrefixI False) ((S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (XName l))) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [PXAttr l]) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Pat l)))))))) :+: ((C1 (MetaCons "PXPcdata" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)) :+: (C1 (MetaCons "PXPatTag" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Pat l))) :+: C1 (MetaCons "PXRPats" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [RPat l])))) :+: (C1 (MetaCons "PSplice" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Splice l))) :+: (C1 (MetaCons "PQuasiQuote" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String))) :+: C1 (MetaCons "PBangPat" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Pat l))))))))

data PatField l Source #

An fpat in a labeled record pattern.

Constructors

PFieldPat l (QName l) (Pat l)

ordinary label-pattern pair

PFieldPun l (QName l)

record field pun

PFieldWildcard l

record field wildcard

Instances
Functor PatField Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> PatField a -> PatField b #

(<$) :: a -> PatField b -> PatField a #

Foldable PatField Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => PatField m -> m #

foldMap :: Monoid m => (a -> m) -> PatField a -> m #

foldr :: (a -> b -> b) -> b -> PatField a -> b #

foldr' :: (a -> b -> b) -> b -> PatField a -> b #

foldl :: (b -> a -> b) -> b -> PatField a -> b #

foldl' :: (b -> a -> b) -> b -> PatField a -> b #

foldr1 :: (a -> a -> a) -> PatField a -> a #

foldl1 :: (a -> a -> a) -> PatField a -> a #

toList :: PatField a -> [a] #

null :: PatField a -> Bool #

length :: PatField a -> Int #

elem :: Eq a => a -> PatField a -> Bool #

maximum :: Ord a => PatField a -> a #

minimum :: Ord a => PatField a -> a #

sum :: Num a => PatField a -> a #

product :: Num a => PatField a -> a #

Traversable PatField Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> PatField a -> f (PatField b) #

sequenceA :: Applicative f => PatField (f a) -> f (PatField a) #

mapM :: Monad m => (a -> m b) -> PatField a -> m (PatField b) #

sequence :: Monad m => PatField (m a) -> m (PatField a) #

Annotated PatField Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: PatField l -> l Source #

amap :: (l -> l) -> PatField l -> PatField l Source #

AppFixity PatField Source # 
Instance details

Defined in Language.Haskell.Exts.Fixity

ExactP PatField Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: PatField SrcSpanInfo -> EP ()

Eq l => Eq (PatField l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: PatField l -> PatField l -> Bool #

(/=) :: PatField l -> PatField l -> Bool #

Data l => Data (PatField l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PatField l -> c (PatField l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (PatField l) #

toConstr :: PatField l -> Constr #

dataTypeOf :: PatField l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (PatField l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (PatField l)) #

gmapT :: (forall b. Data b => b -> b) -> PatField l -> PatField l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PatField l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PatField l -> r #

gmapQ :: (forall d. Data d => d -> u) -> PatField l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> PatField l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> PatField l -> m (PatField l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PatField l -> m (PatField l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PatField l -> m (PatField l) #

Ord l => Ord (PatField l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: PatField l -> PatField l -> Ordering #

(<) :: PatField l -> PatField l -> Bool #

(<=) :: PatField l -> PatField l -> Bool #

(>) :: PatField l -> PatField l -> Bool #

(>=) :: PatField l -> PatField l -> Bool #

max :: PatField l -> PatField l -> PatField l #

min :: PatField l -> PatField l -> PatField l #

Show l => Show (PatField l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> PatField l -> ShowS #

show :: PatField l -> String #

showList :: [PatField l] -> ShowS #

Generic (PatField l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (PatField l) :: Type -> Type #

Methods

from :: PatField l -> Rep (PatField l) x #

to :: Rep (PatField l) x -> PatField l #

Pretty (PatField l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: PatField l -> Doc

prettyPrec :: Int -> PatField l -> Doc

type Rep (PatField l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data PXAttr l Source #

An XML attribute in a pattern.

Constructors

PXAttr l (XName l) (Pat l) 
Instances
Functor PXAttr Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> PXAttr a -> PXAttr b #

(<$) :: a -> PXAttr b -> PXAttr a #

Foldable PXAttr Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => PXAttr m -> m #

foldMap :: Monoid m => (a -> m) -> PXAttr a -> m #

foldr :: (a -> b -> b) -> b -> PXAttr a -> b #

foldr' :: (a -> b -> b) -> b -> PXAttr a -> b #

foldl :: (b -> a -> b) -> b -> PXAttr a -> b #

foldl' :: (b -> a -> b) -> b -> PXAttr a -> b #

foldr1 :: (a -> a -> a) -> PXAttr a -> a #

foldl1 :: (a -> a -> a) -> PXAttr a -> a #

toList :: PXAttr a -> [a] #

null :: PXAttr a -> Bool #

length :: PXAttr a -> Int #

elem :: Eq a => a -> PXAttr a -> Bool #

maximum :: Ord a => PXAttr a -> a #

minimum :: Ord a => PXAttr a -> a #

sum :: Num a => PXAttr a -> a #

product :: Num a => PXAttr a -> a #

Traversable PXAttr Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> PXAttr a -> f (PXAttr b) #

sequenceA :: Applicative f => PXAttr (f a) -> f (PXAttr a) #

mapM :: Monad m => (a -> m b) -> PXAttr a -> m (PXAttr b) #

sequence :: Monad m => PXAttr (m a) -> m (PXAttr a) #

Annotated PXAttr Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: PXAttr l -> l Source #

amap :: (l -> l) -> PXAttr l -> PXAttr l Source #

AppFixity PXAttr Source # 
Instance details

Defined in Language.Haskell.Exts.Fixity

ExactP PXAttr Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: PXAttr SrcSpanInfo -> EP ()

Eq l => Eq (PXAttr l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: PXAttr l -> PXAttr l -> Bool #

(/=) :: PXAttr l -> PXAttr l -> Bool #

Data l => Data (PXAttr l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PXAttr l -> c (PXAttr l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (PXAttr l) #

toConstr :: PXAttr l -> Constr #

dataTypeOf :: PXAttr l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (PXAttr l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (PXAttr l)) #

gmapT :: (forall b. Data b => b -> b) -> PXAttr l -> PXAttr l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PXAttr l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PXAttr l -> r #

gmapQ :: (forall d. Data d => d -> u) -> PXAttr l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> PXAttr l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> PXAttr l -> m (PXAttr l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PXAttr l -> m (PXAttr l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PXAttr l -> m (PXAttr l) #

Ord l => Ord (PXAttr l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: PXAttr l -> PXAttr l -> Ordering #

(<) :: PXAttr l -> PXAttr l -> Bool #

(<=) :: PXAttr l -> PXAttr l -> Bool #

(>) :: PXAttr l -> PXAttr l -> Bool #

(>=) :: PXAttr l -> PXAttr l -> Bool #

max :: PXAttr l -> PXAttr l -> PXAttr l #

min :: PXAttr l -> PXAttr l -> PXAttr l #

Show l => Show (PXAttr l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> PXAttr l -> ShowS #

show :: PXAttr l -> String #

showList :: [PXAttr l] -> ShowS #

Generic (PXAttr l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (PXAttr l) :: Type -> Type #

Methods

from :: PXAttr l -> Rep (PXAttr l) x #

to :: Rep (PXAttr l) x -> PXAttr l #

Pretty (PXAttr l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: PXAttr l -> Doc

prettyPrec :: Int -> PXAttr l -> Doc

type Rep (PXAttr l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data RPat l Source #

An entity in a regular pattern.

Constructors

RPOp l (RPat l) (RPatOp l)

operator pattern, e.g. pat*

RPEither l (RPat l) (RPat l)

choice pattern, e.g. (1 | 2)

RPSeq l [RPat l]

sequence pattern, e.g. (| 1, 2, 3 |)

RPGuard l (Pat l) [Stmt l]

guarded pattern, e.g. (| p | p < 3 |)

RPCAs l (Name l) (RPat l)

non-linear variable binding, e.g. (foo@:(1 | 2))*

RPAs l (Name l) (RPat l)

linear variable binding, e.g. foo@(1 | 2)

RPParen l (RPat l)

parenthesised pattern, e.g. (2*)

RPPat l (Pat l)

an ordinary pattern

Instances
Functor RPat Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> RPat a -> RPat b #

(<$) :: a -> RPat b -> RPat a #

Foldable RPat Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => RPat m -> m #

foldMap :: Monoid m => (a -> m) -> RPat a -> m #

foldr :: (a -> b -> b) -> b -> RPat a -> b #

foldr' :: (a -> b -> b) -> b -> RPat a -> b #

foldl :: (b -> a -> b) -> b -> RPat a -> b #

foldl' :: (b -> a -> b) -> b -> RPat a -> b #

foldr1 :: (a -> a -> a) -> RPat a -> a #

foldl1 :: (a -> a -> a) -> RPat a -> a #

toList :: RPat a -> [a] #

null :: RPat a -> Bool #

length :: RPat a -> Int #

elem :: Eq a => a -> RPat a -> Bool #

maximum :: Ord a => RPat a -> a #

minimum :: Ord a => RPat a -> a #

sum :: Num a => RPat a -> a #

product :: Num a => RPat a -> a #

Traversable RPat Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> RPat a -> f (RPat b) #

sequenceA :: Applicative f => RPat (f a) -> f (RPat a) #

mapM :: Monad m => (a -> m b) -> RPat a -> m (RPat b) #

sequence :: Monad m => RPat (m a) -> m (RPat a) #

Annotated RPat Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: RPat l -> l Source #

amap :: (l -> l) -> RPat l -> RPat l Source #

AppFixity RPat Source # 
Instance details

Defined in Language.Haskell.Exts.Fixity

ExactP RPat Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: RPat SrcSpanInfo -> EP ()

Eq l => Eq (RPat l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: RPat l -> RPat l -> Bool #

(/=) :: RPat l -> RPat l -> Bool #

Data l => Data (RPat l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RPat l -> c (RPat l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RPat l) #

toConstr :: RPat l -> Constr #

dataTypeOf :: RPat l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (RPat l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RPat l)) #

gmapT :: (forall b. Data b => b -> b) -> RPat l -> RPat l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RPat l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RPat l -> r #

gmapQ :: (forall d. Data d => d -> u) -> RPat l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> RPat l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RPat l -> m (RPat l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RPat l -> m (RPat l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RPat l -> m (RPat l) #

Ord l => Ord (RPat l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: RPat l -> RPat l -> Ordering #

(<) :: RPat l -> RPat l -> Bool #

(<=) :: RPat l -> RPat l -> Bool #

(>) :: RPat l -> RPat l -> Bool #

(>=) :: RPat l -> RPat l -> Bool #

max :: RPat l -> RPat l -> RPat l #

min :: RPat l -> RPat l -> RPat l #

Show l => Show (RPat l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> RPat l -> ShowS #

show :: RPat l -> String #

showList :: [RPat l] -> ShowS #

Generic (RPat l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (RPat l) :: Type -> Type #

Methods

from :: RPat l -> Rep (RPat l) x #

to :: Rep (RPat l) x -> RPat l #

Pretty (RPat l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: RPat l -> Doc

prettyPrec :: Int -> RPat l -> Doc

type Rep (RPat l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (RPat l) = D1 (MetaData "RPat" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-Z8xb2tkymYIClPofvAOw3" False) (((C1 (MetaCons "RPOp" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (RPat l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (RPatOp l)))) :+: C1 (MetaCons "RPEither" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (RPat l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (RPat l))))) :+: (C1 (MetaCons "RPSeq" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [RPat l])) :+: C1 (MetaCons "RPGuard" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Pat l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Stmt l]))))) :+: ((C1 (MetaCons "RPCAs" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Name l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (RPat l)))) :+: C1 (MetaCons "RPAs" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Name l)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (RPat l))))) :+: (C1 (MetaCons "RPParen" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (RPat l))) :+: C1 (MetaCons "RPPat" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Pat l))))))

data RPatOp l Source #

A regular pattern operator.

Constructors

RPStar l

* = 0 or more

RPStarG l

*! = 0 or more, greedy

RPPlus l

+ = 1 or more

RPPlusG l

+! = 1 or more, greedy

RPOpt l

? = 0 or 1

RPOptG l

?! = 0 or 1, greedy

Instances
Functor RPatOp Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> RPatOp a -> RPatOp b #

(<$) :: a -> RPatOp b -> RPatOp a #

Foldable RPatOp Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => RPatOp m -> m #

foldMap :: Monoid m => (a -> m) -> RPatOp a -> m #

foldr :: (a -> b -> b) -> b -> RPatOp a -> b #

foldr' :: (a -> b -> b) -> b -> RPatOp a -> b #

foldl :: (b -> a -> b) -> b -> RPatOp a -> b #

foldl' :: (b -> a -> b) -> b -> RPatOp a -> b #

foldr1 :: (a -> a -> a) -> RPatOp a -> a #

foldl1 :: (a -> a -> a) -> RPatOp a -> a #

toList :: RPatOp a -> [a] #

null :: RPatOp a -> Bool #

length :: RPatOp a -> Int #

elem :: Eq a => a -> RPatOp a -> Bool #

maximum :: Ord a => RPatOp a -> a #

minimum :: Ord a => RPatOp a -> a #

sum :: Num a => RPatOp a -> a #

product :: Num a => RPatOp a -> a #

Traversable RPatOp Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> RPatOp a -> f (RPatOp b) #

sequenceA :: Applicative f => RPatOp (f a) -> f (RPatOp a) #

mapM :: Monad m => (a -> m b) -> RPatOp a -> m (RPatOp b) #

sequence :: Monad m => RPatOp (m a) -> m (RPatOp a) #

Annotated RPatOp Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: RPatOp l -> l Source #

amap :: (l -> l) -> RPatOp l -> RPatOp l Source #

ExactP RPatOp Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: RPatOp SrcSpanInfo -> EP ()

Eq l => Eq (RPatOp l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: RPatOp l -> RPatOp l -> Bool #

(/=) :: RPatOp l -> RPatOp l -> Bool #

Data l => Data (RPatOp l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RPatOp l -> c (RPatOp l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RPatOp l) #

toConstr :: RPatOp l -> Constr #

dataTypeOf :: RPatOp l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (RPatOp l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RPatOp l)) #

gmapT :: (forall b. Data b => b -> b) -> RPatOp l -> RPatOp l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RPatOp l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RPatOp l -> r #

gmapQ :: (forall d. Data d => d -> u) -> RPatOp l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> RPatOp l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RPatOp l -> m (RPatOp l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RPatOp l -> m (RPatOp l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RPatOp l -> m (RPatOp l) #

Ord l => Ord (RPatOp l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: RPatOp l -> RPatOp l -> Ordering #

(<) :: RPatOp l -> RPatOp l -> Bool #

(<=) :: RPatOp l -> RPatOp l -> Bool #

(>) :: RPatOp l -> RPatOp l -> Bool #

(>=) :: RPatOp l -> RPatOp l -> Bool #

max :: RPatOp l -> RPatOp l -> RPatOp l #

min :: RPatOp l -> RPatOp l -> RPatOp l #

Show l => Show (RPatOp l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> RPatOp l -> ShowS #

show :: RPatOp l -> String #

showList :: [RPatOp l] -> ShowS #

Generic (RPatOp l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (RPatOp l) :: Type -> Type #

Methods

from :: RPatOp l -> Rep (RPatOp l) x #

to :: Rep (RPatOp l) x -> RPatOp l #

Pretty (RPatOp l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: RPatOp l -> Doc

prettyPrec :: Int -> RPatOp l -> Doc

type Rep (RPatOp l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Literals

data Literal l Source #

literal Values of this type hold the abstract value of the literal, along with the precise string representation used. For example, 10, 0o12 and 0xa have the same value representation, but each carry a different string representation.

Constructors

Char l Char String

character literal

String l String String

string literal

Int l Integer String

integer literal

Frac l Rational String

floating point literal

PrimInt l Integer String

unboxed integer literal

PrimWord l Integer String

unboxed word literal

PrimFloat l Rational String

unboxed float literal

PrimDouble l Rational String

unboxed double literal

PrimChar l Char String

unboxed character literal

PrimString l String String

unboxed string literal

Instances
Functor Literal Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Literal a -> Literal b #

(<$) :: a -> Literal b -> Literal a #

Foldable Literal Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Literal m -> m #

foldMap :: Monoid m => (a -> m) -> Literal a -> m #

foldr :: (a -> b -> b) -> b -> Literal a -> b #

foldr' :: (a -> b -> b) -> b -> Literal a -> b #

foldl :: (b -> a -> b) -> b -> Literal a -> b #

foldl' :: (b -> a -> b) -> b -> Literal a -> b #

foldr1 :: (a -> a -> a) -> Literal a -> a #

foldl1 :: (a -> a -> a) -> Literal a -> a #

toList :: Literal a -> [a] #

null :: Literal a -> Bool #

length :: Literal a -> Int #

elem :: Eq a => a -> Literal a -> Bool #

maximum :: Ord a => Literal a -> a #

minimum :: Ord a => Literal a -> a #

sum :: Num a => Literal a -> a #

product :: Num a => Literal a -> a #

Traversable Literal Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> Literal a -> f (Literal b) #

sequenceA :: Applicative f => Literal (f a) -> f (Literal a) #

mapM :: Monad m => (a -> m b) -> Literal a -> m (Literal b) #

sequence :: Monad m => Literal (m a) -> m (Literal a) #

Annotated Literal Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Literal l -> l Source #

amap :: (l -> l) -> Literal l -> Literal l Source #

ExactP Literal Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Literal SrcSpanInfo -> EP ()

Eq l => Eq (Literal l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: Literal l -> Literal l -> Bool #

(/=) :: Literal l -> Literal l -> Bool #

Data l => Data (Literal l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Literal l -> c (Literal l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Literal l) #

toConstr :: Literal l -> Constr #

dataTypeOf :: Literal l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Literal l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Literal l)) #

gmapT :: (forall b. Data b => b -> b) -> Literal l -> Literal l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Literal l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Literal l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Literal l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Literal l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Literal l -> m (Literal l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Literal l -> m (Literal l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Literal l -> m (Literal l) #

Ord l => Ord (Literal l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: Literal l -> Literal l -> Ordering #

(<) :: Literal l -> Literal l -> Bool #

(<=) :: Literal l -> Literal l -> Bool #

(>) :: Literal l -> Literal l -> Bool #

(>=) :: Literal l -> Literal l -> Bool #

max :: Literal l -> Literal l -> Literal l #

min :: Literal l -> Literal l -> Literal l #

Show l => Show (Literal l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> Literal l -> ShowS #

show :: Literal l -> String #

showList :: [Literal l] -> ShowS #

Generic (Literal l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Literal l) :: Type -> Type #

Methods

from :: Literal l -> Rep (Literal l) x #

to :: Rep (Literal l) x -> Literal l #

Pretty (Literal l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Literal l -> Doc

prettyPrec :: Int -> Literal l -> Doc

type Rep (Literal l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (Literal l) = D1 (MetaData "Literal" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-Z8xb2tkymYIClPofvAOw3" False) (((C1 (MetaCons "Char" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Char) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String))) :+: C1 (MetaCons "String" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)))) :+: (C1 (MetaCons "Int" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Integer) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String))) :+: (C1 (MetaCons "Frac" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Rational) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String))) :+: C1 (MetaCons "PrimInt" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Integer) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)))))) :+: ((C1 (MetaCons "PrimWord" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Integer) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String))) :+: C1 (MetaCons "PrimFloat" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Rational) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)))) :+: (C1 (MetaCons "PrimDouble" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Rational) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String))) :+: (C1 (MetaCons "PrimChar" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Char) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String))) :+: C1 (MetaCons "PrimString" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)))))))

data Sign l Source #

An indication whether a literal pattern has been negated or not.

Constructors

Signless l 
Negative l 
Instances
Functor Sign Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Sign a -> Sign b #

(<$) :: a -> Sign b -> Sign a #

Foldable Sign Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Sign m -> m #

foldMap :: Monoid m => (a -> m) -> Sign a -> m #

foldr :: (a -> b -> b) -> b -> Sign a -> b #

foldr' :: (a -> b -> b) -> b -> Sign a -> b #

foldl :: (b -> a -> b) -> b -> Sign a -> b #

foldl' :: (b -> a -> b) -> b -> Sign a -> b #

foldr1 :: (a -> a -> a) -> Sign a -> a #

foldl1 :: (a -> a -> a) -> Sign a -> a #

toList :: Sign a -> [a] #

null :: Sign a -> Bool #

length :: Sign a -> Int #

elem :: Eq a => a -> Sign a -> Bool #

maximum :: Ord a => Sign a -> a #

minimum :: Ord a => Sign a -> a #

sum :: Num a => Sign a -> a #

product :: Num a => Sign a -> a #

Traversable Sign Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> Sign a -> f (Sign b) #

sequenceA :: Applicative f => Sign (f a) -> f (Sign a) #

mapM :: Monad m => (a -> m b) -> Sign a -> m (Sign b) #

sequence :: Monad m => Sign (m a) -> m (Sign a) #

Annotated Sign Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Sign l -> l Source #

amap :: (l -> l) -> Sign l -> Sign l Source #

ExactP Sign Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Sign SrcSpanInfo -> EP ()

Eq l => Eq (Sign l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: Sign l -> Sign l -> Bool #

(/=) :: Sign l -> Sign l -> Bool #

Data l => Data (Sign l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Sign l -> c (Sign l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Sign l) #

toConstr :: Sign l -> Constr #

dataTypeOf :: Sign l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Sign l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Sign l)) #

gmapT :: (forall b. Data b => b -> b) -> Sign l -> Sign l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sign l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sign l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Sign l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Sign l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Sign l -> m (Sign l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Sign l -> m (Sign l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Sign l -> m (Sign l) #

Ord l => Ord (Sign l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: Sign l -> Sign l -> Ordering #

(<) :: Sign l -> Sign l -> Bool #

(<=) :: Sign l -> Sign l -> Bool #

(>) :: Sign l -> Sign l -> Bool #

(>=) :: Sign l -> Sign l -> Bool #

max :: Sign l -> Sign l -> Sign l #

min :: Sign l -> Sign l -> Sign l #

Show l => Show (Sign l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> Sign l -> ShowS #

show :: Sign l -> String #

showList :: [Sign l] -> ShowS #

Generic (Sign l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Sign l) :: Type -> Type #

Methods

from :: Sign l -> Rep (Sign l) x #

to :: Rep (Sign l) x -> Sign l #

type Rep (Sign l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (Sign l) = D1 (MetaData "Sign" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-Z8xb2tkymYIClPofvAOw3" False) (C1 (MetaCons "Signless" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)) :+: C1 (MetaCons "Negative" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l)))

Variables, Constructors and Operators

data ModuleName l Source #

The name of a Haskell module.

Constructors

ModuleName l String 
Instances
Functor ModuleName Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> ModuleName a -> ModuleName b #

(<$) :: a -> ModuleName b -> ModuleName a #

Foldable ModuleName Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => ModuleName m -> m #

foldMap :: Monoid m => (a -> m) -> ModuleName a -> m #

foldr :: (a -> b -> b) -> b -> ModuleName a -> b #

foldr' :: (a -> b -> b) -> b -> ModuleName a -> b #

foldl :: (b -> a -> b) -> b -> ModuleName a -> b #

foldl' :: (b -> a -> b) -> b -> ModuleName a -> b #

foldr1 :: (a -> a -> a) -> ModuleName a -> a #

foldl1 :: (a -> a -> a) -> ModuleName a -> a #

toList :: ModuleName a -> [a] #

null :: ModuleName a -> Bool #

length :: ModuleName a -> Int #

elem :: Eq a => a -> ModuleName a -> Bool #

maximum :: Ord a => ModuleName a -> a #

minimum :: Ord a => ModuleName a -> a #

sum :: Num a => ModuleName a -> a #

product :: Num a => ModuleName a -> a #

Traversable ModuleName Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> ModuleName a -> f (ModuleName b) #

sequenceA :: Applicative f => ModuleName (f a) -> f (ModuleName a) #

mapM :: Monad m => (a -> m b) -> ModuleName a -> m (ModuleName b) #

sequence :: Monad m => ModuleName (m a) -> m (ModuleName a) #

Annotated ModuleName Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: ModuleName l -> l Source #

amap :: (l -> l) -> ModuleName l -> ModuleName l Source #

ExactP ModuleName Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: ModuleName SrcSpanInfo -> EP ()

Eq l => Eq (ModuleName l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: ModuleName l -> ModuleName l -> Bool #

(/=) :: ModuleName l -> ModuleName l -> Bool #

Data l => Data (ModuleName l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ModuleName l -> c (ModuleName l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ModuleName l) #

toConstr :: ModuleName l -> Constr #

dataTypeOf :: ModuleName l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ModuleName l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ModuleName l)) #

gmapT :: (forall b. Data b => b -> b) -> ModuleName l -> ModuleName l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ModuleName l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ModuleName l -> r #

gmapQ :: (forall d. Data d => d -> u) -> ModuleName l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ModuleName l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ModuleName l -> m (ModuleName l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ModuleName l -> m (ModuleName l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ModuleName l -> m (ModuleName l) #

Ord l => Ord (ModuleName l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Show l => Show (ModuleName l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Generic (ModuleName l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (ModuleName l) :: Type -> Type #

Methods

from :: ModuleName l -> Rep (ModuleName l) x #

to :: Rep (ModuleName l) x -> ModuleName l #

Pretty (ModuleName l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: ModuleName l -> Doc

prettyPrec :: Int -> ModuleName l -> Doc

type Rep (ModuleName l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep (ModuleName l) = D1 (MetaData "ModuleName" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-Z8xb2tkymYIClPofvAOw3" False) (C1 (MetaCons "ModuleName" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)))

data QName l Source #

This type is used to represent qualified variables, and also qualified constructors.

Constructors

Qual l (ModuleName l) (Name l)

name qualified with a module name

UnQual l (Name l)

unqualified local name

Special l (SpecialCon l)

built-in constructor with special syntax

Instances
Functor QName Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> QName a -> QName b #

(<$) :: a -> QName b -> QName a #

Foldable QName Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => QName m -> m #

foldMap :: Monoid m => (a -> m) -> QName a -> m #

foldr :: (a -> b -> b) -> b -> QName a -> b #

foldr' :: (a -> b -> b) -> b -> QName a -> b #

foldl :: (b -> a -> b) -> b -> QName a -> b #

foldl' :: (b -> a -> b) -> b -> QName a -> b #

foldr1 :: (a -> a -> a) -> QName a -> a #

foldl1 :: (a -> a -> a) -> QName a -> a #

toList :: QName a -> [a] #

null :: QName a -> Bool #

length :: QName a -> Int #

elem :: Eq a => a -> QName a -> Bool #

maximum :: Ord a => QName a -> a #

minimum :: Ord a => QName a -> a #

sum :: Num a => QName a -> a #

product :: Num a => QName a -> a #

Traversable QName Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> QName a -> f (QName b) #

sequenceA :: Applicative f => QName (f a) -> f (QName a) #

mapM :: Monad m => (a -> m b) -> QName a -> m (QName b) #

sequence :: Monad m => QName (m a) -> m (QName a) #

Annotated QName Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: QName l -> l Source #

amap :: (l -> l) -> QName l -> QName l Source #

ExactP QName Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: QName SrcSpanInfo -> EP ()

Eq l => Eq (QName l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: QName l -> QName l -> Bool #

(/=) :: QName l -> QName l -> Bool #

Data l => Data (QName l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> QName l -> c (QName l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (QName l) #

toConstr :: QName l -> Constr #

dataTypeOf :: QName l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (QName l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (QName l)) #

gmapT :: (forall b. Data b => b -> b) -> QName l -> QName l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> QName l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> QName l -> r #

gmapQ :: (forall d. Data d => d -> u) -> QName l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> QName l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> QName l -> m (QName l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> QName l -> m (QName l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> QName l -> m (QName l) #

Ord l => Ord (QName l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: QName l -> QName l -> Ordering #

(<) :: QName l -> QName l -> Bool #

(<=) :: QName l -> QName l -> Bool #

(>) :: QName l -> QName l -> Bool #

(>=) :: QName l -> QName l -> Bool #

max :: QName l -> QName l -> QName l #

min :: QName l -> QName l -> QName l #

Show l => Show (QName l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> QName l -> ShowS #

show :: QName l -> String #

showList :: [QName l] -> ShowS #

Generic (QName l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (QName l) :: Type -> Type #

Methods

from :: QName l -> Rep (QName l) x #

to :: Rep (QName l) x -> QName l #

Pretty (QName l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: QName l -> Doc

prettyPrec :: Int -> QName l -> Doc

type Rep (QName l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data Name l Source #

This type is used to represent variables, and also constructors.

Constructors

Ident l String

varid or conid.

Symbol l String

varsym or consym

Instances
Functor Name Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Name a -> Name b #

(<$) :: a -> Name b -> Name a #

Foldable Name Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Name m -> m #

foldMap :: Monoid m => (a -> m) -> Name a -> m #

foldr :: (a -> b -> b) -> b -> Name a -> b #

foldr' :: (a -> b -> b) -> b -> Name a -> b #

foldl :: (b -> a -> b) -> b -> Name a -> b #

foldl' :: (b -> a -> b) -> b -> Name a -> b #

foldr1 :: (a -> a -> a) -> Name a -> a #

foldl1 :: (a -> a -> a) -> Name a -> a #

toList :: Name a -> [a] #

null :: Name a -> Bool #

length :: Name a -> Int #

elem :: Eq a => a -> Name a -> Bool #

maximum :: Ord a => Name a -> a #

minimum :: Ord a => Name a -> a #

sum :: Num a => Name a -> a #

product :: Num a => Name a -> a #

Traversable Name Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> Name a -> f (Name b) #

sequenceA :: Applicative f => Name (f a) -> f (Name a) #

mapM :: Monad m => (a -> m b) -> Name a -> m (Name b) #

sequence :: Monad m => Name (m a) -> m (Name a) #

Annotated Name Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Name l -> l Source #

amap :: (l -> l) -> Name l -> Name l Source #

ExactP Name Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Name SrcSpanInfo -> EP ()

Eq l => Eq (Name l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: Name l -> Name l -> Bool #

(/=) :: Name l -> Name l -> Bool #

Data l => Data (Name l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Name l -> c (Name l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Name l) #

toConstr :: Name l -> Constr #

dataTypeOf :: Name l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Name l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Name l)) #

gmapT :: (forall b. Data b => b -> b) -> Name l -> Name l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Name l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Name l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Name l -> m (Name l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Name l -> m (Name l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Name l -> m (Name l) #

Ord l => Ord (Name l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: Name l -> Name l -> Ordering #

(<) :: Name l -> Name l -> Bool #

(<=) :: Name l -> Name l -> Bool #

(>) :: Name l -> Name l -> Bool #

(>=) :: Name l -> Name l -> Bool #

max :: Name l -> Name l -> Name l #

min :: Name l -> Name l -> Name l #

Show l => Show (Name l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> Name l -> ShowS #

show :: Name l -> String #

showList :: [Name l] -> ShowS #

Generic (Name l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Name l) :: Type -> Type #

Methods

from :: Name l -> Rep (Name l) x #

to :: Rep (Name l) x -> Name l #

Pretty (Name l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Name l -> Doc

prettyPrec :: Int -> Name l -> Doc

type Rep (Name l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data QOp l Source #

Possibly qualified infix operators (qop), appearing in expressions.

Constructors

QVarOp l (QName l)

variable operator (qvarop)

QConOp l (QName l)

constructor operator (qconop)

Instances
Functor QOp Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> QOp a -> QOp b #

(<$) :: a -> QOp b -> QOp a #

Foldable QOp Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => QOp m -> m #

foldMap :: Monoid m => (a -> m) -> QOp a -> m #

foldr :: (a -> b -> b) -> b -> QOp a -> b #

foldr' :: (a -> b -> b) -> b -> QOp a -> b #

foldl :: (b -> a -> b) -> b -> QOp a -> b #

foldl' :: (b -> a -> b) -> b -> QOp a -> b #

foldr1 :: (a -> a -> a) -> QOp a -> a #

foldl1 :: (a -> a -> a) -> QOp a -> a #

toList :: QOp a -> [a] #

null :: QOp a -> Bool #

length :: QOp a -> Int #

elem :: Eq a => a -> QOp a -> Bool #

maximum :: Ord a => QOp a -> a #

minimum :: Ord a => QOp a -> a #

sum :: Num a => QOp a -> a #

product :: Num a => QOp a -> a #

Traversable QOp Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> QOp a -> f (QOp b) #

sequenceA :: Applicative f => QOp (f a) -> f (QOp a) #

mapM :: Monad m => (a -> m b) -> QOp a -> m (QOp b) #

sequence :: Monad m => QOp (m a) -> m (QOp a) #

Annotated QOp Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: QOp l -> l Source #

amap :: (l -> l) -> QOp l -> QOp l Source #

ExactP QOp Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: QOp SrcSpanInfo -> EP ()

Eq l => Eq (QOp l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: QOp l -> QOp l -> Bool #

(/=) :: QOp l -> QOp l -> Bool #

Data l => Data (QOp l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> QOp l -> c (QOp l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (QOp l) #

toConstr :: QOp l -> Constr #

dataTypeOf :: QOp l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (QOp l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (QOp l)) #

gmapT :: (forall b. Data b => b -> b) -> QOp l -> QOp l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> QOp l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> QOp l -> r #

gmapQ :: (forall d. Data d => d -> u) -> QOp l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> QOp l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> QOp l -> m (QOp l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> QOp l -> m (QOp l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> QOp l -> m (QOp l) #

Ord l => Ord (QOp l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: QOp l -> QOp l -> Ordering #

(<) :: QOp l -> QOp l -> Bool #

(<=) :: QOp l -> QOp l -> Bool #

(>) :: QOp l -> QOp l -> Bool #

(>=) :: QOp l -> QOp l -> Bool #

max :: QOp l -> QOp l -> QOp l #

min :: QOp l -> QOp l -> QOp l #

Show l => Show (QOp l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> QOp l -> ShowS #

show :: QOp l -> String #

showList :: [QOp l] -> ShowS #

Generic (QOp l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (QOp l) :: Type -> Type #

Methods

from :: QOp l -> Rep (QOp l) x #

to :: Rep (QOp l) x -> QOp l #

Pretty (QOp l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: QOp l -> Doc

prettyPrec :: Int -> QOp l -> Doc

type Rep (QOp l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data Op l Source #

Operators appearing in infix declarations are never qualified.

Constructors

VarOp l (Name l)

variable operator (varop)

ConOp l (Name l)

constructor operator (conop)

Instances
Functor Op Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Op a -> Op b #

(<$) :: a -> Op b -> Op a #

Foldable Op Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Op m -> m #

foldMap :: Monoid m => (a -> m) -> Op a -> m #

foldr :: (a -> b -> b) -> b -> Op a -> b #

foldr' :: (a -> b -> b) -> b -> Op a -> b #

foldl :: (b -> a -> b) -> b -> Op a -> b #

foldl' :: (b -> a -> b) -> b -> Op a -> b #

foldr1 :: (a -> a -> a) -> Op a -> a #

foldl1 :: (a -> a -> a) -> Op a -> a #

toList :: Op a -> [a] #

null :: Op a -> Bool #

length :: Op a -> Int #

elem :: Eq a => a -> Op a -> Bool #

maximum :: Ord a => Op a -> a #

minimum :: Ord a => Op a -> a #

sum :: Num a => Op a -> a #

product :: Num a => Op a -> a #

Traversable Op Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> Op a -> f (Op b) #

sequenceA :: Applicative f => Op (f a) -> f (Op a) #

mapM :: Monad m => (a -> m b) -> Op a -> m (Op b) #

sequence :: Monad m => Op (m a) -> m (Op a) #

Annotated Op Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Op l -> l Source #

amap :: (l -> l) -> Op l -> Op l Source #

ExactP Op Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Op SrcSpanInfo -> EP ()

Eq l => Eq (Op l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: Op l -> Op l -> Bool #

(/=) :: Op l -> Op l -> Bool #

Data l => Data (Op l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Op l -> c (Op l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Op l) #

toConstr :: Op l -> Constr #

dataTypeOf :: Op l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Op l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Op l)) #

gmapT :: (forall b. Data b => b -> b) -> Op l -> Op l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Op l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Op l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Op l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Op l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Op l -> m (Op l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Op l -> m (Op l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Op l -> m (Op l) #

Ord l => Ord (Op l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: Op l -> Op l -> Ordering #

(<) :: Op l -> Op l -> Bool #

(<=) :: Op l -> Op l -> Bool #

(>) :: Op l -> Op l -> Bool #

(>=) :: Op l -> Op l -> Bool #

max :: Op l -> Op l -> Op l #

min :: Op l -> Op l -> Op l #

Show l => Show (Op l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> Op l -> ShowS #

show :: Op l -> String #

showList :: [Op l] -> ShowS #

Generic (Op l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Op l) :: Type -> Type #

Methods

from :: Op l -> Rep (Op l) x #

to :: Rep (Op l) x -> Op l #

Pretty (Op l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Op l -> Doc

prettyPrec :: Int -> Op l -> Doc

type Rep (Op l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data SpecialCon l Source #

Constructors with special syntax. These names are never qualified, and always refer to builtin type or data constructors.

Constructors

UnitCon l

unit type and data constructor ()

ListCon l

list type and data constructor []

FunCon l

function type constructor ->

TupleCon l Boxed Int

n-ary tuple type and data constructors (,) etc, possibly boxed (#,#)

Cons l

list data constructor (:)

UnboxedSingleCon l

unboxed singleton tuple constructor (# #)

ExprHole l

An expression hole _

Instances
Functor SpecialCon Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> SpecialCon a -> SpecialCon b #

(<$) :: a -> SpecialCon b -> SpecialCon a #

Foldable SpecialCon Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => SpecialCon m -> m #

foldMap :: Monoid m => (a -> m) -> SpecialCon a -> m #

foldr :: (a -> b -> b) -> b -> SpecialCon a -> b #

foldr' :: (a -> b -> b) -> b -> SpecialCon a -> b #

foldl :: (b -> a -> b) -> b -> SpecialCon a -> b #

foldl' :: (b -> a -> b) -> b -> SpecialCon a -> b #

foldr1 :: (a -> a -> a) -> SpecialCon a -> a #

foldl1 :: (a -> a -> a) -> SpecialCon a -> a #

toList :: SpecialCon a -> [a] #

null :: SpecialCon a -> Bool #

length :: SpecialCon a -> Int #

elem :: Eq a => a -> SpecialCon a -> Bool #

maximum :: Ord a => SpecialCon a -> a #

minimum :: Ord a => SpecialCon a -> a #

sum :: Num a => SpecialCon a -> a #

product :: Num a => SpecialCon a -> a #

Traversable SpecialCon Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> SpecialCon a -> f (SpecialCon b) #

sequenceA :: Applicative f => SpecialCon (f a) -> f (SpecialCon a) #

mapM :: Monad m => (a -> m b) -> SpecialCon a -> m (SpecialCon b) #

sequence :: Monad m => SpecialCon (m a) -> m (SpecialCon a) #

Annotated SpecialCon Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: SpecialCon l -> l Source #

amap :: (l -> l) -> SpecialCon l -> SpecialCon l Source #

ExactP SpecialCon Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: SpecialCon SrcSpanInfo -> EP ()

Eq l => Eq (SpecialCon l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: SpecialCon l -> SpecialCon l -> Bool #

(/=) :: SpecialCon l -> SpecialCon l -> Bool #

Data l => Data (SpecialCon l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SpecialCon l -> c (SpecialCon l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (SpecialCon l) #

toConstr :: SpecialCon l -> Constr #

dataTypeOf :: SpecialCon l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (SpecialCon l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (SpecialCon l)) #

gmapT :: (forall b. Data b => b -> b) -> SpecialCon l -> SpecialCon l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SpecialCon l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SpecialCon l -> r #

gmapQ :: (forall d. Data d => d -> u) -> SpecialCon l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SpecialCon l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SpecialCon l -> m (SpecialCon l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SpecialCon l -> m (SpecialCon l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SpecialCon l -> m (SpecialCon l) #

Ord l => Ord (SpecialCon l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Show l => Show (SpecialCon l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Generic (SpecialCon l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (SpecialCon l) :: Type -> Type #

Methods

from :: SpecialCon l -> Rep (SpecialCon l) x #

to :: Rep (SpecialCon l) x -> SpecialCon l #

Pretty (SpecialCon l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: SpecialCon l -> Doc

prettyPrec :: Int -> SpecialCon l -> Doc

type Rep (SpecialCon l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data CName l Source #

A name (cname) of a component of a class or data type in an import or export specification.

Constructors

VarName l (Name l)

name of a method or field

ConName l (Name l)

name of a data constructor

Instances
Functor CName Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> CName a -> CName b #

(<$) :: a -> CName b -> CName a #

Foldable CName Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => CName m -> m #

foldMap :: Monoid m => (a -> m) -> CName a -> m #

foldr :: (a -> b -> b) -> b -> CName a -> b #

foldr' :: (a -> b -> b) -> b -> CName a -> b #

foldl :: (b -> a -> b) -> b -> CName a -> b #

foldl' :: (b -> a -> b) -> b -> CName a -> b #

foldr1 :: (a -> a -> a) -> CName a -> a #

foldl1 :: (a -> a -> a) -> CName a -> a #

toList :: CName a -> [a] #

null :: CName a -> Bool #

length :: CName a -> Int #

elem :: Eq a => a -> CName a -> Bool #

maximum :: Ord a => CName a -> a #

minimum :: Ord a => CName a -> a #

sum :: Num a => CName a -> a #

product :: Num a => CName a -> a #

Traversable CName Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> CName a -> f (CName b) #

sequenceA :: Applicative f => CName (f a) -> f (CName a) #

mapM :: Monad m => (a -> m b) -> CName a -> m (CName b) #

sequence :: Monad m => CName (m a) -> m (CName a) #

Annotated CName Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: CName l -> l Source #

amap :: (l -> l) -> CName l -> CName l Source #

ExactP CName Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: CName SrcSpanInfo -> EP ()

Eq l => Eq (CName l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: CName l -> CName l -> Bool #

(/=) :: CName l -> CName l -> Bool #

Data l => Data (CName l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CName l -> c (CName l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (CName l) #

toConstr :: CName l -> Constr #

dataTypeOf :: CName l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (CName l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CName l)) #

gmapT :: (forall b. Data b => b -> b) -> CName l -> CName l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CName l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CName l -> r #

gmapQ :: (forall d. Data d => d -> u) -> CName l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> CName l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> CName l -> m (CName l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CName l -> m (CName l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CName l -> m (CName l) #

Ord l => Ord (CName l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: CName l -> CName l -> Ordering #

(<) :: CName l -> CName l -> Bool #

(<=) :: CName l -> CName l -> Bool #

(>) :: CName l -> CName l -> Bool #

(>=) :: CName l -> CName l -> Bool #

max :: CName l -> CName l -> CName l #

min :: CName l -> CName l -> CName l #

Show l => Show (CName l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> CName l -> ShowS #

show :: CName l -> String #

showList :: [CName l] -> ShowS #

Generic (CName l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (CName l) :: Type -> Type #

Methods

from :: CName l -> Rep (CName l) x #

to :: Rep (CName l) x -> CName l #

Pretty (CName l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: CName l -> Doc

prettyPrec :: Int -> CName l -> Doc

type Rep (CName l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data IPName l Source #

An implicit parameter name.

Constructors

IPDup l String

?ident, non-linear implicit parameter

IPLin l String

%ident, linear implicit parameter

Instances
Functor IPName Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> IPName a -> IPName b #

(<$) :: a -> IPName b -> IPName a #

Foldable IPName Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => IPName m -> m #

foldMap :: Monoid m => (a -> m) -> IPName a -> m #

foldr :: (a -> b -> b) -> b -> IPName a -> b #

foldr' :: (a -> b -> b) -> b -> IPName a -> b #

foldl :: (b -> a -> b) -> b -> IPName a -> b #

foldl' :: (b -> a -> b) -> b -> IPName a -> b #

foldr1 :: (a -> a -> a) -> IPName a -> a #

foldl1 :: (a -> a -> a) -> IPName a -> a #

toList :: IPName a -> [a] #

null :: IPName a -> Bool #

length :: IPName a -> Int #

elem :: Eq a => a -> IPName a -> Bool #

maximum :: Ord a => IPName a -> a #

minimum :: Ord a => IPName a -> a #

sum :: Num a => IPName a -> a #

product :: Num a => IPName a -> a #

Traversable IPName Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> IPName a -> f (IPName b) #

sequenceA :: Applicative f => IPName (f a) -> f (IPName a) #

mapM :: Monad m => (a -> m b) -> IPName a -> m (IPName b) #

sequence :: Monad m => IPName (m a) -> m (IPName a) #

Annotated IPName Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: IPName l -> l Source #

amap :: (l -> l) -> IPName l -> IPName l Source #

ExactP IPName Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: IPName SrcSpanInfo -> EP ()

Eq l => Eq (IPName l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: IPName l -> IPName l -> Bool #

(/=) :: IPName l -> IPName l -> Bool #

Data l => Data (IPName l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IPName l -> c (IPName l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (IPName l) #

toConstr :: IPName l -> Constr #

dataTypeOf :: IPName l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (IPName l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (IPName l)) #

gmapT :: (forall b. Data b => b -> b) -> IPName l -> IPName l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IPName l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IPName l -> r #

gmapQ :: (forall d. Data d => d -> u) -> IPName l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> IPName l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> IPName l -> m (IPName l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IPName l -> m (IPName l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IPName l -> m (IPName l) #

Ord l => Ord (IPName l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: IPName l -> IPName l -> Ordering #

(<) :: IPName l -> IPName l -> Bool #

(<=) :: IPName l -> IPName l -> Bool #

(>) :: IPName l -> IPName l -> Bool #

(>=) :: IPName l -> IPName l -> Bool #

max :: IPName l -> IPName l -> IPName l #

min :: IPName l -> IPName l -> IPName l #

Show l => Show (IPName l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> IPName l -> ShowS #

show :: IPName l -> String #

showList :: [IPName l] -> ShowS #

Generic (IPName l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (IPName l) :: Type -> Type #

Methods

from :: IPName l -> Rep (IPName l) x #

to :: Rep (IPName l) x -> IPName l #

Pretty (IPName l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: IPName l -> Doc

prettyPrec :: Int -> IPName l -> Doc

type Rep (IPName l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data XName l Source #

The name of an xml element or attribute, possibly qualified with a namespace.

Constructors

XName l String 
XDomName l String String 
Instances
Functor XName Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> XName a -> XName b #

(<$) :: a -> XName b -> XName a #

Foldable XName Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => XName m -> m #

foldMap :: Monoid m => (a -> m) -> XName a -> m #

foldr :: (a -> b -> b) -> b -> XName a -> b #

foldr' :: (a -> b -> b) -> b -> XName a -> b #

foldl :: (b -> a -> b) -> b -> XName a -> b #

foldl' :: (b -> a -> b) -> b -> XName a -> b #

foldr1 :: (a -> a -> a) -> XName a -> a #

foldl1 :: (a -> a -> a) -> XName a -> a #

toList :: XName a -> [a] #

null :: XName a -> Bool #

length :: XName a -> Int #

elem :: Eq a => a -> XName a -> Bool #

maximum :: Ord a => XName a -> a #

minimum :: Ord a => XName a -> a #

sum :: Num a => XName a -> a #

product :: Num a => XName a -> a #

Traversable XName Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> XName a -> f (XName b) #

sequenceA :: Applicative f => XName (f a) -> f (XName a) #

mapM :: Monad m => (a -> m b) -> XName a -> m (XName b) #

sequence :: Monad m => XName (m a) -> m (XName a) #

Annotated XName Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: XName l -> l Source #

amap :: (l -> l) -> XName l -> XName l Source #

ExactP XName Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: XName SrcSpanInfo -> EP ()

Eq l => Eq (XName l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: XName l -> XName l -> Bool #

(/=) :: XName l -> XName l -> Bool #

Data l => Data (XName l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> XName l -> c (XName l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (XName l) #

toConstr :: XName l -> Constr #

dataTypeOf :: XName l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (XName l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (XName l)) #

gmapT :: (forall b. Data b => b -> b) -> XName l -> XName l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> XName l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> XName l -> r #

gmapQ :: (forall d. Data d => d -> u) -> XName l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> XName l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> XName l -> m (XName l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> XName l -> m (XName l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> XName l -> m (XName l) #

Ord l => Ord (XName l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: XName l -> XName l -> Ordering #

(<) :: XName l -> XName l -> Bool #

(<=) :: XName l -> XName l -> Bool #

(>) :: XName l -> XName l -> Bool #

(>=) :: XName l -> XName l -> Bool #

max :: XName l -> XName l -> XName l #

min :: XName l -> XName l -> XName l #

Show l => Show (XName l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> XName l -> ShowS #

show :: XName l -> String #

showList :: [XName l] -> ShowS #

Generic (XName l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (XName l) :: Type -> Type #

Methods

from :: XName l -> Rep (XName l) x #

to :: Rep (XName l) x -> XName l #

Pretty (XName l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: XName l -> Doc

prettyPrec :: Int -> XName l -> Doc

type Rep (XName l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data Role l Source #

Constructors

Nominal l 
Representational l 
Phantom l 
RoleWildcard l 
Instances
Functor Role Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Role a -> Role b #

(<$) :: a -> Role b -> Role a #

Foldable Role Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Role m -> m #

foldMap :: Monoid m => (a -> m) -> Role a -> m #

foldr :: (a -> b -> b) -> b -> Role a -> b #

foldr' :: (a -> b -> b) -> b -> Role a -> b #

foldl :: (b -> a -> b) -> b -> Role a -> b #

foldl' :: (b -> a -> b) -> b -> Role a -> b #

foldr1 :: (a -> a -> a) -> Role a -> a #

foldl1 :: (a -> a -> a) -> Role a -> a #

toList :: Role a -> [a] #

null :: Role a -> Bool #

length :: Role a -> Int #

elem :: Eq a => a -> Role a -> Bool #

maximum :: Ord a => Role a -> a #

minimum :: Ord a => Role a -> a #

sum :: Num a => Role a -> a #

product :: Num a => Role a -> a #

Traversable Role Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> Role a -> f (Role b) #

sequenceA :: Applicative f => Role (f a) -> f (Role a) #

mapM :: Monad m => (a -> m b) -> Role a -> m (Role b) #

sequence :: Monad m => Role (m a) -> m (Role a) #

Annotated Role Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Role l -> l Source #

amap :: (l -> l) -> Role l -> Role l Source #

ExactP Role Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Role SrcSpanInfo -> EP ()

Eq l => Eq (Role l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: Role l -> Role l -> Bool #

(/=) :: Role l -> Role l -> Bool #

Data l => Data (Role l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Role l -> c (Role l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Role l) #

toConstr :: Role l -> Constr #

dataTypeOf :: Role l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Role l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Role l)) #

gmapT :: (forall b. Data b => b -> b) -> Role l -> Role l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Role l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Role l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Role l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Role l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Role l -> m (Role l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Role l -> m (Role l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Role l -> m (Role l) #

Ord l => Ord (Role l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: Role l -> Role l -> Ordering #

(<) :: Role l -> Role l -> Bool #

(<=) :: Role l -> Role l -> Bool #

(>) :: Role l -> Role l -> Bool #

(>=) :: Role l -> Role l -> Bool #

max :: Role l -> Role l -> Role l #

min :: Role l -> Role l -> Role l #

Show l => Show (Role l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> Role l -> ShowS #

show :: Role l -> String #

showList :: [Role l] -> ShowS #

Generic (Role l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Role l) :: Type -> Type #

Methods

from :: Role l -> Rep (Role l) x #

to :: Rep (Role l) x -> Role l #

Pretty (Role l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Role l -> Doc

prettyPrec :: Int -> Role l -> Doc

type Rep (Role l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data MaybePromotedName l Source #

Constructors

PromotedName l (QName l) 
UnpromotedName l (QName l) 
Instances
Functor MaybePromotedName Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Foldable MaybePromotedName Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => MaybePromotedName m -> m #

foldMap :: Monoid m => (a -> m) -> MaybePromotedName a -> m #

foldr :: (a -> b -> b) -> b -> MaybePromotedName a -> b #

foldr' :: (a -> b -> b) -> b -> MaybePromotedName a -> b #

foldl :: (b -> a -> b) -> b -> MaybePromotedName a -> b #

foldl' :: (b -> a -> b) -> b -> MaybePromotedName a -> b #

foldr1 :: (a -> a -> a) -> MaybePromotedName a -> a #

foldl1 :: (a -> a -> a) -> MaybePromotedName a -> a #

toList :: MaybePromotedName a -> [a] #

null :: MaybePromotedName a -> Bool #

length :: MaybePromotedName a -> Int #

elem :: Eq a => a -> MaybePromotedName a -> Bool #

maximum :: Ord a => MaybePromotedName a -> a #

minimum :: Ord a => MaybePromotedName a -> a #

sum :: Num a => MaybePromotedName a -> a #

product :: Num a => MaybePromotedName a -> a #

Traversable MaybePromotedName Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> MaybePromotedName a -> f (MaybePromotedName b) #

sequenceA :: Applicative f => MaybePromotedName (f a) -> f (MaybePromotedName a) #

mapM :: Monad m => (a -> m b) -> MaybePromotedName a -> m (MaybePromotedName b) #

sequence :: Monad m => MaybePromotedName (m a) -> m (MaybePromotedName a) #

Annotated MaybePromotedName Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

ExactP MaybePromotedName Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Eq l => Eq (MaybePromotedName l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Data l => Data (MaybePromotedName l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MaybePromotedName l -> c (MaybePromotedName l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (MaybePromotedName l) #

toConstr :: MaybePromotedName l -> Constr #

dataTypeOf :: MaybePromotedName l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (MaybePromotedName l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (MaybePromotedName l)) #

gmapT :: (forall b. Data b => b -> b) -> MaybePromotedName l -> MaybePromotedName l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MaybePromotedName l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MaybePromotedName l -> r #

gmapQ :: (forall d. Data d => d -> u) -> MaybePromotedName l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> MaybePromotedName l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> MaybePromotedName l -> m (MaybePromotedName l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MaybePromotedName l -> m (MaybePromotedName l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MaybePromotedName l -> m (MaybePromotedName l) #

Ord l => Ord (MaybePromotedName l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Show l => Show (MaybePromotedName l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Generic (MaybePromotedName l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (MaybePromotedName l) :: Type -> Type #

Pretty (MaybePromotedName l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: MaybePromotedName l -> Doc

prettyPrec :: Int -> MaybePromotedName l -> Doc

type Rep (MaybePromotedName l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Template Haskell

data Bracket l Source #

A template haskell bracket expression.

Constructors

ExpBracket l (Exp l)

expression bracket: [| ... |]

TExpBracket l (Exp l)

typed expression bracket: [|| ... ||]

PatBracket l (Pat l)

pattern bracket: [p| ... |]

TypeBracket l (Type l)

type bracket: [t| ... |]

DeclBracket l [Decl l]

declaration bracket: [d| ... |]

Instances
Functor Bracket Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Bracket a -> Bracket b #

(<$) :: a -> Bracket b -> Bracket a #

Foldable Bracket Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Bracket m -> m #

foldMap :: Monoid m => (a -> m) -> Bracket a -> m #

foldr :: (a -> b -> b) -> b -> Bracket a -> b #

foldr' :: (a -> b -> b) -> b -> Bracket a -> b #

foldl :: (b -> a -> b) -> b -> Bracket a -> b #

foldl' :: (b -> a -> b) -> b -> Bracket a -> b #

foldr1 :: (a -> a -> a) -> Bracket a -> a #

foldl1 :: (a -> a -> a) -> Bracket a -> a #

toList :: Bracket a -> [a] #

null :: Bracket a -> Bool #

length :: Bracket a -> Int #

elem :: Eq a => a -> Bracket a -> Bool #

maximum :: Ord a => Bracket a -> a #

minimum :: Ord a => Bracket a -> a #

sum :: Num a => Bracket a -> a #

product :: Num a => Bracket a -> a #

Traversable Bracket Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> Bracket a -> f (Bracket b) #

sequenceA :: Applicative f => Bracket (f a) -> f (Bracket a) #

mapM :: Monad m => (a -> m b) -> Bracket a -> m (Bracket b) #

sequence :: Monad m => Bracket (m a) -> m (Bracket a) #

Annotated Bracket Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Bracket l -> l Source #

amap :: (l -> l) -> Bracket l -> Bracket l Source #

AppFixity Bracket Source # 
Instance details

Defined in Language.Haskell.Exts.Fixity

ExactP Bracket Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Bracket SrcSpanInfo -> EP ()

Eq l => Eq (Bracket l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: Bracket l -> Bracket l -> Bool #

(/=) :: Bracket l -> Bracket l -> Bool #

Data l => Data (Bracket l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Bracket l -> c (Bracket l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Bracket l) #

toConstr :: Bracket l -> Constr #

dataTypeOf :: Bracket l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Bracket l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Bracket l)) #

gmapT :: (forall b. Data b => b -> b) -> Bracket l -> Bracket l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bracket l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bracket l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Bracket l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Bracket l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Bracket l -> m (Bracket l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Bracket l -> m (Bracket l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Bracket l -> m (Bracket l) #

Ord l => Ord (Bracket l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: Bracket l -> Bracket l -> Ordering #

(<) :: Bracket l -> Bracket l -> Bool #

(<=) :: Bracket l -> Bracket l -> Bool #

(>) :: Bracket l -> Bracket l -> Bool #

(>=) :: Bracket l -> Bracket l -> Bool #

max :: Bracket l -> Bracket l -> Bracket l #

min :: Bracket l -> Bracket l -> Bracket l #

Show l => Show (Bracket l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> Bracket l -> ShowS #

show :: Bracket l -> String #

showList :: [Bracket l] -> ShowS #

Generic (Bracket l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Bracket l) :: Type -> Type #

Methods

from :: Bracket l -> Rep (Bracket l) x #

to :: Rep (Bracket l) x -> Bracket l #

Pretty (Bracket l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Bracket l -> Doc

prettyPrec :: Int -> Bracket l -> Doc

type Rep (Bracket l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data Splice l Source #

A template haskell splice expression

Constructors

IdSplice l String

variable splice: $var

TIdSplice l String

typed variable splice: $$var

ParenSplice l (Exp l)

parenthesised expression splice: $(exp)

TParenSplice l (Exp l)

parenthesised typed expression splice: $$(exp)

Instances
Functor Splice Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Splice a -> Splice b #

(<$) :: a -> Splice b -> Splice a #

Foldable Splice Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Splice m -> m #

foldMap :: Monoid m => (a -> m) -> Splice a -> m #

foldr :: (a -> b -> b) -> b -> Splice a -> b #

foldr' :: (a -> b -> b) -> b -> Splice a -> b #

foldl :: (b -> a -> b) -> b -> Splice a -> b #

foldl' :: (b -> a -> b) -> b -> Splice a -> b #

foldr1 :: (a -> a -> a) -> Splice a -> a #

foldl1 :: (a -> a -> a) -> Splice a -> a #

toList :: Splice a -> [a] #

null :: Splice a -> Bool #

length :: Splice a -> Int #

elem :: Eq a => a -> Splice a -> Bool #

maximum :: Ord a => Splice a -> a #

minimum :: Ord a => Splice a -> a #

sum :: Num a => Splice a -> a #

product :: Num a => Splice a -> a #

Traversable Splice Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> Splice a -> f (Splice b) #

sequenceA :: Applicative f => Splice (f a) -> f (Splice a) #

mapM :: Monad m => (a -> m b) -> Splice a -> m (Splice b) #

sequence :: Monad m => Splice (m a) -> m (Splice a) #

Annotated Splice Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Splice l -> l Source #

amap :: (l -> l) -> Splice l -> Splice l Source #

AppFixity Splice Source # 
Instance details

Defined in Language.Haskell.Exts.Fixity

ExactP Splice Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Splice SrcSpanInfo -> EP ()

Eq l => Eq (Splice l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: Splice l -> Splice l -> Bool #

(/=) :: Splice l -> Splice l -> Bool #

Data l => Data (Splice l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Splice l -> c (Splice l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Splice l) #

toConstr :: Splice l -> Constr #

dataTypeOf :: Splice l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Splice l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Splice l)) #

gmapT :: (forall b. Data b => b -> b) -> Splice l -> Splice l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Splice l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Splice l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Splice l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Splice l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Splice l -> m (Splice l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Splice l -> m (Splice l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Splice l -> m (Splice l) #

Ord l => Ord (Splice l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: Splice l -> Splice l -> Ordering #

(<) :: Splice l -> Splice l -> Bool #

(<=) :: Splice l -> Splice l -> Bool #

(>) :: Splice l -> Splice l -> Bool #

(>=) :: Splice l -> Splice l -> Bool #

max :: Splice l -> Splice l -> Splice l #

min :: Splice l -> Splice l -> Splice l #

Show l => Show (Splice l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> Splice l -> ShowS #

show :: Splice l -> String #

showList :: [Splice l] -> ShowS #

Generic (Splice l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Splice l) :: Type -> Type #

Methods

from :: Splice l -> Rep (Splice l) x #

to :: Rep (Splice l) x -> Splice l #

Pretty (Splice l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Splice l -> Doc

prettyPrec :: Int -> Splice l -> Doc

type Rep (Splice l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

FFI

data Safety l Source #

The safety of a foreign function call.

Constructors

PlayRisky l

unsafe

PlaySafe l Bool

safe (False) or threadsafe (True)

PlayInterruptible l

interruptible

Instances
Functor Safety Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Safety a -> Safety b #

(<$) :: a -> Safety b -> Safety a #

Foldable Safety Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Safety m -> m #

foldMap :: Monoid m => (a -> m) -> Safety a -> m #

foldr :: (a -> b -> b) -> b -> Safety a -> b #

foldr' :: (a -> b -> b) -> b -> Safety a -> b #

foldl :: (b -> a -> b) -> b -> Safety a -> b #

foldl' :: (b -> a -> b) -> b -> Safety a -> b #

foldr1 :: (a -> a -> a) -> Safety a -> a #

foldl1 :: (a -> a -> a) -> Safety a -> a #

toList :: Safety a -> [a] #

null :: Safety a -> Bool #

length :: Safety a -> Int #

elem :: Eq a => a -> Safety a -> Bool #

maximum :: Ord a => Safety a -> a #

minimum :: Ord a => Safety a -> a #

sum :: Num a => Safety a -> a #

product :: Num a => Safety a -> a #

Traversable Safety Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> Safety a -> f (Safety b) #

sequenceA :: Applicative f => Safety (f a) -> f (Safety a) #

mapM :: Monad m => (a -> m b) -> Safety a -> m (Safety b) #

sequence :: Monad m => Safety (m a) -> m (Safety a) #

Annotated Safety Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Safety l -> l Source #

amap :: (l -> l) -> Safety l -> Safety l Source #

ExactP Safety Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Safety SrcSpanInfo -> EP ()

Eq l => Eq (Safety l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: Safety l -> Safety l -> Bool #

(/=) :: Safety l -> Safety l -> Bool #

Data l => Data (Safety l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Safety l -> c (Safety l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Safety l) #

toConstr :: Safety l -> Constr #

dataTypeOf :: Safety l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Safety l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Safety l)) #

gmapT :: (forall b. Data b => b -> b) -> Safety l -> Safety l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Safety l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Safety l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Safety l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Safety l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Safety l -> m (Safety l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Safety l -> m (Safety l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Safety l -> m (Safety l) #

Ord l => Ord (Safety l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: Safety l -> Safety l -> Ordering #

(<) :: Safety l -> Safety l -> Bool #

(<=) :: Safety l -> Safety l -> Bool #

(>) :: Safety l -> Safety l -> Bool #

(>=) :: Safety l -> Safety l -> Bool #

max :: Safety l -> Safety l -> Safety l #

min :: Safety l -> Safety l -> Safety l #

Show l => Show (Safety l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> Safety l -> ShowS #

show :: Safety l -> String #

showList :: [Safety l] -> ShowS #

Generic (Safety l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Safety l) :: Type -> Type #

Methods

from :: Safety l -> Rep (Safety l) x #

to :: Rep (Safety l) x -> Safety l #

Pretty (Safety l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Safety l -> Doc

prettyPrec :: Int -> Safety l -> Doc

type Rep (Safety l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data CallConv l Source #

The calling convention of a foreign function call.

Constructors

StdCall l 
CCall l 
CPlusPlus l 
DotNet l 
Jvm l 
Js l 
JavaScript l 
CApi l 
Instances
Functor CallConv Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> CallConv a -> CallConv b #

(<$) :: a -> CallConv b -> CallConv a #

Foldable CallConv Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => CallConv m -> m #

foldMap :: Monoid m => (a -> m) -> CallConv a -> m #

foldr :: (a -> b -> b) -> b -> CallConv a -> b #

foldr' :: (a -> b -> b) -> b -> CallConv a -> b #

foldl :: (b -> a -> b) -> b -> CallConv a -> b #

foldl' :: (b -> a -> b) -> b -> CallConv a -> b #

foldr1 :: (a -> a -> a) -> CallConv a -> a #

foldl1 :: (a -> a -> a) -> CallConv a -> a #

toList :: CallConv a -> [a] #

null :: CallConv a -> Bool #

length :: CallConv a -> Int #

elem :: Eq a => a -> CallConv a -> Bool #

maximum :: Ord a => CallConv a -> a #

minimum :: Ord a => CallConv a -> a #

sum :: Num a => CallConv a -> a #

product :: Num a => CallConv a -> a #

Traversable CallConv Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> CallConv a -> f (CallConv b) #

sequenceA :: Applicative f => CallConv (f a) -> f (CallConv a) #

mapM :: Monad m => (a -> m b) -> CallConv a -> m (CallConv b) #

sequence :: Monad m => CallConv (m a) -> m (CallConv a) #

Annotated CallConv Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: CallConv l -> l Source #

amap :: (l -> l) -> CallConv l -> CallConv l Source #

ExactP CallConv Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: CallConv SrcSpanInfo -> EP ()

Eq l => Eq (CallConv l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: CallConv l -> CallConv l -> Bool #

(/=) :: CallConv l -> CallConv l -> Bool #

Data l => Data (CallConv l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CallConv l -> c (CallConv l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (CallConv l) #

toConstr :: CallConv l -> Constr #

dataTypeOf :: CallConv l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (CallConv l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CallConv l)) #

gmapT :: (forall b. Data b => b -> b) -> CallConv l -> CallConv l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CallConv l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CallConv l -> r #

gmapQ :: (forall d. Data d => d -> u) -> CallConv l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> CallConv l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> CallConv l -> m (CallConv l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CallConv l -> m (CallConv l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CallConv l -> m (CallConv l) #

Ord l => Ord (CallConv l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: CallConv l -> CallConv l -> Ordering #

(<) :: CallConv l -> CallConv l -> Bool #

(<=) :: CallConv l -> CallConv l -> Bool #

(>) :: CallConv l -> CallConv l -> Bool #

(>=) :: CallConv l -> CallConv l -> Bool #

max :: CallConv l -> CallConv l -> CallConv l #

min :: CallConv l -> CallConv l -> CallConv l #

Show l => Show (CallConv l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> CallConv l -> ShowS #

show :: CallConv l -> String #

showList :: [CallConv l] -> ShowS #

Generic (CallConv l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (CallConv l) :: Type -> Type #

Methods

from :: CallConv l -> Rep (CallConv l) x #

to :: Rep (CallConv l) x -> CallConv l #

Pretty (CallConv l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: CallConv l -> Doc

prettyPrec :: Int -> CallConv l -> Doc

type Rep (CallConv l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Pragmas

data ModulePragma l Source #

A top level options pragma, preceding the module header.

Constructors

LanguagePragma l [Name l]

LANGUAGE pragma

OptionsPragma l (Maybe Tool) String

OPTIONS pragma, possibly qualified with a tool, e.g. OPTIONS_GHC

AnnModulePragma l (Annotation l)

ANN pragma with module scope

Instances
Functor ModulePragma Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> ModulePragma a -> ModulePragma b #

(<$) :: a -> ModulePragma b -> ModulePragma a #

Foldable ModulePragma Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => ModulePragma m -> m #

foldMap :: Monoid m => (a -> m) -> ModulePragma a -> m #

foldr :: (a -> b -> b) -> b -> ModulePragma a -> b #

foldr' :: (a -> b -> b) -> b -> ModulePragma a -> b #

foldl :: (b -> a -> b) -> b -> ModulePragma a -> b #

foldl' :: (b -> a -> b) -> b -> ModulePragma a -> b #

foldr1 :: (a -> a -> a) -> ModulePragma a -> a #

foldl1 :: (a -> a -> a) -> ModulePragma a -> a #

toList :: ModulePragma a -> [a] #

null :: ModulePragma a -> Bool #

length :: ModulePragma a -> Int #

elem :: Eq a => a -> ModulePragma a -> Bool #

maximum :: Ord a => ModulePragma a -> a #

minimum :: Ord a => ModulePragma a -> a #

sum :: Num a => ModulePragma a -> a #

product :: Num a => ModulePragma a -> a #

Traversable ModulePragma Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> ModulePragma a -> f (ModulePragma b) #

sequenceA :: Applicative f => ModulePragma (f a) -> f (ModulePragma a) #

mapM :: Monad m => (a -> m b) -> ModulePragma a -> m (ModulePragma b) #

sequence :: Monad m => ModulePragma (m a) -> m (ModulePragma a) #

Annotated ModulePragma Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: ModulePragma l -> l Source #

amap :: (l -> l) -> ModulePragma l -> ModulePragma l Source #

ExactP ModulePragma Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: ModulePragma SrcSpanInfo -> EP ()

Eq l => Eq (ModulePragma l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Data l => Data (ModulePragma l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ModulePragma l -> c (ModulePragma l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ModulePragma l) #

toConstr :: ModulePragma l -> Constr #

dataTypeOf :: ModulePragma l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ModulePragma l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ModulePragma l)) #

gmapT :: (forall b. Data b => b -> b) -> ModulePragma l -> ModulePragma l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ModulePragma l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ModulePragma l -> r #

gmapQ :: (forall d. Data d => d -> u) -> ModulePragma l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ModulePragma l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ModulePragma l -> m (ModulePragma l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ModulePragma l -> m (ModulePragma l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ModulePragma l -> m (ModulePragma l) #

Ord l => Ord (ModulePragma l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Show l => Show (ModulePragma l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Generic (ModulePragma l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (ModulePragma l) :: Type -> Type #

Methods

from :: ModulePragma l -> Rep (ModulePragma l) x #

to :: Rep (ModulePragma l) x -> ModulePragma l #

Pretty (ModulePragma l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: ModulePragma l -> Doc

prettyPrec :: Int -> ModulePragma l -> Doc

Parseable (NonGreedy (ListOf (ModulePragma SrcSpanInfo))) Source # 
Instance details

Defined in Language.Haskell.Exts.Parser

type Rep (ModulePragma l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data Tool Source #

Recognised tools for OPTIONS pragmas.

Instances
Eq Tool Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: Tool -> Tool -> Bool #

(/=) :: Tool -> Tool -> Bool #

Data Tool Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Tool -> c Tool #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Tool #

toConstr :: Tool -> Constr #

dataTypeOf :: Tool -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Tool) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Tool) #

gmapT :: (forall b. Data b => b -> b) -> Tool -> Tool #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tool -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tool -> r #

gmapQ :: (forall d. Data d => d -> u) -> Tool -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Tool -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Tool -> m Tool #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Tool -> m Tool #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Tool -> m Tool #

Ord Tool Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: Tool -> Tool -> Ordering #

(<) :: Tool -> Tool -> Bool #

(<=) :: Tool -> Tool -> Bool #

(>) :: Tool -> Tool -> Bool #

(>=) :: Tool -> Tool -> Bool #

max :: Tool -> Tool -> Tool #

min :: Tool -> Tool -> Tool #

Show Tool Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> Tool -> ShowS #

show :: Tool -> String #

showList :: [Tool] -> ShowS #

Generic Tool Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep Tool :: Type -> Type #

Methods

from :: Tool -> Rep Tool x #

to :: Rep Tool x -> Tool #

Pretty Tool Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Tool -> Doc

prettyPrec :: Int -> Tool -> Doc

type Rep Tool Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

type Rep Tool = D1 (MetaData "Tool" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.23.1-Z8xb2tkymYIClPofvAOw3" False) ((C1 (MetaCons "GHC" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "HUGS" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "NHC98" PrefixI False) (U1 :: Type -> Type))) :+: (C1 (MetaCons "YHC" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "HADDOCK" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "UnknownTool" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)))))

data Overlap l Source #

Recognised overlaps for overlap pragmas.

Constructors

NoOverlap l

NO_OVERLAP pragma

Overlap l

OVERLAP pragma

Overlapping l 
Overlaps l 
Overlappable l 
Incoherent l

INCOHERENT pragma

Instances
Functor Overlap Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Overlap a -> Overlap b #

(<$) :: a -> Overlap b -> Overlap a #

Foldable Overlap Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Overlap m -> m #

foldMap :: Monoid m => (a -> m) -> Overlap a -> m #

foldr :: (a -> b -> b) -> b -> Overlap a -> b #

foldr' :: (a -> b -> b) -> b -> Overlap a -> b #

foldl :: (b -> a -> b) -> b -> Overlap a -> b #

foldl' :: (b -> a -> b) -> b -> Overlap a -> b #

foldr1 :: (a -> a -> a) -> Overlap a -> a #

foldl1 :: (a -> a -> a) -> Overlap a -> a #

toList :: Overlap a -> [a] #

null :: Overlap a -> Bool #

length :: Overlap a -> Int #

elem :: Eq a => a -> Overlap a -> Bool #

maximum :: Ord a => Overlap a -> a #

minimum :: Ord a => Overlap a -> a #

sum :: Num a => Overlap a -> a #

product :: Num a => Overlap a -> a #

Traversable Overlap Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> Overlap a -> f (Overlap b) #

sequenceA :: Applicative f => Overlap (f a) -> f (Overlap a) #

mapM :: Monad m => (a -> m b) -> Overlap a -> m (Overlap b) #

sequence :: Monad m => Overlap (m a) -> m (Overlap a) #

Annotated Overlap Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Overlap l -> l Source #

amap :: (l -> l) -> Overlap l -> Overlap l Source #

ExactP Overlap Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Overlap SrcSpanInfo -> EP ()

Eq l => Eq (Overlap l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: Overlap l -> Overlap l -> Bool #

(/=) :: Overlap l -> Overlap l -> Bool #

Data l => Data (Overlap l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Overlap l -> c (Overlap l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Overlap l) #

toConstr :: Overlap l -> Constr #

dataTypeOf :: Overlap l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Overlap l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Overlap l)) #

gmapT :: (forall b. Data b => b -> b) -> Overlap l -> Overlap l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Overlap l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Overlap l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Overlap l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Overlap l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Overlap l -> m (Overlap l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Overlap l -> m (Overlap l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Overlap l -> m (Overlap l) #

Ord l => Ord (Overlap l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: Overlap l -> Overlap l -> Ordering #

(<) :: Overlap l -> Overlap l -> Bool #

(<=) :: Overlap l -> Overlap l -> Bool #

(>) :: Overlap l -> Overlap l -> Bool #

(>=) :: Overlap l -> Overlap l -> Bool #

max :: Overlap l -> Overlap l -> Overlap l #

min :: Overlap l -> Overlap l -> Overlap l #

Show l => Show (Overlap l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> Overlap l -> ShowS #

show :: Overlap l -> String #

showList :: [Overlap l] -> ShowS #

Generic (Overlap l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Overlap l) :: Type -> Type #

Methods

from :: Overlap l -> Rep (Overlap l) x #

to :: Rep (Overlap l) x -> Overlap l #

Pretty (Overlap l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Overlap l -> Doc

prettyPrec :: Int -> Overlap l -> Doc

type Rep (Overlap l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data Rule l Source #

The body of a RULES pragma.

Constructors

Rule l String (Maybe (Activation l)) (Maybe [RuleVar l]) (Exp l) (Exp l) 
Instances
Functor Rule Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Rule a -> Rule b #

(<$) :: a -> Rule b -> Rule a #

Foldable Rule Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Rule m -> m #

foldMap :: Monoid m => (a -> m) -> Rule a -> m #

foldr :: (a -> b -> b) -> b -> Rule a -> b #

foldr' :: (a -> b -> b) -> b -> Rule a -> b #

foldl :: (b -> a -> b) -> b -> Rule a -> b #

foldl' :: (b -> a -> b) -> b -> Rule a -> b #

foldr1 :: (a -> a -> a) -> Rule a -> a #

foldl1 :: (a -> a -> a) -> Rule a -> a #

toList :: Rule a -> [a] #

null :: Rule a -> Bool #

length :: Rule a -> Int #

elem :: Eq a => a -> Rule a -> Bool #

maximum :: Ord a => Rule a -> a #

minimum :: Ord a => Rule a -> a #

sum :: Num a => Rule a -> a #

product :: Num a => Rule a -> a #

Traversable Rule Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> Rule a -> f (Rule b) #

sequenceA :: Applicative f => Rule (f a) -> f (Rule a) #

mapM :: Monad m => (a -> m b) -> Rule a -> m (Rule b) #

sequence :: Monad m => Rule (m a) -> m (Rule a) #

Annotated Rule Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Rule l -> l Source #

amap :: (l -> l) -> Rule l -> Rule l Source #

ExactP Rule Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Rule SrcSpanInfo -> EP ()

Eq l => Eq (Rule l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: Rule l -> Rule l -> Bool #

(/=) :: Rule l -> Rule l -> Bool #

Data l => Data (Rule l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Rule l -> c (Rule l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Rule l) #

toConstr :: Rule l -> Constr #

dataTypeOf :: Rule l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Rule l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Rule l)) #

gmapT :: (forall b. Data b => b -> b) -> Rule l -> Rule l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rule l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rule l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Rule l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Rule l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Rule l -> m (Rule l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Rule l -> m (Rule l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Rule l -> m (Rule l) #

Ord l => Ord (Rule l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: Rule l -> Rule l -> Ordering #

(<) :: Rule l -> Rule l -> Bool #

(<=) :: Rule l -> Rule l -> Bool #

(>) :: Rule l -> Rule l -> Bool #

(>=) :: Rule l -> Rule l -> Bool #

max :: Rule l -> Rule l -> Rule l #

min :: Rule l -> Rule l -> Rule l #

Show l => Show (Rule l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> Rule l -> ShowS #

show :: Rule l -> String #

showList :: [Rule l] -> ShowS #

Generic (Rule l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Rule l) :: Type -> Type #

Methods

from :: Rule l -> Rep (Rule l) x #

to :: Rep (Rule l) x -> Rule l #

Pretty (Rule l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Rule l -> Doc

prettyPrec :: Int -> Rule l -> Doc

type Rep (Rule l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data RuleVar l Source #

Variables used in a RULES pragma, optionally annotated with types

Constructors

RuleVar l (Name l) 
TypedRuleVar l (Name l) (Type l) 
Instances
Functor RuleVar Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> RuleVar a -> RuleVar b #

(<$) :: a -> RuleVar b -> RuleVar a #

Foldable RuleVar Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => RuleVar m -> m #

foldMap :: Monoid m => (a -> m) -> RuleVar a -> m #

foldr :: (a -> b -> b) -> b -> RuleVar a -> b #

foldr' :: (a -> b -> b) -> b -> RuleVar a -> b #

foldl :: (b -> a -> b) -> b -> RuleVar a -> b #

foldl' :: (b -> a -> b) -> b -> RuleVar a -> b #

foldr1 :: (a -> a -> a) -> RuleVar a -> a #

foldl1 :: (a -> a -> a) -> RuleVar a -> a #

toList :: RuleVar a -> [a] #

null :: RuleVar a -> Bool #

length :: RuleVar a -> Int #

elem :: Eq a => a -> RuleVar a -> Bool #

maximum :: Ord a => RuleVar a -> a #

minimum :: Ord a => RuleVar a -> a #

sum :: Num a => RuleVar a -> a #

product :: Num a => RuleVar a -> a #

Traversable RuleVar Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> RuleVar a -> f (RuleVar b) #

sequenceA :: Applicative f => RuleVar (f a) -> f (RuleVar a) #

mapM :: Monad m => (a -> m b) -> RuleVar a -> m (RuleVar b) #

sequence :: Monad m => RuleVar (m a) -> m (RuleVar a) #

Annotated RuleVar Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: RuleVar l -> l Source #

amap :: (l -> l) -> RuleVar l -> RuleVar l Source #

ExactP RuleVar Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: RuleVar SrcSpanInfo -> EP ()

Eq l => Eq (RuleVar l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: RuleVar l -> RuleVar l -> Bool #

(/=) :: RuleVar l -> RuleVar l -> Bool #

Data l => Data (RuleVar l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RuleVar l -> c (RuleVar l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RuleVar l) #

toConstr :: RuleVar l -> Constr #

dataTypeOf :: RuleVar l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (RuleVar l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RuleVar l)) #

gmapT :: (forall b. Data b => b -> b) -> RuleVar l -> RuleVar l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RuleVar l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RuleVar l -> r #

gmapQ :: (forall d. Data d => d -> u) -> RuleVar l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> RuleVar l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RuleVar l -> m (RuleVar l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleVar l -> m (RuleVar l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleVar l -> m (RuleVar l) #

Ord l => Ord (RuleVar l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: RuleVar l -> RuleVar l -> Ordering #

(<) :: RuleVar l -> RuleVar l -> Bool #

(<=) :: RuleVar l -> RuleVar l -> Bool #

(>) :: RuleVar l -> RuleVar l -> Bool #

(>=) :: RuleVar l -> RuleVar l -> Bool #

max :: RuleVar l -> RuleVar l -> RuleVar l #

min :: RuleVar l -> RuleVar l -> RuleVar l #

Show l => Show (RuleVar l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> RuleVar l -> ShowS #

show :: RuleVar l -> String #

showList :: [RuleVar l] -> ShowS #

Generic (RuleVar l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (RuleVar l) :: Type -> Type #

Methods

from :: RuleVar l -> Rep (RuleVar l) x #

to :: Rep (RuleVar l) x -> RuleVar l #

Pretty (RuleVar l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: RuleVar l -> Doc

prettyPrec :: Int -> RuleVar l -> Doc

type Rep (RuleVar l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data Activation l Source #

Activation clause of a RULES pragma.

Constructors

ActiveFrom l Int 
ActiveUntil l Int 
Instances
Functor Activation Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Activation a -> Activation b #

(<$) :: a -> Activation b -> Activation a #

Foldable Activation Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Activation m -> m #

foldMap :: Monoid m => (a -> m) -> Activation a -> m #

foldr :: (a -> b -> b) -> b -> Activation a -> b #

foldr' :: (a -> b -> b) -> b -> Activation a -> b #

foldl :: (b -> a -> b) -> b -> Activation a -> b #

foldl' :: (b -> a -> b) -> b -> Activation a -> b #

foldr1 :: (a -> a -> a) -> Activation a -> a #

foldl1 :: (a -> a -> a) -> Activation a -> a #

toList :: Activation a -> [a] #

null :: Activation a -> Bool #

length :: Activation a -> Int #

elem :: Eq a => a -> Activation a -> Bool #

maximum :: Ord a => Activation a -> a #

minimum :: Ord a => Activation a -> a #

sum :: Num a => Activation a -> a #

product :: Num a => Activation a -> a #

Traversable Activation Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> Activation a -> f (Activation b) #

sequenceA :: Applicative f => Activation (f a) -> f (Activation a) #

mapM :: Monad m => (a -> m b) -> Activation a -> m (Activation b) #

sequence :: Monad m => Activation (m a) -> m (Activation a) #

Annotated Activation Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Activation l -> l Source #

amap :: (l -> l) -> Activation l -> Activation l Source #

ExactP Activation Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Activation SrcSpanInfo -> EP ()

Eq l => Eq (Activation l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: Activation l -> Activation l -> Bool #

(/=) :: Activation l -> Activation l -> Bool #

Data l => Data (Activation l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Activation l -> c (Activation l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Activation l) #

toConstr :: Activation l -> Constr #

dataTypeOf :: Activation l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Activation l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Activation l)) #

gmapT :: (forall b. Data b => b -> b) -> Activation l -> Activation l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Activation l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Activation l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Activation l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Activation l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Activation l -> m (Activation l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Activation l -> m (Activation l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Activation l -> m (Activation l) #

Ord l => Ord (Activation l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Show l => Show (Activation l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Generic (Activation l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Activation l) :: Type -> Type #

Methods

from :: Activation l -> Rep (Activation l) x #

to :: Rep (Activation l) x -> Activation l #

Pretty (Activation l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Activation l -> Doc

prettyPrec :: Int -> Activation l -> Doc

type Rep (Activation l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data Annotation l Source #

An annotation through an ANN pragma.

Constructors

Ann l (Name l) (Exp l)

An annotation for a declared name.

TypeAnn l (Name l) (Exp l)

An annotation for a declared type.

ModuleAnn l (Exp l)

An annotation for the defining module.

Instances
Functor Annotation Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> Annotation a -> Annotation b #

(<$) :: a -> Annotation b -> Annotation a #

Foldable Annotation Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => Annotation m -> m #

foldMap :: Monoid m => (a -> m) -> Annotation a -> m #

foldr :: (a -> b -> b) -> b -> Annotation a -> b #

foldr' :: (a -> b -> b) -> b -> Annotation a -> b #

foldl :: (b -> a -> b) -> b -> Annotation a -> b #

foldl' :: (b -> a -> b) -> b -> Annotation a -> b #

foldr1 :: (a -> a -> a) -> Annotation a -> a #

foldl1 :: (a -> a -> a) -> Annotation a -> a #

toList :: Annotation a -> [a] #

null :: Annotation a -> Bool #

length :: Annotation a -> Int #

elem :: Eq a => a -> Annotation a -> Bool #

maximum :: Ord a => Annotation a -> a #

minimum :: Ord a => Annotation a -> a #

sum :: Num a => Annotation a -> a #

product :: Num a => Annotation a -> a #

Traversable Annotation Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> Annotation a -> f (Annotation b) #

sequenceA :: Applicative f => Annotation (f a) -> f (Annotation a) #

mapM :: Monad m => (a -> m b) -> Annotation a -> m (Annotation b) #

sequence :: Monad m => Annotation (m a) -> m (Annotation a) #

Annotated Annotation Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Annotation l -> l Source #

amap :: (l -> l) -> Annotation l -> Annotation l Source #

AppFixity Annotation Source # 
Instance details

Defined in Language.Haskell.Exts.Fixity

ExactP Annotation Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: Annotation SrcSpanInfo -> EP ()

Eq l => Eq (Annotation l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: Annotation l -> Annotation l -> Bool #

(/=) :: Annotation l -> Annotation l -> Bool #

Data l => Data (Annotation l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Annotation l -> c (Annotation l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Annotation l) #

toConstr :: Annotation l -> Constr #

dataTypeOf :: Annotation l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Annotation l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Annotation l)) #

gmapT :: (forall b. Data b => b -> b) -> Annotation l -> Annotation l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Annotation l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Annotation l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Annotation l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Annotation l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Annotation l -> m (Annotation l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Annotation l -> m (Annotation l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Annotation l -> m (Annotation l) #

Ord l => Ord (Annotation l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Show l => Show (Annotation l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Generic (Annotation l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Annotation l) :: Type -> Type #

Methods

from :: Annotation l -> Rep (Annotation l) x #

to :: Rep (Annotation l) x -> Annotation l #

Pretty (Annotation l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: Annotation l -> Doc

prettyPrec :: Int -> Annotation l -> Doc

type Rep (Annotation l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

data BooleanFormula l Source #

A boolean formula for MINIMAL pragmas.

Constructors

VarFormula l (Name l)

A variable.

AndFormula l [BooleanFormula l]

And boolean formulas.

OrFormula l [BooleanFormula l]

Or boolean formulas.

ParenFormula l (BooleanFormula l)

Parenthesized boolean formulas.

Instances
Functor BooleanFormula Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> BooleanFormula a -> BooleanFormula b #

(<$) :: a -> BooleanFormula b -> BooleanFormula a #

Foldable BooleanFormula Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => BooleanFormula m -> m #

foldMap :: Monoid m => (a -> m) -> BooleanFormula a -> m #

foldr :: (a -> b -> b) -> b -> BooleanFormula a -> b #

foldr' :: (a -> b -> b) -> b -> BooleanFormula a -> b #

foldl :: (b -> a -> b) -> b -> BooleanFormula a -> b #

foldl' :: (b -> a -> b) -> b -> BooleanFormula a -> b #

foldr1 :: (a -> a -> a) -> BooleanFormula a -> a #

foldl1 :: (a -> a -> a) -> BooleanFormula a -> a #

toList :: BooleanFormula a -> [a] #

null :: BooleanFormula a -> Bool #

length :: BooleanFormula a -> Int #

elem :: Eq a => a -> BooleanFormula a -> Bool #

maximum :: Ord a => BooleanFormula a -> a #

minimum :: Ord a => BooleanFormula a -> a #

sum :: Num a => BooleanFormula a -> a #

product :: Num a => BooleanFormula a -> a #

Traversable BooleanFormula Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> BooleanFormula a -> f (BooleanFormula b) #

sequenceA :: Applicative f => BooleanFormula (f a) -> f (BooleanFormula a) #

mapM :: Monad m => (a -> m b) -> BooleanFormula a -> m (BooleanFormula b) #

sequence :: Monad m => BooleanFormula (m a) -> m (BooleanFormula a) #

Annotated BooleanFormula Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: BooleanFormula l -> l Source #

amap :: (l -> l) -> BooleanFormula l -> BooleanFormula l Source #

ExactP BooleanFormula Source # 
Instance details

Defined in Language.Haskell.Exts.ExactPrint

Methods

exactP :: BooleanFormula SrcSpanInfo -> EP ()

Eq l => Eq (BooleanFormula l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Data l => Data (BooleanFormula l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> BooleanFormula l -> c (BooleanFormula l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (BooleanFormula l) #

toConstr :: BooleanFormula l -> Constr #

dataTypeOf :: BooleanFormula l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (BooleanFormula l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (BooleanFormula l)) #

gmapT :: (forall b. Data b => b -> b) -> BooleanFormula l -> BooleanFormula l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BooleanFormula l -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BooleanFormula l -> r #

gmapQ :: (forall d. Data d => d -> u) -> BooleanFormula l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> BooleanFormula l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> BooleanFormula l -> m (BooleanFormula l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> BooleanFormula l -> m (BooleanFormula l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> BooleanFormula l -> m (BooleanFormula l) #

Ord l => Ord (BooleanFormula l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Show l => Show (BooleanFormula l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Generic (BooleanFormula l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (BooleanFormula l) :: Type -> Type #

Pretty (BooleanFormula l) Source # 
Instance details

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: BooleanFormula l -> Doc

prettyPrec :: Int -> BooleanFormula l -> Doc

type Rep (BooleanFormula l) Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Builtin names

Modules

Main function of a program

Constructors

unit_con :: l -> Exp l Source #

tuple_con :: l -> Boxed -> Int -> Exp l Source #

Special identifiers

as_name :: l -> Name l Source #

dot_name :: l -> Name l Source #

jvm_name :: l -> Name l Source #

js_name :: l -> Name l Source #

via_name :: l -> Name l Source #

Type constructors

tuple_tycon :: l -> Boxed -> Int -> Type l Source #

Source coordinates

Annotated trees

class Functor ast => Annotated ast where Source #

AST nodes are annotated, and this class allows manipulation of the annotations.

Methods

ann :: ast l -> l Source #

Retrieve the annotation of an AST node.

amap :: (l -> l) -> ast l -> ast l Source #

Change the annotation of an AST node. Note that only the annotation of the node itself is affected, and not the annotations of any child nodes. if all nodes in the AST tree are to be affected, use fmap.

Instances
Annotated Alt Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Alt l -> l Source #

amap :: (l -> l) -> Alt l -> Alt l Source #

Annotated FieldUpdate Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: FieldUpdate l -> l Source #

amap :: (l -> l) -> FieldUpdate l -> FieldUpdate l Source #

Annotated QualStmt Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: QualStmt l -> l Source #

amap :: (l -> l) -> QualStmt l -> QualStmt l Source #

Annotated Stmt Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Stmt l -> l Source #

amap :: (l -> l) -> Stmt l -> Stmt l Source #

Annotated PatField Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: PatField l -> l Source #

amap :: (l -> l) -> PatField l -> PatField l Source #

Annotated RPat Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: RPat l -> l Source #

amap :: (l -> l) -> RPat l -> RPat l Source #

Annotated RPatOp Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: RPatOp l -> l Source #

amap :: (l -> l) -> RPatOp l -> RPatOp l Source #

Annotated PXAttr Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: PXAttr l -> l Source #

amap :: (l -> l) -> PXAttr l -> PXAttr l Source #

Annotated Pat Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Pat l -> l Source #

amap :: (l -> l) -> Pat l -> Pat l Source #

Annotated WarningText Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: WarningText l -> l Source #

amap :: (l -> l) -> WarningText l -> WarningText l Source #

Annotated RuleVar Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: RuleVar l -> l Source #

amap :: (l -> l) -> RuleVar l -> RuleVar l Source #

Annotated Rule Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Rule l -> l Source #

amap :: (l -> l) -> Rule l -> Rule l Source #

Annotated Activation Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Activation l -> l Source #

amap :: (l -> l) -> Activation l -> Activation l Source #

Annotated Overlap Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Overlap l -> l Source #

amap :: (l -> l) -> Overlap l -> Overlap l Source #

Annotated ModulePragma Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: ModulePragma l -> l Source #

amap :: (l -> l) -> ModulePragma l -> ModulePragma l Source #

Annotated CallConv Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: CallConv l -> l Source #

amap :: (l -> l) -> CallConv l -> CallConv l Source #

Annotated Safety Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Safety l -> l Source #

amap :: (l -> l) -> Safety l -> Safety l Source #

Annotated Splice Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Splice l -> l Source #

amap :: (l -> l) -> Splice l -> Splice l Source #

Annotated Bracket Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Bracket l -> l Source #

amap :: (l -> l) -> Bracket l -> Bracket l Source #

Annotated XAttr Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: XAttr l -> l Source #

amap :: (l -> l) -> XAttr l -> XAttr l Source #

Annotated XName Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: XName l -> l Source #

amap :: (l -> l) -> XName l -> XName l Source #

Annotated Exp Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Exp l -> l Source #

amap :: (l -> l) -> Exp l -> Exp l Source #

Annotated Sign Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Sign l -> l Source #

amap :: (l -> l) -> Sign l -> Sign l Source #

Annotated Literal Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Literal l -> l Source #

amap :: (l -> l) -> Literal l -> Literal l Source #

Annotated Asst Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Asst l -> l Source #

amap :: (l -> l) -> Asst l -> Asst l Source #

Annotated Context Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Context l -> l Source #

amap :: (l -> l) -> Context l -> Context l Source #

Annotated FunDep Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: FunDep l -> l Source #

amap :: (l -> l) -> FunDep l -> FunDep l Source #

Annotated TyVarBind Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: TyVarBind l -> l Source #

amap :: (l -> l) -> TyVarBind l -> TyVarBind l Source #

Annotated Promoted Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Promoted l -> l Source #

amap :: (l -> l) -> Promoted l -> Promoted l Source #

Annotated MaybePromotedName Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Annotated Type Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Type l -> l Source #

amap :: (l -> l) -> Type l -> Type l Source #

Annotated GuardedRhs Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: GuardedRhs l -> l Source #

amap :: (l -> l) -> GuardedRhs l -> GuardedRhs l Source #

Annotated Rhs Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Rhs l -> l Source #

amap :: (l -> l) -> Rhs l -> Rhs l Source #

Annotated Unpackedness Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Unpackedness l -> l Source #

amap :: (l -> l) -> Unpackedness l -> Unpackedness l Source #

Annotated BangType Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: BangType l -> l Source #

amap :: (l -> l) -> BangType l -> BangType l Source #

Annotated InstDecl Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: InstDecl l -> l Source #

amap :: (l -> l) -> InstDecl l -> InstDecl l Source #

Annotated ClassDecl Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: ClassDecl l -> l Source #

amap :: (l -> l) -> ClassDecl l -> ClassDecl l Source #

Annotated GadtDecl Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: GadtDecl l -> l Source #

amap :: (l -> l) -> GadtDecl l -> GadtDecl l Source #

Annotated FieldDecl Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: FieldDecl l -> l Source #

amap :: (l -> l) -> FieldDecl l -> FieldDecl l Source #

Annotated ConDecl Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: ConDecl l -> l Source #

amap :: (l -> l) -> ConDecl l -> ConDecl l Source #

Annotated QualConDecl Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: QualConDecl l -> l Source #

amap :: (l -> l) -> QualConDecl l -> QualConDecl l Source #

Annotated Match Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Match l -> l Source #

amap :: (l -> l) -> Match l -> Match l Source #

Annotated IPBind Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: IPBind l -> l Source #

amap :: (l -> l) -> IPBind l -> IPBind l Source #

Annotated Binds Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Binds l -> l Source #

amap :: (l -> l) -> Binds l -> Binds l Source #

Annotated DerivStrategy Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: DerivStrategy l -> l Source #

amap :: (l -> l) -> DerivStrategy l -> DerivStrategy l Source #

Annotated Deriving Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Deriving l -> l Source #

amap :: (l -> l) -> Deriving l -> Deriving l Source #

Annotated InstHead Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: InstHead l -> l Source #

amap :: (l -> l) -> InstHead l -> InstHead l Source #

Annotated InstRule Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: InstRule l -> l Source #

amap :: (l -> l) -> InstRule l -> InstRule l Source #

Annotated DeclHead Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: DeclHead l -> l Source #

amap :: (l -> l) -> DeclHead l -> DeclHead l Source #

Annotated ResultSig Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: ResultSig l -> l Source #

amap :: (l -> l) -> ResultSig l -> ResultSig l Source #

Annotated InjectivityInfo Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: InjectivityInfo l -> l Source #

amap :: (l -> l) -> InjectivityInfo l -> InjectivityInfo l Source #

Annotated DataOrNew Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: DataOrNew l -> l Source #

amap :: (l -> l) -> DataOrNew l -> DataOrNew l Source #

Annotated Role Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Role l -> l Source #

amap :: (l -> l) -> Role l -> Role l Source #

Annotated BooleanFormula Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: BooleanFormula l -> l Source #

amap :: (l -> l) -> BooleanFormula l -> BooleanFormula l Source #

Annotated Annotation Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Annotation l -> l Source #

amap :: (l -> l) -> Annotation l -> Annotation l Source #

Annotated TypeEqn Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: TypeEqn l -> l Source #

amap :: (l -> l) -> TypeEqn l -> TypeEqn l Source #

Annotated Decl Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Decl l -> l Source #

amap :: (l -> l) -> Decl l -> Decl l Source #

Annotated Assoc Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Assoc l -> l Source #

amap :: (l -> l) -> Assoc l -> Assoc l Source #

Annotated ImportSpec Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: ImportSpec l -> l Source #

amap :: (l -> l) -> ImportSpec l -> ImportSpec l Source #

Annotated ImportSpecList Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: ImportSpecList l -> l Source #

amap :: (l -> l) -> ImportSpecList l -> ImportSpecList l Source #

Annotated ImportDecl Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: ImportDecl l -> l Source #

amap :: (l -> l) -> ImportDecl l -> ImportDecl l Source #

Annotated Namespace Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Namespace l -> l Source #

amap :: (l -> l) -> Namespace l -> Namespace l Source #

Annotated EWildcard Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: EWildcard l -> l Source #

amap :: (l -> l) -> EWildcard l -> EWildcard l Source #

Annotated ExportSpec Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: ExportSpec l -> l Source #

amap :: (l -> l) -> ExportSpec l -> ExportSpec l Source #

Annotated ExportSpecList Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: ExportSpecList l -> l Source #

amap :: (l -> l) -> ExportSpecList l -> ExportSpecList l Source #

Annotated ModuleHead Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: ModuleHead l -> l Source #

amap :: (l -> l) -> ModuleHead l -> ModuleHead l Source #

Annotated Module Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Module l -> l Source #

amap :: (l -> l) -> Module l -> Module l Source #

Annotated CName Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: CName l -> l Source #

amap :: (l -> l) -> CName l -> CName l Source #

Annotated Op Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Op l -> l Source #

amap :: (l -> l) -> Op l -> Op l Source #

Annotated QOp Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: QOp l -> l Source #

amap :: (l -> l) -> QOp l -> QOp l Source #

Annotated IPName Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: IPName l -> l Source #

amap :: (l -> l) -> IPName l -> IPName l Source #

Annotated Name Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: Name l -> l Source #

amap :: (l -> l) -> Name l -> Name l Source #

Annotated QName Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: QName l -> l Source #

amap :: (l -> l) -> QName l -> QName l Source #

Annotated SpecialCon Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: SpecialCon l -> l Source #

amap :: (l -> l) -> SpecialCon l -> SpecialCon l Source #

Annotated ModuleName Source # 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: ModuleName l -> l Source #

amap :: (l -> l) -> ModuleName l -> ModuleName l Source #

(=~=) :: (Annotated a, Eq (a ())) => a l1 -> a l2 -> Bool Source #

Test if two AST elements are equal modulo annotations.