napkin-0.5.13
Safe HaskellNone
LanguageHaskell2010

PostgresqlSyntax.Ast.Instances.Data

Orphan instances

Data PreparableStmt # 
Instance details

Methods

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

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

toConstr :: PreparableStmt -> Constr #

dataTypeOf :: PreparableStmt -> DataType #

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

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

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

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

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

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

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

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

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

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

Data InsertStmt # 
Instance details

Methods

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

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

toConstr :: InsertStmt -> Constr #

dataTypeOf :: InsertStmt -> DataType #

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

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

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

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

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

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

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

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

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

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

Data InsertTarget # 
Instance details

Methods

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

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

toConstr :: InsertTarget -> Constr #

dataTypeOf :: InsertTarget -> DataType #

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

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

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

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

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

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

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

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

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

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

Data InsertRest # 
Instance details

Methods

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

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

toConstr :: InsertRest -> Constr #

dataTypeOf :: InsertRest -> DataType #

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

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

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

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

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

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

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

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

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

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

Data OverrideKind # 
Instance details

Methods

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

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

toConstr :: OverrideKind -> Constr #

dataTypeOf :: OverrideKind -> DataType #

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

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

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

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

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

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

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

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

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

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

Data InsertColumnItem # 
Instance details

Methods

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

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

toConstr :: InsertColumnItem -> Constr #

dataTypeOf :: InsertColumnItem -> DataType #

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

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

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

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

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

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

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

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

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

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

Data OnConflict # 
Instance details

Methods

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

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

toConstr :: OnConflict -> Constr #

dataTypeOf :: OnConflict -> DataType #

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

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

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

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

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

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

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

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

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

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

Data OnConflictDo # 
Instance details

Methods

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

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

toConstr :: OnConflictDo -> Constr #

dataTypeOf :: OnConflictDo -> DataType #

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

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

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

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

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

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

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

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

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

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

Data ConfExpr # 
Instance details

Methods

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

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

toConstr :: ConfExpr -> Constr #

dataTypeOf :: ConfExpr -> DataType #

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

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

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

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

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

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

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

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

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

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

Data UpdateStmt # 
Instance details

Methods

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

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

toConstr :: UpdateStmt -> Constr #

dataTypeOf :: UpdateStmt -> DataType #

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

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

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

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

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

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

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

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

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

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

Data SetClause # 
Instance details

Methods

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

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

toConstr :: SetClause -> Constr #

dataTypeOf :: SetClause -> DataType #

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

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

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

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

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

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

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

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

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

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

Data SetTarget # 
Instance details

Methods

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

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

toConstr :: SetTarget -> Constr #

dataTypeOf :: SetTarget -> DataType #

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

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

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

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

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

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

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

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

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

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

Data DeleteStmt # 
Instance details

Methods

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

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

toConstr :: DeleteStmt -> Constr #

dataTypeOf :: DeleteStmt -> DataType #

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

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

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

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

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

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

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

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

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

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

Data SelectWithParens # 
Instance details

Methods

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

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

toConstr :: SelectWithParens -> Constr #

dataTypeOf :: SelectWithParens -> DataType #

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

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

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

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

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

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

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

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

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

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

Data SelectNoParens # 
Instance details

Methods

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

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

toConstr :: SelectNoParens -> Constr #

dataTypeOf :: SelectNoParens -> DataType #

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

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

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

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

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

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

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

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

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

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

Data SimpleSelect # 
Instance details

Methods

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

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

toConstr :: SimpleSelect -> Constr #

dataTypeOf :: SimpleSelect -> DataType #

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

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

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

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

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

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

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

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

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

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

Data Targeting # 
Instance details

Methods

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

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

toConstr :: Targeting -> Constr #

dataTypeOf :: Targeting -> DataType #

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

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

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

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

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

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

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

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

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

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

Data TargetEl # 
Instance details

Methods

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

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

toConstr :: TargetEl -> Constr #

dataTypeOf :: TargetEl -> DataType #

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

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

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

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

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

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

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

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

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

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

Data SelectBinOp # 
Instance details

Methods

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

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

toConstr :: SelectBinOp -> Constr #

dataTypeOf :: SelectBinOp -> DataType #

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

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

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

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

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

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

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

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

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

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

Data WithClause # 
Instance details

Methods

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

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

toConstr :: WithClause -> Constr #

dataTypeOf :: WithClause -> DataType #

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

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

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

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

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

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

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

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

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

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

Data CommonTableExpr # 
Instance details

Methods

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

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

toConstr :: CommonTableExpr -> Constr #

dataTypeOf :: CommonTableExpr -> DataType #

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

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

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

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

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

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

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

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

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

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

Data OptTempTableName # 
Instance details

Methods

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

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

toConstr :: OptTempTableName -> Constr #

dataTypeOf :: OptTempTableName -> DataType #

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

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

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

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

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

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

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

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

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

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

Data GroupByItem # 
Instance details

Methods

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

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

toConstr :: GroupByItem -> Constr #

dataTypeOf :: GroupByItem -> DataType #

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

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

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

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

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

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

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

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

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

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

