Data.Generics.Schemes

syb-0.7.2.2: Scrap Your Boilerplate

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

Data.Generics.Schemes

Description

"Scrap your boilerplate" --- Generic programming in Haskell See http://www.cs.uu.nl/wiki/GenericProgramming/SYB. The present module provides frequently used generic traversal schemes.

Synopsis

- everywhere :: (forall a. Data a => a -> a) -> forall a. Data a => a -> a
- everywhere' :: (forall a. Data a => a -> a) -> forall a. Data a => a -> a
- everywhereBut :: GenericQ Bool -> GenericT -> GenericT
- everywhereM :: forall m. Monad m => GenericM m -> GenericM m
- somewhere :: forall m. MonadPlus m => GenericM m -> GenericM m
- everything :: forall r. (r -> r -> r) -> GenericQ r -> GenericQ r
- everythingBut :: forall r. (r -> r -> r) -> GenericQ (r, Bool) -> GenericQ r
- everythingWithContext :: forall s r. s -> (r -> r -> r) -> GenericQ (s -> (r, s)) -> GenericQ r
- listify :: Typeable r => (r -> Bool) -> GenericQ [r]
- something :: GenericQ (Maybe u) -> GenericQ (Maybe u)
- synthesize :: forall s t. s -> (t -> s -> s) -> GenericQ (s -> t) -> GenericQ t
- gsize :: Data a => a -> Int
- glength :: GenericQ Int
- gdepth :: GenericQ Int
- gcount :: GenericQ Bool -> GenericQ Int
- gnodecount :: GenericQ Int
- gtypecount :: Typeable a => a -> GenericQ Int
- gfindtype :: (Data x, Typeable y) => x -> Maybe y

# Documentation

everywhere :: (forall a. Data a => a -> a) -> forall a. Data a => a -> a #

Apply a transformation everywhere in bottom-up manner

everywhere' :: (forall a. Data a => a -> a) -> forall a. Data a => a -> a #

Apply a transformation everywhere in top-down manner

everywhereBut :: GenericQ Bool -> GenericT -> GenericT #

Variation on everywhere with an extra stop condition

everywhereM :: forall m. Monad m => GenericM m -> GenericM m #

Monadic variation on everywhere

somewhere :: forall m. MonadPlus m => GenericM m -> GenericM m #

Apply a monadic transformation at least somewhere

everything :: forall r. (r -> r -> r) -> GenericQ r -> GenericQ r #

Summarise all nodes in top-down, left-to-right order

everythingBut :: forall r. (r -> r -> r) -> GenericQ (r, Bool) -> GenericQ r #

Variation of "everything" with an added stop condition

everythingWithContext :: forall s r. s -> (r -> r -> r) -> GenericQ (s -> (r, s)) -> GenericQ r #

Summarise all nodes in top-down, left-to-right order, carrying some state down the tree during the computation, but not left-to-right to siblings.

listify :: Typeable r => (r -> Bool) -> GenericQ [r] #

Get a list of all entities that meet a predicate

something :: GenericQ (Maybe u) -> GenericQ (Maybe u) #

Look up a subterm by means of a maybe-typed filter

synthesize :: forall s t. s -> (t -> s -> s) -> GenericQ (s -> t) -> GenericQ t #

Bottom-up synthesis of a data structure; 1st argument z is the initial element for the synthesis; 2nd argument o is for reduction of results from subterms; 3rd argument f updates the synthesised data according to the given term

gsize :: Data a => a -> Int #

Compute size of an arbitrary data structure

glength :: GenericQ Int #

Count the number of immediate subterms of the given term

gdepth :: GenericQ Int #

Determine depth of the given term

gcount :: GenericQ Bool -> GenericQ Int #

Determine the number of all suitable nodes in a given term

gnodecount :: GenericQ Int #

Determine the number of all nodes in a given term

gtypecount :: Typeable a => a -> GenericQ Int #

Determine the number of nodes of a given type in a given term

gfindtype :: (Data x, Typeable y) => x -> Maybe y #

Find (unambiguously) an immediate subterm of a given type