Language.Haskell.Tools.AST.Instances.Data

Data instances for Haskell AST (used for generics)

Orphan instances

(Domain dom, SourceInfo stage) => Data (QualifiedName dom stage)

Methods

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

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

toConstr :: QualifiedName dom stage -> Constr

dataTypeOf :: QualifiedName dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (FieldWildcard dom stage)

Methods

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

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

toConstr :: FieldWildcard dom stage -> Constr

dataTypeOf :: FieldWildcard dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (Cmd dom stage)

Methods

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

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

toConstr :: Cmd dom stage -> Constr

dataTypeOf :: Cmd dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (Expr dom stage)

Methods

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

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

toConstr :: Expr dom stage -> Constr

dataTypeOf :: Expr dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (RhsGuard dom stage)

Methods

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

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

toConstr :: RhsGuard dom stage -> Constr

dataTypeOf :: RhsGuard dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (LocalBinds dom stage)

Methods

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

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

toConstr :: LocalBinds dom stage -> Constr

dataTypeOf :: LocalBinds dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (LocalBind dom stage)

Methods

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

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

toConstr :: LocalBind dom stage -> Constr

dataTypeOf :: LocalBind dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (Bracket dom stage)

Methods

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

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

toConstr :: Bracket dom stage -> Constr

dataTypeOf :: Bracket dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (QuasiQuote dom stage)

Methods

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

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

toConstr :: QuasiQuote dom stage -> Constr

dataTypeOf :: QuasiQuote dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (Splice dom stage)

Methods

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

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

toConstr :: Splice dom stage -> Constr

dataTypeOf :: Splice dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (ImportDecl dom stage)

Methods

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

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

toConstr :: ImportDecl dom stage -> Constr

dataTypeOf :: ImportDecl dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (Module dom stage)

Methods

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

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

toConstr :: Module dom stage -> Constr

dataTypeOf :: Module dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (PhaseInvert dom stage)

Methods

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

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

toConstr :: PhaseInvert dom stage -> Constr

dataTypeOf :: PhaseInvert dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (PhaseNumber dom stage)

Methods

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

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

toConstr :: PhaseNumber dom stage -> Constr

dataTypeOf :: PhaseNumber dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (PhaseControl dom stage)

Methods

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

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

toConstr :: PhaseControl dom stage -> Constr

dataTypeOf :: PhaseControl dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (LineNumber dom stage)

Methods

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

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

toConstr :: LineNumber dom stage -> Constr

dataTypeOf :: LineNumber dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (Precedence dom stage)

Methods

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

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

toConstr :: Precedence dom stage -> Constr

dataTypeOf :: Precedence dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (ConlikeAnnot dom stage)

Methods

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

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

toConstr :: ConlikeAnnot dom stage -> Constr

dataTypeOf :: ConlikeAnnot dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (Role dom stage)

Methods

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

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

toConstr :: Role dom stage -> Constr

dataTypeOf :: Role dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (Assoc dom stage)

Methods

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

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

toConstr :: Assoc dom stage -> Constr

dataTypeOf :: Assoc dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (Safety dom stage)

Methods

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

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

toConstr :: Safety dom stage -> Constr

dataTypeOf :: Safety dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (ArrowAppl dom stage)

Methods

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

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

toConstr :: ArrowAppl dom stage -> Constr

dataTypeOf :: ArrowAppl dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (CallConv dom stage)

Methods

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

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

toConstr :: CallConv dom stage -> Constr

dataTypeOf :: CallConv dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (OverlapPragma dom stage)

Methods

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

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

toConstr :: OverlapPragma dom stage -> Constr

dataTypeOf :: OverlapPragma dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (TypeKeyword dom stage)

Methods

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

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

toConstr :: TypeKeyword dom stage -> Constr

dataTypeOf :: TypeKeyword dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (DoKind dom stage)

Methods

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

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

toConstr :: DoKind dom stage -> Constr

dataTypeOf :: DoKind dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (DataOrNewtypeKeyword dom stage)

Methods

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

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

toConstr :: DataOrNewtypeKeyword dom stage -> Constr

dataTypeOf :: DataOrNewtypeKeyword dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (ModuleName dom stage)

Methods

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

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

toConstr :: ModuleName dom stage -> Constr

dataTypeOf :: ModuleName dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (StringNode dom stage)

Methods

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

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

toConstr :: StringNode dom stage -> Constr

dataTypeOf :: StringNode dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (UnqualName dom stage)

Methods

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

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

toConstr :: UnqualName dom stage -> Constr

dataTypeOf :: UnqualName dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (Name dom stage)

Methods

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

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

toConstr :: Name dom stage -> Constr

dataTypeOf :: Name dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (Operator dom stage)

Methods

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

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

toConstr :: Operator dom stage -> Constr

dataTypeOf :: Operator dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (Literal dom stage)

Methods

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

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

toConstr :: Literal dom stage -> Constr

dataTypeOf :: Literal dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (Kind dom stage)

Methods

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

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

toConstr :: Kind dom stage -> Constr

dataTypeOf :: Kind dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (KindConstraint dom stage)

Methods

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

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

toConstr :: KindConstraint dom stage -> Constr

dataTypeOf :: KindConstraint dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (Assertion dom stage)

Methods

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

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

toConstr :: Assertion dom stage -> Constr

dataTypeOf :: Assertion dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (Context dom stage)

Methods

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

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

toConstr :: Context dom stage -> Constr

