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

Data.Generics.Reify

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

Contents

Types as values
Generic operations to reify terms
Generic operations to reify types

Description
"Scrap your boilerplate" --- Generic programming in Haskell See http://www.cs.vu.nl/boilerplate/. The present module provides some preliminary support some sort of structural reflection. This module is presumably less common sense that most other boilerplate modules. Also, it is a bit less easy-going.
Synopsis

type TypeVal a = a -> ()
typeVal :: TypeVal a
sameType :: (Typeable a, Typeable b) => TypeVal a -> TypeVal b -> Bool
val2type :: a -> TypeVal a
type2val :: TypeVal a -> a
withType :: a -> TypeVal a -> a
argType :: (a -> b) -> TypeVal a
resType :: (a -> b) -> TypeVal b
paraType :: t a -> TypeVal a
type TypeFun a r = TypeVal a -> r
type GTypeFun r = forall a . Data a => TypeFun a r
extType :: (Data a, Typeable r) => GTypeFun r -> TypeFun a r -> GTypeFun r
glength :: GenericQ Int
gcount :: GenericQ Bool -> GenericQ Int
gnodecount :: GenericQ Int
gtypecount :: Typeable a => (a -> ()) -> GenericQ Int
gfindtype :: (Data x, Data y) => x -> Maybe y
gmapType :: ([(Constr, r')] -> r) -> GTypeFun (Constr -> r') -> GTypeFun r
gmapConstr :: ([r] -> r') -> GTypeFun r -> GTypeFun (Constr -> r')
constrArity :: GTypeFun (Constr -> Int)
gmapSubtermTypes :: (Data a, Typeable r) => (r -> r -> r) -> r -> GTypeFun r -> TypeVal a -> r
gmapSubtermTypesConst :: (Data a, Typeable r) => (r -> r -> r) -> r -> GTypeFun r -> TypeVal a -> r
gcountSubtermTypes :: Data a => TypeVal a -> Int
reachableType :: (Data a, Data b) => TypeVal a -> TypeVal b -> Bool
depthOfType :: GTypeFun Bool -> GTypeFun (Maybe (Constr, Maybe Int))
depthOfConstr :: GTypeFun Bool -> GTypeFun (Constr -> Maybe Int)

Types as values
type TypeVal a = a -> ()
Type as values to stipulate use of undefineds
typeVal :: TypeVal a
The value that denotes a type
sameType :: (Typeable a, Typeable b) => TypeVal a -> TypeVal b -> Bool
Test for type equivalence
val2type :: a -> TypeVal a
Map a value to its type
type2val :: TypeVal a -> a
Stipulate this idiom!
withType :: a -> TypeVal a -> a
Constrain a type
argType :: (a -> b) -> TypeVal a
The argument type of a function
resType :: (a -> b) -> TypeVal b
The result type of a function
paraType :: t a -> TypeVal a
The parameter type of type constructor
type TypeFun a r = TypeVal a -> r
type GTypeFun r = forall a . Data a => TypeFun a r
extType :: (Data a, Typeable r) => GTypeFun r -> TypeFun a r -> GTypeFun r
Extend a type function
Generic operations to reify terms
glength :: GenericQ Int
Count the number of immediate subterms of the given term
gcount :: GenericQ Bool -> GenericQ Int
Determine the number of all suitable nodes in a given term
gnodecount :: GenericQ Int
Determine the number of all nodes in a given term
gtypecount :: Typeable a => (a -> ()) -> GenericQ Int
Determine the number of nodes of a given type in a given term
gfindtype :: (Data x, Data y) => x -> Maybe y
Find (unambiguously) an immediate subterm of a given type
Generic operations to reify types
gmapType :: ([(Constr, r')] -> r) -> GTypeFun (Constr -> r') -> GTypeFun r
Query all constructors of a given type
gmapConstr :: ([r] -> r') -> GTypeFun r -> GTypeFun (Constr -> r')
Query all subterm types of a given constructor
constrArity :: GTypeFun (Constr -> Int)
Compute arity of a given constructor
gmapSubtermTypes :: (Data a, Typeable r) => (r -> r -> r) -> r -> GTypeFun r -> TypeVal a -> r
Query all immediate subterm types of a given type
gmapSubtermTypesConst :: (Data a, Typeable r) => (r -> r -> r) -> r -> GTypeFun r -> TypeVal a -> r
Query all immediate subterm types. There is an extra argument to constant out the type at hand. This can be used to avoid cycles.
gcountSubtermTypes :: Data a => TypeVal a -> Int
reachableType :: (Data a, Data b) => TypeVal a -> TypeVal b -> Bool
Reachability relation on types, i.e., test if nodes of type a are reachable from nodes of type b. The relation is defined to be reflexive.
depthOfType :: GTypeFun Bool -> GTypeFun (Maybe (Constr, Maybe Int))
Depth of a datatype as the constructor with the minimum depth. The outermost Nothing denotes a type without constructors. The innermost Nothing denotes potentially infinite.
depthOfConstr :: GTypeFun Bool -> GTypeFun (Constr -> Maybe Int)
Depth of a constructor. Depth is viewed as the maximum depth of all subterm types + 1. Nothing denotes potentially infinite.
Produced by Haddock version 0.6