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