Data WindowDefinition # 
Instance details

Methods

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

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

toConstr :: WindowDefinition -> Constr #

dataTypeOf :: WindowDefinition -> DataType #

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

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

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

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

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

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

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

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

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

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

Data WindowSpecification # 
Instance details

Methods

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

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

toConstr :: WindowSpecification -> Constr #

dataTypeOf :: WindowSpecification -> DataType #

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

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

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

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

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

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

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

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

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

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

Data FrameClause # 
Instance details

Methods

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

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

toConstr :: FrameClause -> Constr #

dataTypeOf :: FrameClause -> DataType #

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

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

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

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

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

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

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

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

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

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

Data FrameClauseMode # 
Instance details

Methods

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

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

toConstr :: FrameClauseMode -> Constr #

dataTypeOf :: FrameClauseMode -> DataType #

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

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

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

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

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

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

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

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

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

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

Data FrameExtent # 
Instance details

Methods

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

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

toConstr :: FrameExtent -> Constr #

dataTypeOf :: FrameExtent -> DataType #

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

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

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

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

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

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

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

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

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

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

Data FrameBound # 
Instance details

Methods

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

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

toConstr :: FrameBound -> Constr #

dataTypeOf :: FrameBound -> DataType #

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

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

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

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

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

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

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

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

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

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

Data WindowExclusionClause # 
Instance details

Methods

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

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

toConstr :: WindowExclusionClause -> Constr #

dataTypeOf :: WindowExclusionClause -> DataType #

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

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

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

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

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

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

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

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

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

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

Data SortBy # 
Instance details

Methods

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

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

toConstr :: SortBy -> Constr #

dataTypeOf :: SortBy -> DataType #

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

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

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

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

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

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

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

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

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

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

Data SelectLimit # 
Instance details

Methods

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

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

toConstr :: SelectLimit -> Constr #

dataTypeOf :: SelectLimit -> DataType #

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

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

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

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

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

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

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

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

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

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

Data LimitClause # 
Instance details

Methods

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

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

toConstr :: LimitClause -> Constr #

dataTypeOf :: LimitClause -> DataType #

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

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

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

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

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

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

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

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

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

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

Data SelectFetchFirstValue # 
Instance details

Methods

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

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

toConstr :: SelectFetchFirstValue -> Constr #

dataTypeOf :: SelectFetchFirstValue -> DataType #

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

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

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

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

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

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

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

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

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

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

Data SelectLimitValue # 
Instance details

Methods

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

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

toConstr :: SelectLimitValue -> Constr #

dataTypeOf :: SelectLimitValue -> DataType #

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

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

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

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

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

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

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

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

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

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

Data OffsetClause # 
Instance details

Methods

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

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

toConstr :: OffsetClause -> Constr #

dataTypeOf :: OffsetClause -> DataType #

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

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

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

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

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

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

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

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

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

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

Data ForLockingClause # 
Instance details

Methods

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

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

toConstr :: ForLockingClause -> Constr #

dataTypeOf :: ForLockingClause -> DataType #

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

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

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

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

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

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

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

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

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

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

Data ForLockingItem # 
Instance details

Methods

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

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

toConstr :: ForLockingItem -> Constr #

dataTypeOf :: ForLockingItem -> DataType #

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

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

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

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

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

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

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

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

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

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

Data ForLockingStrength # 
Instance details

Methods

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

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

toConstr :: ForLockingStrength -> Constr #

dataTypeOf :: ForLockingStrength -> DataType #

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

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

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

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

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

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

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

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

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

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

Data TableRef # 
Instance details

Methods

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

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

toConstr :: TableRef -> Constr #

dataTypeOf :: TableRef -> DataType #

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

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

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

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

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

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

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

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

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

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

Data RelationExpr # 
Instance details

Methods

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

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

toConstr :: RelationExpr -> Constr #

dataTypeOf :: RelationExpr -> DataType #

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

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

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

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

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

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

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

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

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

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

Data RelationExprOptAlias # 
Instance details

Methods

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

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

toConstr :: RelationExprOptAlias -> Constr #

dataTypeOf :: RelationExprOptAlias -> DataType #

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

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

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

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

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

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

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

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

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

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

Data TablesampleClause # 
Instance details

Methods

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

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

toConstr :: TablesampleClause -> Constr #

dataTypeOf :: TablesampleClause -> DataType #

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

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

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

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

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

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

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

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

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

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

Data FuncTable # 
Instance details

Methods

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

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

toConstr :: FuncTable -> Constr #

dataTypeOf :: FuncTable -> DataType #

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

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

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

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

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

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

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

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

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

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

Data RowsfromItem # 
Instance details

Methods

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

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

toConstr :: RowsfromItem -> Constr #

dataTypeOf :: RowsfromItem -> DataType #

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

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

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

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

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

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

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

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

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

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

Data TableFuncElement # 
Instance details

Methods

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

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

toConstr :: TableFuncElement -> Constr #

dataTypeOf :: TableFuncElement -> DataType #

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

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

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

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

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

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

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

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

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

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

