syb-0.7.2.2: Scrap Your Boilerplate
Copyright(c) The University of Glasgow CWI 2001--2004
LicenseBSD-style (see the LICENSE file)
Maintainergenerics@haskell.org
Stabilityexperimental
Portabilitynon-portable (local universal quantification)
Safe HaskellSafe-Inferred
LanguageHaskell98

Data.Generics.Twins

Description

"Scrap your boilerplate" --- Generic programming in Haskell See http://www.cs.uu.nl/wiki/GenericProgramming/SYB. The present module provides support for multi-parameter traversal, which is also demonstrated with generic operations like equality.

Synopsis

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) Source #

gfoldl with accumulation

gmapAccumT :: Data d => (forall e. Data e => a -> e -> (a, e)) -> a -> d -> (a, d) Source #

gmapT with accumulation

gmapAccumM :: (Data d, Monad m) => (forall e. Data e => a -> e -> (a, m e)) -> a -> d -> (a, m d) Source #

gmapM with accumulation

gmapAccumQl :: Data d => (r -> r' -> r) -> r -> (forall e. Data e => a -> e -> (a, r')) -> a -> d -> (a, r) Source #

gmapQl with accumulation

gmapAccumQr :: Data d => (r' -> r -> r) -> r -> (forall e. Data e => a -> e -> (a, r')) -> a -> d -> (a, r) Source #

gmapQr with accumulation

gmapAccumQ :: Data d => (forall e. Data e => a -> e -> (a, q)) -> a -> d -> (a, [q]) Source #

gmapQ with accumulation

gmapAccumA :: forall b d a. (Data d, Applicative a) => (forall e. Data e => b -> e -> (b, a e)) -> b -> d -> (b, a d) Source #

Applicative version

Mapping combinators for twin traversal

gzipWithT :: GenericQ GenericT -> GenericQ GenericT Source #

Twin map for transformation

gzipWithM :: Monad m => GenericQ (GenericM m) -> GenericQ (GenericM m) Source #

Twin map for monadic transformation

gzipWithQ :: GenericQ (GenericQ r) -> GenericQ (GenericQ [r]) Source #

Twin map for queries

Typical twin traversals

geq :: Data a => a -> a -> Bool Source #

Generic equality: an alternative to "deriving Eq"

gzip :: GenericQ (GenericM Maybe) -> GenericQ (GenericM Maybe) Source #

Generic zip controlled by a function with type-specific branches

gcompare :: Data a => a -> a -> Ordering Source #

Generic comparison: an alternative to "deriving Ord"