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

Data.Generics.Aliases

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

Contents

Combinators to "make" generic functions via cast
Type synonyms for generic function types
Inredients of generic functions
Function combinators on generic functions
Operators for (over-appreciated) unfolding

Description
"Scrap your boilerplate" --- Generic programming in Haskell See http://www.cs.vu.nl/boilerplate/. The present module provides a number of declarations for typical generic function types, corresponding type case, and others.
Synopsis

mkT :: (Typeable a, Typeable b) => (b -> b) -> a -> a
mkQ :: (Typeable a, Typeable b) => r -> (b -> r) -> a -> r
mkM :: (Monad m, Typeable a, Typeable b) => (b -> m b) -> a -> m a
mkMp :: (MonadPlus m, Typeable a, Typeable b) => (b -> m b) -> a -> m a
mkR :: (MonadPlus m, Typeable a, Typeable b) => m b -> m a
extT :: (Typeable a, Typeable b) => (a -> a) -> (b -> b) -> a -> a
extQ :: (Typeable a, Typeable b) => (a -> q) -> (b -> q) -> a -> q
extM :: (Monad m, Typeable a, Typeable b) => (a -> m a) -> (b -> m b) -> a -> m a
extMp :: (MonadPlus m, Typeable a, Typeable b) => (a -> m a) -> (b -> m b) -> a -> m a
extB :: (Typeable a, Typeable b) => a -> b -> a
extR :: (Monad m, Typeable a, Typeable b) => m a -> m b -> m a
type GenericT = forall a . Data a => a -> a
type GenericQ r = forall a . Data a => a -> r
type GenericM m = forall a . Data a => a -> m a
type GenericB = forall a . Data a => a
type GenericR m = forall a . Data a => m a
type Generic c = forall a . Data a => a -> c a

data Generic' c = Generic' {

unGeneric' :: (Generic c)

}

orElse :: Maybe a -> Maybe a -> Maybe a
recoverMp :: MonadPlus m => GenericM m -> GenericM m
recoverQ :: MonadPlus m => r -> GenericQ (m r) -> GenericQ (m r)
choiceMp :: MonadPlus m => GenericM m -> GenericM m -> GenericM m
choiceQ :: MonadPlus m => GenericQ (m r) -> GenericQ (m r) -> GenericQ (m r)
gunfoldB :: Data a => Constr -> (forall a . Data a => a) -> a
gunfoldR :: (Monad m, Data a) => Constr -> (forall a . Data a => m a) -> m a

Combinators to "make" generic functions via cast
mkT :: (Typeable a, Typeable b) => (b -> b) -> a -> a
Make a generic transformation; start from a type-specific case; preserve the term otherwise
mkQ :: (Typeable a, Typeable b) => r -> (b -> r) -> a -> r
Make a generic query; start from a type-specific case; return a constant otherwise
mkM :: (Monad m, Typeable a, Typeable b) => (b -> m b) -> a -> m a
Make a generic monadic transformation; start from a type-specific case; resort to return otherwise
mkMp :: (MonadPlus m, Typeable a, Typeable b) => (b -> m b) -> a -> m a
Make a generic monadic transformation for MonadPlus; use "const mzero" (i.e., failure) instead of return as default.
mkR :: (MonadPlus m, Typeable a, Typeable b) => m b -> m a
Make a generic builder; start from a type-specific ase; resort to no build (i.e., mzero) otherwise
extT :: (Typeable a, Typeable b) => (a -> a) -> (b -> b) -> a -> a
Extend a generic transformation by a type-specific case
extQ :: (Typeable a, Typeable b) => (a -> q) -> (b -> q) -> a -> q
Extend a generic query by a type-specific case
extM :: (Monad m, Typeable a, Typeable b) => (a -> m a) -> (b -> m b) -> a -> m a
Extend a generic monadic transformation by a type-specific case
extMp :: (MonadPlus m, Typeable a, Typeable b) => (a -> m a) -> (b -> m b) -> a -> m a
Extend a generic MonadPlus transformation by a type-specific case
extB :: (Typeable a, Typeable b) => a -> b -> a
Extend a generic builder
extR :: (Monad m, Typeable a, Typeable b) => m a -> m b -> m a
Extend a generic reader
Type synonyms for generic function types
type GenericT = forall a . Data a => a -> a
Generic transformations, i.e., take an "a" and return an "a"
type GenericQ r = forall a . Data a => a -> r
Generic queries of type "r", i.e., take any "a" and return an "r"
type GenericM m = forall a . Data a => a -> m a
Generic monadic transformations, i.e., take an "a" and compute an "a"
type GenericB = forall a . Data a => a
Generic builders i.e., produce an "a".
type GenericR m = forall a . Data a => m a
Generic readers, say monadic builders, i.e., produce an "a" with the help of a monad "m".
type Generic c = forall a . Data a => a -> c a
The general scheme underlying generic functions assumed by gfoldl; there are isomorphisms such as GenericT = Generic ID.
data Generic' c

Wrapped generic functions; recall: [Generic c] would be legal but [Generic' c] not.
Constructors

Generic' |

unGeneric' :: (Generic c) |

Inredients of generic functions
orElse :: Maybe a -> Maybe a -> Maybe a
Left-biased choice on maybies
Function combinators on generic functions
recoverMp :: MonadPlus m => GenericM m -> GenericM m
Recover from the failure of monadic transformation by identity
recoverQ :: MonadPlus m => r -> GenericQ (m r) -> GenericQ (m r)
Recover from the failure of monadic query by a constant
choiceMp :: MonadPlus m => GenericM m -> GenericM m -> GenericM m
Choice for monadic transformations
choiceQ :: MonadPlus m => GenericQ (m r) -> GenericQ (m r) -> GenericQ (m r)
Choice for monadic queries
Operators for (over-appreciated) unfolding
gunfoldB :: Data a => Constr -> (forall a . Data a => a) -> a
Construct an initial term with undefined immediate subterms and then map over the skeleton to fill in proper terms.
gunfoldR :: (Monad m, Data a) => Constr -> (forall a . Data a => m a) -> m a
Monadic variation on "gunfoldB"
Produced by Haddock version 0.6