Data AliasClause # 
Instance details

Methods

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

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

toConstr :: AliasClause -> Constr #

dataTypeOf :: AliasClause -> DataType #

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

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

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

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

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

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

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

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

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

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

Data FuncAliasClause # 
Instance details

Methods

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

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

toConstr :: FuncAliasClause -> Constr #

dataTypeOf :: FuncAliasClause -> DataType #

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

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

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

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

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

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

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

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

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

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

Data JoinedTable # 
Instance details

Methods

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

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

toConstr :: JoinedTable -> Constr #

dataTypeOf :: JoinedTable -> DataType #

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

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

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

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

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

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

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

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

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

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

Data JoinMeth # 
Instance details

Methods

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

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

toConstr :: JoinMeth -> Constr #

dataTypeOf :: JoinMeth -> DataType #

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

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

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

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

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

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

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

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

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

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

Data JoinType # 
Instance details

Methods

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

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

toConstr :: JoinType -> Constr #

dataTypeOf :: JoinType -> DataType #

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

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

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

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

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

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

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

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

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

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

Data JoinQual # 
Instance details

Methods

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

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

toConstr :: JoinQual -> Constr #

dataTypeOf :: JoinQual -> DataType #

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

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

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

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

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

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

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

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

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

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

Data WhereOrCurrentClause # 
Instance details

Methods

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

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

toConstr :: WhereOrCurrentClause -> Constr #

dataTypeOf :: WhereOrCurrentClause -> DataType #

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

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

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

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

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

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

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

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

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

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

Data AExpr # 
Instance details

Methods

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

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

toConstr :: AExpr -> Constr #

dataTypeOf :: AExpr -> DataType #

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

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

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

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

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

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

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

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

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

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

Data BExpr # 
Instance details

Methods

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

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

toConstr :: BExpr -> Constr #

dataTypeOf :: BExpr -> DataType #

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

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

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

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

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

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

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

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

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

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

Data CExpr # 
Instance details

Methods

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

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

toConstr :: CExpr -> Constr #

dataTypeOf :: CExpr -> DataType #

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

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

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

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

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

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

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

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

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

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

Data InExpr # 
Instance details

Methods

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

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

toConstr :: InExpr -> Constr #

dataTypeOf :: InExpr -> DataType #

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

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

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

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

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

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

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

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

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

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

Data SubType # 
Instance details

Methods

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

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

toConstr :: SubType -> Constr #

dataTypeOf :: SubType -> DataType #

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

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

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

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

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

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

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

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

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

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

Data ArrayExpr # 
Instance details

Methods

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

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

toConstr :: ArrayExpr -> Constr #

dataTypeOf :: ArrayExpr -> DataType #

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

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

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

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

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

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

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

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

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

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

Data Row # 
Instance details

Methods

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

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

toConstr :: Row -> Constr #

dataTypeOf :: Row -> DataType #

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

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

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

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

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

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

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

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

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

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

Data ImplicitRow # 
Instance details

Methods

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

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

toConstr :: ImplicitRow -> Constr #

dataTypeOf :: ImplicitRow -> DataType #

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

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

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

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

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

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

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

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

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

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

Data FuncExpr # 
Instance details

Methods

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

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

toConstr :: FuncExpr -> Constr #

dataTypeOf :: FuncExpr -> DataType #

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

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

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

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

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

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

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

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

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

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

Data FuncExprWindowless # 
Instance details

Methods

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

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

toConstr :: FuncExprWindowless -> Constr #

dataTypeOf :: FuncExprWindowless -> DataType #

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

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

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

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

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

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

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

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

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

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

Data OverClause # 
Instance details

Methods

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

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

toConstr :: OverClause -> Constr #

dataTypeOf :: OverClause -> DataType #

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

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

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

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

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

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

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

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

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

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

Data FuncExprCommonSubexpr # 
Instance details

Methods

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

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

toConstr :: FuncExprCommonSubexpr -> Constr #

dataTypeOf :: FuncExprCommonSubexpr -> DataType #

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

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

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

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

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

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

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

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

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

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

Data ExtractList # 
Instance details

Methods

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

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

toConstr :: ExtractList -> Constr #

dataTypeOf :: ExtractList -> DataType #

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

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

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

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

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

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

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

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

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

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

Data ExtractArg # 
Instance details

Methods

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

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

toConstr :: ExtractArg -> Constr #

dataTypeOf :: ExtractArg -> DataType #

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

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

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

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

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

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

gmapQi :: Int -> (forall d. Data d => d -> u) -> ExtractArg -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ExtractArg -> m ExtractArg #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ExtractArg -> m ExtractArg #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ExtractArg -> m ExtractArg #

Data OverlayList # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OverlayList -> c OverlayList #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OverlayList #

toConstr :: OverlayList -> Constr #

dataTypeOf :: OverlayList -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c OverlayList) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OverlayList) #

gmapT :: (forall b. Data b => b -> b) -> OverlayList -> OverlayList #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OverlayList -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OverlayList -> r #

