
Data.Generics.Twins  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 support for multiparameter traversal, which is also
demonstrated with generic operations like equality.


Synopsis 

gfoldlAccum :: Data d => (forall e r. Data e => a > c (e > r) > e > (a, c r)) > (forall g. a > g > (a, c g)) > a > d > (a, c d)   gmapAccumT :: Data d => (forall e. Data e => a > e > (a, e)) > a > d > (a, d)   gmapAccumM :: (Data d, Monad m) => (forall e. Data e => a > e > (a, m e)) > a > d > (a, m d)   gmapAccumQl :: Data d => (r > r' > r) > r > (forall e. Data e => a > e > (a, r')) > a > d > (a, r)   gmapAccumQr :: Data d => (r' > r > r) > r > (forall e. Data e => a > e > (a, r')) > a > d > (a, r)   gmapAccumQ :: Data d => (forall e. Data e => a > e > (a, q)) > a > d > (a, [q])   gzipWithT :: GenericQ GenericT > GenericQ GenericT   gzipWithM :: Monad m => GenericQ (GenericM m) > GenericQ (GenericM m)   gzipWithQ :: GenericQ (GenericQ r) > GenericQ (GenericQ [r])   geq :: Data a => a > a > Bool   gzip :: GenericQ (GenericM Maybe) > GenericQ (GenericM Maybe) 



Generic folds and maps that also accumulate


gfoldlAccum :: Data d => (forall e r. Data e => a > c (e > r) > e > (a, c r)) > (forall g. a > g > (a, c g)) > a > d > (a, c d) 
gfoldl with accumulation


gmapAccumT :: Data d => (forall e. Data e => a > e > (a, e)) > a > d > (a, d) 
gmapT with accumulation


gmapAccumM :: (Data d, Monad m) => (forall e. Data e => a > e > (a, m e)) > a > d > (a, m d) 
gmapM with accumulation


gmapAccumQl :: Data d => (r > r' > r) > r > (forall e. Data e => a > e > (a, r')) > a > d > (a, r) 
gmapQl with accumulation


gmapAccumQr :: Data d => (r' > r > r) > r > (forall e. Data e => a > e > (a, r')) > a > d > (a, r) 
gmapQr with accumulation


gmapAccumQ :: Data d => (forall e. Data e => a > e > (a, q)) > a > d > (a, [q]) 
gmapQ with accumulation


Mapping combinators for twin traversal


gzipWithT :: GenericQ GenericT > GenericQ GenericT 
Twin map for transformation


gzipWithM :: Monad m => GenericQ (GenericM m) > GenericQ (GenericM m) 
Twin map for monadic transformation


gzipWithQ :: GenericQ (GenericQ r) > GenericQ (GenericQ [r]) 
Twin map for queries


Typical twin traversals


geq :: Data a => a > a > Bool 
Generic equality: an alternative to "deriving Eq"


gzip :: GenericQ (GenericM Maybe) > GenericQ (GenericM Maybe) 
Generic zip controlled by a function with typespecific branches


Produced by Haddock version 2.3.0 