diff --git a/Data/Generics/Fixplate.hs b/Data/Generics/Fixplate.hs
--- a/Data/Generics/Fixplate.hs
+++ b/Data/Generics/Fixplate.hs
@@ -48,6 +48,8 @@
 --
 -- * "Data.Generics.Fixplate.Base" - core types and type classes
 --
+-- * "Data.Generics.Fixplate.Functor" - sum and product functors
+--
 -- * "Data.Generics.Fixplate.Traversals" - Uniplate-style traversals
 --
 -- * "Data.Generics.Fixplate.Morphisms" - recursion schemes
@@ -60,6 +62,8 @@
 --
 -- * "Data.Generics.Fixplate.Draw" - generic tree drawing (both ASCII and graphviz)
 -- 
+-- * "Data.Generics.Fixplate.Pretty" - pretty-printing of expression trees
+--
 -- * "Data.Generics.Fixplate.Trie" - generic generalized tries
 --
 -- * "Data.Generics.Fixplate.Hash" - annotating trees with their hashes
@@ -67,8 +71,10 @@
 -- 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.
+-- The only exception is the "Data.Generics.Fixplate.Functor" module, which uses the TypeOperators
+-- language extension for syntactic convenience (but this is not used anywhere else).
+--
 -- 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)
diff --git a/Data/Generics/Fixplate/Attributes.hs b/Data/Generics/Fixplate/Attributes.hs
--- a/Data/Generics/Fixplate/Attributes.hs
+++ b/Data/Generics/Fixplate/Attributes.hs
@@ -1,5 +1,8 @@
 
 -- | Synthetising attributes, partly motivated by Attribute Grammars, and partly by recursion schemes.