dataTypeOf :: Context dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (Type dom stage)

Methods

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

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

toConstr :: Type dom stage -> Constr

dataTypeOf :: Type dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (TyVar dom stage)

Methods

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

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

toConstr :: TyVar dom stage -> Constr

dataTypeOf :: TyVar dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (PatternField dom stage)

Methods

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

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

toConstr :: PatternField dom stage -> Constr

dataTypeOf :: PatternField dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (Pattern dom stage)

Methods

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

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

toConstr :: Pattern dom stage -> Constr

dataTypeOf :: Pattern dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (CompStmt dom stage)

Methods

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

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

toConstr :: CompStmt dom stage -> Constr

dataTypeOf :: CompStmt dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (ListCompBody dom stage)

Methods

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

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

toConstr :: ListCompBody dom stage -> Constr

dataTypeOf :: ListCompBody dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (Number dom stage)

Methods

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

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

toConstr :: Number dom stage -> Constr

dataTypeOf :: Number dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (SourceRange dom stage)

Methods

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

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

toConstr :: SourceRange dom stage -> Constr

dataTypeOf :: SourceRange dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (ExprPragma dom stage)

Methods

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

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

toConstr :: ExprPragma dom stage -> Constr

dataTypeOf :: ExprPragma dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (TupSecElem dom stage)

Methods

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

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

toConstr :: TupSecElem dom stage -> Constr

dataTypeOf :: TupSecElem dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (FieldUpdate dom stage)

Methods

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

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

toConstr :: FieldUpdate dom stage -> Constr

dataTypeOf :: FieldUpdate dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (MinimalFormula dom stage)

Methods

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

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

toConstr :: MinimalFormula dom stage -> Constr

dataTypeOf :: MinimalFormula dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (AnnotationSubject dom stage)

Methods

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

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

toConstr :: AnnotationSubject dom stage -> Constr

dataTypeOf :: AnnotationSubject dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (Rule dom stage)

Methods

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

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

toConstr :: Rule dom stage -> Constr

dataTypeOf :: Rule dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (TopLevelPragma dom stage)

Methods

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

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

toConstr :: TopLevelPragma dom stage -> Constr

dataTypeOf :: TopLevelPragma dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (GuardedRhs dom stage)

Methods

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

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

toConstr :: GuardedRhs dom stage -> Constr

dataTypeOf :: GuardedRhs dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (Rhs dom stage)

Methods

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

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

toConstr :: Rhs dom stage -> Constr

dataTypeOf :: Rhs dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (FixitySignature dom stage)

Methods

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

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

toConstr :: FixitySignature dom stage -> Constr

dataTypeOf :: FixitySignature dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (TypeSignature dom stage)

Methods

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

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

toConstr :: TypeSignature dom stage -> Constr

dataTypeOf :: TypeSignature dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (MatchLhs dom stage)

Methods

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

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

toConstr :: MatchLhs dom stage -> Constr

dataTypeOf :: MatchLhs dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (Match dom stage)

Methods

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

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

toConstr :: Match dom stage -> Constr

dataTypeOf :: Match dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (ValueBind dom stage)

Methods

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

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

toConstr :: ValueBind dom stage -> Constr

dataTypeOf :: ValueBind dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (PatSynWhere dom stage)

Methods

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

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

toConstr :: PatSynWhere dom stage -> Constr

dataTypeOf :: PatSynWhere dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (PatSynRhs dom stage)

Methods

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

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

toConstr :: PatSynRhs dom stage -> Constr

dataTypeOf :: PatSynRhs dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (PatSynLhs dom stage)

Methods

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

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

toConstr :: PatSynLhs dom stage -> Constr

dataTypeOf :: PatSynLhs dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (PatternSynonym dom stage)

Methods

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

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

toConstr :: PatternSynonym dom stage -> Constr

dataTypeOf :: PatternSynonym dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (PatternTypeSignature dom stage)

Methods

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

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

toConstr :: PatternTypeSignature dom stage -> Constr

dataTypeOf :: PatternTypeSignature dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (TypeEqn dom stage)

Methods

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

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

toConstr :: TypeEqn dom stage -> Constr

dataTypeOf :: TypeEqn dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (InstanceHead dom stage)

Methods

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

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

toConstr :: InstanceHead dom stage -> Constr

dataTypeOf :: InstanceHead dom stage -> DataType

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

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

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

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

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

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

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

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

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

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

(Domain dom, SourceInfo stage) => Data (InstanceRule dom stage)

Methods

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

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

toConstr :: InstanceRule dom stage -> Constr

dataTypeOf :: InstanceRule dom stage -> DataType

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

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

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

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

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

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

gmapQi :: Int -> (forall d. Data d => d -> u) -> InstanceRule dom stage -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> InstanceRule dom stage -> m (InstanceRule dom stage)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InstanceRule dom stage -> m (InstanceRule dom stage)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InstanceRule dom stage -> m (InstanceRule dom stage)

(Domain dom, SourceInfo stage) => Data (Deriving dom stage)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Deriving dom stage -> c (Deriving dom stage)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Deriving dom stage)

toConstr :: Deriving dom stage -> Constr

dataTypeOf :: Deriving dom stage -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Deriving dom stage))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Deriving dom stage))

gmapT :: (forall b. Data b => b -> b) -> Deriving dom stage -> Deriving dom stage

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Deriving dom stage -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Deriving dom stage -> r

