| Haskell Hierarchical Libraries (base package) | Source code | Contents | Index
Data.Generics.Aliases |
Portability | non-portable (local universal quantification)
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 Type extension for unary type constructors
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
ext0 :: (Typeable a, Typeable b) => c a -> c b -> c 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)
}
newtype GenericT' = GT {
unGT :: (Data a => a -> a)
}
newtype GenericQ' r = GQ {
unGQ :: (GenericQ r)
}
newtype GenericM' m = GM {
unGM :: (Data a => a -> m a)
}
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)
ext1T :: (Data d, Typeable1 t) => (forall d . Data d => d -> d) -> (forall d . Data d => t d -> t d) -> d -> d
ext1M :: (Monad m, Data d, Typeable1 t) => (forall d . Data d => d -> m d) -> (forall d . Data d => t d -> m (t d)) -> d -> m d
ext1Q :: (Data d, Typeable1 t) => (d -> q) -> (forall d . Data d => t d -> q) -> d -> q
ext1R :: (Monad m, Data d, Typeable1 t) => m d -> (forall d . Data d => m (t d)) -> m d
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
ext0 :: (Typeable a, Typeable b) => c a -> c b -> c a
Flexible type extension
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 T.
data Generic' c
Wrapped generic functions; recall: [Generic c] would be legal but [Generic' c] not.
Constructors
Generic' |
unGeneric' :: (Generic c) |
newtype GenericT'
Other first-class polymorphic wrappers
Constructors
GT |
unGT :: (Data a => a -> a) |
newtype GenericQ' r
Constructors
GQ |
unGQ :: (GenericQ r) |
newtype GenericM' m
Constructors
GM |
unGM :: (Data a => a -> m a) |
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
Type extension for unary type constructors
ext1T :: (Data d, Typeable1 t) => (forall d . Data d => d -> d) -> (forall d . Data d => t d -> t d) -> d -> d
Type extension of transformations for unary type constructors
ext1M :: (Monad m, Data d, Typeable1 t) => (forall d . Data d => d -> m d) -> (forall d . Data d => t d -> m (t d)) -> d -> m d
Type extension of monadic transformations for type constructors
ext1Q :: (Data d, Typeable1 t) => (d -> q) -> (forall d . Data d => t d -> q) -> d -> q
Type extension of queries for type constructors
ext1R :: (Monad m, Data d, Typeable1 t) => m d -> (forall d . Data d => m (t d)) -> m d
Type extension of readers for type constructors
Produced by Haddock version 0.8