gmapQ :: (forall d. Data d => d -> u) -> OverlayList -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> OverlayList -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> OverlayList -> m OverlayList #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OverlayList -> m OverlayList #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OverlayList -> m OverlayList #

Data PositionList # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PositionList -> c PositionList #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PositionList #

toConstr :: PositionList -> Constr #

dataTypeOf :: PositionList -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c PositionList) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PositionList) #

gmapT :: (forall b. Data b => b -> b) -> PositionList -> PositionList #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PositionList -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PositionList -> r #

gmapQ :: (forall d. Data d => d -> u) -> PositionList -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> PositionList -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> PositionList -> m PositionList #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PositionList -> m PositionList #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PositionList -> m PositionList #

Data SubstrList # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SubstrList -> c SubstrList #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SubstrList #

toConstr :: SubstrList -> Constr #

dataTypeOf :: SubstrList -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SubstrList) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SubstrList) #

gmapT :: (forall b. Data b => b -> b) -> SubstrList -> SubstrList #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SubstrList -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SubstrList -> r #

gmapQ :: (forall d. Data d => d -> u) -> SubstrList -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SubstrList -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SubstrList -> m SubstrList #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SubstrList -> m SubstrList #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SubstrList -> m SubstrList #

Data SubstrListFromFor # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SubstrListFromFor -> c SubstrListFromFor #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SubstrListFromFor #

toConstr :: SubstrListFromFor -> Constr #

dataTypeOf :: SubstrListFromFor -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SubstrListFromFor) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SubstrListFromFor) #

gmapT :: (forall b. Data b => b -> b) -> SubstrListFromFor -> SubstrListFromFor #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SubstrListFromFor -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SubstrListFromFor -> r #

gmapQ :: (forall d. Data d => d -> u) -> SubstrListFromFor -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SubstrListFromFor -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SubstrListFromFor -> m SubstrListFromFor #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SubstrListFromFor -> m SubstrListFromFor #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SubstrListFromFor -> m SubstrListFromFor #

Data TrimModifier # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TrimModifier -> c TrimModifier #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TrimModifier #

toConstr :: TrimModifier -> Constr #

dataTypeOf :: TrimModifier -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TrimModifier) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TrimModifier) #

gmapT :: (forall b. Data b => b -> b) -> TrimModifier -> TrimModifier #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TrimModifier -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TrimModifier -> r #

gmapQ :: (forall d. Data d => d -> u) -> TrimModifier -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> TrimModifier -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TrimModifier -> m TrimModifier #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TrimModifier -> m TrimModifier #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TrimModifier -> m TrimModifier #

Data TrimList # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TrimList -> c TrimList #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TrimList #

toConstr :: TrimList -> Constr #

dataTypeOf :: TrimList -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TrimList) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TrimList) #

gmapT :: (forall b. Data b => b -> b) -> TrimList -> TrimList #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TrimList -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TrimList -> r #

gmapQ :: (forall d. Data d => d -> u) -> TrimList -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> TrimList -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TrimList -> m TrimList #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TrimList -> m TrimList #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TrimList -> m TrimList #

Data CaseExpr # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CaseExpr -> c CaseExpr #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CaseExpr #

toConstr :: CaseExpr -> Constr #

dataTypeOf :: CaseExpr -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c CaseExpr) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CaseExpr) #

gmapT :: (forall b. Data b => b -> b) -> CaseExpr -> CaseExpr #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CaseExpr -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CaseExpr -> r #

gmapQ :: (forall d. Data d => d -> u) -> CaseExpr -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> CaseExpr -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> CaseExpr -> m CaseExpr #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CaseExpr -> m CaseExpr #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CaseExpr -> m CaseExpr #

Data WhenClause # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WhenClause -> c WhenClause #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c WhenClause #

toConstr :: WhenClause -> Constr #

dataTypeOf :: WhenClause -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c WhenClause) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WhenClause) #

gmapT :: (forall b. Data b => b -> b) -> WhenClause -> WhenClause #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WhenClause -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WhenClause -> r #

gmapQ :: (forall d. Data d => d -> u) -> WhenClause -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> WhenClause -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> WhenClause -> m WhenClause #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WhenClause -> m WhenClause #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WhenClause -> m WhenClause #

Data FuncApplication # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FuncApplication -> c FuncApplication #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FuncApplication #

toConstr :: FuncApplication -> Constr #

dataTypeOf :: FuncApplication -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FuncApplication) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FuncApplication) #

gmapT :: (forall b. Data b => b -> b) -> FuncApplication -> FuncApplication #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FuncApplication -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FuncApplication -> r #

gmapQ :: (forall d. Data d => d -> u) -> FuncApplication -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FuncApplication -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FuncApplication -> m FuncApplication #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FuncApplication -> m FuncApplication #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FuncApplication -> m FuncApplication #

Data FuncApplicationParams # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FuncApplicationParams -> c FuncApplicationParams #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FuncApplicationParams #

toConstr :: FuncApplicationParams -> Constr #

dataTypeOf :: FuncApplicationParams -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FuncApplicationParams) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FuncApplicationParams) #

