Portability  nonportable 

Stability  experimental 
Maintainer  sweirich@cis.upenn.edu 
Safe Haskell  SafeInfered 
 mkT :: (Rep a, Rep b) => (b > b) > a > a
 mkQ :: (Rep a, Rep b) => r > (b > r) > a > r
 mkM :: (Monad m, Rep a, Rep b) => (b > m b) > a > m a
 mkMp :: (MonadPlus m, Rep a, Rep b) => (b > m b) > a > m a
 mkR :: (MonadPlus m, Rep a, Rep b) => m b > m a
 ext0 :: (Rep a, Rep b) => c a > c b > c a
 extT :: (Rep a, Rep b) => (a > a) > (b > b) > a > a
 extQ :: (Rep a, Rep b) => (a > q) > (b > q) > a > q
 extM :: (Monad m, Rep a, Rep b) => (a > m a) > (b > m b) > a > m a
 extMp :: (MonadPlus m, Rep a, Rep b) => (a > m a) > (b > m b) > a > m a
 extB :: (Rep a, Rep b) => a > b > a
 extR :: (Monad m, Rep a, Rep b) => m a > m b > m a
 type GenericT = forall a. Rep a => a > a
 type GenericQ r = forall a. Rep a => a > r
 type GenericM m = forall a. Rep a => a > m a
 type GenericB = forall a. Rep a => a
 type GenericR m = forall a. Rep a => m a
 type Generic c = forall a. Rep a => a > c a
 data Generic' c = Generic' {
 unGeneric' :: Generic c
 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)
Combinators to "make" generic functions via cast
mkT :: (Rep a, Rep b) => (b > b) > a > aSource
Make a generic transformation; start from a typespecific case; preserve the term otherwise
mkQ :: (Rep a, Rep b) => r > (b > r) > a > rSource
Make a generic query; start from a typespecific case; return a constant otherwise
mkM :: (Monad m, Rep a, Rep b) => (b > m b) > a > m aSource
Make a generic monadic transformation; start from a typespecific case; resort to return otherwise
mkMp :: (MonadPlus m, Rep a, Rep b) => (b > m b) > a > m aSource
Make a generic monadic transformation for MonadPlus; use "const mzero" (i.e., failure) instead of return as default.
mkR :: (MonadPlus m, Rep a, Rep b) => m b > m aSource
Make a generic builder; start from a typespecific ase; resort to no build (i.e., mzero) otherwise
extT :: (Rep a, Rep b) => (a > a) > (b > b) > a > aSource
Extend a generic transformation by a typespecific case
extQ :: (Rep a, Rep b) => (a > q) > (b > q) > a > qSource
Extend a generic query by a typespecific case
extM :: (Monad m, Rep a, Rep b) => (a > m a) > (b > m b) > a > m aSource
Extend a generic monadic transformation by a typespecific case
extMp :: (MonadPlus m, Rep a, Rep b) => (a > m a) > (b > m b) > a > m aSource
Extend a generic MonadPlus transformation by a typespecific case
Type synonyms for generic function types
type GenericT = forall a. Rep a => a > aSource
Generic transformations, i.e., take an "a" and return an "a"
type GenericQ r = forall a. Rep a => a > rSource
Generic queries of type "r", i.e., take any "a" and return an "r"
type GenericM m = forall a. Rep a => a > m aSource
Generic monadic transformations, i.e., take an "a" and compute an "a"
type GenericR m = forall a. Rep a => m aSource
Generic readers, say monadic builders, i.e., produce an "a" with the help of a monad "m".
type Generic c = forall a. Rep a => a > c aSource
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.
Generic'  

Inredients of generic functions
Function combinators on generic functions
recoverMp :: MonadPlus m => GenericM m > GenericM mSource
Recover from the failure of monadic transformation by identity
recoverQ :: MonadPlus m => r > GenericQ (m r) > GenericQ (m r)Source
Recover from the failure of monadic query by a constant
choiceMp :: MonadPlus m => GenericM m > GenericM m > GenericM mSource
Choice for monadic transformations
choiceQ :: MonadPlus m => GenericQ (m r) > GenericQ (m r) > GenericQ (m r)Source
Choice for monadic queries