| Haskell Hierarchical Libraries (base package) | Contents | Index

Data.Generics.Basics

Portability | non-portable
Stability | experimental
Maintainer | libraries@haskell.org

Contents

Module Data.Typeable re-exported for convenience
The Data class for processing constructor applications
Datatype representations
Observers for datatype representations
Representations of algebraic data types
From strings to constr's and vice versa: all data types
Convenience funtions: algebraic data types
Representation of primitive types
Non-representations for non-presentable types
Convenience functions: take type constructors apart
Generic maps defined in terms of gfoldl
Generic operation(s) defined in terms of gunfold

Description
"Scrap your boilerplate" --- Generic programming in Haskell See http://www.cs.vu.nl/boilerplate/. The present module provides the Data class with its primitives for generic programming.
Synopsis

module Data.Typeable
class Typeable a => Data a where

gfoldl :: (forall a b . Data a => c (a -> b) -> a -> c b) -> (forall g . g -> c g) -> a -> c a
gunfold :: (forall b r . Data b => c (b -> r) -> c r) -> (forall r . r -> c r) -> Constr -> c a
toConstr :: a -> Constr
dataTypeOf :: a -> DataType
dataCast1 :: Typeable1 t => (forall a . Data a => c (t a)) -> Maybe (c a)
dataCast2 :: Typeable2 t => (forall a b . (Data a, Data b) => c (t a b)) -> Maybe (c a)
gmapT :: (forall b . Data b => b -> b) -> a -> a
gmapQl :: (r -> r' -> r) -> r -> (forall a . Data a => a -> r') -> a -> r
gmapQr :: (r' -> r -> r) -> r -> (forall a . Data a => a -> r') -> a -> r
gmapQ :: (forall a . Data a => a -> u) -> a -> [u]
gmapQi :: Int -> (forall a . Data a => a -> u) -> a -> u
gmapM :: Monad m => (forall a . Data a => a -> m a) -> a -> m a
gmapMp :: MonadPlus m => (forall a . Data a => a -> m a) -> a -> m a
gmapMo :: MonadPlus m => (forall a . Data a => a -> m a) -> a -> m a

data DataType
data Constr

data DataRep

= AlgRep [Constr]
| IntRep
| FloatRep
| StringRep
| NoRep

data ConstrRep

= AlgConstr ConIndex
| IntConstr Integer
| FloatConstr Double
| StringConstr String

type ConIndex = Int

data Fixity

= Prefix
| Infix

dataTypeName :: DataType -> String
dataTypeRep :: DataType -> DataRep
constrType :: Constr -> DataType
constrRep :: Constr -> ConstrRep
repConstr :: DataType -> ConstrRep -> Constr
mkDataType :: String -> [Constr] -> DataType
mkConstr :: DataType -> String -> [String] -> Fixity -> Constr
dataTypeConstrs :: DataType -> [Constr]
constrFields :: Constr -> [String]
constrFixity :: Constr -> Fixity
showConstr :: Constr -> String
readConstr :: DataType -> String -> Maybe Constr
isAlgType :: DataType -> Bool
indexConstr :: DataType -> ConIndex -> Constr
constrIndex :: Constr -> ConIndex
maxConstrIndex :: DataType -> ConIndex
mkIntType :: String -> DataType
mkFloatType :: String -> DataType
mkStringType :: String -> DataType
mkIntConstr :: DataType -> Integer -> Constr
mkFloatConstr :: DataType -> Double -> Constr
mkStringConstr :: DataType -> String -> Constr
mkNorepType :: String -> DataType
isNorepType :: DataType -> Bool
tyconUQname :: String -> String
tyconModule :: String -> String
gmapT :: Data a => (forall b . Data b => b -> b) -> a -> a
gmapQ :: Data a => (forall a . Data a => a -> u) -> a -> [u]
gmapQl :: Data a => (r -> r' -> r) -> r -> (forall a . Data a => a -> r') -> a -> r
gmapQr :: Data a => (r' -> r -> r) -> r -> (forall a . Data a => a -> r') -> a -> r
gmapQi :: Data a => Int -> (forall a . Data a => a -> u) -> a -> u
gmapM :: (Data a, Monad m) => (forall a . Data a => a -> m a) -> a -> m a
gmapMp :: (Data a, MonadPlus m) => (forall a . Data a => a -> m a) -> a -> m a
gmapMo :: (Data a, MonadPlus m) => (forall a . Data a => a -> m a) -> a -> m a
fromConstr :: Data a => Constr -> a
fromConstrB :: Data a => (forall a . Data a => a) -> Constr -> a
fromConstrM :: (Monad m, Data a) => (forall a . Data a => m a) -> Constr -> m a