gmapQ :: (forall d. Data d => d -> u) -> Deriving dom stage -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Deriving dom stage -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Deriving dom stage -> m (Deriving dom stage)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Deriving dom stage -> m (Deriving dom stage)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Deriving dom stage -> m (Deriving dom stage)

(Domain dom, SourceInfo stage) => Data (FieldDecl dom stage)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FieldDecl dom stage -> c (FieldDecl dom stage)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FieldDecl dom stage)

toConstr :: FieldDecl dom stage -> Constr

dataTypeOf :: FieldDecl dom stage -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (FieldDecl dom stage))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FieldDecl dom stage))

gmapT :: (forall b. Data b => b -> b) -> FieldDecl dom stage -> FieldDecl dom stage

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FieldDecl dom stage -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FieldDecl dom stage -> r

gmapQ :: (forall d. Data d => d -> u) -> FieldDecl dom stage -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> FieldDecl dom stage -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FieldDecl dom stage -> m (FieldDecl dom stage)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldDecl dom stage -> m (FieldDecl dom stage)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldDecl dom stage -> m (FieldDecl dom stage)

(Domain dom, SourceInfo stage) => Data (ConDecl dom stage)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ConDecl dom stage -> c (ConDecl dom stage)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ConDecl dom stage)

toConstr :: ConDecl dom stage -> Constr

dataTypeOf :: ConDecl dom stage -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (ConDecl dom stage))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ConDecl dom stage))

gmapT :: (forall b. Data b => b -> b) -> ConDecl dom stage -> ConDecl dom stage

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ConDecl dom stage -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ConDecl dom stage -> r

gmapQ :: (forall d. Data d => d -> u) -> ConDecl dom stage -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ConDecl dom stage -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ConDecl dom stage -> m (ConDecl dom stage)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ConDecl dom stage -> m (ConDecl dom stage)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ConDecl dom stage -> m (ConDecl dom stage)

(Domain dom, SourceInfo stage) => Data (FunDep dom stage)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FunDep dom stage -> c (FunDep dom stage)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FunDep dom stage)

toConstr :: FunDep dom stage -> Constr

dataTypeOf :: FunDep dom stage -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (FunDep dom stage))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FunDep dom stage))

gmapT :: (forall b. Data b => b -> b) -> FunDep dom stage -> FunDep dom stage

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FunDep dom stage -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FunDep dom stage -> r

gmapQ :: (forall d. Data d => d -> u) -> FunDep dom stage -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> FunDep dom stage -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FunDep dom stage -> m (FunDep dom stage)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FunDep dom stage -> m (FunDep dom stage)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FunDep dom stage -> m (FunDep dom stage)

(Domain dom, SourceInfo stage) => Data (FunDeps dom stage)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FunDeps dom stage -> c (FunDeps dom stage)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FunDeps dom stage)

toConstr :: FunDeps dom stage -> Constr

dataTypeOf :: FunDeps dom stage -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (FunDeps dom stage))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FunDeps dom stage))

gmapT :: (forall b. Data b => b -> b) -> FunDeps dom stage -> FunDeps dom stage

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FunDeps dom stage -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FunDeps dom stage -> r

gmapQ :: (forall d. Data d => d -> u) -> FunDeps dom stage -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> FunDeps dom stage -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FunDeps dom stage -> m (FunDeps dom stage)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FunDeps dom stage -> m (FunDeps dom stage)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FunDeps dom stage -> m (FunDeps dom stage)

(Domain dom, SourceInfo stage) => Data (GadtConType dom stage)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GadtConType dom stage -> c (GadtConType dom stage)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (GadtConType dom stage)

toConstr :: GadtConType dom stage -> Constr

dataTypeOf :: GadtConType dom stage -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (GadtConType dom stage))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (GadtConType dom stage))

gmapT :: (forall b. Data b => b -> b) -> GadtConType dom stage -> GadtConType dom stage

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GadtConType dom stage -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GadtConType dom stage -> r

gmapQ :: (forall d. Data d => d -> u) -> GadtConType dom stage -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> GadtConType dom stage -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GadtConType dom stage -> m (GadtConType dom stage)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GadtConType dom stage -> m (GadtConType dom stage)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GadtConType dom stage -> m (GadtConType dom stage)

(Domain dom, SourceInfo stage) => Data (GadtConDecl dom stage)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GadtConDecl dom stage -> c (GadtConDecl dom stage)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (GadtConDecl dom stage)

toConstr :: GadtConDecl dom stage -> Constr

dataTypeOf :: GadtConDecl dom stage -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (GadtConDecl dom stage))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (GadtConDecl dom stage))

gmapT :: (forall b. Data b => b -> b) -> GadtConDecl dom stage -> GadtConDecl dom stage

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GadtConDecl dom stage -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GadtConDecl dom stage -> r

gmapQ :: (forall d. Data d => d -> u) -> GadtConDecl dom stage -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> GadtConDecl dom stage -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GadtConDecl dom stage -> m (GadtConDecl dom stage)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GadtConDecl dom stage -> m (GadtConDecl dom stage)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GadtConDecl dom stage -> m (GadtConDecl dom stage)

(Domain dom, SourceInfo stage) => Data (InstBodyDecl dom stage)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InstBodyDecl dom stage -> c (InstBodyDecl dom stage)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (InstBodyDecl dom stage)

toConstr :: InstBodyDecl dom stage -> Constr

