Data.Generics.Uniplate.Typeable

uniplate-1.6.12: Help writing simple, concise and fast generic operations.

Safe Haskell | None
Language | Haskell98

Data.Generics.Uniplate.Typeable

Contents

- The Class
- The Combinators
- Orphan instances

Description

RECOMMENDATION: Use Data.Generics.Uniplate.Data instead - it usually performs faster (sometimes significantly so) and requires no special instance declarations.

This module supplies a method for writing `Uniplate` / `Biplate` instances. One instance declaration is required for each data type you wish to work with. The instances can be generated using Derive: http://community.haskell.org/~ndm/derive/.

To take an example:

    data Expr = Var Int | Neg Expr | Add Expr Expr
                deriving Typeable

    instance (Typeable a, Uniplate a) => PlateAll Expr a where
        plateAll (Var x  ) = plate Var |+ x
        plateAll (Neg x  ) = plate Neg |+ x
        plateAll (Add x y) = plate Add |+ x |+ y

Synopsis

- module Data.Generics.Uniplate.Operations
- module Data.Typeable
- class PlateAll from to where
- plate :: from -> Type from to
- (|+) :: (Typeable item, Typeable to, PlateAll item to) => Type (item -> from) to -> item -> Type from to
- (|-) :: Type (item -> from) to -> item -> Type from to
- plateProject :: (Typeable item, Typeable to, PlateAll item to) => (from -> item) -> (item -> from) -> from -> Type from to

# Documentation

module Data.Generics.Uniplate.Operations

module Data.Typeable

# The Class

class PlateAll from to where #

This class should be defined for each data type of interest.

Minimal complete definition

plateAll

Methods

plateAll :: from -> Type from to #

This method should be defined using `plate` and `|+`, `|-`.

Instances

PlateAll Bool to # |
Methods plateAll :: Bool -> Type Bool to #
PlateAll Char to # |
Methods plateAll :: Char -> Type Char to #
PlateAll Double to # |
Methods plateAll :: Double -> Type Double to #
PlateAll Float to # |
Methods plateAll :: Float -> Type Float to #
PlateAll Int to # |
Methods plateAll :: Int -> Type Int to #
PlateAll Integer to # |
Methods plateAll :: Integer -> Type Integer to #
PlateAll () to # |
Methods plateAll :: () -> Type () to #
(PlateAll from to, Typeable * from, Typeable * to, Uniplate to) => PlateAll [from] to # |
Methods plateAll :: [from] -> Type [from] to #
(PlateAll from to, Typeable * from, Typeable * to, Uniplate to) => PlateAll (Maybe from) to # |
Methods plateAll :: Maybe from -> Type (Maybe from) to #
(Integral a, PlateAll a to, Typeable * a, Typeable * to, Uniplate to) => PlateAll (Ratio a) to # |
Methods plateAll :: Ratio a -> Type (Ratio a) to #
(PlateAll a to, Typeable * a, PlateAll b to, Typeable * b, Typeable * to, Uniplate to) => PlateAll (Either a b) to # |
Methods plateAll :: Either a b -> Type (Either a b) to #
(PlateAll a to, Typeable * a, PlateAll b to, Typeable * b, Typeable * to, Uniplate to) => PlateAll (a, b) to # |
Methods plateAll :: (a, b) -> Type (a, b) to #
(PlateAll a to, Typeable * a, PlateAll b to, Typeable * b, PlateAll c to, Typeable * c, Typeable * to, Uniplate to) => PlateAll (a, b, c) to # |
Methods plateAll :: (a, b, c) -> Type (a, b, c) to #
(PlateAll a to, Typeable * a, PlateAll b to, Typeable * b, PlateAll c to, Typeable * c, PlateAll d to, Typeable * d, Typeable * to, Uniplate to) => PlateAll (a, b, c, d) to # |
Methods plateAll :: (a, b, c, d) -> Type (a, b, c, d) to #
(PlateAll a to, Typeable * a, PlateAll b to, Typeable * b, PlateAll c to, Typeable * c, PlateAll d to, Typeable * d, PlateAll e to, Typeable * e, Typeable * to, Uniplate to) => PlateAll (a, b, c, d, e) to # |
Methods plateAll :: (a, b, c, d, e) -> Type (a, b, c, d, e) to #

# The Combinators

plate :: from -> Type from to #

The main combinator used to start the chain.

(|+) :: (Typeable item, Typeable to, PlateAll item to) => Type (item -> from) to -> item -> Type from to #

The field to the right may contain the target.

(|-) :: Type (item -> from) to -> item -> Type from to #

The field to the right does not contain the target. This can be used as either an optimisation, or more commonly for excluding primitives such as Int.

plateProject :: (Typeable item, Typeable to, PlateAll item to) => (from -> item) -> (item -> from) -> from -> Type from to #

Write an instance in terms of a projection/injection pair. Usually used to define instances for abstract containers such as Map:

    instance (Ord a, Typeable a, PlateAll a c, Typeable b, PlateAll b c,
             Typeable c, PlateAll c c) => PlateAll (Map.Map a b) c where
        plateAll = plateProject Map.toList Map.fromList

# Orphan instances

PlateAll a a => Uniplate a # |
Methods uniplate :: a -> (Str a, Str a -> a) # descend :: (a -> a) -> a -> a # descendM :: Monad m => (a -> m a) -> a -> m a #
(Typeable * a, Typeable * b, Uniplate b, PlateAll a b) => Biplate a b # |
Methods biplate :: a -> (Str b, Str b -> a) # descendBi :: (b -> b) -> a -> a # descendBiM :: Monad m => (b -> m b) -> a -> m a #