diff --git a/result.cabal b/result.cabal
--- a/result.cabal
+++ b/result.cabal
@@ -1,5 +1,5 @@
 name:                result
-version:             0.2.2.0
+version:             0.2.3.0
 synopsis:            Encode success or at least one error
 homepage:            https://github.com/srijs/haskell-result
 license:             MIT
@@ -14,10 +14,13 @@
 
 library
   hs-source-dirs:      src
-  exposed-modules:     Data.Result
+  exposed-modules:     Data.Result,
+                       Control.Monad.Trans.Result
   build-depends:       base >= 4 && < 5,
                        bifunctors,
+                       mtl,
                        semigroups,
+                       transformers,
                        keys
   default-language:    Haskell2010
 
diff --git a/src/Control/Monad/Trans/Result.hs b/src/Control/Monad/Trans/Result.hs
new file mode 100644
--- /dev/null
+++ b/src/Control/Monad/Trans/Result.hs
@@ -0,0 +1,61 @@
+{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses, UndecidableInstances #-}
+
+module Control.Monad.Trans.Result
+  ( ResultT, runResultT
+  , raiseT, accumulateT
+  ) where
+
+
+import Control.Applicative (liftA2)
+import Control.Monad (join)
+import Control.Monad.Trans.Class
+import qualified Control.Monad.State.Class as State
+
+import Data.Functor.Identity
+import Data.Result
+
+
+data ResultT e m a = ResultT { runResultT :: m (Result e a) }
+
+
+instance Functor f => Functor (ResultT e f) where
+  fmap f (ResultT m) =
+    ResultT (fmap (fmap f) m)
+
+
+instance Applicative f => Applicative (ResultT e f) where
+  pure a =
+    ResultT (pure (pure a))
+
+  (ResultT mf) <*> (ResultT ma) =
+    ResultT $
+      liftA2 (<*>) mf ma
+
+
+instance Monad m => Monad (ResultT e m) where
+  return =
+    pure
+
+  (ResultT m) >>= f =
+    ResultT $
+      m >>= fmap join . traverse (runResultT . f)
+
+
+instance MonadTrans (ResultT e) where
+  lift m =
+    ResultT (pure <$> m)
+
+
+raiseT :: Applicative f => e -> ResultT e f a
+raiseT e =
+  ResultT (pure (raise e))
+
+
+accumulateT :: (Traversable t , Applicative f) => t (ResultT e f a) -> ResultT e f (t a)
+accumulateT results =
+  ResultT (accumulate <$> traverse runResultT results)
+
+
+instance State.MonadState s m => State.MonadState s (ResultT e m) where
+  state f =
+    ResultT (pure <$> State.state f)