
Data.Generics.Aliases  Portability  nonportable (local universal quantification)  Stability  experimental  Maintainer  generics@haskell.org 





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' {}   newtype GenericT' = GT {}   newtype GenericQ' r = GQ {}   newtype GenericM' m = GM {}   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 e. Data e => e > e) > (forall f. Data f => t f > t f) > d > d   ext1M :: (Monad m, Data d, Typeable1 t) => (forall e. Data e => e > m e) > (forall f. Data f => t f > m (t f)) > d > m d   ext1Q :: (Data d, Typeable1 t) => (d > q) > (forall e. Data e => t e > q) > d > q   ext1R :: (Monad m, Data d, Typeable1 t) => m d > (forall e. Data e => m (t e)) > m d 



Combinators to "make" generic functions via cast



Make a generic transformation;
start from a typespecific case;
preserve the term otherwise



Make a generic query;
start from a typespecific case;
return a constant otherwise



Make a generic monadic transformation;
start from a typespecific case;
resort to return otherwise



Make a generic monadic transformation for MonadPlus;
use "const mzero" (i.e., failure) instead of return as default.



Make a generic builder;
start from a typespecific ase;
resort to no build (i.e., mzero) otherwise



Flexible type extension



Extend a generic transformation by a typespecific case



Extend a generic query by a typespecific case



Extend a generic monadic transformation by a typespecific case



Extend a generic MonadPlus transformation by a typespecific case



Extend a generic builder



Extend a generic reader


Type synonyms for generic function types



Generic transformations,
i.e., take an "a" and return an "a"


type GenericQ r = forall a. Data a => a > r  Source 

Generic queries of type "r",
i.e., take any "a" and return an "r"


type GenericM m = forall a. Data a => a > m a  Source 

Generic monadic transformations,
i.e., take an "a" and compute an "a"



Generic builders
i.e., produce an "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  Source 

The general scheme underlying generic functions
assumed by gfoldl; there are isomorphisms such as
GenericT = Generic T.



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



Other firstclass polymorphic wrappers
 Constructors  






Constructors  GM   unGM :: Data a => a > m a  




Inredients of generic functions



Leftbiased choice on maybies


Function combinators on generic functions



Recover from the failure of monadic transformation by identity



Recover from the failure of monadic query by a constant



Choice for monadic transformations



Choice for monadic queries


Type extension for unary type constructors



Type extension of transformations for unary type constructors



Type extension of monadic transformations for type constructors



Type extension of queries for type constructors



Type extension of readers for type constructors


Produced by Haddock version 2.6.1 