dataTypeOf :: InstBodyDecl dom stage -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (InstBodyDecl dom stage))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (InstBodyDecl dom stage))

gmapT :: (forall b. Data b => b -> b) -> InstBodyDecl dom stage -> InstBodyDecl dom stage

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> InstBodyDecl dom stage -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> InstBodyDecl dom stage -> r

gmapQ :: (forall d. Data d => d -> u) -> InstBodyDecl dom stage -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> InstBodyDecl dom stage -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> InstBodyDecl dom stage -> m (InstBodyDecl dom stage)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InstBodyDecl dom stage -> m (InstBodyDecl dom stage)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InstBodyDecl dom stage -> m (InstBodyDecl dom stage)

(Domain dom, SourceInfo stage) => Data (InstBody dom stage)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InstBody dom stage -> c (InstBody dom stage)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (InstBody dom stage)

toConstr :: InstBody dom stage -> Constr

dataTypeOf :: InstBody dom stage -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (InstBody dom stage))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (InstBody dom stage))

gmapT :: (forall b. Data b => b -> b) -> InstBody dom stage -> InstBody dom stage

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> InstBody dom stage -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> InstBody dom stage -> r

gmapQ :: (forall d. Data d => d -> u) -> InstBody dom stage -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> InstBody dom stage -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> InstBody dom stage -> m (InstBody dom stage)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InstBody dom stage -> m (InstBody dom stage)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InstBody dom stage -> m (InstBody dom stage)

(Domain dom, SourceInfo stage) => Data (DeclHead dom stage)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DeclHead dom stage -> c (DeclHead dom stage)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DeclHead dom stage)

toConstr :: DeclHead dom stage -> Constr

dataTypeOf :: DeclHead dom stage -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (DeclHead dom stage))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (DeclHead dom stage))

gmapT :: (forall b. Data b => b -> b) -> DeclHead dom stage -> DeclHead dom stage

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DeclHead dom stage -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DeclHead dom stage -> r

gmapQ :: (forall d. Data d => d -> u) -> DeclHead dom stage -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> DeclHead dom stage -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DeclHead dom stage -> m (DeclHead dom stage)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DeclHead dom stage -> m (DeclHead dom stage)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DeclHead dom stage -> m (DeclHead dom stage)

(Domain dom, SourceInfo stage) => Data (ClassElement dom stage)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ClassElement dom stage -> c (ClassElement dom stage)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ClassElement dom stage)

toConstr :: ClassElement dom stage -> Constr

dataTypeOf :: ClassElement dom stage -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (ClassElement dom stage))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ClassElement dom stage))

gmapT :: (forall b. Data b => b -> b) -> ClassElement dom stage -> ClassElement dom stage

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ClassElement dom stage -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ClassElement dom stage -> r

gmapQ :: (forall d. Data d => d -> u) -> ClassElement dom stage -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ClassElement dom stage -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ClassElement dom stage -> m (ClassElement dom stage)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ClassElement dom stage -> m (ClassElement dom stage)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ClassElement dom stage -> m (ClassElement dom stage)

(Domain dom, SourceInfo stage) => Data (ClassBody dom stage)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ClassBody dom stage -> c (ClassBody dom stage)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ClassBody dom stage)

toConstr :: ClassBody dom stage -> Constr

dataTypeOf :: ClassBody dom stage -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (ClassBody dom stage))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ClassBody dom stage))

gmapT :: (forall b. Data b => b -> b) -> ClassBody dom stage -> ClassBody dom stage

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ClassBody dom stage -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ClassBody dom stage -> r

gmapQ :: (forall d. Data d => d -> u) -> ClassBody dom stage -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ClassBody dom stage -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ClassBody dom stage -> m (ClassBody dom stage)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ClassBody dom stage -> m (ClassBody dom stage)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ClassBody dom stage -> m (ClassBody dom stage)

(Domain dom, SourceInfo stage) => Data (InjectivityAnn dom stage)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InjectivityAnn dom stage -> c (InjectivityAnn dom stage)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (InjectivityAnn dom stage)

toConstr :: InjectivityAnn dom stage -> Constr

dataTypeOf :: InjectivityAnn dom stage -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (InjectivityAnn dom stage))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (InjectivityAnn dom stage))

gmapT :: (forall b. Data b => b -> b) -> InjectivityAnn dom stage -> InjectivityAnn dom stage

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> InjectivityAnn dom stage -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> InjectivityAnn dom stage -> r

gmapQ :: (forall d. Data d => d -> u) -> InjectivityAnn dom stage -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> InjectivityAnn dom stage -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> InjectivityAnn dom stage -> m (InjectivityAnn dom stage)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InjectivityAnn dom stage -> m (InjectivityAnn dom stage)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InjectivityAnn dom stage -> m (InjectivityAnn dom stage)

(Domain dom, SourceInfo stage) => Data (TypeFamilySpec dom stage)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TypeFamilySpec dom stage -> c (TypeFamilySpec dom stage)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (TypeFamilySpec dom stage)

toConstr :: TypeFamilySpec dom stage -> Constr

dataTypeOf :: TypeFamilySpec dom stage -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (TypeFamilySpec dom stage))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (TypeFamilySpec dom stage))

gmapT :: (forall b. Data b => b -> b) -> TypeFamilySpec dom stage -> TypeFamilySpec dom stage

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TypeFamilySpec dom stage -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TypeFamilySpec dom stage -> r

