syb-0.7: Scrap Your Boilerplate

Copyright(c) The University of Glasgow CWI 2001--2004
LicenseBSD-style (see the LICENSE file)
Maintainergenerics@haskell.org
Stabilityexperimental
Portabilitynon-portable (uses Data.Data)
Safe HaskellNone
LanguageHaskell98

Data.Generics.Instances

Contents

Description

"Scrap your boilerplate" --- Generic programming in Haskell See http://www.cs.uu.nl/wiki/GenericProgramming/SYB. The present module contains thirteen Data instances which are considered dubious (either because the types are abstract or just not meant to be traversed). Instances in this module might change or disappear in future releases of this package.

(This module does not export anything. It really just defines instances.)

Orphan instances

Data TypeRep Source # 

Methods

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

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

toConstr :: TypeRep -> Constr #

dataTypeOf :: TypeRep -> DataType #

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

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

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

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

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

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

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

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

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

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

Data TyCon Source # 

Methods

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

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

toConstr :: TyCon -> Constr #

dataTypeOf :: TyCon -> DataType #

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

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

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

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

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

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

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

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

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

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

Data DataType Source # 

Methods

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

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

toConstr :: DataType -> Constr #

dataTypeOf :: DataType -> DataType #

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

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

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

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

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

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

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

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

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

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

Data ThreadId Source # 

Methods

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

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

toConstr :: ThreadId -> Constr #

dataTypeOf :: ThreadId -> DataType #

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

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

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

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

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

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

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

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

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

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

Data Handle Source # 

Methods

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

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

toConstr :: Handle -> Constr #

dataTypeOf :: Handle -> DataType #

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

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

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

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

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

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

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

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

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

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

Typeable * a => Data (StablePtr a) Source # 

Methods

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

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

toConstr :: StablePtr a -> Constr #

dataTypeOf :: StablePtr a -> DataType #

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

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

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

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

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

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

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

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

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

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

Typeable * a => Data (IO a) Source # 

Methods

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

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

toConstr :: IO a -> Constr #

dataTypeOf :: IO a -> DataType #

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

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

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

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

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

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

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

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

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

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

Typeable * a => Data (STM a) Source # 

Methods

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

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

toConstr :: STM a -> Constr #

dataTypeOf :: STM a -> DataType #

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

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

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

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

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

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

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

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

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

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

Typeable * a => Data (TVar a) Source # 

Methods

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

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

toConstr :: TVar a -> Constr #

dataTypeOf :: TVar a -> DataType #

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

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

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

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

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

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

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

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

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

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

Typeable * a => Data (IORef a) Source # 

Methods

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

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

toConstr :: IORef a -> Constr #

dataTypeOf :: IORef a -> DataType #

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

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

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

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

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

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

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

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

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

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

Typeable * a => Data (MVar a) Source # 

Methods

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

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

toConstr :: MVar a -> Constr #

dataTypeOf :: MVar a -> DataType #

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

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

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

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

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

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

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

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

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

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

(Data a, Data b) => Data (a -> b) Source # 

Methods

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

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

toConstr :: (a -> b) -> Constr #

dataTypeOf :: (a -> b) -> DataType #

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

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

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

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

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

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

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

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

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

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

(Typeable * s, Typeable * a) => Data (ST s a) Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ST s a -> c (ST s a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ST s a) #

toConstr :: ST s a -> Constr #

dataTypeOf :: ST s a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (ST s a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ST s a)) #

gmapT :: (forall b. Data b => b -> b) -> ST s a -> ST s a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ST s a -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ST s a -> r #

gmapQ :: (forall d. Data d => d -> u) -> ST s a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ST s a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ST s a -> m (ST s a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ST s a -> m (ST s a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ST s a -> m (ST s a) #