Module Data.Typeable re-exported for convenience
module Data.Typeable
The Data class for processing constructor applications
class Typeable a => Data a where

Methods

gfoldl :: (forall a b . Data a => c (a -> b) -> a -> c b) -> (forall g . g -> c g) -> a -> c a
Left-associative fold operation for constructor applications
gunfold :: (forall b r . Data b => c (b -> r) -> c r) -> (forall r . r -> c r) -> Constr -> c a
Unfolding constructor applications
toConstr :: a -> Constr
Obtaining the constructor from a given datum. For proper terms, this is meant to be the top-level constructor. Primitive datatypes are here viewed as potentially infinite sets of values (i.e., constructors).
dataTypeOf :: a -> DataType
Provide access to list of all constructors
dataCast1 :: Typeable1 t => (forall a . Data a => c (t a)) -> Maybe (c a)
Mediate types and unary type constructors
dataCast2 :: Typeable2 t => (forall a b . (Data a, Data b) => c (t a b)) -> Maybe (c a)
Mediate types and binary type constructors
gmapT :: (forall b . Data b => b -> b) -> a -> a
A generic transformation that maps over the immediate subterms
gmapQl :: (r -> r' -> r) -> r -> (forall a . Data a => a -> r') -> a -> r
A generic query with a left-associative binary operator
gmapQr :: (r' -> r -> r) -> r -> (forall a . Data a => a -> r') -> a -> r
A generic query with a right-associative binary operator
gmapQ :: (forall a . Data a => a -> u) -> a -> [u]
A generic query that processes the immediate subterms and returns a list
gmapQi :: Int -> (forall a . Data a => a -> u) -> a -> u
A generic query that processes one child by index (zero-based)
gmapM :: Monad m => (forall a . Data a => a -> m a) -> a -> m a
A generic monadic transformation that maps over the immediate subterms
gmapMp :: MonadPlus m => (forall a . Data a => a -> m a) -> a -> m a
Transformation of at least one immediate subterm does not fail
gmapMo :: MonadPlus m => (forall a . Data a => a -> m a) -> a -> m a
Transformation of one immediate subterm with success

Instances

Data Bool
Data Char
Data DataType
Data Double
Data Float
Data Handle
Data Int
Data Int16
Data Int32
Data Int64
Data Int8
Data IntSet
Data Integer
Data Ordering
Data ThreadId
Data TyCon
Data TypeRep
Data Word
Data Word16
Data Word32
Data Word64
Data Word8
Data ()
(Data a, Data b) => Data (a, b)
(Data a, Data b, Data c) => Data (a, b, c)
(Data a, Data b, Data c, Data d) => Data (a, b, c, d)
(Data a, Data b, Data c, Data d, Data e) => Data (a, b, c, d, e)
(Data a, Data b, Data c, Data d, Data e, Data f) => Data (a, b, c, d, e, f)
(Data a, Data b, Data c, Data d, Data e, Data f, Data g) => Data (a, b, c, d, e, f, g)
(Data a, Data b) => Data (a -> b)
Typeable a => Data (ForeignPtr a)
Typeable a => Data (IO a)
Typeable a => Data (IORef a)
Data a => Data (IntMap a)
Typeable a => Data (MVar a)
Data a => Data (Maybe a)
Typeable a => Data (Ptr a)
(Data a, Integral a) => Data (Ratio a)
Typeable a => Data (STM a)
(Data a, Ord a) => Data (Set a)
Typeable a => Data (StablePtr a)
Typeable a => Data (TVar a)
Data a => Data [a]
(Typeable a, Data b, Ix a) => Data (Array a b)
(Data a, Data b) => Data (Either a b)
(Data a, Data b, Ord a) => Data (FiniteMap a b)
(Data k, Data a, Ord k) => Data (Map k a)
(Typeable s, Typeable a) => Data (ST s a)

Datatype representations
data DataType

Representation of datatypes. | A package of constructor representations with names of type and module. | The list of constructors could be an array, a balanced tree, or others.
Instances

Data DataType
Show DataType
Typeable DataType

data Constr

Representation of constructors
Instances