gmapT :: (forall b. Data b => b -> b) -> FuncApplicationParams -> FuncApplicationParams #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FuncApplicationParams -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FuncApplicationParams -> r #

gmapQ :: (forall d. Data d => d -> u) -> FuncApplicationParams -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FuncApplicationParams -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FuncApplicationParams -> m FuncApplicationParams #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FuncApplicationParams -> m FuncApplicationParams #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FuncApplicationParams -> m FuncApplicationParams #

Data FuncArgExpr # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FuncArgExpr -> c FuncArgExpr #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FuncArgExpr #

toConstr :: FuncArgExpr -> Constr #

dataTypeOf :: FuncArgExpr -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FuncArgExpr) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FuncArgExpr) #

gmapT :: (forall b. Data b => b -> b) -> FuncArgExpr -> FuncArgExpr #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FuncArgExpr -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FuncArgExpr -> r #

gmapQ :: (forall d. Data d => d -> u) -> FuncArgExpr -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FuncArgExpr -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FuncArgExpr -> m FuncArgExpr #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FuncArgExpr -> m FuncArgExpr #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FuncArgExpr -> m FuncArgExpr #

Data AexprConst # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AexprConst -> c AexprConst #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AexprConst #

toConstr :: AexprConst -> Constr #

dataTypeOf :: AexprConst -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AexprConst) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AexprConst) #

gmapT :: (forall b. Data b => b -> b) -> AexprConst -> AexprConst #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AexprConst -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AexprConst -> r #

gmapQ :: (forall d. Data d => d -> u) -> AexprConst -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> AexprConst -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AexprConst -> m AexprConst #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AexprConst -> m AexprConst #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AexprConst -> m AexprConst #

Data FuncConstArgs # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FuncConstArgs -> c FuncConstArgs #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FuncConstArgs #

toConstr :: FuncConstArgs -> Constr #

dataTypeOf :: FuncConstArgs -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FuncConstArgs) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FuncConstArgs) #

gmapT :: (forall b. Data b => b -> b) -> FuncConstArgs -> FuncConstArgs #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FuncConstArgs -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FuncConstArgs -> r #

gmapQ :: (forall d. Data d => d -> u) -> FuncConstArgs -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FuncConstArgs -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FuncConstArgs -> m FuncConstArgs #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FuncConstArgs -> m FuncConstArgs #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FuncConstArgs -> m FuncConstArgs #

Data ConstTypename # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ConstTypename -> c ConstTypename #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ConstTypename #

toConstr :: ConstTypename -> Constr #

dataTypeOf :: ConstTypename -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ConstTypename) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ConstTypename) #

gmapT :: (forall b. Data b => b -> b) -> ConstTypename -> ConstTypename #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ConstTypename -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ConstTypename -> r #

gmapQ :: (forall d. Data d => d -> u) -> ConstTypename -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ConstTypename -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ConstTypename -> m ConstTypename #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ConstTypename -> m ConstTypename #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ConstTypename -> m ConstTypename #

Data Numeric # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Numeric -> c Numeric #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Numeric #

toConstr :: Numeric -> Constr #

dataTypeOf :: Numeric -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Numeric) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Numeric) #

gmapT :: (forall b. Data b => b -> b) -> Numeric -> Numeric #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Numeric -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Numeric -> r #

gmapQ :: (forall d. Data d => d -> u) -> Numeric -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Numeric -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Numeric -> m Numeric #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Numeric -> m Numeric #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Numeric -> m Numeric #

Data Bit # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Bit -> c Bit #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Bit #

toConstr :: Bit -> Constr #

dataTypeOf :: Bit -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Bit) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bit) #

gmapT :: (forall b. Data b => b -> b) -> Bit -> Bit #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bit -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bit -> r #

gmapQ :: (forall d. Data d => d -> u) -> Bit -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Bit -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Bit -> m Bit #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Bit -> m Bit #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Bit -> m Bit #

Data ConstCharacter # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ConstCharacter -> c ConstCharacter #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ConstCharacter #

toConstr :: ConstCharacter -> Constr #

dataTypeOf :: ConstCharacter -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ConstCharacter) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ConstCharacter) #

gmapT :: (forall b. Data b => b -> b) -> ConstCharacter -> ConstCharacter #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ConstCharacter -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ConstCharacter -> r #

gmapQ :: (forall d. Data d => d -> u) -> ConstCharacter -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ConstCharacter -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ConstCharacter -> m ConstCharacter #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ConstCharacter -> m ConstCharacter #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ConstCharacter -> m ConstCharacter #

Data Character # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Character -> c Character #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Character #

toConstr :: Character -> Constr #

dataTypeOf :: Character -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Character) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Character) #

gmapT :: (forall b. Data b => b -> b) -> Character -> Character #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Character -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Character -> r #

gmapQ :: (forall d. Data d => d -> u) -> Character -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Character -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Character -> m Character #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Character -> m Character #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Character -> m Character #

Data ConstDatetime # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ConstDatetime -> c ConstDatetime #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ConstDatetime #

toConstr :: ConstDatetime -> Constr #

