diff --git a/enumerator.cabal b/enumerator.cabal
--- a/enumerator.cabal
+++ b/enumerator.cabal
@@ -1,5 +1,5 @@
 name: enumerator
-version: 0.2
+version: 0.2.1
 synopsis: Implementation of Oleg Kiselyov's left-fold enumerators
 license: MIT
 license-file: license.txt
diff --git a/hs/Data/Enumerator.hs b/hs/Data/Enumerator.hs
--- a/hs/Data/Enumerator.hs
+++ b/hs/Data/Enumerator.hs
@@ -26,6 +26,7 @@
 	, continue
 	, throwError
 	, catchError
+	, mapError
 	, liftI
 	, (>>==)
 	, (==<<)
@@ -70,6 +71,7 @@
 import Control.Monad (liftM, ap)
 import qualified Control.Monad.IO.Class as MIO
 import qualified Control.Monad.Trans.Class as MT
+import Control.Monad.Fix (fix)
 import qualified Data.List as DataList
 import Control.Monad (foldM)
 import qualified Control.Exception as E
@@ -214,23 +216,31 @@
 	case step of
 		Error err -> runIteratee (h err)
 		_ -> return step
+-- | A pseudo-'Enumerator' which alters the error representation of its
+-- iteratee. Use this to compose enumerators and iteratees with differing
+-- or sub-optimal error types.
+mapError :: Monad m => (e1 -> e2) -> Step e1 a m b -> Iteratee e2 a m b
+mapError conv = fix $ \loop s -> case s of
+	Yield x chunks -> yield x chunks
+	Continue k ->  continue ((loop $$) . k)
+	Error err -> throwError (conv err)
 infixl 1 >>==
 
 -- | Equivalent to (>>=), but allows 'Iteratee's with different input types
 -- to be composed.
 (>>==) :: Monad m =>
 	Iteratee e a m b ->
-	(Step e a m b -> Iteratee e a' m b') ->
-	Iteratee e a' m b'
+	(Step e a m b -> Iteratee e' a' m b') ->
+	Iteratee e' a' m b'
 i >>== f = Iteratee $ runIteratee i >>= runIteratee . f
 {-# INLINE (>>==) #-}
 infixr 1 ==<<
 
 -- | @(==\<\<) = flip (\>\>==)@
 (==<<):: Monad m =>
-	(Step e a m b -> Iteratee e a' m b') ->
+	(Step e a m b -> Iteratee e' a' m b') ->
 	Iteratee e a m b ->
-	Iteratee e a' m b'
+	Iteratee e' a' m b'
 (==<<) = flip (>>==)
 {-# INLINE (==<<) #-}
 infixr 0 $$
@@ -240,9 +250,9 @@
 -- This might be easier to read when passing a chain of iteratees to an
 -- enumerator.
 ($$):: Monad m =>
-	(Step e a m b -> Iteratee e a' m b') ->
+	(Step e a m b -> Iteratee e' a' m b') ->
 	Iteratee e a m b ->
-	Iteratee e a' m b'
+	Iteratee e' a' m b'
 ($$) = (==<<)
 {-# INLINE ($$) #-}
 infixr 1 >==>
@@ -250,19 +260,19 @@
 -- | @(>==>) e1 e2 s = e1 s >>== e2@
 (>==>) :: Monad m =>
 	Enumerator e a m b ->
-	(Step e a m b -> Iteratee e a' m b') ->
+	(Step e a m b -> Iteratee e' a' m b') ->
 	Step e a m b ->
-	Iteratee e a' m b'
+	Iteratee e' a' m b'
 (>==>) e1 e2 s = e1 s >>== e2
 {-# INLINE (>==>) #-}
 infixr 1 <==<
 
 -- | @(\<==\<) = flip (>==>)@
 (<==<) :: Monad m =>
-	(Step e a m b -> Iteratee e a' m b') ->
+	(Step e a m b -> Iteratee e' a' m b') ->
 	Enumerator e a m b ->
 	Step e a m b ->
-	Iteratee e a' m b'
+	Iteratee e' a' m b'
 (<==<) = flip (>==>)
 {-# INLINE (<==<) #-}
 -- | Consume all input until 'EOF', then return consumed input as a list.