diff --git a/Language/KURE/Combinators/Translate.hs b/Language/KURE/Combinators/Translate.hs
--- a/Language/KURE/Combinators/Translate.hs
+++ b/Language/KURE/Combinators/Translate.hs
@@ -51,7 +51,8 @@
 import Prelude hiding (id, map, foldr, mapM)
 
 import Control.Category ((>>>),id)
-import Control.Monad (liftM)
+import Control.Applicative
+import Control.Monad (liftM,ap)
 
 import Data.Foldable
 import Data.Traversable
@@ -181,6 +182,10 @@
 
 data PBool a = PBool !Bool a
 
+instance Functor PBool where
+  fmap :: (a -> b) -> PBool a -> PBool b
+  fmap f (PBool b a) = PBool b (f a)
+
 checkSuccessPBool :: Monad m => String -> m (PBool a) -> m a
 checkSuccessPBool msg m = do PBool b a <- m
                              if b
@@ -203,6 +208,20 @@
 unAnyR (AnyR mba) = mba
 {-# INLINE unAnyR #-}
 
+instance Monad m => Functor (AnyR m) where
+   fmap :: (a -> b) -> AnyR m a -> AnyR m b
+   fmap = liftM
+   {-# INLINE fmap #-}
+
+instance Monad m => Applicative (AnyR m) where
+   pure :: a -> AnyR m a
+   pure = return
+   {-# INLINE pure #-}
+
+   (<*>) :: AnyR m (a -> b) -> AnyR m a -> AnyR m b
+   (<*>) = ap
+   {-# INLINE (<*>) #-}
+
 instance Monad m => Monad (AnyR m) where
    return :: a -> AnyR m a
    return = AnyR . return . PBool False
@@ -247,6 +266,20 @@
 unOneR :: OneR m a -> Bool -> m (PBool a)
 unOneR (OneR mba) = mba
 {-# INLINE unOneR #-}
+
+instance Monad m => Functor (OneR m) where
+   fmap :: (a -> b) -> OneR m a -> OneR m b
+   fmap = liftM
+   {-# INLINE fmap #-}
+
+instance Monad m => Applicative (OneR m) where
+   pure :: a -> OneR m a
+   pure = return
+   {-# INLINE pure #-}
+
+   (<*>) :: OneR m (a -> b) -> OneR m a -> OneR m b
+   (<*>) = ap
+   {-# INLINE (<*>) #-}
 
 instance Monad m => Monad (OneR m) where
    return :: a -> OneR m a
diff --git a/Language/KURE/MonadCatch.hs b/Language/KURE/MonadCatch.hs
--- a/Language/KURE/MonadCatch.hs
+++ b/Language/KURE/MonadCatch.hs
@@ -52,9 +52,10 @@
 ------------------------------------------------------------------------------------------
 
 -- | 'Monad's with a catch for 'fail'.
---   The following law is expected to hold:
+--   The following laws are expected to hold:
 --
 -- > fail msg `catchM` f == f msg
+-- > return a `catchM` f == return a
 
 class Monad m => MonadCatch m where
   -- | Catch a failing monadic computation.
diff --git a/Language/KURE/Walker.hs b/Language/KURE/Walker.hs
--- a/Language/KURE/Walker.hs
+++ b/Language/KURE/Walker.hs
@@ -79,6 +79,7 @@
 import Data.DList (singleton, toList)
 
 import Control.Monad
+import Control.Applicative
 import Control.Arrow
 import Control.Category hiding ((.))
 
@@ -402,6 +403,20 @@
 unAllT (AllT mw) = mw
 {-# INLINE unAllT #-}
 
+instance (Monoid w, Monad m) => Functor (AllT w m) where
+   fmap :: (a -> b) -> AllT w m a -> AllT w m b
+   fmap = liftM
+   {-# INLINE fmap #-}
+
+instance (Monoid w, Monad m) => Applicative (AllT w m) where
+   pure :: a -> AllT w m a
+   pure = return
+   {-# INLINE pure #-}
+
+   (<*>) :: AllT w m (a -> b) -> AllT w m a -> AllT w m b
+   (<*>) = ap
+   {-# INLINE (<*>) #-}
+
 instance (Monoid w, Monad m) => Monad (AllT w m) where
    return :: a -> AllT w m a
    return a = AllT $ return (P a mempty)
@@ -446,6 +461,20 @@
 unOneT (OneT f) = f
 {-# INLINE unOneT #-}
 
+instance (Monoid w, Monad m) => Functor (OneT w m) where
+   fmap :: (a -> b) -> OneT w m a -> OneT w m b
+   fmap = liftM
+   {-# INLINE fmap #-}
+
+instance (Monoid w, Monad m) => Applicative (OneT w m) where
+   pure :: a -> OneT w m a
+   pure = return
+   {-# INLINE pure #-}
+
+   (<*>) :: OneT w m (a -> b) -> OneT w m a -> OneT w m b
+   (<*>) = ap
+   {-# INLINE (<*>) #-}
+
 instance Monad m => Monad (OneT w m) where
    return :: a -> OneT w m a
    return a = OneT $ \ mw -> return (P a mw)
@@ -491,6 +520,20 @@
 getChildSecond :: (Maybe (c,g) -> Maybe (c,g)) -> GetChild c g a -> GetChild c g a
 getChildSecond f (GetChild ka mcg) = GetChild ka (f mcg)
 {-# INLINE getChildSecond #-}
+
+instance Functor (GetChild c g) where
+   fmap :: (a -> b) -> GetChild c g a -> GetChild c g b
+   fmap = liftM
+   {-# INLINE fmap #-}
+
+instance Applicative (GetChild c g) where
+   pure :: a -> GetChild c g a
+   pure = return
+   {-# INLINE pure #-}
+
+   (<*>) :: GetChild c g (a -> b) -> GetChild c g a -> GetChild c g b
+   (<*>) = ap
+   {-# INLINE (<*>) #-}
 
 instance Monad (GetChild c g) where
    return :: a -> GetChild c g a
diff --git a/kure.cabal b/kure.cabal
--- a/kure.cabal
+++ b/kure.cabal
@@ -1,5 +1,5 @@
 Name:                kure
-Version:             2.14.0
+Version:             2.14.4
 Synopsis:            Combinators for Strategic Programming
 Description:	     The Kansas University Rewrite Engine (KURE) is a domain-specific language for strategic rewriting.
 	 	     KURE was inspired by Stratego and StrategyLib, and has similarities with Scrap Your Boilerplate and Uniplate.
@@ -11,7 +11,7 @@
                      .
                      You can read about KURE in the following article:
                      .
-                     KURE: A Haskell-Embedded Strategic Programming Language with Custom Closed Universes.  Neil Sculthorpe and Nicolas Frisby and Andy Gill.  2013.
+                     The Kansas University Rewrite Engine: A Haskell-Embedded Strategic Programming Language with Custom Closed Universes.  Neil Sculthorpe, Nicolas Frisby and Andy Gill.  2013.
                      <http://www.ittc.ku.edu/~neil/papers_and_talks/kure.pdf>
 
 Category:            Language