| base-3.0.2.0: Basic libraries | 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 | Source
Make a generic transformation; start from a type-specific case; preserve the term otherwise
mkQ :: (Typeable a, Typeable b) => r -> (b -> r) -> a -> r | Source
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 | Source
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 | Source
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 | Source
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 | Source
Flexible type extension
extT :: (Typeable a, Typeable b) => (a -> a) -> (b -> b) -> a -> a | Source
Extend a generic transformation by a type-specific case
extQ :: (Typeable a, Typeable b) => (a -> q) -> (b -> q) -> a -> q | Source
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 | Source
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 | Source
Extend a generic MonadPlus transformation by a type-specific case
extB :: (Typeable a, Typeable b) => a -> b -> a | Source
Extend a generic builder
extR :: (Monad m, Typeable a, Typeable b) => m a -> m b -> m a | Source
Extend a generic reader
Type synonyms for generic function types
type GenericT = forall a . Data a => a -> a | Source
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"
type GenericB = forall a . Data a => a | Source
Generic builders i.e., produce an "a".
type GenericR m = forall a . Data a => m a | Source
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.
data Generic' c | Source
Wrapped generic functions; recall: [Generic c] would be legal but [Generic' c] not.
Constructors
Generic' |
unGeneric' :: (Generic c) |
newtype GenericT' | Source
Other first-class polymorphic wrappers
Constructors
GT |
unGT :: (Data a => a -> a) |
newtype GenericQ' r | Source
Constructors
GQ |
unGQ :: (GenericQ r) |
newtype GenericM' m | Source
Constructors
GM |
unGM :: (Data a => a -> m a) |
Inredients of generic functions
orElse :: Maybe a -> Maybe a -> Maybe a | Source
Left-biased choice on maybies
Function combinators on generic functions
recoverMp :: MonadPlus m => GenericM m -> GenericM m | Source
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 m | Source
Choice for monadic transformations
choiceQ :: MonadPlus m => GenericQ (m r) -> GenericQ (m r) -> GenericQ (m r) | Source
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 | Source
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 | Source
Type extension of monadic transformations for type constructors
ext1Q :: (Data d, Typeable1 t) => (d -> q) -> (forall d . Data d => t d -> q) -> d -> q | Source
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 | Source
Type extension of readers for type constructors
Produced by Haddock version 0.9