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)

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

Instances

(Data a, Integral a) => Data (Ratio a)

Data a => Data [a]

Data a => Data (Maybe a)

Data Ordering

(Data a, Data b) => Data (Either a b)

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

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 TypeRep

Data TyCon

Data DataType

Typeable a => Data (IO a)

Data Handle

Typeable a => Data (Ptr a)

Typeable a => Data (StablePtr a)

Typeable a => Data (IORef 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

Show DataType

Typeable DataType

Data DataType

data Constr

Representation of constructors

Instances

Show Constr

Eq Constr

data DataRep

Public representation of datatypes

Constructors