fixplate-0.1.5: Uniplate-style generic traversals for optionally annotated fixed-point types.Source codeContentsIndex
Data.Generics.Fixplate
Description

This library provides Uniplate-style generic traversals and other recursion schemes for fixed-point types. There are many advantages of using fixed-point types instead of explicit recursion:

  • we can easily add attributes to the nodes of an existing tree;
  • there is no need for a custom type class, we can build everything on the top of Functor, Foldable and Traversable, for which GHC can derive the instances for us;
  • we can provide interesting recursion schemes
  • some operations can retain the structure of the tree, instead flattening it into a list;
  • it is relatively straightforward to provide generic implementations of the zipper, tries, tree drawing, hashing, etc...

The main disadvantage is that it does not work well for mutually recursive data types, and that pattern matching becomes more tedious (but there are partial solutions for the latter).

Consider as an example the following simple expression language, encoded by a recursive algebraic data type:

 data Expr 
   = Kst Int 
   | Var String 
   | Add Expr Expr
   deriving (Eq,Show)

We can open up the recursion, and obtain a functor instead:

 data Expr1 e 
   = Kst Int 
   | Var String 
   | Add e e 
   deriving (Eq,Show,Functor,Foldable,Traversable)

The fixed-point type Mu Expr1 is isomorphic to Expr. However, we can also add some attributes to the nodes: The type Attr Expr1 a = Mu (Ann Expr1 a) is the type of with the same structure, but with each node having an extra field of type a.

The functions in this library work on types like that: Mu f, where f is a functor, and sometimes explicitely on Attr f a.

The organization of the modules (excluding Util.*) is the following:

This module re-exports the most common functionality present in the library (but not for example the zipper, tries, hashing).

The library itself should be fully Haskell98 compatible; no language extensions are used. Note: to obtain Eq, Ord, Show, Read and other instances for fixed point types like Mu Expr1, consult the documentation of the EqF type class (cf. the related OrdF, ShowF and ReadF classes)

Synopsis
module Data.Generics.Fixplate.Base
module Data.Generics.Fixplate.Traversals
module Data.Generics.Fixplate.Morphisms
module Data.Generics.Fixplate.Attributes
module Data.Generics.Fixplate.Draw
class Functor f where
fmap :: (a -> b) -> f a -> f b
class Foldable t where
fold :: Monoid m => t m -> m
foldMap :: Monoid m => (a -> m) -> t a -> m
foldr :: (a -> b -> b) -> b -> t a -> b
foldl :: (a -> b -> a) -> a -> t b -> a
foldr1 :: (a -> a -> a) -> t a -> a
foldl1 :: (a -> a -> a) -> t a -> a
class (Functor t, Foldable t) => Traversable t where
traverse :: Applicative f => (a -> f b) -> t a -> f (t b)
sequenceA :: Applicative f => t (f a) -> f (t a)
mapM :: Monad m => (a -> m b) -> t a -> m (t b)
sequence :: Monad m => t (m a) -> m (t a)
Documentation
module Data.Generics.Fixplate.Base
module Data.Generics.Fixplate.Traversals
module Data.Generics.Fixplate.Morphisms
module Data.Generics.Fixplate.Attributes
module Data.Generics.Fixplate.Draw
class Functor f whereSource

The Functor class is used for types that can be mapped over. Instances of Functor should satisfy the following laws:

fmap id == id fmap (f . g) == fmap f . fmap g

The instances of Functor for lists, Data.Maybe.Maybe and System.IO.IO defined in the Prelude satisfy these laws.

Methods
fmap :: (a -> b) -> f a -> f bSource
show/hide Instances
class Foldable t whereSource

Data structures that can be folded.

Minimal complete definition: foldMap or foldr.

For example, given a data type

data Tree a = Empty | Leaf a | Node (Tree a) a (Tree a)

a suitable instance would be

instance Foldable Tree foldMap f Empty = mempty foldMap f (Leaf x) = f x foldMap f (Node l k r) = foldMap f l `mappend` f k `mappend` foldMap f r

This is suitable even for abstract types, as the monoid is assumed to satisfy the monoid laws.

Methods
fold :: Monoid m => t m -> mSource
Combine the elements of a structure using a monoid.
foldMap :: Monoid m => (a -> m) -> t a -> mSource
Map each element of the structure to a monoid, and combine the results.
foldr :: (a -> b -> b) -> b -> t a -> bSource

Right-associative fold of a structure.

foldr f z = foldr f z . toList
foldl :: (a -> b -> a) -> a -> t b -> aSource

Left-associative fold of a structure.

foldl f z = foldl f z . toList
foldr1 :: (a -> a -> a) -> t a -> aSource

A variant of foldr that has no base case, and thus may only be applied to non-empty structures.

foldr1 f = foldr1 f . toList
foldl1 :: (a -> a -> a) -> t a -> aSource

A variant of foldl that has no base case, and thus may only be applied to non-empty structures.

foldl1 f = foldl1 f . toList
show/hide Instances
class (Functor t, Foldable t) => Traversable t whereSource

Functors representing data structures that can be traversed from left to right.

Minimal complete definition: traverse or sequenceA.

Instances are similar to Functor, e.g. given a data type

data Tree a = Empty | Leaf a | Node (Tree a) a (Tree a)

a suitable instance would be

instance Traversable Tree traverse f Empty = pure Empty traverse f (Leaf x) = Leaf <$> f x traverse f (Node l k r) = Node <$> traverse f l <*> f k <*> traverse f r

This is suitable even for abstract types, as the laws for <*> imply a form of associativity.

The superclass instances should satisfy the following:

  • In the Functor instance, fmap should be equivalent to traversal with the identity applicative functor (fmapDefault).
  • In the Foldable instance, Data.Foldable.foldMap should be equivalent to traversal with a constant applicative functor (foldMapDefault).
Methods
traverse :: Applicative f => (a -> f b) -> t a -> f (t b)Source
Map each element of a structure to an action, evaluate these actions from left to right, and collect the results.
sequenceA :: Applicative f => t (f a) -> f (t a)Source
Evaluate each action in the structure from left to right, and collect the results.
mapM :: Monad m => (a -> m b) -> t a -> m (t b)Source
Map each element of a structure to a monadic action, evaluate these actions from left to right, and collect the results.
sequence :: Monad m => t (m a) -> m (t a)Source
Evaluate each monadic action in the structure from left to right, and collect the results.
show/hide Instances
Produced by Haddock version 2.6.1