Safe Haskell	None
Language	Haskell2010

Language.Haskell.Tools.AST.Ann

Contents

Annotation type resolution
Annotations
Info types

Description

Parts of AST representation for keeping extra data

Synopsis

data RangeStage
data NormRangeStage
data RngTemplateStage
data SrcTemplateStage
data Dom name
data IdDom
type SemanticInfo (domain :: *) (node :: * -> * -> *) = SemanticInfo' domain (SemaInfoClassify node)
data SemaInfoNameCls
data SemaInfoLitCls
data SemaInfoExprCls
data SemaInfoImportCls
data SemaInfoModuleCls
data SemaInfoDefaultCls
data SemaInfoWildcardCls
type family SemaInfoClassify (node :: * -> * -> *) where ...
type family SemanticInfo' (domain :: *) (nodecls :: *)
type Domain d = (Typeable d, Data d, SemanticInfo' d SemaInfoDefaultCls ~ NoSemanticInfo, Data (SemanticInfo' d SemaInfoNameCls), Data (SemanticInfo' d SemaInfoLitCls), Data (SemanticInfo' d SemaInfoExprCls), Data (SemanticInfo' d SemaInfoImportCls), Data (SemanticInfo' d SemaInfoModuleCls), Data (SemanticInfo' d SemaInfoWildcardCls))
type DomainWith e d = (Data (SemanticInfo' d (SemaInfoClassify e)), Domain d)
class HasRange a where
- getRange :: a -> SrcSpan
- setRange :: SrcSpan -> a -> a
class (Typeable stage, Data stage, Data (SpanInfo stage), Data (ListInfo stage), Data (OptionalInfo stage), HasRange (SpanInfo stage), HasRange (ListInfo stage), HasRange (OptionalInfo stage)) => SourceInfo stage where
- data SpanInfo stage :: *
- data ListInfo stage :: *
- data OptionalInfo stage :: *
shortShowSpan :: SrcSpan -> String
shortShowSpanWithFile :: SrcSpan -> String
shortShowLoc :: SrcLoc -> String
class SourceInfo stage => RangeInfo stage where
- nodeSpan :: Simple Lens (SpanInfo stage) SrcSpan
- listPos :: Simple Lens (ListInfo stage) SrcLoc
- optionalPos :: Simple Lens (OptionalInfo stage) SrcLoc
data NodeInfo sema src = NodeInfo {
- _semanticInfo :: sema
- _sourceInfo :: src
}
sourceInfo :: forall sema src src'. Lens (NodeInfo sema src) (NodeInfo sema src') src src'
semanticInfo :: forall sema src sema'. Lens (NodeInfo sema src) (NodeInfo sema' src) sema sema'
data Ann elem dom stage = Ann {
- _annotation :: NodeInfo (SemanticInfo dom elem) (SpanInfo stage)
- _element :: elem dom stage
}
element :: forall elem dom stage. Lens (Ann elem dom stage) (Ann elem dom stage) (elem dom stage) (elem dom stage)
annotation :: forall elem dom stage. Lens (Ann elem dom stage) (Ann elem dom stage) (NodeInfo (SemanticInfo dom elem) (SpanInfo stage)) (NodeInfo (SemanticInfo dom elem) (SpanInfo stage))
data AnnListG elem dom stage = AnnListG {
- _annListAnnot :: NodeInfo (SemanticInfo dom (AnnListG elem)) (ListInfo stage)
- _annListElems :: [Ann elem dom stage]
}
annListElems :: forall elem dom stage. Lens (AnnListG elem dom stage) (AnnListG elem dom stage) [Ann elem dom stage] [Ann elem dom stage]
annListAnnot :: forall elem dom stage. Lens (AnnListG elem dom stage) (AnnListG elem dom stage) (NodeInfo (SemanticInfo dom (AnnListG elem)) (ListInfo stage)) (NodeInfo (SemanticInfo dom (AnnListG elem)) (ListInfo stage))
annList :: Traversal (AnnListG e d s) (AnnListG e d s) (Ann e d s) (Ann e d s)
data AnnMaybeG elem dom stage = AnnMaybeG {
- _annMaybeAnnot :: NodeInfo (SemanticInfo dom (AnnMaybeG elem)) (OptionalInfo stage)
- _annMaybe :: Maybe (Ann elem dom stage)
}
annMaybeAnnot :: forall elem dom stage. Lens (AnnMaybeG elem dom stage) (AnnMaybeG elem dom stage) (NodeInfo (SemanticInfo dom (AnnMaybeG elem)) (OptionalInfo stage)) (NodeInfo (SemanticInfo dom (AnnMaybeG elem)) (OptionalInfo stage))
annMaybe :: forall elem dom stage. Lens (AnnMaybeG elem dom stage) (AnnMaybeG elem dom stage) (Maybe (Ann elem dom stage)) (Maybe (Ann elem dom stage))
class HasSourceInfo e where
- type SourceInfoType e :: *
- srcInfo :: Simple Lens e (SourceInfoType e)
annJust :: Partial (AnnMaybeG e d s) (AnnMaybeG e d s) (Ann e d s) (Ann e d s)
annNil :: NodeInfo (SemanticInfo d (AnnListG e)) (ListInfo s) -> AnnListG e d s
isAnnNothing :: AnnMaybeG e d s -> Bool
isAnnJust :: AnnMaybeG e d s -> Bool
annLength :: AnnListG e d s -> Int
annNothing :: NodeInfo (SemanticInfo d (AnnMaybeG e)) (OptionalInfo s) -> AnnMaybeG e d s
class ApplySemaChange cls where
- appSemaChange :: SemaTrf f dom1 dom2 -> SemanticInfo' dom1 cls -> f (SemanticInfo' dom2 cls)
class ApplySemaChange (SemaInfoClassify a) => SemanticTraversal a where
- semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> a dom1 st -> f (a dom2 st)
data SemaTrf f dom1 dom2 = SemaTrf {
- trfSemaNameCls :: SemanticInfo' dom1 SemaInfoNameCls -> f (SemanticInfo' dom2 SemaInfoNameCls)
- trfSemaExprCls :: SemanticInfo' dom1 SemaInfoExprCls -> f (SemanticInfo' dom2 SemaInfoExprCls)
- trfSemaLitCls :: SemanticInfo' dom1 SemaInfoLitCls -> f (SemanticInfo' dom2 SemaInfoLitCls)
- trfSemaImportCls :: SemanticInfo' dom1 SemaInfoImportCls -> f (SemanticInfo' dom2 SemaInfoImportCls)
- trfSemaModuleCls :: SemanticInfo' dom1 SemaInfoModuleCls -> f (SemanticInfo' dom2 SemaInfoModuleCls)
- trfSemaWildcardCls :: SemanticInfo' dom1 SemaInfoWildcardCls -> f (SemanticInfo' dom2 SemaInfoWildcardCls)
- trfSemaDefault :: SemanticInfo' dom1 SemaInfoDefaultCls -> f (SemanticInfo' dom2 SemaInfoDefaultCls)
}
class SourceInfoTraversal a where
- sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> a dom st1 -> f (a dom st2)
- sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> a dom st1 -> f (a dom st2)
- sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> a dom st1 -> f (a dom st2)
data SourceInfoTrf f st1 st2 = SourceInfoTrf {
- trfSpanInfo :: SpanInfo st1 -> f (SpanInfo st2)
- trfListInfo :: ListInfo st1 -> f (ListInfo st2)
- trfOptionalInfo :: OptionalInfo st1 -> f (OptionalInfo st2)
}

Annotation type resolution

data RangeStage Source #

A stage in which the nodes are marked with the ranges in the source files which contain the source code of the given AST element.