dataTypeOf :: ConstDatetime -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ConstDatetime) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ConstDatetime) #

gmapT :: (forall b. Data b => b -> b) -> ConstDatetime -> ConstDatetime #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ConstDatetime -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ConstDatetime -> r #

gmapQ :: (forall d. Data d => d -> u) -> ConstDatetime -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ConstDatetime -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ConstDatetime -> m ConstDatetime #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ConstDatetime -> m ConstDatetime #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ConstDatetime -> m ConstDatetime #

Data Interval # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Interval -> c Interval #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Interval #

toConstr :: Interval -> Constr #

dataTypeOf :: Interval -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Interval) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Interval) #

gmapT :: (forall b. Data b => b -> b) -> Interval -> Interval #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Interval -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Interval -> r #

gmapQ :: (forall d. Data d => d -> u) -> Interval -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Interval -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Interval -> m Interval #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Interval -> m Interval #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Interval -> m Interval #

Data Ident # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ident -> c Ident #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Ident #

toConstr :: Ident -> Constr #

dataTypeOf :: Ident -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Ident) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ident) #

gmapT :: (forall b. Data b => b -> b) -> Ident -> Ident #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ident -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ident -> r #

gmapQ :: (forall d. Data d => d -> u) -> Ident -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Ident -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ident -> m Ident #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ident -> m Ident #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ident -> m Ident #

Data Columnref # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Columnref -> c Columnref #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Columnref #

toConstr :: Columnref -> Constr #

dataTypeOf :: Columnref -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Columnref) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Columnref) #

gmapT :: (forall b. Data b => b -> b) -> Columnref -> Columnref #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Columnref -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Columnref -> r #

gmapQ :: (forall d. Data d => d -> u) -> Columnref -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Columnref -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Columnref -> m Columnref #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Columnref -> m Columnref #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Columnref -> m Columnref #

Data AnyName # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnyName -> c AnyName #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AnyName #

toConstr :: AnyName -> Constr #

dataTypeOf :: AnyName -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AnyName) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnyName) #

gmapT :: (forall b. Data b => b -> b) -> AnyName -> AnyName #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnyName -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnyName -> r #

gmapQ :: (forall d. Data d => d -> u) -> AnyName -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> AnyName -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnyName -> m AnyName #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnyName -> m AnyName #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnyName -> m AnyName #

Data FuncName # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FuncName -> c FuncName #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FuncName #

toConstr :: FuncName -> Constr #

dataTypeOf :: FuncName -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FuncName) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FuncName) #

gmapT :: (forall b. Data b => b -> b) -> FuncName -> FuncName #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FuncName -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FuncName -> r #

gmapQ :: (forall d. Data d => d -> u) -> FuncName -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FuncName -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FuncName -> m FuncName #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FuncName -> m FuncName #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FuncName -> m FuncName #

Data QualifiedName # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> QualifiedName -> c QualifiedName #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c QualifiedName #

toConstr :: QualifiedName -> Constr #

dataTypeOf :: QualifiedName -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c QualifiedName) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c QualifiedName) #

gmapT :: (forall b. Data b => b -> b) -> QualifiedName -> QualifiedName #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> QualifiedName -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> QualifiedName -> r #

gmapQ :: (forall d. Data d => d -> u) -> QualifiedName -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> QualifiedName -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> QualifiedName -> m QualifiedName #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> QualifiedName -> m QualifiedName #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> QualifiedName -> m QualifiedName #

Data IndirectionEl # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IndirectionEl -> c IndirectionEl #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c IndirectionEl #

toConstr :: IndirectionEl -> Constr #

dataTypeOf :: IndirectionEl -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c IndirectionEl) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IndirectionEl) #

gmapT :: (forall b. Data b => b -> b) -> IndirectionEl -> IndirectionEl #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IndirectionEl -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IndirectionEl -> r #

gmapQ :: (forall d. Data d => d -> u) -> IndirectionEl -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> IndirectionEl -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> IndirectionEl -> m IndirectionEl #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IndirectionEl -> m IndirectionEl #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IndirectionEl -> m IndirectionEl #

Data Typename # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Typename -> c Typename #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Typename #

toConstr :: Typename -> Constr #

dataTypeOf :: Typename -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Typename) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Typename) #

gmapT :: (forall b. Data b => b -> b) -> Typename -> Typename #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Typename -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Typename -> r #

gmapQ :: (forall d. Data d => d -> u) -> Typename -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Typename -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Typename -> m Typename #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Typename -> m Typename #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Typename -> m Typename #

Data TypenameArrayDimensions # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TypenameArrayDimensions -> c TypenameArrayDimensions #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TypenameArrayDimensions #

toConstr :: TypenameArrayDimensions -> Constr #

dataTypeOf :: TypenameArrayDimensions -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TypenameArrayDimensions) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypenameArrayDimensions) #

gmapT :: (forall b. Data b => b -> b) -> TypenameArrayDimensions -> TypenameArrayDimensions #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TypenameArrayDimensions -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TypenameArrayDimensions -> r #