+--
+-- TODO: better organization \/ interface to all these functions...
+--
 
 {-# LANGUAGE CPP #-}
 module Data.Generics.Fixplate.Attributes
@@ -448,7 +451,7 @@
   h tree@(Fix (TreeF label ts)) ys = unLabel label++"_"++show siz++"(" ++ intercalate "," (zipWith c (toList ys) sizs) ++ ")" where
     siz = cata f tree
     sizs = map (cata f) ts
-    f t = 1 + Data.Foldable.sum t
+    f t = (1::Int) + Data.Foldable.sum t
     c str j = str ++ "<" ++ show j ++ ">"
 
 prop_synthPara :: FixT Label -> Bool
@@ -456,7 +459,7 @@
   g :: TreeF Label (FixT Label , String) -> String
   g (TreeF (Label label) xs) = label++"(" ++ intercalate "," (map u xs) ++ ")" where
     u (tree,a) = show siz ++ "_" ++ a where
-      siz = cata (\t -> 1 + Data.Foldable.sum t) tree
+      siz = cata (\t -> (1::Int) + Data.Foldable.sum t) tree
 
 scanCataNaive :: Functor f => (a -> f b -> b) -> Attr f a -> Attr f b
 scanCataNaive f = annZipWith (flip const) . synthCata (\(Ann a x) -> f a x)
diff --git a/Data/Generics/Fixplate/Base.hs b/Data/Generics/Fixplate/Base.hs
--- a/Data/Generics/Fixplate/Base.hs
+++ b/Data/Generics/Fixplate/Base.hs
@@ -7,10 +7,10 @@
 --------------------------------------------------------------------------------
 
 import Control.Applicative
-import Control.Monad (liftM)
+import Control.Monad ( liftM , ap)
 import Data.Foldable
 import Data.Traversable
-import Prelude hiding (foldl,foldr,mapM,mapM_,concat,concatMap)
+import Prelude hiding ( foldl , foldr , mapM , mapM_ , concat , concatMap)
 
 import Text.Show
 import Text.Read
@@ -309,9 +309,14 @@
     go (Fix (CoAnn t)) = Fix <$> (CoAnn <$> traverse go t)
     go (Fix (Pure  x)) = Fix <$> (Pure  <$> h x)
 
+instance Functor f => Applicative (CoAttrib f) where
+  pure x = CoAttrib (Fix (Pure x))
+  (<*>)  = ap
+
 instance Functor f => Monad (CoAttrib f) where
   return x = CoAttrib (Fix (Pure x))
   CoAttrib (Fix (CoAnn t))  >>=  u  =  CoAttrib (Fix (CoAnn (fmap (unCoAttrib . (>>=u) . CoAttrib) t)))
   CoAttrib (Fix (Pure  x))  >>=  u  =  u x
+
 
 --------------------------------------------------------------------------------
diff --git a/Data/Generics/Fixplate/Functor.hs b/Data/Generics/Fixplate/Functor.hs
new file mode 100644
--- /dev/null
+++ b/Data/Generics/Fixplate/Functor.hs
@@ -0,0 +1,117 @@
+
+-- | Sum and product functors, with the usual instances. 
+-- You can in principle use these to extend existing expressions, for example
+--
+-- > type ExtendedExpression = Mu (Expr :+: Custom)
+--
+-- This module uses the TypeOperators language extension for convenience.
+--
+
+{-# LANGUAGE TypeOperators #-}
+module Data.Generics.Fixplate.Functor 
+  ( (:+:) (..) 
+  , (:*:) (..)
+  )
+  where
+
+--------------------------------------------------------------------------------
+
+import Prelude hiding ( foldl , foldr , mapM )
+import Control.Applicative ( (<$>) , (<*>) )
+import Control.Monad ( liftM )
+
+import Data.Generics.Fixplate
+
+--------------------------------------------------------------------------------
+
+-- | Sum of two functors
+data (f :+: g) a = InL (f a) | InR (g a) deriving (Eq,Ord,Show)
+
+-- | Product of two functors
+data (f :*: g) a = (f a) :*: (g a)       deriving (Eq,Ord,Show)
+
+infixl 6 :+:
+infixl 7 :*:
+
+--------------------------------------------------------------------------------
+
+instance (Functor f, Functor g) => Functor (f :+: g) where
+  fmap h (InL x) = InL (fmap h x)
+  fmap h (InR y) = InR (fmap h y)
+
+instance (Foldable f, Foldable g) => Foldable (f :+: g) where
+  foldl h a (InL x) = foldl h a x
+  foldl h a (InR y) = foldl h a y
+
+  foldr h a (InL x) = foldr h a x 
+  foldr h a (InR y) = foldr h a y 
+
+instance (Traversable f, Traversable g) => Traversable (f :+: g) where
+  traverse h (InL x) = InL <$> traverse h x
+  traverse h (InR y) = InR <$> traverse h y
+
+  mapM h (InL x) = liftM InL $ mapM h x
+  mapM h (InR y) = liftM InR $ mapM h y
+
+--------------------------------------------------------------------------------
+
+instance (Functor f, Functor g) => Functor (f :*: g) where
+  fmap h (x :*: y) = fmap h x :*: fmap h y
+
+instance (Foldable f, Foldable g) => Foldable (f :*: g) where
+  foldl h a (x :*: y) = let a' = foldl h a x in foldl h a' y
+  foldr h a (x :*: y) = let a' = foldr h a y in foldr h a' x
+
+instance (Traversable f, Traversable g) => Traversable (f :*: g) where
+  traverse h (x :*: y) = (:*:) <$> traverse h x <*> traverse h y
+  mapM h (x :*: y) = do 
+    x1 <- mapM h x
+    y1 <- mapM h y
+    return (x1 :*: y1)
+
+--------------------------------------------------------------------------------
+
+app_prec , mul_prec :: Int
+app_prec = 10 
+mul_prec = 7 
+
+--------------------------------------------------------------------------------
+
+instance (EqF f, EqF g) => EqF (f :+: g) where 
+  equalF (InL x) (InL y) = equalF x y
+  equalF (InR x) (InR y) = equalF x y
+  equalF _       _       = False
+
+instance (OrdF f, OrdF g) => OrdF (f :+: g) where
+  compareF (InL x) (InL y) = compareF x y
+  compareF (InR x) (InR y) = compareF x y
+  compareF (InL _) (InR _) = LT
+  compareF (InR _) (InL _) = GT
+
+instance (ShowF f, ShowF g) => ShowF (f :+: g) where 
+  showsPrecF d (InL x) = showParen (d>app_prec) 
+    $ showString "InL " 
+    . showsPrecF (app_prec+1) x
+  showsPrecF d (InR x) = showParen (d>app_prec) 
+    $ showString "InR " 
+    . showsPrecF (app_prec+1) x
+
+--------------------------------------------------------------------------------
+
+instance (EqF f, EqF g) => EqF (f :*: g) where 
+  equalF (x1 :*: x2) (y1 :*: y2) = equalF x1 y1 && equalF x2 y2
+
+instance (OrdF f, OrdF g) => OrdF (f :*: g) where
+  compareF (x1 :*: x2) (y1 :*: y2) = case compareF x1 y1 of 
+    LT -> LT
+    GT -> GT
+    EQ -> compareF  x2 y2 
+
+instance (ShowF f, ShowF g) => ShowF (f :*: g) where 
+  showsPrecF d (x :*: y) = showParen (d>mul_prec) 
+    $ showsPrecF (mul_prec+1) x
+    . showString " :*: " 
+    . showsPrecF (mul_prec+1) y
+
+--------------------------------------------------------------------------------
+
diff --git a/Data/Generics/Fixplate/Hash.hs b/Data/Generics/Fixplate/Hash.hs
--- a/Data/Generics/Fixplate/Hash.hs
+++ b/Data/Generics/Fixplate/Hash.hs
@@ -31,7 +31,7 @@
 import Data.Foldable    as F
 import Data.Traversable as T
 
-import Text.Show
+import Text.Show ()
 
 --------------------------------------------------------------------------------
 
diff --git a/Data/Generics/Fixplate/Misc.hs b/Data/Generics/Fixplate/Misc.hs
--- a/Data/Generics/Fixplate/Misc.hs
+++ b/Data/Generics/Fixplate/Misc.hs
@@ -4,14 +4,16 @@
 
 --------------------------------------------------------------------------------
 
-import Prelude hiding (mapM,mapM_)
+import Prelude hiding ( mapM , mapM_ )
 
 import Data.List ( sortBy , groupBy )
 import Data.Ord
 
 import Data.Traversable
 
---import Control.Monad (liftM)
+import Control.Applicative ( Applicative(..) )
+import Control.Monad ( ap , liftM )
+
 --import Control.Monad.Trans.State
 
 --------------------------------------------------------------------------------
@@ -96,29 +98,42 @@
   return ()
 
 mapAccumM :: (Traversable t, Monad m) => (a -> b -> m (a, c)) -> a -> t b -> m (a, t c)
-mapAccumM act x0 t = runStateT (mapM (StateT . flip act) t) x0 where
+mapAccumM user x0 t = liftM swap $ runStateT (mapM action t) x0 where
+  action x = StateT $ \acc -> do
+    (acc', y) <- user acc x 
+    return (y, acc') 
 
+swap :: (a,b) -> (b,a)
+swap (x,y) = (y,x)
+
 --------------------------------------------------------------------------------  
 
-newtype StateT s m a = StateT { runStateT :: s -> m (s,a) }
+newtype StateT s m a = StateT { runStateT :: s -> m (a,s) }
 
+instance (Functor m) => Functor (StateT s m) where
+  fmap f m = StateT $ \s -> fmap (\ ~(a, s') -> (f a, s')) $ runStateT m s
+
+instance (Functor m, Monad m) => Applicative (StateT s m) where
+  pure  = return
+  (<*>) = ap
+
 instance (Monad m) => Monad (StateT s m) where
-  return a = state $ \s -> (s,a)
+  return a = state $ \s -> (a, s)
   m >>= k  = StateT $ \s -> do
-    ~(s', a) <- runStateT m s
+    ~(a, s') <- runStateT m s
     runStateT (k a) s'
   fail str = StateT $ \_ -> fail str
 
-state :: Monad m => (s -> (s,a)) -> StateT s m a 
+state :: (Monad m) => (s -> (a,s)) -> StateT s m a 
 state f = StateT (return . f)
 
 sget :: (Monad m) => StateT s m s
 sget = state $ \s -> (s,s)
 
 sput :: (Monad m) => s -> StateT s m ()
-sput s = state $ \_ -> (s,())
+sput s = state $ \_ -> ((),s)
 
 smodify :: (Monad m) => (s -> s) -> StateT s m ()
-smodify f = state $ \s -> (f s,())
+smodify f = state $ \s -> ((), f s)
 
 --------------------------------------------------------------------------------  
diff --git a/Data/Generics/Fixplate/Pretty.hs b/Data/Generics/Fixplate/Pretty.hs
new file mode 100644
--- /dev/null
+++ b/Data/Generics/Fixplate/Pretty.hs
@@ -0,0 +1,172 @@
+
+-- | Generic pretty-printing of expression trees.
+--
+-- TODO: 
+--
+--  * make the style configurable (so that we can print the same expression in different formats)
+--    (in Haskell98, we have to use the record instead of class trick for this?)
+--
+--  * corresponding parser?
+--
+
+module Data.Generics.Fixplate.Pretty where
+
+--------------------------------------------------------------------------------
+
+import Prelude
+import Data.List ( intersperse )
+
+import Data.Generics.Fixplate
+import Data.Foldable ( toList )
+
+import Text.Show ()
+
+--------------------------------------------------------------------------------
+
+-- | Associativity
+data Assoc 
+  = NoAssoc 
+  | LeftAssoc 
+  | RightAssoc
+  deriving (Eq,Show)
+
+-- | A pair of matching brackets, eg. @Bracket \"(\" \")\"@ or @Bracket \"[|\" \"|]\"@.
+data Bracket = Bracket !String !String deriving (Eq,Show)
+
+-- | A separator, eg. @\",\"@ or @\" | \"@.
+type Separator = String
+
+-- | Application style 
+data AppStyle
+  = Haskell                    -- ^ eg. @(Node arg1 arg2 arg3)@; precedence will be @app_prec == 10@
+  | Algol !Bracket !Separator  -- ^ eg. @node[arg1,arg2,arg3]@; precedence will be 11, but child environment precedence will be 0
+  deriving (Eq,Show)
+
+-- | Mixfix style. Example: 
+--
+-- > [ Keyword "if" , Placeholder , keyword "then" , Placeholder , keyword "else" , Placeholder ]
+--
+data MixWord 
+  = Keyword String
+  | Placeholder
+  deriving (Eq,Show)
+
+mixWords :: [MixWord] -> [ShowS] -> ShowS
+mixWords mws args = Prelude.foldr (.) id (intersperse (showChar ' ') (go mws args)) where 
+  go :: [MixWord] -> [ShowS] -> [ShowS]
+  go (Keyword s   : rest) fs     = showString s : go rest fs
+  go (Placeholder : rest) (f:fs) = f : go rest fs
+  go (Placeholder : rest) [] = error "mixWords: not enough arguments"
+  go [] []     = []
+  go [] (f:fs) = f : go [] fs
+
+-- | Fixities. TODO: separate non-fixity stuff like style and words
+data Fixity 
+  = Atom                   -- ^ eg. @variable@; precedence will be 666
+  | Application !AppStyle  -- ^ eg. @(Node arg1 arg2 arg3)@ or @node[arg1,arg2,arg3]@.
+  | Prefix  !Int           -- ^ eg. @~arg@; the @Int@ is the precendence
+  | Infix !Assoc !Int      -- ^ eg. @x+y@
+  | Postfix !Int           -- ^ eg. @arg++@
+  | Mixfix [MixWord]       -- ^ eg. @if ... then ... else ... @ or @let ... in ...@. With precedence 0?
+  | Custom  !Int           -- ^ for your custom rendering
+  deriving (Eq,Show)
+
+fixityPrecedence :: Fixity -> Int
+fixityPrecedence f = case f of
+  Atom              -> 666
+  Application style -> 
+    case style of
+      Haskell  -> 10
+      Algol {} -> 11
+  Prefix prec       -> prec
+  Infix assoc prec  -> prec
+  Postfix prec      -> prec
+  Mixfix {}         -> 0
+  Custom prec       -> prec
+
+--------------------------------------------------------------------------------
+
+-- | A class encoding fixity and rendering of nodes if the tree.
+--
+-- Minimum complete definition: 'fixity', and 'showNode' or 'showsPrecNode'.
+-- Unless you want some type of rendering not directly supported, you shouldn't specify 'showsPrecNode'.
+--
+class (Functor f, Foldable f) => Pretty f where
+  -- | fixity of the node
+  fixity    :: f a -> Fixity                                      
+
+  -- | a string representing the node /without/ the children
+  showNode  :: f a -> String                                      
+
+  -- | full rendering of the node. You can redefine this for custom renderings.
+  showsPrecNode :: (Int -> a -> ShowS) -> Int -> f a -> ShowS     
+  showsPrecNode child d node = showParen (d > prec) $ 
+    case fty of       
+      Atom -> showString (showNode node)
+
+      Application style -> case style of
+
+        Haskell -> head . args where
+          head = showString (showNode node)
+          args = Prelude.foldr (.) id [ showChar ' ' . child (prec+1) c | c <- children ]
+
+        Algol (Bracket open close) sep -> head . showString open . args . showString close where
+          head = showString (showNode node)
+          args = Prelude.foldr (.) id 
+               $ intersperse (showString sep) [ child 0 c | c <- children ]
+
+      Prefix prec -> 
+        case children of
+          [] -> error "showsPrecNode: prefix node with no arguments"
+          (c:cs) -> op . arg1 c . args cs
+        where
+          op = showString (showNode node)
+          arg1 c  = child (prec+1) c 
+          args cs = Prelude.foldr (.) id [ showChar ' ' . child (prec+1) c | c <- cs ]
+
+      Postfix prec -> 
+        case children of
+          []  -> error "showsPrecNode: postfix node with no arguments"
+          ccs -> let (cs,c) = (Prelude.init ccs, Prelude.last ccs) 
+                 in  args cs . arg1 c . op
+        where
+          op = showString (showNode node)
+          arg1 c  = child (prec+1) c 
+          args cs = Prelude.foldr (.) id [ child (prec+1) c . showChar ' ' | c <- cs ]
+
+      Infix assoc prec -> 
+        case children of
+          []  -> error "showsPrecNode: infix node with no arguments"
+          [_] -> error "showsPrecNode: infix node with a single argument"
+          (c1:c2:cs) -> lhs c1 . op . rhs c2 . rest cs
+        where
+          lhs  c1 = child lprec c1 
+          op      = showString (showNode node) 
+          rhs  c2 = child rprec c2
+          rest cs = Prelude.foldr (.) id [ showChar ' ' . child (prec+1) c | c <- cs ]
+          lprec = case assoc of { LeftAssoc  -> prec ; _ -> prec+1 }
+          rprec = case assoc of { RightAssoc -> prec ; _ -> prec+1 }
+        
+      Mixfix mwords -> mixWords mwords [ child (prec+1) {- ? -} c | c <- children ]
+
+      Custom prec -> error "for custom rendering, you should redefine `showsPrecNode'"
+
+    where
+      fty  = fixity node
+      prec = fixityPrecedence fty
+      children = toList node
+
+--------------------------------------------------------------------------------
+
+-- | Render the expression
+pretty :: Pretty f => Mu f -> String 
+pretty tree = prettyS tree "" 
+
+prettyS :: Pretty f => Mu f -> ShowS
+prettyS = prettyPrec 0 
+
+prettyPrec :: Pretty f => Int -> Mu f -> ShowS
+prettyPrec d t = go d t where
+  go d (Fix t) = showsPrecNode go d t
+
+--------------------------------------------------------------------------------
diff --git a/Data/Generics/Fixplate/Trie.hs b/Data/Generics/Fixplate/Trie.hs
--- a/Data/Generics/Fixplate/Trie.hs
+++ b/Data/Generics/Fixplate/Trie.hs
@@ -17,7 +17,9 @@
     -- * Construction \/ deconstruction
   , empty , singleton
   , fromList , toList
+    -- * Multisets
   , bag , universeBag
+  , christmasTree
     -- * Lookup
   , lookup 
     -- * Insertion \/ deletion
@@ -53,6 +55,7 @@
 import Test.QuickCheck
 import Data.Generics.Fixplate.Test.Tools
 import Data.Generics.Fixplate.Misc
+import Data.Generics.Fixplate.Traversals
 import Data.List ( sort , group , nubBy , nub , (\\) , foldl' )
 import Control.Applicative ( (<$>) )
 import Debug.Trace
@@ -69,10 +72,19 @@
 --
 -- > universeBag == bag . universe
 --
--- TODO: more efficient implementation?
+-- TODO: more efficient implementation? and better name
 universeBag :: (Functor f, Foldable f, OrdF f) => Mu f -> Trie f Int
 universeBag = bag . universe
 
+-- | We attribute each node with the multiset of all its subtrees.
+-- TODO: better name
+christmasTree :: (Functor f, Foldable f, OrdF f) => Mu f -> Attr f (Trie f Int)
+christmasTree = go where
+  go this@(Fix t) = Fix (Ann (ins us) sub) where
+    sub = fmap go t
+    us  = Foldable.foldl (trieUnionWith (+)) emptyTrie (fmap attribute sub)   
+    ins = trieInsertWith id (+) this 1
+
 ---------------------------------------------------------------------------------
 
 empty :: (Functor f, Foldable f, OrdF f) => Trie f a 
@@ -284,6 +296,11 @@
   quickCheck prop_intersection
 
   quickCheck prop_unibag_naive
+  quickCheck prop_unibag_naive_2
+  quickCheck prop_christmasTree
+  quickCheck prop_christmasTree_2
+  quickCheck prop_christmasTree_3
+
   quickCheck prop_fromList_naive
   quickCheck prop_bag
   quickCheck prop_bag_b
@@ -351,6 +368,9 @@
 prop_unibag_naive :: FixT Label -> Bool
 prop_unibag_naive tree = toList (universeBag tree) == toList (universeBagNaive tree)
 
+prop_unibag_naive_2 :: FixT Bool -> Bool
+prop_unibag_naive_2 tree = toList (universeBag tree) == toList (universeBagNaive tree)
+
 prop_fromList_naive :: FiniteMap -> Bool
 prop_fromList_naive (FiniteMap list) = toList (fromList list) == toList (fromListNaive list)
 
@@ -471,6 +491,21 @@
 
   dtrie = sort $     toList $     differenceWith f (   bag xs) (   bag ys)
   dmap  = sort $ Map.toList $ Map.differenceWith f (mapBag xs) (mapBag ys) 
+
+prop_christmasTree :: FixT Label -> Bool
+prop_christmasTree tree = toList (attribute (christmasTree tree)) == toList (universeBag tree)
+
+prop_christmasTree_3 :: FixT Bool -> Bool
+prop_christmasTree_3 tree = toList (attribute (christmasTree tree)) == toList (universeBag tree)
+
+-- we reduce the labels so that there is more chance for collisions
+prop_christmasTree_2 :: Bool -> FixT Label -> Bool
+prop_christmasTree_2 b tree0 = toList (attribute (christmasTree tree)) == toList (universeBag tree) where
+  tree = transform f tree0
+  f = if b 
+    then \(Fix (TreeF (Label label) ts)) -> Fix $ TreeF (Label (take 1 label)) ts
+    else \(Fix (TreeF (Label label) ts)) -> Fix $ TreeF (Label ""            ) ts
+
 
 #endif
 
diff --git a/Data/Generics/Fixplate/Util/Hash/Class.hs b/Data/Generics/Fixplate/Util/Hash/Class.hs
--- a/Data/Generics/Fixplate/Util/Hash/Class.hs
+++ b/Data/Generics/Fixplate/Util/Hash/Class.hs
@@ -6,9 +6,9 @@
 
 import Data.Char
 import Data.Word
-import Data.Int
 import Data.Bits
 import Data.List
+-- import Data.Int
 
 --------------------------------------------------------------------------------
 
diff --git a/Data/Generics/Fixplate/Zipper.hs b/Data/Generics/Fixplate/Zipper.hs
--- a/Data/Generics/Fixplate/Zipper.hs
+++ b/Data/Generics/Fixplate/Zipper.hs
@@ -1,5 +1,5 @@
 
-{-# LANGUAGE CPP #-}
+{-# LANGUAGE CPP, FlexibleInstances #-}
 
 -- | The Zipper is a data structure which maintains a location in 
 -- a tree, and allows O(1) movement and local changes
diff --git a/LICENSE b/LICENSE
--- a/LICENSE
+++ b/LICENSE
@@ -1,4 +1,4 @@
-Copyright (c) 2011-2012, Balazs Komuves
+Copyright (c) 2011-2015, Balazs Komuves
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
diff --git a/fixplate.cabal b/fixplate.cabal
--- a/fixplate.cabal
+++ b/fixplate.cabal
@@ -1,21 +1,22 @@
 
 Name:                fixplate
-Version:             0.1.5
+Version:             0.1.6
 Synopsis:            Uniplate-style generic traversals for optionally annotated fixed-point types.
 Description:         Uniplate-style generic traversals for fixed-point types, which can be  
                      optionally annotated with attributes. We also provide recursion schemes,
-                     and a generic zipper. See the module "Data.Generics.Fixplate" and then 
-                     the individual modules for more detailed information.
+                     a generic zipper, generic pretty-printer, generic tries, generic hashing,
+                     and generic tree visualization. See the module "Data.Generics.Fixplate" and 
+                     then the individual modules for more detailed information.
 License:             BSD3
 License-file:        LICENSE
 Author:              Balazs Komuves
-Copyright:           (c) 2011-2012 Balazs Komuves
+Copyright:           (c) 2011-2015 Balazs Komuves
 Maintainer:          bkomuves (plus) hackage (at) gmail (dot) com
 Homepage:            http://code.haskell.org/~bkomuves/
 Stability:           Experimental
 Category:            Generics
-Tested-With:         GHC == 7.0.3
-Cabal-Version:       >= 1.6
+Tested-With:         GHC == 7.10.2
+Cabal-Version:       >= 1.10
 Build-Type:          Simple
 
 source-repository head
@@ -30,17 +31,9 @@
   Description: Include utility modules
   default: True
 
-Flag base4
-  Description: Base v4
-  
 Library
 
-  if flag(base4)
-    Build-Depends:       base >= 4 && < 5
-    cpp-options:         -DBASE_VERSION=4
-  else 
-    Build-Depends:       base >= 3 && < 4
-    cpp-options:         -DBASE_VERSION=3
+  Build-Depends:       base >= 4 && < 5
 
   if flag(withUtils)
     Build-Depends:       containers
@@ -52,12 +45,14 @@
 
   Exposed-Modules:     Data.Generics.Fixplate
                        Data.Generics.Fixplate.Base
+                       Data.Generics.Fixplate.Functor
                        Data.Generics.Fixplate.Open
                        Data.Generics.Fixplate.Traversals
                        Data.Generics.Fixplate.Morphisms
                        Data.Generics.Fixplate.Attributes
                        Data.Generics.Fixplate.Zipper
                        Data.Generics.Fixplate.Draw
+                       Data.Generics.Fixplate.Pretty
                        Data.Generics.Fixplate.Trie
                        Data.Generics.Fixplate.Hash
 
@@ -74,14 +69,18 @@
     Exposed-Modules:     Data.Generics.Fixplate.Test.Tools
                          Data.Generics.Fixplate.Test.Instances
                          Data.Generics.Fixplate.Tests
-    Extensions:          TypeSynonymInstances
+
+    other-extensions:    TypeSynonymInstances
  
-  Extensions:          CPP
+  default-extensions:  CPP
+  other-extensions:    TypeOperators
 
   if impl(ghc)
-    Extensions:          BangPatterns
+    default-extensions:  BangPatterns
 
   Hs-Source-Dirs:      .
+
+  Default-Language:    Haskell2010
 
   ghc-options:         -Wall -fno-warn-unused-matches -fno-warn-name-shadowing