diff --git a/catamorphism.cabal b/catamorphism.cabal
--- a/catamorphism.cabal
+++ b/catamorphism.cabal
@@ -1,7 +1,48 @@
 name:                catamorphism
-version:             0.6.1.0
-synopsis:            A package exposing a helper function for generating catamorphisms.
-description:         A package exposing a helper function for generating catamorphisms.
+version:             0.6.1.1
+synopsis:            Exposes a Template Haskell function for generating catamorphisms.
+description:
+  This module exposes a 'makeCata' function which can create catamorphisms for
+  arbitrary Haskell types. Catamorphisms are functions which deconstruct some
+  value by replacing each data constructor with a custom function yielding a
+  new value. See <http://www.haskell.org/haskellwiki/Catamorphisms> for a more
+  in-depth discussion of catamorphisms in Haskell.
+  .
+  The Haskell base package already comes with a couple of standard
+  catamorphisms, such as 'maybe' (for 'Maybe' values). The 'maybe' function
+  could have been generated using 'makeCata' as follows:
+  .
+  > -- Defines 'maybe :: b -> (a -> b) -> Maybe a -> b'
+  > $(makeCata defaultOptions ''Maybe)
+  .
+  However, catamorphisms are especially useful for recursive data structures.
+  Consider the following simple example which defines a basic data type for
+  modelling sums of numbers, supporting variables:
+  .
+  > import Data.Morphism.Cata
+  > import Data.Maybe (fromJust)
+  >
+  > data Expr a = Number a
+  >             | Variable Char
+  >             | Sum (Expr a) (Expr a)
+  >
+  > -- Defines 'expr :: (a -> b) -> (Char -> b) -> (b -> b -> b) -> Expr a -> b'
+  > $(makeCata defaultOptions ''Expr)
+  .
+  The 'makeCata' invocation defines a 'expr' function which works like a fold on
+  'Expr' values; it can be used to implement various useful other functions:
+  .
+  > -- Evaluate an Expr, given some variable bindings
+  > eval :: Num a => [(Char, a)] -> Expr a -> a
+  > eval vars = expr id (fromJust . (`lookup` vars)) (+)
+  >
+  > -- Pretty-prints an Expr
+  > pprint :: Show a => Expr a -> String
+  > pprint = expr show show (\a b -> a ++ " + " ++ b)
+  >
+  > -- Counts the number of variables used in an expr
+  > numVars :: Expr a -> Int
+  > numVars = expr (const 1) (const 0) (+)
 homepage:            https://github.com/frerich/catamorphism
 license:             BSD3
 license-file:        LICENSE
diff --git a/src/Data/Morphism/Cata.hs b/src/Data/Morphism/Cata.hs
--- a/src/Data/Morphism/Cata.hs
+++ b/src/Data/Morphism/Cata.hs
@@ -177,7 +177,7 @@
         return (SigD funName (ForallT (PlainTV resultTypeName : tyVarBndrs) [] (foldr1 makeFuncT args)))
 
     funDef :: [Con] -> Q Dec
-    funDef cons = (FunD funName . (:[])) <$> funImpl cons
+    funDef cons = FunD funName . (:[]) <$> funImpl cons
 
     funName :: Name
     funName = mkName $
@@ -209,9 +209,7 @@
 
       where
         conToConP :: Con -> Q Pat
-        conToConP c = do
-            argNames <- replicateM (length . conArgTypes $ c) (VarP <$> newName "a")
-            return (ConP (conName c) argNames)
+        conToConP c = ConP (conName c) <$> replicateM (length . conArgTypes $ c) (VarP <$> newName "a")
 
 tyVarName :: TyVarBndr -> Name
 tyVarName (PlainTV n)    = n