diff --git a/result.cabal b/result.cabal
--- a/result.cabal
+++ b/result.cabal
@@ -1,5 +1,5 @@
 name:                result
-version:             0.2.5.0
+version:             0.2.5.1
 synopsis:            Encode success or at least one error
 homepage:            https://github.com/srijs/haskell-result
 license:             MIT
@@ -19,7 +19,6 @@
   build-depends:       base >= 4 && < 5,
                        bifunctors,
                        mtl,
-                       semigroups,
                        transformers,
                        keys
   default-language:    Haskell2010
diff --git a/src/Data/Result.hs b/src/Data/Result.hs
--- a/src/Data/Result.hs
+++ b/src/Data/Result.hs
@@ -13,20 +13,19 @@
 import Data.Bifoldable
 import Data.Bitraversable
 import Data.Key
-import qualified Data.List.NonEmpty as NonEmpty
 import Data.Monoid
 
 
 newtype Result e a =
-    Result (Either (NonEmpty.NonEmpty e) a)
+    Result (Either (e, [e]) a)
   deriving (Eq, Ord, Show, Functor, Applicative, Monad, Foldable)
 
 
 instance Traversable (Result e) where
-  traverse f (Result e) =
-    case e of
-      Left es ->
-        pure (Result (Left es))
+  traverse f (Result x) =
+    case x of
+      Left (e, es) ->
+        pure (Result (Left (e, es)))
       Right a ->
         Result . Right <$> f a
 
@@ -36,40 +35,44 @@
     case (mea, meb) of
       (Result (Right eaa), Result (Right eba)) ->
         Result (Right (f eaa eba))
-      _ ->
-        Result (Left (NonEmpty.fromList (errors mea <> errors meb)))
+      (Result (Left (e, es)), Result (Left (e', es'))) ->
+        Result (Left (e, es ++ e' : es'))
+      (Result (Left ees), _) ->
+        Result (Left ees)
+      (_, Result (Left ees)) ->
+        Result (Left ees)
 
 
 instance Bifunctor Result where
-  bimap f g (Result e) =
-    case e of
-      Left es ->
-        Result (Left (fmap f es))
+  bimap f g (Result x) =
+    case x of
+      Left (e, es) ->
+        Result (Left (f e, fmap f es))
       Right a ->
         Result (Right (g a))
 
 
 instance Bifoldable Result where
-  bifoldMap f g (Result e) =
-    case e of
-      Left es ->
-        foldMap f es
+  bifoldMap f g (Result x) =
+    case x of
+      Left (e, es) ->
+        f e <> foldMap f es
       Right a ->
         g a
 
 
 instance Bitraversable Result where
-  bitraverse f g (Result e) =
-    case e of
-      Left es ->
-        Result . Left <$> traverse f es
+  bitraverse f g (Result x) =
+    case x of
+      Left (e, es) ->
+        (\e' es' -> Result (Left (e', es'))) <$> f e <*> traverse f es
       Right a ->
         Result . Right <$> g a
 
 
 raise :: e -> Result e a
 raise e =
-  Result (Left (e NonEmpty.:| []))
+  Result (Left (e, []))
 
 
 raiseAll :: [e] -> Result e ()
@@ -78,7 +81,7 @@
     [] ->
       Right ()
     (e:es') ->
-      Left (e NonEmpty.:| es')
+      Left (e, es')
 
 
 get :: Result e a -> Maybe a
@@ -91,10 +94,10 @@
 
 
 errors :: Result e a -> [e]
-errors (Result e) =
-  case e of
-    Left es ->
-      NonEmpty.toList es
+errors (Result x) =
+  case x of
+    Left (e, es) ->
+      e:es
     Right _ ->
       []
 
@@ -103,7 +106,7 @@
 fromEither eith =
   Result $ case eith of
     Left e ->
-      Left (e NonEmpty.:| [])
+      Left (e, [])
     Right a ->
       Right a