Orphan instances

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #

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 #