diff --git a/category-extras.cabal b/category-extras.cabal
--- a/category-extras.cabal
+++ b/category-extras.cabal
@@ -1,6 +1,6 @@
 name:                   category-extras
 category:               Control, Monads, Comonads
-version:                0.52.3
+version:                0.53.0
 license:                BSD3
 cabal-version:          >= 1.2
 license-file:           LICENSE
@@ -135,6 +135,8 @@
                 Control.Morphism.Hylo,
                 Control.Morphism.Meta,
                 Control.Morphism.Para,
+                Control.Morphism.Postpro,
+                Control.Morphism.Prepro,
                 Control.Morphism.Span,
                 Control.Morphism.Universal,
                 Control.Morphism.Zygo,
diff --git a/src/Control/Comonad/Fix.hs b/src/Control/Comonad/Fix.hs
--- a/src/Control/Comonad/Fix.hs
+++ b/src/Control/Comonad/Fix.hs
@@ -10,17 +10,22 @@
 --
 -------------------------------------------------------------------------------------------
 module Control.Comonad.Fix 
-	( ComonadFix(..)
+	( cofix
 	) where
 
 import Control.Comonad
-import Control.Monad.Identity
+-- import Control.Monad.Identity
 
-class Comonad w => ComonadFix w where
-	cofix :: w (w a -> a) -> a
+--class Comonad w => ComonadFix w where
+--	cofix :: w (w a -> a) -> a
 
-instance ComonadFix Identity where
-	cofix (Identity f) = fix (f . Identity)
+--instance ComonadFix Identity where
+--	cofix (Identity f) = fix (f . Identity)
 
-instance ComonadFix ((,)e) where
-	cofix ~(e,f) = let x = f (e,x) in x
+--instance ComonadFix ((,)e) where
+--	cofix ~(e,f) = let x = f (e,x) in x
+
+
+cofix :: Comonad w => w (w a -> a) -> a
+cofix w = extract w (extend cofix w)
+
diff --git a/src/Control/Functor/Composition.hs b/src/Control/Functor/Composition.hs
--- a/src/Control/Functor/Composition.hs
+++ b/src/Control/Functor/Composition.hs
@@ -21,6 +21,8 @@
 	, associateComposition
 	, coassociateComposition
 	, (:.:)
+	, preTransform
+	, postTransform
 	, Comp
 	, (:++:)
 	, (:**:)
@@ -28,6 +30,7 @@
 	) where
 
 import Control.Functor
+import Control.Functor.Extras
 import Control.Functor.Exponential
 import Control.Functor.Full
 import Control.Functor.HigherOrder
@@ -62,11 +65,17 @@
 instance (Full f, Full g) => Full (CompF f g) where
         premap f = premap . premap $ decompose . f . compose
 
+preTransform :: Composition o => (f :~> g) -> (f `o` k) :~> (g `o` k) 
+preTransform f x = compose (f (decompose x))
+
+postTransform :: (Functor k, Composition o) => (f :~> g) -> (k `o` f) :~> (k `o` g) 
+postTransform f x = compose (fmap f (decompose x))
+
 -- | The only reason the compositions are all the same is for type inference. This can be liberalized.
-associateComposition :: (Functor f, Composition c) => c (c f g) h a -> c f (c g h) a
+associateComposition :: (Functor f, Composition o) => ((f `o` g) `o` h) :~> (f `o` (g `o` h))
 associateComposition = compose . fmap compose . decompose . decompose
 
-coassociateComposition :: (Functor f, Composition c) => c f (c g h) a -> c (c f g) h a
+coassociateComposition :: (Functor f, Composition o) => (f `o` (g `o` h)) :~> ((f `o` g) `o` h)
 coassociateComposition = compose . compose . fmap decompose . decompose
 
 
diff --git a/src/Control/Functor/Fix.hs b/src/Control/Functor/Fix.hs
--- a/src/Control/Functor/Fix.hs
+++ b/src/Control/Functor/Fix.hs
@@ -62,3 +62,4 @@
 
 pcoaugment :: PComonad f => ((Fix f a -> f b (Fix f a)) -> Fix f b) -> (Fix f a -> b) -> Fix f b
 pcoaugment g k = g (pextend (k . InB) . outB)
