diff --git a/changelog.md b/changelog.md
--- a/changelog.md
+++ b/changelog.md
@@ -1,7 +1,12 @@
 # Changelog for [`multistate` package](https://hackage.haskell.org/package/multistate)
 
-** 0.8.0.0 *April 2018*
+## 0.8.0.1 *October 2018*
 
+  * Adapt for ghc-8.6 (really, this time)
+  * Make package -Wcompat-ible
+
+## 0.8.0.0 *April 2018*
+
   * Adapt for ghc-8.4
   * Drop support for ghc<8.0
   * Add class `MonadMultiGet` that roughly translates to "any read access"
@@ -9,7 +14,7 @@
   * Add data-type `MultiGST` that has a single taggified HList instead of the
     three r, w, s lists with `MultiRWS`
 
-** 0.7.1.2 *August 2017*
+## 0.7.1.2 *August 2017*
 
   * Adapt for ghc-8.2
   
diff --git a/multistate.cabal b/multistate.cabal
--- a/multistate.cabal
+++ b/multistate.cabal
@@ -1,10 +1,10 @@
 Name:          multistate
-Version:       0.8.0.0
+Version:       0.8.0.1
 Cabal-Version: >= 1.10
 Build-Type:    Simple
 license:       BSD3
 license-file:  LICENSE
-Copyright:     Copyright (C) 2013-2017 Jan Bracker, 2013-2016 Lennart Spitzner
+Copyright:     Copyright (C) 2013 Jan Bracker, 2013-2018 Lennart Spitzner
 Maintainer:    Lennart Spitzner <hexagoxel@hexagoxel.de>
 Author:        Jan Bracker, Lennart Spitzner
 Homepage:      https://github.com/lspitzner/multistate
@@ -69,7 +69,7 @@
   other-modules:
     Control.Monad.Trans.MultiGST.Common
   build-depends:
-    base         >= 4.9   && <4.12,
+    base         >= 4.9   && <4.13,
     mtl          >= 2.1   && <2.3,
     transformers >= 0.3   && <0.6,
     tagged       >= 0.7   && <0.9,
@@ -84,6 +84,7 @@
     UndecidableInstances
     TypeOperators
     DataKinds