gmapQ :: (forall d. Data d => d -> u) -> TypenameArrayDimensions -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> TypenameArrayDimensions -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TypenameArrayDimensions -> m TypenameArrayDimensions #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TypenameArrayDimensions -> m TypenameArrayDimensions #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TypenameArrayDimensions -> m TypenameArrayDimensions #

Data SimpleTypename # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SimpleTypename -> c SimpleTypename #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SimpleTypename #

toConstr :: SimpleTypename -> Constr #

dataTypeOf :: SimpleTypename -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SimpleTypename) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SimpleTypename) #

gmapT :: (forall b. Data b => b -> b) -> SimpleTypename -> SimpleTypename #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SimpleTypename -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SimpleTypename -> r #

gmapQ :: (forall d. Data d => d -> u) -> SimpleTypename -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SimpleTypename -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SimpleTypename -> m SimpleTypename #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SimpleTypename -> m SimpleTypename #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SimpleTypename -> m SimpleTypename #

Data GenericType # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GenericType -> c GenericType #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c GenericType #

toConstr :: GenericType -> Constr #

dataTypeOf :: GenericType -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c GenericType) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GenericType) #

gmapT :: (forall b. Data b => b -> b) -> GenericType -> GenericType #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GenericType -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GenericType -> r #

gmapQ :: (forall d. Data d => d -> u) -> GenericType -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> GenericType -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GenericType -> m GenericType #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GenericType -> m GenericType #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GenericType -> m GenericType #

Data QualOp # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> QualOp -> c QualOp #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c QualOp #

toConstr :: QualOp -> Constr #

dataTypeOf :: QualOp -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c QualOp) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c QualOp) #

gmapT :: (forall b. Data b => b -> b) -> QualOp -> QualOp #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> QualOp -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> QualOp -> r #

gmapQ :: (forall d. Data d => d -> u) -> QualOp -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> QualOp -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> QualOp -> m QualOp #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> QualOp -> m QualOp #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> QualOp -> m QualOp #

Data QualAllOp # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> QualAllOp -> c QualAllOp #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c QualAllOp #

toConstr :: QualAllOp -> Constr #

dataTypeOf :: QualAllOp -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c QualAllOp) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c QualAllOp) #

gmapT :: (forall b. Data b => b -> b) -> QualAllOp -> QualAllOp #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> QualAllOp -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> QualAllOp -> r #

gmapQ :: (forall d. Data d => d -> u) -> QualAllOp -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> QualAllOp -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> QualAllOp -> m QualAllOp #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> QualAllOp -> m QualAllOp #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> QualAllOp -> m QualAllOp #

Data AnyOperator # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnyOperator -> c AnyOperator #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AnyOperator #

toConstr :: AnyOperator -> Constr #

dataTypeOf :: AnyOperator -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AnyOperator) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnyOperator) #

gmapT :: (forall b. Data b => b -> b) -> AnyOperator -> AnyOperator #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnyOperator -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnyOperator -> r #

gmapQ :: (forall d. Data d => d -> u) -> AnyOperator -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> AnyOperator -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnyOperator -> m AnyOperator #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnyOperator -> m AnyOperator #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnyOperator -> m AnyOperator #

Data AllOp # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AllOp -> c AllOp #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AllOp #

toConstr :: AllOp -> Constr #

dataTypeOf :: AllOp -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AllOp) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AllOp) #

gmapT :: (forall b. Data b => b -> b) -> AllOp -> AllOp #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AllOp -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AllOp -> r #

gmapQ :: (forall d. Data d => d -> u) -> AllOp -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> AllOp -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AllOp -> m AllOp #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AllOp -> m AllOp #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AllOp -> m AllOp #

Data MathOp # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MathOp -> c MathOp #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c MathOp #

toConstr :: MathOp -> Constr #

dataTypeOf :: MathOp -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c MathOp) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MathOp) #

gmapT :: (forall b. Data b => b -> b) -> MathOp -> MathOp #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MathOp -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MathOp -> r #

gmapQ :: (forall d. Data d => d -> u) -> MathOp -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> MathOp -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> MathOp -> m MathOp #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MathOp -> m MathOp #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MathOp -> m MathOp #

Data SymbolicExprBinOp # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SymbolicExprBinOp -> c SymbolicExprBinOp #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SymbolicExprBinOp #

toConstr :: SymbolicExprBinOp -> Constr #

dataTypeOf :: SymbolicExprBinOp -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SymbolicExprBinOp) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SymbolicExprBinOp) #

gmapT :: (forall b. Data b => b -> b) -> SymbolicExprBinOp -> SymbolicExprBinOp #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SymbolicExprBinOp -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SymbolicExprBinOp -> r #

gmapQ :: (forall d. Data d => d -> u) -> SymbolicExprBinOp -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SymbolicExprBinOp -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SymbolicExprBinOp -> m SymbolicExprBinOp #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SymbolicExprBinOp -> m SymbolicExprBinOp #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SymbolicExprBinOp -> m SymbolicExprBinOp #

Data VerbalExprBinOp # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VerbalExprBinOp -> c VerbalExprBinOp #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VerbalExprBinOp #

