diff --git a/Language/KURE/Combinators.hs b/Language/KURE/Combinators.hs
--- a/Language/KURE/Combinators.hs
+++ b/Language/KURE/Combinators.hs
@@ -13,18 +13,17 @@
 -- and the 'Translate' functions operate with 'Rewrite'. 
 
 module Language.KURE.Combinators 
-	(  -- * 'Translate' combinators
+	(  -- * The 'Translate' combinators
 	  (<+)
 	, (>->)
 	, failT
-	, (?)
 	, readerT
 	, getDecsT
 	, mapDecsT
 	, pureT
 	, constT
 	, concatT
-	, -- * 'Rewrite' combinators
+	, -- * The 'Rewrite' combinators
 	  (.+)
 	, (!->)
 	, tryR
@@ -33,6 +32,9 @@
 	, acceptR
 	, idR
 	, failR
+	, -- * Generic failure, over both 'Monad's and 'Translate's.
+	  (?)
+	, Failable(..)
 	) where 
 	
 import Language.KURE.RewriteMonad	
@@ -60,10 +62,6 @@
 failT :: (Monad m, Monoid dec) => String -> Translate m dec a b
 failT msg = translate $ \ _ -> failM msg
 
--- | Guarded translate.
-(?) ::  (Monoid dec, Monad m) => Bool -> Translate m dec a b -> Translate m dec a b
-(?) False _rr = failT "(False ?)"
-(?) True   rr = rr
 
 -- | look at the argument for the translation before choosing which translation to perform. 
 readerT :: (Monoid dec, Monad m) => (a -> Translate m dec a b) -> Translate m dec a b
@@ -130,6 +128,22 @@
 -- | failing rewrite.
 failR :: (Monad m, Monoid dec) => String -> Rewrite m dec a
 failR = failT
+
+--------------------------------------------------------------------------------
+-- | Failable structure.
+class Failable f where
+  failure :: String -> f a
+
+instance (Monad m, Monoid dec) => Failable (Translate m dec a) where 
+  failure msg = failT msg
+
+instance (Monad m, Monoid dec) => Failable (RewriteM m dec) where 
+  failure msg = fail msg
+ 
+-- | Guarded translate or monadic action.
+(?) ::  (Failable f) => Bool -> f a -> f a
+(?) False _rr = failure "(False ?)"
+(?) True   rr = rr
 
 
 --------------------------------------------------------------------------------
diff --git a/Language/KURE/RewriteMonad.hs b/Language/KURE/RewriteMonad.hs
--- a/Language/KURE/RewriteMonad.hs
+++ b/Language/KURE/RewriteMonad.hs
@@ -142,6 +142,6 @@
 getDecsM :: (Monad m, Monoid dec) => RewriteM m dec dec
 getDecsM = RewriteM $ \ dec -> return $ RewriteReturnM dec mempty mempty
 
--- | 'mapDecs" changes the local environment, inside a local monadic invocation.
+-- | 'mapDecs' changes the local environment, inside a local monadic invocation.
 mapDecsM :: (Monad m, Monoid dec) => (dec -> dec) -> RewriteM m dec a -> RewriteM m dec a
 mapDecsM fn (RewriteM m) = RewriteM $ \ dec -> m (fn dec)
diff --git a/kure.cabal b/kure.cabal
--- a/kure.cabal
+++ b/kure.cabal
@@ -1,5 +1,5 @@
 Name:                kure
-Version:             0.2.1
+Version:             0.2.2
 Synopsis:            Combinators for Strategic Programming
 Description:	     KURE is a DSL for building rewriting DSLs.
 	 	     KURE shares combinator names and concepts with Stratego, but unlike Stratego, KURE is strongly typed.