Orphan instances

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) -> 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 #

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 #

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) -> 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 #

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 #

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 #

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) -> 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 #

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) -> 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 #

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 #

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) -> CallStmt -> c CallStmt #

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

toConstr :: CallStmt -> Constr #

dataTypeOf :: CallStmt -> DataType #

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

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

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

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

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

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

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

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

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

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

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 #

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 #

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 #

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) -> 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) -> 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 #

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 #

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 #

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) -> 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) -> 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) -> 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) -> 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) -> 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) -> 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) -> 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 #

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 #

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 #

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 #

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) -> 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) -> 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) -> 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 #

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) -> 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 #

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) -> 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 #

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) -> 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) -> 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 #

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 #

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 #

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) -> 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) -> 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) -> 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 #

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) -> 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) -> 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) -> 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) -> 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) -> 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 #

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 #

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 #

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) -> 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) -> 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) -> 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) -> 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) -> 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 #