+
diff --git a/src/Control/Functor/Strong.hs b/src/Control/Functor/Strong.hs
--- a/src/Control/Functor/Strong.hs
+++ b/src/Control/Functor/Strong.hs
@@ -18,7 +18,7 @@
 import Control.Monad.Either (Either(..))
 
 strength :: Functor f => a -> f b -> f (a,b)
-strength a fb = fmap ((,)a) fb
+strength = fmap . (,)
 
 costrength :: Traversable f => f (Either a b) -> Either a (f b)
-costrength = sequence
+costrength = Data.Traversable.sequence
diff --git a/src/Control/Morphism/Apo.hs b/src/Control/Morphism/Apo.hs
--- a/src/Control/Morphism/Apo.hs
+++ b/src/Control/Morphism/Apo.hs
@@ -12,10 +12,10 @@
 -- Traditional operators, shown here to show how to roll your own
 ----------------------------------------------------------------------------
 module Control.Morphism.Apo 
-	( apo
+	( apo, g_apo
+	, postpro_apo, g_postpro_apo
 	, Apo, ApoT
 	, distApoT
-	, g_apo
 	, GApo, GApoT
 	, distGApo, distGApoT
 	) where
@@ -26,6 +26,7 @@
 import Control.Monad
 import Control.Monad.Either 
 import Control.Morphism.Ana
+import Control.Morphism.Postpro
 import Control.Arrow ((|||))
 
 -- * Unfold Sugar
@@ -36,13 +37,20 @@
 g_apo :: Functor f => Coalgebra f b -> GCoalgebra f (GApo b) a -> a -> FixF f
 g_apo g = g_ana (distGApo g)
 
+postpro_apo :: Functor f => GCoalgebra f (Apo f) a -> (f :~> f) -> a -> FixF f
+postpro_apo = g_postpro_apo outF
+
+g_postpro_apo :: Functor f => Coalgebra f b -> GCoalgebra f (GApo b) a -> (f :~> f) -> a -> FixF f
+g_postpro_apo g = g_postpro (distGApo g)
+
 type Apo f a 		= Either (FixF f) a
 type ApoT f m a 	= EitherT (FixF f) m a
 
 type GApo b a 		= Either b a
 type GApoT b m a 	= EitherT b m a 
 
--- * Distributive Law Combinators
+-- * Distributive Law Combinators for apomorphisms
+-- NB: we don't actually have simple recursion combinators for all of these 
 
 distGApo :: Functor f => Coalgebra f b -> Dist (Either b) f
 distGApo f = fmap Left . f  ||| fmap Right
diff --git a/src/Control/Morphism/Build.hs b/src/Control/Morphism/Build.hs
--- a/src/Control/Morphism/Build.hs
+++ b/src/Control/Morphism/Build.hs
@@ -17,6 +17,7 @@
 import Control.Functor.KanExtension
 -- import Control.Functor.KanExtension.Interpreter
 -- import Control.Morphism.Cata
+-- prepro/preprobuild fusion?
 
 -- | @forall h g.  hcata h . hbuild g = g h@ cannot be realized as a RULE because
 -- h and g are not monotypes.
diff --git a/src/Control/Morphism/Futu.hs b/src/Control/Morphism/Futu.hs
--- a/src/Control/Morphism/Futu.hs
+++ b/src/Control/Morphism/Futu.hs
@@ -11,22 +11,36 @@
 -- 
 -- Traditional operators, shown here to show how to roll your own
 ----------------------------------------------------------------------------
-module Control.Morphism.Futu where
+module Control.Morphism.Futu 
+	( futu, g_futu
+	, postpro_futu, g_postpro_futu
+	, distFutu
+	) where
 
 import Control.Functor.Algebra
 import Control.Functor.Extras
 import Control.Functor.Fix
-import Control.Comonad ()
 import Control.Monad.Free
 import Control.Morphism.Ana
+import Control.Morphism.Postpro
 
--- futu :: Functor f => GCoalgebra f (Free f) a -> a -> FixF f
+-- | Generalized from @futu :: Functor f => GCoalgebra f (Free f) a -> a -> FixF f@
 futu :: (RunMonadFree f m) => GCoalgebra f m a -> a -> FixF f
 futu = g_ana (distFutu id)
 
 g_futu :: (Functor f, RunMonadFree h m) => Dist h f -> GCoalgebra f m a -> a -> FixF f
 g_futu k = g_ana (distFutu k)
 
+-- | A futumorphic postpromorphism
+postpro_futu :: (RunMonadFree f m) => GCoalgebra f m a -> (f :~> f) -> a -> FixF f
+postpro_futu = g_postpro (distFutu id)
+
+-- | A generalized-futumorphic postpromorphism
+g_postpro_futu :: (Functor f, RunMonadFree h m) => Dist h f -> GCoalgebra f m a -> (f :~> f) -> a -> FixF f
+g_postpro_futu k = g_postpro (distFutu k)
+
+-- | Turn a distributive law for a functor into a distributive law for the free monad of that functor.
+-- This has been generalized to support generating distributive laws for a number of related free-monad-like
+-- constructions such as the Codensity monad of the free monad of a functor.
 distFutu :: (Functor f, RunMonadFree h m) => Dist h f -> Dist m f
 distFutu k = cataFree (fmap return) (fmap inFree . k)
-
diff --git a/src/Control/Morphism/Histo.hs b/src/Control/Morphism/Histo.hs
--- a/src/Control/Morphism/Histo.hs
+++ b/src/Control/Morphism/Histo.hs
@@ -11,7 +11,11 @@
 -- 
 -- Traditional operators, shown here to show how to roll your own
 ----------------------------------------------------------------------------
-module Control.Morphism.Histo where
+module Control.Morphism.Histo 
+	( distHisto
+	, histo, g_histo
+	, prepro_histo, g_prepro_histo
+	) where
 
 import Control.Functor.Algebra
 import Control.Functor.Extras
@@ -19,12 +23,21 @@
 import Control.Comonad
 import Control.Comonad.Cofree
 import Control.Morphism.Cata
+import Control.Morphism.Prepro
 
+distHisto :: (RunComonadCofree h w, Functor f) => Dist f h -> Dist f w
+distHisto k = anaCofree (fmap extract) (k . fmap outCofree)
+
 histo :: (RunComonadCofree f w) => GAlgebra f w a -> FixF f -> a
 histo = g_cata (distHisto id)
 
 g_histo :: (RunComonadCofree h w, Functor f) => Dist f h -> GAlgebra f w a -> FixF f -> a
 g_histo k = g_cata (distHisto k)
 
-distHisto :: (RunComonadCofree h w, Functor f) => Dist f h -> Dist f w
-distHisto k = anaCofree (fmap extract) (k . fmap outCofree)
+-- A histomorphic prepromorphism
+prepro_histo :: (RunComonadCofree f w) => GAlgebra f w a -> (f :~> f) -> FixF f -> a
+prepro_histo = g_prepro (distHisto id)
+
+-- A generalized histomorphic prepromorphism
+g_prepro_histo :: (RunComonadCofree h w, Functor f) => Dist f h -> GAlgebra f w a -> (f :~> f) -> FixF f -> a
+g_prepro_histo k = g_prepro (distHisto k)
diff --git a/src/Control/Morphism/Para.hs b/src/Control/Morphism/Para.hs
--- a/src/Control/Morphism/Para.hs
+++ b/src/Control/Morphism/Para.hs
@@ -10,7 +10,13 @@
 -- Portability :  non-portable (rank-2 polymorphism)
 -- 
 ----------------------------------------------------------------------------
-module Control.Morphism.Para where
+module Control.Morphism.Para 
+	( Para
+	, ParaT 
+	, distParaT 
+	, para, g_para
+	, prepro_para, g_prepro_para
+	) where
 
 import Control.Comonad
 import Control.Comonad.Reader
@@ -19,17 +25,28 @@
 import Control.Functor.Fix
 import Control.Morphism.Cata
 import Control.Morphism.Zygo
-
--- * Refold Sugar
+import Control.Morphism.Prepro
 
+-- * Paramorphisms use Reader Comonads
 type Para f 	= (,) (FixF f)
 type ParaT w f 	= CoreaderT w (FixF f)
 
+-- * Distributive Laws
+distParaT :: (Functor f, Comonad w) => Dist f w -> Dist f (ParaT w f)
+distParaT = distZygoT (liftAlgebra InF)
+
+-- * Paramorphism
 para :: Functor f => GAlgebra f (Para f) a -> FixF f -> a
 para = zygo InF
 
+-- | Generalized paramorphisms using a comonad reader transformer to carry the primitive recursive state
 g_para :: (Functor f, Comonad w) => Dist f w -> GAlgebra f (ParaT w f) a -> FixF f -> a
 g_para f = g_cata (distParaT f)
 
-distParaT :: (Functor f, Comonad w) => Dist f w -> Dist f (ParaT w f)
-distParaT = distZygoT (liftAlgebra InF)
+-- | A paramorphic prepromorphism
+prepro_para :: Functor f => GAlgebra f (Para f) a -> (f :~> f) -> FixF f -> a
+prepro_para = prepro_zygo InF
+
+-- | A generalized paramorphic prepromorphism
+g_prepro_para :: (Functor f, Comonad w) => Dist f w -> GAlgebra f (ParaT w f) a -> (f :~> f) -> FixF f -> a
+g_prepro_para f = g_prepro (distParaT f)
diff --git a/src/Control/Morphism/Postpro.hs b/src/Control/Morphism/Postpro.hs
new file mode 100644
--- /dev/null
+++ b/src/Control/Morphism/Postpro.hs
@@ -0,0 +1,32 @@
+{-# OPTIONS_GHC -fglasgow-exts #-}
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Control.Morphism.Postpro
+-- Copyright   :  (C) 2008 Edward Kmett
+-- License     :  BSD-style (see the file LICENSE)
+--
+-- Maintainer  :  Edward Kmett <ekmett@gmail.com>
+-- Stability   :  experimental
+-- Portability :  non-portable (rank-2 polymorphism)
+-- 
+-- See Maarten Fokkinga''s PhD Dissertation for postpro. g_postpro is 
+-- an obvious generalization.
+----------------------------------------------------------------------------
+module Control.Morphism.Postpro 
+	( postpro
+	, g_postpro
+	) where
+
+import Control.Monad
+import Control.Functor.Algebra 
+import Control.Functor.Extras
+import Control.Functor.Fix
+import Control.Morphism.Ana
+
+-- prepro f e = x where x = f . fmap (x . cata (InF . e)) . outF
+postpro :: Functor f => (c -> f c) -> (f :~> f) -> c -> FixF f
+postpro g e = x where x = InF . fmap (ana (e . outF) . x) . g
+
+-- | Generalized postpromorphisms
+g_postpro :: (Functor f, Monad m) => Dist m f -> GCoalgebra f m a -> (f :~> f) -> a -> FixF f
+g_postpro k g e = a . return where a = InF . fmap (ana (e . outF) . a . join) . k . liftM g
diff --git a/src/Control/Morphism/Prepro.hs b/src/Control/Morphism/Prepro.hs
new file mode 100644
--- /dev/null
+++ b/src/Control/Morphism/Prepro.hs
@@ -0,0 +1,44 @@
+{-# OPTIONS_GHC -fglasgow-exts #-}
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Control.Morphism.Prepro
+-- Copyright   :  (C) 2008 Edward Kmett
+-- License     :  BSD-style (see the file LICENSE)
+--
+-- Maintainer  :  Edward Kmett <ekmett@gmail.com>
+-- Stability   :  experimental
+-- Portability :  non-portable (rank-2 polymorphism)
+-- 
+-- See Maarten Fokkinga''s PhD Dissertation for cascade and prepro.
+-- g_prepro is an obvious generalization.
+----------------------------------------------------------------------------
+module Control.Morphism.Prepro 
+	( prepro, g_prepro, cascade
+	) where
+
+import Control.Comonad
+import Control.Category.Hask
+import Control.Functor
+import Control.Functor.Pointed
+import Control.Functor.Algebra 
+import Control.Functor.Extras
+import Control.Functor.Fix
+-- import Control.Functor.HigherOrder
+import Control.Monad.Identity
+import Control.Morphism.Cata
+
+-- | @cascade f . map f = map f . cascade f@
+cascade :: Bifunctor s Hask Hask Hask => (a -> a) -> Fix s a -> Fix s a 
+cascade f = InB . bimap id (cascade f . fmap f) . outB 
+-- equivalently:
+-- cascade f = InB . bimap id (fmap f . cascade f) . outB 
+
+prepro :: Functor f => (f c -> c) -> (f :~> f) -> FixF f -> c
+prepro f e = x where x = f . fmap (x . cata (InF . e)) . outF
+
+-- | Generalized prepromorphisms
+g_prepro :: (Functor f, Comonad w) => Dist f w -> GAlgebra f w a -> (f :~> f) -> FixF f -> a
+g_prepro k g e = extract . c where c = liftW g . k . fmap (duplicate . c . cata (InF . e)) . outF
+
+--repro :: Functor f => (f b -> b) -> (f :~> f) -> (f :~> f) -> (a -> f a) -> a -> b
+--repro f fe ge g = x where x = f . fmap (ana (fe . outF) . x . cata (InF . ge)) . g
diff --git a/src/Control/Morphism/Zygo.hs b/src/Control/Morphism/Zygo.hs
--- a/src/Control/Morphism/Zygo.hs
+++ b/src/Control/Morphism/Zygo.hs
@@ -10,7 +10,14 @@
 -- Portability :  non-portable (rank-2 polymorphism)
 --
 ----------------------------------------------------------------------------
-module Control.Morphism.Zygo where
+module Control.Morphism.Zygo 
+	( Zygo, ZygoT
+	, distZygo, distZygoT
+	, zygo
+	, g_zygo
+	, prepro_zygo
+	, g_prepro_zygo 
+	) where
 
 import Control.Arrow ((&&&))
 import Control.Comonad
@@ -19,16 +26,11 @@
 import Control.Functor.Extras
 import Control.Functor.Fix
 import Control.Morphism.Cata
+import Control.Morphism.Prepro
 
 type Zygo = (,)
 type ZygoT = CoreaderT
 
-zygo :: Functor f => Algebra f b -> GAlgebra f (Zygo b) a -> FixF f -> a
-zygo f = g_cata (distZygo f)
-
-g_zygo :: (Functor f, Comonad w) => GAlgebra f w b -> Dist f w -> GAlgebra f (ZygoT w b) a -> FixF f -> a
-g_zygo f w = g_cata (distZygoT f w)
-
 -- * Distributive Law Combinators
 
 distZygo :: Functor f => Algebra f b -> Dist f (Zygo b)
@@ -37,3 +39,16 @@
 distZygoT :: (Functor f, Comonad w) => GAlgebra f w b -> Dist f w -> Dist f (ZygoT w b)
 distZygoT g k = CoreaderT . liftW (g . fmap (liftW fst) &&& fmap (snd . extract)) . k . fmap (duplicate . runCoreaderT)
 
+zygo :: Functor f => Algebra f b -> GAlgebra f (Zygo b) a -> FixF f -> a
+zygo f = g_cata (distZygo f)
+
+g_zygo :: (Functor f, Comonad w) => GAlgebra f w b -> Dist f w -> GAlgebra f (ZygoT w b) a -> FixF f -> a
+g_zygo f w = g_cata (distZygoT f w)
+
+-- | a zygomorphic prepromorphism
+prepro_zygo :: Functor f => Algebra f b -> GAlgebra f (Zygo b) a -> (f :~> f) -> FixF f -> a
+prepro_zygo f = g_prepro (distZygo f)
+
+-- | a generalized zygomorphic prepromorphism 
+g_prepro_zygo :: (Functor f, Comonad w) => GAlgebra f w b -> Dist f w -> GAlgebra f (ZygoT w b) a -> (f :~> f) -> FixF f -> a
+g_prepro_zygo f w = g_prepro (distZygoT f w)