toConstr :: VerbalExprBinOp -> Constr #

dataTypeOf :: VerbalExprBinOp -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c VerbalExprBinOp) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VerbalExprBinOp) #

gmapT :: (forall b. Data b => b -> b) -> VerbalExprBinOp -> VerbalExprBinOp #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VerbalExprBinOp -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VerbalExprBinOp -> r #

gmapQ :: (forall d. Data d => d -> u) -> VerbalExprBinOp -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> VerbalExprBinOp -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> VerbalExprBinOp -> m VerbalExprBinOp #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VerbalExprBinOp -> m VerbalExprBinOp #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VerbalExprBinOp -> m VerbalExprBinOp #

Data AExprReversableOp # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AExprReversableOp -> c AExprReversableOp #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AExprReversableOp #

toConstr :: AExprReversableOp -> Constr #

dataTypeOf :: AExprReversableOp -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AExprReversableOp) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AExprReversableOp) #

gmapT :: (forall b. Data b => b -> b) -> AExprReversableOp -> AExprReversableOp #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AExprReversableOp -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AExprReversableOp -> r #

gmapQ :: (forall d. Data d => d -> u) -> AExprReversableOp -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> AExprReversableOp -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AExprReversableOp -> m AExprReversableOp #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AExprReversableOp -> m AExprReversableOp #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AExprReversableOp -> m AExprReversableOp #

Data BExprIsOp # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> BExprIsOp -> c BExprIsOp #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c BExprIsOp #

toConstr :: BExprIsOp -> Constr #

dataTypeOf :: BExprIsOp -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c BExprIsOp) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BExprIsOp) #

gmapT :: (forall b. Data b => b -> b) -> BExprIsOp -> BExprIsOp #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BExprIsOp -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BExprIsOp -> r #

gmapQ :: (forall d. Data d => d -> u) -> BExprIsOp -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> BExprIsOp -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> BExprIsOp -> m BExprIsOp #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> BExprIsOp -> m BExprIsOp #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> BExprIsOp -> m BExprIsOp #

Data SubqueryOp # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SubqueryOp -> c SubqueryOp #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SubqueryOp #

toConstr :: SubqueryOp -> Constr #

dataTypeOf :: SubqueryOp -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SubqueryOp) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SubqueryOp) #

gmapT :: (forall b. Data b => b -> b) -> SubqueryOp -> SubqueryOp #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SubqueryOp -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SubqueryOp -> r #

gmapQ :: (forall d. Data d => d -> u) -> SubqueryOp -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SubqueryOp -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SubqueryOp -> m SubqueryOp #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SubqueryOp -> m SubqueryOp #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SubqueryOp -> m SubqueryOp #

Data IndexElem # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IndexElem -> c IndexElem #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c IndexElem #

toConstr :: IndexElem -> Constr #

dataTypeOf :: IndexElem -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c IndexElem) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IndexElem) #

gmapT :: (forall b. Data b => b -> b) -> IndexElem -> IndexElem #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IndexElem -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IndexElem -> r #

gmapQ :: (forall d. Data d => d -> u) -> IndexElem -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> IndexElem -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> IndexElem -> m IndexElem #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IndexElem -> m IndexElem #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IndexElem -> m IndexElem #

Data IndexElemDef # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IndexElemDef -> c IndexElemDef #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c IndexElemDef #

toConstr :: IndexElemDef -> Constr #

dataTypeOf :: IndexElemDef -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c IndexElemDef) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IndexElemDef) #

gmapT :: (forall b. Data b => b -> b) -> IndexElemDef -> IndexElemDef #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IndexElemDef -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IndexElemDef -> r #

gmapQ :: (forall d. Data d => d -> u) -> IndexElemDef -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> IndexElemDef -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> IndexElemDef -> m IndexElemDef #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IndexElemDef -> m IndexElemDef #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IndexElemDef -> m IndexElemDef #

Data AscDesc # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AscDesc -> c AscDesc #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AscDesc #

toConstr :: AscDesc -> Constr #

dataTypeOf :: AscDesc -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AscDesc) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AscDesc) #

gmapT :: (forall b. Data b => b -> b) -> AscDesc -> AscDesc #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AscDesc -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AscDesc -> r #

gmapQ :: (forall d. Data d => d -> u) -> AscDesc -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> AscDesc -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AscDesc -> m AscDesc #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AscDesc -> m AscDesc #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AscDesc -> m AscDesc #

Data NullsOrder # 
Instance details

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NullsOrder -> c NullsOrder #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NullsOrder #

toConstr :: NullsOrder -> Constr #

dataTypeOf :: NullsOrder -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NullsOrder) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NullsOrder) #

gmapT :: (forall b. Data b => b -> b) -> NullsOrder -> NullsOrder #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NullsOrder -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NullsOrder -> r #

gmapQ :: (forall d. Data d => d -> u) -> NullsOrder -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> NullsOrder -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> NullsOrder -> m NullsOrder #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NullsOrder -> m NullsOrder #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NullsOrder -> m NullsOrder #