gmapQ :: (forall d. Data d => d -> u) -> TypeFamilySpec dom stage -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> TypeFamilySpec dom stage -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TypeFamilySpec dom stage -> m (TypeFamilySpec dom stage)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeFamilySpec dom stage -> m (TypeFamilySpec dom stage)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeFamilySpec dom stage -> m (TypeFamilySpec dom stage)

(Domain dom, SourceInfo stage) => Data (TypeFamily dom stage)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TypeFamily dom stage -> c (TypeFamily dom stage)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (TypeFamily dom stage)

toConstr :: TypeFamily dom stage -> Constr

dataTypeOf :: TypeFamily dom stage -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (TypeFamily dom stage))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (TypeFamily dom stage))

gmapT :: (forall b. Data b => b -> b) -> TypeFamily dom stage -> TypeFamily dom stage

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TypeFamily dom stage -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TypeFamily dom stage -> r

gmapQ :: (forall d. Data d => d -> u) -> TypeFamily dom stage -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> TypeFamily dom stage -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TypeFamily dom stage -> m (TypeFamily dom stage)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeFamily dom stage -> m (TypeFamily dom stage)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeFamily dom stage -> m (TypeFamily dom stage)

(Domain dom, SourceInfo stage) => Data (Decl dom stage)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Decl dom stage -> c (Decl dom stage)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Decl dom stage)

toConstr :: Decl dom stage -> Constr

dataTypeOf :: Decl dom stage -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Decl dom stage))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Decl dom stage))

gmapT :: (forall b. Data b => b -> b) -> Decl dom stage -> Decl dom stage

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Decl dom stage -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Decl dom stage -> r

gmapQ :: (forall d. Data d => d -> u) -> Decl dom stage -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Decl dom stage -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Decl dom stage -> m (Decl dom stage)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Decl dom stage -> m (Decl dom stage)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Decl dom stage -> m (Decl dom stage)

(Domain dom, SourceInfo stage) => Data (ImportRenaming dom stage)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ImportRenaming dom stage -> c (ImportRenaming dom stage)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ImportRenaming dom stage)

toConstr :: ImportRenaming dom stage -> Constr

dataTypeOf :: ImportRenaming dom stage -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (ImportRenaming dom stage))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ImportRenaming dom stage))

gmapT :: (forall b. Data b => b -> b) -> ImportRenaming dom stage -> ImportRenaming dom stage

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ImportRenaming dom stage -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ImportRenaming dom stage -> r

gmapQ :: (forall d. Data d => d -> u) -> ImportRenaming dom stage -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ImportRenaming dom stage -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ImportRenaming dom stage -> m (ImportRenaming dom stage)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportRenaming dom stage -> m (ImportRenaming dom stage)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportRenaming dom stage -> m (ImportRenaming dom stage)

(Domain dom, SourceInfo stage) => Data (TypeNamespace dom stage)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TypeNamespace dom stage -> c (TypeNamespace dom stage)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (TypeNamespace dom stage)

toConstr :: TypeNamespace dom stage -> Constr

dataTypeOf :: TypeNamespace dom stage -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (TypeNamespace dom stage))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (TypeNamespace dom stage))

gmapT :: (forall b. Data b => b -> b) -> TypeNamespace dom stage -> TypeNamespace dom stage

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TypeNamespace dom stage -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TypeNamespace dom stage -> r

gmapQ :: (forall d. Data d => d -> u) -> TypeNamespace dom stage -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> TypeNamespace dom stage -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TypeNamespace dom stage -> m (TypeNamespace dom stage)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeNamespace dom stage -> m (TypeNamespace dom stage)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeNamespace dom stage -> m (TypeNamespace dom stage)

(Domain dom, SourceInfo stage) => Data (ImportSafe dom stage)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ImportSafe dom stage -> c (ImportSafe dom stage)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ImportSafe dom stage)

toConstr :: ImportSafe dom stage -> Constr

dataTypeOf :: ImportSafe dom stage -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (ImportSafe dom stage))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ImportSafe dom stage))

gmapT :: (forall b. Data b => b -> b) -> ImportSafe dom stage -> ImportSafe dom stage

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ImportSafe dom stage -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ImportSafe dom stage -> r

gmapQ :: (forall d. Data d => d -> u) -> ImportSafe dom stage -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ImportSafe dom stage -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ImportSafe dom stage -> m (ImportSafe dom stage)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportSafe dom stage -> m (ImportSafe dom stage)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportSafe dom stage -> m (ImportSafe dom stage)

(Domain dom, SourceInfo stage) => Data (ImportSource dom stage)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ImportSource dom stage -> c (ImportSource dom stage)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ImportSource dom stage)

toConstr :: ImportSource dom stage -> Constr

dataTypeOf :: ImportSource dom stage -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (ImportSource dom stage))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ImportSource dom stage))

gmapT :: (forall b. Data b => b -> b) -> ImportSource dom stage -> ImportSource dom stage

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ImportSource dom stage -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ImportSource dom stage -> r

gmapQ :: (forall d. Data d => d -> u) -> ImportSource dom stage -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ImportSource dom stage -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ImportSource dom stage -> m (ImportSource dom stage)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportSource dom stage -> m (ImportSource dom stage)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportSource dom stage -> m (ImportSource dom stage)

(Domain dom, SourceInfo stage) => Data (ImportQualified dom stage)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ImportQualified dom stage -> c (ImportQualified dom stage)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ImportQualified dom stage)

