Copyright	(c) The University of Glasgow CWI 2001--2004
License	BSD-style (see the LICENSE file)
Maintainer	generics@haskell.org
Stability	experimental
Portability	non-portable (local universal quantification)
Safe Haskell	Safe
Language	Haskell98

Data.Generics.Aliases

Contents

Combinators to "make" generic functions via cast
Type synonyms for generic function types
Ingredients of generic functions
Function combinators on generic functions
Type extension for unary type constructors
Type extension for binary type constructors

Description

"Scrap your boilerplate" --- Generic programming in Haskell See http://www.cs.uu.nl/wiki/GenericProgramming/SYB. 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 :: forall a. Data a => a -> a
}
newtype GenericQ' r = GQ {
- unGQ :: GenericQ r
}
newtype GenericM' m = GM {
- unGM :: forall a. 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)
ext1 :: (Data a, Typeable t) => c a -> (forall d. Data d => c (t d)) -> c a
ext1T :: (Data d, Typeable t) => (forall e. Data e => e -> e) -> (forall f. Data f => t f -> t f) -> d -> d
ext1M :: (Monad m, Data d, Typeable t) => (forall e. Data e => e -> m e) -> (forall f. Data f => t f -> m (t f)) -> d -> m d
ext1Q :: (Data d, Typeable t) => (d -> q) -> (forall e. Data e => t e -> q) -> d -> q
ext1R :: (Monad m, Data d, Typeable t) => m d -> (forall e. Data e => m (t e)) -> m d
ext1B :: (Data a, Typeable t) => a -> (forall b. Data b => t b) -> a
ext2T :: (Data d, Typeable t) => (forall e. Data e => e -> e) -> (forall d1 d2. (Data d1, Data d2) => t d1 d2 -> t d1 d2) -> d -> d
ext2M :: (Monad m, Data d, Typeable t) => (forall e. Data e => e -> m e) -> (forall d1 d2. (Data d1, Data d2) => t d1 d2 -> m (t d1 d2)) -> d -> m d
ext2Q :: (Data d, Typeable t) => (d -> q) -> (forall d1 d2. (Data d1, Data d2) => t d1 d2 -> q) -> d -> q
ext2R :: (Monad m, Data d, Typeable t) => m d -> (forall d1 d2. (Data d1, Data d2) => m (t d1 d2)) -> m d
ext2B :: (Data a, Typeable t) => a -> (forall d1 d2. (Data d1, Data d2) => t d1 d2) -> 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

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'
Fields unGeneric' :: Generic c

newtype GenericT' #

Other first-class polymorphic wrappers

Constructors

GT
Fields unGT :: forall a. Data a => a -> a

newtype GenericQ' r #

Constructors

GQ
Fields unGQ :: GenericQ r

newtype GenericM' m #

Constructors

GM
Fields unGM :: forall a. Data a => a -> m a

Ingredients of generic functions

orElse :: Maybe a -> Maybe a -> Maybe a #

Left-biased choice on maybes

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

ext1 :: (Data a, Typeable t) => c a -> (forall d. Data d => c (t d)) -> c a #

Flexible type extension

ext1T :: (Data d, Typeable t) => (forall e. Data e => e -> e) -> (forall f. Data f => t f -> t f) -> d -> d #

Type extension of transformations for unary type constructors

ext1M :: (Monad m, Data d, Typeable t) => (forall e. Data e => e -> m e) -> (forall f. Data f => t f -> m (t f)) -> d -> m d #

Type extension of monadic transformations for type constructors

ext1Q :: (Data d, Typeable t) => (d -> q) -> (forall e. Data e => t e -> q) -> d -> q #

Type extension of queries for type constructors

ext1R :: (Monad m, Data d, Typeable t) => m d -> (forall e. Data e => m (t e)) -> m d #

Type extension of readers for type constructors

ext1B :: (Data a, Typeable t) => a -> (forall b. Data b => t b) -> a #

Type extension of builders for type constructors

Type extension for binary type constructors

ext2T :: (Data d, Typeable t) => (forall e. Data e => e -> e) -> (forall d1 d2. (Data d1, Data d2) => t d1 d2 -> t d1 d2) -> d -> d #

Type extension of transformations for unary type constructors

ext2M :: (Monad m, Data d, Typeable t) => (forall e. Data e => e -> m e) -> (forall d1 d2. (Data d1, Data d2) => t d1 d2 -> m (t d1 d2)) -> d -> m d #

Type extension of monadic transformations for type constructors

ext2Q :: (Data d, Typeable t) => (d -> q) -> (forall d1 d2. (Data d1, Data d2) => t d1 d2 -> q) -> d -> q #

Type extension of queries for type constructors

ext2R :: (Monad m, Data d, Typeable t) => m d -> (forall d1 d2. (Data d1, Data d2) => m (t d1 d2)) -> m d #

Type extension of readers for type constructors

ext2B :: (Data a, Typeable t) => a -> (forall d1 d2. (Data d1, Data d2) => t d1 d2) -> a #

Type extension of builders for type constructors