|
Data.Generics.Aliases | Portability | non-portable | Stability | experimental | Maintainer | libraries@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 | | 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' {} | | 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 | |
|
|
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 |