haskell-tools-ast-1.1.0.2: Haskell AST for efficient tooling

Safe HaskellNone
LanguageHaskell2010

Language.Haskell.Tools.AST

Contents

Description

A custom AST representation for Haskell tools. Different layers of the AST are recursive, to separate them into modules we introduced source imports.

Synopsis

Documentation

data UModule dom stage Source #

The representation of a haskell module, that is a separate compilation unit. It may or may not have a header.

Constructors

UModule 

Fields

Instances
SourceInfoTraversal UModule Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UModule dom st1 -> f (UModule dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UModule dom st1 -> f (UModule dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UModule dom st1 -> f (UModule dom st2) Source #

SemanticTraversal UModule Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UModule dom1 st -> f (UModule dom2 st) Source #

(GoodOperationFor c (UModule dom stage), ClassyPlate c (AnnListG UFilePragma dom stage), ClassyPlate c (AnnMaybeG UModuleHead dom stage), ClassyPlate c (AnnListG UImportDecl dom stage), ClassyPlate c (AnnListG UDecl dom stage)) => ClassyPlate c (UModule dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UModule dom stage -> UModule dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UModule dom stage -> m (UModule dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UModule dom stage -> UModule dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UModule dom stage -> m (UModule dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UModule dom stage -> UModule dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UModule dom stage -> m (UModule dom stage) #

(Domain dom, SourceInfo stage) => Data (UModule dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UModule dom stage -> c (UModule dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UModule dom stage) #

toConstr :: UModule dom stage -> Constr #

dataTypeOf :: UModule dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UModule dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UModule dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UModule dom stage -> UModule dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UModule dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UModule dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UModule dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UModule dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UModule dom stage -> m (UModule dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UModule dom stage -> m (UModule dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UModule dom stage -> m (UModule dom stage) #

Domain dom => Generic (UModule dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UModule dom stage) :: * -> * #

Methods

from :: UModule dom stage -> Rep (UModule dom stage) x #

to :: Rep (UModule dom stage) x -> UModule dom stage #

HasModuleInfo dom => HasModuleInfo' (Ann UModule dom st) Source # 
Instance details

Defined in Language.Haskell.Tools.AST.SemaInfoClasses

type Rep (UModule dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UModule dom stage) = D1 (MetaData "UModule" "Language.Haskell.Tools.AST.Representation.Modules" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UModule" PrefixI True) ((S1 (MetaSel (Just "_filePragmas") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UFilePragma dom stage)) :*: S1 (MetaSel (Just "_modHead") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UModuleHead dom stage))) :*: (S1 (MetaSel (Just "_modImports") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UImportDecl dom stage)) :*: S1 (MetaSel (Just "_modDecl") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UDecl dom stage)))))
type IgnoredFields (UModule dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UModule dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UModuleHead dom stage Source #

Module declaration with name and (optional) exports

Constructors

UModuleHead 

Fields

Instances
SourceInfoTraversal UModuleHead Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UModuleHead dom st1 -> f (UModuleHead dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UModuleHead dom st1 -> f (UModuleHead dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UModuleHead dom st1 -> f (UModuleHead dom st2) Source #

SemanticTraversal UModuleHead Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UModuleHead dom1 st -> f (UModuleHead dom2 st) Source #

(GoodOperationFor c (UModuleHead dom stage), ClassyPlate c (Ann UModuleName dom stage), ClassyPlate c (AnnMaybeG UModulePragma dom stage), ClassyPlate c (AnnMaybeG UExportSpecs dom stage)) => ClassyPlate c (UModuleHead dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UModuleHead dom stage -> UModuleHead dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UModuleHead dom stage -> m (UModuleHead dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UModuleHead dom stage -> UModuleHead dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UModuleHead dom stage -> m (UModuleHead dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UModuleHead dom stage -> UModuleHead dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UModuleHead dom stage -> m (UModuleHead dom stage) #

(Domain dom, SourceInfo stage) => Data (UModuleHead dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UModuleHead dom stage -> c (UModuleHead dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UModuleHead dom stage) #

toConstr :: UModuleHead dom stage -> Constr #

dataTypeOf :: UModuleHead dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UModuleHead dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UModuleHead dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UModuleHead dom stage -> UModuleHead dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UModuleHead dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UModuleHead dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UModuleHead dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UModuleHead dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UModuleHead dom stage -> m (UModuleHead dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UModuleHead dom stage -> m (UModuleHead dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UModuleHead dom stage -> m (UModuleHead dom stage) #

Domain dom => Generic (UModuleHead dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UModuleHead dom stage) :: * -> * #

Methods

from :: UModuleHead dom stage -> Rep (UModuleHead dom stage) x #

to :: Rep (UModuleHead dom stage) x -> UModuleHead dom stage #

type Rep (UModuleHead dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UModuleHead dom stage) = D1 (MetaData "UModuleHead" "Language.Haskell.Tools.AST.Representation.Modules" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UModuleHead" PrefixI True) (S1 (MetaSel (Just "_mhName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UModuleName dom stage)) :*: (S1 (MetaSel (Just "_mhPragma") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UModulePragma dom stage)) :*: S1 (MetaSel (Just "_mhExports") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UExportSpecs dom stage)))))
type IgnoredFields (UModuleHead dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UModuleHead dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UExportSpecs dom stage Source #

A list of export specifications surrounded by parentheses

Constructors

UExportSpecs 

Fields

Instances
SourceInfoTraversal UExportSpecs Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UExportSpecs dom st1 -> f (UExportSpecs dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UExportSpecs dom st1 -> f (UExportSpecs dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UExportSpecs dom st1 -> f (UExportSpecs dom st2) Source #

SemanticTraversal UExportSpecs Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UExportSpecs dom1 st -> f (UExportSpecs dom2 st) Source #

(GoodOperationFor c (UExportSpecs dom stage), ClassyPlate c (AnnListG UExportSpec dom stage)) => ClassyPlate c (UExportSpecs dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UExportSpecs dom stage -> UExportSpecs dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UExportSpecs dom stage -> m (UExportSpecs dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UExportSpecs dom stage -> UExportSpecs dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UExportSpecs dom stage -> m (UExportSpecs dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UExportSpecs dom stage -> UExportSpecs dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UExportSpecs dom stage -> m (UExportSpecs dom stage) #

(Domain dom, SourceInfo stage) => Data (UExportSpecs dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UExportSpecs dom stage -> c (UExportSpecs dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UExportSpecs dom stage) #

toConstr :: UExportSpecs dom stage -> Constr #

dataTypeOf :: UExportSpecs dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UExportSpecs dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UExportSpecs dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UExportSpecs dom stage -> UExportSpecs dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UExportSpecs dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UExportSpecs dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UExportSpecs dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UExportSpecs dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UExportSpecs dom stage -> m (UExportSpecs dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UExportSpecs dom stage -> m (UExportSpecs dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UExportSpecs dom stage -> m (UExportSpecs dom stage) #

Domain dom => Generic (UExportSpecs dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UExportSpecs dom stage) :: * -> * #

Methods

from :: UExportSpecs dom stage -> Rep (UExportSpecs dom stage) x #

to :: Rep (UExportSpecs dom stage) x -> UExportSpecs dom stage #

type Rep (UExportSpecs dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UExportSpecs dom stage) = D1 (MetaData "UExportSpecs" "Language.Haskell.Tools.AST.Representation.Modules" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UExportSpecs" PrefixI True) (S1 (MetaSel (Just "_espExports") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UExportSpec dom stage))))
type IgnoredFields (UExportSpecs dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UExportSpecs dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UExportSpec dom stage Source #

Export specifier

Constructors

UDeclExport

Export a name and related names

Fields

UModuleExport

The export of an imported module ( module A )

Fields

Instances
SourceInfoTraversal UExportSpec Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UExportSpec dom st1 -> f (UExportSpec dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UExportSpec dom st1 -> f (UExportSpec dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UExportSpec dom st1 -> f (UExportSpec dom st2) Source #

SemanticTraversal UExportSpec Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UExportSpec dom1 st -> f (UExportSpec dom2 st) Source #

(GoodOperationFor c (UExportSpec dom stage), ClassyPlate c (Ann UIESpec dom stage), ClassyPlate c (Ann UModuleName dom stage)) => ClassyPlate c (UExportSpec dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UExportSpec dom stage -> UExportSpec dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UExportSpec dom stage -> m (UExportSpec dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UExportSpec dom stage -> UExportSpec dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UExportSpec dom stage -> m (UExportSpec dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UExportSpec dom stage -> UExportSpec dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UExportSpec dom stage -> m (UExportSpec dom stage) #

(Domain dom, SourceInfo stage) => Data (UExportSpec dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UExportSpec dom stage -> c (UExportSpec dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UExportSpec dom stage) #

toConstr :: UExportSpec dom stage -> Constr #

dataTypeOf :: UExportSpec dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UExportSpec dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UExportSpec dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UExportSpec dom stage -> UExportSpec dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UExportSpec dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UExportSpec dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UExportSpec dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UExportSpec dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UExportSpec dom stage -> m (UExportSpec dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UExportSpec dom stage -> m (UExportSpec dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UExportSpec dom stage -> m (UExportSpec dom stage) #

Domain dom => Generic (UExportSpec dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UExportSpec dom stage) :: * -> * #

Methods

from :: UExportSpec dom stage -> Rep (UExportSpec dom stage) x #

to :: Rep (UExportSpec dom stage) x -> UExportSpec dom stage #

type Rep (UExportSpec dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UExportSpec dom stage) = D1 (MetaData "UExportSpec" "Language.Haskell.Tools.AST.Representation.Modules" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UDeclExport" PrefixI True) (S1 (MetaSel (Just "_exportDecl") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UIESpec dom stage))) :+: C1 (MetaCons "UModuleExport" PrefixI True) (S1 (MetaSel (Just "_exportModuleName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UModuleName dom stage))))
type IgnoredFields (UExportSpec dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UExportSpec dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UIESpec dom stage Source #

Marks a name to be imported or exported with related names (subspecifier)

Constructors

UIESpec 

Fields

Instances
SourceInfoTraversal UIESpec Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UIESpec dom st1 -> f (UIESpec dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UIESpec dom st1 -> f (UIESpec dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UIESpec dom st1 -> f (UIESpec dom st2) Source #

SemanticTraversal UIESpec Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UIESpec dom1 st -> f (UIESpec dom2 st) Source #

(GoodOperationFor c (UIESpec dom stage), ClassyPlate c (AnnMaybeG UImportModifier dom stage), ClassyPlate c (Ann UName dom stage), ClassyPlate c (AnnMaybeG USubSpec dom stage)) => ClassyPlate c (UIESpec dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UIESpec dom stage -> UIESpec dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UIESpec dom stage -> m (UIESpec dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UIESpec dom stage -> UIESpec dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UIESpec dom stage -> m (UIESpec dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UIESpec dom stage -> UIESpec dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UIESpec dom stage -> m (UIESpec dom stage) #

(Domain dom, SourceInfo stage) => Data (UIESpec dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UIESpec dom stage -> c (UIESpec dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UIESpec dom stage) #

toConstr :: UIESpec dom stage -> Constr #

dataTypeOf :: UIESpec dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UIESpec dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UIESpec dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UIESpec dom stage -> UIESpec dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UIESpec dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UIESpec dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UIESpec dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UIESpec dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UIESpec dom stage -> m (UIESpec dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UIESpec dom stage -> m (UIESpec dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UIESpec dom stage -> m (UIESpec dom stage) #

Domain dom => Generic (UIESpec dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UIESpec dom stage) :: * -> * #

Methods

from :: UIESpec dom stage -> Rep (UIESpec dom stage) x #

to :: Rep (UIESpec dom stage) x -> UIESpec dom stage #

type Rep (UIESpec dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UIESpec dom stage) = D1 (MetaData "UIESpec" "Language.Haskell.Tools.AST.Representation.Modules" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UIESpec" PrefixI True) (S1 (MetaSel (Just "_ieModifier") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UImportModifier dom stage)) :*: (S1 (MetaSel (Just "_ieName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage)) :*: S1 (MetaSel (Just "_ieSubspec") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG USubSpec dom stage)))))
type IgnoredFields (UIESpec dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UIESpec dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UImportModifier dom stage Source #

Specifies the imported element

Constructors

UImportPattern

pattern: modifier for importing pattern synonyms

UImportType

type: modifier for importing types

Instances
SourceInfoTraversal UImportModifier Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UImportModifier dom st1 -> f (UImportModifier dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UImportModifier dom st1 -> f (UImportModifier dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UImportModifier dom st1 -> f (UImportModifier dom st2) Source #

SemanticTraversal UImportModifier Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UImportModifier dom1 st -> f (UImportModifier dom2 st) Source #

GoodOperationFor c (UImportModifier dom stage) => ClassyPlate c (UImportModifier dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UImportModifier dom stage -> UImportModifier dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UImportModifier dom stage -> m (UImportModifier dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UImportModifier dom stage -> UImportModifier dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UImportModifier dom stage -> m (UImportModifier dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UImportModifier dom stage -> UImportModifier dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UImportModifier dom stage -> m (UImportModifier dom stage) #

(Domain dom, SourceInfo stage) => Data (UImportModifier dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UImportModifier dom stage -> c (UImportModifier dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UImportModifier dom stage) #

toConstr :: UImportModifier dom stage -> Constr #

dataTypeOf :: UImportModifier dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UImportModifier dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UImportModifier dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UImportModifier dom stage -> UImportModifier dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UImportModifier dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UImportModifier dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UImportModifier dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UImportModifier dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UImportModifier dom stage -> m (UImportModifier dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UImportModifier dom stage -> m (UImportModifier dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UImportModifier dom stage -> m (UImportModifier dom stage) #

Domain dom => Generic (UImportModifier dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UImportModifier dom stage) :: * -> * #

Methods

from :: UImportModifier dom stage -> Rep (UImportModifier dom stage) x #

to :: Rep (UImportModifier dom stage) x -> UImportModifier dom stage #

type Rep (UImportModifier dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UImportModifier dom stage) = D1 (MetaData "UImportModifier" "Language.Haskell.Tools.AST.Representation.Modules" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UImportPattern" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "UImportType" PrefixI False) (U1 :: * -> *))
type IgnoredFields (UImportModifier dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UImportModifier dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data USubSpec dom stage Source #

Marks how related names will be imported or exported with a given name

Constructors

USubSpecAll

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

USubSpecList

(a,b,c): a class exported with some of its methods, or a datatype exported with some of its constructors.

Fields

Instances
SourceInfoTraversal USubSpec Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> USubSpec dom st1 -> f (USubSpec dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> USubSpec dom st1 -> f (USubSpec dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> USubSpec dom st1 -> f (USubSpec dom st2) Source #

SemanticTraversal USubSpec Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> USubSpec dom1 st -> f (USubSpec dom2 st) Source #

(GoodOperationFor c (USubSpec dom stage), ClassyPlate c (AnnListG UName dom stage)) => ClassyPlate c (USubSpec dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> USubSpec dom stage -> USubSpec dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> USubSpec dom stage -> m (USubSpec dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> USubSpec dom stage -> USubSpec dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> USubSpec dom stage -> m (USubSpec dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> USubSpec dom stage -> USubSpec dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> USubSpec dom stage -> m (USubSpec dom stage) #

(Domain dom, SourceInfo stage) => Data (USubSpec dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> USubSpec dom stage -> c (USubSpec dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (USubSpec dom stage) #

toConstr :: USubSpec dom stage -> Constr #

dataTypeOf :: USubSpec dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (USubSpec dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (USubSpec dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> USubSpec dom stage -> USubSpec dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> USubSpec dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> USubSpec dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> USubSpec dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> USubSpec dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> USubSpec dom stage -> m (USubSpec dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> USubSpec dom stage -> m (USubSpec dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> USubSpec dom stage -> m (USubSpec dom stage) #

Domain dom => Generic (USubSpec dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (USubSpec dom stage) :: * -> * #

Methods

from :: USubSpec dom stage -> Rep (USubSpec dom stage) x #

to :: Rep (USubSpec dom stage) x -> USubSpec dom stage #

type Rep (USubSpec dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (USubSpec dom stage) = D1 (MetaData "USubSpec" "Language.Haskell.Tools.AST.Representation.Modules" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "USubSpecAll" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "USubSpecList" PrefixI True) (S1 (MetaSel (Just "_essList") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UName dom stage))))
type IgnoredFields (USubSpec dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (USubSpec dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UFilePragma dom stage Source #

Pragmas that must be used before defining the module

Constructors

ULanguagePragma

LANGUAGE pragma, listing the enabled language extensions in that file

UOptionsPragma

OPTIONS pragma, possibly qualified with a tool, e.g. OPTIONS_GHC

Fields

Instances
SourceInfoTraversal UFilePragma Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UFilePragma dom st1 -> f (UFilePragma dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UFilePragma dom st1 -> f (UFilePragma dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UFilePragma dom st1 -> f (UFilePragma dom st2) Source #

SemanticTraversal UFilePragma Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UFilePragma dom1 st -> f (UFilePragma dom2 st) Source #

(GoodOperationFor c (UFilePragma dom stage), ClassyPlate c (AnnListG ULanguageExtension dom stage), ClassyPlate c (Ann UStringNode dom stage)) => ClassyPlate c (UFilePragma dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UFilePragma dom stage -> UFilePragma dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UFilePragma dom stage -> m (UFilePragma dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UFilePragma dom stage -> UFilePragma dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UFilePragma dom stage -> m (UFilePragma dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UFilePragma dom stage -> UFilePragma dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UFilePragma dom stage -> m (UFilePragma dom stage) #

(Domain dom, SourceInfo stage) => Data (UFilePragma dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UFilePragma dom stage -> c (UFilePragma dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UFilePragma dom stage) #

toConstr :: UFilePragma dom stage -> Constr #

dataTypeOf :: UFilePragma dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UFilePragma dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UFilePragma dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UFilePragma dom stage -> UFilePragma dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UFilePragma dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UFilePragma dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UFilePragma dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UFilePragma dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UFilePragma dom stage -> m (UFilePragma dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UFilePragma dom stage -> m (UFilePragma dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UFilePragma dom stage -> m (UFilePragma dom stage) #

Domain dom => Generic (UFilePragma dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UFilePragma dom stage) :: * -> * #

Methods

from :: UFilePragma dom stage -> Rep (UFilePragma dom stage) x #

to :: Rep (UFilePragma dom stage) x -> UFilePragma dom stage #

type Rep (UFilePragma dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UFilePragma dom stage) = D1 (MetaData "UFilePragma" "Language.Haskell.Tools.AST.Representation.Modules" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "ULanguagePragma" PrefixI True) (S1 (MetaSel (Just "_lpPragmas") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG ULanguageExtension dom stage))) :+: C1 (MetaCons "UOptionsPragma" PrefixI True) (S1 (MetaSel (Just "_opStr") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UStringNode dom stage))))
type IgnoredFields (UFilePragma dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UFilePragma dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UModulePragma dom stage Source #

Pragmas that must be used after the module head

Constructors

UModuleWarningPragma

A warning pragma attached to the module

Fields

UModuleDeprecatedPragma

A deprecated pragma attached to the module

Instances
SourceInfoTraversal UModulePragma Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UModulePragma dom st1 -> f (UModulePragma dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UModulePragma dom st1 -> f (UModulePragma dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UModulePragma dom st1 -> f (UModulePragma dom st2) Source #

SemanticTraversal UModulePragma Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UModulePragma dom1 st -> f (UModulePragma dom2 st) Source #

(GoodOperationFor c (UModulePragma dom stage), ClassyPlate c (AnnListG UStringNode dom stage), ClassyPlate c (AnnListG UStringNode dom stage)) => ClassyPlate c (UModulePragma dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UModulePragma dom stage -> UModulePragma dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UModulePragma dom stage -> m (UModulePragma dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UModulePragma dom stage -> UModulePragma dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UModulePragma dom stage -> m (UModulePragma dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UModulePragma dom stage -> UModulePragma dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UModulePragma dom stage -> m (UModulePragma dom stage) #

(Domain dom, SourceInfo stage) => Data (UModulePragma dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UModulePragma dom stage -> c (UModulePragma dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UModulePragma dom stage) #

toConstr :: UModulePragma dom stage -> Constr #

dataTypeOf :: UModulePragma dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UModulePragma dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UModulePragma dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UModulePragma dom stage -> UModulePragma dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UModulePragma dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UModulePragma dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UModulePragma dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UModulePragma dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UModulePragma dom stage -> m (UModulePragma dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UModulePragma dom stage -> m (UModulePragma dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UModulePragma dom stage -> m (UModulePragma dom stage) #

Domain dom => Generic (UModulePragma dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UModulePragma dom stage) :: * -> * #

Methods

from :: UModulePragma dom stage -> Rep (UModulePragma dom stage) x #

to :: Rep (UModulePragma dom stage) x -> UModulePragma dom stage #

type Rep (UModulePragma dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UModulePragma dom stage) = D1 (MetaData "UModulePragma" "Language.Haskell.Tools.AST.Representation.Modules" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UModuleWarningPragma" PrefixI True) (S1 (MetaSel (Just "_modWarningStr") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UStringNode dom stage))) :+: C1 (MetaCons "UModuleDeprecatedPragma" PrefixI True) (S1 (MetaSel (Just "_modDeprecatedPragma") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UStringNode dom stage))))
type IgnoredFields (UModulePragma dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UModulePragma dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data ULanguageExtension dom stage Source #

The name of the enabled language extension, for example ( LambdaCase )

Constructors

ULanguageExtension 

Fields

Instances
SourceInfoTraversal ULanguageExtension Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> ULanguageExtension dom st1 -> f (ULanguageExtension dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> ULanguageExtension dom st1 -> f (ULanguageExtension dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> ULanguageExtension dom st1 -> f (ULanguageExtension dom st2) Source #

SemanticTraversal ULanguageExtension Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> ULanguageExtension dom1 st -> f (ULanguageExtension dom2 st) Source #

GoodOperationFor c (ULanguageExtension dom stage) => ClassyPlate c (ULanguageExtension dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> ULanguageExtension dom stage -> ULanguageExtension dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> ULanguageExtension dom stage -> m (ULanguageExtension dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> ULanguageExtension dom stage -> ULanguageExtension dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> ULanguageExtension dom stage -> m (ULanguageExtension dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> ULanguageExtension dom stage -> ULanguageExtension dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> ULanguageExtension dom stage -> m (ULanguageExtension dom stage) #

(Domain dom, SourceInfo stage) => Data (ULanguageExtension dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ULanguageExtension dom stage -> c (ULanguageExtension dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ULanguageExtension dom stage) #

toConstr :: ULanguageExtension dom stage -> Constr #

dataTypeOf :: ULanguageExtension dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ULanguageExtension dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ULanguageExtension dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> ULanguageExtension dom stage -> ULanguageExtension dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ULanguageExtension dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ULanguageExtension dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> ULanguageExtension dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ULanguageExtension dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ULanguageExtension dom stage -> m (ULanguageExtension dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ULanguageExtension dom stage -> m (ULanguageExtension dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ULanguageExtension dom stage -> m (ULanguageExtension dom stage) #

Domain dom => Generic (ULanguageExtension dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (ULanguageExtension dom stage) :: * -> * #

Methods

from :: ULanguageExtension dom stage -> Rep (ULanguageExtension dom stage) x #

to :: Rep (ULanguageExtension dom stage) x -> ULanguageExtension dom stage #

type Rep (ULanguageExtension dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (ULanguageExtension dom stage) = D1 (MetaData "ULanguageExtension" "Language.Haskell.Tools.AST.Representation.Modules" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "ULanguageExtension" PrefixI True) (S1 (MetaSel (Just "_langExt") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)))
type IgnoredFields (ULanguageExtension dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (ULanguageExtension dom stage) = (Right "_langExt" :: Either (Symbol, Nat) Symbol) ': ([] :: [Either (Symbol, Nat) Symbol])

data UImportDecl dom stage Source #

An import declaration: import Module.Name

Instances
SourceInfoTraversal UImportDecl Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UImportDecl dom st1 -> f (UImportDecl dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UImportDecl dom st1 -> f (UImportDecl dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UImportDecl dom st1 -> f (UImportDecl dom st2) Source #

SemanticTraversal UImportDecl Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UImportDecl dom1 st -> f (UImportDecl dom2 st) Source #

(GoodOperationFor c (UImportDecl dom stage), ClassyPlate c (AnnMaybeG UImportSource dom stage), ClassyPlate c (AnnMaybeG UImportQualified dom stage), ClassyPlate c (AnnMaybeG UImportSafe dom stage), ClassyPlate c (AnnMaybeG UStringNode dom stage), ClassyPlate c (Ann UModuleName dom stage), ClassyPlate c (AnnMaybeG UImportRenaming dom stage), ClassyPlate c (AnnMaybeG UImportSpec dom stage)) => ClassyPlate c (UImportDecl dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UImportDecl dom stage -> UImportDecl dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UImportDecl dom stage -> m (UImportDecl dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UImportDecl dom stage -> UImportDecl dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UImportDecl dom stage -> m (UImportDecl dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UImportDecl dom stage -> UImportDecl dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UImportDecl dom stage -> m (UImportDecl dom stage) #

(Domain dom, SourceInfo stage) => Data (UImportDecl dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UImportDecl dom stage -> c (UImportDecl dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UImportDecl dom stage) #

toConstr :: UImportDecl dom stage -> Constr #

dataTypeOf :: UImportDecl dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UImportDecl dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UImportDecl dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UImportDecl dom stage -> UImportDecl dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UImportDecl dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UImportDecl dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UImportDecl dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UImportDecl dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UImportDecl dom stage -> m (UImportDecl dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UImportDecl dom stage -> m (UImportDecl dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UImportDecl dom stage -> m (UImportDecl dom stage) #

Domain dom => Generic (UImportDecl dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UImportDecl dom stage) :: * -> * #

Methods

from :: UImportDecl dom stage -> Rep (UImportDecl dom stage) x #

to :: Rep (UImportDecl dom stage) x -> UImportDecl dom stage #

HasImportInfo dom => HasImportInfo' (Ann UImportDecl dom st) Source # 
Instance details

Defined in Language.Haskell.Tools.AST.SemaInfoClasses

type Rep (UImportDecl dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UImportDecl dom stage) = D1 (MetaData "UImportDecl" "Language.Haskell.Tools.AST.Representation.Modules" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UImportDecl" PrefixI True) ((S1 (MetaSel (Just "_importSource") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UImportSource dom stage)) :*: (S1 (MetaSel (Just "_importQualified") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UImportQualified dom stage)) :*: S1 (MetaSel (Just "_importSafe") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UImportSafe dom stage)))) :*: ((S1 (MetaSel (Just "_importPkg") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UStringNode dom stage)) :*: S1 (MetaSel (Just "_importModule") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UModuleName dom stage))) :*: (S1 (MetaSel (Just "_importAs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UImportRenaming dom stage)) :*: S1 (MetaSel (Just "_importSpec") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UImportSpec dom stage))))))
type IgnoredFields (UImportDecl dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UImportDecl dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UImportSpec dom stage Source #

Restriction on the imported names

Constructors

UImportSpecList

Restrict the import definition to ONLY import the listed names

Fields

UImportSpecHiding

Restrict the import definition to DONT import the listed names

Fields

Instances
SourceInfoTraversal UImportSpec Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UImportSpec dom st1 -> f (UImportSpec dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UImportSpec dom st1 -> f (UImportSpec dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UImportSpec dom st1 -> f (UImportSpec dom st2) Source #

SemanticTraversal UImportSpec Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UImportSpec dom1 st -> f (UImportSpec dom2 st) Source #

(GoodOperationFor c (UImportSpec dom stage), ClassyPlate c (AnnListG UIESpec dom stage), ClassyPlate c (AnnListG UIESpec dom stage)) => ClassyPlate c (UImportSpec dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UImportSpec dom stage -> UImportSpec dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UImportSpec dom stage -> m (UImportSpec dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UImportSpec dom stage -> UImportSpec dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UImportSpec dom stage -> m (UImportSpec dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UImportSpec dom stage -> UImportSpec dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UImportSpec dom stage -> m (UImportSpec dom stage) #

(Domain dom, SourceInfo stage) => Data (UImportSpec dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UImportSpec dom stage -> c (UImportSpec dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UImportSpec dom stage) #

toConstr :: UImportSpec dom stage -> Constr #

dataTypeOf :: UImportSpec dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UImportSpec dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UImportSpec dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UImportSpec dom stage -> UImportSpec dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UImportSpec dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UImportSpec dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UImportSpec dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UImportSpec dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UImportSpec dom stage -> m (UImportSpec dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UImportSpec dom stage -> m (UImportSpec dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UImportSpec dom stage -> m (UImportSpec dom stage) #

Domain dom => Generic (UImportSpec dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UImportSpec dom stage) :: * -> * #

Methods

from :: UImportSpec dom stage -> Rep (UImportSpec dom stage) x #

to :: Rep (UImportSpec dom stage) x -> UImportSpec dom stage #

type Rep (UImportSpec dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UImportSpec dom stage) = D1 (MetaData "UImportSpec" "Language.Haskell.Tools.AST.Representation.Modules" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UImportSpecList" PrefixI True) (S1 (MetaSel (Just "_importSpecList") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UIESpec dom stage))) :+: C1 (MetaCons "UImportSpecHiding" PrefixI True) (S1 (MetaSel (Just "_importSpecHiding") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UIESpec dom stage))))
type IgnoredFields (UImportSpec dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UImportSpec dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UImportQualified dom stage Source #

Marks the import as qualified: qualified

Constructors

UImportQualified 
Instances
SourceInfoTraversal UImportQualified Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UImportQualified dom st1 -> f (UImportQualified dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UImportQualified dom st1 -> f (UImportQualified dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UImportQualified dom st1 -> f (UImportQualified dom st2) Source #

SemanticTraversal UImportQualified Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UImportQualified dom1 st -> f (UImportQualified dom2 st) Source #

GoodOperationFor c (UImportQualified dom stage) => ClassyPlate c (UImportQualified dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UImportQualified dom stage -> UImportQualified dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UImportQualified dom stage -> m (UImportQualified dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UImportQualified dom stage -> UImportQualified dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UImportQualified dom stage -> m (UImportQualified dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UImportQualified dom stage -> UImportQualified dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UImportQualified dom stage -> m (UImportQualified dom stage) #

(Domain dom, SourceInfo stage) => Data (UImportQualified dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UImportQualified dom stage -> c (UImportQualified dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UImportQualified dom stage) #

toConstr :: UImportQualified dom stage -> Constr #

dataTypeOf :: UImportQualified dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UImportQualified dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UImportQualified dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UImportQualified dom stage -> UImportQualified dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UImportQualified dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UImportQualified dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UImportQualified dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UImportQualified dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UImportQualified dom stage -> m (UImportQualified dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UImportQualified dom stage -> m (UImportQualified dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UImportQualified dom stage -> m (UImportQualified dom stage) #

Domain dom => Generic (UImportQualified dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UImportQualified dom stage) :: * -> * #

Methods

from :: UImportQualified dom stage -> Rep (UImportQualified dom stage) x #

to :: Rep (UImportQualified dom stage) x -> UImportQualified dom stage #

type Rep (UImportQualified dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UImportQualified dom stage) = D1 (MetaData "UImportQualified" "Language.Haskell.Tools.AST.Representation.Modules" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UImportQualified" PrefixI False) (U1 :: * -> *))
type IgnoredFields (UImportQualified dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UImportQualified dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UImportSource dom stage Source #

Marks the import as source: {--}

Constructors

UImportSource 
Instances
SourceInfoTraversal UImportSource Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UImportSource dom st1 -> f (UImportSource dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UImportSource dom st1 -> f (UImportSource dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UImportSource dom st1 -> f (UImportSource dom st2) Source #

SemanticTraversal UImportSource Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UImportSource dom1 st -> f (UImportSource dom2 st) Source #

GoodOperationFor c (UImportSource dom stage) => ClassyPlate c (UImportSource dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UImportSource dom stage -> UImportSource dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UImportSource dom stage -> m (UImportSource dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UImportSource dom stage -> UImportSource dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UImportSource dom stage -> m (UImportSource dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UImportSource dom stage -> UImportSource dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UImportSource dom stage -> m (UImportSource dom stage) #

(Domain dom, SourceInfo stage) => Data (UImportSource dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UImportSource dom stage -> c (UImportSource dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UImportSource dom stage) #

toConstr :: UImportSource dom stage -> Constr #

dataTypeOf :: UImportSource dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UImportSource dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UImportSource dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UImportSource dom stage -> UImportSource dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UImportSource dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UImportSource dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UImportSource dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UImportSource dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UImportSource dom stage -> m (UImportSource dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UImportSource dom stage -> m (UImportSource dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UImportSource dom stage -> m (UImportSource dom stage) #

Domain dom => Generic (UImportSource dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UImportSource dom stage) :: * -> * #

Methods

from :: UImportSource dom stage -> Rep (UImportSource dom stage) x #

to :: Rep (UImportSource dom stage) x -> UImportSource dom stage #

type Rep (UImportSource dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UImportSource dom stage) = D1 (MetaData "UImportSource" "Language.Haskell.Tools.AST.Representation.Modules" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UImportSource" PrefixI False) (U1 :: * -> *))
type IgnoredFields (UImportSource dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UImportSource dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UImportSafe dom stage Source #

Marks the import as safe: safe

Constructors

UImportSafe 
Instances
SourceInfoTraversal UImportSafe Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UImportSafe dom st1 -> f (UImportSafe dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UImportSafe dom st1 -> f (UImportSafe dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UImportSafe dom st1 -> f (UImportSafe dom st2) Source #

SemanticTraversal UImportSafe Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UImportSafe dom1 st -> f (UImportSafe dom2 st) Source #

GoodOperationFor c (UImportSafe dom stage) => ClassyPlate c (UImportSafe dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UImportSafe dom stage -> UImportSafe dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UImportSafe dom stage -> m (UImportSafe dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UImportSafe dom stage -> UImportSafe dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UImportSafe dom stage -> m (UImportSafe dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UImportSafe dom stage -> UImportSafe dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UImportSafe dom stage -> m (UImportSafe dom stage) #

(Domain dom, SourceInfo stage) => Data (UImportSafe dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UImportSafe dom stage -> c (UImportSafe dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UImportSafe dom stage) #

toConstr :: UImportSafe dom stage -> Constr #

dataTypeOf :: UImportSafe dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UImportSafe dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UImportSafe dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UImportSafe dom stage -> UImportSafe dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UImportSafe dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UImportSafe dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UImportSafe dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UImportSafe dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UImportSafe dom stage -> m (UImportSafe dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UImportSafe dom stage -> m (UImportSafe dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UImportSafe dom stage -> m (UImportSafe dom stage) #

Domain dom => Generic (UImportSafe dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UImportSafe dom stage) :: * -> * #

Methods

from :: UImportSafe dom stage -> Rep (UImportSafe dom stage) x #

to :: Rep (UImportSafe dom stage) x -> UImportSafe dom stage #

type Rep (UImportSafe dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UImportSafe dom stage) = D1 (MetaData "UImportSafe" "Language.Haskell.Tools.AST.Representation.Modules" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UImportSafe" PrefixI False) (U1 :: * -> *))
type IgnoredFields (UImportSafe dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UImportSafe dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UTypeNamespace dom stage Source #

Marks an imported name to belong to the type namespace: type

Constructors

UTypeNamespace 
Instances
SourceInfoTraversal UTypeNamespace Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UTypeNamespace dom st1 -> f (UTypeNamespace dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UTypeNamespace dom st1 -> f (UTypeNamespace dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UTypeNamespace dom st1 -> f (UTypeNamespace dom st2) Source #

SemanticTraversal UTypeNamespace Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UTypeNamespace dom1 st -> f (UTypeNamespace dom2 st) Source #

GoodOperationFor c (UTypeNamespace dom stage) => ClassyPlate c (UTypeNamespace dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UTypeNamespace dom stage -> UTypeNamespace dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UTypeNamespace dom stage -> m (UTypeNamespace dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UTypeNamespace dom stage -> UTypeNamespace dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UTypeNamespace dom stage -> m (UTypeNamespace dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UTypeNamespace dom stage -> UTypeNamespace dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UTypeNamespace dom stage -> m (UTypeNamespace dom stage) #

(Domain dom, SourceInfo stage) => Data (UTypeNamespace dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UTypeNamespace dom stage -> c (UTypeNamespace dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UTypeNamespace dom stage) #

toConstr :: UTypeNamespace dom stage -> Constr #

dataTypeOf :: UTypeNamespace dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UTypeNamespace dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UTypeNamespace dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UTypeNamespace dom stage -> UTypeNamespace dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UTypeNamespace dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UTypeNamespace dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UTypeNamespace dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UTypeNamespace dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UTypeNamespace dom stage -> m (UTypeNamespace dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UTypeNamespace dom stage -> m (UTypeNamespace dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UTypeNamespace dom stage -> m (UTypeNamespace dom stage) #

Domain dom => Generic (UTypeNamespace dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UTypeNamespace dom stage) :: * -> * #

Methods

from :: UTypeNamespace dom stage -> Rep (UTypeNamespace dom stage) x #

to :: Rep (UTypeNamespace dom stage) x -> UTypeNamespace dom stage #

type Rep (UTypeNamespace dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UTypeNamespace dom stage) = D1 (MetaData "UTypeNamespace" "Language.Haskell.Tools.AST.Representation.Modules" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UTypeNamespace" PrefixI False) (U1 :: * -> *))
type IgnoredFields (UTypeNamespace dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UTypeNamespace dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UImportRenaming dom stage Source #

Renaming imports ( as A )

Constructors

UImportRenaming 

Fields

Instances
SourceInfoTraversal UImportRenaming Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UImportRenaming dom st1 -> f (UImportRenaming dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UImportRenaming dom st1 -> f (UImportRenaming dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UImportRenaming dom st1 -> f (UImportRenaming dom st2) Source #

SemanticTraversal UImportRenaming Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UImportRenaming dom1 st -> f (UImportRenaming dom2 st) Source #

(GoodOperationFor c (UImportRenaming dom stage), ClassyPlate c (Ann UModuleName dom stage)) => ClassyPlate c (UImportRenaming dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UImportRenaming dom stage -> UImportRenaming dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UImportRenaming dom stage -> m (UImportRenaming dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UImportRenaming dom stage -> UImportRenaming dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UImportRenaming dom stage -> m (UImportRenaming dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UImportRenaming dom stage -> UImportRenaming dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UImportRenaming dom stage -> m (UImportRenaming dom stage) #

(Domain dom, SourceInfo stage) => Data (UImportRenaming dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UImportRenaming dom stage -> c (UImportRenaming dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UImportRenaming dom stage) #

toConstr :: UImportRenaming dom stage -> Constr #

dataTypeOf :: UImportRenaming dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UImportRenaming dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UImportRenaming dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UImportRenaming dom stage -> UImportRenaming dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UImportRenaming dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UImportRenaming dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UImportRenaming dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UImportRenaming dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UImportRenaming dom stage -> m (UImportRenaming dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UImportRenaming dom stage -> m (UImportRenaming dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UImportRenaming dom stage -> m (UImportRenaming dom stage) #

Domain dom => Generic (UImportRenaming dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UImportRenaming dom stage) :: * -> * #

Methods

from :: UImportRenaming dom stage -> Rep (UImportRenaming dom stage) x #

to :: Rep (UImportRenaming dom stage) x -> UImportRenaming dom stage #

type Rep (UImportRenaming dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UImportRenaming dom stage) = D1 (MetaData "UImportRenaming" "Language.Haskell.Tools.AST.Representation.Modules" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UImportRenaming" PrefixI True) (S1 (MetaSel (Just "_importRename") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UModuleName dom stage))))
type IgnoredFields (UImportRenaming dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UImportRenaming dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UModuleName dom stage Source #

The name of a module

Constructors

UModuleName 
Instances
SourceInfoTraversal UModuleName Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UModuleName dom st1 -> f (UModuleName dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UModuleName dom st1 -> f (UModuleName dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UModuleName dom st1 -> f (UModuleName dom st2) Source #

SemanticTraversal UModuleName Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UModuleName dom1 st -> f (UModuleName dom2 st) Source #

GoodOperationFor c (UModuleName dom stage) => ClassyPlate c (UModuleName dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UModuleName dom stage -> UModuleName dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UModuleName dom stage -> m (UModuleName dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UModuleName dom stage -> UModuleName dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UModuleName dom stage -> m (UModuleName dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UModuleName dom stage -> UModuleName dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UModuleName dom stage -> m (UModuleName dom stage) #

(Domain dom, SourceInfo stage) => Data (UModuleName dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UModuleName dom stage -> c (UModuleName dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UModuleName dom stage) #

toConstr :: UModuleName dom stage -> Constr #

dataTypeOf :: UModuleName dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UModuleName dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UModuleName dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UModuleName dom stage -> UModuleName dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UModuleName dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UModuleName dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UModuleName dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UModuleName dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UModuleName dom stage -> m (UModuleName dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UModuleName dom stage -> m (UModuleName dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UModuleName dom stage -> m (UModuleName dom stage) #

Domain dom => Generic (UModuleName dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UModuleName dom stage) :: * -> * #

Methods

from :: UModuleName dom stage -> Rep (UModuleName dom stage) x #

to :: Rep (UModuleName dom stage) x -> UModuleName dom stage #

type Rep (UModuleName dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UModuleName dom stage) = D1 (MetaData "UModuleName" "Language.Haskell.Tools.AST.Representation.Modules" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UModuleName" PrefixI True) (S1 (MetaSel (Just "_moduleNameString") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)))
type IgnoredFields (UModuleName dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UModuleName dom stage) = (Right "_moduleNameString" :: Either (Symbol, Nat) Symbol) ': ([] :: [Either (Symbol, Nat) Symbol])

data TypeKeyword dom stage Source #

The type keyword used to qualify that the type and not the constructor of the same name is referred

Constructors

TypeKeyword 
Instances
SourceInfoTraversal TypeKeyword Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> TypeKeyword dom st1 -> f (TypeKeyword dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> TypeKeyword dom st1 -> f (TypeKeyword dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> TypeKeyword dom st1 -> f (TypeKeyword dom st2) Source #

SemanticTraversal TypeKeyword Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> TypeKeyword dom1 st -> f (TypeKeyword dom2 st) Source #

GoodOperationFor c (TypeKeyword dom stage) => ClassyPlate c (TypeKeyword dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> TypeKeyword dom stage -> TypeKeyword dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> TypeKeyword dom stage -> m (TypeKeyword dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> TypeKeyword dom stage -> TypeKeyword dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> TypeKeyword dom stage -> m (TypeKeyword dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> TypeKeyword dom stage -> TypeKeyword dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> TypeKeyword dom stage -> m (TypeKeyword dom stage) #

(Domain dom, SourceInfo stage) => Data (TypeKeyword dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TypeKeyword dom stage -> c (TypeKeyword dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (TypeKeyword dom stage) #

toConstr :: TypeKeyword dom stage -> Constr #

dataTypeOf :: TypeKeyword dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (TypeKeyword dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (TypeKeyword dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> TypeKeyword dom stage -> TypeKeyword dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TypeKeyword dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TypeKeyword dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> TypeKeyword dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> TypeKeyword dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TypeKeyword dom stage -> m (TypeKeyword dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeKeyword dom stage -> m (TypeKeyword dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeKeyword dom stage -> m (TypeKeyword dom stage) #

Domain dom => Generic (TypeKeyword dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (TypeKeyword dom stage) :: * -> * #

Methods

from :: TypeKeyword dom stage -> Rep (TypeKeyword dom stage) x #

to :: Rep (TypeKeyword dom stage) x -> TypeKeyword dom stage #

type Rep (TypeKeyword dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (TypeKeyword dom stage) = D1 (MetaData "TypeKeyword" "Language.Haskell.Tools.AST.Representation.Modules" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "TypeKeyword" PrefixI False) (U1 :: * -> *))
type IgnoredFields (TypeKeyword dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (TypeKeyword dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data USplice dom stage Source #

A template haskell splice

Constructors

UIdSplice

A simple name splice: $generateX

Fields

UParenSplice

A splice with parentheses: $(generate input)

Fields

Instances
SourceInfoTraversal USplice Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> USplice dom st1 -> f (USplice dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> USplice dom st1 -> f (USplice dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> USplice dom st1 -> f (USplice dom st2) Source #

SemanticTraversal USplice Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> USplice dom1 st -> f (USplice dom2 st) Source #

(GoodOperationFor c (USplice dom stage), ClassyPlate c (Ann UName dom stage), ClassyPlate c (Ann UExpr dom stage)) => ClassyPlate c (USplice dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> USplice dom stage -> USplice dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> USplice dom stage -> m (USplice dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> USplice dom stage -> USplice dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> USplice dom stage -> m (USplice dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> USplice dom stage -> USplice dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> USplice dom stage -> m (USplice dom stage) #

(Domain dom, SourceInfo stage) => Data (USplice dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> USplice dom stage -> c (USplice dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (USplice dom stage) #

toConstr :: USplice dom stage -> Constr #

dataTypeOf :: USplice dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (USplice dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (USplice dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> USplice dom stage -> USplice dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> USplice dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> USplice dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> USplice dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> USplice dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> USplice dom stage -> m (USplice dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> USplice dom stage -> m (USplice dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> USplice dom stage -> m (USplice dom stage) #

Domain dom => Generic (USplice dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (USplice dom stage) :: * -> * #

Methods

from :: USplice dom stage -> Rep (USplice dom stage) x #

to :: Rep (USplice dom stage) x -> USplice dom stage #

type Rep (USplice dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (USplice dom stage) = D1 (MetaData "USplice" "Language.Haskell.Tools.AST.Representation.TH" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UIdSplice" PrefixI True) (S1 (MetaSel (Just "_spliceId") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage))) :+: C1 (MetaCons "UParenSplice" PrefixI True) (S1 (MetaSel (Just "_spliceExpr") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage))))
type IgnoredFields (USplice dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (USplice dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UQuasiQuote dom stage Source #

Template haskell quasi-quotation: [quoter|str]

Constructors

UQuasiQuote 

Fields

Instances
SourceInfoTraversal UQuasiQuote Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UQuasiQuote dom st1 -> f (UQuasiQuote dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UQuasiQuote dom st1 -> f (UQuasiQuote dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UQuasiQuote dom st1 -> f (UQuasiQuote dom st2) Source #

SemanticTraversal UQuasiQuote Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UQuasiQuote dom1 st -> f (UQuasiQuote dom2 st) Source #

(GoodOperationFor c (UQuasiQuote dom stage), ClassyPlate c (Ann UName dom stage), ClassyPlate c (Ann QQString dom stage)) => ClassyPlate c (UQuasiQuote dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UQuasiQuote dom stage -> UQuasiQuote dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UQuasiQuote dom stage -> m (UQuasiQuote dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UQuasiQuote dom stage -> UQuasiQuote dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UQuasiQuote dom stage -> m (UQuasiQuote dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UQuasiQuote dom stage -> UQuasiQuote dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UQuasiQuote dom stage -> m (UQuasiQuote dom stage) #

(Domain dom, SourceInfo stage) => Data (UQuasiQuote dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UQuasiQuote dom stage -> c (UQuasiQuote dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UQuasiQuote dom stage) #

toConstr :: UQuasiQuote dom stage -> Constr #

dataTypeOf :: UQuasiQuote dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UQuasiQuote dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UQuasiQuote dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UQuasiQuote dom stage -> UQuasiQuote dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UQuasiQuote dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UQuasiQuote dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UQuasiQuote dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UQuasiQuote dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UQuasiQuote dom stage -> m (UQuasiQuote dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UQuasiQuote dom stage -> m (UQuasiQuote dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UQuasiQuote dom stage -> m (UQuasiQuote dom stage) #

Domain dom => Generic (UQuasiQuote dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UQuasiQuote dom stage) :: * -> * #

Methods

from :: UQuasiQuote dom stage -> Rep (UQuasiQuote dom stage) x #

to :: Rep (UQuasiQuote dom stage) x -> UQuasiQuote dom stage #

type Rep (UQuasiQuote dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UQuasiQuote dom stage) = D1 (MetaData "UQuasiQuote" "Language.Haskell.Tools.AST.Representation.TH" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UQuasiQuote" PrefixI True) (S1 (MetaSel (Just "_qqExprName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage)) :*: S1 (MetaSel (Just "_qqExprBody") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann QQString dom stage))))
type IgnoredFields (UQuasiQuote dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UQuasiQuote dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data QQString dom stage Source #

Template Haskell Quasi-quotation content

Constructors

QQString 

Fields

Instances
SourceInfoTraversal QQString Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> QQString dom st1 -> f (QQString dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> QQString dom st1 -> f (QQString dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> QQString dom st1 -> f (QQString dom st2) Source #

SemanticTraversal QQString Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> QQString dom1 st -> f (QQString dom2 st) Source #

GoodOperationFor c (QQString dom stage) => ClassyPlate c (QQString dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> QQString dom stage -> QQString dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> QQString dom stage -> m (QQString dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> QQString dom stage -> QQString dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> QQString dom stage -> m (QQString dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> QQString dom stage -> QQString dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> QQString dom stage -> m (QQString dom stage) #

(Domain dom, SourceInfo stage) => Data (QQString dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> QQString dom stage -> c (QQString dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (QQString dom stage) #

toConstr :: QQString dom stage -> Constr #

dataTypeOf :: QQString dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (QQString dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (QQString dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> QQString dom stage -> QQString dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> QQString dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> QQString dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> QQString dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> QQString dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> QQString dom stage -> m (QQString dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> QQString dom stage -> m (QQString dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> QQString dom stage -> m (QQString dom stage) #

Domain dom => Generic (QQString dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (QQString dom stage) :: * -> * #

Methods

from :: QQString dom stage -> Rep (QQString dom stage) x #

to :: Rep (QQString dom stage) x -> QQString dom stage #

type Rep (QQString dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (QQString dom stage) = D1 (MetaData "QQString" "Language.Haskell.Tools.AST.Representation.TH" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "QQString" PrefixI True) (S1 (MetaSel (Just "_qqString") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)))
type IgnoredFields (QQString dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (QQString dom stage) = (Right "_qqString" :: Either (Symbol, Nat) Symbol) ': ([] :: [Either (Symbol, Nat) Symbol])

data UBracket dom stage Source #

Template Haskell bracket expressions

Constructors

UExprBracket

Expression bracket ( [| x + y |] )

Fields

UPatternBracket

Pattern bracket ( [p| Point x y |] )

Fields

UTypeBracket

Type bracket ( [t| (Int,Int) |] )

Fields

UDeclsBracket

Declaration bracket ( [d| f :: Int -> Int; f x = x*x |] )

Fields

Instances
SourceInfoTraversal UBracket Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UBracket dom st1 -> f (UBracket dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UBracket dom st1 -> f (UBracket dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UBracket dom st1 -> f (UBracket dom st2) Source #

SemanticTraversal UBracket Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UBracket dom1 st -> f (UBracket dom2 st) Source #

(GoodOperationFor c (UBracket dom stage), ClassyPlate c (Ann UExpr dom stage), ClassyPlate c (Ann UPattern dom stage), ClassyPlate c (Ann UType dom stage), ClassyPlate c (AnnListG UDecl dom stage)) => ClassyPlate c (UBracket dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UBracket dom stage -> UBracket dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UBracket dom stage -> m (UBracket dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UBracket dom stage -> UBracket dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UBracket dom stage -> m (UBracket dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UBracket dom stage -> UBracket dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UBracket dom stage -> m (UBracket dom stage) #

(Domain dom, SourceInfo stage) => Data (UBracket dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UBracket dom stage -> c (UBracket dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UBracket dom stage) #

toConstr :: UBracket dom stage -> Constr #

dataTypeOf :: UBracket dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UBracket dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UBracket dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UBracket dom stage -> UBracket dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UBracket dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UBracket dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UBracket dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UBracket dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UBracket dom stage -> m (UBracket dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UBracket dom stage -> m (UBracket dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UBracket dom stage -> m (UBracket dom stage) #

Domain dom => Generic (UBracket dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UBracket dom stage) :: * -> * #

Methods

from :: UBracket dom stage -> Rep (UBracket dom stage) x #

to :: Rep (UBracket dom stage) x -> UBracket dom stage #

type Rep (UBracket dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UBracket dom stage) = D1 (MetaData "UBracket" "Language.Haskell.Tools.AST.Representation.TH" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) ((C1 (MetaCons "UExprBracket" PrefixI True) (S1 (MetaSel (Just "_bracketExpr") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage))) :+: C1 (MetaCons "UPatternBracket" PrefixI True) (S1 (MetaSel (Just "_bracketPattern") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UPattern dom stage)))) :+: (C1 (MetaCons "UTypeBracket" PrefixI True) (S1 (MetaSel (Just "_bracketType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UType dom stage))) :+: C1 (MetaCons "UDeclsBracket" PrefixI True) (S1 (MetaSel (Just "_bracketDecl") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UDecl dom stage)))))
type IgnoredFields (UBracket dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UBracket dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

Declarations

data UDecl dom stage Source #

Haskell declarationw

Constructors

UTypeDecl

A type synonym ( type String = [Char] )

Fields

UTypeFamilyDecl

A type family declaration ( type family F x )

Fields

UClosedTypeFamilyDecl

A closed type family declaration

Fields

UDataDecl

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

UGDataDecl

A GADT-style data or newtype declaration.

UTypeInstDecl

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

Fields

UDataInstDecl

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

UGDataInstDecl

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

UClassDecl

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

Fields

UInstDecl

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

UPatternSynonymDecl

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

Fields

UDerivDecl

Standalone deriving declaration ( deriving instance X T )

UFixityDecl

Fixity declaration ( infixl 5 +, - )

Fields

UDefaultDecl

Default types ( default (T1, T2) )

Fields

UTypeSigDecl

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

Fields

UPatTypeSigDecl

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

UValueBinding

Function or value binding ( f x = 12 )

Fields

UForeignImport

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

Fields

UForeignExport

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

Fields

UPragmaDecl

Top-level pragmas

Fields

URoleDecl

Role annotations ( type role Ptr representational )

Fields

USpliceDecl

A Template Haskell splice declaration ( $(generateDecls) )

Fields

Instances
SourceInfoTraversal UDecl Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UDecl dom st1 -> f (UDecl dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UDecl dom st1 -> f (UDecl dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UDecl dom st1 -> f (UDecl dom st2) Source #

SemanticTraversal UDecl Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UDecl dom1 st -> f (UDecl dom2 st) Source #

NamedElement UDecl Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Helpers

Methods

elementName :: (RefMonads w r, MonadPlus r, Morph Maybe r, Morph [] r) => Reference w r MU MU (Ann UDecl dom st) (Ann UDecl dom st) (Ann UQualifiedName dom st) (Ann UQualifiedName dom st) Source #

(GoodOperationFor c (UDecl dom stage), ClassyPlate c (Ann UDeclHead dom stage), ClassyPlate c (Ann UType dom stage), ClassyPlate c (Ann UTypeFamily dom stage), ClassyPlate c (Ann UDeclHead dom stage), ClassyPlate c (AnnMaybeG UTypeFamilySpec dom stage), ClassyPlate c (AnnListG UTypeEqn dom stage), ClassyPlate c (Ann UDataOrNewtypeKeyword dom stage), ClassyPlate c (AnnMaybeG UContext dom stage), ClassyPlate c (Ann UDeclHead dom stage), ClassyPlate c (AnnListG UConDecl dom stage), ClassyPlate c (AnnListG UDeriving dom stage), ClassyPlate c (Ann UDataOrNewtypeKeyword dom stage), ClassyPlate c (AnnMaybeG UContext dom stage), ClassyPlate c (Ann UDeclHead dom stage), ClassyPlate c (AnnMaybeG UKindConstraint dom stage), ClassyPlate c (AnnListG UGadtConDecl dom stage), ClassyPlate c (AnnListG UDeriving dom stage), ClassyPlate c (Ann UInstanceRule dom stage), ClassyPlate c (Ann UType dom stage), ClassyPlate c (Ann UDataOrNewtypeKeyword dom stage), ClassyPlate c (Ann UInstanceRule dom stage), ClassyPlate c (AnnListG UConDecl dom stage), ClassyPlate c (AnnListG UDeriving dom stage), ClassyPlate c (Ann UDataOrNewtypeKeyword dom stage), ClassyPlate c (Ann UInstanceRule dom stage), ClassyPlate c (AnnMaybeG UKindConstraint dom stage), ClassyPlate c (AnnListG UGadtConDecl dom stage), ClassyPlate c (AnnMaybeG UContext dom stage), ClassyPlate c (Ann UDeclHead dom stage), ClassyPlate c (AnnMaybeG UFunDeps dom stage), ClassyPlate c (AnnMaybeG UClassBody dom stage), ClassyPlate c (AnnMaybeG UOverlapPragma dom stage), ClassyPlate c (Ann UInstanceRule dom stage), ClassyPlate c (AnnMaybeG UInstBody dom stage), ClassyPlate c (Ann UPatternSynonym dom stage), ClassyPlate c (AnnMaybeG UDeriveStrategy dom stage), ClassyPlate c (AnnMaybeG UOverlapPragma dom stage), ClassyPlate c (Ann UInstanceRule dom stage), ClassyPlate c (Ann UFixitySignature dom stage), ClassyPlate c (AnnListG UType dom stage), ClassyPlate c (Ann UTypeSignature dom stage), ClassyPlate c (Ann UPatternTypeSignature dom stage), ClassyPlate c (Ann UValueBind dom stage), ClassyPlate c (Ann UCallConv dom stage), ClassyPlate c (AnnMaybeG USafety dom stage), ClassyPlate c (Ann UName dom stage), ClassyPlate c (Ann UType dom stage), ClassyPlate c (Ann UCallConv dom stage), ClassyPlate c (Ann UName dom stage), ClassyPlate c (Ann UType dom stage), ClassyPlate c (Ann UTopLevelPragma dom stage), ClassyPlate c (Ann UQualifiedName dom stage), ClassyPlate c (AnnListG URole dom stage), ClassyPlate c (Ann USplice dom stage)) => ClassyPlate c (UDecl dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UDecl dom stage -> UDecl dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UDecl dom stage -> m (UDecl dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UDecl dom stage -> UDecl dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UDecl dom stage -> m (UDecl dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UDecl dom stage -> UDecl dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UDecl dom stage -> m (UDecl dom stage) #

(Domain dom, SourceInfo stage) => Data (UDecl dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UDecl dom stage -> c (UDecl dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UDecl dom stage) #

toConstr :: UDecl dom stage -> Constr #

dataTypeOf :: UDecl dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UDecl dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UDecl dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UDecl dom stage -> UDecl dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UDecl dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UDecl dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UDecl dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UDecl dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UDecl dom stage -> m (UDecl dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UDecl dom stage -> m (UDecl dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UDecl dom stage -> m (UDecl dom stage) #

Domain dom => Generic (UDecl dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UDecl dom stage) :: * -> * #

Methods

from :: UDecl dom stage -> Rep (UDecl dom stage) x #

to :: Rep (UDecl dom stage) x -> UDecl dom stage #

type Rep (UDecl dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UDecl dom stage) = D1 (MetaData "UDecl" "Language.Haskell.Tools.AST.Representation.Decls" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) ((((C1 (MetaCons "UTypeDecl" PrefixI True) (S1 (MetaSel (Just "_declHead") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UDeclHead dom stage)) :*: S1 (MetaSel (Just "_declType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UType dom stage))) :+: C1 (MetaCons "UTypeFamilyDecl" PrefixI True) (S1 (MetaSel (Just "_declTypeFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UTypeFamily dom stage)))) :+: (C1 (MetaCons "UClosedTypeFamilyDecl" PrefixI True) (S1 (MetaSel (Just "_declHead") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UDeclHead dom stage)) :*: (S1 (MetaSel (Just "_declSpec") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UTypeFamilySpec dom stage)) :*: S1 (MetaSel (Just "_declDecl") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UTypeEqn dom stage)))) :+: (C1 (MetaCons "UDataDecl" PrefixI True) ((S1 (MetaSel (Just "_declNewtype") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UDataOrNewtypeKeyword dom stage)) :*: S1 (MetaSel (Just "_declCtx") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UContext dom stage))) :*: (S1 (MetaSel (Just "_declHead") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UDeclHead dom stage)) :*: (S1 (MetaSel (Just "_declCons") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UConDecl dom stage)) :*: S1 (MetaSel (Just "_declDeriving") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UDeriving dom stage))))) :+: C1 (MetaCons "UGDataDecl" PrefixI True) ((S1 (MetaSel (Just "_declNewtype") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UDataOrNewtypeKeyword dom stage)) :*: (S1 (MetaSel (Just "_declCtx") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UContext dom stage)) :*: S1 (MetaSel (Just "_declHead") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UDeclHead dom stage)))) :*: (S1 (MetaSel (Just "_declKind") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UKindConstraint dom stage)) :*: (S1 (MetaSel (Just "_declGadt") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UGadtConDecl dom stage)) :*: S1 (MetaSel (Just "_declDeriving") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UDeriving dom stage)))))))) :+: ((C1 (MetaCons "UTypeInstDecl" PrefixI True) (S1 (MetaSel (Just "_declInstance") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UInstanceRule dom stage)) :*: S1 (MetaSel (Just "_declAssignedType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UType dom stage))) :+: (C1 (MetaCons "UDataInstDecl" PrefixI True) ((S1 (MetaSel (Just "_declNewtype") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UDataOrNewtypeKeyword dom stage)) :*: S1 (MetaSel (Just "_declInstance") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UInstanceRule dom stage))) :*: (S1 (MetaSel (Just "_declCons") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UConDecl dom stage)) :*: S1 (MetaSel (Just "_declDeriving") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UDeriving dom stage)))) :+: C1 (MetaCons "UGDataInstDecl" PrefixI True) ((S1 (MetaSel (Just "_declNewtype") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UDataOrNewtypeKeyword dom stage)) :*: S1 (MetaSel (Just "_declInstance") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UInstanceRule dom stage))) :*: (S1 (MetaSel (Just "_declKind") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UKindConstraint dom stage)) :*: S1 (MetaSel (Just "_declGadt") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UGadtConDecl dom stage)))))) :+: (C1 (MetaCons "UClassDecl" PrefixI True) ((S1 (MetaSel (Just "_declCtx") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UContext dom stage)) :*: S1 (MetaSel (Just "_declHead") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UDeclHead dom stage))) :*: (S1 (MetaSel (Just "_declFunDeps") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UFunDeps dom stage)) :*: S1 (MetaSel (Just "_declBody") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UClassBody dom stage)))) :+: (C1 (MetaCons "UInstDecl" PrefixI True) (S1 (MetaSel (Just "_declOverlap") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UOverlapPragma dom stage)) :*: (S1 (MetaSel (Just "_declInstRule") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UInstanceRule dom stage)) :*: S1 (MetaSel (Just "_declInstDecl") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UInstBody dom stage)))) :+: C1 (MetaCons "UPatternSynonymDecl" PrefixI True) (S1 (MetaSel (Just "_declPatSyn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UPatternSynonym dom stage))))))) :+: (((C1 (MetaCons "UDerivDecl" PrefixI True) (S1 (MetaSel (Just "_declDerivStrat") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UDeriveStrategy dom stage)) :*: (S1 (MetaSel (Just "_declOverlap") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UOverlapPragma dom stage)) :*: S1 (MetaSel (Just "_declInstRule") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UInstanceRule dom stage)))) :+: C1 (MetaCons "UFixityDecl" PrefixI True) (S1 (MetaSel (Just "_declFixity") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UFixitySignature dom stage)))) :+: (C1 (MetaCons "UDefaultDecl" PrefixI True) (S1 (MetaSel (Just "_declTypes") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UType dom stage))) :+: (C1 (MetaCons "UTypeSigDecl" PrefixI True) (S1 (MetaSel (Just "_declTypeSig") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UTypeSignature dom stage))) :+: C1 (MetaCons "UPatTypeSigDecl" PrefixI True) (S1 (MetaSel (Just "_declPatTypeSig") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UPatternTypeSignature dom stage)))))) :+: ((C1 (MetaCons "UValueBinding" PrefixI True) (S1 (MetaSel (Just "_declValBind") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UValueBind dom stage))) :+: (C1 (MetaCons "UForeignImport" PrefixI True) ((S1 (MetaSel (Just "_declCallConv") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UCallConv dom stage)) :*: S1 (MetaSel (Just "_declSafety") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG USafety dom stage))) :*: (S1 (MetaSel (Just "_declName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage)) :*: S1 (MetaSel (Just "_declForeignType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UType dom stage)))) :+: C1 (MetaCons "UForeignExport" PrefixI True) (S1 (MetaSel (Just "_declCallConv") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UCallConv dom stage)) :*: (S1 (MetaSel (Just "_declName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage)) :*: S1 (MetaSel (Just "_declForeignType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UType dom stage)))))) :+: (C1 (MetaCons "UPragmaDecl" PrefixI True) (S1 (MetaSel (Just "_declPragma") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UTopLevelPragma dom stage))) :+: (C1 (MetaCons "URoleDecl" PrefixI True) (S1 (MetaSel (Just "_declRoleType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UQualifiedName dom stage)) :*: S1 (MetaSel (Just "_declRoles") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG URole dom stage))) :+: C1 (MetaCons "USpliceDecl" PrefixI True) (S1 (MetaSel (Just "_declSplice") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann USplice dom stage))))))))
type IgnoredFields (UDecl dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UDecl dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UDeclHead dom stage Source #

Constructors

UDeclHead

Type or class name

Fields

UDHParen

Parenthesized type

Fields

UDHApp

Type application

Fields

UDHInfix

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

Fields

Instances
SourceInfoTraversal UDeclHead Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UDeclHead dom st1 -> f (UDeclHead dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UDeclHead dom st1 -> f (UDeclHead dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UDeclHead dom st1 -> f (UDeclHead dom st2) Source #

SemanticTraversal UDeclHead Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UDeclHead dom1 st -> f (UDeclHead dom2 st) Source #

(GoodOperationFor c (UDeclHead dom stage), ClassyPlate c (Ann UName dom stage), ClassyPlate c (Ann UDeclHead dom stage), ClassyPlate c (Ann UDeclHead dom stage), ClassyPlate c (Ann UTyVar dom stage), ClassyPlate c (Ann UTyVar dom stage), ClassyPlate c (Ann UOperator dom stage), ClassyPlate c (Ann UTyVar dom stage)) => ClassyPlate c (UDeclHead dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UDeclHead dom stage -> UDeclHead dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UDeclHead dom stage -> m (UDeclHead dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UDeclHead dom stage -> UDeclHead dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UDeclHead dom stage -> m (UDeclHead dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UDeclHead dom stage -> UDeclHead dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UDeclHead dom stage -> m (UDeclHead dom stage) #

(Domain dom, SourceInfo stage) => Data (UDeclHead dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UDeclHead dom stage -> c (UDeclHead dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UDeclHead dom stage) #

toConstr :: UDeclHead dom stage -> Constr #

dataTypeOf :: UDeclHead dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UDeclHead dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UDeclHead dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UDeclHead dom stage -> UDeclHead dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UDeclHead dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UDeclHead dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UDeclHead dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UDeclHead dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UDeclHead dom stage -> m (UDeclHead dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UDeclHead dom stage -> m (UDeclHead dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UDeclHead dom stage -> m (UDeclHead dom stage) #

Domain dom => Generic (UDeclHead dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UDeclHead dom stage) :: * -> * #

Methods

from :: UDeclHead dom stage -> Rep (UDeclHead dom stage) x #

to :: Rep (UDeclHead dom stage) x -> UDeclHead dom stage #

type Rep (UDeclHead dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UDeclHead dom stage) = D1 (MetaData "UDeclHead" "Language.Haskell.Tools.AST.Representation.Decls" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) ((C1 (MetaCons "UDeclHead" PrefixI True) (S1 (MetaSel (Just "_dhName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage))) :+: C1 (MetaCons "UDHParen" PrefixI True) (S1 (MetaSel (Just "_dhBody") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UDeclHead dom stage)))) :+: (C1 (MetaCons "UDHApp" PrefixI True) (S1 (MetaSel (Just "_dhAppFun") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UDeclHead dom stage)) :*: S1 (MetaSel (Just "_dhAppOperand") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UTyVar dom stage))) :+: C1 (MetaCons "UDHInfix" PrefixI True) (S1 (MetaSel (Just "_dhLeft") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UTyVar dom stage)) :*: (S1 (MetaSel (Just "_dhOperator") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UOperator dom stage)) :*: S1 (MetaSel (Just "_dhRight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UTyVar dom stage))))))
type IgnoredFields (UDeclHead dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UDeclHead dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

Type class definitions

data UClassBody dom stage Source #

The list of declarations that can appear in a typeclass

Constructors

UClassBody 

Fields

Instances
SourceInfoTraversal UClassBody Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UClassBody dom st1 -> f (UClassBody dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UClassBody dom st1 -> f (UClassBody dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UClassBody dom st1 -> f (UClassBody dom st2) Source #

SemanticTraversal UClassBody Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UClassBody dom1 st -> f (UClassBody dom2 st) Source #

(GoodOperationFor c (UClassBody dom stage), ClassyPlate c (AnnListG UClassElement dom stage)) => ClassyPlate c (UClassBody dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UClassBody dom stage -> UClassBody dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UClassBody dom stage -> m (UClassBody dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UClassBody dom stage -> UClassBody dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UClassBody dom stage -> m (UClassBody dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UClassBody dom stage -> UClassBody dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UClassBody dom stage -> m (UClassBody dom stage) #

(Domain dom, SourceInfo stage) => Data (UClassBody dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UClassBody dom stage -> c (UClassBody dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UClassBody dom stage) #

toConstr :: UClassBody dom stage -> Constr #

dataTypeOf :: UClassBody dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UClassBody dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UClassBody dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UClassBody dom stage -> UClassBody dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UClassBody dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UClassBody dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UClassBody dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UClassBody dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UClassBody dom stage -> m (UClassBody dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UClassBody dom stage -> m (UClassBody dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UClassBody dom stage -> m (UClassBody dom stage) #

Domain dom => Generic (UClassBody dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UClassBody dom stage) :: * -> * #

Methods

from :: UClassBody dom stage -> Rep (UClassBody dom stage) x #

to :: Rep (UClassBody dom stage) x -> UClassBody dom stage #

type Rep (UClassBody dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UClassBody dom stage) = D1 (MetaData "UClassBody" "Language.Haskell.Tools.AST.Representation.Decls" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UClassBody" PrefixI True) (S1 (MetaSel (Just "_cbElements") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UClassElement dom stage))))
type IgnoredFields (UClassBody dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UClassBody dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UClassElement dom stage Source #

Members of a class declaration

Constructors

UClsSig

Signature: f :: A -> B

Fields

UClsFixity

Fixity signature in class: infixl 1 >>-

Fields

UClsDef

Default binding: f x = "aaa"

Fields

UClsTypeFam

Declaration of an associated type synonym: type T x :: *

Fields

UClsTypeDef

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

Fields

UClsDefSig

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

Fields

UClsMinimal

Minimal pragma: {--}

Fields

UClsInline

Inline-like pragma in class definition not supported yet (GHC 8.0.1) | UClsPatSig { _cePatSig :: Ann UPatternTypeSignature dom stage } -- ^ Pattern signature in a class declaration (by using PatternSynonyms)

Fields

Instances
SourceInfoTraversal UClassElement Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UClassElement dom st1 -> f (UClassElement dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UClassElement dom st1 -> f (UClassElement dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UClassElement dom st1 -> f (UClassElement dom st2) Source #

SemanticTraversal UClassElement Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UClassElement dom1 st -> f (UClassElement dom2 st) Source #

(GoodOperationFor c (UClassElement dom stage), ClassyPlate c (Ann UTypeSignature dom stage), ClassyPlate c (Ann UFixitySignature dom stage), ClassyPlate c (Ann UValueBind dom stage), ClassyPlate c (Ann UTypeFamily dom stage), ClassyPlate c (Ann UDeclHead dom stage), ClassyPlate c (Ann UType dom stage), ClassyPlate c (Ann UName dom stage), ClassyPlate c (Ann UType dom stage), ClassyPlate c (Ann UMinimalFormula dom stage), ClassyPlate c (Ann UInlinePragma dom stage)) => ClassyPlate c (UClassElement dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UClassElement dom stage -> UClassElement dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UClassElement dom stage -> m (UClassElement dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UClassElement dom stage -> UClassElement dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UClassElement dom stage -> m (UClassElement dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UClassElement dom stage -> UClassElement dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UClassElement dom stage -> m (UClassElement dom stage) #

(Domain dom, SourceInfo stage) => Data (UClassElement dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UClassElement dom stage -> c (UClassElement dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UClassElement dom stage) #

toConstr :: UClassElement dom stage -> Constr #

dataTypeOf :: UClassElement dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UClassElement dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UClassElement dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UClassElement dom stage -> UClassElement dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UClassElement dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UClassElement dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UClassElement dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UClassElement dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UClassElement dom stage -> m (UClassElement dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UClassElement dom stage -> m (UClassElement dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UClassElement dom stage -> m (UClassElement dom stage) #

Domain dom => Generic (UClassElement dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UClassElement dom stage) :: * -> * #

Methods

from :: UClassElement dom stage -> Rep (UClassElement dom stage) x #

to :: Rep (UClassElement dom stage) x -> UClassElement dom stage #

type Rep (UClassElement dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UClassElement dom stage) = D1 (MetaData "UClassElement" "Language.Haskell.Tools.AST.Representation.Decls" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (((C1 (MetaCons "UClsSig" PrefixI True) (S1 (MetaSel (Just "_ceTypeSig") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UTypeSignature dom stage))) :+: C1 (MetaCons "UClsFixity" PrefixI True) (S1 (MetaSel (Just "_clsFixity") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UFixitySignature dom stage)))) :+: (C1 (MetaCons "UClsDef" PrefixI True) (S1 (MetaSel (Just "_ceBind") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UValueBind dom stage))) :+: C1 (MetaCons "UClsTypeFam" PrefixI True) (S1 (MetaSel (Just "_ceTypeFam") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UTypeFamily dom stage))))) :+: ((C1 (MetaCons "UClsTypeDef" PrefixI True) (S1 (MetaSel (Just "_ceHead") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UDeclHead dom stage)) :*: S1 (MetaSel (Just "_ceKind") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UType dom stage))) :+: C1 (MetaCons "UClsDefSig" PrefixI True) (S1 (MetaSel (Just "_ceName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage)) :*: S1 (MetaSel (Just "_ceType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UType dom stage)))) :+: (C1 (MetaCons "UClsMinimal" PrefixI True) (S1 (MetaSel (Just "_pragmaFormula") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UMinimalFormula dom stage))) :+: C1 (MetaCons "UClsInline" PrefixI True) (S1 (MetaSel (Just "_clsInline") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UInlinePragma dom stage))))))
type IgnoredFields (UClassElement dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UClassElement dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

Type class instances

data UInstanceRule dom stage Source #

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

Constructors

UInstanceRule

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

Fields

Instances
SourceInfoTraversal UInstanceRule Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UInstanceRule dom st1 -> f (UInstanceRule dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UInstanceRule dom st1 -> f (UInstanceRule dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UInstanceRule dom st1 -> f (UInstanceRule dom st2) Source #

SemanticTraversal UInstanceRule Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UInstanceRule dom1 st -> f (UInstanceRule dom2 st) Source #

(GoodOperationFor c (UInstanceRule dom stage), ClassyPlate c (AnnMaybeG (AnnListG UTyVar) dom stage), ClassyPlate c (AnnMaybeG UContext dom stage), ClassyPlate c (Ann UInstanceHead dom stage)) => ClassyPlate c (UInstanceRule dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UInstanceRule dom stage -> UInstanceRule dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UInstanceRule dom stage -> m (UInstanceRule dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UInstanceRule dom stage -> UInstanceRule dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UInstanceRule dom stage -> m (UInstanceRule dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UInstanceRule dom stage -> UInstanceRule dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UInstanceRule dom stage -> m (UInstanceRule dom stage) #

(Domain dom, SourceInfo stage) => Data (UInstanceRule dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UInstanceRule dom stage -> c (UInstanceRule dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UInstanceRule dom stage) #

toConstr :: UInstanceRule dom stage -> Constr #

dataTypeOf :: UInstanceRule dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UInstanceRule dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UInstanceRule dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UInstanceRule dom stage -> UInstanceRule dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UInstanceRule dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UInstanceRule dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UInstanceRule dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UInstanceRule dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UInstanceRule dom stage -> m (UInstanceRule dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UInstanceRule dom stage -> m (UInstanceRule dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UInstanceRule dom stage -> m (UInstanceRule dom stage) #

Domain dom => Generic (UInstanceRule dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UInstanceRule dom stage) :: * -> * #

Methods

from :: UInstanceRule dom stage -> Rep (UInstanceRule dom stage) x #

to :: Rep (UInstanceRule dom stage) x -> UInstanceRule dom stage #

type Rep (UInstanceRule dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UInstanceRule dom stage) = D1 (MetaData "UInstanceRule" "Language.Haskell.Tools.AST.Representation.Decls" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UInstanceRule" PrefixI True) (S1 (MetaSel (Just "_irVars") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG (AnnListG UTyVar) dom stage)) :*: (S1 (MetaSel (Just "_irCtx") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UContext dom stage)) :*: S1 (MetaSel (Just "_irHead") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UInstanceHead dom stage)))))
type IgnoredFields (UInstanceRule dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UInstanceRule dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UInstanceHead dom stage Source #

The specification of the class instance declaration

Constructors

UInstanceHeadCon

Type or class name

Fields

UInstanceHeadInfix

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

Fields

UInstanceHeadParen

Parenthesized instance head

Fields

UInstanceHeadApp

Application to one more type

Fields

Instances
SourceInfoTraversal UInstanceHead Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UInstanceHead dom st1 -> f (UInstanceHead dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UInstanceHead dom st1 -> f (UInstanceHead dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UInstanceHead dom st1 -> f (UInstanceHead dom st2) Source #

SemanticTraversal UInstanceHead Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UInstanceHead dom1 st -> f (UInstanceHead dom2 st) Source #

(GoodOperationFor c (UInstanceHead dom stage), ClassyPlate c (Ann UName dom stage), ClassyPlate c (Ann UType dom stage), ClassyPlate c (Ann UOperator dom stage), ClassyPlate c (Ann UInstanceHead dom stage), ClassyPlate c (Ann UInstanceHead dom stage), ClassyPlate c (Ann UType dom stage)) => ClassyPlate c (UInstanceHead dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UInstanceHead dom stage -> UInstanceHead dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UInstanceHead dom stage -> m (UInstanceHead dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UInstanceHead dom stage -> UInstanceHead dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UInstanceHead dom stage -> m (UInstanceHead dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UInstanceHead dom stage -> UInstanceHead dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UInstanceHead dom stage -> m (UInstanceHead dom stage) #

(Domain dom, SourceInfo stage) => Data (UInstanceHead dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UInstanceHead dom stage -> c (UInstanceHead dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UInstanceHead dom stage) #

toConstr :: UInstanceHead dom stage -> Constr #

dataTypeOf :: UInstanceHead dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UInstanceHead dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UInstanceHead dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UInstanceHead dom stage -> UInstanceHead dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UInstanceHead dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UInstanceHead dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UInstanceHead dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UInstanceHead dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UInstanceHead dom stage -> m (UInstanceHead dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UInstanceHead dom stage -> m (UInstanceHead dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UInstanceHead dom stage -> m (UInstanceHead dom stage) #

Domain dom => Generic (UInstanceHead dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UInstanceHead dom stage) :: * -> * #

Methods

from :: UInstanceHead dom stage -> Rep (UInstanceHead dom stage) x #

to :: Rep (UInstanceHead dom stage) x -> UInstanceHead dom stage #

type Rep (UInstanceHead dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UInstanceHead dom stage) = D1 (MetaData "UInstanceHead" "Language.Haskell.Tools.AST.Representation.Decls" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) ((C1 (MetaCons "UInstanceHeadCon" PrefixI True) (S1 (MetaSel (Just "_ihConName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage))) :+: C1 (MetaCons "UInstanceHeadInfix" PrefixI True) (S1 (MetaSel (Just "_ihLeftOp") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UType dom stage)) :*: S1 (MetaSel (Just "_ihOperator") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UOperator dom stage)))) :+: (C1 (MetaCons "UInstanceHeadParen" PrefixI True) (S1 (MetaSel (Just "_ihHead") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UInstanceHead dom stage))) :+: C1 (MetaCons "UInstanceHeadApp" PrefixI True) (S1 (MetaSel (Just "_ihFun") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UInstanceHead dom stage)) :*: S1 (MetaSel (Just "_ihType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UType dom stage)))))
type IgnoredFields (UInstanceHead dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UInstanceHead dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UInstBody dom stage Source #

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

Constructors

UInstBody 
Instances
SourceInfoTraversal UInstBody Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UInstBody dom st1 -> f (UInstBody dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UInstBody dom st1 -> f (UInstBody dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UInstBody dom st1 -> f (UInstBody dom st2) Source #

SemanticTraversal UInstBody Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UInstBody dom1 st -> f (UInstBody dom2 st) Source #

(GoodOperationFor c (UInstBody dom stage), ClassyPlate c (AnnListG UInstBodyDecl dom stage)) => ClassyPlate c (UInstBody dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UInstBody dom stage -> UInstBody dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UInstBody dom stage -> m (UInstBody dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UInstBody dom stage -> UInstBody dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UInstBody dom stage -> m (UInstBody dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UInstBody dom stage -> UInstBody dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UInstBody dom stage -> m (UInstBody dom stage) #

(Domain dom, SourceInfo stage) => Data (UInstBody dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UInstBody dom stage -> c (UInstBody dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UInstBody dom stage) #

toConstr :: UInstBody dom stage -> Constr #

dataTypeOf :: UInstBody dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UInstBody dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UInstBody dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UInstBody dom stage -> UInstBody dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UInstBody dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UInstBody dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UInstBody dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UInstBody dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UInstBody dom stage -> m (UInstBody dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UInstBody dom stage -> m (UInstBody dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UInstBody dom stage -> m (UInstBody dom stage) #

Domain dom => Generic (UInstBody dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UInstBody dom stage) :: * -> * #

Methods

from :: UInstBody dom stage -> Rep (UInstBody dom stage) x #

to :: Rep (UInstBody dom stage) x -> UInstBody dom stage #

type Rep (UInstBody dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UInstBody dom stage) = D1 (MetaData "UInstBody" "Language.Haskell.Tools.AST.Representation.Decls" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UInstBody" PrefixI True) (S1 (MetaSel (Just "_instBodyDecls") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UInstBodyDecl dom stage))))
type IgnoredFields (UInstBody dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UInstBody dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UInstBodyDecl dom stage Source #

Declarations inside an instance declaration.

Constructors

UInstBodyNormalDecl

A normal value binding ( f x = 12 )

Fields

UInstBodyTypeSig

Type signature in instance definition with InstanceSigs

Fields

UInstBodyTypeDecl

An associated type definition ( type A X = B )

Fields

UInstBodyDataDecl

An associated data type implementation ( data A X = C1 | C2 )

UInstBodyGadtDataDecl

An associated data type implemented using GADT style

USpecializeInstance

Specialize instance pragma (no phase selection is allowed)

Fields

UInlineInstance

Inline-like pragma in a class instance

Fields

UInstanceSpecialize

Specialize pragma not supported yet | UInstBodyPatSyn { _instBodyPatSyn :: Ann UPatternSynonym dom stage } -- ^ A pattern synonym in a class instance

Instances
SourceInfoTraversal UInstBodyDecl Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UInstBodyDecl dom st1 -> f (UInstBodyDecl dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UInstBodyDecl dom st1 -> f (UInstBodyDecl dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UInstBodyDecl dom st1 -> f (UInstBodyDecl dom st2) Source #

SemanticTraversal UInstBodyDecl Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UInstBodyDecl dom1 st -> f (UInstBodyDecl dom2 st) Source #

(GoodOperationFor c (UInstBodyDecl dom stage), ClassyPlate c (Ann UValueBind dom stage), ClassyPlate c (Ann UTypeSignature dom stage), ClassyPlate c (Ann UTypeEqn dom stage), ClassyPlate c (Ann UDataOrNewtypeKeyword dom stage), ClassyPlate c (Ann UInstanceRule dom stage), ClassyPlate c (AnnListG UConDecl dom stage), ClassyPlate c (AnnListG UDeriving dom stage), ClassyPlate c (Ann UDataOrNewtypeKeyword dom stage), ClassyPlate c (Ann UInstanceRule dom stage), ClassyPlate c (AnnMaybeG UKindConstraint dom stage), ClassyPlate c (AnnListG UGadtConDecl dom stage), ClassyPlate c (AnnListG UDeriving dom stage), ClassyPlate c (Ann UType dom stage), ClassyPlate c (Ann UInlinePragma dom stage), ClassyPlate c (Ann USpecializePragma dom stage)) => ClassyPlate c (UInstBodyDecl dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UInstBodyDecl dom stage -> UInstBodyDecl dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UInstBodyDecl dom stage -> m (UInstBodyDecl dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UInstBodyDecl dom stage -> UInstBodyDecl dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UInstBodyDecl dom stage -> m (UInstBodyDecl dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UInstBodyDecl dom stage -> UInstBodyDecl dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UInstBodyDecl dom stage -> m (UInstBodyDecl dom stage) #

(Domain dom, SourceInfo stage) => Data (UInstBodyDecl dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UInstBodyDecl dom stage -> c (UInstBodyDecl dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UInstBodyDecl dom stage) #

toConstr :: UInstBodyDecl dom stage -> Constr #

dataTypeOf :: UInstBodyDecl dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UInstBodyDecl dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UInstBodyDecl dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UInstBodyDecl dom stage -> UInstBodyDecl dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UInstBodyDecl dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UInstBodyDecl dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UInstBodyDecl dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UInstBodyDecl dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UInstBodyDecl dom stage -> m (UInstBodyDecl dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UInstBodyDecl dom stage -> m (UInstBodyDecl dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UInstBodyDecl dom stage -> m (UInstBodyDecl dom stage) #

Domain dom => Generic (UInstBodyDecl dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UInstBodyDecl dom stage) :: * -> * #

Methods

from :: UInstBodyDecl dom stage -> Rep (UInstBodyDecl dom stage) x #

to :: Rep (UInstBodyDecl dom stage) x -> UInstBodyDecl dom stage #

type Rep (UInstBodyDecl dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UInstBodyDecl dom stage) = D1 (MetaData "UInstBodyDecl" "Language.Haskell.Tools.AST.Representation.Decls" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (((C1 (MetaCons "UInstBodyNormalDecl" PrefixI True) (S1 (MetaSel (Just "_instBodyDeclFunbind") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UValueBind dom stage))) :+: C1 (MetaCons "UInstBodyTypeSig" PrefixI True) (S1 (MetaSel (Just "_instBodyTypeSig") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UTypeSignature dom stage)))) :+: (C1 (MetaCons "UInstBodyTypeDecl" PrefixI True) (S1 (MetaSel (Just "_instBodyTypeEqn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UTypeEqn dom stage))) :+: C1 (MetaCons "UInstBodyDataDecl" PrefixI True) ((S1 (MetaSel (Just "_instBodyDataNew") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UDataOrNewtypeKeyword dom stage)) :*: S1 (MetaSel (Just "_instBodyLhsType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UInstanceRule dom stage))) :*: (S1 (MetaSel (Just "_instBodyDataCons") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UConDecl dom stage)) :*: S1 (MetaSel (Just "_instBodyDerivings") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UDeriving dom stage)))))) :+: ((C1 (MetaCons "UInstBodyGadtDataDecl" PrefixI True) ((S1 (MetaSel (Just "_instBodyDataNew") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UDataOrNewtypeKeyword dom stage)) :*: S1 (MetaSel (Just "_instBodyLhsType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UInstanceRule dom stage))) :*: (S1 (MetaSel (Just "_instBodyDataKind") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UKindConstraint dom stage)) :*: (S1 (MetaSel (Just "_instBodyGadtCons") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UGadtConDecl dom stage)) :*: S1 (MetaSel (Just "_instBodyDerivings") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UDeriving dom stage))))) :+: C1 (MetaCons "USpecializeInstance" PrefixI True) (S1 (MetaSel (Just "_specializeInstanceType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UType dom stage)))) :+: (C1 (MetaCons "UInlineInstance" PrefixI True) (S1 (MetaSel (Just "_instanceInline") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UInlinePragma dom stage))) :+: C1 (MetaCons "UInstanceSpecialize" PrefixI True) (S1 (MetaSel (Just "_specializeInstance") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann USpecializePragma dom stage))))))
type IgnoredFields (UInstBodyDecl dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UInstBodyDecl dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UOverlapPragma dom stage Source #

Overlap pragmas. Can be applied to class declarations and class instance declarations.

Constructors

UEnableOverlap

OVERLAP pragma

UDisableOverlap

NO_OVERLAP pragma

UOverlappable

OVERLAPPABLE pragma

UOverlapping

OVERLAPPING pragma

UOverlaps

OVERLAPS pragma

UIncoherentOverlap

INCOHERENT pragma

Instances
SourceInfoTraversal UOverlapPragma Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UOverlapPragma dom st1 -> f (UOverlapPragma dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UOverlapPragma dom st1 -> f (UOverlapPragma dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UOverlapPragma dom st1 -> f (UOverlapPragma dom st2) Source #

SemanticTraversal UOverlapPragma Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UOverlapPragma dom1 st -> f (UOverlapPragma dom2 st) Source #

GoodOperationFor c (UOverlapPragma dom stage) => ClassyPlate c (UOverlapPragma dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UOverlapPragma dom stage -> UOverlapPragma dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UOverlapPragma dom stage -> m (UOverlapPragma dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UOverlapPragma dom stage -> UOverlapPragma dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UOverlapPragma dom stage -> m (UOverlapPragma dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UOverlapPragma dom stage -> UOverlapPragma dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UOverlapPragma dom stage -> m (UOverlapPragma dom stage) #

(Domain dom, SourceInfo stage) => Data (UOverlapPragma dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UOverlapPragma dom stage -> c (UOverlapPragma dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UOverlapPragma dom stage) #

toConstr :: UOverlapPragma dom stage -> Constr #

dataTypeOf :: UOverlapPragma dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UOverlapPragma dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UOverlapPragma dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UOverlapPragma dom stage -> UOverlapPragma dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UOverlapPragma dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UOverlapPragma dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UOverlapPragma dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UOverlapPragma dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UOverlapPragma dom stage -> m (UOverlapPragma dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UOverlapPragma dom stage -> m (UOverlapPragma dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UOverlapPragma dom stage -> m (UOverlapPragma dom stage) #

Domain dom => Generic (UOverlapPragma dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UOverlapPragma dom stage) :: * -> * #

Methods

from :: UOverlapPragma dom stage -> Rep (UOverlapPragma dom stage) x #

to :: Rep (UOverlapPragma dom stage) x -> UOverlapPragma dom stage #

type Rep (UOverlapPragma dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UOverlapPragma dom stage) = D1 (MetaData "UOverlapPragma" "Language.Haskell.Tools.AST.Representation.Decls" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) ((C1 (MetaCons "UEnableOverlap" PrefixI False) (U1 :: * -> *) :+: (C1 (MetaCons "UDisableOverlap" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "UOverlappable" PrefixI False) (U1 :: * -> *))) :+: (C1 (MetaCons "UOverlapping" PrefixI False) (U1 :: * -> *) :+: (C1 (MetaCons "UOverlaps" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "UIncoherentOverlap" PrefixI False) (U1 :: * -> *))))
type IgnoredFields (UOverlapPragma dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UOverlapPragma dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

Type families

data UTypeFamily dom stage Source #

Open type and data families

Constructors

UTypeFamily

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

Fields

UDataFamily

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

Fields

Instances
SourceInfoTraversal UTypeFamily Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UTypeFamily dom st1 -> f (UTypeFamily dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UTypeFamily dom st1 -> f (UTypeFamily dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UTypeFamily dom st1 -> f (UTypeFamily dom st2) Source #

SemanticTraversal UTypeFamily Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UTypeFamily dom1 st -> f (UTypeFamily dom2 st) Source #

(GoodOperationFor c (UTypeFamily dom stage), ClassyPlate c (Ann UDeclHead dom stage), ClassyPlate c (AnnMaybeG UTypeFamilySpec dom stage), ClassyPlate c (Ann UDeclHead dom stage), ClassyPlate c (AnnMaybeG UKindConstraint dom stage)) => ClassyPlate c (UTypeFamily dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UTypeFamily dom stage -> UTypeFamily dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UTypeFamily dom stage -> m (UTypeFamily dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UTypeFamily dom stage -> UTypeFamily dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UTypeFamily dom stage -> m (UTypeFamily dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UTypeFamily dom stage -> UTypeFamily dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UTypeFamily dom stage -> m (UTypeFamily dom stage) #

(Domain dom, SourceInfo stage) => Data (UTypeFamily dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UTypeFamily dom stage -> c (UTypeFamily dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UTypeFamily dom stage) #

toConstr :: UTypeFamily dom stage -> Constr #

dataTypeOf :: UTypeFamily dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UTypeFamily dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UTypeFamily dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UTypeFamily dom stage -> UTypeFamily dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UTypeFamily dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UTypeFamily dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UTypeFamily dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UTypeFamily dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UTypeFamily dom stage -> m (UTypeFamily dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UTypeFamily dom stage -> m (UTypeFamily dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UTypeFamily dom stage -> m (UTypeFamily dom stage) #

Domain dom => Generic (UTypeFamily dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UTypeFamily dom stage) :: * -> * #

Methods

from :: UTypeFamily dom stage -> Rep (UTypeFamily dom stage) x #

to :: Rep (UTypeFamily dom stage) x -> UTypeFamily dom stage #

type Rep (UTypeFamily dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UTypeFamily dom stage) = D1 (MetaData "UTypeFamily" "Language.Haskell.Tools.AST.Representation.Decls" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UTypeFamily" PrefixI True) (S1 (MetaSel (Just "_tfHead") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UDeclHead dom stage)) :*: S1 (MetaSel (Just "_tfSpec") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UTypeFamilySpec dom stage))) :+: C1 (MetaCons "UDataFamily" PrefixI True) (S1 (MetaSel (Just "_tfHead") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UDeclHead dom stage)) :*: S1 (MetaSel (Just "_tfKind") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UKindConstraint dom stage))))
type IgnoredFields (UTypeFamily dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UTypeFamily dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UTypeFamilySpec dom stage Source #

Type family specification with kinds specification and injectivity.

Constructors

UTypeFamilyKind

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

Fields

UTypeFamilyTyVar

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

Fields

UTypeFamilyInjectivity

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

Fields

Instances
SourceInfoTraversal UTypeFamilySpec Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UTypeFamilySpec dom st1 -> f (UTypeFamilySpec dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UTypeFamilySpec dom st1 -> f (UTypeFamilySpec dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UTypeFamilySpec dom st1 -> f (UTypeFamilySpec dom st2) Source #

SemanticTraversal UTypeFamilySpec Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UTypeFamilySpec dom1 st -> f (UTypeFamilySpec dom2 st) Source #

(GoodOperationFor c (UTypeFamilySpec dom stage), ClassyPlate c (Ann UKindConstraint dom stage), ClassyPlate c (Ann UTyVar dom stage), ClassyPlate c (Ann UInjectivityAnn dom stage)) => ClassyPlate c (UTypeFamilySpec dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UTypeFamilySpec dom stage -> UTypeFamilySpec dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UTypeFamilySpec dom stage -> m (UTypeFamilySpec dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UTypeFamilySpec dom stage -> UTypeFamilySpec dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UTypeFamilySpec dom stage -> m (UTypeFamilySpec dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UTypeFamilySpec dom stage -> UTypeFamilySpec dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UTypeFamilySpec dom stage -> m (UTypeFamilySpec dom stage) #

(Domain dom, SourceInfo stage) => Data (UTypeFamilySpec dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UTypeFamilySpec dom stage -> c (UTypeFamilySpec dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UTypeFamilySpec dom stage) #

toConstr :: UTypeFamilySpec dom stage -> Constr #

dataTypeOf :: UTypeFamilySpec dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UTypeFamilySpec dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UTypeFamilySpec dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UTypeFamilySpec dom stage -> UTypeFamilySpec dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UTypeFamilySpec dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UTypeFamilySpec dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UTypeFamilySpec dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UTypeFamilySpec dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UTypeFamilySpec dom stage -> m (UTypeFamilySpec dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UTypeFamilySpec dom stage -> m (UTypeFamilySpec dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UTypeFamilySpec dom stage -> m (UTypeFamilySpec dom stage) #

Domain dom => Generic (UTypeFamilySpec dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UTypeFamilySpec dom stage) :: * -> * #

Methods

from :: UTypeFamilySpec dom stage -> Rep (UTypeFamilySpec dom stage) x #

to :: Rep (UTypeFamilySpec dom stage) x -> UTypeFamilySpec dom stage #

type Rep (UTypeFamilySpec dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UTypeFamilySpec dom stage) = D1 (MetaData "UTypeFamilySpec" "Language.Haskell.Tools.AST.Representation.Decls" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UTypeFamilyKind" PrefixI True) (S1 (MetaSel (Just "_tfSpecKind") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UKindConstraint dom stage))) :+: (C1 (MetaCons "UTypeFamilyTyVar" PrefixI True) (S1 (MetaSel (Just "_tfTypeVar") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UTyVar dom stage))) :+: C1 (MetaCons "UTypeFamilyInjectivity" PrefixI True) (S1 (MetaSel (Just "_tfInjectivity") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UInjectivityAnn dom stage)))))
type IgnoredFields (UTypeFamilySpec dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UTypeFamilySpec dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UInjectivityAnn dom stage Source #

Injectivity annotation for type families ( = r | r -> a )

Constructors

UInjectivityAnn 

Fields

Instances
SourceInfoTraversal UInjectivityAnn Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UInjectivityAnn dom st1 -> f (UInjectivityAnn dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UInjectivityAnn dom st1 -> f (UInjectivityAnn dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UInjectivityAnn dom st1 -> f (UInjectivityAnn dom st2) Source #

SemanticTraversal UInjectivityAnn Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UInjectivityAnn dom1 st -> f (UInjectivityAnn dom2 st) Source #

(GoodOperationFor c (UInjectivityAnn dom stage), ClassyPlate c (Ann UTyVar dom stage), ClassyPlate c (AnnListG UName dom stage)) => ClassyPlate c (UInjectivityAnn dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UInjectivityAnn dom stage -> UInjectivityAnn dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UInjectivityAnn dom stage -> m (UInjectivityAnn dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UInjectivityAnn dom stage -> UInjectivityAnn dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UInjectivityAnn dom stage -> m (UInjectivityAnn dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UInjectivityAnn dom stage -> UInjectivityAnn dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UInjectivityAnn dom stage -> m (UInjectivityAnn dom stage) #

(Domain dom, SourceInfo stage) => Data (UInjectivityAnn dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UInjectivityAnn dom stage -> c (UInjectivityAnn dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UInjectivityAnn dom stage) #

toConstr :: UInjectivityAnn dom stage -> Constr #

dataTypeOf :: UInjectivityAnn dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UInjectivityAnn dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UInjectivityAnn dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UInjectivityAnn dom stage -> UInjectivityAnn dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UInjectivityAnn dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UInjectivityAnn dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UInjectivityAnn dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UInjectivityAnn dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UInjectivityAnn dom stage -> m (UInjectivityAnn dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UInjectivityAnn dom stage -> m (UInjectivityAnn dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UInjectivityAnn dom stage -> m (UInjectivityAnn dom stage) #

Domain dom => Generic (UInjectivityAnn dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UInjectivityAnn dom stage) :: * -> * #

Methods

from :: UInjectivityAnn dom stage -> Rep (UInjectivityAnn dom stage) x #

to :: Rep (UInjectivityAnn dom stage) x -> UInjectivityAnn dom stage #

type Rep (UInjectivityAnn dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UInjectivityAnn dom stage) = D1 (MetaData "UInjectivityAnn" "Language.Haskell.Tools.AST.Representation.Decls" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UInjectivityAnn" PrefixI True) (S1 (MetaSel (Just "_injAnnRes") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UTyVar dom stage)) :*: S1 (MetaSel (Just "_injAnnDeps") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UName dom stage))))
type IgnoredFields (UInjectivityAnn dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UInjectivityAnn dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UTypeEqn dom stage Source #

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

Constructors

UTypeEqn 

Fields

Instances
SourceInfoTraversal UTypeEqn Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UTypeEqn dom st1 -> f (UTypeEqn dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UTypeEqn dom st1 -> f (UTypeEqn dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UTypeEqn dom st1 -> f (UTypeEqn dom st2) Source #

SemanticTraversal UTypeEqn Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UTypeEqn dom1 st -> f (UTypeEqn dom2 st) Source #

(GoodOperationFor c (UTypeEqn dom stage), ClassyPlate c (Ann UType dom stage), ClassyPlate c (Ann UType dom stage)) => ClassyPlate c (UTypeEqn dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UTypeEqn dom stage -> UTypeEqn dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UTypeEqn dom stage -> m (UTypeEqn dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UTypeEqn dom stage -> UTypeEqn dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UTypeEqn dom stage -> m (UTypeEqn dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UTypeEqn dom stage -> UTypeEqn dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UTypeEqn dom stage -> m (UTypeEqn dom stage) #

(Domain dom, SourceInfo stage) => Data (UTypeEqn dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UTypeEqn dom stage -> c (UTypeEqn dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UTypeEqn dom stage) #

toConstr :: UTypeEqn dom stage -> Constr #

dataTypeOf :: UTypeEqn dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UTypeEqn dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UTypeEqn dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UTypeEqn dom stage -> UTypeEqn dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UTypeEqn dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UTypeEqn dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UTypeEqn dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UTypeEqn dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UTypeEqn dom stage -> m (UTypeEqn dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UTypeEqn dom stage -> m (UTypeEqn dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UTypeEqn dom stage -> m (UTypeEqn dom stage) #

Domain dom => Generic (UTypeEqn dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UTypeEqn dom stage) :: * -> * #

Methods

from :: UTypeEqn dom stage -> Rep (UTypeEqn dom stage) x #

to :: Rep (UTypeEqn dom stage) x -> UTypeEqn dom stage #

type Rep (UTypeEqn dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UTypeEqn dom stage) = D1 (MetaData "UTypeEqn" "Language.Haskell.Tools.AST.Representation.Decls" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UTypeEqn" PrefixI True) (S1 (MetaSel (Just "_teLhs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UType dom stage)) :*: S1 (MetaSel (Just "_teRhs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UType dom stage))))
type IgnoredFields (UTypeEqn dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UTypeEqn dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

Type definitions

data UGadtConDecl dom stage Source #

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

Constructors

UGadtConDecl 
Instances
SourceInfoTraversal UGadtConDecl Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UGadtConDecl dom st1 -> f (UGadtConDecl dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UGadtConDecl dom st1 -> f (UGadtConDecl dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UGadtConDecl dom st1 -> f (UGadtConDecl dom st2) Source #

SemanticTraversal UGadtConDecl Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UGadtConDecl dom1 st -> f (UGadtConDecl dom2 st) Source #

(GoodOperationFor c (UGadtConDecl dom stage), ClassyPlate c (AnnListG UName dom stage), ClassyPlate c (AnnListG UTyVar dom stage), ClassyPlate c (AnnMaybeG UContext dom stage), ClassyPlate c (Ann UGadtConType dom stage)) => ClassyPlate c (UGadtConDecl dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UGadtConDecl dom stage -> UGadtConDecl dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UGadtConDecl dom stage -> m (UGadtConDecl dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UGadtConDecl dom stage -> UGadtConDecl dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UGadtConDecl dom stage -> m (UGadtConDecl dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UGadtConDecl dom stage -> UGadtConDecl dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UGadtConDecl dom stage -> m (UGadtConDecl dom stage) #

(Domain dom, SourceInfo stage) => Data (UGadtConDecl dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UGadtConDecl dom stage -> c (UGadtConDecl dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UGadtConDecl dom stage) #

toConstr :: UGadtConDecl dom stage -> Constr #

dataTypeOf :: UGadtConDecl dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UGadtConDecl dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UGadtConDecl dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UGadtConDecl dom stage -> UGadtConDecl dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UGadtConDecl dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UGadtConDecl dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UGadtConDecl dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UGadtConDecl dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UGadtConDecl dom stage -> m (UGadtConDecl dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UGadtConDecl dom stage -> m (UGadtConDecl dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UGadtConDecl dom stage -> m (UGadtConDecl dom stage) #

Domain dom => Generic (UGadtConDecl dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UGadtConDecl dom stage) :: * -> * #

Methods

from :: UGadtConDecl dom stage -> Rep (UGadtConDecl dom stage) x #

to :: Rep (UGadtConDecl dom stage) x -> UGadtConDecl dom stage #

type Rep (UGadtConDecl dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UGadtConDecl dom stage) = D1 (MetaData "UGadtConDecl" "Language.Haskell.Tools.AST.Representation.Decls" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UGadtConDecl" PrefixI True) ((S1 (MetaSel (Just "_gadtConNames") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UName dom stage)) :*: S1 (MetaSel (Just "_gadtConTypeArgs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UTyVar dom stage))) :*: (S1 (MetaSel (Just "_gadtConTypeCtx") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UContext dom stage)) :*: S1 (MetaSel (Just "_gadtConType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UGadtConType dom stage)))))
type IgnoredFields (UGadtConDecl dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UGadtConDecl dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UDataOrNewtypeKeyword dom stage Source #

The data or the newtype keyword to define ADTs.

Instances
SourceInfoTraversal UDataOrNewtypeKeyword Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UDataOrNewtypeKeyword dom st1 -> f (UDataOrNewtypeKeyword dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UDataOrNewtypeKeyword dom st1 -> f (UDataOrNewtypeKeyword dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UDataOrNewtypeKeyword dom st1 -> f (UDataOrNewtypeKeyword dom st2) Source #

SemanticTraversal UDataOrNewtypeKeyword Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UDataOrNewtypeKeyword dom1 st -> f (UDataOrNewtypeKeyword dom2 st) Source #

GoodOperationFor c (UDataOrNewtypeKeyword dom stage) => ClassyPlate c (UDataOrNewtypeKeyword dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UDataOrNewtypeKeyword dom stage -> UDataOrNewtypeKeyword dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UDataOrNewtypeKeyword dom stage -> m (UDataOrNewtypeKeyword dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UDataOrNewtypeKeyword dom stage -> UDataOrNewtypeKeyword dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UDataOrNewtypeKeyword dom stage -> m (UDataOrNewtypeKeyword dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UDataOrNewtypeKeyword dom stage -> UDataOrNewtypeKeyword dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UDataOrNewtypeKeyword dom stage -> m (UDataOrNewtypeKeyword dom stage) #

(Domain dom, SourceInfo stage) => Data (UDataOrNewtypeKeyword dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UDataOrNewtypeKeyword dom stage -> c (UDataOrNewtypeKeyword dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UDataOrNewtypeKeyword dom stage) #

toConstr :: UDataOrNewtypeKeyword dom stage -> Constr #

dataTypeOf :: UDataOrNewtypeKeyword dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UDataOrNewtypeKeyword dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UDataOrNewtypeKeyword dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UDataOrNewtypeKeyword dom stage -> UDataOrNewtypeKeyword dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UDataOrNewtypeKeyword dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UDataOrNewtypeKeyword dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UDataOrNewtypeKeyword dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UDataOrNewtypeKeyword dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UDataOrNewtypeKeyword dom stage -> m (UDataOrNewtypeKeyword dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UDataOrNewtypeKeyword dom stage -> m (UDataOrNewtypeKeyword dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UDataOrNewtypeKeyword dom stage -> m (UDataOrNewtypeKeyword dom stage) #

Domain dom => Generic (UDataOrNewtypeKeyword dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UDataOrNewtypeKeyword dom stage) :: * -> * #

Methods

from :: UDataOrNewtypeKeyword dom stage -> Rep (UDataOrNewtypeKeyword dom stage) x #

to :: Rep (UDataOrNewtypeKeyword dom stage) x -> UDataOrNewtypeKeyword dom stage #

type Rep (UDataOrNewtypeKeyword dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UDataOrNewtypeKeyword dom stage) = D1 (MetaData "UDataOrNewtypeKeyword" "Language.Haskell.Tools.AST.Representation.Decls" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UDataKeyword" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "UNewtypeKeyword" PrefixI False) (U1 :: * -> *))
type IgnoredFields (UDataOrNewtypeKeyword dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UDataOrNewtypeKeyword dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UGadtConType dom stage Source #

Type of GADT constructors (can be record types: { val :: Int })

Instances
SourceInfoTraversal UGadtConType Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UGadtConType dom st1 -> f (UGadtConType dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UGadtConType dom st1 -> f (UGadtConType dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UGadtConType dom st1 -> f (UGadtConType dom st2) Source #

SemanticTraversal UGadtConType Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UGadtConType dom1 st -> f (UGadtConType dom2 st) Source #

(GoodOperationFor c (UGadtConType dom stage), ClassyPlate c (Ann UType dom stage), ClassyPlate c (AnnListG UFieldDecl dom stage), ClassyPlate c (Ann UType dom stage)) => ClassyPlate c (UGadtConType dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UGadtConType dom stage -> UGadtConType dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UGadtConType dom stage -> m (UGadtConType dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UGadtConType dom stage -> UGadtConType dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UGadtConType dom stage -> m (UGadtConType dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UGadtConType dom stage -> UGadtConType dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UGadtConType dom stage -> m (UGadtConType dom stage) #

(Domain dom, SourceInfo stage) => Data (UGadtConType dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UGadtConType dom stage -> c (UGadtConType dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UGadtConType dom stage) #

toConstr :: UGadtConType dom stage -> Constr #

dataTypeOf :: UGadtConType dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UGadtConType dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UGadtConType dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UGadtConType dom stage -> UGadtConType dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UGadtConType dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UGadtConType dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UGadtConType dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UGadtConType dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UGadtConType dom stage -> m (UGadtConType dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UGadtConType dom stage -> m (UGadtConType dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UGadtConType dom stage -> m (UGadtConType dom stage) #

Domain dom => Generic (UGadtConType dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UGadtConType dom stage) :: * -> * #

Methods

from :: UGadtConType dom stage -> Rep (UGadtConType dom stage) x #

to :: Rep (UGadtConType dom stage) x -> UGadtConType dom stage #

type Rep (UGadtConType dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UGadtConType dom stage) = D1 (MetaData "UGadtConType" "Language.Haskell.Tools.AST.Representation.Decls" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UGadtNormalType" PrefixI True) (S1 (MetaSel (Just "_gadtConNormalType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UType dom stage))) :+: C1 (MetaCons "UGadtRecordType" PrefixI True) (S1 (MetaSel (Just "_gadtConRecordFields") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UFieldDecl dom stage)) :*: S1 (MetaSel (Just "_gadtConResultType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UType dom stage))))
type IgnoredFields (UGadtConType dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UGadtConType dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UFunDeps dom stage Source #

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

Constructors

UFunDeps 

Fields

Instances
SourceInfoTraversal UFunDeps Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UFunDeps dom st1 -> f (UFunDeps dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UFunDeps dom st1 -> f (UFunDeps dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UFunDeps dom st1 -> f (UFunDeps dom st2) Source #

SemanticTraversal UFunDeps Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UFunDeps dom1 st -> f (UFunDeps dom2 st) Source #

(GoodOperationFor c (UFunDeps dom stage), ClassyPlate c (AnnListG UFunDep dom stage)) => ClassyPlate c (UFunDeps dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UFunDeps dom stage -> UFunDeps dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UFunDeps dom stage -> m (UFunDeps dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UFunDeps dom stage -> UFunDeps dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UFunDeps dom stage -> m (UFunDeps dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UFunDeps dom stage -> UFunDeps dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UFunDeps dom stage -> m (UFunDeps dom stage) #

(Domain dom, SourceInfo stage) => Data (UFunDeps dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UFunDeps dom stage -> c (UFunDeps dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UFunDeps dom stage) #

toConstr :: UFunDeps dom stage -> Constr #

dataTypeOf :: UFunDeps dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UFunDeps dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UFunDeps dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UFunDeps dom stage -> UFunDeps dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UFunDeps dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UFunDeps dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UFunDeps dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UFunDeps dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UFunDeps dom stage -> m (UFunDeps dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UFunDeps dom stage -> m (UFunDeps dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UFunDeps dom stage -> m (UFunDeps dom stage) #

Domain dom => Generic (UFunDeps dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UFunDeps dom stage) :: * -> * #

Methods

from :: UFunDeps dom stage -> Rep (UFunDeps dom stage) x #

to :: Rep (UFunDeps dom stage) x -> UFunDeps dom stage #

type Rep (UFunDeps dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UFunDeps dom stage) = D1 (MetaData "UFunDeps" "Language.Haskell.Tools.AST.Representation.Decls" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UFunDeps" PrefixI True) (S1 (MetaSel (Just "_funDeps") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UFunDep dom stage))))
type IgnoredFields (UFunDeps dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UFunDeps dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UFunDep dom stage Source #

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

Constructors

UFunDep 

Fields

Instances
SourceInfoTraversal UFunDep Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UFunDep dom st1 -> f (UFunDep dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UFunDep dom st1 -> f (UFunDep dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UFunDep dom st1 -> f (UFunDep dom st2) Source #

SemanticTraversal UFunDep Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UFunDep dom1 st -> f (UFunDep dom2 st) Source #

(GoodOperationFor c (UFunDep dom stage), ClassyPlate c (AnnListG UName dom stage), ClassyPlate c (AnnListG UName dom stage)) => ClassyPlate c (UFunDep dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UFunDep dom stage -> UFunDep dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UFunDep dom stage -> m (UFunDep dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UFunDep dom stage -> UFunDep dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UFunDep dom stage -> m (UFunDep dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UFunDep dom stage -> UFunDep dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UFunDep dom stage -> m (UFunDep dom stage) #

(Domain dom, SourceInfo stage) => Data (UFunDep dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UFunDep dom stage -> c (UFunDep dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UFunDep dom stage) #

toConstr :: UFunDep dom stage -> Constr #

dataTypeOf :: UFunDep dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UFunDep dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UFunDep dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UFunDep dom stage -> UFunDep dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UFunDep dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UFunDep dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UFunDep dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UFunDep dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UFunDep dom stage -> m (UFunDep dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UFunDep dom stage -> m (UFunDep dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UFunDep dom stage -> m (UFunDep dom stage) #

Domain dom => Generic (UFunDep dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UFunDep dom stage) :: * -> * #

Methods

from :: UFunDep dom stage -> Rep (UFunDep dom stage) x #

to :: Rep (UFunDep dom stage) x -> UFunDep dom stage #

type Rep (UFunDep dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UFunDep dom stage) = D1 (MetaData "UFunDep" "Language.Haskell.Tools.AST.Representation.Decls" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UFunDep" PrefixI True) (S1 (MetaSel (Just "_funDepLhs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UName dom stage)) :*: S1 (MetaSel (Just "_funDepRhs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UName dom stage))))
type IgnoredFields (UFunDep dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UFunDep dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UConDecl dom stage Source #

A constructor declaration for a datatype

Constructors

UConDecl

Ordinary data constructor ( C t1 t2 )

Fields

URecordDecl

Record data constructor ( C { _n1 :: t1, _n2 :: t2 } )

Fields

UInfixConDecl

Infix data constructor ( t1 :+: t2 )

Fields

Instances
SourceInfoTraversal UConDecl Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UConDecl dom st1 -> f (UConDecl dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UConDecl dom st1 -> f (UConDecl dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UConDecl dom st1 -> f (UConDecl dom st2) Source #

SemanticTraversal UConDecl Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UConDecl dom1 st -> f (UConDecl dom2 st) Source #

(GoodOperationFor c (UConDecl dom stage), ClassyPlate c (AnnListG UTyVar dom stage), ClassyPlate c (AnnMaybeG UContext dom stage), ClassyPlate c (Ann UName dom stage), ClassyPlate c (AnnListG UType dom stage), ClassyPlate c (AnnListG UTyVar dom stage), ClassyPlate c (AnnMaybeG UContext dom stage), ClassyPlate c (Ann UName dom stage), ClassyPlate c (AnnListG UFieldDecl dom stage), ClassyPlate c (AnnListG UTyVar dom stage), ClassyPlate c (AnnMaybeG UContext dom stage), ClassyPlate c (Ann UType dom stage), ClassyPlate c (Ann UOperator dom stage), ClassyPlate c (Ann UType dom stage)) => ClassyPlate c (UConDecl dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UConDecl dom stage -> UConDecl dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UConDecl dom stage -> m (UConDecl dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UConDecl dom stage -> UConDecl dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UConDecl dom stage -> m (UConDecl dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UConDecl dom stage -> UConDecl dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UConDecl dom stage -> m (UConDecl dom stage) #

(Domain dom, SourceInfo stage) => Data (UConDecl dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UConDecl dom stage -> c (UConDecl dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UConDecl dom stage) #

toConstr :: UConDecl dom stage -> Constr #

dataTypeOf :: UConDecl dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UConDecl dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UConDecl dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UConDecl dom stage -> UConDecl dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UConDecl dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UConDecl dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UConDecl dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UConDecl dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UConDecl dom stage -> m (UConDecl dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UConDecl dom stage -> m (UConDecl dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UConDecl dom stage -> m (UConDecl dom stage) #

Domain dom => Generic (UConDecl dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UConDecl dom stage) :: * -> * #

Methods

from :: UConDecl dom stage -> Rep (UConDecl dom stage) x #

to :: Rep (UConDecl dom stage) x -> UConDecl dom stage #

type Rep (UConDecl dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UConDecl dom stage) = D1 (MetaData "UConDecl" "Language.Haskell.Tools.AST.Representation.Decls" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UConDecl" PrefixI True) ((S1 (MetaSel (Just "_conTypeArgs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UTyVar dom stage)) :*: S1 (MetaSel (Just "_conTypeCtx") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UContext dom stage))) :*: (S1 (MetaSel (Just "_conDeclName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage)) :*: S1 (MetaSel (Just "_conDeclArgs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UType dom stage)))) :+: (C1 (MetaCons "URecordDecl" PrefixI True) ((S1 (MetaSel (Just "_conTypeArgs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UTyVar dom stage)) :*: S1 (MetaSel (Just "_conTypeCtx") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UContext dom stage))) :*: (S1 (MetaSel (Just "_conDeclName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage)) :*: S1 (MetaSel (Just "_conDeclFields") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UFieldDecl dom stage)))) :+: C1 (MetaCons "UInfixConDecl" PrefixI True) ((S1 (MetaSel (Just "_conTypeArgs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UTyVar dom stage)) :*: S1 (MetaSel (Just "_conTypeCtx") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UContext dom stage))) :*: (S1 (MetaSel (Just "_conDeclLhs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UType dom stage)) :*: (S1 (MetaSel (Just "_conDeclOp") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UOperator dom stage)) :*: S1 (MetaSel (Just "_conDeclRhs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UType dom stage)))))))
type IgnoredFields (UConDecl dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UConDecl dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UFieldDecl dom stage Source #

Field declaration ( fld :: Int )

Constructors

UFieldDecl 

Fields

Instances
SourceInfoTraversal UFieldDecl Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UFieldDecl dom st1 -> f (UFieldDecl dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UFieldDecl dom st1 -> f (UFieldDecl dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UFieldDecl dom st1 -> f (UFieldDecl dom st2) Source #

SemanticTraversal UFieldDecl Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UFieldDecl dom1 st -> f (UFieldDecl dom2 st) Source #

(GoodOperationFor c (UFieldDecl dom stage), ClassyPlate c (AnnListG UName dom stage), ClassyPlate c (Ann UType dom stage)) => ClassyPlate c (UFieldDecl dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UFieldDecl dom stage -> UFieldDecl dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UFieldDecl dom stage -> m (UFieldDecl dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UFieldDecl dom stage -> UFieldDecl dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UFieldDecl dom stage -> m (UFieldDecl dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UFieldDecl dom stage -> UFieldDecl dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UFieldDecl dom stage -> m (UFieldDecl dom stage) #

(Domain dom, SourceInfo stage) => Data (UFieldDecl dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UFieldDecl dom stage -> c (UFieldDecl dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UFieldDecl dom stage) #

toConstr :: UFieldDecl dom stage -> Constr #

dataTypeOf :: UFieldDecl dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UFieldDecl dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UFieldDecl dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UFieldDecl dom stage -> UFieldDecl dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UFieldDecl dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UFieldDecl dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UFieldDecl dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UFieldDecl dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UFieldDecl dom stage -> m (UFieldDecl dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UFieldDecl dom stage -> m (UFieldDecl dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UFieldDecl dom stage -> m (UFieldDecl dom stage) #

Domain dom => Generic (UFieldDecl dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UFieldDecl dom stage) :: * -> * #

Methods

from :: UFieldDecl dom stage -> Rep (UFieldDecl dom stage) x #

to :: Rep (UFieldDecl dom stage) x -> UFieldDecl dom stage #

type Rep (UFieldDecl dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UFieldDecl dom stage) = D1 (MetaData "UFieldDecl" "Language.Haskell.Tools.AST.Representation.Decls" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UFieldDecl" PrefixI True) (S1 (MetaSel (Just "_fieldNames") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UName dom stage)) :*: S1 (MetaSel (Just "_fieldType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UType dom stage))))
type IgnoredFields (UFieldDecl dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UFieldDecl dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UDeriving dom stage Source #

A deriving clause following a data type declaration. ( deriving Show or deriving (Show, Eq) )

Instances
SourceInfoTraversal UDeriving Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UDeriving dom st1 -> f (UDeriving dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UDeriving dom st1 -> f (UDeriving dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UDeriving dom st1 -> f (UDeriving dom st2) Source #

SemanticTraversal UDeriving Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UDeriving dom1 st -> f (UDeriving dom2 st) Source #

(GoodOperationFor c (UDeriving dom stage), ClassyPlate c (AnnMaybeG UDeriveStrategy dom stage), ClassyPlate c (Ann UInstanceHead dom stage), ClassyPlate c (AnnMaybeG UDeriveStrategy dom stage), ClassyPlate c (AnnListG UInstanceHead dom stage)) => ClassyPlate c (UDeriving dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UDeriving dom stage -> UDeriving dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UDeriving dom stage -> m (UDeriving dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UDeriving dom stage -> UDeriving dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UDeriving dom stage -> m (UDeriving dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UDeriving dom stage -> UDeriving dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UDeriving dom stage -> m (UDeriving dom stage) #

(Domain dom, SourceInfo stage) => Data (UDeriving dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UDeriving dom stage -> c (UDeriving dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UDeriving dom stage) #

toConstr :: UDeriving dom stage -> Constr #

dataTypeOf :: UDeriving dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UDeriving dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UDeriving dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UDeriving dom stage -> UDeriving dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UDeriving dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UDeriving dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UDeriving dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UDeriving dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UDeriving dom stage -> m (UDeriving dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UDeriving dom stage -> m (UDeriving dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UDeriving dom stage -> m (UDeriving dom stage) #

Domain dom => Generic (UDeriving dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UDeriving dom stage) :: * -> * #

Methods

from :: UDeriving dom stage -> Rep (UDeriving dom stage) x #

to :: Rep (UDeriving dom stage) x -> UDeriving dom stage #

type Rep (UDeriving dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UDeriving dom stage) = D1 (MetaData "UDeriving" "Language.Haskell.Tools.AST.Representation.Decls" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UDerivingOne" PrefixI True) (S1 (MetaSel (Just "_deriveStrategy") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UDeriveStrategy dom stage)) :*: S1 (MetaSel (Just "_oneDerived") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UInstanceHead dom stage))) :+: C1 (MetaCons "UDerivings" PrefixI True) (S1 (MetaSel (Just "_deriveStrategy") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UDeriveStrategy dom stage)) :*: S1 (MetaSel (Just "_allDerived") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UInstanceHead dom stage))))
type IgnoredFields (UDeriving dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UDeriving dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UDeriveStrategy dom stage Source #

Instances
SourceInfoTraversal UDeriveStrategy Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UDeriveStrategy dom st1 -> f (UDeriveStrategy dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UDeriveStrategy dom st1 -> f (UDeriveStrategy dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UDeriveStrategy dom st1 -> f (UDeriveStrategy dom st2) Source #

SemanticTraversal UDeriveStrategy Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UDeriveStrategy dom1 st -> f (UDeriveStrategy dom2 st) Source #

GoodOperationFor c (UDeriveStrategy dom stage) => ClassyPlate c (UDeriveStrategy dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UDeriveStrategy dom stage -> UDeriveStrategy dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UDeriveStrategy dom stage -> m (UDeriveStrategy dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UDeriveStrategy dom stage -> UDeriveStrategy dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UDeriveStrategy dom stage -> m (UDeriveStrategy dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UDeriveStrategy dom stage -> UDeriveStrategy dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UDeriveStrategy dom stage -> m (UDeriveStrategy dom stage) #

(Domain dom, SourceInfo stage) => Data (UDeriveStrategy dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UDeriveStrategy dom stage -> c (UDeriveStrategy dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UDeriveStrategy dom stage) #

toConstr :: UDeriveStrategy dom stage -> Constr #

dataTypeOf :: UDeriveStrategy dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UDeriveStrategy dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UDeriveStrategy dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UDeriveStrategy dom stage -> UDeriveStrategy dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UDeriveStrategy dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UDeriveStrategy dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UDeriveStrategy dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UDeriveStrategy dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UDeriveStrategy dom stage -> m (UDeriveStrategy dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UDeriveStrategy dom stage -> m (UDeriveStrategy dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UDeriveStrategy dom stage -> m (UDeriveStrategy dom stage) #

Domain dom => Generic (UDeriveStrategy dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UDeriveStrategy dom stage) :: * -> * #

Methods

from :: UDeriveStrategy dom stage -> Rep (UDeriveStrategy dom stage) x #

to :: Rep (UDeriveStrategy dom stage) x -> UDeriveStrategy dom stage #

type Rep (UDeriveStrategy dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UDeriveStrategy dom stage) = D1 (MetaData "UDeriveStrategy" "Language.Haskell.Tools.AST.Representation.Decls" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UStockStrategy" PrefixI False) (U1 :: * -> *) :+: (C1 (MetaCons "UAnyClassStrategy" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "UNewtypeStrategy" PrefixI False) (U1 :: * -> *)))
type IgnoredFields (UDeriveStrategy dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UDeriveStrategy dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

Pattern synonyms

data UPatternTypeSignature dom stage Source #

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

Constructors

UPatternTypeSignature 

Fields

Instances
SourceInfoTraversal UPatternTypeSignature Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UPatternTypeSignature dom st1 -> f (UPatternTypeSignature dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UPatternTypeSignature dom st1 -> f (UPatternTypeSignature dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UPatternTypeSignature dom st1 -> f (UPatternTypeSignature dom st2) Source #

SemanticTraversal UPatternTypeSignature Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UPatternTypeSignature dom1 st -> f (UPatternTypeSignature dom2 st) Source #

(GoodOperationFor c (UPatternTypeSignature dom stage), ClassyPlate c (AnnListG UName dom stage), ClassyPlate c (Ann UType dom stage)) => ClassyPlate c (UPatternTypeSignature dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UPatternTypeSignature dom stage -> UPatternTypeSignature dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UPatternTypeSignature dom stage -> m (UPatternTypeSignature dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UPatternTypeSignature dom stage -> UPatternTypeSignature dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UPatternTypeSignature dom stage -> m (UPatternTypeSignature dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UPatternTypeSignature dom stage -> UPatternTypeSignature dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UPatternTypeSignature dom stage -> m (UPatternTypeSignature dom stage) #

(Domain dom, SourceInfo stage) => Data (UPatternTypeSignature dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UPatternTypeSignature dom stage -> c (UPatternTypeSignature dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UPatternTypeSignature dom stage) #

toConstr :: UPatternTypeSignature dom stage -> Constr #

dataTypeOf :: UPatternTypeSignature dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UPatternTypeSignature dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UPatternTypeSignature dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UPatternTypeSignature dom stage -> UPatternTypeSignature dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UPatternTypeSignature dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UPatternTypeSignature dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UPatternTypeSignature dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UPatternTypeSignature dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UPatternTypeSignature dom stage -> m (UPatternTypeSignature dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UPatternTypeSignature dom stage -> m (UPatternTypeSignature dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UPatternTypeSignature dom stage -> m (UPatternTypeSignature dom stage) #

Domain dom => Generic (UPatternTypeSignature dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UPatternTypeSignature dom stage) :: * -> * #

Methods

from :: UPatternTypeSignature dom stage -> Rep (UPatternTypeSignature dom stage) x #

to :: Rep (UPatternTypeSignature dom stage) x -> UPatternTypeSignature dom stage #

type Rep (UPatternTypeSignature dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UPatternTypeSignature dom stage) = D1 (MetaData "UPatternTypeSignature" "Language.Haskell.Tools.AST.Representation.Decls" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UPatternTypeSignature" PrefixI True) (S1 (MetaSel (Just "_patSigName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UName dom stage)) :*: S1 (MetaSel (Just "_patSigType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UType dom stage))))
type IgnoredFields (UPatternTypeSignature dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UPatternTypeSignature dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UPatternSynonym dom stage Source #

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

Constructors

UPatternSynonym 

Fields

Instances
SourceInfoTraversal UPatternSynonym Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UPatternSynonym dom st1 -> f (UPatternSynonym dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UPatternSynonym dom st1 -> f (UPatternSynonym dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UPatternSynonym dom st1 -> f (UPatternSynonym dom st2) Source #

SemanticTraversal UPatternSynonym Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UPatternSynonym dom1 st -> f (UPatternSynonym dom2 st) Source #

(GoodOperationFor c (UPatternSynonym dom stage), ClassyPlate c (Ann UPatSynLhs dom stage), ClassyPlate c (Ann UPatSynRhs dom stage)) => ClassyPlate c (UPatternSynonym dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UPatternSynonym dom stage -> UPatternSynonym dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UPatternSynonym dom stage -> m (UPatternSynonym dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UPatternSynonym dom stage -> UPatternSynonym dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UPatternSynonym dom stage -> m (UPatternSynonym dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UPatternSynonym dom stage -> UPatternSynonym dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UPatternSynonym dom stage -> m (UPatternSynonym dom stage) #

(Domain dom, SourceInfo stage) => Data (UPatternSynonym dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UPatternSynonym dom stage -> c (UPatternSynonym dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UPatternSynonym dom stage) #

toConstr :: UPatternSynonym dom stage -> Constr #

dataTypeOf :: UPatternSynonym dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UPatternSynonym dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UPatternSynonym dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UPatternSynonym dom stage -> UPatternSynonym dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UPatternSynonym dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UPatternSynonym dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UPatternSynonym dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UPatternSynonym dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UPatternSynonym dom stage -> m (UPatternSynonym dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UPatternSynonym dom stage -> m (UPatternSynonym dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UPatternSynonym dom stage -> m (UPatternSynonym dom stage) #

Domain dom => Generic (UPatternSynonym dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UPatternSynonym dom stage) :: * -> * #

Methods

from :: UPatternSynonym dom stage -> Rep (UPatternSynonym dom stage) x #

to :: Rep (UPatternSynonym dom stage) x -> UPatternSynonym dom stage #

type Rep (UPatternSynonym dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UPatternSynonym dom stage) = D1 (MetaData "UPatternSynonym" "Language.Haskell.Tools.AST.Representation.Decls" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UPatternSynonym" PrefixI True) (S1 (MetaSel (Just "_patLhs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UPatSynLhs dom stage)) :*: S1 (MetaSel (Just "_patRhs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UPatSynRhs dom stage))))
type IgnoredFields (UPatternSynonym dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UPatternSynonym dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UPatSynLhs dom stage Source #

Left hand side of a pattern synonym

Constructors

UNormalPatSyn

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

Fields

UInfixPatSyn

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

Fields

URecordPatSyn

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

Fields

Instances
SourceInfoTraversal UPatSynLhs Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UPatSynLhs dom st1 -> f (UPatSynLhs dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UPatSynLhs dom st1 -> f (UPatSynLhs dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UPatSynLhs dom st1 -> f (UPatSynLhs dom st2) Source #

SemanticTraversal UPatSynLhs Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UPatSynLhs dom1 st -> f (UPatSynLhs dom2 st) Source #

(GoodOperationFor c (UPatSynLhs dom stage), ClassyPlate c (Ann UName dom stage), ClassyPlate c (AnnListG UName dom stage), ClassyPlate c (Ann UName dom stage), ClassyPlate c (Ann UOperator dom stage), ClassyPlate c (Ann UName dom stage), ClassyPlate c (Ann UName dom stage), ClassyPlate c (AnnListG UName dom stage)) => ClassyPlate c (UPatSynLhs dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UPatSynLhs dom stage -> UPatSynLhs dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UPatSynLhs dom stage -> m (UPatSynLhs dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UPatSynLhs dom stage -> UPatSynLhs dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UPatSynLhs dom stage -> m (UPatSynLhs dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UPatSynLhs dom stage -> UPatSynLhs dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UPatSynLhs dom stage -> m (UPatSynLhs dom stage) #

(Domain dom, SourceInfo stage) => Data (UPatSynLhs dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UPatSynLhs dom stage -> c (UPatSynLhs dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UPatSynLhs dom stage) #

toConstr :: UPatSynLhs dom stage -> Constr #

dataTypeOf :: UPatSynLhs dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UPatSynLhs dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UPatSynLhs dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UPatSynLhs dom stage -> UPatSynLhs dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UPatSynLhs dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UPatSynLhs dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UPatSynLhs dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UPatSynLhs dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UPatSynLhs dom stage -> m (UPatSynLhs dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UPatSynLhs dom stage -> m (UPatSynLhs dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UPatSynLhs dom stage -> m (UPatSynLhs dom stage) #

Domain dom => Generic (UPatSynLhs dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UPatSynLhs dom stage) :: * -> * #

Methods

from :: UPatSynLhs dom stage -> Rep (UPatSynLhs dom stage) x #

to :: Rep (UPatSynLhs dom stage) x -> UPatSynLhs dom stage #

type Rep (UPatSynLhs dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UPatSynLhs dom stage) = D1 (MetaData "UPatSynLhs" "Language.Haskell.Tools.AST.Representation.Decls" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UNormalPatSyn" PrefixI True) (S1 (MetaSel (Just "_patName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage)) :*: S1 (MetaSel (Just "_patArgs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UName dom stage))) :+: (C1 (MetaCons "UInfixPatSyn" PrefixI True) (S1 (MetaSel (Just "_patSynLhs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage)) :*: (S1 (MetaSel (Just "_patSynOp") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UOperator dom stage)) :*: S1 (MetaSel (Just "_patSynRhs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage)))) :+: C1 (MetaCons "URecordPatSyn" PrefixI True) (S1 (MetaSel (Just "_patName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage)) :*: S1 (MetaSel (Just "_patArgs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UName dom stage)))))
type IgnoredFields (UPatSynLhs dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UPatSynLhs dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UPatSynRhs dom stage Source #

Right-hand side of pattern synonym

Constructors

UBidirectionalPatSyn

pattern Int = App Int [] or pattern Int <- App Int [] where Int = App Int []

Fields

UOneDirectionalPatSyn
 pattern Int <- App Int []

Fields

Instances
SourceInfoTraversal UPatSynRhs Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UPatSynRhs dom st1 -> f (UPatSynRhs dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UPatSynRhs dom st1 -> f (UPatSynRhs dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UPatSynRhs dom st1 -> f (UPatSynRhs dom st2) Source #

SemanticTraversal UPatSynRhs Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UPatSynRhs dom1 st -> f (UPatSynRhs dom2 st) Source #

(GoodOperationFor c (UPatSynRhs dom stage), ClassyPlate c (Ann UPattern dom stage), ClassyPlate c (AnnMaybeG UPatSynWhere dom stage), ClassyPlate c (Ann UPattern dom stage)) => ClassyPlate c (UPatSynRhs dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UPatSynRhs dom stage -> UPatSynRhs dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UPatSynRhs dom stage -> m (UPatSynRhs dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UPatSynRhs dom stage -> UPatSynRhs dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UPatSynRhs dom stage -> m (UPatSynRhs dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UPatSynRhs dom stage -> UPatSynRhs dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UPatSynRhs dom stage -> m (UPatSynRhs dom stage) #

(Domain dom, SourceInfo stage) => Data (UPatSynRhs dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UPatSynRhs dom stage -> c (UPatSynRhs dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UPatSynRhs dom stage) #

toConstr :: UPatSynRhs dom stage -> Constr #

dataTypeOf :: UPatSynRhs dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UPatSynRhs dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UPatSynRhs dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UPatSynRhs dom stage -> UPatSynRhs dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UPatSynRhs dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UPatSynRhs dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UPatSynRhs dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UPatSynRhs dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UPatSynRhs dom stage -> m (UPatSynRhs dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UPatSynRhs dom stage -> m (UPatSynRhs dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UPatSynRhs dom stage -> m (UPatSynRhs dom stage) #

Domain dom => Generic (UPatSynRhs dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UPatSynRhs dom stage) :: * -> * #

Methods

from :: UPatSynRhs dom stage -> Rep (UPatSynRhs dom stage) x #

to :: Rep (UPatSynRhs dom stage) x -> UPatSynRhs dom stage #

type Rep (UPatSynRhs dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UPatSynRhs dom stage) = D1 (MetaData "UPatSynRhs" "Language.Haskell.Tools.AST.Representation.Decls" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UBidirectionalPatSyn" PrefixI True) (S1 (MetaSel (Just "_patRhsPat") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UPattern dom stage)) :*: S1 (MetaSel (Just "_patRhsOpposite") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UPatSynWhere dom stage))) :+: C1 (MetaCons "UOneDirectionalPatSyn" PrefixI True) (S1 (MetaSel (Just "_patRhsPat") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UPattern dom stage))))
type IgnoredFields (UPatSynRhs dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UPatSynRhs dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UPatSynWhere dom stage Source #

Where clause of pattern synonym (explicit expression direction)

Constructors

UPatSynWhere 

Fields

Instances
SourceInfoTraversal UPatSynWhere Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UPatSynWhere dom st1 -> f (UPatSynWhere dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UPatSynWhere dom st1 -> f (UPatSynWhere dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UPatSynWhere dom st1 -> f (UPatSynWhere dom st2) Source #

SemanticTraversal UPatSynWhere Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UPatSynWhere dom1 st -> f (UPatSynWhere dom2 st) Source #

(GoodOperationFor c (UPatSynWhere dom stage), ClassyPlate c (AnnListG UMatch dom stage)) => ClassyPlate c (UPatSynWhere dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UPatSynWhere dom stage -> UPatSynWhere dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UPatSynWhere dom stage -> m (UPatSynWhere dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UPatSynWhere dom stage -> UPatSynWhere dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UPatSynWhere dom stage -> m (UPatSynWhere dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UPatSynWhere dom stage -> UPatSynWhere dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UPatSynWhere dom stage -> m (UPatSynWhere dom stage) #

(Domain dom, SourceInfo stage) => Data (UPatSynWhere dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UPatSynWhere dom stage -> c (UPatSynWhere dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UPatSynWhere dom stage) #

toConstr :: UPatSynWhere dom stage -> Constr #

dataTypeOf :: UPatSynWhere dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UPatSynWhere dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UPatSynWhere dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UPatSynWhere dom stage -> UPatSynWhere dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UPatSynWhere dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UPatSynWhere dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UPatSynWhere dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UPatSynWhere dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UPatSynWhere dom stage -> m (UPatSynWhere dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UPatSynWhere dom stage -> m (UPatSynWhere dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UPatSynWhere dom stage -> m (UPatSynWhere dom stage) #

Domain dom => Generic (UPatSynWhere dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UPatSynWhere dom stage) :: * -> * #

Methods

from :: UPatSynWhere dom stage -> Rep (UPatSynWhere dom stage) x #

to :: Rep (UPatSynWhere dom stage) x -> UPatSynWhere dom stage #

type Rep (UPatSynWhere dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UPatSynWhere dom stage) = D1 (MetaData "UPatSynWhere" "Language.Haskell.Tools.AST.Representation.Decls" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UPatSynWhere" PrefixI True) (S1 (MetaSel (Just "_patOpposite") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UMatch dom stage))))
type IgnoredFields (UPatSynWhere dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UPatSynWhere dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

Foreign imports

data UCallConv dom stage Source #

Call conventions of foreign functions

Instances
SourceInfoTraversal UCallConv Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UCallConv dom st1 -> f (UCallConv dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UCallConv dom st1 -> f (UCallConv dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UCallConv dom st1 -> f (UCallConv dom st2) Source #

SemanticTraversal UCallConv Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UCallConv dom1 st -> f (UCallConv dom2 st) Source #

GoodOperationFor c (UCallConv dom stage) => ClassyPlate c (UCallConv dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UCallConv dom stage -> UCallConv dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UCallConv dom stage -> m (UCallConv dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UCallConv dom stage -> UCallConv dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UCallConv dom stage -> m (UCallConv dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UCallConv dom stage -> UCallConv dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UCallConv dom stage -> m (UCallConv dom stage) #

(Domain dom, SourceInfo stage) => Data (UCallConv dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UCallConv dom stage -> c (UCallConv dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UCallConv dom stage) #

toConstr :: UCallConv dom stage -> Constr #

dataTypeOf :: UCallConv dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UCallConv dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UCallConv dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UCallConv dom stage -> UCallConv dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UCallConv dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UCallConv dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UCallConv dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UCallConv dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UCallConv dom stage -> m (UCallConv dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UCallConv dom stage -> m (UCallConv dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UCallConv dom stage -> m (UCallConv dom stage) #

Domain dom => Generic (UCallConv dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UCallConv dom stage) :: * -> * #

Methods

from :: UCallConv dom stage -> Rep (UCallConv dom stage) x #

to :: Rep (UCallConv dom stage) x -> UCallConv dom stage #

type Rep (UCallConv dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UCallConv dom stage) = D1 (MetaData "UCallConv" "Language.Haskell.Tools.AST.Representation.Decls" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (((C1 (MetaCons "UStdCall" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "UCCall" PrefixI False) (U1 :: * -> *)) :+: (C1 (MetaCons "UCPlusPlus" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "UDotNet" PrefixI False) (U1 :: * -> *))) :+: ((C1 (MetaCons "UJvm" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "UJs" PrefixI False) (U1 :: * -> *)) :+: (C1 (MetaCons "UJavaScript" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "UCApi" PrefixI False) (U1 :: * -> *))))
type IgnoredFields (UCallConv dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UCallConv dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data USafety dom stage Source #

Safety annotations for foreign calls

Instances
SourceInfoTraversal USafety Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> USafety dom st1 -> f (USafety dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> USafety dom st1 -> f (USafety dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> USafety dom st1 -> f (USafety dom st2) Source #

SemanticTraversal USafety Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> USafety dom1 st -> f (USafety dom2 st) Source #

GoodOperationFor c (USafety dom stage) => ClassyPlate c (USafety dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> USafety dom stage -> USafety dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> USafety dom stage -> m (USafety dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> USafety dom stage -> USafety dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> USafety dom stage -> m (USafety dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> USafety dom stage -> USafety dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> USafety dom stage -> m (USafety dom stage) #

(Domain dom, SourceInfo stage) => Data (USafety dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> USafety dom stage -> c (USafety dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (USafety dom stage) #

toConstr :: USafety dom stage -> Constr #

dataTypeOf :: USafety dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (USafety dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (USafety dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> USafety dom stage -> USafety dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> USafety dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> USafety dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> USafety dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> USafety dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> USafety dom stage -> m (USafety dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> USafety dom stage -> m (USafety dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> USafety dom stage -> m (USafety dom stage) #

Domain dom => Generic (USafety dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (USafety dom stage) :: * -> * #

Methods

from :: USafety dom stage -> Rep (USafety dom stage) x #

to :: Rep (USafety dom stage) x -> USafety dom stage #

type Rep (USafety dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (USafety dom stage) = D1 (MetaData "USafety" "Language.Haskell.Tools.AST.Representation.Decls" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) ((C1 (MetaCons "USafe" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "UThreadSafe" PrefixI False) (U1 :: * -> *)) :+: (C1 (MetaCons "UUnsafe" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "UInterruptible" PrefixI False) (U1 :: * -> *)))
type IgnoredFields (USafety dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (USafety dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

Role annotations

data URole dom stage Source #

Role annotations for types

Instances
SourceInfoTraversal URole Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> URole dom st1 -> f (URole dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> URole dom st1 -> f (URole dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> URole dom st1 -> f (URole dom st2) Source #

SemanticTraversal URole Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> URole dom1 st -> f (URole dom2 st) Source #

GoodOperationFor c (URole dom stage) => ClassyPlate c (URole dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> URole dom stage -> URole dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> URole dom stage -> m (URole dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> URole dom stage -> URole dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> URole dom stage -> m (URole dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> URole dom stage -> URole dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> URole dom stage -> m (URole dom stage) #

(Domain dom, SourceInfo stage) => Data (URole dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> URole dom stage -> c (URole dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (URole dom stage) #

toConstr :: URole dom stage -> Constr #

dataTypeOf :: URole dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (URole dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (URole dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> URole dom stage -> URole dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> URole dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> URole dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> URole dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> URole dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> URole dom stage -> m (URole dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> URole dom stage -> m (URole dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> URole dom stage -> m (URole dom stage) #

Domain dom => Generic (URole dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (URole dom stage) :: * -> * #

Methods

from :: URole dom stage -> Rep (URole dom stage) x #

to :: Rep (URole dom stage) x -> URole dom stage #

type Rep (URole dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (URole dom stage) = D1 (MetaData "URole" "Language.Haskell.Tools.AST.Representation.Decls" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UNominal" PrefixI False) (U1 :: * -> *) :+: (C1 (MetaCons "URepresentational" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "UPhantom" PrefixI False) (U1 :: * -> *)))
type IgnoredFields (URole dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (URole dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

Pragmas

data UTopLevelPragma dom stage Source #

Top level pragmas

Constructors

URulePragma

A pragma that introduces source rewrite rules ( {--} )

Fields

UDeprPragma

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

Fields

UWarningPragma

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

Fields

UAnnPragma

A pragma that annotates a definition with an arbitrary value ( {-# ANN f 42 ) TODO: extract pragmas that appear both in top-level and in instances (inline, inlinable, noinline)

Fields

UInlinePragmaDecl 

Fields

ULinePragma

A pragma for maintaining line numbers in generated sources ( {--} )

USpecializeDecl 
UCompletePragma

The COMPLETE pragma is used to inform the pattern match checker that a certain set of patterns is complete ( {--} ).

Fields

Instances
SourceInfoTraversal UTopLevelPragma Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UTopLevelPragma dom st1 -> f (UTopLevelPragma dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UTopLevelPragma dom st1 -> f (UTopLevelPragma dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UTopLevelPragma dom st1 -> f (UTopLevelPragma dom st2) Source #

SemanticTraversal UTopLevelPragma Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UTopLevelPragma dom1 st -> f (UTopLevelPragma dom2 st) Source #

(GoodOperationFor c (UTopLevelPragma dom stage), ClassyPlate c (AnnListG URule dom stage), ClassyPlate c (AnnListG UName dom stage), ClassyPlate c (AnnListG UStringNode dom stage), ClassyPlate c (AnnListG UName dom stage), ClassyPlate c (AnnListG UStringNode dom stage), ClassyPlate c (Ann UAnnotationSubject dom stage), ClassyPlate c (Ann UExpr dom stage), ClassyPlate c (Ann UInlinePragma dom stage), ClassyPlate c (Ann LineNumber dom stage), ClassyPlate c (AnnMaybeG UStringNode dom stage), ClassyPlate c (Ann USpecializePragma dom stage), ClassyPlate c (AnnListG UName dom stage), ClassyPlate c (AnnMaybeG UName dom stage)) => ClassyPlate c (UTopLevelPragma dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UTopLevelPragma dom stage -> UTopLevelPragma dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UTopLevelPragma dom stage -> m (UTopLevelPragma dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UTopLevelPragma dom stage -> UTopLevelPragma dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UTopLevelPragma dom stage -> m (UTopLevelPragma dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UTopLevelPragma dom stage -> UTopLevelPragma dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UTopLevelPragma dom stage -> m (UTopLevelPragma dom stage) #

(Domain dom, SourceInfo stage) => Data (UTopLevelPragma dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UTopLevelPragma dom stage -> c (UTopLevelPragma dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UTopLevelPragma dom stage) #

toConstr :: UTopLevelPragma dom stage -> Constr #

dataTypeOf :: UTopLevelPragma dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UTopLevelPragma dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UTopLevelPragma dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UTopLevelPragma dom stage -> UTopLevelPragma dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UTopLevelPragma dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UTopLevelPragma dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UTopLevelPragma dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UTopLevelPragma dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UTopLevelPragma dom stage -> m (UTopLevelPragma dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UTopLevelPragma dom stage -> m (UTopLevelPragma dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UTopLevelPragma dom stage -> m (UTopLevelPragma dom stage) #

Domain dom => Generic (UTopLevelPragma dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UTopLevelPragma dom stage) :: * -> * #

Methods

from :: UTopLevelPragma dom stage -> Rep (UTopLevelPragma dom stage) x #

to :: Rep (UTopLevelPragma dom stage) x -> UTopLevelPragma dom stage #

type Rep (UTopLevelPragma dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UTopLevelPragma dom stage) = D1 (MetaData "UTopLevelPragma" "Language.Haskell.Tools.AST.Representation.Decls" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (((C1 (MetaCons "URulePragma" PrefixI True) (S1 (MetaSel (Just "_pragmaRule") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG URule dom stage))) :+: C1 (MetaCons "UDeprPragma" PrefixI True) (S1 (MetaSel (Just "_pragmaObjects") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UName dom stage)) :*: S1 (MetaSel (Just "_deprMessage") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UStringNode dom stage)))) :+: (C1 (MetaCons "UWarningPragma" PrefixI True) (S1 (MetaSel (Just "_pragmaObjects") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UName dom stage)) :*: S1 (MetaSel (Just "_warnMessage") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UStringNode dom stage))) :+: C1 (MetaCons "UAnnPragma" PrefixI True) (S1 (MetaSel (Just "_annotationSubject") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UAnnotationSubject dom stage)) :*: S1 (MetaSel (Just "_annotateExpr") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage))))) :+: ((C1 (MetaCons "UInlinePragmaDecl" PrefixI True) (S1 (MetaSel (Just "_pragmaInline") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UInlinePragma dom stage))) :+: C1 (MetaCons "ULinePragma" PrefixI True) (S1 (MetaSel (Just "_pragmaLineNum") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann LineNumber dom stage)) :*: S1 (MetaSel (Just "_pragmaFileName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UStringNode dom stage)))) :+: (C1 (MetaCons "USpecializeDecl" PrefixI True) (S1 (MetaSel (Just "_specializePragma") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann USpecializePragma dom stage))) :+: C1 (MetaCons "UCompletePragma" PrefixI True) (S1 (MetaSel (Just "_pragmaObjects") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UName dom stage)) :*: S1 (MetaSel (Just "_pragmaSignature") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UName dom stage))))))
type IgnoredFields (UTopLevelPragma dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UTopLevelPragma dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data USpecializePragma dom stage Source #

Constructors

USpecializePragma

A pragma that tells the compiler that a polymorph function should be optimized for a given type ( {--} )

Fields

Instances
SourceInfoTraversal USpecializePragma Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> USpecializePragma dom st1 -> f (USpecializePragma dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> USpecializePragma dom st1 -> f (USpecializePragma dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> USpecializePragma dom st1 -> f (USpecializePragma dom st2) Source #

SemanticTraversal USpecializePragma Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> USpecializePragma dom1 st -> f (USpecializePragma dom2 st) Source #

(GoodOperationFor c (USpecializePragma dom stage), ClassyPlate c (AnnMaybeG UPhaseControl dom stage), ClassyPlate c (Ann UName dom stage), ClassyPlate c (AnnListG UType dom stage)) => ClassyPlate c (USpecializePragma dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> USpecializePragma dom stage -> USpecializePragma dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> USpecializePragma dom stage -> m (USpecializePragma dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> USpecializePragma dom stage -> USpecializePragma dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> USpecializePragma dom stage -> m (USpecializePragma dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> USpecializePragma dom stage -> USpecializePragma dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> USpecializePragma dom stage -> m (USpecializePragma dom stage) #

(Domain dom, SourceInfo stage) => Data (USpecializePragma dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> USpecializePragma dom stage -> c (USpecializePragma dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (USpecializePragma dom stage) #

toConstr :: USpecializePragma dom stage -> Constr #

dataTypeOf :: USpecializePragma dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (USpecializePragma dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (USpecializePragma dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> USpecializePragma dom stage -> USpecializePragma dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> USpecializePragma dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> USpecializePragma dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> USpecializePragma dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> USpecializePragma dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> USpecializePragma dom stage -> m (USpecializePragma dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> USpecializePragma dom stage -> m (USpecializePragma dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> USpecializePragma dom stage -> m (USpecializePragma dom stage) #

Domain dom => Generic (USpecializePragma dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (USpecializePragma dom stage) :: * -> * #

Methods

from :: USpecializePragma dom stage -> Rep (USpecializePragma dom stage) x #

to :: Rep (USpecializePragma dom stage) x -> USpecializePragma dom stage #

type Rep (USpecializePragma dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (USpecializePragma dom stage) = D1 (MetaData "USpecializePragma" "Language.Haskell.Tools.AST.Representation.Decls" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "USpecializePragma" PrefixI True) (S1 (MetaSel (Just "_pragmaPhase") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UPhaseControl dom stage)) :*: (S1 (MetaSel (Just "_specializeDef") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage)) :*: S1 (MetaSel (Just "_specializeType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UType dom stage)))))
type IgnoredFields (USpecializePragma dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (USpecializePragma dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data URule dom stage Source #

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

Constructors

URule 

Fields

Instances
SourceInfoTraversal URule Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> URule dom st1 -> f (URule dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> URule dom st1 -> f (URule dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> URule dom st1 -> f (URule dom st2) Source #

SemanticTraversal URule Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> URule dom1 st -> f (URule dom2 st) Source #

(GoodOperationFor c (URule dom stage), ClassyPlate c (Ann UStringNode dom stage), ClassyPlate c (AnnMaybeG UPhaseControl dom stage), ClassyPlate c (AnnListG URuleVar dom stage), ClassyPlate c (Ann UExpr dom stage), ClassyPlate c (Ann UExpr dom stage)) => ClassyPlate c (URule dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> URule dom stage -> URule dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> URule dom stage -> m (URule dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> URule dom stage -> URule dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> URule dom stage -> m (URule dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> URule dom stage -> URule dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> URule dom stage -> m (URule dom stage) #

(Domain dom, SourceInfo stage) => Data (URule dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> URule dom stage -> c (URule dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (URule dom stage) #

toConstr :: URule dom stage -> Constr #

dataTypeOf :: URule dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (URule dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (URule dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> URule dom stage -> URule dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> URule dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> URule dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> URule dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> URule dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> URule dom stage -> m (URule dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> URule dom stage -> m (URule dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> URule dom stage -> m (URule dom stage) #

Domain dom => Generic (URule dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (URule dom stage) :: * -> * #

Methods

from :: URule dom stage -> Rep (URule dom stage) x #

to :: Rep (URule dom stage) x -> URule dom stage #

type Rep (URule dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (URule dom stage) = D1 (MetaData "URule" "Language.Haskell.Tools.AST.Representation.Decls" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "URule" PrefixI True) ((S1 (MetaSel (Just "_ruleName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UStringNode dom stage)) :*: S1 (MetaSel (Just "_rulePhase") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UPhaseControl dom stage))) :*: (S1 (MetaSel (Just "_ruleBounded") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG URuleVar dom stage)) :*: (S1 (MetaSel (Just "_ruleLhs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage)) :*: S1 (MetaSel (Just "_ruleRhs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage))))))
type IgnoredFields (URule dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (URule dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data URuleVar dom stage Source #

A variable for a rewrite rule. With or without type signature.

Constructors

URuleVar

A simple rule variable

Fields

USigRuleVar

A rule variable with signature

Fields

Instances
SourceInfoTraversal URuleVar Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> URuleVar dom st1 -> f (URuleVar dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> URuleVar dom st1 -> f (URuleVar dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> URuleVar dom st1 -> f (URuleVar dom st2) Source #

SemanticTraversal URuleVar Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> URuleVar dom1 st -> f (URuleVar dom2 st) Source #

(GoodOperationFor c (URuleVar dom stage), ClassyPlate c (Ann UName dom stage), ClassyPlate c (Ann UName dom stage), ClassyPlate c (Ann UType dom stage)) => ClassyPlate c (URuleVar dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> URuleVar dom stage -> URuleVar dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> URuleVar dom stage -> m (URuleVar dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> URuleVar dom stage -> URuleVar dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> URuleVar dom stage -> m (URuleVar dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> URuleVar dom stage -> URuleVar dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> URuleVar dom stage -> m (URuleVar dom stage) #

(Domain dom, SourceInfo stage) => Data (URuleVar dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> URuleVar dom stage -> c (URuleVar dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (URuleVar dom stage) #

toConstr :: URuleVar dom stage -> Constr #

dataTypeOf :: URuleVar dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (URuleVar dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (URuleVar dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> URuleVar dom stage -> URuleVar dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> URuleVar dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> URuleVar dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> URuleVar dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> URuleVar dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> URuleVar dom stage -> m (URuleVar dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> URuleVar dom stage -> m (URuleVar dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> URuleVar dom stage -> m (URuleVar dom stage) #

Domain dom => Generic (URuleVar dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (URuleVar dom stage) :: * -> * #

Methods

from :: URuleVar dom stage -> Rep (URuleVar dom stage) x #

to :: Rep (URuleVar dom stage) x -> URuleVar dom stage #

type Rep (URuleVar dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (URuleVar dom stage) = D1 (MetaData "URuleVar" "Language.Haskell.Tools.AST.Representation.Decls" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "URuleVar" PrefixI True) (S1 (MetaSel (Just "_ruleVarName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage))) :+: C1 (MetaCons "USigRuleVar" PrefixI True) (S1 (MetaSel (Just "_ruleVarName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage)) :*: S1 (MetaSel (Just "_ruleVarType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UType dom stage))))
type IgnoredFields (URuleVar dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (URuleVar dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UAnnotationSubject dom stage Source #

Annotation allows you to connect an expression to any declaration.

Constructors

UNameAnnotation

The definition with the given name is annotated

Fields

UTypeAnnotation

A type with the given name is annotated

Fields

UModuleAnnotation

The whole module is annotated

Instances
SourceInfoTraversal UAnnotationSubject Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UAnnotationSubject dom st1 -> f (UAnnotationSubject dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UAnnotationSubject dom st1 -> f (UAnnotationSubject dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UAnnotationSubject dom st1 -> f (UAnnotationSubject dom st2) Source #

SemanticTraversal UAnnotationSubject Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UAnnotationSubject dom1 st -> f (UAnnotationSubject dom2 st) Source #

(GoodOperationFor c (UAnnotationSubject dom stage), ClassyPlate c (Ann UName dom stage), ClassyPlate c (Ann UName dom stage)) => ClassyPlate c (UAnnotationSubject dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UAnnotationSubject dom stage -> UAnnotationSubject dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UAnnotationSubject dom stage -> m (UAnnotationSubject dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UAnnotationSubject dom stage -> UAnnotationSubject dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UAnnotationSubject dom stage -> m (UAnnotationSubject dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UAnnotationSubject dom stage -> UAnnotationSubject dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UAnnotationSubject dom stage -> m (UAnnotationSubject dom stage) #

(Domain dom, SourceInfo stage) => Data (UAnnotationSubject dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UAnnotationSubject dom stage -> c (UAnnotationSubject dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UAnnotationSubject dom stage) #

toConstr :: UAnnotationSubject dom stage -> Constr #

dataTypeOf :: UAnnotationSubject dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UAnnotationSubject dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UAnnotationSubject dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UAnnotationSubject dom stage -> UAnnotationSubject dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UAnnotationSubject dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UAnnotationSubject dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UAnnotationSubject dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UAnnotationSubject dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UAnnotationSubject dom stage -> m (UAnnotationSubject dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UAnnotationSubject dom stage -> m (UAnnotationSubject dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UAnnotationSubject dom stage -> m (UAnnotationSubject dom stage) #

Domain dom => Generic (UAnnotationSubject dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UAnnotationSubject dom stage) :: * -> * #

Methods

from :: UAnnotationSubject dom stage -> Rep (UAnnotationSubject dom stage) x #

to :: Rep (UAnnotationSubject dom stage) x -> UAnnotationSubject dom stage #

type Rep (UAnnotationSubject dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UAnnotationSubject dom stage) = D1 (MetaData "UAnnotationSubject" "Language.Haskell.Tools.AST.Representation.Decls" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UNameAnnotation" PrefixI True) (S1 (MetaSel (Just "_annotateName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage))) :+: (C1 (MetaCons "UTypeAnnotation" PrefixI True) (S1 (MetaSel (Just "_annotateName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage))) :+: C1 (MetaCons "UModuleAnnotation" PrefixI False) (U1 :: * -> *)))
type IgnoredFields (UAnnotationSubject dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UAnnotationSubject dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UMinimalFormula dom stage Source #

Formulas of minimal annotations declaring which functions should be defined.

Constructors

UMinimalName 

Fields

UMinimalParen 

Fields

UMinimalOr

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

Fields

UMinimalAnd

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

Instances
SourceInfoTraversal UMinimalFormula Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UMinimalFormula dom st1 -> f (UMinimalFormula dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UMinimalFormula dom st1 -> f (UMinimalFormula dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UMinimalFormula dom st1 -> f (UMinimalFormula dom st2) Source #

SemanticTraversal UMinimalFormula Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UMinimalFormula dom1 st -> f (UMinimalFormula dom2 st) Source #

(GoodOperationFor c (UMinimalFormula dom stage), ClassyPlate c (Ann UName dom stage), ClassyPlate c (Ann UMinimalFormula dom stage), ClassyPlate c (AnnListG UMinimalFormula dom stage), ClassyPlate c (AnnListG UMinimalFormula dom stage)) => ClassyPlate c (UMinimalFormula dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UMinimalFormula dom stage -> UMinimalFormula dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UMinimalFormula dom stage -> m (UMinimalFormula dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UMinimalFormula dom stage -> UMinimalFormula dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UMinimalFormula dom stage -> m (UMinimalFormula dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UMinimalFormula dom stage -> UMinimalFormula dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UMinimalFormula dom stage -> m (UMinimalFormula dom stage) #

(Domain dom, SourceInfo stage) => Data (UMinimalFormula dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UMinimalFormula dom stage -> c (UMinimalFormula dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UMinimalFormula dom stage) #

toConstr :: UMinimalFormula dom stage -> Constr #

dataTypeOf :: UMinimalFormula dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UMinimalFormula dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UMinimalFormula dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UMinimalFormula dom stage -> UMinimalFormula dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UMinimalFormula dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UMinimalFormula dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UMinimalFormula dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UMinimalFormula dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UMinimalFormula dom stage -> m (UMinimalFormula dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UMinimalFormula dom stage -> m (UMinimalFormula dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UMinimalFormula dom stage -> m (UMinimalFormula dom stage) #

Domain dom => Generic (UMinimalFormula dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UMinimalFormula dom stage) :: * -> * #

Methods

from :: UMinimalFormula dom stage -> Rep (UMinimalFormula dom stage) x #

to :: Rep (UMinimalFormula dom stage) x -> UMinimalFormula dom stage #

type Rep (UMinimalFormula dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UMinimalFormula dom stage) = D1 (MetaData "UMinimalFormula" "Language.Haskell.Tools.AST.Representation.Decls" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) ((C1 (MetaCons "UMinimalName" PrefixI True) (S1 (MetaSel (Just "_minimalName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage))) :+: C1 (MetaCons "UMinimalParen" PrefixI True) (S1 (MetaSel (Just "_minimalInner") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UMinimalFormula dom stage)))) :+: (C1 (MetaCons "UMinimalOr" PrefixI True) (S1 (MetaSel (Just "_minimalOrs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UMinimalFormula dom stage))) :+: C1 (MetaCons "UMinimalAnd" PrefixI True) (S1 (MetaSel (Just "_minimalAnds") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UMinimalFormula dom stage)))))
type IgnoredFields (UMinimalFormula dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UMinimalFormula dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data LineNumber dom stage Source #

A line number for a line pragma.

Constructors

LineNumber 

Fields

Instances
SourceInfoTraversal LineNumber Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> LineNumber dom st1 -> f (LineNumber dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> LineNumber dom st1 -> f (LineNumber dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> LineNumber dom st1 -> f (LineNumber dom st2) Source #

SemanticTraversal LineNumber Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> LineNumber dom1 st -> f (LineNumber dom2 st) Source #

GoodOperationFor c (LineNumber dom stage) => ClassyPlate c (LineNumber dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> LineNumber dom stage -> LineNumber dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> LineNumber dom stage -> m (LineNumber dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> LineNumber dom stage -> LineNumber dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> LineNumber dom stage -> m (LineNumber dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> LineNumber dom stage -> LineNumber dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> LineNumber dom stage -> m (LineNumber dom stage) #

(Domain dom, SourceInfo stage) => Data (LineNumber dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LineNumber dom stage -> c (LineNumber dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (LineNumber dom stage) #

toConstr :: LineNumber dom stage -> Constr #

dataTypeOf :: LineNumber dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (LineNumber dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (LineNumber dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> LineNumber dom stage -> LineNumber dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LineNumber dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LineNumber dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> LineNumber dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> LineNumber dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> LineNumber dom stage -> m (LineNumber dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LineNumber dom stage -> m (LineNumber dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LineNumber dom stage -> m (LineNumber dom stage) #

Domain dom => Generic (LineNumber dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (LineNumber dom stage) :: * -> * #

Methods

from :: LineNumber dom stage -> Rep (LineNumber dom stage) x #

to :: Rep (LineNumber dom stage) x -> LineNumber dom stage #

type Rep (LineNumber dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (LineNumber dom stage) = D1 (MetaData "LineNumber" "Language.Haskell.Tools.AST.Representation.Decls" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "LineNumber" PrefixI True) (S1 (MetaSel (Just "_lineNumber") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int)))
type IgnoredFields (LineNumber dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (LineNumber dom stage) = (Right "_lineNumber" :: Either (Symbol, Nat) Symbol) ': ([] :: [Either (Symbol, Nat) Symbol])

data UValueBind dom stage Source #

Value binding for top-level and local bindings

Constructors

USimpleBind

Non-function binding ( v = "12" ) TODO: use one name for a function instead of names in each match

Fields

UFunBind

Function binding ( f 0 = 1; f x = x ). All matches must have the same name.

Fields

Instances
SourceInfoTraversal UValueBind Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UValueBind dom st1 -> f (UValueBind dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UValueBind dom st1 -> f (UValueBind dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UValueBind dom st1 -> f (UValueBind dom st2) Source #

SemanticTraversal UValueBind Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UValueBind dom1 st -> f (UValueBind dom2 st) Source #

(GoodOperationFor c (UValueBind dom stage), ClassyPlate c (Ann UPattern dom stage), ClassyPlate c (Ann URhs dom stage), ClassyPlate c (AnnMaybeG ULocalBinds dom stage), ClassyPlate c (AnnListG UMatch dom stage)) => ClassyPlate c (UValueBind dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UValueBind dom stage -> UValueBind dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UValueBind dom stage -> m (UValueBind dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UValueBind dom stage -> UValueBind dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UValueBind dom stage -> m (UValueBind dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UValueBind dom stage -> UValueBind dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UValueBind dom stage -> m (UValueBind dom stage) #

(Domain dom, SourceInfo stage) => Data (UValueBind dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UValueBind dom stage -> c (UValueBind dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UValueBind dom stage) #

toConstr :: UValueBind dom stage -> Constr #

dataTypeOf :: UValueBind dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UValueBind dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UValueBind dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UValueBind dom stage -> UValueBind dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UValueBind dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UValueBind dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UValueBind dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UValueBind dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UValueBind dom stage -> m (UValueBind dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UValueBind dom stage -> m (UValueBind dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UValueBind dom stage -> m (UValueBind dom stage) #

Domain dom => Generic (UValueBind dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UValueBind dom stage) :: * -> * #

Methods

from :: UValueBind dom stage -> Rep (UValueBind dom stage) x #

to :: Rep (UValueBind dom stage) x -> UValueBind dom stage #

type Rep (UValueBind dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UValueBind dom stage) = D1 (MetaData "UValueBind" "Language.Haskell.Tools.AST.Representation.Binds" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "USimpleBind" PrefixI True) (S1 (MetaSel (Just "_valBindPat") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UPattern dom stage)) :*: (S1 (MetaSel (Just "_valBindRhs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann URhs dom stage)) :*: S1 (MetaSel (Just "_valBindLocals") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG ULocalBinds dom stage)))) :+: C1 (MetaCons "UFunBind" PrefixI True) (S1 (MetaSel (Just "_funBindMatches") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UMatch dom stage))))
type IgnoredFields (UValueBind dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UValueBind dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UMatch dom stage Source #

Clause of function binding

Constructors

UMatch 

Fields

Instances
SourceInfoTraversal UMatch Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UMatch dom st1 -> f (UMatch dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UMatch dom st1 -> f (UMatch dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UMatch dom st1 -> f (UMatch dom st2) Source #

SemanticTraversal UMatch Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UMatch dom1 st -> f (UMatch dom2 st) Source #

(GoodOperationFor c (UMatch dom stage), ClassyPlate c (Ann UMatchLhs dom stage), ClassyPlate c (Ann URhs dom stage), ClassyPlate c (AnnMaybeG ULocalBinds dom stage)) => ClassyPlate c (UMatch dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UMatch dom stage -> UMatch dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UMatch dom stage -> m (UMatch dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UMatch dom stage -> UMatch dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UMatch dom stage -> m (UMatch dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UMatch dom stage -> UMatch dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UMatch dom stage -> m (UMatch dom stage) #

(Domain dom, SourceInfo stage) => Data (UMatch dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UMatch dom stage -> c (UMatch dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UMatch dom stage) #

toConstr :: UMatch dom stage -> Constr #

dataTypeOf :: UMatch dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UMatch dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UMatch dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UMatch dom stage -> UMatch dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UMatch dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UMatch dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UMatch dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UMatch dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UMatch dom stage -> m (UMatch dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UMatch dom stage -> m (UMatch dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UMatch dom stage -> m (UMatch dom stage) #

Domain dom => Generic (UMatch dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UMatch dom stage) :: * -> * #

Methods

from :: UMatch dom stage -> Rep (UMatch dom stage) x #

to :: Rep (UMatch dom stage) x -> UMatch dom stage #

type Rep (UMatch dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UMatch dom stage) = D1 (MetaData "UMatch" "Language.Haskell.Tools.AST.Representation.Binds" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UMatch" PrefixI True) (S1 (MetaSel (Just "_matchLhs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UMatchLhs dom stage)) :*: (S1 (MetaSel (Just "_matchRhs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann URhs dom stage)) :*: S1 (MetaSel (Just "_matchBinds") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG ULocalBinds dom stage)))))
type IgnoredFields (UMatch dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UMatch dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UMatchLhs dom stage Source #

Something on the left side of the match

Constructors

UNormalLhs

A match lhs with the function name and parameter names ( f a b )

Fields

UInfixLhs

An infix match lhs for an operator ( a + b )

Fields

Instances
SourceInfoTraversal UMatchLhs Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UMatchLhs dom st1 -> f (UMatchLhs dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UMatchLhs dom st1 -> f (UMatchLhs dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UMatchLhs dom st1 -> f (UMatchLhs dom st2) Source #

SemanticTraversal UMatchLhs Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UMatchLhs dom1 st -> f (UMatchLhs dom2 st) Source #

(GoodOperationFor c (UMatchLhs dom stage), ClassyPlate c (Ann UName dom stage), ClassyPlate c (AnnListG UPattern dom stage), ClassyPlate c (Ann UPattern dom stage), ClassyPlate c (Ann UOperator dom stage), ClassyPlate c (Ann UPattern dom stage), ClassyPlate c (AnnListG UPattern dom stage)) => ClassyPlate c (UMatchLhs dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UMatchLhs dom stage -> UMatchLhs dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UMatchLhs dom stage -> m (UMatchLhs dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UMatchLhs dom stage -> UMatchLhs dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UMatchLhs dom stage -> m (UMatchLhs dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UMatchLhs dom stage -> UMatchLhs dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UMatchLhs dom stage -> m (UMatchLhs dom stage) #

(Domain dom, SourceInfo stage) => Data (UMatchLhs dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UMatchLhs dom stage -> c (UMatchLhs dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UMatchLhs dom stage) #

toConstr :: UMatchLhs dom stage -> Constr #

dataTypeOf :: UMatchLhs dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UMatchLhs dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UMatchLhs dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UMatchLhs dom stage -> UMatchLhs dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UMatchLhs dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UMatchLhs dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UMatchLhs dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UMatchLhs dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UMatchLhs dom stage -> m (UMatchLhs dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UMatchLhs dom stage -> m (UMatchLhs dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UMatchLhs dom stage -> m (UMatchLhs dom stage) #

Domain dom => Generic (UMatchLhs dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UMatchLhs dom stage) :: * -> * #

Methods

from :: UMatchLhs dom stage -> Rep (UMatchLhs dom stage) x #

to :: Rep (UMatchLhs dom stage) x -> UMatchLhs dom stage #

type Rep (UMatchLhs dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UMatchLhs dom stage) = D1 (MetaData "UMatchLhs" "Language.Haskell.Tools.AST.Representation.Binds" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UNormalLhs" PrefixI True) (S1 (MetaSel (Just "_matchLhsName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage)) :*: S1 (MetaSel (Just "_matchLhsArgs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UPattern dom stage))) :+: C1 (MetaCons "UInfixLhs" PrefixI True) ((S1 (MetaSel (Just "_matchLhsLhs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UPattern dom stage)) :*: S1 (MetaSel (Just "_matchLhsOperator") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UOperator dom stage))) :*: (S1 (MetaSel (Just "_matchLhsRhs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UPattern dom stage)) :*: S1 (MetaSel (Just "_matchLhsArgs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UPattern dom stage)))))
type IgnoredFields (UMatchLhs dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UMatchLhs dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data ULocalBinds dom stage Source #

Local bindings attached to a declaration ( where x = 42 )

Constructors

ULocalBinds 

Fields

Instances
SourceInfoTraversal ULocalBinds Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> ULocalBinds dom st1 -> f (ULocalBinds dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> ULocalBinds dom st1 -> f (ULocalBinds dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> ULocalBinds dom st1 -> f (ULocalBinds dom st2) Source #

SemanticTraversal ULocalBinds Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> ULocalBinds dom1 st -> f (ULocalBinds dom2 st) Source #

(GoodOperationFor c (ULocalBinds dom stage), ClassyPlate c (AnnListG ULocalBind dom stage)) => ClassyPlate c (ULocalBinds dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> ULocalBinds dom stage -> ULocalBinds dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> ULocalBinds dom stage -> m (ULocalBinds dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> ULocalBinds dom stage -> ULocalBinds dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> ULocalBinds dom stage -> m (ULocalBinds dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> ULocalBinds dom stage -> ULocalBinds dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> ULocalBinds dom stage -> m (ULocalBinds dom stage) #

(Domain dom, SourceInfo stage) => Data (ULocalBinds dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ULocalBinds dom stage -> c (ULocalBinds dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ULocalBinds dom stage) #

toConstr :: ULocalBinds dom stage -> Constr #

dataTypeOf :: ULocalBinds dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ULocalBinds dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ULocalBinds dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> ULocalBinds dom stage -> ULocalBinds dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ULocalBinds dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ULocalBinds dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> ULocalBinds dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ULocalBinds dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ULocalBinds dom stage -> m (ULocalBinds dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ULocalBinds dom stage -> m (ULocalBinds dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ULocalBinds dom stage -> m (ULocalBinds dom stage) #

Domain dom => Generic (ULocalBinds dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (ULocalBinds dom stage) :: * -> * #

Methods

from :: ULocalBinds dom stage -> Rep (ULocalBinds dom stage) x #

to :: Rep (ULocalBinds dom stage) x -> ULocalBinds dom stage #

type Rep (ULocalBinds dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (ULocalBinds dom stage) = D1 (MetaData "ULocalBinds" "Language.Haskell.Tools.AST.Representation.Binds" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "ULocalBinds" PrefixI True) (S1 (MetaSel (Just "_localBinds") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG ULocalBind dom stage))))
type IgnoredFields (ULocalBinds dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (ULocalBinds dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data ULocalBind dom stage Source #

Bindings that are enabled in local blocks (where or let).

Constructors

ULocalValBind

A local binding for a value

Fields

ULocalSignature

A local type signature

Fields

ULocalFixity

A local fixity declaration

Fields

ULocalInline

A local inline pragma

Fields

Instances
SourceInfoTraversal ULocalBind Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> ULocalBind dom st1 -> f (ULocalBind dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> ULocalBind dom st1 -> f (ULocalBind dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> ULocalBind dom st1 -> f (ULocalBind dom st2) Source #

SemanticTraversal ULocalBind Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> ULocalBind dom1 st -> f (ULocalBind dom2 st) Source #

NamedElement ULocalBind Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Helpers

Methods

elementName :: (RefMonads w r, MonadPlus r, Morph Maybe r, Morph [] r) => Reference w r MU MU (Ann ULocalBind dom st) (Ann ULocalBind dom st) (Ann UQualifiedName dom st) (Ann UQualifiedName dom st) Source #

(GoodOperationFor c (ULocalBind dom stage), ClassyPlate c (Ann UValueBind dom stage), ClassyPlate c (Ann UTypeSignature dom stage), ClassyPlate c (Ann UFixitySignature dom stage), ClassyPlate c (Ann UInlinePragma dom stage)) => ClassyPlate c (ULocalBind dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> ULocalBind dom stage -> ULocalBind dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> ULocalBind dom stage -> m (ULocalBind dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> ULocalBind dom stage -> ULocalBind dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> ULocalBind dom stage -> m (ULocalBind dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> ULocalBind dom stage -> ULocalBind dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> ULocalBind dom stage -> m (ULocalBind dom stage) #

(Domain dom, SourceInfo stage) => Data (ULocalBind dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ULocalBind dom stage -> c (ULocalBind dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ULocalBind dom stage) #

toConstr :: ULocalBind dom stage -> Constr #

dataTypeOf :: ULocalBind dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ULocalBind dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ULocalBind dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> ULocalBind dom stage -> ULocalBind dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ULocalBind dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ULocalBind dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> ULocalBind dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ULocalBind dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ULocalBind dom stage -> m (ULocalBind dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ULocalBind dom stage -> m (ULocalBind dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ULocalBind dom stage -> m (ULocalBind dom stage) #

Domain dom => Generic (ULocalBind dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (ULocalBind dom stage) :: * -> * #

Methods

from :: ULocalBind dom stage -> Rep (ULocalBind dom stage) x #

to :: Rep (ULocalBind dom stage) x -> ULocalBind dom stage #

type Rep (ULocalBind dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (ULocalBind dom stage) = D1 (MetaData "ULocalBind" "Language.Haskell.Tools.AST.Representation.Binds" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) ((C1 (MetaCons "ULocalValBind" PrefixI True) (S1 (MetaSel (Just "_localVal") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UValueBind dom stage))) :+: C1 (MetaCons "ULocalSignature" PrefixI True) (S1 (MetaSel (Just "_localSig") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UTypeSignature dom stage)))) :+: (C1 (MetaCons "ULocalFixity" PrefixI True) (S1 (MetaSel (Just "_localFixity") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UFixitySignature dom stage))) :+: C1 (MetaCons "ULocalInline" PrefixI True) (S1 (MetaSel (Just "_localInline") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UInlinePragma dom stage)))))
type IgnoredFields (ULocalBind dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (ULocalBind dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UTypeSignature dom stage Source #

A type signature ( f :: Int -> Int )

Constructors

UTypeSignature 

Fields

Instances
SourceInfoTraversal UTypeSignature Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UTypeSignature dom st1 -> f (UTypeSignature dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UTypeSignature dom st1 -> f (UTypeSignature dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UTypeSignature dom st1 -> f (UTypeSignature dom st2) Source #

SemanticTraversal UTypeSignature Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UTypeSignature dom1 st -> f (UTypeSignature dom2 st) Source #

(GoodOperationFor c (UTypeSignature dom stage), ClassyPlate c (AnnListG UName dom stage), ClassyPlate c (Ann UType dom stage)) => ClassyPlate c (UTypeSignature dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UTypeSignature dom stage -> UTypeSignature dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UTypeSignature dom stage -> m (UTypeSignature dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UTypeSignature dom stage -> UTypeSignature dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UTypeSignature dom stage -> m (UTypeSignature dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UTypeSignature dom stage -> UTypeSignature dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UTypeSignature dom stage -> m (UTypeSignature dom stage) #

(Domain dom, SourceInfo stage) => Data (UTypeSignature dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UTypeSignature dom stage -> c (UTypeSignature dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UTypeSignature dom stage) #

toConstr :: UTypeSignature dom stage -> Constr #

dataTypeOf :: UTypeSignature dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UTypeSignature dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UTypeSignature dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UTypeSignature dom stage -> UTypeSignature dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UTypeSignature dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UTypeSignature dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UTypeSignature dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UTypeSignature dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UTypeSignature dom stage -> m (UTypeSignature dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UTypeSignature dom stage -> m (UTypeSignature dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UTypeSignature dom stage -> m (UTypeSignature dom stage) #

Domain dom => Generic (UTypeSignature dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UTypeSignature dom stage) :: * -> * #

Methods

from :: UTypeSignature dom stage -> Rep (UTypeSignature dom stage) x #

to :: Rep (UTypeSignature dom stage) x -> UTypeSignature dom stage #

type Rep (UTypeSignature dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UTypeSignature dom stage) = D1 (MetaData "UTypeSignature" "Language.Haskell.Tools.AST.Representation.Binds" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UTypeSignature" PrefixI True) (S1 (MetaSel (Just "_tsName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UName dom stage)) :*: S1 (MetaSel (Just "_tsType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UType dom stage))))
type IgnoredFields (UTypeSignature dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UTypeSignature dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

Fixities

data UFixitySignature dom stage Source #

A fixity signature ( infixl 5 +, - ).

Constructors

UFixitySignature 
Instances
SourceInfoTraversal UFixitySignature Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UFixitySignature dom st1 -> f (UFixitySignature dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UFixitySignature dom st1 -> f (UFixitySignature dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UFixitySignature dom st1 -> f (UFixitySignature dom st2) Source #

SemanticTraversal UFixitySignature Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UFixitySignature dom1 st -> f (UFixitySignature dom2 st) Source #

(GoodOperationFor c (UFixitySignature dom stage), ClassyPlate c (Ann Assoc dom stage), ClassyPlate c (AnnMaybeG Precedence dom stage), ClassyPlate c (AnnListG UOperator dom stage)) => ClassyPlate c (UFixitySignature dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UFixitySignature dom stage -> UFixitySignature dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UFixitySignature dom stage -> m (UFixitySignature dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UFixitySignature dom stage -> UFixitySignature dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UFixitySignature dom stage -> m (UFixitySignature dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UFixitySignature dom stage -> UFixitySignature dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UFixitySignature dom stage -> m (UFixitySignature dom stage) #

(Domain dom, SourceInfo stage) => Data (UFixitySignature dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UFixitySignature dom stage -> c (UFixitySignature dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UFixitySignature dom stage) #

toConstr :: UFixitySignature dom stage -> Constr #

dataTypeOf :: UFixitySignature dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UFixitySignature dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UFixitySignature dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UFixitySignature dom stage -> UFixitySignature dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UFixitySignature dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UFixitySignature dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UFixitySignature dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UFixitySignature dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UFixitySignature dom stage -> m (UFixitySignature dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UFixitySignature dom stage -> m (UFixitySignature dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UFixitySignature dom stage -> m (UFixitySignature dom stage) #

Domain dom => Generic (UFixitySignature dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UFixitySignature dom stage) :: * -> * #

Methods

from :: UFixitySignature dom stage -> Rep (UFixitySignature dom stage) x #

to :: Rep (UFixitySignature dom stage) x -> UFixitySignature dom stage #

type Rep (UFixitySignature dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UFixitySignature dom stage) = D1 (MetaData "UFixitySignature" "Language.Haskell.Tools.AST.Representation.Binds" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UFixitySignature" PrefixI True) (S1 (MetaSel (Just "_fixityAssoc") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann Assoc dom stage)) :*: (S1 (MetaSel (Just "_fixityPrecedence") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG Precedence dom stage)) :*: S1 (MetaSel (Just "_fixityOperators") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UOperator dom stage)))))
type IgnoredFields (UFixitySignature dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UFixitySignature dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data Assoc dom stage Source #

Associativity of an operator.

Constructors

AssocNone

non-associative operator (declared with infix)

AssocLeft

left-associative operator (declared with infixl)

AssocRight

right-associative operator (declared with infixr)

Instances
SourceInfoTraversal Assoc Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> Assoc dom st1 -> f (Assoc dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> Assoc dom st1 -> f (Assoc dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> Assoc dom st1 -> f (Assoc dom st2) Source #

SemanticTraversal Assoc Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> Assoc dom1 st -> f (Assoc dom2 st) Source #

GoodOperationFor c (Assoc dom stage) => ClassyPlate c (Assoc dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> Assoc dom stage -> Assoc dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> Assoc dom stage -> m (Assoc dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> Assoc dom stage -> Assoc dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> Assoc dom stage -> m (Assoc dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> Assoc dom stage -> Assoc dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> Assoc dom stage -> m (Assoc dom stage) #

(Domain dom, SourceInfo stage) => Data (Assoc dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

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

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

toConstr :: Assoc dom stage -> Constr #

dataTypeOf :: Assoc dom stage -> DataType #

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

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

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

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

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

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

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

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

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

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

Domain dom => Generic (Assoc dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (Assoc dom stage) :: * -> * #

Methods

from :: Assoc dom stage -> Rep (Assoc dom stage) x #

to :: Rep (Assoc dom stage) x -> Assoc dom stage #

type Rep (Assoc dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (Assoc dom stage) = D1 (MetaData "Assoc" "Language.Haskell.Tools.AST.Representation.Binds" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "AssocNone" PrefixI False) (U1 :: * -> *) :+: (C1 (MetaCons "AssocLeft" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "AssocRight" PrefixI False) (U1 :: * -> *)))
type IgnoredFields (Assoc dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (Assoc dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data Precedence dom stage Source #

Numeric precedence of an operator

Constructors

Precedence 
Instances
SourceInfoTraversal Precedence Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> Precedence dom st1 -> f (Precedence dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> Precedence dom st1 -> f (Precedence dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> Precedence dom st1 -> f (Precedence dom st2) Source #

SemanticTraversal Precedence Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> Precedence dom1 st -> f (Precedence dom2 st) Source #

GoodOperationFor c (Precedence dom stage) => ClassyPlate c (Precedence dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> Precedence dom stage -> Precedence dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> Precedence dom stage -> m (Precedence dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> Precedence dom stage -> Precedence dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> Precedence dom stage -> m (Precedence dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> Precedence dom stage -> Precedence dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> Precedence dom stage -> m (Precedence dom stage) #

(Domain dom, SourceInfo stage) => Data (Precedence dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Precedence dom stage -> c (Precedence dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Precedence dom stage) #

toConstr :: Precedence dom stage -> Constr #

dataTypeOf :: Precedence dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Precedence dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Precedence dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> Precedence dom stage -> Precedence dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Precedence dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Precedence dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> Precedence dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Precedence dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Precedence dom stage -> m (Precedence dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Precedence dom stage -> m (Precedence dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Precedence dom stage -> m (Precedence dom stage) #

Domain dom => Generic (Precedence dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (Precedence dom stage) :: * -> * #

Methods

from :: Precedence dom stage -> Rep (Precedence dom stage) x #

to :: Rep (Precedence dom stage) x -> Precedence dom stage #

type Rep (Precedence dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (Precedence dom stage) = D1 (MetaData "Precedence" "Language.Haskell.Tools.AST.Representation.Binds" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "Precedence" PrefixI True) (S1 (MetaSel (Just "_precedenceValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int)))
type IgnoredFields (Precedence dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (Precedence dom stage) = (Right "_precedenceValue" :: Either (Symbol, Nat) Symbol) ': ([] :: [Either (Symbol, Nat) Symbol])

data URhs dom stage Source #

Right hand side of a value binding (possible with guards): ( = 3 or | x == 1 = 3; | otherwise = 4 )

Constructors

UUnguardedRhs

An unguarded right-hand-side ( = 3 )

Fields

UGuardedRhss

An unguarded right-hand-side ( | x == 1 = 3; | otherwise = 4 )

Fields

Instances
SourceInfoTraversal URhs Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> URhs dom st1 -> f (URhs dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> URhs dom st1 -> f (URhs dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> URhs dom st1 -> f (URhs dom st2) Source #

SemanticTraversal URhs Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> URhs dom1 st -> f (URhs dom2 st) Source #

(GoodOperationFor c (URhs dom stage), ClassyPlate c (Ann UExpr dom stage), ClassyPlate c (AnnListG UGuardedRhs dom stage)) => ClassyPlate c (URhs dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> URhs dom stage -> URhs dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> URhs dom stage -> m (URhs dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> URhs dom stage -> URhs dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> URhs dom stage -> m (URhs dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> URhs dom stage -> URhs dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> URhs dom stage -> m (URhs dom stage) #

(Domain dom, SourceInfo stage) => Data (URhs dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> URhs dom stage -> c (URhs dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (URhs dom stage) #

toConstr :: URhs dom stage -> Constr #

dataTypeOf :: URhs dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (URhs dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (URhs dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> URhs dom stage -> URhs dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> URhs dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> URhs dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> URhs dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> URhs dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> URhs dom stage -> m (URhs dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> URhs dom stage -> m (URhs dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> URhs dom stage -> m (URhs dom stage) #

Domain dom => Generic (URhs dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (URhs dom stage) :: * -> * #

Methods

from :: URhs dom stage -> Rep (URhs dom stage) x #

to :: Rep (URhs dom stage) x -> URhs dom stage #

type Rep (URhs dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (URhs dom stage) = D1 (MetaData "URhs" "Language.Haskell.Tools.AST.Representation.Binds" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UUnguardedRhs" PrefixI True) (S1 (MetaSel (Just "_rhsExpr") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage))) :+: C1 (MetaCons "UGuardedRhss" PrefixI True) (S1 (MetaSel (Just "_rhsGuards") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UGuardedRhs dom stage))))
type IgnoredFields (URhs dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (URhs dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UGuardedRhs dom stage Source #

A guarded right-hand side of a value binding ( | x > 3 = 2 )

Constructors

UGuardedRhs 

Fields

Instances
SourceInfoTraversal UGuardedRhs Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UGuardedRhs dom st1 -> f (UGuardedRhs dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UGuardedRhs dom st1 -> f (UGuardedRhs dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UGuardedRhs dom st1 -> f (UGuardedRhs dom st2) Source #

SemanticTraversal UGuardedRhs Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UGuardedRhs dom1 st -> f (UGuardedRhs dom2 st) Source #

(GoodOperationFor c (UGuardedRhs dom stage), ClassyPlate c (AnnListG URhsGuard dom stage), ClassyPlate c (Ann UExpr dom stage)) => ClassyPlate c (UGuardedRhs dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UGuardedRhs dom stage -> UGuardedRhs dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UGuardedRhs dom stage -> m (UGuardedRhs dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UGuardedRhs dom stage -> UGuardedRhs dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UGuardedRhs dom stage -> m (UGuardedRhs dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UGuardedRhs dom stage -> UGuardedRhs dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UGuardedRhs dom stage -> m (UGuardedRhs dom stage) #

(Domain dom, SourceInfo stage) => Data (UGuardedRhs dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UGuardedRhs dom stage -> c (UGuardedRhs dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UGuardedRhs dom stage) #

toConstr :: UGuardedRhs dom stage -> Constr #

dataTypeOf :: UGuardedRhs dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UGuardedRhs dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UGuardedRhs dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UGuardedRhs dom stage -> UGuardedRhs dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UGuardedRhs dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UGuardedRhs dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UGuardedRhs dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UGuardedRhs dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UGuardedRhs dom stage -> m (UGuardedRhs dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UGuardedRhs dom stage -> m (UGuardedRhs dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UGuardedRhs dom stage -> m (UGuardedRhs dom stage) #

Domain dom => Generic (UGuardedRhs dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UGuardedRhs dom stage) :: * -> * #

Methods

from :: UGuardedRhs dom stage -> Rep (UGuardedRhs dom stage) x #

to :: Rep (UGuardedRhs dom stage) x -> UGuardedRhs dom stage #

type Rep (UGuardedRhs dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UGuardedRhs dom stage) = D1 (MetaData "UGuardedRhs" "Language.Haskell.Tools.AST.Representation.Binds" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UGuardedRhs" PrefixI True) (S1 (MetaSel (Just "_guardStmts") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG URhsGuard dom stage)) :*: S1 (MetaSel (Just "_guardExpr") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage))))
type IgnoredFields (UGuardedRhs dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UGuardedRhs dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data URhsGuard dom stage Source #

Guards for value bindings and pattern matches ( Just v x, v 1 )

Constructors

UGuardBind

A bind statement in a pattern guard ( Just v <- x )

Fields

UGuardLet

A let statement in a pattern guard ( let x = 3 )

Fields

UGuardCheck

An expression to check for a pattern guard

Fields

Instances
SourceInfoTraversal URhsGuard Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> URhsGuard dom st1 -> f (URhsGuard dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> URhsGuard dom st1 -> f (URhsGuard dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> URhsGuard dom st1 -> f (URhsGuard dom st2) Source #

SemanticTraversal URhsGuard Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> URhsGuard dom1 st -> f (URhsGuard dom2 st) Source #

(GoodOperationFor c (URhsGuard dom stage), ClassyPlate c (Ann UPattern dom stage), ClassyPlate c (Ann UExpr dom stage), ClassyPlate c (AnnListG ULocalBind dom stage), ClassyPlate c (Ann UExpr dom stage)) => ClassyPlate c (URhsGuard dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> URhsGuard dom stage -> URhsGuard dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> URhsGuard dom stage -> m (URhsGuard dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> URhsGuard dom stage -> URhsGuard dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> URhsGuard dom stage -> m (URhsGuard dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> URhsGuard dom stage -> URhsGuard dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> URhsGuard dom stage -> m (URhsGuard dom stage) #

(Domain dom, SourceInfo stage) => Data (URhsGuard dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> URhsGuard dom stage -> c (URhsGuard dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (URhsGuard dom stage) #

toConstr :: URhsGuard dom stage -> Constr #

dataTypeOf :: URhsGuard dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (URhsGuard dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (URhsGuard dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> URhsGuard dom stage -> URhsGuard dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> URhsGuard dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> URhsGuard dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> URhsGuard dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> URhsGuard dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> URhsGuard dom stage -> m (URhsGuard dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> URhsGuard dom stage -> m (URhsGuard dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> URhsGuard dom stage -> m (URhsGuard dom stage) #

Domain dom => Generic (URhsGuard dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (URhsGuard dom stage) :: * -> * #

Methods

from :: URhsGuard dom stage -> Rep (URhsGuard dom stage) x #

to :: Rep (URhsGuard dom stage) x -> URhsGuard dom stage #

type Rep (URhsGuard dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (URhsGuard dom stage) = D1 (MetaData "URhsGuard" "Language.Haskell.Tools.AST.Representation.Binds" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UGuardBind" PrefixI True) (S1 (MetaSel (Just "_guardPat") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UPattern dom stage)) :*: S1 (MetaSel (Just "_guardRhs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage))) :+: (C1 (MetaCons "UGuardLet" PrefixI True) (S1 (MetaSel (Just "_guardBinds") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG ULocalBind dom stage))) :+: C1 (MetaCons "UGuardCheck" PrefixI True) (S1 (MetaSel (Just "_guardCheck") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage)))))
type IgnoredFields (URhsGuard dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (URhsGuard dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UInlinePragma dom stage Source #

Pragmas that control how the definitions will be inlined

Constructors

UInlinePragma

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

UNoInlinePragma

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

Fields

UInlinablePragma

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

Fields

Instances
SourceInfoTraversal UInlinePragma Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UInlinePragma dom st1 -> f (UInlinePragma dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UInlinePragma dom st1 -> f (UInlinePragma dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UInlinePragma dom st1 -> f (UInlinePragma dom st2) Source #

SemanticTraversal UInlinePragma Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UInlinePragma dom1 st -> f (UInlinePragma dom2 st) Source #

(GoodOperationFor c (UInlinePragma dom stage), ClassyPlate c (AnnMaybeG UConlikeAnnot dom stage), ClassyPlate c (AnnMaybeG UPhaseControl dom stage), ClassyPlate c (Ann UName dom stage), ClassyPlate c (Ann UName dom stage), ClassyPlate c (AnnMaybeG UPhaseControl dom stage), ClassyPlate c (Ann UName dom stage)) => ClassyPlate c (UInlinePragma dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UInlinePragma dom stage -> UInlinePragma dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UInlinePragma dom stage -> m (UInlinePragma dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UInlinePragma dom stage -> UInlinePragma dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UInlinePragma dom stage -> m (UInlinePragma dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UInlinePragma dom stage -> UInlinePragma dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UInlinePragma dom stage -> m (UInlinePragma dom stage) #

(Domain dom, SourceInfo stage) => Data (UInlinePragma dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UInlinePragma dom stage -> c (UInlinePragma dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UInlinePragma dom stage) #

toConstr :: UInlinePragma dom stage -> Constr #

dataTypeOf :: UInlinePragma dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UInlinePragma dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UInlinePragma dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UInlinePragma dom stage -> UInlinePragma dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UInlinePragma dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UInlinePragma dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UInlinePragma dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UInlinePragma dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UInlinePragma dom stage -> m (UInlinePragma dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UInlinePragma dom stage -> m (UInlinePragma dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UInlinePragma dom stage -> m (UInlinePragma dom stage) #

Domain dom => Generic (UInlinePragma dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UInlinePragma dom stage) :: * -> * #

Methods

from :: UInlinePragma dom stage -> Rep (UInlinePragma dom stage) x #

to :: Rep (UInlinePragma dom stage) x -> UInlinePragma dom stage #

type Rep (UInlinePragma dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UInlinePragma dom stage) = D1 (MetaData "UInlinePragma" "Language.Haskell.Tools.AST.Representation.Binds" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UInlinePragma" PrefixI True) (S1 (MetaSel (Just "_inlineConlike") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UConlikeAnnot dom stage)) :*: (S1 (MetaSel (Just "_inlinePhase") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UPhaseControl dom stage)) :*: S1 (MetaSel (Just "_inlineDef") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage)))) :+: (C1 (MetaCons "UNoInlinePragma" PrefixI True) (S1 (MetaSel (Just "_noInlineDef") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage))) :+: C1 (MetaCons "UInlinablePragma" PrefixI True) (S1 (MetaSel (Just "_inlinePhase") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UPhaseControl dom stage)) :*: S1 (MetaSel (Just "_inlinableDef") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage)))))
type IgnoredFields (UInlinePragma dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UInlinePragma dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UConlikeAnnot dom stage Source #

A CONLIKE modifier for an INLINE pragma.

Constructors

UConlikeAnnot 
Instances
SourceInfoTraversal UConlikeAnnot Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UConlikeAnnot dom st1 -> f (UConlikeAnnot dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UConlikeAnnot dom st1 -> f (UConlikeAnnot dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UConlikeAnnot dom st1 -> f (UConlikeAnnot dom st2) Source #

SemanticTraversal UConlikeAnnot Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UConlikeAnnot dom1 st -> f (UConlikeAnnot dom2 st) Source #

GoodOperationFor c (UConlikeAnnot dom stage) => ClassyPlate c (UConlikeAnnot dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UConlikeAnnot dom stage -> UConlikeAnnot dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UConlikeAnnot dom stage -> m (UConlikeAnnot dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UConlikeAnnot dom stage -> UConlikeAnnot dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UConlikeAnnot dom stage -> m (UConlikeAnnot dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UConlikeAnnot dom stage -> UConlikeAnnot dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UConlikeAnnot dom stage -> m (UConlikeAnnot dom stage) #

(Domain dom, SourceInfo stage) => Data (UConlikeAnnot dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UConlikeAnnot dom stage -> c (UConlikeAnnot dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UConlikeAnnot dom stage) #

toConstr :: UConlikeAnnot dom stage -> Constr #

dataTypeOf :: UConlikeAnnot dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UConlikeAnnot dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UConlikeAnnot dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UConlikeAnnot dom stage -> UConlikeAnnot dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UConlikeAnnot dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UConlikeAnnot dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UConlikeAnnot dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UConlikeAnnot dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UConlikeAnnot dom stage -> m (UConlikeAnnot dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UConlikeAnnot dom stage -> m (UConlikeAnnot dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UConlikeAnnot dom stage -> m (UConlikeAnnot dom stage) #

Domain dom => Generic (UConlikeAnnot dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UConlikeAnnot dom stage) :: * -> * #

Methods

from :: UConlikeAnnot dom stage -> Rep (UConlikeAnnot dom stage) x #

to :: Rep (UConlikeAnnot dom stage) x -> UConlikeAnnot dom stage #

type Rep (UConlikeAnnot dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UConlikeAnnot dom stage) = D1 (MetaData "UConlikeAnnot" "Language.Haskell.Tools.AST.Representation.Binds" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UConlikeAnnot" PrefixI False) (U1 :: * -> *))
type IgnoredFields (UConlikeAnnot dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UConlikeAnnot dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UPhaseControl dom stage Source #

Controls the activation of a rewrite rule ( [1] )

Constructors

UPhaseControl 
Instances
SourceInfoTraversal UPhaseControl Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UPhaseControl dom st1 -> f (UPhaseControl dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UPhaseControl dom st1 -> f (UPhaseControl dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UPhaseControl dom st1 -> f (UPhaseControl dom st2) Source #

SemanticTraversal UPhaseControl Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UPhaseControl dom1 st -> f (UPhaseControl dom2 st) Source #

(GoodOperationFor c (UPhaseControl dom stage), ClassyPlate c (AnnMaybeG PhaseInvert dom stage), ClassyPlate c (AnnMaybeG PhaseNumber dom stage)) => ClassyPlate c (UPhaseControl dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UPhaseControl dom stage -> UPhaseControl dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UPhaseControl dom stage -> m (UPhaseControl dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UPhaseControl dom stage -> UPhaseControl dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UPhaseControl dom stage -> m (UPhaseControl dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UPhaseControl dom stage -> UPhaseControl dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UPhaseControl dom stage -> m (UPhaseControl dom stage) #

(Domain dom, SourceInfo stage) => Data (UPhaseControl dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UPhaseControl dom stage -> c (UPhaseControl dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UPhaseControl dom stage) #

toConstr :: UPhaseControl dom stage -> Constr #

dataTypeOf :: UPhaseControl dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UPhaseControl dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UPhaseControl dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UPhaseControl dom stage -> UPhaseControl dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UPhaseControl dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UPhaseControl dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UPhaseControl dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UPhaseControl dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UPhaseControl dom stage -> m (UPhaseControl dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UPhaseControl dom stage -> m (UPhaseControl dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UPhaseControl dom stage -> m (UPhaseControl dom stage) #

Domain dom => Generic (UPhaseControl dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UPhaseControl dom stage) :: * -> * #

Methods

from :: UPhaseControl dom stage -> Rep (UPhaseControl dom stage) x #

to :: Rep (UPhaseControl dom stage) x -> UPhaseControl dom stage #

type Rep (UPhaseControl dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UPhaseControl dom stage) = D1 (MetaData "UPhaseControl" "Language.Haskell.Tools.AST.Representation.Binds" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UPhaseControl" PrefixI True) (S1 (MetaSel (Just "_phaseUntil") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG PhaseInvert dom stage)) :*: S1 (MetaSel (Just "_phaseNumber") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG PhaseNumber dom stage))))
type IgnoredFields (UPhaseControl dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UPhaseControl dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data PhaseNumber dom stage Source #

Phase number for rewrite rules

Constructors

PhaseNumber 

Fields

Instances
SourceInfoTraversal PhaseNumber Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> PhaseNumber dom st1 -> f (PhaseNumber dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> PhaseNumber dom st1 -> f (PhaseNumber dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> PhaseNumber dom st1 -> f (PhaseNumber dom st2) Source #

SemanticTraversal PhaseNumber Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> PhaseNumber dom1 st -> f (PhaseNumber dom2 st) Source #

GoodOperationFor c (PhaseNumber dom stage) => ClassyPlate c (PhaseNumber dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> PhaseNumber dom stage -> PhaseNumber dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> PhaseNumber dom stage -> m (PhaseNumber dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> PhaseNumber dom stage -> PhaseNumber dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> PhaseNumber dom stage -> m (PhaseNumber dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> PhaseNumber dom stage -> PhaseNumber dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> PhaseNumber dom stage -> m (PhaseNumber dom stage) #

(Domain dom, SourceInfo stage) => Data (PhaseNumber dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PhaseNumber dom stage -> c (PhaseNumber dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (PhaseNumber dom stage) #

toConstr :: PhaseNumber dom stage -> Constr #

dataTypeOf :: PhaseNumber dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (PhaseNumber dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (PhaseNumber dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> PhaseNumber dom stage -> PhaseNumber dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PhaseNumber dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PhaseNumber dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> PhaseNumber dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> PhaseNumber dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> PhaseNumber dom stage -> m (PhaseNumber dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PhaseNumber dom stage -> m (PhaseNumber dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PhaseNumber dom stage -> m (PhaseNumber dom stage) #

Domain dom => Generic (PhaseNumber dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (PhaseNumber dom stage) :: * -> * #

Methods

from :: PhaseNumber dom stage -> Rep (PhaseNumber dom stage) x #

to :: Rep (PhaseNumber dom stage) x -> PhaseNumber dom stage #

type Rep (PhaseNumber dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (PhaseNumber dom stage) = D1 (MetaData "PhaseNumber" "Language.Haskell.Tools.AST.Representation.Binds" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "PhaseNumber" PrefixI True) (S1 (MetaSel (Just "_phaseNum") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Integer)))
type IgnoredFields (PhaseNumber dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (PhaseNumber dom stage) = (Right "_phaseNum" :: Either (Symbol, Nat) Symbol) ': ([] :: [Either (Symbol, Nat) Symbol])

data PhaseInvert dom stage Source #

A tilde that marks the inversion of the phase number

Constructors

PhaseInvert 
Instances
SourceInfoTraversal PhaseInvert Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> PhaseInvert dom st1 -> f (PhaseInvert dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> PhaseInvert dom st1 -> f (PhaseInvert dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> PhaseInvert dom st1 -> f (PhaseInvert dom st2) Source #

SemanticTraversal PhaseInvert Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> PhaseInvert dom1 st -> f (PhaseInvert dom2 st) Source #

GoodOperationFor c (PhaseInvert dom stage) => ClassyPlate c (PhaseInvert dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> PhaseInvert dom stage -> PhaseInvert dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> PhaseInvert dom stage -> m (PhaseInvert dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> PhaseInvert dom stage -> PhaseInvert dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> PhaseInvert dom stage -> m (PhaseInvert dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> PhaseInvert dom stage -> PhaseInvert dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> PhaseInvert dom stage -> m (PhaseInvert dom stage) #

(Domain dom, SourceInfo stage) => Data (PhaseInvert dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PhaseInvert dom stage -> c (PhaseInvert dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (PhaseInvert dom stage) #

toConstr :: PhaseInvert dom stage -> Constr #

dataTypeOf :: PhaseInvert dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (PhaseInvert dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (PhaseInvert dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> PhaseInvert dom stage -> PhaseInvert dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PhaseInvert dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PhaseInvert dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> PhaseInvert dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> PhaseInvert dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> PhaseInvert dom stage -> m (PhaseInvert dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PhaseInvert dom stage -> m (PhaseInvert dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PhaseInvert dom stage -> m (PhaseInvert dom stage) #

Domain dom => Generic (PhaseInvert dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (PhaseInvert dom stage) :: * -> * #

Methods

from :: PhaseInvert dom stage -> Rep (PhaseInvert dom stage) x #

to :: Rep (PhaseInvert dom stage) x -> PhaseInvert dom stage #

type Rep (PhaseInvert dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (PhaseInvert dom stage) = D1 (MetaData "PhaseInvert" "Language.Haskell.Tools.AST.Representation.Binds" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "PhaseInvert" PrefixI False) (U1 :: * -> *))
type IgnoredFields (PhaseInvert dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (PhaseInvert dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UExpr dom stage Source #

Haskell expressions

Constructors

UVar

A variable or a data constructor ( a )

Fields

ULit

Literal expression ( 42 )

Fields

UInfixApp

An infix operator application ( a + b )

Fields

UPrefixApp

Prefix operator application ( -x )

Fields

UApp

Function application ( f 4 )

Fields

ULambda

Lambda expression ( a b -> a + b )

Fields

ULet

Local binding ( let x = 2; y = 3 in e x y )

Fields

UIf

If expression ( if a then b else c )

Fields

UMultiIf

Multi way if expressions with MultiWayIf extension ( if | guard1 -> expr1; guard2 -> expr2 )

Fields

UCase

Pattern matching expression ( case expr of pat1 -> expr1; pat2 -> expr2 )

Fields

UDo

Do-notation expressions ( do x <- act1; act2 )

Fields

UTuple

Tuple expression ( (e1, e2, e3) )

Fields

UUnboxedTuple

Unboxed tuple expression ( () )

Fields

UTupleSection

Tuple section, enabled with TupleSections ( (a,,b) ). One of the elements must be missing.

UUnboxedTupSec

Unboxed tuple section enabled with TupleSections ( () ). One of the elements must be missing.

UList

List expression: [1,2,3]

Fields

UParArray

Parallel array expression: [: 1,2,3 :]

Fields

UParen

Parenthesized expression: ( a + b )

Fields

ULeftSection

Left operator section: (1+)

Fields

URightSection

Right operator section: (+1)

Fields

URecCon

Record value construction: Point { x = 3, y = -2 }

Fields

URecUpdate

Record value update: p1 { x = 3, y = -2 }

Fields

UEnum

Enumeration expression ( [1,3..10] )

Fields

UParArrayEnum

Parallel array enumeration ( [: 1,3 .. 10 :] )

Fields

UListComp

List comprehension ( [ (x, y) | x <- xs | y <- ys ] )

Fields

UParArrayComp

Parallel array comprehensions [: (x, y) | x <- xs , y <- ys :] enabled by ParallelArrays

Fields

UTypeSig

Explicit type signature ( x :: Int )

Fields

UExplTypeApp

Explicit type application ( show @Integer (read "5") )

Fields

UVarQuote

'x for template haskell reifying of expressions

Fields

UTypeQuote

''T for template haskell reifying of types

Fields

UBracketExpr

Template haskell bracket expression

Fields

USplice

Template haskell splice expression, for example: $(gen a) or $x

Fields

UQuasiQuoteExpr

Template haskell quasi-quotation: [$quoter|str]

Fields

UExprPragma 

Fields

UProc

Arrow definition: proc a -> f -< a+1

Fields

UArrowApp

Arrow application: f -< a+1

Fields

ULamCase

Lambda case ( case 0 -> 1; 1 -> 2 )

Fields

UStaticPtr

Static pointer expression ( static e ). The inner expression must be closed (cannot have variables bound outside)

Fields

UUnboxedSum

Unboxed sum expression ( () ).

UHole

A hole in the program _, similar to undefined but gives type information. XML expressions omitted

Instances
SourceInfoTraversal UExpr Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UExpr dom st1 -> f (UExpr dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UExpr dom st1 -> f (UExpr dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UExpr dom st1 -> f (UExpr dom st2) Source #

SemanticTraversal UExpr Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UExpr dom1 st -> f (UExpr dom2 st) Source #

(GoodOperationFor c (UExpr dom stage), ClassyPlate c (Ann UName dom stage), ClassyPlate c (Ann ULiteral dom stage), ClassyPlate c (Ann UExpr dom stage), ClassyPlate c (Ann UOperator dom stage), ClassyPlate c (Ann UExpr dom stage), ClassyPlate c (Ann UOperator dom stage), ClassyPlate c (Ann UExpr dom stage), ClassyPlate c (Ann UExpr dom stage), ClassyPlate c (Ann UExpr dom stage), ClassyPlate c (AnnListG UPattern dom stage), ClassyPlate c (Ann UExpr dom stage), ClassyPlate c (AnnListG ULocalBind dom stage), ClassyPlate c (Ann UExpr dom stage), ClassyPlate c (Ann UExpr dom stage), ClassyPlate c (Ann UExpr dom stage), ClassyPlate c (Ann UExpr dom stage), ClassyPlate c (AnnListG UGuardedCaseRhs dom stage), ClassyPlate c (Ann UExpr dom stage), ClassyPlate c (AnnListG UAlt dom stage), ClassyPlate c (Ann UDoKind dom stage), ClassyPlate c (AnnListG UStmt dom stage), ClassyPlate c (AnnListG UExpr dom stage), ClassyPlate c (AnnListG UExpr dom stage), ClassyPlate c (AnnListG UTupSecElem dom stage), ClassyPlate c (AnnListG UTupSecElem dom stage), ClassyPlate c (AnnListG UExpr dom stage), ClassyPlate c (AnnListG UExpr dom stage), ClassyPlate c (Ann UExpr dom stage), ClassyPlate c (Ann UExpr dom stage), ClassyPlate c (Ann UOperator dom stage), ClassyPlate c (Ann UOperator dom stage), ClassyPlate c (Ann UExpr dom stage), ClassyPlate c (Ann UName dom stage), ClassyPlate c (AnnListG UFieldUpdate dom stage), ClassyPlate c (Ann UExpr dom stage), ClassyPlate c (AnnListG UFieldUpdate dom stage), ClassyPlate c (Ann UExpr dom stage), ClassyPlate c (AnnMaybeG UExpr dom stage), ClassyPlate c (AnnMaybeG UExpr dom stage), ClassyPlate c (Ann UExpr dom stage), ClassyPlate c (AnnMaybeG UExpr dom stage), ClassyPlate c (Ann UExpr dom stage), ClassyPlate c (Ann UExpr dom stage), ClassyPlate c (AnnListG UListCompBody dom stage), ClassyPlate c (Ann UExpr dom stage), ClassyPlate c (AnnListG UListCompBody dom stage), ClassyPlate c (Ann UExpr dom stage), ClassyPlate c (Ann UType dom stage), ClassyPlate c (Ann UExpr dom stage), ClassyPlate c (Ann UType dom stage), ClassyPlate c (Ann UName dom stage), ClassyPlate c (Ann UName dom stage), ClassyPlate c (Ann UBracket dom stage), ClassyPlate c (Ann USplice dom stage), ClassyPlate c (Ann UQuasiQuote dom stage), ClassyPlate c (Ann UExprPragma dom stage), ClassyPlate c (Ann UExpr dom stage), ClassyPlate c (Ann UPattern dom stage), ClassyPlate c (Ann UCmd dom stage), ClassyPlate c (Ann UExpr dom stage), ClassyPlate c (Ann UArrowAppl dom stage), ClassyPlate c (Ann UExpr dom stage), ClassyPlate c (AnnListG UAlt dom stage), ClassyPlate c (Ann UExpr dom stage), ClassyPlate c (AnnListG UUnboxedSumPlaceHolder dom stage), ClassyPlate c (Ann UExpr dom stage), ClassyPlate c (AnnListG UUnboxedSumPlaceHolder dom stage)) => ClassyPlate c (UExpr dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UExpr dom stage -> UExpr dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UExpr dom stage -> m (UExpr dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UExpr dom stage -> UExpr dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UExpr dom stage -> m (UExpr dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UExpr dom stage -> UExpr dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UExpr dom stage -> m (UExpr dom stage) #

(Domain dom, SourceInfo stage) => Data (UExpr dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UExpr dom stage -> c (UExpr dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UExpr dom stage) #

toConstr :: UExpr dom stage -> Constr #

dataTypeOf :: UExpr dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UExpr dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UExpr dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UExpr dom stage -> UExpr dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UExpr dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UExpr dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UExpr dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UExpr dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UExpr dom stage -> m (UExpr dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UExpr dom stage -> m (UExpr dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UExpr dom stage -> m (UExpr dom stage) #

Domain dom => Generic (UExpr dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UExpr dom stage) :: * -> * #

Methods

from :: UExpr dom stage -> Rep (UExpr dom stage) x #

to :: Rep (UExpr dom stage) x -> UExpr dom stage #

HasScopeInfo dom => HasScopeInfo' (Ann UExpr dom st) Source # 
Instance details

Defined in Language.Haskell.Tools.AST.SemaInfoClasses

Methods

semanticsScope :: Ann UExpr dom st -> Scope Source #

type Rep (UExpr dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UExpr dom stage) = D1 (MetaData "UExpr" "Language.Haskell.Tools.AST.Representation.Exprs" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (((((C1 (MetaCons "UVar" PrefixI True) (S1 (MetaSel (Just "_exprName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage))) :+: C1 (MetaCons "ULit" PrefixI True) (S1 (MetaSel (Just "_exprLit") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann ULiteral dom stage)))) :+: (C1 (MetaCons "UInfixApp" PrefixI True) (S1 (MetaSel (Just "_exprLhs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage)) :*: (S1 (MetaSel (Just "_exprOperator") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UOperator dom stage)) :*: S1 (MetaSel (Just "_exprRhs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage)))) :+: (C1 (MetaCons "UPrefixApp" PrefixI True) (S1 (MetaSel (Just "_exprOperator") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UOperator dom stage)) :*: S1 (MetaSel (Just "_exprRhs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage))) :+: C1 (MetaCons "UApp" PrefixI True) (S1 (MetaSel (Just "_exprFun") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage)) :*: S1 (MetaSel (Just "_exprArg") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage)))))) :+: ((C1 (MetaCons "ULambda" PrefixI True) (S1 (MetaSel (Just "_exprBindings") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UPattern dom stage)) :*: S1 (MetaSel (Just "_exprInner") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage))) :+: C1 (MetaCons "ULet" PrefixI True) (S1 (MetaSel (Just "_exprFunBind") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG ULocalBind dom stage)) :*: S1 (MetaSel (Just "_exprInner") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage)))) :+: (C1 (MetaCons "UIf" PrefixI True) (S1 (MetaSel (Just "_exprCond") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage)) :*: (S1 (MetaSel (Just "_exprThen") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage)) :*: S1 (MetaSel (Just "_exprElse") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage)))) :+: (C1 (MetaCons "UMultiIf" PrefixI True) (S1 (MetaSel (Just "_exprIfAlts") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UGuardedCaseRhs dom stage))) :+: C1 (MetaCons "UCase" PrefixI True) (S1 (MetaSel (Just "_exprCase") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage)) :*: S1 (MetaSel (Just "_exprAlts") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UAlt dom stage))))))) :+: (((C1 (MetaCons "UDo" PrefixI True) (S1 (MetaSel (Just "_doKind") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UDoKind dom stage)) :*: S1 (MetaSel (Just "_exprStmts") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UStmt dom stage))) :+: C1 (MetaCons "UTuple" PrefixI True) (S1 (MetaSel (Just "_tupleElems") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UExpr dom stage)))) :+: (C1 (MetaCons "UUnboxedTuple" PrefixI True) (S1 (MetaSel (Just "_tupleElems") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UExpr dom stage))) :+: (C1 (MetaCons "UTupleSection" PrefixI True) (S1 (MetaSel (Just "_tupleSectionElems") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UTupSecElem dom stage))) :+: C1 (MetaCons "UUnboxedTupSec" PrefixI True) (S1 (MetaSel (Just "_tupleSectionElems") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UTupSecElem dom stage)))))) :+: ((C1 (MetaCons "UList" PrefixI True) (S1 (MetaSel (Just "_listElems") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UExpr dom stage))) :+: C1 (MetaCons "UParArray" PrefixI True) (S1 (MetaSel (Just "_listElems") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UExpr dom stage)))) :+: (C1 (MetaCons "UParen" PrefixI True) (S1 (MetaSel (Just "_exprInner") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage))) :+: (C1 (MetaCons "ULeftSection" PrefixI True) (S1 (MetaSel (Just "_exprLhs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage)) :*: S1 (MetaSel (Just "_exprOperator") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UOperator dom stage))) :+: C1 (MetaCons "URightSection" PrefixI True) (S1 (MetaSel (Just "_exprOperator") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UOperator dom stage)) :*: S1 (MetaSel (Just "_exprRhs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage)))))))) :+: ((((C1 (MetaCons "URecCon" PrefixI True) (S1 (MetaSel (Just "_exprRecName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage)) :*: S1 (MetaSel (Just "_exprRecFields") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UFieldUpdate dom stage))) :+: C1 (MetaCons "URecUpdate" PrefixI True) (S1 (MetaSel (Just "_exprInner") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage)) :*: S1 (MetaSel (Just "_exprRecFields") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UFieldUpdate dom stage)))) :+: (C1 (MetaCons "UEnum" PrefixI True) (S1 (MetaSel (Just "_enumFrom") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage)) :*: (S1 (MetaSel (Just "_enumThen") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UExpr dom stage)) :*: S1 (MetaSel (Just "_enumTo") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UExpr dom stage)))) :+: (C1 (MetaCons "UParArrayEnum" PrefixI True) (S1 (MetaSel (Just "_enumFrom") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage)) :*: (S1 (MetaSel (Just "_enumThen") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UExpr dom stage)) :*: S1 (MetaSel (Just "_enumToFix") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage)))) :+: C1 (MetaCons "UListComp" PrefixI True) (S1 (MetaSel (Just "_compExpr") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage)) :*: S1 (MetaSel (Just "_compBody") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UListCompBody dom stage)))))) :+: ((C1 (MetaCons "UParArrayComp" PrefixI True) (S1 (MetaSel (Just "_compExpr") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage)) :*: S1 (MetaSel (Just "_compBody") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UListCompBody dom stage))) :+: C1 (MetaCons "UTypeSig" PrefixI True) (S1 (MetaSel (Just "_exprInner") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage)) :*: S1 (MetaSel (Just "_exprSig") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UType dom stage)))) :+: (C1 (MetaCons "UExplTypeApp" PrefixI True) (S1 (MetaSel (Just "_exprInner") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage)) :*: S1 (MetaSel (Just "_exprType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UType dom stage))) :+: (C1 (MetaCons "UVarQuote" PrefixI True) (S1 (MetaSel (Just "_quotedName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage))) :+: C1 (MetaCons "UTypeQuote" PrefixI True) (S1 (MetaSel (Just "_quotedName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage))))))) :+: (((C1 (MetaCons "UBracketExpr" PrefixI True) (S1 (MetaSel (Just "_exprBracket") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UBracket dom stage))) :+: C1 (MetaCons "USplice" PrefixI True) (S1 (MetaSel (Just "_exprSplice") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann USplice dom stage)))) :+: (C1 (MetaCons "UQuasiQuoteExpr" PrefixI True) (S1 (MetaSel (Just "_exprQQ") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UQuasiQuote dom stage))) :+: (C1 (MetaCons "UExprPragma" PrefixI True) (S1 (MetaSel (Just "_exprPragma") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExprPragma dom stage)) :*: S1 (MetaSel (Just "_innerExpr") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage))) :+: C1 (MetaCons "UProc" PrefixI True) (S1 (MetaSel (Just "_procPattern") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UPattern dom stage)) :*: S1 (MetaSel (Just "_procExpr") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UCmd dom stage)))))) :+: ((C1 (MetaCons "UArrowApp" PrefixI True) (S1 (MetaSel (Just "_exprLhs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage)) :*: (S1 (MetaSel (Just "_arrowAppl") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UArrowAppl dom stage)) :*: S1 (MetaSel (Just "_exprRhs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage)))) :+: C1 (MetaCons "ULamCase" PrefixI True) (S1 (MetaSel (Just "_exprAlts") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UAlt dom stage)))) :+: (C1 (MetaCons "UStaticPtr" PrefixI True) (S1 (MetaSel (Just "_exprInner") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage))) :+: (C1 (MetaCons "UUnboxedSum" PrefixI True) (S1 (MetaSel (Just "_exprSumPlaceholdersBefore") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UUnboxedSumPlaceHolder dom stage)) :*: (S1 (MetaSel (Just "_exprInner") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage)) :*: S1 (MetaSel (Just "_exprSumPlaceholdersAfter") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UUnboxedSumPlaceHolder dom stage)))) :+: C1 (MetaCons "UHole" PrefixI False) (U1 :: * -> *)))))))
type IgnoredFields (UExpr dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UExpr dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UFieldUpdate dom stage Source #

Field update expressions

Constructors

UNormalFieldUpdate

Update of a field ( x = 1 )

Fields

UFieldPun

Update the field to the value of the same name ( x )

Fields

UFieldWildcard

Update the fields of the bounded names to their values ( .. ). Must be the last initializer. Cannot be used in a record update expression.

Fields

Instances
SourceInfoTraversal UFieldUpdate Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UFieldUpdate dom st1 -> f (UFieldUpdate dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UFieldUpdate dom st1 -> f (UFieldUpdate dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UFieldUpdate dom st1 -> f (UFieldUpdate dom st2) Source #

SemanticTraversal UFieldUpdate Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UFieldUpdate dom1 st -> f (UFieldUpdate dom2 st) Source #

(GoodOperationFor c (UFieldUpdate dom stage), ClassyPlate c (Ann UName dom stage), ClassyPlate c (Ann UExpr dom stage), ClassyPlate c (Ann UName dom stage), ClassyPlate c (Ann UFieldWildcard dom stage)) => ClassyPlate c (UFieldUpdate dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UFieldUpdate dom stage -> UFieldUpdate dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UFieldUpdate dom stage -> m (UFieldUpdate dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UFieldUpdate dom stage -> UFieldUpdate dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UFieldUpdate dom stage -> m (UFieldUpdate dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UFieldUpdate dom stage -> UFieldUpdate dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UFieldUpdate dom stage -> m (UFieldUpdate dom stage) #

(Domain dom, SourceInfo stage) => Data (UFieldUpdate dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UFieldUpdate dom stage -> c (UFieldUpdate dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UFieldUpdate dom stage) #

toConstr :: UFieldUpdate dom stage -> Constr #

dataTypeOf :: UFieldUpdate dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UFieldUpdate dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UFieldUpdate dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UFieldUpdate dom stage -> UFieldUpdate dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UFieldUpdate dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UFieldUpdate dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UFieldUpdate dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UFieldUpdate dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UFieldUpdate dom stage -> m (UFieldUpdate dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UFieldUpdate dom stage -> m (UFieldUpdate dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UFieldUpdate dom stage -> m (UFieldUpdate dom stage) #

Domain dom => Generic (UFieldUpdate dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UFieldUpdate dom stage) :: * -> * #

Methods

from :: UFieldUpdate dom stage -> Rep (UFieldUpdate dom stage) x #

to :: Rep (UFieldUpdate dom stage) x -> UFieldUpdate dom stage #

type Rep (UFieldUpdate dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UFieldUpdate dom stage) = D1 (MetaData "UFieldUpdate" "Language.Haskell.Tools.AST.Representation.Exprs" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UNormalFieldUpdate" PrefixI True) (S1 (MetaSel (Just "_fieldName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage)) :*: S1 (MetaSel (Just "_fieldValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage))) :+: (C1 (MetaCons "UFieldPun" PrefixI True) (S1 (MetaSel (Just "_fieldUpdateName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage))) :+: C1 (MetaCons "UFieldWildcard" PrefixI True) (S1 (MetaSel (Just "_fieldWildcard") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UFieldWildcard dom stage)))))
type IgnoredFields (UFieldUpdate dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UFieldUpdate dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UFieldWildcard dom stage Source #

Marker for a field wildcard. Only needed to attach semantic information in a type-safe way.

Constructors

FldWildcard 
Instances
SourceInfoTraversal UFieldWildcard Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UFieldWildcard dom st1 -> f (UFieldWildcard dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UFieldWildcard dom st1 -> f (UFieldWildcard dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UFieldWildcard dom st1 -> f (UFieldWildcard dom st2) Source #

SemanticTraversal UFieldWildcard Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UFieldWildcard dom1 st -> f (UFieldWildcard dom2 st) Source #

GoodOperationFor c (UFieldWildcard dom stage) => ClassyPlate c (UFieldWildcard dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UFieldWildcard dom stage -> UFieldWildcard dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UFieldWildcard dom stage -> m (UFieldWildcard dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UFieldWildcard dom stage -> UFieldWildcard dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UFieldWildcard dom stage -> m (UFieldWildcard dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UFieldWildcard dom stage -> UFieldWildcard dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UFieldWildcard dom stage -> m (UFieldWildcard dom stage) #

(Domain dom, SourceInfo stage) => Data (UFieldWildcard dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UFieldWildcard dom stage -> c (UFieldWildcard dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UFieldWildcard dom stage) #

toConstr :: UFieldWildcard dom stage -> Constr #

dataTypeOf :: UFieldWildcard dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UFieldWildcard dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UFieldWildcard dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UFieldWildcard dom stage -> UFieldWildcard dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UFieldWildcard dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UFieldWildcard dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UFieldWildcard dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UFieldWildcard dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UFieldWildcard dom stage -> m (UFieldWildcard dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UFieldWildcard dom stage -> m (UFieldWildcard dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UFieldWildcard dom stage -> m (UFieldWildcard dom stage) #

Domain dom => Generic (UFieldWildcard dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UFieldWildcard dom stage) :: * -> * #

Methods

from :: UFieldWildcard dom stage -> Rep (UFieldWildcard dom stage) x #

to :: Rep (UFieldWildcard dom stage) x -> UFieldWildcard dom stage #

HasImplicitFieldsInfo dom => HasImplicitFieldsInfo' (Ann UFieldWildcard dom st) Source # 
Instance details

Defined in Language.Haskell.Tools.AST.SemaInfoClasses

type Rep (UFieldWildcard dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UFieldWildcard dom stage) = D1 (MetaData "UFieldWildcard" "Language.Haskell.Tools.AST.Representation.Exprs" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "FldWildcard" PrefixI False) (U1 :: * -> *))
type IgnoredFields (UFieldWildcard dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UFieldWildcard dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UTupSecElem dom stage Source #

An element of a tuple section that can be an expression or missing (indicating a value from a parameter)

Constructors

Present

An existing element in a tuple section

Fields

Missing

A missing element in a tuple section

Instances
SourceInfoTraversal UTupSecElem Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UTupSecElem dom st1 -> f (UTupSecElem dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UTupSecElem dom st1 -> f (UTupSecElem dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UTupSecElem dom st1 -> f (UTupSecElem dom st2) Source #

SemanticTraversal UTupSecElem Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UTupSecElem dom1 st -> f (UTupSecElem dom2 st) Source #

(GoodOperationFor c (UTupSecElem dom stage), ClassyPlate c (Ann UExpr dom stage)) => ClassyPlate c (UTupSecElem dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UTupSecElem dom stage -> UTupSecElem dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UTupSecElem dom stage -> m (UTupSecElem dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UTupSecElem dom stage -> UTupSecElem dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UTupSecElem dom stage -> m (UTupSecElem dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UTupSecElem dom stage -> UTupSecElem dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UTupSecElem dom stage -> m (UTupSecElem dom stage) #

(Domain dom, SourceInfo stage) => Data (UTupSecElem dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UTupSecElem dom stage -> c (UTupSecElem dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UTupSecElem dom stage) #

toConstr :: UTupSecElem dom stage -> Constr #

dataTypeOf :: UTupSecElem dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UTupSecElem dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UTupSecElem dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UTupSecElem dom stage -> UTupSecElem dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UTupSecElem dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UTupSecElem dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UTupSecElem dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UTupSecElem dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UTupSecElem dom stage -> m (UTupSecElem dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UTupSecElem dom stage -> m (UTupSecElem dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UTupSecElem dom stage -> m (UTupSecElem dom stage) #

Domain dom => Generic (UTupSecElem dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UTupSecElem dom stage) :: * -> * #

Methods

from :: UTupSecElem dom stage -> Rep (UTupSecElem dom stage) x #

to :: Rep (UTupSecElem dom stage) x -> UTupSecElem dom stage #

type Rep (UTupSecElem dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UTupSecElem dom stage) = D1 (MetaData "UTupSecElem" "Language.Haskell.Tools.AST.Representation.Exprs" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "Present" PrefixI True) (S1 (MetaSel (Just "_tupSecExpr") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage))) :+: C1 (MetaCons "Missing" PrefixI False) (U1 :: * -> *))
type IgnoredFields (UTupSecElem dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UTupSecElem dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UAlt' expr dom stage Source #

Clause of case expression ( Just x -> x + 1 )

Constructors

UAlt 

Fields

Instances
(GoodOperationFor c (UAlt' expr dom stage), ClassyPlate c (Ann UPattern dom stage), ClassyPlate c (Ann (UCaseRhs' expr) dom stage), ClassyPlate c (AnnMaybeG ULocalBinds dom stage)) => ClassyPlate c (UAlt' expr dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UAlt' expr dom stage -> UAlt' expr dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UAlt' expr dom stage -> m (UAlt' expr dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UAlt' expr dom stage -> UAlt' expr dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UAlt' expr dom stage -> m (UAlt' expr dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UAlt' expr dom stage -> UAlt' expr dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UAlt' expr dom stage -> m (UAlt' expr dom stage) #

SourceInfoTraversal expr => SourceInfoTraversal (UAlt' expr) Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UAlt' expr dom st1 -> f (UAlt' expr dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UAlt' expr dom st1 -> f (UAlt' expr dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UAlt' expr dom st1 -> f (UAlt' expr dom st2) Source #

SemanticTraversal expr => SemanticTraversal (UAlt' expr) Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UAlt' expr dom1 st -> f (UAlt' expr dom2 st) Source #

(DomainWith expr dom, SourceInfo stage, Typeable expr, Data (expr dom stage)) => Data (UAlt' expr dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UAlt' expr dom stage -> c (UAlt' expr dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UAlt' expr dom stage) #

toConstr :: UAlt' expr dom stage -> Constr #

dataTypeOf :: UAlt' expr dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UAlt' expr dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UAlt' expr dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UAlt' expr dom stage -> UAlt' expr dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UAlt' expr dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UAlt' expr dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UAlt' expr dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UAlt' expr dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UAlt' expr dom stage -> m (UAlt' expr dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UAlt' expr dom stage -> m (UAlt' expr dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UAlt' expr dom stage -> m (UAlt' expr dom stage) #

Domain dom => Generic (UAlt' expr dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UAlt' expr dom stage) :: * -> * #

Methods

from :: UAlt' expr dom stage -> Rep (UAlt' expr dom stage) x #

to :: Rep (UAlt' expr dom stage) x -> UAlt' expr dom stage #

type Rep (UAlt' expr dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UAlt' expr dom stage) = D1 (MetaData "UAlt'" "Language.Haskell.Tools.AST.Representation.Exprs" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UAlt" PrefixI True) (S1 (MetaSel (Just "_altPattern") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UPattern dom stage)) :*: (S1 (MetaSel (Just "_altRhs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann (UCaseRhs' expr) dom stage)) :*: S1 (MetaSel (Just "_altBinds") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG ULocalBinds dom stage)))))
type IgnoredFields (UAlt' expr dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UAlt' expr dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UCaseRhs' expr dom stage Source #

Right hand side of a match (possible with guards): ( -> 3 or | x == 1 -> 3; | otherwise -> 4 )

Constructors

UUnguardedCaseRhs

Unguarded right-hand side a pattern match ( -> 3 )

Fields

UGuardedCaseRhss

Guarded right-hand sides of a pattern match ( | x == 1 -> 3; | otherwise -> 4 )

Fields

Instances
(GoodOperationFor c (UCaseRhs' expr dom stage), ClassyPlate c (Ann expr dom stage), ClassyPlate c (AnnListG (UGuardedCaseRhs' expr) dom stage)) => ClassyPlate c (UCaseRhs' expr dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UCaseRhs' expr dom stage -> UCaseRhs' expr dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UCaseRhs' expr dom stage -> m (UCaseRhs' expr dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UCaseRhs' expr dom stage -> UCaseRhs' expr dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UCaseRhs' expr dom stage -> m (UCaseRhs' expr dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UCaseRhs' expr dom stage -> UCaseRhs' expr dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UCaseRhs' expr dom stage -> m (UCaseRhs' expr dom stage) #

SourceInfoTraversal expr => SourceInfoTraversal (UCaseRhs' expr) Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UCaseRhs' expr dom st1 -> f (UCaseRhs' expr dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UCaseRhs' expr dom st1 -> f (UCaseRhs' expr dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UCaseRhs' expr dom st1 -> f (UCaseRhs' expr dom st2) Source #

SemanticTraversal expr => SemanticTraversal (UCaseRhs' expr) Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UCaseRhs' expr dom1 st -> f (UCaseRhs' expr dom2 st) Source #

(DomainWith expr dom, SourceInfo stage, Typeable expr, Data (expr dom stage)) => Data (UCaseRhs' expr dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UCaseRhs' expr dom stage -> c (UCaseRhs' expr dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UCaseRhs' expr dom stage) #

toConstr :: UCaseRhs' expr dom stage -> Constr #

dataTypeOf :: UCaseRhs' expr dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UCaseRhs' expr dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UCaseRhs' expr dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UCaseRhs' expr dom stage -> UCaseRhs' expr dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UCaseRhs' expr dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UCaseRhs' expr dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UCaseRhs' expr dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UCaseRhs' expr dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UCaseRhs' expr dom stage -> m (UCaseRhs' expr dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UCaseRhs' expr dom stage -> m (UCaseRhs' expr dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UCaseRhs' expr dom stage -> m (UCaseRhs' expr dom stage) #

Domain dom => Generic (UCaseRhs' expr dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UCaseRhs' expr dom stage) :: * -> * #

Methods

from :: UCaseRhs' expr dom stage -> Rep (UCaseRhs' expr dom stage) x #

to :: Rep (UCaseRhs' expr dom stage) x -> UCaseRhs' expr dom stage #

type Rep (UCaseRhs' expr dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UCaseRhs' expr dom stage) = D1 (MetaData "UCaseRhs'" "Language.Haskell.Tools.AST.Representation.Exprs" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UUnguardedCaseRhs" PrefixI True) (S1 (MetaSel (Just "_rhsCaseExpr") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann expr dom stage))) :+: C1 (MetaCons "UGuardedCaseRhss" PrefixI True) (S1 (MetaSel (Just "_rhsCaseGuards") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG (UGuardedCaseRhs' expr) dom stage))))
type IgnoredFields (UCaseRhs' expr dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UCaseRhs' expr dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UGuardedCaseRhs' expr dom stage Source #

A guarded right-hand side of pattern matches binding ( | x > 3 -> 2 )

Constructors

UGuardedCaseRhs 

Fields

Instances
(GoodOperationFor c (UGuardedCaseRhs' expr dom stage), ClassyPlate c (AnnListG URhsGuard dom stage), ClassyPlate c (Ann expr dom stage)) => ClassyPlate c (UGuardedCaseRhs' expr dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UGuardedCaseRhs' expr dom stage -> UGuardedCaseRhs' expr dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UGuardedCaseRhs' expr dom stage -> m (UGuardedCaseRhs' expr dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UGuardedCaseRhs' expr dom stage -> UGuardedCaseRhs' expr dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UGuardedCaseRhs' expr dom stage -> m (UGuardedCaseRhs' expr dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UGuardedCaseRhs' expr dom stage -> UGuardedCaseRhs' expr dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UGuardedCaseRhs' expr dom stage -> m (UGuardedCaseRhs' expr dom stage) #

SourceInfoTraversal expr => SourceInfoTraversal (UGuardedCaseRhs' expr) Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UGuardedCaseRhs' expr dom st1 -> f (UGuardedCaseRhs' expr dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UGuardedCaseRhs' expr dom st1 -> f (UGuardedCaseRhs' expr dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UGuardedCaseRhs' expr dom st1 -> f (UGuardedCaseRhs' expr dom st2) Source #

SemanticTraversal expr => SemanticTraversal (UGuardedCaseRhs' expr) Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UGuardedCaseRhs' expr dom1 st -> f (UGuardedCaseRhs' expr dom2 st) Source #

(DomainWith expr dom, SourceInfo stage, Typeable expr, Data (expr dom stage)) => Data (UGuardedCaseRhs' expr dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UGuardedCaseRhs' expr dom stage -> c (UGuardedCaseRhs' expr dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UGuardedCaseRhs' expr dom stage) #

toConstr :: UGuardedCaseRhs' expr dom stage -> Constr #

dataTypeOf :: UGuardedCaseRhs' expr dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UGuardedCaseRhs' expr dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UGuardedCaseRhs' expr dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UGuardedCaseRhs' expr dom stage -> UGuardedCaseRhs' expr dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UGuardedCaseRhs' expr dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UGuardedCaseRhs' expr dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UGuardedCaseRhs' expr dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UGuardedCaseRhs' expr dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UGuardedCaseRhs' expr dom stage -> m (UGuardedCaseRhs' expr dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UGuardedCaseRhs' expr dom stage -> m (UGuardedCaseRhs' expr dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UGuardedCaseRhs' expr dom stage -> m (UGuardedCaseRhs' expr dom stage) #

Domain dom => Generic (UGuardedCaseRhs' expr dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UGuardedCaseRhs' expr dom stage) :: * -> * #

Methods

from :: UGuardedCaseRhs' expr dom stage -> Rep (UGuardedCaseRhs' expr dom stage) x #

to :: Rep (UGuardedCaseRhs' expr dom stage) x -> UGuardedCaseRhs' expr dom stage #

type Rep (UGuardedCaseRhs' expr dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UGuardedCaseRhs' expr dom stage) = D1 (MetaData "UGuardedCaseRhs'" "Language.Haskell.Tools.AST.Representation.Exprs" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UGuardedCaseRhs" PrefixI True) (S1 (MetaSel (Just "_caseGuardStmts") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG URhsGuard dom stage)) :*: S1 (MetaSel (Just "_caseGuardExpr") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann expr dom stage))))
type IgnoredFields (UGuardedCaseRhs' expr dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UGuardedCaseRhs' expr dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UExprPragma dom stage Source #

Pragmas that can be applied to expressions

Constructors

UCorePragma

A CORE pragma for adding notes to expressions.

Fields

USccPragma

An SCC pragma for defining cost centers for profiling

Fields

UGeneratedPragma

A pragma that describes if an expression was generated from a code fragment by an external tool ( {--} )

Fields

Instances
SourceInfoTraversal UExprPragma Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UExprPragma dom st1 -> f (UExprPragma dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UExprPragma dom st1 -> f (UExprPragma dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UExprPragma dom st1 -> f (UExprPragma dom st2) Source #

SemanticTraversal UExprPragma Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UExprPragma dom1 st -> f (UExprPragma dom2 st) Source #

(GoodOperationFor c (UExprPragma dom stage), ClassyPlate c (Ann UStringNode dom stage), ClassyPlate c (Ann UStringNode dom stage), ClassyPlate c (Ann USourceRange dom stage)) => ClassyPlate c (UExprPragma dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UExprPragma dom stage -> UExprPragma dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UExprPragma dom stage -> m (UExprPragma dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UExprPragma dom stage -> UExprPragma dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UExprPragma dom stage -> m (UExprPragma dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UExprPragma dom stage -> UExprPragma dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UExprPragma dom stage -> m (UExprPragma dom stage) #

(Domain dom, SourceInfo stage) => Data (UExprPragma dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UExprPragma dom stage -> c (UExprPragma dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UExprPragma dom stage) #

toConstr :: UExprPragma dom stage -> Constr #

dataTypeOf :: UExprPragma dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UExprPragma dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UExprPragma dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UExprPragma dom stage -> UExprPragma dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UExprPragma dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UExprPragma dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UExprPragma dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UExprPragma dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UExprPragma dom stage -> m (UExprPragma dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UExprPragma dom stage -> m (UExprPragma dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UExprPragma dom stage -> m (UExprPragma dom stage) #

Domain dom => Generic (UExprPragma dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UExprPragma dom stage) :: * -> * #

Methods

from :: UExprPragma dom stage -> Rep (UExprPragma dom stage) x #

to :: Rep (UExprPragma dom stage) x -> UExprPragma dom stage #

type Rep (UExprPragma dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UExprPragma dom stage) = D1 (MetaData "UExprPragma" "Language.Haskell.Tools.AST.Representation.Exprs" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UCorePragma" PrefixI True) (S1 (MetaSel (Just "_pragmaStr") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UStringNode dom stage))) :+: (C1 (MetaCons "USccPragma" PrefixI True) (S1 (MetaSel (Just "_pragmaStr") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UStringNode dom stage))) :+: C1 (MetaCons "UGeneratedPragma" PrefixI True) (S1 (MetaSel (Just "_pragmaSrcRange") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann USourceRange dom stage)))))
type IgnoredFields (UExprPragma dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UExprPragma dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data USourceRange dom stage Source #

In-AST source ranges (for generated pragmas)

Constructors

USourceRange 

Fields

Instances
SourceInfoTraversal USourceRange Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> USourceRange dom st1 -> f (USourceRange dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> USourceRange dom st1 -> f (USourceRange dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> USourceRange dom st1 -> f (USourceRange dom st2) Source #

SemanticTraversal USourceRange Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> USourceRange dom1 st -> f (USourceRange dom2 st) Source #

(GoodOperationFor c (USourceRange dom stage), ClassyPlate c (Ann UStringNode dom stage), ClassyPlate c (Ann Number dom stage), ClassyPlate c (Ann Number dom stage), ClassyPlate c (Ann Number dom stage), ClassyPlate c (Ann Number dom stage)) => ClassyPlate c (USourceRange dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> USourceRange dom stage -> USourceRange dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> USourceRange dom stage -> m (USourceRange dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> USourceRange dom stage -> USourceRange dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> USourceRange dom stage -> m (USourceRange dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> USourceRange dom stage -> USourceRange dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> USourceRange dom stage -> m (USourceRange dom stage) #

(Domain dom, SourceInfo stage) => Data (USourceRange dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> USourceRange dom stage -> c (USourceRange dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (USourceRange dom stage) #

toConstr :: USourceRange dom stage -> Constr #

dataTypeOf :: USourceRange dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (USourceRange dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (USourceRange dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> USourceRange dom stage -> USourceRange dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> USourceRange dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> USourceRange dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> USourceRange dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> USourceRange dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> USourceRange dom stage -> m (USourceRange dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> USourceRange dom stage -> m (USourceRange dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> USourceRange dom stage -> m (USourceRange dom stage) #

Domain dom => Generic (USourceRange dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (USourceRange dom stage) :: * -> * #

Methods

from :: USourceRange dom stage -> Rep (USourceRange dom stage) x #

to :: Rep (USourceRange dom stage) x -> USourceRange dom stage #

type Rep (USourceRange dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (USourceRange dom stage) = D1 (MetaData "USourceRange" "Language.Haskell.Tools.AST.Representation.Exprs" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "USourceRange" PrefixI True) ((S1 (MetaSel (Just "_srFileName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UStringNode dom stage)) :*: S1 (MetaSel (Just "_srFromLine") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann Number dom stage))) :*: (S1 (MetaSel (Just "_srFromCol") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann Number dom stage)) :*: (S1 (MetaSel (Just "_srToLine") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann Number dom stage)) :*: S1 (MetaSel (Just "_srToCol") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann Number dom stage))))))
type IgnoredFields (USourceRange dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (USourceRange dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data Number dom stage Source #

Constructors

Number 
Instances
SourceInfoTraversal Number Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> Number dom st1 -> f (Number dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> Number dom st1 -> f (Number dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> Number dom st1 -> f (Number dom st2) Source #

SemanticTraversal Number Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> Number dom1 st -> f (Number dom2 st) Source #

GoodOperationFor c (Number dom stage) => ClassyPlate c (Number dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> Number dom stage -> Number dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> Number dom stage -> m (Number dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> Number dom stage -> Number dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> Number dom stage -> m (Number dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> Number dom stage -> Number dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> Number dom stage -> m (Number dom stage) #

(Domain dom, SourceInfo stage) => Data (Number dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Number dom stage -> c (Number dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Number dom stage) #

toConstr :: Number dom stage -> Constr #

dataTypeOf :: Number dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Number dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Number dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> Number dom stage -> Number dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Number dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Number dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> Number dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Number dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Number dom stage -> m (Number dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Number dom stage -> m (Number dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Number dom stage -> m (Number dom stage) #

Domain dom => Generic (Number dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (Number dom stage) :: * -> * #

Methods

from :: Number dom stage -> Rep (Number dom stage) x #

to :: Rep (Number dom stage) x -> Number dom stage #

type Rep (Number dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (Number dom stage) = D1 (MetaData "Number" "Language.Haskell.Tools.AST.Representation.Exprs" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "Number" PrefixI True) (S1 (MetaSel (Just "_numberInteger") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Integer)))
type IgnoredFields (Number dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (Number dom stage) = (Right "_numberInteger" :: Either (Symbol, Nat) Symbol) ': ([] :: [Either (Symbol, Nat) Symbol])

Arrows

data UCmd dom stage Source #

Constructors

UArrowAppCmd

An arrow application command ( f -< x + 1 )

Fields

UArrowFormCmd

A form command ( (|untilA (increment -< x+y) (within 0.5 -< x)|) )

Fields

UAppCmd

A function application command

Fields

UInfixCmd

An infix command application

Fields

ULambdaCmd

A lambda command

Fields

UParenCmd

A parenthesized command

Fields

UCaseCmd

A pattern match command

Fields

UIfCmd

An if command ( if f x y then g -< x+1 else h -< y+2 )

Fields

ULetCmd

A local binding command ( let z = x+y )

Fields

UDoCmd

A do-notation in a command

Fields

Instances
SourceInfoTraversal UCmd Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UCmd dom st1 -> f (UCmd dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UCmd dom st1 -> f (UCmd dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UCmd dom st1 -> f (UCmd dom st2) Source #

SemanticTraversal UCmd Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UCmd dom1 st -> f (UCmd dom2 st) Source #

(GoodOperationFor c (UCmd dom stage), ClassyPlate c (Ann UExpr dom stage), ClassyPlate c (Ann UArrowAppl dom stage), ClassyPlate c (Ann UExpr dom stage), ClassyPlate c (Ann UExpr dom stage), ClassyPlate c (AnnListG UCmd dom stage), ClassyPlate c (Ann UCmd dom stage), ClassyPlate c (Ann UExpr dom stage), ClassyPlate c (Ann UCmd dom stage), ClassyPlate c (Ann UName dom stage), ClassyPlate c (Ann UCmd dom stage), ClassyPlate c (AnnListG UPattern dom stage), ClassyPlate c (Ann UCmd dom stage), ClassyPlate c (Ann UCmd dom stage), ClassyPlate c (Ann UExpr dom stage), ClassyPlate c (AnnListG UCmdAlt dom stage), ClassyPlate c (Ann UExpr dom stage), ClassyPlate c (Ann UCmd dom stage), ClassyPlate c (Ann UCmd dom stage), ClassyPlate c (AnnListG ULocalBind dom stage), ClassyPlate c (Ann UCmd dom stage), ClassyPlate c (AnnListG UCmdStmt dom stage)) => ClassyPlate c (UCmd dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UCmd dom stage -> UCmd dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UCmd dom stage -> m (UCmd dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UCmd dom stage -> UCmd dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UCmd dom stage -> m (UCmd dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UCmd dom stage -> UCmd dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UCmd dom stage -> m (UCmd dom stage) #

(Domain dom, SourceInfo stage) => Data (UCmd dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UCmd dom stage -> c (UCmd dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UCmd dom stage) #

toConstr :: UCmd dom stage -> Constr #

dataTypeOf :: UCmd dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UCmd dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UCmd dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UCmd dom stage -> UCmd dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UCmd dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UCmd dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UCmd dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UCmd dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UCmd dom stage -> m (UCmd dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UCmd dom stage -> m (UCmd dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UCmd dom stage -> m (UCmd dom stage) #

Domain dom => Generic (UCmd dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UCmd dom stage) :: * -> * #

Methods

from :: UCmd dom stage -> Rep (UCmd dom stage) x #

to :: Rep (UCmd dom stage) x -> UCmd dom stage #

type Rep (UCmd dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UCmd dom stage) = D1 (MetaData "UCmd" "Language.Haskell.Tools.AST.Representation.Exprs" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (((C1 (MetaCons "UArrowAppCmd" PrefixI True) (S1 (MetaSel (Just "_cmdLhs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage)) :*: (S1 (MetaSel (Just "_cmdArrowOp") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UArrowAppl dom stage)) :*: S1 (MetaSel (Just "_cmdRhs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage)))) :+: C1 (MetaCons "UArrowFormCmd" PrefixI True) (S1 (MetaSel (Just "_cmdExpr") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage)) :*: S1 (MetaSel (Just "_cmdInnerCmds") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UCmd dom stage)))) :+: (C1 (MetaCons "UAppCmd" PrefixI True) (S1 (MetaSel (Just "_cmdInnerCmd") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UCmd dom stage)) :*: S1 (MetaSel (Just "_cmdApplied") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage))) :+: (C1 (MetaCons "UInfixCmd" PrefixI True) (S1 (MetaSel (Just "_cmdLeftCmd") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UCmd dom stage)) :*: (S1 (MetaSel (Just "_cmdOperator") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage)) :*: S1 (MetaSel (Just "_cmdRightCmd") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UCmd dom stage)))) :+: C1 (MetaCons "ULambdaCmd" PrefixI True) (S1 (MetaSel (Just "_cmdBindings") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UPattern dom stage)) :*: S1 (MetaSel (Just "_cmdInner") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UCmd dom stage)))))) :+: ((C1 (MetaCons "UParenCmd" PrefixI True) (S1 (MetaSel (Just "_cmdInner") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UCmd dom stage))) :+: C1 (MetaCons "UCaseCmd" PrefixI True) (S1 (MetaSel (Just "_cmdExpr") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage)) :*: S1 (MetaSel (Just "_cmdAlts") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UCmdAlt dom stage)))) :+: (C1 (MetaCons "UIfCmd" PrefixI True) (S1 (MetaSel (Just "_cmdExpr") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage)) :*: (S1 (MetaSel (Just "_cmdThen") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UCmd dom stage)) :*: S1 (MetaSel (Just "_cmdElse") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UCmd dom stage)))) :+: (C1 (MetaCons "ULetCmd" PrefixI True) (S1 (MetaSel (Just "_cmdBinds") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG ULocalBind dom stage)) :*: S1 (MetaSel (Just "_cmdInner") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UCmd dom stage))) :+: C1 (MetaCons "UDoCmd" PrefixI True) (S1 (MetaSel (Just "_cmdStmts") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UCmdStmt dom stage)))))))
type IgnoredFields (UCmd dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UCmd dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UArrowAppl dom stage Source #

Constructors

ULeftAppl

Left arrow application: -<

URightAppl

Right arrow application: >-

ULeftHighApp

Left arrow high application: -<<

URightHighApp

Right arrow high application: >>-

Instances
SourceInfoTraversal UArrowAppl Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UArrowAppl dom st1 -> f (UArrowAppl dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UArrowAppl dom st1 -> f (UArrowAppl dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UArrowAppl dom st1 -> f (UArrowAppl dom st2) Source #

SemanticTraversal UArrowAppl Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UArrowAppl dom1 st -> f (UArrowAppl dom2 st) Source #

GoodOperationFor c (UArrowAppl dom stage) => ClassyPlate c (UArrowAppl dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UArrowAppl dom stage -> UArrowAppl dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UArrowAppl dom stage -> m (UArrowAppl dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UArrowAppl dom stage -> UArrowAppl dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UArrowAppl dom stage -> m (UArrowAppl dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UArrowAppl dom stage -> UArrowAppl dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UArrowAppl dom stage -> m (UArrowAppl dom stage) #

(Domain dom, SourceInfo stage) => Data (UArrowAppl dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UArrowAppl dom stage -> c (UArrowAppl dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UArrowAppl dom stage) #

toConstr :: UArrowAppl dom stage -> Constr #

dataTypeOf :: UArrowAppl dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UArrowAppl dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UArrowAppl dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UArrowAppl dom stage -> UArrowAppl dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UArrowAppl dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UArrowAppl dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UArrowAppl dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UArrowAppl dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UArrowAppl dom stage -> m (UArrowAppl dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UArrowAppl dom stage -> m (UArrowAppl dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UArrowAppl dom stage -> m (UArrowAppl dom stage) #

Domain dom => Generic (UArrowAppl dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UArrowAppl dom stage) :: * -> * #

Methods

from :: UArrowAppl dom stage -> Rep (UArrowAppl dom stage) x #

to :: Rep (UArrowAppl dom stage) x -> UArrowAppl dom stage #

type Rep (UArrowAppl dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UArrowAppl dom stage) = D1 (MetaData "UArrowAppl" "Language.Haskell.Tools.AST.Representation.Exprs" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) ((C1 (MetaCons "ULeftAppl" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "URightAppl" PrefixI False) (U1 :: * -> *)) :+: (C1 (MetaCons "ULeftHighApp" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "URightHighApp" PrefixI False) (U1 :: * -> *)))
type IgnoredFields (UArrowAppl dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UArrowAppl dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UUnboxedSumPlaceHolder dom stage Source #

Instances
SourceInfoTraversal UUnboxedSumPlaceHolder Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UUnboxedSumPlaceHolder dom st1 -> f (UUnboxedSumPlaceHolder dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UUnboxedSumPlaceHolder dom st1 -> f (UUnboxedSumPlaceHolder dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UUnboxedSumPlaceHolder dom st1 -> f (UUnboxedSumPlaceHolder dom st2) Source #

SemanticTraversal UUnboxedSumPlaceHolder Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UUnboxedSumPlaceHolder dom1 st -> f (UUnboxedSumPlaceHolder dom2 st) Source #

GoodOperationFor c (UUnboxedSumPlaceHolder dom stage) => ClassyPlate c (UUnboxedSumPlaceHolder dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UUnboxedSumPlaceHolder dom stage -> UUnboxedSumPlaceHolder dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UUnboxedSumPlaceHolder dom stage -> m (UUnboxedSumPlaceHolder dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UUnboxedSumPlaceHolder dom stage -> UUnboxedSumPlaceHolder dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UUnboxedSumPlaceHolder dom stage -> m (UUnboxedSumPlaceHolder dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UUnboxedSumPlaceHolder dom stage -> UUnboxedSumPlaceHolder dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UUnboxedSumPlaceHolder dom stage -> m (UUnboxedSumPlaceHolder dom stage) #

(Domain dom, SourceInfo stage) => Data (UUnboxedSumPlaceHolder dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UUnboxedSumPlaceHolder dom stage -> c (UUnboxedSumPlaceHolder dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UUnboxedSumPlaceHolder dom stage) #

toConstr :: UUnboxedSumPlaceHolder dom stage -> Constr #

dataTypeOf :: UUnboxedSumPlaceHolder dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UUnboxedSumPlaceHolder dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UUnboxedSumPlaceHolder dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UUnboxedSumPlaceHolder dom stage -> UUnboxedSumPlaceHolder dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UUnboxedSumPlaceHolder dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UUnboxedSumPlaceHolder dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UUnboxedSumPlaceHolder dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UUnboxedSumPlaceHolder dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UUnboxedSumPlaceHolder dom stage -> m (UUnboxedSumPlaceHolder dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UUnboxedSumPlaceHolder dom stage -> m (UUnboxedSumPlaceHolder dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UUnboxedSumPlaceHolder dom stage -> m (UUnboxedSumPlaceHolder dom stage) #

Domain dom => Generic (UUnboxedSumPlaceHolder dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UUnboxedSumPlaceHolder dom stage) :: * -> * #

Methods

from :: UUnboxedSumPlaceHolder dom stage -> Rep (UUnboxedSumPlaceHolder dom stage) x #

to :: Rep (UUnboxedSumPlaceHolder dom stage) x -> UUnboxedSumPlaceHolder dom stage #

type Rep (UUnboxedSumPlaceHolder dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UUnboxedSumPlaceHolder dom stage) = D1 (MetaData "UUnboxedSumPlaceHolder" "Language.Haskell.Tools.AST.Representation.Exprs" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UUnboxedSumPlaceHolder" PrefixI False) (U1 :: * -> *))
type IgnoredFields (UUnboxedSumPlaceHolder dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

data UStmt' expr dom stage Source #

Normal monadic statements

Constructors

UBindStmt

Binding statement ( x <- action )

Fields

UExprStmt

Non-binding statement ( action )

Fields

ULetStmt

Let statement ( let x = 3; y = 4 )

Fields

URecStmt

A recursive binding statement with ( rec b <- f a c; c <- f b a )

Fields

Instances
(GoodOperationFor c (UStmt' expr dom stage), ClassyPlate c (Ann UPattern dom stage), ClassyPlate c (Ann expr dom stage), ClassyPlate c (Ann expr dom stage), ClassyPlate c (AnnListG ULocalBind dom stage), ClassyPlate c (AnnListG (UStmt' expr) dom stage)) => ClassyPlate c (UStmt' expr dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UStmt' expr dom stage -> UStmt' expr dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UStmt' expr dom stage -> m (UStmt' expr dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UStmt' expr dom stage -> UStmt' expr dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UStmt' expr dom stage -> m (UStmt' expr dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UStmt' expr dom stage -> UStmt' expr dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UStmt' expr dom stage -> m (UStmt' expr dom stage) #

SourceInfoTraversal expr => SourceInfoTraversal (UStmt' expr) Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UStmt' expr dom st1 -> f (UStmt' expr dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UStmt' expr dom st1 -> f (UStmt' expr dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UStmt' expr dom st1 -> f (UStmt' expr dom st2) Source #

SemanticTraversal expr => SemanticTraversal (UStmt' expr) Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UStmt' expr dom1 st -> f (UStmt' expr dom2 st) Source #

(DomainWith expr dom, SourceInfo stage, Typeable expr, Data (expr dom stage)) => Data (UStmt' expr dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UStmt' expr dom stage -> c (UStmt' expr dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UStmt' expr dom stage) #

toConstr :: UStmt' expr dom stage -> Constr #

dataTypeOf :: UStmt' expr dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UStmt' expr dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UStmt' expr dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UStmt' expr dom stage -> UStmt' expr dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UStmt' expr dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UStmt' expr dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UStmt' expr dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UStmt' expr dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UStmt' expr dom stage -> m (UStmt' expr dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UStmt' expr dom stage -> m (UStmt' expr dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UStmt' expr dom stage -> m (UStmt' expr dom stage) #

Domain dom => Generic (UStmt' expr dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UStmt' expr dom stage) :: * -> * #

Methods

from :: UStmt' expr dom stage -> Rep (UStmt' expr dom stage) x #

to :: Rep (UStmt' expr dom stage) x -> UStmt' expr dom stage #

type Rep (UStmt' expr dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UStmt' expr dom stage) = D1 (MetaData "UStmt'" "Language.Haskell.Tools.AST.Representation.Stmts" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) ((C1 (MetaCons "UBindStmt" PrefixI True) (S1 (MetaSel (Just "_stmtPattern") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UPattern dom stage)) :*: S1 (MetaSel (Just "_stmtExpr") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann expr dom stage))) :+: C1 (MetaCons "UExprStmt" PrefixI True) (S1 (MetaSel (Just "_stmtExpr") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann expr dom stage)))) :+: (C1 (MetaCons "ULetStmt" PrefixI True) (S1 (MetaSel (Just "_stmtBinds") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG ULocalBind dom stage))) :+: C1 (MetaCons "URecStmt" PrefixI True) (S1 (MetaSel (Just "_cmdStmtBinds") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG (UStmt' expr) dom stage)))))
type IgnoredFields (UStmt' expr dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UStmt' expr dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UListCompBody dom stage Source #

Body of a list comprehension: ( | x <- [1..10] )

Constructors

UListCompBody 

Fields

Instances
SourceInfoTraversal UListCompBody Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UListCompBody dom st1 -> f (UListCompBody dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UListCompBody dom st1 -> f (UListCompBody dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UListCompBody dom st1 -> f (UListCompBody dom st2) Source #

SemanticTraversal UListCompBody Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UListCompBody dom1 st -> f (UListCompBody dom2 st) Source #

(GoodOperationFor c (UListCompBody dom stage), ClassyPlate c (AnnListG UCompStmt dom stage)) => ClassyPlate c (UListCompBody dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UListCompBody dom stage -> UListCompBody dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UListCompBody dom stage -> m (UListCompBody dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UListCompBody dom stage -> UListCompBody dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UListCompBody dom stage -> m (UListCompBody dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UListCompBody dom stage -> UListCompBody dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UListCompBody dom stage -> m (UListCompBody dom stage) #

(Domain dom, SourceInfo stage) => Data (UListCompBody dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UListCompBody dom stage -> c (UListCompBody dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UListCompBody dom stage) #

toConstr :: UListCompBody dom stage -> Constr #

dataTypeOf :: UListCompBody dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UListCompBody dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UListCompBody dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UListCompBody dom stage -> UListCompBody dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UListCompBody dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UListCompBody dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UListCompBody dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UListCompBody dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UListCompBody dom stage -> m (UListCompBody dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UListCompBody dom stage -> m (UListCompBody dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UListCompBody dom stage -> m (UListCompBody dom stage) #

Domain dom => Generic (UListCompBody dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UListCompBody dom stage) :: * -> * #

Methods

from :: UListCompBody dom stage -> Rep (UListCompBody dom stage) x #

to :: Rep (UListCompBody dom stage) x -> UListCompBody dom stage #

type Rep (UListCompBody dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UListCompBody dom stage) = D1 (MetaData "UListCompBody" "Language.Haskell.Tools.AST.Representation.Stmts" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UListCompBody" PrefixI True) (S1 (MetaSel (Just "_compStmts") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UCompStmt dom stage))))
type IgnoredFields (UListCompBody dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UListCompBody dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UCompStmt dom stage Source #

List comprehension statement

Constructors

UCompStmt

Normal monadic statement of a list comprehension

Fields

UThenStmt

Then statements by TransformListComp ( then sortWith by (x + y) )

Fields

UGroupStmt

Grouping statements by TransformListComp ( then group by (x + y) using groupWith ) Note: either byExpr or usingExpr must have a value

Fields

Instances
SourceInfoTraversal UCompStmt Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UCompStmt dom st1 -> f (UCompStmt dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UCompStmt dom st1 -> f (UCompStmt dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UCompStmt dom st1 -> f (UCompStmt dom st2) Source #

SemanticTraversal UCompStmt Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UCompStmt dom1 st -> f (UCompStmt dom2 st) Source #

(GoodOperationFor c (UCompStmt dom stage), ClassyPlate c (Ann UStmt dom stage), ClassyPlate c (Ann UExpr dom stage), ClassyPlate c (AnnMaybeG UExpr dom stage), ClassyPlate c (AnnMaybeG UExpr dom stage), ClassyPlate c (AnnMaybeG UExpr dom stage)) => ClassyPlate c (UCompStmt dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UCompStmt dom stage -> UCompStmt dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UCompStmt dom stage -> m (UCompStmt dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UCompStmt dom stage -> UCompStmt dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UCompStmt dom stage -> m (UCompStmt dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UCompStmt dom stage -> UCompStmt dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UCompStmt dom stage -> m (UCompStmt dom stage) #

(Domain dom, SourceInfo stage) => Data (UCompStmt dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UCompStmt dom stage -> c (UCompStmt dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UCompStmt dom stage) #

toConstr :: UCompStmt dom stage -> Constr #

dataTypeOf :: UCompStmt dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UCompStmt dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UCompStmt dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UCompStmt dom stage -> UCompStmt dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UCompStmt dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UCompStmt dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UCompStmt dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UCompStmt dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UCompStmt dom stage -> m (UCompStmt dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UCompStmt dom stage -> m (UCompStmt dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UCompStmt dom stage -> m (UCompStmt dom stage) #

Domain dom => Generic (UCompStmt dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UCompStmt dom stage) :: * -> * #

Methods

from :: UCompStmt dom stage -> Rep (UCompStmt dom stage) x #

to :: Rep (UCompStmt dom stage) x -> UCompStmt dom stage #

type Rep (UCompStmt dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UCompStmt dom stage) = D1 (MetaData "UCompStmt" "Language.Haskell.Tools.AST.Representation.Stmts" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UCompStmt" PrefixI True) (S1 (MetaSel (Just "_compStmt") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UStmt dom stage))) :+: (C1 (MetaCons "UThenStmt" PrefixI True) (S1 (MetaSel (Just "_thenExpr") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage)) :*: S1 (MetaSel (Just "_byExpr") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UExpr dom stage))) :+: C1 (MetaCons "UGroupStmt" PrefixI True) (S1 (MetaSel (Just "_byExpr") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UExpr dom stage)) :*: S1 (MetaSel (Just "_usingExpr") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UExpr dom stage)))))
type IgnoredFields (UCompStmt dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UCompStmt dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UDoKind dom stage Source #

Keywords do or mdo to start a do-block

Constructors

UDoKeyword 
UMDoKeyword 
Instances
SourceInfoTraversal UDoKind Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UDoKind dom st1 -> f (UDoKind dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UDoKind dom st1 -> f (UDoKind dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UDoKind dom st1 -> f (UDoKind dom st2) Source #

SemanticTraversal UDoKind Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UDoKind dom1 st -> f (UDoKind dom2 st) Source #

GoodOperationFor c (UDoKind dom stage) => ClassyPlate c (UDoKind dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UDoKind dom stage -> UDoKind dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UDoKind dom stage -> m (UDoKind dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UDoKind dom stage -> UDoKind dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UDoKind dom stage -> m (UDoKind dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UDoKind dom stage -> UDoKind dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UDoKind dom stage -> m (UDoKind dom stage) #

(Domain dom, SourceInfo stage) => Data (UDoKind dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UDoKind dom stage -> c (UDoKind dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UDoKind dom stage) #

toConstr :: UDoKind dom stage -> Constr #

dataTypeOf :: UDoKind dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UDoKind dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UDoKind dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UDoKind dom stage -> UDoKind dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UDoKind dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UDoKind dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UDoKind dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UDoKind dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UDoKind dom stage -> m (UDoKind dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UDoKind dom stage -> m (UDoKind dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UDoKind dom stage -> m (UDoKind dom stage) #

Domain dom => Generic (UDoKind dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UDoKind dom stage) :: * -> * #

Methods

from :: UDoKind dom stage -> Rep (UDoKind dom stage) x #

to :: Rep (UDoKind dom stage) x -> UDoKind dom stage #

type Rep (UDoKind dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UDoKind dom stage) = D1 (MetaData "UDoKind" "Language.Haskell.Tools.AST.Representation.Stmts" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UDoKeyword" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "UMDoKeyword" PrefixI False) (U1 :: * -> *))
type IgnoredFields (UDoKind dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UDoKind dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UPattern dom stage Source #

Representation of patterns for pattern bindings

Constructors

UVarPat

Pattern name binding

Fields

ULitPat

Literal pattern

Fields

UInfixAppPat

Infix constructor application pattern ( a :+: b )

Fields

UAppPat

Constructor application pattern ( Point x y )

Fields

UTuplePat

Tuple pattern ( (x,y) )

Fields

UUnboxTuplePat

Unboxed tuple pattern ( () )

Fields

UListPat

List pattern ( [1,2,a,x] )

Fields

UParArrPat

Parallel array pattern ( [:1,2,a,x:] )

Fields

UParenPat

Parenthesised patterns

Fields

URecPat

Record pattern ( Point { x = 3, y } )

Fields

UAsPat

As-pattern (explicit name binding) ( ls@(hd:_) )

Fields

UWildPat

Wildcard pattern: ( _ )

UIrrefutablePat

Irrefutable pattern ( ~(x:_) )

Fields

UBangPat

Bang pattern ( !x )

Fields

UTypeSigPat

Pattern with explicit type signature ( x :: Int )

Fields

UViewPat

View pattern ( f -> Just 1 ) regular list pattern omitted xml patterns omitted

Fields

USplicePat

Splice patterns: $(generateX inp)

Fields

UQuasiQuotePat

Quasi-quoted patterns: [| 1 + 2 |]

Fields

UNPlusKPat 

Fields

UUnboxedSumPat

Unboxed sum pattern ( () ).

Instances
SourceInfoTraversal UPattern Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UPattern dom st1 -> f (UPattern dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UPattern dom st1 -> f (UPattern dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UPattern dom st1 -> f (UPattern dom st2) Source #

SemanticTraversal UPattern Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UPattern dom1 st -> f (UPattern dom2 st) Source #

(GoodOperationFor c (UPattern dom stage), ClassyPlate c (Ann UName dom stage), ClassyPlate c (Ann ULiteral dom stage), ClassyPlate c (Ann UPattern dom stage), ClassyPlate c (Ann UOperator dom stage), ClassyPlate c (Ann UPattern dom stage), ClassyPlate c (Ann UName dom stage), ClassyPlate c (AnnListG UPattern dom stage), ClassyPlate c (AnnListG UPattern dom stage), ClassyPlate c (AnnListG UPattern dom stage), ClassyPlate c (AnnListG UPattern dom stage), ClassyPlate c (AnnListG UPattern dom stage), ClassyPlate c (Ann UPattern dom stage), ClassyPlate c (Ann UName dom stage), ClassyPlate c (AnnListG UPatternField dom stage), ClassyPlate c (Ann UName dom stage), ClassyPlate c (Ann UPattern dom stage), ClassyPlate c (Ann UPattern dom stage), ClassyPlate c (Ann UPattern dom stage), ClassyPlate c (Ann UPattern dom stage), ClassyPlate c (Ann UType dom stage), ClassyPlate c (Ann UExpr dom stage), ClassyPlate c (Ann UPattern dom stage), ClassyPlate c (Ann USplice dom stage), ClassyPlate c (Ann UQuasiQuote dom stage), ClassyPlate c (Ann UName dom stage), ClassyPlate c (Ann ULiteral dom stage), ClassyPlate c (AnnListG UUnboxedSumPlaceHolder dom stage), ClassyPlate c (Ann UPattern dom stage), ClassyPlate c (AnnListG UUnboxedSumPlaceHolder dom stage)) => ClassyPlate c (UPattern dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UPattern dom stage -> UPattern dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UPattern dom stage -> m (UPattern dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UPattern dom stage -> UPattern dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UPattern dom stage -> m (UPattern dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UPattern dom stage -> UPattern dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UPattern dom stage -> m (UPattern dom stage) #

(Domain dom, SourceInfo stage) => Data (UPattern dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UPattern dom stage -> c (UPattern dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UPattern dom stage) #

toConstr :: UPattern dom stage -> Constr #

dataTypeOf :: UPattern dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UPattern dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UPattern dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UPattern dom stage -> UPattern dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UPattern dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UPattern dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UPattern dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UPattern dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UPattern dom stage -> m (UPattern dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UPattern dom stage -> m (UPattern dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UPattern dom stage -> m (UPattern dom stage) #

Domain dom => Generic (UPattern dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UPattern dom stage) :: * -> * #

Methods

from :: UPattern dom stage -> Rep (UPattern dom stage) x #

to :: Rep (UPattern dom stage) x -> UPattern dom stage #

type Rep (UPattern dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UPattern dom stage) = D1 (MetaData "UPattern" "Language.Haskell.Tools.AST.Representation.Patterns" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) ((((C1 (MetaCons "UVarPat" PrefixI True) (S1 (MetaSel (Just "_patternName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage))) :+: C1 (MetaCons "ULitPat" PrefixI True) (S1 (MetaSel (Just "_patternLiteral") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann ULiteral dom stage)))) :+: (C1 (MetaCons "UInfixAppPat" PrefixI True) (S1 (MetaSel (Just "_patternLhs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UPattern dom stage)) :*: (S1 (MetaSel (Just "_patternOperator") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UOperator dom stage)) :*: S1 (MetaSel (Just "_patternRhs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UPattern dom stage)))) :+: (C1 (MetaCons "UAppPat" PrefixI True) (S1 (MetaSel (Just "_patternName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage)) :*: S1 (MetaSel (Just "_patternArgs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UPattern dom stage))) :+: C1 (MetaCons "UTuplePat" PrefixI True) (S1 (MetaSel (Just "_patternElems") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UPattern dom stage)))))) :+: ((C1 (MetaCons "UUnboxTuplePat" PrefixI True) (S1 (MetaSel (Just "_patternElems") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UPattern dom stage))) :+: C1 (MetaCons "UListPat" PrefixI True) (S1 (MetaSel (Just "_patternElems") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UPattern dom stage)))) :+: (C1 (MetaCons "UParArrPat" PrefixI True) (S1 (MetaSel (Just "_patternElems") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UPattern dom stage))) :+: (C1 (MetaCons "UParenPat" PrefixI True) (S1 (MetaSel (Just "_patternInner") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UPattern dom stage))) :+: C1 (MetaCons "URecPat" PrefixI True) (S1 (MetaSel (Just "_patternName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage)) :*: S1 (MetaSel (Just "_patternFields") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UPatternField dom stage))))))) :+: (((C1 (MetaCons "UAsPat" PrefixI True) (S1 (MetaSel (Just "_patternName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage)) :*: S1 (MetaSel (Just "_patternInner") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UPattern dom stage))) :+: C1 (MetaCons "UWildPat" PrefixI False) (U1 :: * -> *)) :+: (C1 (MetaCons "UIrrefutablePat" PrefixI True) (S1 (MetaSel (Just "_patternInner") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UPattern dom stage))) :+: (C1 (MetaCons "UBangPat" PrefixI True) (S1 (MetaSel (Just "_patternInner") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UPattern dom stage))) :+: C1 (MetaCons "UTypeSigPat" PrefixI True) (S1 (MetaSel (Just "_patternInner") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UPattern dom stage)) :*: S1 (MetaSel (Just "_patternType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UType dom stage)))))) :+: ((C1 (MetaCons "UViewPat" PrefixI True) (S1 (MetaSel (Just "_patternExpr") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UExpr dom stage)) :*: S1 (MetaSel (Just "_patternInner") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UPattern dom stage))) :+: C1 (MetaCons "USplicePat" PrefixI True) (S1 (MetaSel (Just "_patternSplice") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann USplice dom stage)))) :+: (C1 (MetaCons "UQuasiQuotePat" PrefixI True) (S1 (MetaSel (Just "_patQQ") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UQuasiQuote dom stage))) :+: (C1 (MetaCons "UNPlusKPat" PrefixI True) (S1 (MetaSel (Just "_patternName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage)) :*: S1 (MetaSel (Just "_patternLit") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann ULiteral dom stage))) :+: C1 (MetaCons "UUnboxedSumPat" PrefixI True) (S1 (MetaSel (Just "_patternSumPlaceholdersBefore") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UUnboxedSumPlaceHolder dom stage)) :*: (S1 (MetaSel (Just "_patternInner") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UPattern dom stage)) :*: S1 (MetaSel (Just "_patternSumPlaceholdersAfter") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UUnboxedSumPlaceHolder dom stage)))))))))
type IgnoredFields (UPattern dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UPattern dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UPatternField dom stage Source #

Constructors

UNormalFieldPattern

Named field pattern ( p = Point 3 2 )

Fields

UFieldPunPattern

Named field pun ( p )

Fields

UFieldWildcardPattern

Wildcard field pattern ( .. )

Instances
SourceInfoTraversal UPatternField Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UPatternField dom st1 -> f (UPatternField dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UPatternField dom st1 -> f (UPatternField dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UPatternField dom st1 -> f (UPatternField dom st2) Source #

SemanticTraversal UPatternField Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UPatternField dom1 st -> f (UPatternField dom2 st) Source #

(GoodOperationFor c (UPatternField dom stage), ClassyPlate c (Ann UName dom stage), ClassyPlate c (Ann UPattern dom stage), ClassyPlate c (Ann UName dom stage), ClassyPlate c (Ann UFieldWildcard dom stage)) => ClassyPlate c (UPatternField dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UPatternField dom stage -> UPatternField dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UPatternField dom stage -> m (UPatternField dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UPatternField dom stage -> UPatternField dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UPatternField dom stage -> m (UPatternField dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UPatternField dom stage -> UPatternField dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UPatternField dom stage -> m (UPatternField dom stage) #

(Domain dom, SourceInfo stage) => Data (UPatternField dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UPatternField dom stage -> c (UPatternField dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UPatternField dom stage) #

toConstr :: UPatternField dom stage -> Constr #

dataTypeOf :: UPatternField dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UPatternField dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UPatternField dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UPatternField dom stage -> UPatternField dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UPatternField dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UPatternField dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UPatternField dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UPatternField dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UPatternField dom stage -> m (UPatternField dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UPatternField dom stage -> m (UPatternField dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UPatternField dom stage -> m (UPatternField dom stage) #

Domain dom => Generic (UPatternField dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UPatternField dom stage) :: * -> * #

Methods

from :: UPatternField dom stage -> Rep (UPatternField dom stage) x #

to :: Rep (UPatternField dom stage) x -> UPatternField dom stage #

type Rep (UPatternField dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UPatternField dom stage) = D1 (MetaData "UPatternField" "Language.Haskell.Tools.AST.Representation.Patterns" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UNormalFieldPattern" PrefixI True) (S1 (MetaSel (Just "_fieldPatternName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage)) :*: S1 (MetaSel (Just "_fieldPattern") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UPattern dom stage))) :+: (C1 (MetaCons "UFieldPunPattern" PrefixI True) (S1 (MetaSel (Just "_fieldPatternName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage))) :+: C1 (MetaCons "UFieldWildcardPattern" PrefixI True) (S1 (MetaSel (Just "_fieldPatternWildcard") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UFieldWildcard dom stage)))))
type IgnoredFields (UPatternField dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UPatternField dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UTyVar dom stage Source #

Type variable declaration

Constructors

UTyVarDecl 

Fields

Instances
SourceInfoTraversal UTyVar Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UTyVar dom st1 -> f (UTyVar dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UTyVar dom st1 -> f (UTyVar dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UTyVar dom st1 -> f (UTyVar dom st2) Source #

SemanticTraversal UTyVar Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UTyVar dom1 st -> f (UTyVar dom2 st) Source #

(GoodOperationFor c (UTyVar dom stage), ClassyPlate c (Ann UName dom stage), ClassyPlate c (AnnMaybeG UKindConstraint dom stage)) => ClassyPlate c (UTyVar dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UTyVar dom stage -> UTyVar dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UTyVar dom stage -> m (UTyVar dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UTyVar dom stage -> UTyVar dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UTyVar dom stage -> m (UTyVar dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UTyVar dom stage -> UTyVar dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UTyVar dom stage -> m (UTyVar dom stage) #

(Domain dom, SourceInfo stage) => Data (UTyVar dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UTyVar dom stage -> c (UTyVar dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UTyVar dom stage) #

toConstr :: UTyVar dom stage -> Constr #

dataTypeOf :: UTyVar dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UTyVar dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UTyVar dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UTyVar dom stage -> UTyVar dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UTyVar dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UTyVar dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UTyVar dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UTyVar dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UTyVar dom stage -> m (UTyVar dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UTyVar dom stage -> m (UTyVar dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UTyVar dom stage -> m (UTyVar dom stage) #

Domain dom => Generic (UTyVar dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UTyVar dom stage) :: * -> * #

Methods

from :: UTyVar dom stage -> Rep (UTyVar dom stage) x #

to :: Rep (UTyVar dom stage) x -> UTyVar dom stage #

type Rep (UTyVar dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UTyVar dom stage) = D1 (MetaData "UTyVar" "Language.Haskell.Tools.AST.Representation.Types" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UTyVarDecl" PrefixI True) (S1 (MetaSel (Just "_tyVarName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage)) :*: S1 (MetaSel (Just "_tyVarKind") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnMaybeG UKindConstraint dom stage))))
type IgnoredFields (UTyVar dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UTyVar dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UType dom stage Source #

Haskell types

Constructors

UTyForall

Forall types ( forall x y . type )

Fields

UTyCtx

Type with a context ( forall x y . type )

Fields

UTyFun

Function types ( a -> b )

Fields

UTyTuple

Tuple types ( (a,b) )

Fields

UTyUnbTuple

Unboxed tuple types ( () )

Fields

UTyList

List type with special syntax ( [a] )

Fields

UTyParArray

Parallel array type ( [:a:] )

Fields

UTyApp

Type application ( F a )

Fields

UTyVar

Type variable or constructor ( a )

Fields

UTyParen

Type surrounded by parentheses ( (T a) )

Fields

UTyInfix

Infix type constructor ( (a <: b) )

Fields

UTyKinded

Type with explicit kind signature ( a :: * )

Fields

UTyPromoted 

Fields

UTySplice

A Template Haskell splice type ( $(genType) ).

Fields

UTyQuasiQuote

A Template Haskell quasi-quote type ( [quoter| ... ] ).

Fields

UTyBang

Strict type marked with !.

Fields

UTyLazy

Lazy type marked with ~. (Should only be used if Strict or StrictData language extension is used)

Fields

UTyUnpack

Strict type marked with UNPACK pragma. (Usually contains the bang mark.)

Fields

UTyNoUnpack

Strict type marked with NOUNPACK pragma. (Usually contains the bang mark.)

Fields

UTyWildcard

A wildcard type ( _ ) with -XPartialTypeSignatures

UTyNamedWildc

A named wildcard type ( _t ) with -XPartialTypeSignatures

Fields

UUnbSumType

An unboxed sum type ( () )

Fields

Instances
SourceInfoTraversal UType Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UType dom st1 -> f (UType dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UType dom st1 -> f (UType dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UType dom st1 -> f (UType dom st2) Source #

SemanticTraversal UType Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UType dom1 st -> f (UType dom2 st) Source #

(GoodOperationFor c (UType dom stage), ClassyPlate c (AnnListG UTyVar dom stage), ClassyPlate c (Ann UType dom stage), ClassyPlate c (Ann UContext dom stage), ClassyPlate c (Ann UType dom stage), ClassyPlate c (Ann UType dom stage), ClassyPlate c (Ann UType dom stage), ClassyPlate c (AnnListG UType dom stage), ClassyPlate c (AnnListG UType dom stage), ClassyPlate c (Ann UType dom stage), ClassyPlate c (Ann UType dom stage), ClassyPlate c (Ann UType dom stage), ClassyPlate c (Ann UType dom stage), ClassyPlate c (Ann UName dom stage), ClassyPlate c (Ann UType dom stage), ClassyPlate c (Ann UType dom stage), ClassyPlate c (Ann UOperator dom stage), ClassyPlate c (Ann UType dom stage), ClassyPlate c (Ann UType dom stage), ClassyPlate c (Ann UKind dom stage), ClassyPlate c (Ann (UPromoted UType) dom stage), ClassyPlate c (Ann USplice dom stage), ClassyPlate c (Ann UQuasiQuote dom stage), ClassyPlate c (Ann UType dom stage), ClassyPlate c (Ann UType dom stage), ClassyPlate c (Ann UType dom stage), ClassyPlate c (Ann UType dom stage), ClassyPlate c (Ann UName dom stage), ClassyPlate c (AnnListG UType dom stage)) => ClassyPlate c (UType dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UType dom stage -> UType dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UType dom stage -> m (UType dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UType dom stage -> UType dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UType dom stage -> m (UType dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UType dom stage -> UType dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UType dom stage -> m (UType dom stage) #

(Domain dom, SourceInfo stage) => Data (UType dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UType dom stage -> c (UType dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UType dom stage) #

toConstr :: UType dom stage -> Constr #

dataTypeOf :: UType dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UType dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UType dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UType dom stage -> UType dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UType dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UType dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UType dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UType dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UType dom stage -> m (UType dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UType dom stage -> m (UType dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UType dom stage -> m (UType dom stage) #

Domain dom => Generic (UType dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UType dom stage) :: * -> * #

Methods

from :: UType dom stage -> Rep (UType dom stage) x #

to :: Rep (UType dom stage) x -> UType dom stage #

type Rep (UType dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UType dom stage) = D1 (MetaData "UType" "Language.Haskell.Tools.AST.Representation.Types" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) ((((C1 (MetaCons "UTyForall" PrefixI True) (S1 (MetaSel (Just "_typeBounded") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UTyVar dom stage)) :*: S1 (MetaSel (Just "_typeType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UType dom stage))) :+: C1 (MetaCons "UTyCtx" PrefixI True) (S1 (MetaSel (Just "_typeCtx") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UContext dom stage)) :*: S1 (MetaSel (Just "_typeType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UType dom stage)))) :+: (C1 (MetaCons "UTyFun" PrefixI True) (S1 (MetaSel (Just "_typeParam") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UType dom stage)) :*: S1 (MetaSel (Just "_typeResult") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UType dom stage))) :+: (C1 (MetaCons "UTyTuple" PrefixI True) (S1 (MetaSel (Just "_typeElements") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UType dom stage))) :+: C1 (MetaCons "UTyUnbTuple" PrefixI True) (S1 (MetaSel (Just "_typeElements") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UType dom stage)))))) :+: ((C1 (MetaCons "UTyList" PrefixI True) (S1 (MetaSel (Just "_typeElement") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UType dom stage))) :+: (C1 (MetaCons "UTyParArray" PrefixI True) (S1 (MetaSel (Just "_typeElement") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UType dom stage))) :+: C1 (MetaCons "UTyApp" PrefixI True) (S1 (MetaSel (Just "_typeCon") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UType dom stage)) :*: S1 (MetaSel (Just "_typeArg") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UType dom stage))))) :+: (C1 (MetaCons "UTyVar" PrefixI True) (S1 (MetaSel (Just "_typeName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage))) :+: (C1 (MetaCons "UTyParen" PrefixI True) (S1 (MetaSel (Just "_typeInner") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UType dom stage))) :+: C1 (MetaCons "UTyInfix" PrefixI True) (S1 (MetaSel (Just "_typeLeft") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UType dom stage)) :*: (S1 (MetaSel (Just "_typeOperator") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UOperator dom stage)) :*: S1 (MetaSel (Just "_typeRight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UType dom stage)))))))) :+: (((C1 (MetaCons "UTyKinded" PrefixI True) (S1 (MetaSel (Just "_typeInner") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UType dom stage)) :*: S1 (MetaSel (Just "_typeKind") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UKind dom stage))) :+: C1 (MetaCons "UTyPromoted" PrefixI True) (S1 (MetaSel (Just "_tpPromoted") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann (UPromoted UType) dom stage)))) :+: (C1 (MetaCons "UTySplice" PrefixI True) (S1 (MetaSel (Just "_tsSplice") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann USplice dom stage))) :+: (C1 (MetaCons "UTyQuasiQuote" PrefixI True) (S1 (MetaSel (Just "_typeQQ") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UQuasiQuote dom stage))) :+: C1 (MetaCons "UTyBang" PrefixI True) (S1 (MetaSel (Just "_typeInner") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UType dom stage)))))) :+: ((C1 (MetaCons "UTyLazy" PrefixI True) (S1 (MetaSel (Just "_typeInner") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UType dom stage))) :+: (C1 (MetaCons "UTyUnpack" PrefixI True) (S1 (MetaSel (Just "_typeInner") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UType dom stage))) :+: C1 (MetaCons "UTyNoUnpack" PrefixI True) (S1 (MetaSel (Just "_typeInner") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UType dom stage))))) :+: (C1 (MetaCons "UTyWildcard" PrefixI False) (U1 :: * -> *) :+: (C1 (MetaCons "UTyNamedWildc" PrefixI True) (S1 (MetaSel (Just "_typeWildcardName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage))) :+: C1 (MetaCons "UUnbSumType" PrefixI True) (S1 (MetaSel (Just "_typeElements") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UType dom stage))))))))
type IgnoredFields (UType dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UType dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UContext dom stage Source #

Constructors

UContext

Assertions with the fat arrow ( C a => ... )

Fields

Instances
SourceInfoTraversal UContext Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UContext dom st1 -> f (UContext dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UContext dom st1 -> f (UContext dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UContext dom st1 -> f (UContext dom st2) Source #

SemanticTraversal UContext Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UContext dom1 st -> f (UContext dom2 st) Source #

(GoodOperationFor c (UContext dom stage), ClassyPlate c (Ann UAssertion dom stage)) => ClassyPlate c (UContext dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UContext dom stage -> UContext dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UContext dom stage -> m (UContext dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UContext dom stage -> UContext dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UContext dom stage -> m (UContext dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UContext dom stage -> UContext dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UContext dom stage -> m (UContext dom stage) #

(Domain dom, SourceInfo stage) => Data (UContext dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UContext dom stage -> c (UContext dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UContext dom stage) #

toConstr :: UContext dom stage -> Constr #

dataTypeOf :: UContext dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UContext dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UContext dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UContext dom stage -> UContext dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UContext dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UContext dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UContext dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UContext dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UContext dom stage -> m (UContext dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UContext dom stage -> m (UContext dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UContext dom stage -> m (UContext dom stage) #

Domain dom => Generic (UContext dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UContext dom stage) :: * -> * #

Methods

from :: UContext dom stage -> Rep (UContext dom stage) x #

to :: Rep (UContext dom stage) x -> UContext dom stage #

type Rep (UContext dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UContext dom stage) = D1 (MetaData "UContext" "Language.Haskell.Tools.AST.Representation.Types" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UContext" PrefixI True) (S1 (MetaSel (Just "_contextAssertion") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UAssertion dom stage))))
type IgnoredFields (UContext dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UContext dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UAssertion dom stage Source #

A single assertion in the context

Constructors

UClassAssert

Class assertion (Cls x)

Fields

UInfixAssert

Infix class assertion, also contains type equations ( a ~ X y )

Fields

UImplicitAssert

Assertion for implicit parameter binding ( ?cmp :: a -> a -> Bool )

Fields

UTupleAssert

Multiple assertions in one ( (Ord a, Show a) )

Fields

UWildcardAssert

Wildcard assertion ( _ ), enabled by PartialTypeSignatures

Instances
SourceInfoTraversal UAssertion Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UAssertion dom st1 -> f (UAssertion dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UAssertion dom st1 -> f (UAssertion dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UAssertion dom st1 -> f (UAssertion dom st2) Source #

SemanticTraversal UAssertion Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UAssertion dom1 st -> f (UAssertion dom2 st) Source #

(GoodOperationFor c (UAssertion dom stage), ClassyPlate c (Ann UName dom stage), ClassyPlate c (AnnListG UType dom stage), ClassyPlate c (Ann UType dom stage), ClassyPlate c (Ann UOperator dom stage), ClassyPlate c (Ann UType dom stage), ClassyPlate c (Ann UName dom stage), ClassyPlate c (Ann UType dom stage), ClassyPlate c (AnnListG UAssertion dom stage)) => ClassyPlate c (UAssertion dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UAssertion dom stage -> UAssertion dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UAssertion dom stage -> m (UAssertion dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UAssertion dom stage -> UAssertion dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UAssertion dom stage -> m (UAssertion dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UAssertion dom stage -> UAssertion dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UAssertion dom stage -> m (UAssertion dom stage) #

(Domain dom, SourceInfo stage) => Data (UAssertion dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UAssertion dom stage -> c (UAssertion dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UAssertion dom stage) #

toConstr :: UAssertion dom stage -> Constr #

dataTypeOf :: UAssertion dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UAssertion dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UAssertion dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UAssertion dom stage -> UAssertion dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UAssertion dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UAssertion dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UAssertion dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UAssertion dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UAssertion dom stage -> m (UAssertion dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UAssertion dom stage -> m (UAssertion dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UAssertion dom stage -> m (UAssertion dom stage) #

Domain dom => Generic (UAssertion dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UAssertion dom stage) :: * -> * #

Methods

from :: UAssertion dom stage -> Rep (UAssertion dom stage) x #

to :: Rep (UAssertion dom stage) x -> UAssertion dom stage #

type Rep (UAssertion dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UAssertion dom stage) = D1 (MetaData "UAssertion" "Language.Haskell.Tools.AST.Representation.Types" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) ((C1 (MetaCons "UClassAssert" PrefixI True) (S1 (MetaSel (Just "_assertClsName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage)) :*: S1 (MetaSel (Just "_assertTypes") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UType dom stage))) :+: C1 (MetaCons "UInfixAssert" PrefixI True) (S1 (MetaSel (Just "_assertLhs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UType dom stage)) :*: (S1 (MetaSel (Just "_assertOp") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UOperator dom stage)) :*: S1 (MetaSel (Just "_assertRhs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UType dom stage))))) :+: (C1 (MetaCons "UImplicitAssert" PrefixI True) (S1 (MetaSel (Just "_assertImplVar") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage)) :*: S1 (MetaSel (Just "_assertImplType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UType dom stage))) :+: (C1 (MetaCons "UTupleAssert" PrefixI True) (S1 (MetaSel (Just "_innerAsserts") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UAssertion dom stage))) :+: C1 (MetaCons "UWildcardAssert" PrefixI False) (U1 :: * -> *))))
type IgnoredFields (UAssertion dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UAssertion dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UKindConstraint dom stage Source #

Kind constraint ( :: * -> * )

Constructors

UKindConstraint 

Fields

Instances
SourceInfoTraversal UKindConstraint Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UKindConstraint dom st1 -> f (UKindConstraint dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UKindConstraint dom st1 -> f (UKindConstraint dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UKindConstraint dom st1 -> f (UKindConstraint dom st2) Source #

SemanticTraversal UKindConstraint Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UKindConstraint dom1 st -> f (UKindConstraint dom2 st) Source #

(GoodOperationFor c (UKindConstraint dom stage), ClassyPlate c (Ann UKind dom stage)) => ClassyPlate c (UKindConstraint dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UKindConstraint dom stage -> UKindConstraint dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UKindConstraint dom stage -> m (UKindConstraint dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UKindConstraint dom stage -> UKindConstraint dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UKindConstraint dom stage -> m (UKindConstraint dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UKindConstraint dom stage -> UKindConstraint dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UKindConstraint dom stage -> m (UKindConstraint dom stage) #

(Domain dom, SourceInfo stage) => Data (UKindConstraint dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UKindConstraint dom stage -> c (UKindConstraint dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UKindConstraint dom stage) #

toConstr :: UKindConstraint dom stage -> Constr #

dataTypeOf :: UKindConstraint dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UKindConstraint dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UKindConstraint dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UKindConstraint dom stage -> UKindConstraint dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UKindConstraint dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UKindConstraint dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UKindConstraint dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UKindConstraint dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UKindConstraint dom stage -> m (UKindConstraint dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UKindConstraint dom stage -> m (UKindConstraint dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UKindConstraint dom stage -> m (UKindConstraint dom stage) #

Domain dom => Generic (UKindConstraint dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UKindConstraint dom stage) :: * -> * #

Methods

from :: UKindConstraint dom stage -> Rep (UKindConstraint dom stage) x #

to :: Rep (UKindConstraint dom stage) x -> UKindConstraint dom stage #

type Rep (UKindConstraint dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UKindConstraint dom stage) = D1 (MetaData "UKindConstraint" "Language.Haskell.Tools.AST.Representation.Kinds" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UKindConstraint" PrefixI True) (S1 (MetaSel (Just "_kindConstr") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UKind dom stage))))
type IgnoredFields (UKindConstraint dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UKindConstraint dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UKind dom stage Source #

Haskell kinds

Constructors

UStarKind

*, the kind of types

UUnboxKind

#, the kind of unboxed types

UFunKind

->, the kind of type constructor

Fields

UParenKind

A parenthesised kind

Fields

UVarKind

Kind variable (using PolyKinds extension)

Fields

UAppKind

Kind application ( k1 k2 )

Fields

UInfixAppKind

Infix kind application ( k1 ~> k2 )

Fields

UListKind

A list kind ( [k] )

Fields

UTupleKind

A tuple kind ( (Symbol, *) )

Fields

UPromotedKind

A promoted kind ( '(k1,k2,k3) )

Fields

UTypeKind

A type on the kind level with TypeInType

Fields

Instances
SourceInfoTraversal UKind Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UKind dom st1 -> f (UKind dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UKind dom st1 -> f (UKind dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UKind dom st1 -> f (UKind dom st2) Source #

SemanticTraversal UKind Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UKind dom1 st -> f (UKind dom2 st) Source #

(GoodOperationFor c (UKind dom stage), ClassyPlate c (Ann UKind dom stage), ClassyPlate c (Ann UKind dom stage), ClassyPlate c (Ann UKind dom stage), ClassyPlate c (Ann UName dom stage), ClassyPlate c (Ann UKind dom stage), ClassyPlate c (Ann UKind dom stage), ClassyPlate c (Ann UKind dom stage), ClassyPlate c (Ann UOperator dom stage), ClassyPlate c (Ann UKind dom stage), ClassyPlate c (Ann UKind dom stage), ClassyPlate c (AnnListG UKind dom stage), ClassyPlate c (Ann (UPromoted UKind) dom stage), ClassyPlate c (Ann UType dom stage)) => ClassyPlate c (UKind dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UKind dom stage -> UKind dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UKind dom stage -> m (UKind dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UKind dom stage -> UKind dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UKind dom stage -> m (UKind dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UKind dom stage -> UKind dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UKind dom stage -> m (UKind dom stage) #

(Domain dom, SourceInfo stage) => Data (UKind dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UKind dom stage -> c (UKind dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UKind dom stage) #

toConstr :: UKind dom stage -> Constr #

dataTypeOf :: UKind dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UKind dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UKind dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UKind dom stage -> UKind dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UKind dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UKind dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UKind dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UKind dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UKind dom stage -> m (UKind dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UKind dom stage -> m (UKind dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UKind dom stage -> m (UKind dom stage) #

Domain dom => Generic (UKind dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UKind dom stage) :: * -> * #

Methods

from :: UKind dom stage -> Rep (UKind dom stage) x #

to :: Rep (UKind dom stage) x -> UKind dom stage #

type Rep (UKind dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UKind dom stage) = D1 (MetaData "UKind" "Language.Haskell.Tools.AST.Representation.Kinds" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (((C1 (MetaCons "UStarKind" PrefixI False) (U1 :: * -> *) :+: C1 (MetaCons "UUnboxKind" PrefixI False) (U1 :: * -> *)) :+: (C1 (MetaCons "UFunKind" PrefixI True) (S1 (MetaSel (Just "_kindLeft") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UKind dom stage)) :*: S1 (MetaSel (Just "_kindRight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UKind dom stage))) :+: (C1 (MetaCons "UParenKind" PrefixI True) (S1 (MetaSel (Just "_kindParen") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UKind dom stage))) :+: C1 (MetaCons "UVarKind" PrefixI True) (S1 (MetaSel (Just "_kindVar") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage)))))) :+: ((C1 (MetaCons "UAppKind" PrefixI True) (S1 (MetaSel (Just "_kindAppFun") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UKind dom stage)) :*: S1 (MetaSel (Just "_kindAppArg") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UKind dom stage))) :+: (C1 (MetaCons "UInfixAppKind" PrefixI True) (S1 (MetaSel (Just "_kindLhs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UKind dom stage)) :*: (S1 (MetaSel (Just "_kindAppOp") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UOperator dom stage)) :*: S1 (MetaSel (Just "_kindRhs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UKind dom stage)))) :+: C1 (MetaCons "UListKind" PrefixI True) (S1 (MetaSel (Just "_kindElem") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UKind dom stage))))) :+: (C1 (MetaCons "UTupleKind" PrefixI True) (S1 (MetaSel (Just "_kindElems") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UKind dom stage))) :+: (C1 (MetaCons "UPromotedKind" PrefixI True) (S1 (MetaSel (Just "_kindPromoted") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann (UPromoted UKind) dom stage))) :+: C1 (MetaCons "UTypeKind" PrefixI True) (S1 (MetaSel (Just "_kindType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UType dom stage)))))))
type IgnoredFields (UKind dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UKind dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UPromoted t dom stage Source #

Constructors

UPromotedInt

Numeric value promoted to the kind level.

UPromotedString

String value promoted to the kind level.

UPromotedCon

A data constructor value promoted to the kind level.

Fields

UPromotedList

A list of elements as a kind.

Fields

UPromotedTuple

A tuple of elements as a kind.

Fields

UPromotedUnit

Kind of the unit value ().

Instances
(GoodOperationFor c (UPromoted t dom stage), ClassyPlate c (Ann UName dom stage), ClassyPlate c (AnnListG t dom stage), ClassyPlate c (AnnListG t dom stage)) => ClassyPlate c (UPromoted t dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UPromoted t dom stage -> UPromoted t dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UPromoted t dom stage -> m (UPromoted t dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UPromoted t dom stage -> UPromoted t dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UPromoted t dom stage -> m (UPromoted t dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UPromoted t dom stage -> UPromoted t dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UPromoted t dom stage -> m (UPromoted t dom stage) #

SourceInfoTraversal t => SourceInfoTraversal (UPromoted t) Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UPromoted t dom st1 -> f (UPromoted t dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UPromoted t dom st1 -> f (UPromoted t dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UPromoted t dom st1 -> f (UPromoted t dom st2) Source #

SemanticTraversal t => SemanticTraversal (UPromoted t) Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UPromoted t dom1 st -> f (UPromoted t dom2 st) Source #

(DomainWith k dom, SourceInfo stage, Typeable k, Data (k dom stage)) => Data (UPromoted k dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UPromoted k dom stage -> c (UPromoted k dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UPromoted k dom stage) #

toConstr :: UPromoted k dom stage -> Constr #

dataTypeOf :: UPromoted k dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UPromoted k dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UPromoted k dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UPromoted k dom stage -> UPromoted k dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UPromoted k dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UPromoted k dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UPromoted k dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UPromoted k dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UPromoted k dom stage -> m (UPromoted k dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UPromoted k dom stage -> m (UPromoted k dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UPromoted k dom stage -> m (UPromoted k dom stage) #

Domain dom => Generic (UPromoted k dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UPromoted k dom stage) :: * -> * #

Methods

from :: UPromoted k dom stage -> Rep (UPromoted k dom stage) x #

to :: Rep (UPromoted k dom stage) x -> UPromoted k dom stage #

type Rep (UPromoted k dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UPromoted k dom stage) = D1 (MetaData "UPromoted" "Language.Haskell.Tools.AST.Representation.Kinds" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) ((C1 (MetaCons "UPromotedInt" PrefixI True) (S1 (MetaSel (Just "_promotedIntValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Integer)) :+: (C1 (MetaCons "UPromotedString" PrefixI True) (S1 (MetaSel (Just "_promotedStringValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)) :+: C1 (MetaCons "UPromotedCon" PrefixI True) (S1 (MetaSel (Just "_promotedConName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UName dom stage))))) :+: (C1 (MetaCons "UPromotedList" PrefixI True) (S1 (MetaSel (Just "_promotedElements") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG k dom stage))) :+: (C1 (MetaCons "UPromotedTuple" PrefixI True) (S1 (MetaSel (Just "_promotedElements") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG k dom stage))) :+: C1 (MetaCons "UPromotedUnit" PrefixI False) (U1 :: * -> *))))
type IgnoredFields (UPromoted t dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UPromoted t dom stage) = (Right "_promotedIntValue" :: Either (Symbol, Nat) Symbol) ': ((Right "_promotedStringValue" :: Either (Symbol, Nat) Symbol) ': ([] :: [Either (Symbol, Nat) Symbol]))

data ULiteral dom stage Source #

Haskell literals

Constructors

UCharLit

Character literal: c

Fields

UStringLit

String literal: "abc"

UIntLit

Integer literal: 12

UFracLit

Fractional literal: 3.14

UPrimIntLit

Primitive integer literal (of type Int#): 32#

UPrimWordLit

Primitive word literal (of type Word#): 32##

UPrimFloatLit

Primitive float literal (of type Float#): 3.14#

UPrimDoubleLit

Primitive double literal (of type Double#): 3.14##

UPrimCharLit

Primitive character literal (of type Char#): c#

Fields

UPrimStringLit

Primitive string literal (of type Addr#): "xxx"#

Instances
SourceInfoTraversal ULiteral Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> ULiteral dom st1 -> f (ULiteral dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> ULiteral dom st1 -> f (ULiteral dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> ULiteral dom st1 -> f (ULiteral dom st2) Source #

SemanticTraversal ULiteral Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> ULiteral dom1 st -> f (ULiteral dom2 st) Source #

GoodOperationFor c (ULiteral dom stage) => ClassyPlate c (ULiteral dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> ULiteral dom stage -> ULiteral dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> ULiteral dom stage -> m (ULiteral dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> ULiteral dom stage -> ULiteral dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> ULiteral dom stage -> m (ULiteral dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> ULiteral dom stage -> ULiteral dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> ULiteral dom stage -> m (ULiteral dom stage) #

(Domain dom, SourceInfo stage) => Data (ULiteral dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ULiteral dom stage -> c (ULiteral dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ULiteral dom stage) #

toConstr :: ULiteral dom stage -> Constr #

dataTypeOf :: ULiteral dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ULiteral dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ULiteral dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> ULiteral dom stage -> ULiteral dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ULiteral dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ULiteral dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> ULiteral dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ULiteral dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ULiteral dom stage -> m (ULiteral dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ULiteral dom stage -> m (ULiteral dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ULiteral dom stage -> m (ULiteral dom stage) #

Domain dom => Generic (ULiteral dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (ULiteral dom stage) :: * -> * #

Methods

from :: ULiteral dom stage -> Rep (ULiteral dom stage) x #

to :: Rep (ULiteral dom stage) x -> ULiteral dom stage #

HasLiteralInfo dom => HasLiteralInfo' (Ann ULiteral dom st) Source # 
Instance details

Defined in Language.Haskell.Tools.AST.SemaInfoClasses

type Rep (ULiteral dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (ULiteral dom stage) = D1 (MetaData "ULiteral" "Language.Haskell.Tools.AST.Representation.Literals" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (((C1 (MetaCons "UCharLit" PrefixI True) (S1 (MetaSel (Just "_charLitValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Char)) :+: C1 (MetaCons "UStringLit" PrefixI True) (S1 (MetaSel (Just "_stringLitValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String))) :+: (C1 (MetaCons "UIntLit" PrefixI True) (S1 (MetaSel (Just "_intLitValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Integer)) :+: (C1 (MetaCons "UFracLit" PrefixI True) (S1 (MetaSel (Just "_fracLitValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Rational)) :+: C1 (MetaCons "UPrimIntLit" PrefixI True) (S1 (MetaSel (Just "_intLitValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Integer))))) :+: ((C1 (MetaCons "UPrimWordLit" PrefixI True) (S1 (MetaSel (Just "_intLitValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Integer)) :+: C1 (MetaCons "UPrimFloatLit" PrefixI True) (S1 (MetaSel (Just "_floatLitValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Rational))) :+: (C1 (MetaCons "UPrimDoubleLit" PrefixI True) (S1 (MetaSel (Just "_floatLitValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Rational)) :+: (C1 (MetaCons "UPrimCharLit" PrefixI True) (S1 (MetaSel (Just "_charLitValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Char)) :+: C1 (MetaCons "UPrimStringLit" PrefixI True) (S1 (MetaSel (Just "_stringLitValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String))))))
type IgnoredFields (ULiteral dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (ULiteral dom stage) = (Right "_charLitValue" :: Either (Symbol, Nat) Symbol) ': ((Right "_stringLitValue" :: Either (Symbol, Nat) Symbol) ': ((Right "_intLitValue" :: Either (Symbol, Nat) Symbol) ': ((Right "_fracLitValue" :: Either (Symbol, Nat) Symbol) ': ((Right "_intLitValue" :: Either (Symbol, Nat) Symbol) ': ((Right "_intLitValue" :: Either (Symbol, Nat) Symbol) ': ((Right "_floatLitValue" :: Either (Symbol, Nat) Symbol) ': ((Right "_floatLitValue" :: Either (Symbol, Nat) Symbol) ': ((Right "_charLitValue" :: Either (Symbol, Nat) Symbol) ': ((Right "_stringLitValue" :: Either (Symbol, Nat) Symbol) ': ([] :: [Either (Symbol, Nat) Symbol]))))))))))

data UOperator dom stage Source #

Constructors

UBacktickOp

A normal name used as an operator with backticks: a mod b

Fields

UNormalOp

A normal operator used as an operator.

Fields

Instances
SourceInfoTraversal UOperator Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UOperator dom st1 -> f (UOperator dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UOperator dom st1 -> f (UOperator dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UOperator dom st1 -> f (UOperator dom st2) Source #

SemanticTraversal UOperator Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UOperator dom1 st -> f (UOperator dom2 st) Source #

(GoodOperationFor c (UOperator dom stage), ClassyPlate c (Ann UQualifiedName dom stage), ClassyPlate c (Ann UQualifiedName dom stage)) => ClassyPlate c (UOperator dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UOperator dom stage -> UOperator dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UOperator dom stage -> m (UOperator dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UOperator dom stage -> UOperator dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UOperator dom stage -> m (UOperator dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UOperator dom stage -> UOperator dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UOperator dom stage -> m (UOperator dom stage) #

(Domain dom, SourceInfo stage) => Data (UOperator dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UOperator dom stage -> c (UOperator dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UOperator dom stage) #

toConstr :: UOperator dom stage -> Constr #

dataTypeOf :: UOperator dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UOperator dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UOperator dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UOperator dom stage -> UOperator dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UOperator dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UOperator dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UOperator dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UOperator dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UOperator dom stage -> m (UOperator dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UOperator dom stage -> m (UOperator dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UOperator dom stage -> m (UOperator dom stage) #

Domain dom => Generic (UOperator dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UOperator dom stage) :: * -> * #

Methods

from :: UOperator dom stage -> Rep (UOperator dom stage) x #

to :: Rep (UOperator dom stage) x -> UOperator dom stage #

type Rep (UOperator dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UOperator dom stage) = D1 (MetaData "UOperator" "Language.Haskell.Tools.AST.Representation.Names" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UBacktickOp" PrefixI True) (S1 (MetaSel (Just "_operatorName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UQualifiedName dom stage))) :+: C1 (MetaCons "UNormalOp" PrefixI True) (S1 (MetaSel (Just "_operatorName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UQualifiedName dom stage))))
type IgnoredFields (UOperator dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UOperator dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UName dom stage Source #

Constructors

UParenName

Parenthesized name: foldl (+) 0

Fields

UNormalName

A normal, non-operator name.

Fields

UImplicitName

Implicit name: ?var

Fields

Instances
SourceInfoTraversal UName Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UName dom st1 -> f (UName dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UName dom st1 -> f (UName dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UName dom st1 -> f (UName dom st2) Source #

SemanticTraversal UName Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UName dom1 st -> f (UName dom2 st) Source #

(GoodOperationFor c (UName dom stage), ClassyPlate c (Ann UQualifiedName dom stage), ClassyPlate c (Ann UQualifiedName dom stage), ClassyPlate c (Ann UQualifiedName dom stage)) => ClassyPlate c (UName dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UName dom stage -> UName dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UName dom stage -> m (UName dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UName dom stage -> UName dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UName dom stage -> m (UName dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UName dom stage -> UName dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UName dom stage -> m (UName dom stage) #

(Domain dom, SourceInfo stage) => Data (UName dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UName dom stage -> c (UName dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UName dom stage) #

toConstr :: UName dom stage -> Constr #

dataTypeOf :: UName dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UName dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UName dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UName dom stage -> UName dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UName dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UName dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UName dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UName dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UName dom stage -> m (UName dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UName dom stage -> m (UName dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UName dom stage -> m (UName dom stage) #

Domain dom => Generic (UName dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UName dom stage) :: * -> * #

Methods

from :: UName dom stage -> Rep (UName dom stage) x #

to :: Rep (UName dom stage) x -> UName dom stage #

HasIdInfo dom => HasIdInfo' (Ann UName dom st) Source # 
Instance details

Defined in Language.Haskell.Tools.AST.SemaInfoClasses

Methods

semanticsId :: Ann UName dom st -> Id Source #

HasNameInfo dom => HasNameInfo' (Ann UName dom st) Source # 
Instance details

Defined in Language.Haskell.Tools.AST.SemaInfoClasses

Methods

semanticsName :: Ann UName dom st -> Maybe Name Source #

type Rep (UName dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UName dom stage) = D1 (MetaData "UName" "Language.Haskell.Tools.AST.Representation.Names" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UParenName" PrefixI True) (S1 (MetaSel (Just "_simpleName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UQualifiedName dom stage))) :+: (C1 (MetaCons "UNormalName" PrefixI True) (S1 (MetaSel (Just "_simpleName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UQualifiedName dom stage))) :+: C1 (MetaCons "UImplicitName" PrefixI True) (S1 (MetaSel (Just "_simpleName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UQualifiedName dom stage)))))
type IgnoredFields (UName dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UName dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UQualifiedName dom stage Source #

Possible qualified names. Contains also implicit names. Linear implicit parameter: %x. Non-linear implicit parameter: ?x.

Constructors

UQualifiedName 

Fields

Instances
SourceInfoTraversal UQualifiedName Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UQualifiedName dom st1 -> f (UQualifiedName dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UQualifiedName dom st1 -> f (UQualifiedName dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UQualifiedName dom st1 -> f (UQualifiedName dom st2) Source #

SemanticTraversal UQualifiedName Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UQualifiedName dom1 st -> f (UQualifiedName dom2 st) Source #

(GoodOperationFor c (UQualifiedName dom stage), ClassyPlate c (AnnListG UNamePart dom stage), ClassyPlate c (Ann UNamePart dom stage)) => ClassyPlate c (UQualifiedName dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UQualifiedName dom stage -> UQualifiedName dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UQualifiedName dom stage -> m (UQualifiedName dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UQualifiedName dom stage -> UQualifiedName dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UQualifiedName dom stage -> m (UQualifiedName dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UQualifiedName dom stage -> UQualifiedName dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UQualifiedName dom stage -> m (UQualifiedName dom stage) #

(Domain dom, SourceInfo stage) => Data (UQualifiedName dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UQualifiedName dom stage -> c (UQualifiedName dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UQualifiedName dom stage) #

toConstr :: UQualifiedName dom stage -> Constr #

dataTypeOf :: UQualifiedName dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UQualifiedName dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UQualifiedName dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UQualifiedName dom stage -> UQualifiedName dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UQualifiedName dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UQualifiedName dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UQualifiedName dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UQualifiedName dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UQualifiedName dom stage -> m (UQualifiedName dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UQualifiedName dom stage -> m (UQualifiedName dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UQualifiedName dom stage -> m (UQualifiedName dom stage) #

Domain dom => Generic (UQualifiedName dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UQualifiedName dom stage) :: * -> * #

Methods

from :: UQualifiedName dom stage -> Rep (UQualifiedName dom stage) x #

to :: Rep (UQualifiedName dom stage) x -> UQualifiedName dom stage #

HasDefiningInfo dom => HasDefiningInfo' (Ann UQualifiedName dom st) Source # 
Instance details

Defined in Language.Haskell.Tools.AST.SemaInfoClasses

HasScopeInfo dom => HasScopeInfo' (Ann UQualifiedName dom st) Source # 
Instance details

Defined in Language.Haskell.Tools.AST.SemaInfoClasses

HasFixityInfo dom => HasFixityInfo' (Ann UQualifiedName dom st) Source # 
Instance details

Defined in Language.Haskell.Tools.AST.SemaInfoClasses

HasIdInfo dom => HasIdInfo' (Ann UQualifiedName dom st) Source # 
Instance details

Defined in Language.Haskell.Tools.AST.SemaInfoClasses

Methods

semanticsId :: Ann UQualifiedName dom st -> Id Source #

HasNameInfo dom => HasNameInfo' (Ann UQualifiedName dom st) Source # 
Instance details

Defined in Language.Haskell.Tools.AST.SemaInfoClasses

type Rep (UQualifiedName dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UQualifiedName dom stage) = D1 (MetaData "UQualifiedName" "Language.Haskell.Tools.AST.Representation.Names" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UQualifiedName" PrefixI True) (S1 (MetaSel (Just "_qualifiers") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (AnnListG UNamePart dom stage)) :*: S1 (MetaSel (Just "_unqualifiedName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ann UNamePart dom stage))))
type IgnoredFields (UQualifiedName dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UQualifiedName dom stage) = ([] :: [Either (Symbol, Nat) Symbol])

data UNamePart dom stage Source #

Parts of a qualified name.

Constructors

UNamePart 
Instances
SourceInfoTraversal UNamePart Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UNamePart dom st1 -> f (UNamePart dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UNamePart dom st1 -> f (UNamePart dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UNamePart dom st1 -> f (UNamePart dom st2) Source #

SemanticTraversal UNamePart Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UNamePart dom1 st -> f (UNamePart dom2 st) Source #

GoodOperationFor c (UNamePart dom stage) => ClassyPlate c (UNamePart dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UNamePart dom stage -> UNamePart dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UNamePart dom stage -> m (UNamePart dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UNamePart dom stage -> UNamePart dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UNamePart dom stage -> m (UNamePart dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UNamePart dom stage -> UNamePart dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UNamePart dom stage -> m (UNamePart dom stage) #

(Domain dom, SourceInfo stage) => Data (UNamePart dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UNamePart dom stage -> c (UNamePart dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UNamePart dom stage) #

toConstr :: UNamePart dom stage -> Constr #

dataTypeOf :: UNamePart dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UNamePart dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UNamePart dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UNamePart dom stage -> UNamePart dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UNamePart dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UNamePart dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UNamePart dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UNamePart dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UNamePart dom stage -> m (UNamePart dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UNamePart dom stage -> m (UNamePart dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UNamePart dom stage -> m (UNamePart dom stage) #

Domain dom => Generic (UNamePart dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UNamePart dom stage) :: * -> * #

Methods

from :: UNamePart dom stage -> Rep (UNamePart dom stage) x #

to :: Rep (UNamePart dom stage) x -> UNamePart dom stage #

type Rep (UNamePart dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UNamePart dom stage) = D1 (MetaData "UNamePart" "Language.Haskell.Tools.AST.Representation.Names" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UNamePart" PrefixI True) (S1 (MetaSel (Just "_simpleNameStr") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)))
type IgnoredFields (UNamePart dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UNamePart dom stage) = (Right "_simpleNameStr" :: Either (Symbol, Nat) Symbol) ': ([] :: [Either (Symbol, Nat) Symbol])

data UStringNode dom stage Source #

Program elements formatted as string literals (import packages, pragma texts)

Constructors

UStringNode 
Instances
SourceInfoTraversal UStringNode Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SourceInfoTraversal

Methods

sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UStringNode dom st1 -> f (UStringNode dom st2) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> UStringNode dom st1 -> f (UStringNode dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> UStringNode dom st1 -> f (UStringNode dom st2) Source #

SemanticTraversal UStringNode Source # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.SemanticTraversal

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> UStringNode dom1 st -> f (UStringNode dom2 st) Source #

GoodOperationFor c (UStringNode dom stage) => ClassyPlate c (UStringNode dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

Methods

bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UStringNode dom stage -> UStringNode dom stage #

bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UStringNode dom stage -> m (UStringNode dom stage) #

descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UStringNode dom stage -> UStringNode dom stage #

descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UStringNode dom stage -> m (UStringNode dom stage) #

topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> UStringNode dom stage -> UStringNode dom stage #

topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> UStringNode dom stage -> m (UStringNode dom stage) #

(Domain dom, SourceInfo stage) => Data (UStringNode dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UStringNode dom stage -> c (UStringNode dom stage) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UStringNode dom stage) #

toConstr :: UStringNode dom stage -> Constr #

dataTypeOf :: UStringNode dom stage -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UStringNode dom stage)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UStringNode dom stage)) #

gmapT :: (forall b. Data b => b -> b) -> UStringNode dom stage -> UStringNode dom stage #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UStringNode dom stage -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UStringNode dom stage -> r #

gmapQ :: (forall d. Data d => d -> u) -> UStringNode dom stage -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UStringNode dom stage -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UStringNode dom stage -> m (UStringNode dom stage) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UStringNode dom stage -> m (UStringNode dom stage) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UStringNode dom stage -> m (UStringNode dom stage) #

Domain dom => Generic (UStringNode dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

Associated Types

type Rep (UStringNode dom stage) :: * -> * #

Methods

from :: UStringNode dom stage -> Rep (UStringNode dom stage) x #

to :: Rep (UStringNode dom stage) x -> UStringNode dom stage #

type Rep (UStringNode dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.Generic

type Rep (UStringNode dom stage) = D1 (MetaData "UStringNode" "Language.Haskell.Tools.AST.Representation.Names" "haskell-tools-ast-1.1.0.2-IcFuLSyKHEi15r3iGSx9g3" False) (C1 (MetaCons "UStringNode" PrefixI True) (S1 (MetaSel (Just "_stringNodeStr") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)))
type IgnoredFields (UStringNode dom stage) # 
Instance details

Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate

type IgnoredFields (UStringNode dom stage) = (Right "_stringNodeStr" :: Either (Symbol, Nat) Symbol) ': ([] :: [Either (Symbol, Nat) Symbol])