Eq Constr
Show Constr

data DataRep

Public representation of datatypes
Constructors

AlgRep [Constr] |
IntRep |
FloatRep |
StringRep |
NoRep |

Instances

Eq DataRep
Show DataRep

data ConstrRep

Public representation of constructors
Constructors

AlgConstr ConIndex |
IntConstr Integer |
FloatConstr Double |
StringConstr String |

Instances

Eq ConstrRep
Show ConstrRep

type ConIndex = Int
Unique index for datatype constructors. | Textual order is respected. Starts at 1.
data Fixity

Fixity of constructors
Constructors

Prefix |
Infix |

Instances

Eq Fixity
Show Fixity

Observers for datatype representations
dataTypeName :: DataType -> String
Gets the type constructor including the module
dataTypeRep :: DataType -> DataRep
Gets the public presentation of datatypes
constrType :: Constr -> DataType
Gets the datatype of a constructor
constrRep :: Constr -> ConstrRep
Gets the public presentation of constructors
repConstr :: DataType -> ConstrRep -> Constr
Look up a constructor by its representation
Representations of algebraic data types
mkDataType :: String -> [Constr] -> DataType
Constructs an algebraic datatype
mkConstr :: DataType -> String -> [String] -> Fixity -> Constr
Constructs a constructor
dataTypeConstrs :: DataType -> [Constr]
Gets the constructors
constrFields :: Constr -> [String]
Gets the field labels of a constructor
constrFixity :: Constr -> Fixity
Gets the fixity of a constructor
From strings to constr's and vice versa: all data types
showConstr :: Constr -> String
Gets the string for a constructor
readConstr :: DataType -> String -> Maybe Constr
Lookup a constructor via a string
Convenience funtions: algebraic data types
isAlgType :: DataType -> Bool
Test for an algebraic type
indexConstr :: DataType -> ConIndex -> Constr
Gets the constructor for an index
constrIndex :: Constr -> ConIndex
Gets the index of a constructor
maxConstrIndex :: DataType -> ConIndex
Gets the maximum constructor index
Representation of primitive types
mkIntType :: String -> DataType
Constructs the Int type
mkFloatType :: String -> DataType
Constructs the Float type
mkStringType :: String -> DataType
Constructs the String type
mkIntConstr :: DataType -> Integer -> Constr
mkFloatConstr :: DataType -> Double -> Constr
mkStringConstr :: DataType -> String -> Constr
Non-representations for non-presentable types
mkNorepType :: String -> DataType
Constructs a non-representation
isNorepType :: DataType -> Bool
Test for a non-representable type
Convenience functions: take type constructors apart
tyconUQname :: String -> String
Gets the unqualified type constructor Drop *.*.*... before name
tyconModule :: String -> String
Gets the module of a type constructor Take *.*.*... before name
Generic maps defined in terms of gfoldl
gmapT :: Data a => (forall b . Data b => b -> b) -> a -> a
A generic transformation that maps over the immediate subterms
gmapQ :: Data a => (forall a . Data a => a -> u) -> a -> [u]
A generic query that processes the immediate subterms and returns a list
gmapQl :: Data a => (r -> r' -> r) -> r -> (forall a . Data a => a -> r') -> a -> r
A generic query with a left-associative binary operator
gmapQr :: Data a => (r' -> r -> r) -> r -> (forall a . Data a => a -> r') -> a -> r
A generic query with a right-associative binary operator
gmapQi :: Data a => Int -> (forall a . Data a => a -> u) -> a -> u
A generic query that processes one child by index (zero-based)
gmapM :: (Data a, Monad m) => (forall a . Data a => a -> m a) -> a -> m a
A generic monadic transformation that maps over the immediate subterms
gmapMp :: (Data a, MonadPlus m) => (forall a . Data a => a -> m a) -> a -> m a
Transformation of at least one immediate subterm does not fail
gmapMo :: (Data a, MonadPlus m) => (forall a . Data a => a -> m a) -> a -> m a
Transformation of one immediate subterm with success
Generic operation(s) defined in terms of gunfold
fromConstr :: Data a => Constr -> a
Build a term skeleton
fromConstrB :: Data a => (forall a . Data a => a) -> Constr -> a
Build a term and use a generic function for subterms
fromConstrM :: (Monad m, Data a) => (forall a . Data a => m a) -> Constr -> m a
Monadic variation on "fromConstrB"
Produced by Haddock version 0.7