toConstr :: ImportQualified dom stage -> Constr

dataTypeOf :: ImportQualified dom stage -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (ImportQualified dom stage))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ImportQualified dom stage))

gmapT :: (forall b. Data b => b -> b) -> ImportQualified dom stage -> ImportQualified dom stage

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ImportQualified dom stage -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ImportQualified dom stage -> r

gmapQ :: (forall d. Data d => d -> u) -> ImportQualified dom stage -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ImportQualified dom stage -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ImportQualified dom stage -> m (ImportQualified dom stage)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportQualified dom stage -> m (ImportQualified dom stage)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportQualified dom stage -> m (ImportQualified dom stage)

(Domain dom, SourceInfo stage) => Data (ImportSpec dom stage)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ImportSpec dom stage -> c (ImportSpec dom stage)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ImportSpec dom stage)

toConstr :: ImportSpec dom stage -> Constr

dataTypeOf :: ImportSpec dom stage -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (ImportSpec dom stage))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ImportSpec dom stage))

gmapT :: (forall b. Data b => b -> b) -> ImportSpec dom stage -> ImportSpec dom stage

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ImportSpec dom stage -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ImportSpec dom stage -> r

gmapQ :: (forall d. Data d => d -> u) -> ImportSpec dom stage -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ImportSpec dom stage -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ImportSpec dom stage -> m (ImportSpec dom stage)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportSpec dom stage -> m (ImportSpec dom stage)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportSpec dom stage -> m (ImportSpec dom stage)

(Domain dom, SourceInfo stage) => Data (LanguageExtension dom stage)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LanguageExtension dom stage -> c (LanguageExtension dom stage)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (LanguageExtension dom stage)

toConstr :: LanguageExtension dom stage -> Constr

dataTypeOf :: LanguageExtension dom stage -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (LanguageExtension dom stage))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (LanguageExtension dom stage))

gmapT :: (forall b. Data b => b -> b) -> LanguageExtension dom stage -> LanguageExtension dom stage

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LanguageExtension dom stage -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LanguageExtension dom stage -> r

gmapQ :: (forall d. Data d => d -> u) -> LanguageExtension dom stage -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> LanguageExtension dom stage -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> LanguageExtension dom stage -> m (LanguageExtension dom stage)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LanguageExtension dom stage -> m (LanguageExtension dom stage)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LanguageExtension dom stage -> m (LanguageExtension dom stage)

(Domain dom, SourceInfo stage) => Data (ModulePragma dom stage)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ModulePragma dom stage -> c (ModulePragma dom stage)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ModulePragma dom stage)

toConstr :: ModulePragma dom stage -> Constr

dataTypeOf :: ModulePragma dom stage -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (ModulePragma dom stage))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ModulePragma dom stage))

gmapT :: (forall b. Data b => b -> b) -> ModulePragma dom stage -> ModulePragma dom stage

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ModulePragma dom stage -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ModulePragma dom stage -> r

gmapQ :: (forall d. Data d => d -> u) -> ModulePragma dom stage -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ModulePragma dom stage -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ModulePragma dom stage -> m (ModulePragma dom stage)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ModulePragma dom stage -> m (ModulePragma dom stage)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ModulePragma dom stage -> m (ModulePragma dom stage)

(Domain dom, SourceInfo stage) => Data (FilePragma dom stage)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FilePragma dom stage -> c (FilePragma dom stage)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FilePragma dom stage)

toConstr :: FilePragma dom stage -> Constr

dataTypeOf :: FilePragma dom stage -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (FilePragma dom stage))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FilePragma dom stage))

gmapT :: (forall b. Data b => b -> b) -> FilePragma dom stage -> FilePragma dom stage

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FilePragma dom stage -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FilePragma dom stage -> r

gmapQ :: (forall d. Data d => d -> u) -> FilePragma dom stage -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> FilePragma dom stage -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FilePragma dom stage -> m (FilePragma dom stage)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FilePragma dom stage -> m (FilePragma dom stage)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FilePragma dom stage -> m (FilePragma dom stage)

(Domain dom, SourceInfo stage) => Data (SubSpec dom stage)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SubSpec dom stage -> c (SubSpec dom stage)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (SubSpec dom stage)

toConstr :: SubSpec dom stage -> Constr

dataTypeOf :: SubSpec dom stage -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (SubSpec dom stage))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (SubSpec dom stage))

gmapT :: (forall b. Data b => b -> b) -> SubSpec dom stage -> SubSpec dom stage

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SubSpec dom stage -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SubSpec dom stage -> r

gmapQ :: (forall d. Data d => d -> u) -> SubSpec dom stage -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> SubSpec dom stage -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SubSpec dom stage -> m (SubSpec dom stage)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SubSpec dom stage -> m (SubSpec dom stage)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SubSpec dom stage -> m (SubSpec dom stage)

(Domain dom, SourceInfo stage) => Data (IESpec dom stage)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IESpec dom stage -> c (IESpec dom stage)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (IESpec dom stage)

toConstr :: IESpec dom stage -> Constr

dataTypeOf :: IESpec dom stage -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (IESpec dom stage))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (IESpec dom stage))

gmapT :: (forall b. Data b => b -> b) -> IESpec dom stage -> IESpec dom stage

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IESpec dom stage -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IESpec dom stage -> r

