diff --git a/Language/KURE/Term.hs b/Language/KURE/Term.hs
--- a/Language/KURE/Term.hs
+++ b/Language/KURE/Term.hs
@@ -13,6 +13,7 @@
 	, extractR
 	, promoteR
 	, extractU
+        , promoteU
 	, topdownR
 	, bottomupR 
 	, alltdR 
@@ -21,10 +22,10 @@
 	, foldU 
 	) where
 	
-import Language.KURE.RewriteMonad as M	
+import Language.KURE.RewriteMonad
 import Language.KURE.Translate	
 import Language.KURE.Rewrite
-import Language.KURE.Combinators -- perhaps
+import Language.KURE.Combinators
 
 import Control.Monad
 import Data.Monoid
@@ -37,11 +38,10 @@
   -- will have a new datatype for the 'Generic', which will also be an instance of class 'Term'.
   type Generic exp
 
-  -- | 'project' projects into a 'Generic' exp, to get the exp inside, or fail.
-  -- TODO: rename as select
+  -- | 'project' projects into a 'Generic', to get the exp inside, or fails.
   select :: Generic exp -> Maybe exp
 
-  -- | 'inject' injects an exp into a 'Generic' exp.
+  -- | 'inject' injects an exp into a 'Generic'.
   inject  :: exp -> Generic exp
 
 
@@ -54,7 +54,7 @@
 
 ------------------------------------------------------------------------------
 
--- | 'extract' converts a 'Rewrite' over a 'Generic' into a rewrite over a specific expression type. 
+-- | 'extractR' converts a 'Rewrite' over a 'Generic' into a rewrite over a specific expression type. 
 
 extractR  :: (Monad m, Term exp, Monoid dec) => Rewrite m dec (Generic exp) -> Rewrite m dec exp	-- at *this* type
 extractR rr = rewrite $ \ e -> transparently $ do
@@ -63,7 +63,12 @@
                 Nothing -> fail "extractR"
                 Just r -> return r
                 
--- | 'promote' promotes a 'Rewrite' into a 'Generic' 'Rewrite'; other types inside Generic cause failure.
+-- | 'extractU' converts a 'Translate' taking a 'Generic' into a translate over a specific expression type. 
+
+extractU  :: (Monad m, Term exp, Monoid dec) => Translate m dec (Generic exp) r -> Translate m dec exp r
+extractU rr = translate $ \ e -> transparently $ apply rr (inject e)
+
+-- | 'promoteR' promotes a 'Rewrite' into a 'Generic' 'Rewrite'; other types inside Generic cause failure.
 -- 'try' can be used to convert a failure-by-default promotion into a 'id-by-default' promotion.
 
 promoteR  :: (Monad m, Term exp, Monoid dec) => Rewrite m dec exp -> Rewrite m dec (Generic exp)
@@ -74,35 +79,38 @@
                     r <- apply rr e'
                     return (inject r)
 
--- | 'accept' 
+-- | 'promoteU' promotes a 'Translate' into a 'Generic' 'Translate'; other types inside Generic cause failure.
 
-extractU  :: (Monad m, Term exp, Monoid dec) => Translate m dec (Generic exp) r -> Translate m dec exp r
-extractU rr = translate $ \ e -> transparently $ apply rr (inject e)
+promoteU  :: (Monad m, Term exp, Monoid dec) => Translate m dec exp r -> Translate m dec (Generic exp) r
+promoteU rr = translate $ \ e -> transparently $ do
+               case select e of
+                 Nothing -> fail "promoteI"
+                 Just e' -> apply rr e'
 
 -------------------------------------------------------------------------------
 
 -- apply a rewrite in a top down manner.
-topdownR :: (e ~ Generic e, Walker m dec e) => Rewrite m dec e -> Rewrite m dec e
+topdownR :: (e ~ Generic e, Walker m dec e) => Rewrite m dec (Generic e) -> Rewrite m dec (Generic e)
 topdownR  s = s >-> allR (topdownR s)
 
 -- apply a rewrite in a bottom up manner.
-bottomupR :: (e ~ Generic e, Walker m dec e) => Rewrite m dec e -> Rewrite m dec e
+bottomupR :: (e ~ Generic e, Walker m dec e) => Rewrite m dec (Generic e) -> Rewrite m dec (Generic e)
 bottomupR s = allR (bottomupR s) >-> s
 
 -- apply a rewrite in a top down manner, prunning at successful rewrites.
-alltdR :: (e ~ Generic e, Walker m dec e) => Rewrite m dec e -> Rewrite m dec e
+alltdR :: (e ~ Generic e, Walker m dec e) => Rewrite m dec (Generic e) -> Rewrite m dec (Generic e)
 alltdR    s = s <+ allR (alltdR s)
 
 -- apply a rewrite twice, in a topdown and bottom up way, using one single tree traversal.
-downupR :: (e ~ Generic e, Walker m dec e) => Rewrite m dec e -> Rewrite m dec e
+downupR :: (e ~ Generic e, Walker m dec e) => Rewrite m dec (Generic e) -> Rewrite m dec (Generic e)
 downupR   s = s >-> allR (downupR s) >-> s
 
 -- a fixed point traveral, starting with the innermost term.
-innermostR :: (e ~ Generic e, Walker m dec e) => Rewrite m dec e -> Rewrite m dec e
+innermostR :: (e ~ Generic e, Walker m dec e) => Rewrite m dec (Generic e) -> Rewrite m dec (Generic e)
 innermostR s = bottomupR (tryR (s >-> innermostR s))  
 
 -- fold a tree using a single translation for each node.
-foldU :: (e ~ Generic e, Walker m dec e, Monoid r) => Translate m dec e r -> Translate m dec e r
+foldU :: (e ~ Generic e, Walker m dec e, Monoid r) => Translate m dec (Generic e) r -> Translate m dec (Generic e) r
 foldU s = concatT [ s, crushU (foldU s) ]
 
 -------------------------------------------------------------------------------
diff --git a/kure.cabal b/kure.cabal
--- a/kure.cabal
+++ b/kure.cabal
@@ -1,5 +1,5 @@
 Name:                kure
-Version:             0.2.2
+Version:             0.2.3
 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.
@@ -35,8 +35,9 @@
   Ghc-Options:  -Wall
 
 
+
 --Executable test1
---  Ghc-Options:     -fhpc
+--  Ghc-Options:     
 --  Main-Is:        Test.hs
 --  Hs-Source-Dirs: ., test
 --  buildable: True