+    LambdaCase
   ghc-options: {
     -Wall
     -fno-warn-unused-imports
@@ -106,7 +107,7 @@
     multistate,
     base <999,
     transformers <0.6,
-    hspec >=2 && <2.5
+    hspec >=2 && <2.6
   ghc-options:      -Wall
   main-is:          Test.hs
   hs-source-dirs:   test
diff --git a/src/Control/Monad/Trans/MultiGST/Common.hs b/src/Control/Monad/Trans/MultiGST/Common.hs
--- a/src/Control/Monad/Trans/MultiGST/Common.hs
+++ b/src/Control/Monad/Trans/MultiGST/Common.hs
@@ -132,7 +132,7 @@
 
 instance Monoid (HListM '[]) where
   mempty = HNilM
-  mappend _ _ = HNilM
+  mappend = (<>)
 
 instance Eq (HListM '[]) where
   HNilM == HNilM = True
diff --git a/src/Control/Monad/Trans/MultiRWS/Lazy.hs b/src/Control/Monad/Trans/MultiRWS/Lazy.hs
--- a/src/Control/Monad/Trans/MultiRWS/Lazy.hs
+++ b/src/Control/Monad/Trans/MultiRWS/Lazy.hs
@@ -386,18 +386,18 @@
 withMultiStates_ (x :+: xs) = withMultiStates_ xs . withMultiState_ x
 
 withoutMultiReader :: Monad m => MultiRWST rs w s m a -> MultiRWST (r ': rs) w s m a
-withoutMultiReader k = MultiRWST $ do
-  (rs@(_ :+: rr), w, s) <- get
-  ~(a, ~(_, w', s')) <- lift $ runStateT (runMultiRWSTRaw k) (rr, w, s)
-  put (rs, w', s')
-  return a
+withoutMultiReader k = MultiRWST $ get >>= \case
+  (rs@(_ :+: rr), w, s) -> do
+    ~(a, ~(_, w', s')) <- lift $ runStateT (runMultiRWSTRaw k) (rr, w, s)
+    put (rs, w', s')
+    return a
 
 withoutMultiState :: Monad m => MultiRWST r w ss m a -> MultiRWST r w (s ': ss) m a
-withoutMultiState k = MultiRWST $ do
-  (r, w, s :+: sr) <- get
-  ~(a, ~(_, w', s')) <- lift $ runStateT (runMultiRWSTRaw k) (r, w, sr)
-  put (r, w', s :+: s')
-  return a
+withoutMultiState k = MultiRWST $ get >>= \case
+  (r, w, s :+: sr) -> do
+    ~(a, ~(_, w', s')) <- lift $ runStateT (runMultiRWSTRaw k) (r, w, sr)
+    put (r, w', s :+: s')
+    return a
 
 inflateReader :: (Monad m, ContainsType r rs)
               => ReaderT r m a
diff --git a/src/Control/Monad/Trans/MultiRWS/Strict.hs b/src/Control/Monad/Trans/MultiRWS/Strict.hs
--- a/src/Control/Monad/Trans/MultiRWS/Strict.hs
+++ b/src/Control/Monad/Trans/MultiRWS/Strict.hs
@@ -388,18 +388,18 @@
 withMultiStates_ (x :+: xs) = withMultiStates_ xs . withMultiState_ x
 
 withoutMultiReader :: Monad m => MultiRWST rs w s m a -> MultiRWST (r ': rs) w s m a
-withoutMultiReader k = MultiRWST $ do
-  (rs@(_ :+: rr), w, s) <- get
-  (a, (_, w', s')) <- lift $ runStateT (runMultiRWSTRaw k) (rr, w, s)
-  put (rs, w', s')
-  return a
+withoutMultiReader k = MultiRWST $ get >>= \case
+  (rs@(_ :+: rr), w, s) -> do
+    (a, (_, w', s')) <- lift $ runStateT (runMultiRWSTRaw k) (rr, w, s)
+    put (rs, w', s')
+    return a
 
 withoutMultiState :: Monad m => MultiRWST r w ss m a -> MultiRWST r w (s ': ss) m a
-withoutMultiState k = MultiRWST $ do
-  (r, w, s :+: sr) <- get
-  (a, (_, w', s')) <- lift $ runStateT (runMultiRWSTRaw k) (r, w, sr)
-  put (r, w', s :+: s')
-  return a
+withoutMultiState k = MultiRWST $ get >>= \case
+  (r, w, s :+: sr) -> do
+    (a, (_, w', s')) <- lift $ runStateT (runMultiRWSTRaw k) (r, w, sr)
+    put (r, w', s :+: s')
+    return a
 
 inflateReader :: (Monad m, ContainsType r rs)
               => ReaderT r m a
diff --git a/src/Control/Monad/Trans/MultiReader/Lazy.hs b/src/Control/Monad/Trans/MultiReader/Lazy.hs
--- a/src/Control/Monad/Trans/MultiReader/Lazy.hs
+++ b/src/Control/Monad/Trans/MultiReader/Lazy.hs
@@ -186,9 +186,8 @@
 withMultiReaders_ (x :+: xs) = withMultiReaders_ xs . withMultiReader_ x
 
 withoutMultiReader :: Monad m => MultiReaderT rs m a -> MultiReaderT (r ': rs) m a
-withoutMultiReader k = MultiReaderT $ do
-  _ :+: rr <- get
-  lift $ runMultiReaderT rr k
+withoutMultiReader k = MultiReaderT $ get >>= \case
+  (_ :+: rr) -> lift $ runMultiReaderT rr k
 
 inflateReader :: (Monad m, ContainsType r rs)
               => ReaderT r m a
diff --git a/src/Control/Monad/Trans/MultiReader/Strict.hs b/src/Control/Monad/Trans/MultiReader/Strict.hs
--- a/src/Control/Monad/Trans/MultiReader/Strict.hs
+++ b/src/Control/Monad/Trans/MultiReader/Strict.hs
@@ -186,9 +186,8 @@
 withMultiReaders_ (x :+: xs) = withMultiReaders_ xs . withMultiReader_ x
 
 withoutMultiReader :: Monad m => MultiReaderT rs m a -> MultiReaderT (r ': rs) m a
-withoutMultiReader k = MultiReaderT $ do
-  _ :+: rr <- get
-  lift $ runMultiReaderT rr k
+withoutMultiReader k = MultiReaderT $ get >>= \case
+  (_ :+: rr) -> lift $ runMultiReaderT rr k
 
 inflateReader :: (Monad m, ContainsType r rs)
               => ReaderT r m a
diff --git a/src/Control/Monad/Trans/MultiState/Lazy.hs b/src/Control/Monad/Trans/MultiState/Lazy.hs
--- a/src/Control/Monad/Trans/MultiState/Lazy.hs
+++ b/src/Control/Monad/Trans/MultiState/Lazy.hs
@@ -239,11 +239,11 @@
 withMultiStates_ (x :+: xs)  = withMultiStates_ xs . withMultiState_ x
 
 withoutMultiState :: (Functor m, Monad m) => MultiStateT ss m a -> MultiStateT (s ': ss) m a
-withoutMultiState k = MultiStateT $ do
-  s :+: sr <- get
-  ~(a, sr') <- lift $ runMultiStateT sr k
-  put (s :+: sr')
-  return a
+withoutMultiState k = MultiStateT $ get >>= \case
+  s :+: sr -> do
+    ~(a, sr') <- lift $ runMultiStateT sr k
+    put (s :+: sr')
+    return a
 
 inflateState :: (Monad m, ContainsType s ss)
              => StateT s m a
diff --git a/src/Control/Monad/Trans/MultiState/Strict.hs b/src/Control/Monad/Trans/MultiState/Strict.hs
--- a/src/Control/Monad/Trans/MultiState/Strict.hs
+++ b/src/Control/Monad/Trans/MultiState/Strict.hs
@@ -237,11 +237,11 @@
 withMultiStates_ (x :+: xs)  = withMultiStates_ xs . withMultiState_ x
 
 withoutMultiState :: (Functor m, Monad m) => MultiStateT ss m a -> MultiStateT (s ': ss) m a
-withoutMultiState k = MultiStateT $ do
-  s :+: sr <- get
-  (a, sr') <- lift $ runMultiStateT sr k
-  put (s :+: sr')
-  return a
+withoutMultiState k = MultiStateT $ get >>= \case
+  s :+: sr -> do
+    (a, sr') <- lift $ runMultiStateT sr k
+    put (s :+: sr')
+    return a
 
 inflateState :: (Monad m, ContainsType s ss)
              => StateT s m a
diff --git a/src/Data/HList/HList.hs b/src/Data/HList/HList.hs
--- a/src/Data/HList/HList.hs
+++ b/src/Data/HList/HList.hs
@@ -52,13 +52,12 @@
 
 instance Monoid (HList '[]) where
   mempty = HNil
-  mappend _ _ = HNil
-instance (Monoid x, Monoid (HList xs))
+  mappend = (<>)
+instance (Semigroup x, Monoid x, Semigroup (HList xs), Monoid (HList xs))
       => Monoid (HList (x ': xs))
   where
     mempty = mempty :+: mempty
-    mappend (x1 :+: xs1) (x2 :+: xs2) = (x1 `mappend` x2)
-                                    :+: (xs1 `mappend` xs2)
+    mappend = (<>)
 
 instance Eq (HList '[]) where
   HNil == HNil = True
diff --git a/test/Test.hs b/test/Test.hs
--- a/test/Test.hs
+++ b/test/Test.hs
@@ -12,6 +12,8 @@
 import Data.Functor.Identity
 import Data.HList.HList
 import Data.Monoid
+import Data.Semigroup
+
 import qualified Control.Monad.Trans.MultiState as MS
 import qualified Control.Monad.Trans.MultiReader as MR
 import qualified Control.Monad.Trans.MultiWriter as MW
@@ -35,7 +37,7 @@
 runnerMS x m = runEvalMS $ MS.withMultiStateA x m
 runnerMR :: a -> MR.MultiReaderT '[a] Identity a -> a
 runnerMR x m = runEvalMR $ MR.withMultiReader x m
-runnerMW :: Monoid a => MW.MultiWriterT '[a] Identity b -> a
+runnerMW :: (Semigroup a, Monoid a) => MW.MultiWriterT '[a] Identity b -> a
 runnerMW m = case runExecMW m of (x :+: _) -> x
 -- TODO: ghc bug?: warning on:
 -- runnerMW m = case runExecMW m of (x :+: HNil) -> x