diff --git a/CHANGELOG.markdown b/CHANGELOG.markdown
--- a/CHANGELOG.markdown
+++ b/CHANGELOG.markdown
@@ -1,9 +1,17 @@
+4.3.4
+-----
+* Support `bifunctors` 5, `profunctors` 5, and `semigroupoids` 5.
+
+4.3.3.3
+-------
+* Fixed and enhanced documentation for `eitherToError`.
+
 4.3.3.2
-------
+-------
 * Support `exceptions` 0.8
 
 4.3.3.1
-------
+-------
 * Support `exceptions` 0.7
 
 4.3.3
diff --git a/either.cabal b/either.cabal
--- a/either.cabal
+++ b/either.cabal
@@ -1,6 +1,6 @@
 name:          either
 category:      Control, Monads
-version:       4.3.3.2
+version:       4.3.4
 license:       BSD3
 cabal-version: >= 1.6
 license-file:  LICENSE
@@ -28,15 +28,15 @@
 library
   build-depends:
     base              >= 4       && < 5,
-    bifunctors        >= 4       && < 5,
+    bifunctors        >= 4       && < 6,
     exceptions        >= 0.5     && < 0.9,
     free              >= 4.9     && < 5,
     monad-control     >= 0.3.2   && < 1.1,
     MonadRandom       >= 0.1     && < 0.4,
     mtl               >= 2.0     && < 2.3,
-    profunctors       >= 4       && < 5,
+    profunctors       >= 4       && < 6,
     semigroups        >= 0.8.3.1 && < 1,
-    semigroupoids     >= 4       && < 5,
+    semigroupoids     >= 4       && < 6,
     transformers      >= 0.2     && < 0.5,
     transformers-base >= 0.4     && < 0.5
 
diff --git a/src/Control/Monad/Trans/Either.hs b/src/Control/Monad/Trans/Either.hs
--- a/src/Control/Monad/Trans/Either.hs
+++ b/src/Control/Monad/Trans/Either.hs
@@ -27,8 +27,11 @@
   , bimapEitherT
   , mapEitherT
   , hoistEither
+  , bracketEitherT
+  , bracketEitherT_
   , left
   , right
+  , swapEitherT
   ) where
 
 import Control.Applicative
@@ -46,6 +49,7 @@
 import Control.Monad.Trans.Control (MonadBaseControl(..), MonadTransControl(..), defaultLiftBaseWith, defaultRestoreM)
 import Control.Monad.Writer.Class
 import Control.Monad.Random (MonadRandom,getRandom,getRandoms,getRandomR,getRandomRs)
+import Data.Either.Combinators ( swapEither )
 import Data.Foldable
 import Data.Function (on)
 import Data.Functor.Bind
@@ -126,6 +130,34 @@
 hoistEither :: Monad m => Either e a -> EitherT e m a
 hoistEither = EitherT . return
 {-# INLINE hoistEither #-}
+
+-- | Acquire a resource in 'EitherT' and then perform an action with it,
+-- cleaning up afterwards regardless of error. Like
+-- 'Control.Exception.bracket', but acting only in 'EitherT'.
+bracketEitherT :: Monad m => EitherT e m a -> (a -> EitherT e m b) -> (a -> EitherT e m c) -> EitherT e m c
+bracketEitherT before after thing = do
+    a <- before
+    r <- thing a `catchError` (\err -> after a >> left err)
+    -- If catchError already triggered, then `after` already ran *and* we are
+    -- in a Left state, so `after` will not run again here.
+    _ <- after a
+    return r
+
+-- | Version of 'bracketEitherT' which discards the result from the initial
+-- action.
+bracketEitherT_ :: Monad m => EitherT e m a -> EitherT e m b -> EitherT e m c -> EitherT e m c
+bracketEitherT_ before after thing = do
+    _ <- before
+    r <- thing `catchError` (\err -> after >> left err)
+    -- If catchError already triggered, then `after` already ran *and* we are
+    -- in a Left state, so `after` will not run again here.
+    _ <- after
+    return r
+
+-- | Monad transformer version of 'swapEither'.
+swapEitherT :: (Functor m) => EitherT e m a -> EitherT a m e
+swapEitherT = EitherT . fmap swapEither . runEitherT
+{-# INLINE swapEitherT #-}
 
 instance Monad m => Functor (EitherT e m) where
   fmap f = EitherT . liftM (fmap f) . runEitherT
diff --git a/src/Data/Either/Combinators.hs b/src/Data/Either/Combinators.hs
--- a/src/Data/Either/Combinators.hs
+++ b/src/Data/Either/Combinators.hs
@@ -33,6 +33,7 @@
   , leftToMaybe
   , rightToMaybe
   , eitherToError
+  , swapEither
   ) where
 
 import Control.Applicative
@@ -305,6 +306,23 @@
 rightToMaybe :: Either a b -> Maybe b
 rightToMaybe = either (const Nothing) Just
 
--- | Generalize 'Either e' as 'MonadError e m'.
+
+-- | Generalize @Either e@ as @MonadError e m@.
+--
+-- If the argument has form @Left e@, an error is produced in the monad via
+-- 'throwError'. Otherwise, the @Right a@ part is forwarded.
 eitherToError :: (MonadError e m) => Either e a -> m a
 eitherToError = either throwError return
+
+-- | Swap the 'Left' and 'Right' sides of an 'Either'.
+--
+-- @
+-- >>> swapEither (Right 3)
+-- Left 3
+--
+-- >>> swapEither (Left "error")
+-- Right "error"
+-- @
+swapEither :: Either e a -> Either a e
+swapEither = either Right Left
+{-# INLINE swapEither #-}