gmapQ :: (forall d. Data d => d -> u) -> IESpec dom stage -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> IESpec dom stage -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> IESpec dom stage -> m (IESpec dom stage)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IESpec dom stage -> m (IESpec dom stage)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IESpec dom stage -> m (IESpec dom stage)

(Domain dom, SourceInfo stage) => Data (ExportSpec dom stage)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ExportSpec dom stage -> c (ExportSpec dom stage)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ExportSpec dom stage)

toConstr :: ExportSpec dom stage -> Constr

dataTypeOf :: ExportSpec dom stage -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (ExportSpec dom stage))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ExportSpec dom stage))

gmapT :: (forall b. Data b => b -> b) -> ExportSpec dom stage -> ExportSpec dom stage

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ExportSpec dom stage -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ExportSpec dom stage -> r

gmapQ :: (forall d. Data d => d -> u) -> ExportSpec dom stage -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ExportSpec dom stage -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ExportSpec dom stage -> m (ExportSpec dom stage)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ExportSpec dom stage -> m (ExportSpec dom stage)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ExportSpec dom stage -> m (ExportSpec dom stage)

(Domain dom, SourceInfo stage) => Data (ExportSpecList dom stage)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ExportSpecList dom stage -> c (ExportSpecList dom stage)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ExportSpecList dom stage)

toConstr :: ExportSpecList dom stage -> Constr

dataTypeOf :: ExportSpecList dom stage -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (ExportSpecList dom stage))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ExportSpecList dom stage))

gmapT :: (forall b. Data b => b -> b) -> ExportSpecList dom stage -> ExportSpecList dom stage

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ExportSpecList dom stage -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ExportSpecList dom stage -> r

gmapQ :: (forall d. Data d => d -> u) -> ExportSpecList dom stage -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ExportSpecList dom stage -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ExportSpecList dom stage -> m (ExportSpecList dom stage)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ExportSpecList dom stage -> m (ExportSpecList dom stage)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ExportSpecList dom stage -> m (ExportSpecList dom stage)

(Domain dom, SourceInfo stage) => Data (ModuleHead dom stage)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ModuleHead dom stage -> c (ModuleHead dom stage)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ModuleHead dom stage)

toConstr :: ModuleHead dom stage -> Constr

dataTypeOf :: ModuleHead dom stage -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (ModuleHead dom stage))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ModuleHead dom stage))

gmapT :: (forall b. Data b => b -> b) -> ModuleHead dom stage -> ModuleHead dom stage

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ModuleHead dom stage -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ModuleHead dom stage -> r

gmapQ :: (forall d. Data d => d -> u) -> ModuleHead dom stage -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ModuleHead dom stage -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ModuleHead dom stage -> m (ModuleHead dom stage)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ModuleHead dom stage -> m (ModuleHead dom stage)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ModuleHead dom stage -> m (ModuleHead dom stage)

(Domain dom, SourceInfo stage) => Data (QQString dom stage)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> QQString dom stage -> c (QQString dom stage)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (QQString dom stage)

toConstr :: QQString dom stage -> Constr

dataTypeOf :: QQString dom stage -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (QQString dom stage))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (QQString dom stage))

gmapT :: (forall b. Data b => b -> b) -> QQString dom stage -> QQString dom stage

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> QQString dom stage -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> QQString dom stage -> r

gmapQ :: (forall d. Data d => d -> u) -> QQString dom stage -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> QQString dom stage -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> QQString dom stage -> m (QQString dom stage)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> QQString dom stage -> m (QQString dom stage)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> QQString dom stage -> m (QQString dom stage)

(DomainWith e dom, SourceInfo stage, Typeable (* -> * -> *) e, Data (e dom stage)) => Data (Ann e dom stage)

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 a. (Data d, Data a) => c (t d a)) -> 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)

(DomainWith e dom, SourceInfo stage, Typeable (* -> * -> *) e, Data (e dom stage)) => Data (AnnList e dom stage)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnList e dom stage -> c (AnnList e dom stage)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (AnnList e dom stage)

toConstr :: AnnList e dom stage -> Constr

dataTypeOf :: AnnList e dom stage -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (AnnList e dom stage))

dataCast2 :: Typeable (* -> * -> *) t => (forall d a. (Data d, Data a) => c (t d a)) -> Maybe (c (AnnList e dom stage))

gmapT :: (forall b. Data b => b -> b) -> AnnList e dom stage -> AnnList e dom stage

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnList e dom stage -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnList e dom stage -> r

gmapQ :: (forall d. Data d => d -> u) -> AnnList e dom stage -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnList e dom stage -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnList e dom stage -> m (AnnList e dom stage)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnList e dom stage -> m (AnnList e dom stage)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnList e dom stage -> m (AnnList e dom stage)

(DomainWith e dom, SourceInfo stage, Typeable (* -> * -> *) e, Data (e dom stage)) => Data (AnnMaybe e dom stage)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnMaybe e dom stage -> c (AnnMaybe e dom stage)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (AnnMaybe e dom stage)

toConstr :: AnnMaybe e dom stage -> Constr

dataTypeOf :: AnnMaybe e dom stage -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (AnnMaybe e dom stage))

dataCast2 :: Typeable (* -> * -> *) t => (forall d a. (Data d, Data a) => c (t d a)) -> Maybe (c (AnnMaybe e dom stage))

gmapT :: (forall b. Data b => b -> b) -> AnnMaybe e dom stage -> AnnMaybe e dom stage

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnMaybe e dom stage -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnMaybe e dom stage -> r