Instances

Data RangeStage Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RangeStage -> c RangeStage # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RangeStage # toConstr :: RangeStage -> Constr # dataTypeOf :: RangeStage -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c RangeStage) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RangeStage) # gmapT :: (forall b. Data b => b -> b) -> RangeStage -> RangeStage # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RangeStage -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RangeStage -> r # gmapQ :: (forall d. Data d => d -> u) -> RangeStage -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> RangeStage -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RangeStage -> m RangeStage # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RangeStage -> m RangeStage # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RangeStage -> m RangeStage #
RangeInfo RangeStage Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods nodeSpan :: Simple Lens (SpanInfo RangeStage) SrcSpan Source # listPos :: Simple Lens (ListInfo RangeStage) SrcLoc Source # optionalPos :: Simple Lens (OptionalInfo RangeStage) SrcLoc Source #
SourceInfo RangeStage Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Associated Types data SpanInfo RangeStage :: Type Source # data ListInfo RangeStage :: Type Source # data OptionalInfo RangeStage :: Type Source #
Data (SpanInfo RangeStage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SpanInfo RangeStage -> c (SpanInfo RangeStage) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (SpanInfo RangeStage) # toConstr :: SpanInfo RangeStage -> Constr # dataTypeOf :: SpanInfo RangeStage -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (SpanInfo RangeStage)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (SpanInfo RangeStage)) # gmapT :: (forall b. Data b => b -> b) -> SpanInfo RangeStage -> SpanInfo RangeStage # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SpanInfo RangeStage -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SpanInfo RangeStage -> r # gmapQ :: (forall d. Data d => d -> u) -> SpanInfo RangeStage -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SpanInfo RangeStage -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SpanInfo RangeStage -> m (SpanInfo RangeStage) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SpanInfo RangeStage -> m (SpanInfo RangeStage) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SpanInfo RangeStage -> m (SpanInfo RangeStage) #
Data (ListInfo RangeStage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ListInfo RangeStage -> c (ListInfo RangeStage) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ListInfo RangeStage) # toConstr :: ListInfo RangeStage -> Constr # dataTypeOf :: ListInfo RangeStage -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ListInfo RangeStage)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ListInfo RangeStage)) # gmapT :: (forall b. Data b => b -> b) -> ListInfo RangeStage -> ListInfo RangeStage # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ListInfo RangeStage -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ListInfo RangeStage -> r # gmapQ :: (forall d. Data d => d -> u) -> ListInfo RangeStage -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ListInfo RangeStage -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ListInfo RangeStage -> m (ListInfo RangeStage) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ListInfo RangeStage -> m (ListInfo RangeStage) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ListInfo RangeStage -> m (ListInfo RangeStage) #
Data (OptionalInfo RangeStage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OptionalInfo RangeStage -> c (OptionalInfo RangeStage) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (OptionalInfo RangeStage) # toConstr :: OptionalInfo RangeStage -> Constr # dataTypeOf :: OptionalInfo RangeStage -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (OptionalInfo RangeStage)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (OptionalInfo RangeStage)) # gmapT :: (forall b. Data b => b -> b) -> OptionalInfo RangeStage -> OptionalInfo RangeStage # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OptionalInfo RangeStage -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OptionalInfo RangeStage -> r # gmapQ :: (forall d. Data d => d -> u) -> OptionalInfo RangeStage -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> OptionalInfo RangeStage -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> OptionalInfo RangeStage -> m (OptionalInfo RangeStage) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OptionalInfo RangeStage -> m (OptionalInfo RangeStage) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OptionalInfo RangeStage -> m (OptionalInfo RangeStage) #
Show (SpanInfo RangeStage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods showsPrec :: Int -> SpanInfo RangeStage -> ShowS # show :: SpanInfo RangeStage -> String # showList :: [SpanInfo RangeStage] -> ShowS #
Show (ListInfo RangeStage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods showsPrec :: Int -> ListInfo RangeStage -> ShowS # show :: ListInfo RangeStage -> String # showList :: [ListInfo RangeStage] -> ShowS #
Show (OptionalInfo RangeStage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods showsPrec :: Int -> OptionalInfo RangeStage -> ShowS # show :: OptionalInfo RangeStage -> String # showList :: [OptionalInfo RangeStage] -> ShowS #
HasRange (SpanInfo RangeStage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods getRange :: SpanInfo RangeStage -> SrcSpan Source # setRange :: SrcSpan -> SpanInfo RangeStage -> SpanInfo RangeStage Source #
HasRange (ListInfo RangeStage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods getRange :: ListInfo RangeStage -> SrcSpan Source # setRange :: SrcSpan -> ListInfo RangeStage -> ListInfo RangeStage Source #
HasRange (OptionalInfo RangeStage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods getRange :: OptionalInfo RangeStage -> SrcSpan Source # setRange :: SrcSpan -> OptionalInfo RangeStage -> OptionalInfo RangeStage Source #
data SpanInfo RangeStage Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann data SpanInfo RangeStage = NodeSpan { _nodeSpan :: SrcSpan }
data ListInfo RangeStage Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann data ListInfo RangeStage = ListPos { _listBefore :: String _listAfter :: String _listDefaultSep :: String _listIndented :: Maybe [Bool] _listPos :: SrcLoc }
data OptionalInfo RangeStage Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann data OptionalInfo RangeStage = OptionalPos { _optionalBefore :: String _optionalAfter :: String _optionalPos :: SrcLoc }

data NormRangeStage Source #

A stage in which the nodes are still marked with ranges, but these ranges are normalized. Optional and list elements also have ranges in that state.

Instances

Data NormRangeStage Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NormRangeStage -> c NormRangeStage # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NormRangeStage # toConstr :: NormRangeStage -> Constr # dataTypeOf :: NormRangeStage -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NormRangeStage) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NormRangeStage) # gmapT :: (forall b. Data b => b -> b) -> NormRangeStage -> NormRangeStage # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NormRangeStage -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NormRangeStage -> r # gmapQ :: (forall d. Data d => d -> u) -> NormRangeStage -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> NormRangeStage -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NormRangeStage -> m NormRangeStage # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NormRangeStage -> m NormRangeStage # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NormRangeStage -> m NormRangeStage #
SourceInfo NormRangeStage Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Associated Types data SpanInfo NormRangeStage :: Type Source # data ListInfo NormRangeStage :: Type Source # data OptionalInfo NormRangeStage :: Type Source #
Data (SpanInfo NormRangeStage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SpanInfo NormRangeStage -> c (SpanInfo NormRangeStage) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (SpanInfo NormRangeStage) # toConstr :: SpanInfo NormRangeStage -> Constr # dataTypeOf :: SpanInfo NormRangeStage -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (SpanInfo NormRangeStage)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (SpanInfo NormRangeStage)) # gmapT :: (forall b. Data b => b -> b) -> SpanInfo NormRangeStage -> SpanInfo NormRangeStage # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SpanInfo NormRangeStage -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SpanInfo NormRangeStage -> r # gmapQ :: (forall d. Data d => d -> u) -> SpanInfo NormRangeStage -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SpanInfo NormRangeStage -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SpanInfo NormRangeStage -> m (SpanInfo NormRangeStage) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SpanInfo NormRangeStage -> m (SpanInfo NormRangeStage) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SpanInfo NormRangeStage -> m (SpanInfo NormRangeStage) #
Data (ListInfo NormRangeStage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ListInfo NormRangeStage -> c (ListInfo NormRangeStage) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ListInfo NormRangeStage) # toConstr :: ListInfo NormRangeStage -> Constr # dataTypeOf :: ListInfo NormRangeStage -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ListInfo NormRangeStage)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ListInfo NormRangeStage)) # gmapT :: (forall b. Data b => b -> b) -> ListInfo NormRangeStage -> ListInfo NormRangeStage # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ListInfo NormRangeStage -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ListInfo NormRangeStage -> r # gmapQ :: (forall d. Data d => d -> u) -> ListInfo NormRangeStage -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ListInfo NormRangeStage -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ListInfo NormRangeStage -> m (ListInfo NormRangeStage) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ListInfo NormRangeStage -> m (ListInfo NormRangeStage) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ListInfo NormRangeStage -> m (ListInfo NormRangeStage) #
Data (OptionalInfo NormRangeStage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OptionalInfo NormRangeStage -> c (OptionalInfo NormRangeStage) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (OptionalInfo NormRangeStage) # toConstr :: OptionalInfo NormRangeStage -> Constr # dataTypeOf :: OptionalInfo NormRangeStage -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (OptionalInfo NormRangeStage)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (OptionalInfo NormRangeStage)) # gmapT :: (forall b. Data b => b -> b) -> OptionalInfo NormRangeStage -> OptionalInfo NormRangeStage # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OptionalInfo NormRangeStage -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OptionalInfo NormRangeStage -> r # gmapQ :: (forall d. Data d => d -> u) -> OptionalInfo NormRangeStage -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> OptionalInfo NormRangeStage -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> OptionalInfo NormRangeStage -> m (OptionalInfo NormRangeStage) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OptionalInfo NormRangeStage -> m (OptionalInfo NormRangeStage) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OptionalInfo NormRangeStage -> m (OptionalInfo NormRangeStage) #
Show (SpanInfo NormRangeStage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods showsPrec :: Int -> SpanInfo NormRangeStage -> ShowS # show :: SpanInfo NormRangeStage -> String # showList :: [SpanInfo NormRangeStage] -> ShowS #
Show (ListInfo NormRangeStage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods showsPrec :: Int -> ListInfo NormRangeStage -> ShowS # show :: ListInfo NormRangeStage -> String # showList :: [ListInfo NormRangeStage] -> ShowS #
Show (OptionalInfo NormRangeStage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods showsPrec :: Int -> OptionalInfo NormRangeStage -> ShowS # show :: OptionalInfo NormRangeStage -> String # showList :: [OptionalInfo NormRangeStage] -> ShowS #
HasRange (SpanInfo NormRangeStage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods getRange :: SpanInfo NormRangeStage -> SrcSpan Source # setRange :: SrcSpan -> SpanInfo NormRangeStage -> SpanInfo NormRangeStage Source #
HasRange (ListInfo NormRangeStage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods getRange :: ListInfo NormRangeStage -> SrcSpan Source # setRange :: SrcSpan -> ListInfo NormRangeStage -> ListInfo NormRangeStage Source #
HasRange (OptionalInfo NormRangeStage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods getRange :: OptionalInfo NormRangeStage -> SrcSpan Source # setRange :: SrcSpan -> OptionalInfo NormRangeStage -> OptionalInfo NormRangeStage Source #
data SpanInfo NormRangeStage Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann data SpanInfo NormRangeStage = NormNodeInfo { _normNodeSpan :: SrcSpan }
data ListInfo NormRangeStage Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann data ListInfo NormRangeStage = NormListInfo { _normListBefore :: String _normListAfter :: String _normListDefaultSep :: String _normListIndented :: Maybe [Bool] _normListSpan :: SrcSpan }
data OptionalInfo NormRangeStage Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann data OptionalInfo NormRangeStage = NormOptInfo { _normOptBefore :: String _normOptAfter :: String _normOptSpan :: SrcSpan }

data RngTemplateStage Source #

A stage in which AST elements are marked with templates. These templates are hierarchical, and contain the places of the children elements of the node.

Instances

Data RngTemplateStage Source #

Instance details

Defined in Language.Haskell.Tools.AST.Ann

Methods

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

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

toConstr :: RngTemplateStage -> Constr #

dataTypeOf :: RngTemplateStage -> DataType #

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

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

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

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

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

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

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

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

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

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

data SrcTemplateStage Source #

A stage where the annotation controls how the original source code can be retrieved from the AST. A source template is assigned to each node. It has holes where the content of an other node should be printed and ranges for the source code of the node.

Instances

Data SrcTemplateStage Source #

Instance details

Defined in Language.Haskell.Tools.AST.Ann

Methods

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

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

toConstr :: SrcTemplateStage -> Constr #

dataTypeOf :: SrcTemplateStage -> DataType #

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

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

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

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

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

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

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

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

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

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

data Dom name Source #

With this domain, semantic information can be parameterized. In practice it is only used if the compilation cannot proceed past the type checking phase.

Instances

(Data name, Typeable name) => Data (Dom name) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Dom name -> c (Dom name) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Dom name) # toConstr :: Dom name -> Constr # dataTypeOf :: Dom name -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Dom name)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Dom name)) # gmapT :: (forall b. Data b => b -> b) -> Dom name -> Dom name # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Dom name -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Dom name -> r # gmapQ :: (forall d. Data d => d -> u) -> Dom name -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Dom name -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Dom name -> m (Dom name) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Dom name -> m (Dom name) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Dom name -> m (Dom name) #
type SemanticInfo' (Dom n) SemaInfoDefaultCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SemanticInfo' (Dom n) SemaInfoDefaultCls = NoSemanticInfo
type SemanticInfo' (Dom n) SemaInfoWildcardCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SemanticInfo' (Dom n) SemaInfoWildcardCls = ImplicitFieldInfo
type SemanticInfo' (Dom n) SemaInfoModuleCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SemanticInfo' (Dom n) SemaInfoModuleCls = ModuleInfo GhcRn
type SemanticInfo' (Dom n) SemaInfoImportCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SemanticInfo' (Dom n) SemaInfoImportCls = ImportInfo n
type SemanticInfo' (Dom n) SemaInfoExprCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SemanticInfo' (Dom n) SemaInfoExprCls = ScopeInfo
type SemanticInfo' (Dom n) SemaInfoLitCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SemanticInfo' (Dom n) SemaInfoLitCls = PreLiteralInfo
type SemanticInfo' (Dom n) SemaInfoNameCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SemanticInfo' (Dom n) SemaInfoNameCls = NameInfo n

data IdDom Source #

Instances

Data IdDom Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IdDom -> c IdDom # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c IdDom # toConstr :: IdDom -> Constr # dataTypeOf :: IdDom -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c IdDom) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IdDom) # gmapT :: (forall b. Data b => b -> b) -> IdDom -> IdDom # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IdDom -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IdDom -> r # gmapQ :: (forall d. Data d => d -> u) -> IdDom -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> IdDom -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> IdDom -> m IdDom # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IdDom -> m IdDom # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IdDom -> m IdDom #
type SemanticInfo' IdDom SemaInfoWildcardCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SemanticInfo' IdDom SemaInfoWildcardCls = ImplicitFieldInfo
type SemanticInfo' IdDom SemaInfoDefaultCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SemanticInfo' IdDom SemaInfoDefaultCls = NoSemanticInfo
type SemanticInfo' IdDom SemaInfoModuleCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SemanticInfo' IdDom SemaInfoModuleCls = ModuleInfo GhcTc
type SemanticInfo' IdDom SemaInfoImportCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SemanticInfo' IdDom SemaInfoImportCls = ImportInfo GhcTc
type SemanticInfo' IdDom SemaInfoExprCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SemanticInfo' IdDom SemaInfoExprCls = ScopeInfo
type SemanticInfo' IdDom SemaInfoLitCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SemanticInfo' IdDom SemaInfoLitCls = LiteralInfo
type SemanticInfo' IdDom SemaInfoNameCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SemanticInfo' IdDom SemaInfoNameCls = CNameInfo

type SemanticInfo (domain :: *) (node :: * -> * -> *) = SemanticInfo' domain (SemaInfoClassify node) Source #

data SemaInfoNameCls Source #

Instances

ApplySemaChange SemaInfoNameCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods appSemaChange :: SemaTrf f dom1 dom2 -> SemanticInfo' dom1 SemaInfoNameCls -> f (SemanticInfo' dom2 SemaInfoNameCls) Source #
type SemanticInfo' IdDom SemaInfoNameCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SemanticInfo' IdDom SemaInfoNameCls = CNameInfo
type SemanticInfo' (Dom n) SemaInfoNameCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SemanticInfo' (Dom n) SemaInfoNameCls = NameInfo n

data SemaInfoLitCls Source #

Instances

ApplySemaChange SemaInfoLitCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods appSemaChange :: SemaTrf f dom1 dom2 -> SemanticInfo' dom1 SemaInfoLitCls -> f (SemanticInfo' dom2 SemaInfoLitCls) Source #
type SemanticInfo' IdDom SemaInfoLitCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SemanticInfo' IdDom SemaInfoLitCls = LiteralInfo
type SemanticInfo' (Dom n) SemaInfoLitCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SemanticInfo' (Dom n) SemaInfoLitCls = PreLiteralInfo

data SemaInfoExprCls Source #

Instances

ApplySemaChange SemaInfoExprCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods appSemaChange :: SemaTrf f dom1 dom2 -> SemanticInfo' dom1 SemaInfoExprCls -> f (SemanticInfo' dom2 SemaInfoExprCls) Source #
type SemanticInfo' IdDom SemaInfoExprCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SemanticInfo' IdDom SemaInfoExprCls = ScopeInfo
type SemanticInfo' (Dom n) SemaInfoExprCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SemanticInfo' (Dom n) SemaInfoExprCls = ScopeInfo

data SemaInfoImportCls Source #

Instances

ApplySemaChange SemaInfoImportCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods appSemaChange :: SemaTrf f dom1 dom2 -> SemanticInfo' dom1 SemaInfoImportCls -> f (SemanticInfo' dom2 SemaInfoImportCls) Source #
type SemanticInfo' IdDom SemaInfoImportCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SemanticInfo' IdDom SemaInfoImportCls = ImportInfo GhcTc
type SemanticInfo' (Dom n) SemaInfoImportCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SemanticInfo' (Dom n) SemaInfoImportCls = ImportInfo n

data SemaInfoModuleCls Source #

Instances

ApplySemaChange SemaInfoModuleCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods appSemaChange :: SemaTrf f dom1 dom2 -> SemanticInfo' dom1 SemaInfoModuleCls -> f (SemanticInfo' dom2 SemaInfoModuleCls) Source #
type SemanticInfo' IdDom SemaInfoModuleCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SemanticInfo' IdDom SemaInfoModuleCls = ModuleInfo GhcTc
type SemanticInfo' (Dom n) SemaInfoModuleCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SemanticInfo' (Dom n) SemaInfoModuleCls = ModuleInfo GhcRn

data SemaInfoDefaultCls Source #

Instances

ApplySemaChange SemaInfoDefaultCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods appSemaChange :: SemaTrf f dom1 dom2 -> SemanticInfo' dom1 SemaInfoDefaultCls -> f (SemanticInfo' dom2 SemaInfoDefaultCls) Source #
type SemanticInfo' IdDom SemaInfoDefaultCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SemanticInfo' IdDom SemaInfoDefaultCls = NoSemanticInfo
type SemanticInfo' (Dom n) SemaInfoDefaultCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SemanticInfo' (Dom n) SemaInfoDefaultCls = NoSemanticInfo

data SemaInfoWildcardCls Source #

Instances

ApplySemaChange SemaInfoWildcardCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods appSemaChange :: SemaTrf f dom1 dom2 -> SemanticInfo' dom1 SemaInfoWildcardCls -> f (SemanticInfo' dom2 SemaInfoWildcardCls) Source #
type SemanticInfo' IdDom SemaInfoWildcardCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SemanticInfo' IdDom SemaInfoWildcardCls = ImplicitFieldInfo
type SemanticInfo' (Dom n) SemaInfoWildcardCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SemanticInfo' (Dom n) SemaInfoWildcardCls = ImplicitFieldInfo

type family SemaInfoClassify (node :: * -> * -> *) where ... Source #

type family SemanticInfo' (domain :: *) (nodecls :: *) Source #

Instances

type SemanticInfo' IdDom SemaInfoWildcardCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SemanticInfo' IdDom SemaInfoWildcardCls = ImplicitFieldInfo
type SemanticInfo' IdDom SemaInfoDefaultCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SemanticInfo' IdDom SemaInfoDefaultCls = NoSemanticInfo
type SemanticInfo' IdDom SemaInfoModuleCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SemanticInfo' IdDom SemaInfoModuleCls = ModuleInfo GhcTc
type SemanticInfo' IdDom SemaInfoImportCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SemanticInfo' IdDom SemaInfoImportCls = ImportInfo GhcTc
type SemanticInfo' IdDom SemaInfoExprCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SemanticInfo' IdDom SemaInfoExprCls = ScopeInfo
type SemanticInfo' IdDom SemaInfoLitCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SemanticInfo' IdDom SemaInfoLitCls = LiteralInfo
type SemanticInfo' IdDom SemaInfoNameCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SemanticInfo' IdDom SemaInfoNameCls = CNameInfo
type SemanticInfo' (Dom n) SemaInfoDefaultCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SemanticInfo' (Dom n) SemaInfoDefaultCls = NoSemanticInfo
type SemanticInfo' (Dom n) SemaInfoWildcardCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SemanticInfo' (Dom n) SemaInfoWildcardCls = ImplicitFieldInfo
type SemanticInfo' (Dom n) SemaInfoModuleCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SemanticInfo' (Dom n) SemaInfoModuleCls = ModuleInfo GhcRn
type SemanticInfo' (Dom n) SemaInfoImportCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SemanticInfo' (Dom n) SemaInfoImportCls = ImportInfo n
type SemanticInfo' (Dom n) SemaInfoExprCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SemanticInfo' (Dom n) SemaInfoExprCls = ScopeInfo
type SemanticInfo' (Dom n) SemaInfoLitCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SemanticInfo' (Dom n) SemaInfoLitCls = PreLiteralInfo
type SemanticInfo' (Dom n) SemaInfoNameCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SemanticInfo' (Dom n) SemaInfoNameCls = NameInfo n

type Domain d = (Typeable d, Data d, SemanticInfo' d SemaInfoDefaultCls ~ NoSemanticInfo, Data (SemanticInfo' d SemaInfoNameCls), Data (SemanticInfo' d SemaInfoLitCls), Data (SemanticInfo' d SemaInfoExprCls), Data (SemanticInfo' d SemaInfoImportCls), Data (SemanticInfo' d SemaInfoModuleCls), Data (SemanticInfo' d SemaInfoWildcardCls)) Source #

A semantic domain for the AST. The semantic domain maps semantic information for the different types of nodes in the AST. The kind of semantic domain for an AST depends on which stages of the compilation it passed. However after transforming the GHC representation to our AST, the domain stays the same. The domain is not applied to the AST elements that are generated while refactoring.

type DomainWith e d = (Data (SemanticInfo' d (SemaInfoClassify e)), Domain d) Source #

class HasRange a where Source #

Extracts or modifies the concrete range corresponding to a given source info. In case of lists and optional elements, it may not contain the elements inside.

Methods

getRange :: a -> SrcSpan Source #

setRange :: SrcSpan -> a -> a Source #

Instances

HasRange (SpanInfo NormRangeStage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods getRange :: SpanInfo NormRangeStage -> SrcSpan Source # setRange :: SrcSpan -> SpanInfo NormRangeStage -> SpanInfo NormRangeStage Source #
HasRange (SpanInfo RangeStage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods getRange :: SpanInfo RangeStage -> SrcSpan Source # setRange :: SrcSpan -> SpanInfo RangeStage -> SpanInfo RangeStage Source #
HasRange (ListInfo NormRangeStage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods getRange :: ListInfo NormRangeStage -> SrcSpan Source # setRange :: SrcSpan -> ListInfo NormRangeStage -> ListInfo NormRangeStage Source #
HasRange (ListInfo RangeStage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods getRange :: ListInfo RangeStage -> SrcSpan Source # setRange :: SrcSpan -> ListInfo RangeStage -> ListInfo RangeStage Source #
HasRange (OptionalInfo NormRangeStage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods getRange :: OptionalInfo NormRangeStage -> SrcSpan Source # setRange :: SrcSpan -> OptionalInfo NormRangeStage -> OptionalInfo NormRangeStage Source #
HasRange (OptionalInfo RangeStage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods getRange :: OptionalInfo RangeStage -> SrcSpan Source # setRange :: SrcSpan -> OptionalInfo RangeStage -> OptionalInfo RangeStage Source #
SourceInfo stage => HasRange (Ann elem dom stage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods getRange :: Ann elem dom stage -> SrcSpan Source # setRange :: SrcSpan -> Ann elem dom stage -> Ann elem dom stage Source #
SourceInfo stage => HasRange (AnnListG elem dom stage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods getRange :: AnnListG elem dom stage -> SrcSpan Source # setRange :: SrcSpan -> AnnListG elem dom stage -> AnnListG elem dom stage Source #
SourceInfo stage => HasRange (AnnMaybeG elem dom stage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods getRange :: AnnMaybeG elem dom stage -> SrcSpan Source # setRange :: SrcSpan -> AnnMaybeG elem dom stage -> AnnMaybeG elem dom stage Source #

class (Typeable stage, Data stage, Data (SpanInfo stage), Data (ListInfo stage), Data (OptionalInfo stage), HasRange (SpanInfo stage), HasRange (ListInfo stage), HasRange (OptionalInfo stage)) => SourceInfo stage Source #

Class for source information stages

Associated Types

data SpanInfo stage :: * Source #

UType of source info for normal AST elements

data ListInfo stage :: * Source #

UType of source info for lists of AST elements

data OptionalInfo stage :: * Source #

UType of source info for optional AST elements

Instances

SourceInfo NormRangeStage Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Associated Types data SpanInfo NormRangeStage :: Type Source # data ListInfo NormRangeStage :: Type Source # data OptionalInfo NormRangeStage :: Type Source #
SourceInfo RangeStage Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Associated Types data SpanInfo RangeStage :: Type Source # data ListInfo RangeStage :: Type Source # data OptionalInfo RangeStage :: Type Source #

shortShowSpan :: SrcSpan -> String Source #

A short form of showing a range, without file name, for debugging purposes.

shortShowSpanWithFile :: SrcSpan -> String Source #

shortShowLoc :: SrcLoc -> String Source #

A short form of showing a range, without file name, for debugging purposes.

class SourceInfo stage => RangeInfo stage where Source #

A class for marking a source information stage. All programs, regardless of correct Haskell programs or not, must go through these stages to be refactored.

Methods

nodeSpan :: Simple Lens (SpanInfo stage) SrcSpan Source #

listPos :: Simple Lens (ListInfo stage) SrcLoc Source #

optionalPos :: Simple Lens (OptionalInfo stage) SrcLoc Source #

Instances

RangeInfo RangeStage Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods nodeSpan :: Simple Lens (SpanInfo RangeStage) SrcSpan Source # listPos :: Simple Lens (ListInfo RangeStage) SrcLoc Source # optionalPos :: Simple Lens (OptionalInfo RangeStage) SrcLoc Source #

Annotations

data NodeInfo sema src Source #

Semantic and source code related information for an AST node.

Constructors

NodeInfo
Fields _semanticInfo :: sema _sourceInfo :: src

Instances

(Eq sema, Eq src) => Eq (NodeInfo sema src) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods (==) :: NodeInfo sema src -> NodeInfo sema src -> Bool # (/=) :: NodeInfo sema src -> NodeInfo sema src -> Bool #
(Data sema, Data src) => Data (NodeInfo sema src) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NodeInfo sema src -> c (NodeInfo sema src) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (NodeInfo sema src) # toConstr :: NodeInfo sema src -> Constr # dataTypeOf :: NodeInfo sema src -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (NodeInfo sema src)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (NodeInfo sema src)) # gmapT :: (forall b. Data b => b -> b) -> NodeInfo sema src -> NodeInfo sema src # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NodeInfo sema src -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NodeInfo sema src -> r # gmapQ :: (forall d. Data d => d -> u) -> NodeInfo sema src -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> NodeInfo sema src -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NodeInfo sema src -> m (NodeInfo sema src) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NodeInfo sema src -> m (NodeInfo sema src) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NodeInfo sema src -> m (NodeInfo sema src) #
(Show sema, Show src) => Show (NodeInfo sema src) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods showsPrec :: Int -> NodeInfo sema src -> ShowS # show :: NodeInfo sema src -> String # showList :: [NodeInfo sema src] -> ShowS #

sourceInfo :: forall sema src src'. Lens (NodeInfo sema src) (NodeInfo sema src') src src' Source #

semanticInfo :: forall sema src sema'. Lens (NodeInfo sema src) (NodeInfo sema' src) sema sema' Source #

data Ann elem dom stage Source #

An element of the AST keeping extra information.

Constructors

Ann
Fields _annotation :: NodeInfo (SemanticInfo dom elem) (SpanInfo stage) The extra information for the AST part _element :: elem dom stage The original AST part

Instances

(GoodOperationFor c (Ann elem dom stage), ClassyPlate c (elem dom stage)) => ClassyPlate c (Ann elem 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) -> Ann elem dom stage -> Ann elem dom stage bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> Ann elem dom stage -> m (Ann elem dom stage) descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> Ann elem dom stage -> Ann elem dom stage descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> Ann elem dom stage -> m (Ann elem dom stage) topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> Ann elem dom stage -> Ann elem dom stage topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> Ann elem dom stage -> m (Ann elem dom stage)
SourceInfoTraversal e => SourceInfoTraversal (Ann e) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> Ann e dom st1 -> f (Ann e dom st2) Source # sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> Ann e dom st1 -> f (Ann e dom st2) Source # sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> Ann e dom st1 -> f (Ann e dom st2) Source #
(ApplySemaChange (SemaInfoClassify e), SemanticTraversal e) => SemanticTraversal (Ann e) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> Ann e dom1 st -> f (Ann e dom2 st) Source #
SourceInfo src => Eq (Ann elem dom src) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods (==) :: Ann elem dom src -> Ann elem dom src -> Bool # (/=) :: Ann elem dom src -> Ann elem dom src -> Bool #
(DomainWith e dom, SourceInfo stage, Typeable e, Data (e dom stage)) => Data (Ann e dom stage) Source #
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) -> Ann e dom stage -> c (Ann e dom stage) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Ann e dom stage) # toConstr :: Ann e dom stage -> Constr # dataTypeOf :: Ann e dom stage -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Ann e dom stage)) # dataCast2 :: Typeable t => (forall d e0. (Data d, Data e0) => c (t d e0)) -> Maybe (c (Ann e dom stage)) # gmapT :: (forall b. Data b => b -> b) -> Ann e dom stage -> Ann e dom stage # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ann e dom stage -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ann e dom stage -> r # gmapQ :: (forall d. Data d => d -> u) -> Ann e dom stage -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Ann e dom stage -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ann e dom stage -> m (Ann e dom stage) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ann e dom stage -> m (Ann e dom stage) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ann e dom stage -> m (Ann e dom stage) #
Domain dom => Generic (Ann e dom stage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Instances.Generic Associated Types type Rep (Ann e dom stage) :: Type -> Type # Methods from :: Ann e dom stage -> Rep (Ann e dom stage) x # to :: Rep (Ann e dom stage) x -> Ann e dom stage #
SourceInfo stage => HasRange (Ann elem dom stage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods getRange :: Ann elem dom stage -> SrcSpan Source # setRange :: SrcSpan -> Ann elem dom stage -> Ann elem dom stage Source #
HasSourceInfo (Ann elem dom stage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Associated Types type SourceInfoType (Ann elem dom stage) :: Type Source # Methods srcInfo :: Simple Lens (Ann elem dom stage) (SourceInfoType (Ann elem dom stage)) Source #
HasImplicitFieldsInfo dom => HasImplicitFieldsInfo' (Ann UFieldWildcard dom st) Source #
Instance details Defined in Language.Haskell.Tools.AST.SemaInfoClasses Methods semanticsImplicitFlds :: Ann UFieldWildcard dom st -> [(Name, Name)] Source #
HasImportInfo dom => HasImportInfo' (Ann UImportDecl dom st) Source #
Instance details Defined in Language.Haskell.Tools.AST.SemaInfoClasses Methods semanticsImportedModule :: Ann UImportDecl dom st -> Module Source # semanticsAvailable :: Ann UImportDecl dom st -> [Name] Source # semanticsImported :: Ann UImportDecl dom st -> [Name] Source # semanticsTransMods :: Ann UImportDecl dom st -> [Module] Source #
HasModuleInfo dom => HasModuleInfo' (Ann UModule dom st) Source #
Instance details Defined in Language.Haskell.Tools.AST.SemaInfoClasses Methods semanticsModule :: Ann UModule dom st -> Module Source # semanticsDynFlags :: Ann UModule dom st -> DynFlags Source # isBootModule :: Ann UModule dom st -> Bool Source # semanticsImplicitImports :: Ann UModule dom st -> [Name] Source # semanticsPrelTransMods :: Ann UModule dom st -> [Module] Source #
HasDefiningInfo dom => HasDefiningInfo' (Ann UQualifiedName dom st) Source #
Instance details Defined in Language.Haskell.Tools.AST.SemaInfoClasses Methods semanticsDefining :: Ann UQualifiedName dom st -> Bool Source #
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 #
HasScopeInfo dom => HasScopeInfo' (Ann UQualifiedName dom st) Source #
Instance details Defined in Language.Haskell.Tools.AST.SemaInfoClasses Methods semanticsScope :: Ann UQualifiedName dom st -> Scope Source #
HasFixityInfo dom => HasFixityInfo' (Ann UQualifiedName dom st) Source #
Instance details Defined in Language.Haskell.Tools.AST.SemaInfoClasses Methods semanticsFixity :: Ann UQualifiedName dom st -> Maybe Fixity Source #
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 #
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 #
HasLiteralInfo dom => HasLiteralInfo' (Ann ULiteral dom st) Source #
Instance details Defined in Language.Haskell.Tools.AST.SemaInfoClasses Methods semanticsLiteralType :: Ann ULiteral dom st -> Type Source #
HasNameInfo dom => HasNameInfo' (Ann UQualifiedName dom st) Source #
Instance details Defined in Language.Haskell.Tools.AST.SemaInfoClasses Methods semanticsName :: Ann UQualifiedName dom st -> Maybe Name 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 (Ann e dom stage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Instances.Generic type Rep (Ann e dom stage) = D1 (MetaData "Ann" "Language.Haskell.Tools.AST.Ann" "haskell-tools-ast-1.1.1.0-KX9To7HoJR9HzfMqL62gL1" False) (C1 (MetaCons "Ann" PrefixI True) (S1 (MetaSel (Just "_annotation") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NodeInfo (SemanticInfo dom e) (SpanInfo stage))) :*: S1 (MetaSel (Just "_element") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (e dom stage))))
type SourceInfoType (Ann elem dom stage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SourceInfoType (Ann elem dom stage) = SpanInfo stage
type IgnoredFields (Ann elem dom stage)
Instance details Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate type IgnoredFields (Ann elem dom stage) = (Right "_annotation" :: Either (Symbol, Nat) Symbol) ': ([] :: [Either (Symbol, Nat) Symbol])

element :: forall elem dom stage. Lens (Ann elem dom stage) (Ann elem dom stage) (elem dom stage) (elem dom stage) Source #

annotation :: forall elem dom stage. Lens (Ann elem dom stage) (Ann elem dom stage) (NodeInfo (SemanticInfo dom elem) (SpanInfo stage)) (NodeInfo (SemanticInfo dom elem) (SpanInfo stage)) Source #

data AnnListG elem dom stage Source #

A list of AST elements

Constructors

AnnListG
Fields _annListAnnot :: NodeInfo (SemanticInfo dom (AnnListG elem)) (ListInfo stage) _annListElems :: [Ann elem dom stage]

Instances

(GoodOperationFor c (AnnListG elem dom stage), ClassyPlate c [Ann elem dom stage]) => ClassyPlate c (AnnListG elem 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) -> AnnListG elem dom stage -> AnnListG elem dom stage bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> AnnListG elem dom stage -> m (AnnListG elem dom stage) descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> AnnListG elem dom stage -> AnnListG elem dom stage descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> AnnListG elem dom stage -> m (AnnListG elem dom stage) topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> AnnListG elem dom stage -> AnnListG elem dom stage topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> AnnListG elem dom stage -> m (AnnListG elem dom stage)
SourceInfoTraversal e => SourceInfoTraversal (AnnListG e) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> AnnListG e dom st1 -> f (AnnListG e dom st2) Source # sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> AnnListG e dom st1 -> f (AnnListG e dom st2) Source # sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> AnnListG e dom st1 -> f (AnnListG e dom st2) Source #
(ApplySemaChange (SemaInfoClassify e), SemanticTraversal e) => SemanticTraversal (AnnListG e) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> AnnListG e dom1 st -> f (AnnListG e dom2 st) Source #
(DomainWith e dom, SourceInfo stage, Typeable e, Data (e dom stage)) => Data (AnnListG e dom stage) Source #
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) -> AnnListG e dom stage -> c (AnnListG e dom stage) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (AnnListG e dom stage) # toConstr :: AnnListG e dom stage -> Constr # dataTypeOf :: AnnListG e dom stage -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (AnnListG e dom stage)) # dataCast2 :: Typeable t => (forall d e0. (Data d, Data e0) => c (t d e0)) -> Maybe (c (AnnListG e dom stage)) # gmapT :: (forall b. Data b => b -> b) -> AnnListG e dom stage -> AnnListG e dom stage # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnListG e dom stage -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnListG e dom stage -> r # gmapQ :: (forall d. Data d => d -> u) -> AnnListG e dom stage -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnListG e dom stage -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnListG e dom stage -> m (AnnListG e dom stage) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnListG e dom stage -> m (AnnListG e dom stage) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnListG e dom stage -> m (AnnListG e dom stage) #
Domain dom => Generic (AnnListG e dom stage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Instances.Generic Associated Types type Rep (AnnListG e dom stage) :: Type -> Type # Methods from :: AnnListG e dom stage -> Rep (AnnListG e dom stage) x # to :: Rep (AnnListG e dom stage) x -> AnnListG e dom stage #
SourceInfo stage => HasRange (AnnListG elem dom stage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods getRange :: AnnListG elem dom stage -> SrcSpan Source # setRange :: SrcSpan -> AnnListG elem dom stage -> AnnListG elem dom stage Source #
HasSourceInfo (AnnListG elem dom stage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Associated Types type SourceInfoType (AnnListG elem dom stage) :: Type Source # Methods srcInfo :: Simple Lens (AnnListG elem dom stage) (SourceInfoType (AnnListG elem dom stage)) Source #
type Rep (AnnListG e dom stage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Instances.Generic type Rep (AnnListG e dom stage) = D1 (MetaData "AnnListG" "Language.Haskell.Tools.AST.Ann" "haskell-tools-ast-1.1.1.0-KX9To7HoJR9HzfMqL62gL1" False) (C1 (MetaCons "AnnListG" PrefixI True) (S1 (MetaSel (Just "_annListAnnot") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NodeInfo (SemanticInfo dom (AnnListG e)) (ListInfo stage))) :*: S1 (MetaSel (Just "_annListElems") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Ann e dom stage])))
type SourceInfoType (AnnListG elem dom stage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SourceInfoType (AnnListG elem dom stage) = ListInfo stage
type IgnoredFields (AnnListG elem dom stage)
Instance details Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate type IgnoredFields (AnnListG elem dom stage) = (Right "_annListAnnot" :: Either (Symbol, Nat) Symbol) ': ([] :: [Either (Symbol, Nat) Symbol])

annListElems :: forall elem dom stage. Lens (AnnListG elem dom stage) (AnnListG elem dom stage) [Ann elem dom stage] [Ann elem dom stage] Source #

annListAnnot :: forall elem dom stage. Lens (AnnListG elem dom stage) (AnnListG elem dom stage) (NodeInfo (SemanticInfo dom (AnnListG elem)) (ListInfo stage)) (NodeInfo (SemanticInfo dom (AnnListG elem)) (ListInfo stage)) Source #

annList :: Traversal (AnnListG e d s) (AnnListG e d s) (Ann e d s) (Ann e d s) Source #

data AnnMaybeG elem dom stage Source #

An optional AST element

Constructors

AnnMaybeG
Fields _annMaybeAnnot :: NodeInfo (SemanticInfo dom (AnnMaybeG elem)) (OptionalInfo stage) _annMaybe :: Maybe (Ann elem dom stage)

Instances

(GoodOperationFor c (AnnMaybeG elem dom stage), ClassyPlate c (Maybe (Ann elem dom stage))) => ClassyPlate c (AnnMaybeG elem 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) -> AnnMaybeG elem dom stage -> AnnMaybeG elem dom stage bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> AnnMaybeG elem dom stage -> m (AnnMaybeG elem dom stage) descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> AnnMaybeG elem dom stage -> AnnMaybeG elem dom stage descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> AnnMaybeG elem dom stage -> m (AnnMaybeG elem dom stage) topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> AnnMaybeG elem dom stage -> AnnMaybeG elem dom stage topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> AnnMaybeG elem dom stage -> m (AnnMaybeG elem dom stage)
SourceInfoTraversal e => SourceInfoTraversal (AnnMaybeG e) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> AnnMaybeG e dom st1 -> f (AnnMaybeG e dom st2) Source # sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> AnnMaybeG e dom st1 -> f (AnnMaybeG e dom st2) Source # sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> AnnMaybeG e dom st1 -> f (AnnMaybeG e dom st2) Source #
(ApplySemaChange (SemaInfoClassify e), SemanticTraversal e) => SemanticTraversal (AnnMaybeG e) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> AnnMaybeG e dom1 st -> f (AnnMaybeG e dom2 st) Source #
(DomainWith e dom, SourceInfo stage, Typeable e, Data (e dom stage)) => Data (AnnMaybeG e dom stage) Source #
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) -> AnnMaybeG e dom stage -> c (AnnMaybeG e dom stage) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (AnnMaybeG e dom stage) # toConstr :: AnnMaybeG e dom stage -> Constr # dataTypeOf :: AnnMaybeG e dom stage -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (AnnMaybeG e dom stage)) # dataCast2 :: Typeable t => (forall d e0. (Data d, Data e0) => c (t d e0)) -> Maybe (c (AnnMaybeG e dom stage)) # gmapT :: (forall b. Data b => b -> b) -> AnnMaybeG e dom stage -> AnnMaybeG e dom stage # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnMaybeG e dom stage -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnMaybeG e dom stage -> r # gmapQ :: (forall d. Data d => d -> u) -> AnnMaybeG e dom stage -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnMaybeG e dom stage -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnMaybeG e dom stage -> m (AnnMaybeG e dom stage) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnMaybeG e dom stage -> m (AnnMaybeG e dom stage) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnMaybeG e dom stage -> m (AnnMaybeG e dom stage) #
Domain dom => Generic (AnnMaybeG e dom stage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Instances.Generic Associated Types type Rep (AnnMaybeG e dom stage) :: Type -> Type # Methods from :: AnnMaybeG e dom stage -> Rep (AnnMaybeG e dom stage) x # to :: Rep (AnnMaybeG e dom stage) x -> AnnMaybeG e dom stage #
SourceInfo stage => HasRange (AnnMaybeG elem dom stage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods getRange :: AnnMaybeG elem dom stage -> SrcSpan Source # setRange :: SrcSpan -> AnnMaybeG elem dom stage -> AnnMaybeG elem dom stage Source #
HasSourceInfo (AnnMaybeG elem dom stage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Associated Types type SourceInfoType (AnnMaybeG elem dom stage) :: Type Source # Methods srcInfo :: Simple Lens (AnnMaybeG elem dom stage) (SourceInfoType (AnnMaybeG elem dom stage)) Source #
type Rep (AnnMaybeG e dom stage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Instances.Generic type Rep (AnnMaybeG e dom stage) = D1 (MetaData "AnnMaybeG" "Language.Haskell.Tools.AST.Ann" "haskell-tools-ast-1.1.1.0-KX9To7HoJR9HzfMqL62gL1" False) (C1 (MetaCons "AnnMaybeG" PrefixI True) (S1 (MetaSel (Just "_annMaybeAnnot") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NodeInfo (SemanticInfo dom (AnnMaybeG e)) (OptionalInfo stage))) :*: S1 (MetaSel (Just "_annMaybe") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Ann e dom stage)))))
type SourceInfoType (AnnMaybeG elem dom stage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann type SourceInfoType (AnnMaybeG elem dom stage) = OptionalInfo stage
type IgnoredFields (AnnMaybeG elem dom stage)
Instance details Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate type IgnoredFields (AnnMaybeG elem dom stage) = (Right "_annMaybeAnnot" :: Either (Symbol, Nat) Symbol) ': ([] :: [Either (Symbol, Nat) Symbol])

annMaybeAnnot :: forall elem dom stage. Lens (AnnMaybeG elem dom stage) (AnnMaybeG elem dom stage) (NodeInfo (SemanticInfo dom (AnnMaybeG elem)) (OptionalInfo stage)) (NodeInfo (SemanticInfo dom (AnnMaybeG elem)) (OptionalInfo stage)) Source #

annMaybe :: forall elem dom stage. Lens (AnnMaybeG elem dom stage) (AnnMaybeG elem dom stage) (Maybe (Ann elem dom stage)) (Maybe (Ann elem dom stage)) Source #

class HasSourceInfo e where Source #

Associated Types

type SourceInfoType e :: * Source #

Methods

srcInfo :: Simple Lens e (SourceInfoType e) Source #

Instances

HasSourceInfo (Ann elem dom stage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Associated Types type SourceInfoType (Ann elem dom stage) :: Type Source # Methods srcInfo :: Simple Lens (Ann elem dom stage) (SourceInfoType (Ann elem dom stage)) Source #
HasSourceInfo (AnnListG elem dom stage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Associated Types type SourceInfoType (AnnListG elem dom stage) :: Type Source # Methods srcInfo :: Simple Lens (AnnListG elem dom stage) (SourceInfoType (AnnListG elem dom stage)) Source #
HasSourceInfo (AnnMaybeG elem dom stage) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Associated Types type SourceInfoType (AnnMaybeG elem dom stage) :: Type Source # Methods srcInfo :: Simple Lens (AnnMaybeG elem dom stage) (SourceInfoType (AnnMaybeG elem dom stage)) Source #

annJust :: Partial (AnnMaybeG e d s) (AnnMaybeG e d s) (Ann e d s) (Ann e d s) Source #

annNil :: NodeInfo (SemanticInfo d (AnnListG e)) (ListInfo s) -> AnnListG e d s Source #

An empty list of AST elements

isAnnNothing :: AnnMaybeG e d s -> Bool Source #

isAnnJust :: AnnMaybeG e d s -> Bool Source #

annLength :: AnnListG e d s -> Int Source #

annNothing :: NodeInfo (SemanticInfo d (AnnMaybeG e)) (OptionalInfo s) -> AnnMaybeG e d s Source #

A non-existing AST part

Info types

class ApplySemaChange cls where Source #

A class for changing semantic information throught the AST.

Methods

appSemaChange :: SemaTrf f dom1 dom2 -> SemanticInfo' dom1 cls -> f (SemanticInfo' dom2 cls) Source #

Instances

ApplySemaChange SemaInfoWildcardCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods appSemaChange :: SemaTrf f dom1 dom2 -> SemanticInfo' dom1 SemaInfoWildcardCls -> f (SemanticInfo' dom2 SemaInfoWildcardCls) Source #
ApplySemaChange SemaInfoDefaultCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods appSemaChange :: SemaTrf f dom1 dom2 -> SemanticInfo' dom1 SemaInfoDefaultCls -> f (SemanticInfo' dom2 SemaInfoDefaultCls) Source #
ApplySemaChange SemaInfoModuleCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods appSemaChange :: SemaTrf f dom1 dom2 -> SemanticInfo' dom1 SemaInfoModuleCls -> f (SemanticInfo' dom2 SemaInfoModuleCls) Source #
ApplySemaChange SemaInfoImportCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods appSemaChange :: SemaTrf f dom1 dom2 -> SemanticInfo' dom1 SemaInfoImportCls -> f (SemanticInfo' dom2 SemaInfoImportCls) Source #
ApplySemaChange SemaInfoExprCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods appSemaChange :: SemaTrf f dom1 dom2 -> SemanticInfo' dom1 SemaInfoExprCls -> f (SemanticInfo' dom2 SemaInfoExprCls) Source #
ApplySemaChange SemaInfoLitCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods appSemaChange :: SemaTrf f dom1 dom2 -> SemanticInfo' dom1 SemaInfoLitCls -> f (SemanticInfo' dom2 SemaInfoLitCls) Source #
ApplySemaChange SemaInfoNameCls Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods appSemaChange :: SemaTrf f dom1 dom2 -> SemanticInfo' dom1 SemaInfoNameCls -> f (SemanticInfo' dom2 SemaInfoNameCls) Source #

class ApplySemaChange (SemaInfoClassify a) => SemanticTraversal a where Source #

A class for traversing semantic information in an AST

Methods

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

Instances

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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
(ApplySemaChange (SemaInfoClassify e), SemanticTraversal e) => SemanticTraversal (Ann e) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> Ann e dom1 st -> f (Ann e dom2 st) Source #
(ApplySemaChange (SemaInfoClassify e), SemanticTraversal e) => SemanticTraversal (AnnListG e) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> AnnListG e dom1 st -> f (AnnListG e dom2 st) Source #
(ApplySemaChange (SemaInfoClassify e), SemanticTraversal e) => SemanticTraversal (AnnMaybeG e) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> AnnMaybeG e dom1 st -> f (AnnMaybeG e dom2 st) 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 #
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 #
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 #
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 #
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 #

data SemaTrf f dom1 dom2 Source #

A transformation on the possible semantic informations for a given domain

Constructors

SemaTrf

Fields

trfSemaNameCls :: SemanticInfo' dom1 SemaInfoNameCls -> f (SemanticInfo' dom2 SemaInfoNameCls)
trfSemaExprCls :: SemanticInfo' dom1 SemaInfoExprCls -> f (SemanticInfo' dom2 SemaInfoExprCls)
trfSemaLitCls :: SemanticInfo' dom1 SemaInfoLitCls -> f (SemanticInfo' dom2 SemaInfoLitCls)
trfSemaImportCls :: SemanticInfo' dom1 SemaInfoImportCls -> f (SemanticInfo' dom2 SemaInfoImportCls)
trfSemaModuleCls :: SemanticInfo' dom1 SemaInfoModuleCls -> f (SemanticInfo' dom2 SemaInfoModuleCls)
trfSemaWildcardCls :: SemanticInfo' dom1 SemaInfoWildcardCls -> f (SemanticInfo' dom2 SemaInfoWildcardCls)
trfSemaDefault :: SemanticInfo' dom1 SemaInfoDefaultCls -> f (SemanticInfo' dom2 SemaInfoDefaultCls)

class SourceInfoTraversal a where Source #

A class for traversing source information in an AST

Methods

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

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

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

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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
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 #
SourceInfoTraversal e => SourceInfoTraversal (Ann e) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> Ann e dom st1 -> f (Ann e dom st2) Source # sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> Ann e dom st1 -> f (Ann e dom st2) Source # sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> Ann e dom st1 -> f (Ann e dom st2) Source #
SourceInfoTraversal e => SourceInfoTraversal (AnnListG e) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> AnnListG e dom st1 -> f (AnnListG e dom st2) Source # sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> AnnListG e dom st1 -> f (AnnListG e dom st2) Source # sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> AnnListG e dom st1 -> f (AnnListG e dom st2) Source #
SourceInfoTraversal e => SourceInfoTraversal (AnnMaybeG e) Source #
Instance details Defined in Language.Haskell.Tools.AST.Ann Methods sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> AnnMaybeG e dom st1 -> f (AnnMaybeG e dom st2) Source # sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> AnnMaybeG e dom st1 -> f (AnnMaybeG e dom st2) Source # sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> AnnMaybeG e dom st1 -> f (AnnMaybeG e dom st2) Source #
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 #
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 #
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 #
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 #
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 #

data SourceInfoTrf f st1 st2 Source #

A transformation on the possible source informations

Constructors

SourceInfoTrf
Fields trfSpanInfo :: SpanInfo st1 -> f (SpanInfo st2) trfListInfo :: ListInfo st1 -> f (ListInfo st2) trfOptionalInfo :: OptionalInfo st1 -> f (OptionalInfo st2)

SemaInfoClassify UQualifiedName = SemaInfoNameCls
SemaInfoClassify ULiteral = SemaInfoLitCls
SemaInfoClassify UExpr = SemaInfoExprCls
SemaInfoClassify UImportDecl = SemaInfoImportCls
SemaInfoClassify UModule = SemaInfoModuleCls
SemaInfoClassify UFieldWildcard = SemaInfoWildcardCls
SemaInfoClassify a = SemaInfoDefaultCls