gmapQ :: (forall d. Data d => d -> u) -> AnnMaybe e dom stage -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnMaybe e dom stage -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnMaybe e dom stage -> m (AnnMaybe e dom stage)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnMaybe e dom stage -> m (AnnMaybe e dom stage)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnMaybe e dom stage -> m (AnnMaybe e dom stage)

(DomainWith k dom, SourceInfo stage, Typeable (* -> * -> *) k, Data (k dom stage)) => Data (Promoted k dom stage)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Promoted k dom stage -> c (Promoted k dom stage)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Promoted k dom stage)

toConstr :: Promoted k dom stage -> Constr

dataTypeOf :: Promoted k dom stage -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Promoted k dom stage))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Promoted k dom stage))

gmapT :: (forall b. Data b => b -> b) -> Promoted k dom stage -> Promoted k dom stage

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Promoted k dom stage -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Promoted k dom stage -> r

gmapQ :: (forall d. Data d => d -> u) -> Promoted k dom stage -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Promoted k dom stage -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Promoted k dom stage -> m (Promoted k dom stage)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Promoted k dom stage -> m (Promoted k dom stage)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Promoted k dom stage -> m (Promoted k dom stage)

(DomainWith expr dom, SourceInfo stage, Typeable (* -> * -> *) expr, Data (expr dom stage)) => Data (Stmt' expr dom stage)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Stmt' expr dom stage -> c (Stmt' expr dom stage)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Stmt' expr dom stage)

toConstr :: Stmt' expr dom stage -> Constr

dataTypeOf :: Stmt' expr dom stage -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Stmt' expr dom stage))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Stmt' expr dom stage))

gmapT :: (forall b. Data b => b -> b) -> Stmt' expr dom stage -> Stmt' expr dom stage

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Stmt' expr dom stage -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Stmt' expr dom stage -> r

gmapQ :: (forall d. Data d => d -> u) -> Stmt' expr dom stage -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Stmt' expr dom stage -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Stmt' expr dom stage -> m (Stmt' expr dom stage)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Stmt' expr dom stage -> m (Stmt' expr dom stage)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Stmt' expr dom stage -> m (Stmt' expr dom stage)

(DomainWith expr dom, SourceInfo stage, Typeable (* -> * -> *) expr, Data (expr dom stage)) => Data (GuardedCaseRhs' expr dom stage)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GuardedCaseRhs' expr dom stage -> c (GuardedCaseRhs' expr dom stage)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (GuardedCaseRhs' expr dom stage)

toConstr :: GuardedCaseRhs' expr dom stage -> Constr

dataTypeOf :: GuardedCaseRhs' expr dom stage -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (GuardedCaseRhs' expr dom stage))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (GuardedCaseRhs' expr dom stage))

gmapT :: (forall b. Data b => b -> b) -> GuardedCaseRhs' expr dom stage -> GuardedCaseRhs' expr dom stage

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GuardedCaseRhs' expr dom stage -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GuardedCaseRhs' expr dom stage -> r

gmapQ :: (forall d. Data d => d -> u) -> GuardedCaseRhs' expr dom stage -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> GuardedCaseRhs' expr dom stage -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GuardedCaseRhs' expr dom stage -> m (GuardedCaseRhs' expr dom stage)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GuardedCaseRhs' expr dom stage -> m (GuardedCaseRhs' expr dom stage)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GuardedCaseRhs' expr dom stage -> m (GuardedCaseRhs' expr dom stage)

(DomainWith expr dom, SourceInfo stage, Typeable (* -> * -> *) expr, Data (expr dom stage)) => Data (CaseRhs' expr dom stage)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CaseRhs' expr dom stage -> c (CaseRhs' expr dom stage)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (CaseRhs' expr dom stage)

toConstr :: CaseRhs' expr dom stage -> Constr

dataTypeOf :: CaseRhs' expr dom stage -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (CaseRhs' expr dom stage))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CaseRhs' expr dom stage))

gmapT :: (forall b. Data b => b -> b) -> CaseRhs' expr dom stage -> CaseRhs' expr dom stage

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CaseRhs' expr dom stage -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CaseRhs' expr dom stage -> r

gmapQ :: (forall d. Data d => d -> u) -> CaseRhs' expr dom stage -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> CaseRhs' expr dom stage -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> CaseRhs' expr dom stage -> m (CaseRhs' expr dom stage)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CaseRhs' expr dom stage -> m (CaseRhs' expr dom stage)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CaseRhs' expr dom stage -> m (CaseRhs' expr dom stage)

(DomainWith expr dom, SourceInfo stage, Typeable (* -> * -> *) expr, Data (expr dom stage)) => Data (Alt' expr dom stage)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Alt' expr dom stage -> c (Alt' expr dom stage)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Alt' expr dom stage)

toConstr :: Alt' expr dom stage -> Constr

dataTypeOf :: Alt' expr dom stage -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Alt' expr dom stage))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Alt' expr dom stage))

gmapT :: (forall b. Data b => b -> b) -> Alt' expr dom stage -> Alt' expr dom stage

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alt' expr dom stage -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Alt' expr dom stage -> r

gmapQ :: (forall d. Data d => d -> u) -> Alt' expr dom stage -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Alt' expr dom stage -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Alt' expr dom stage -> m (Alt' expr dom stage)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Alt' expr dom stage -> m (Alt' expr dom stage)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Alt' expr dom stage -> m (Alt' expr dom stage)