diff --git a/hw-fingertree-strict.cabal b/hw-fingertree-strict.cabal
--- a/hw-fingertree-strict.cabal
+++ b/hw-fingertree-strict.cabal
@@ -1,5 +1,5 @@
 name:                   hw-fingertree-strict
-version:                0.1.0.0
+version:                0.1.0.1
 -- synopsis:
 -- description:
 homepage:               https://github.com/githubuser/hw-fingertree-strict#readme
@@ -39,6 +39,8 @@
                       , HaskellWorks.Data.Segment.Strict
   build-depends:        base >= 4.7 && < 5
   default-language:     Haskell2010
+  if !impl(ghc >= 8.0)
+    build-depends: semigroups == 0.18.*
 
 test-suite hw-fingertree-strict-test
   type: exitcode-stdio-1.0
diff --git a/src/HaskellWorks/Data/FingerTree/Strict.hs b/src/HaskellWorks/Data/FingerTree/Strict.hs
--- a/src/HaskellWorks/Data/FingerTree/Strict.hs
+++ b/src/HaskellWorks/Data/FingerTree/Strict.hs
@@ -68,6 +68,8 @@
 import Data.Foldable       (Foldable (foldMap), foldr', toList)
 import Data.Monoid
 
+import qualified Data.Semigroup as S
+
 infixr 5 ><
 infixr 5 <|, :<
 infixl 5 |>, :>
@@ -93,10 +95,16 @@
     fmap _ EmptyR    = EmptyR
     fmap f (xs :> x) = fmap f xs :> f x
 
+instance Measured v a => S.Semigroup (FingerTree v a) where
+  (<>) = (><)
+  {-# INLINE (<>) #-}
+
 -- | 'empty' and '><'.
 instance Measured v a => Monoid (FingerTree v a) where
-    mempty = empty
-    mappend = (><)
+  mempty = empty
+  {-# INLINE mempty #-}
+  mappend = (<>)
+  {-# INLINE mappend #-}
 
 -- Explicit Digit type (Exercise 1)
 
diff --git a/src/HaskellWorks/Data/IntervalMap/Strict.hs b/src/HaskellWorks/Data/IntervalMap/Strict.hs
--- a/src/HaskellWorks/Data/IntervalMap/Strict.hs
+++ b/src/HaskellWorks/Data/IntervalMap/Strict.hs
@@ -44,14 +44,15 @@
     search, intersections, dominators
     ) where
 
-import           HaskellWorks.Data.FingerTree.Strict (FingerTree, Measured (..), ViewL (..), (<|), (><))
-import qualified HaskellWorks.Data.FingerTree.Strict as FT
-
-import Control.Applicative ((<$>))
-import Data.Foldable       (Foldable (foldMap))
+import Control.Applicative                 ((<$>))
+import Data.Foldable                       (Foldable (foldMap))
 import Data.Monoid
-import Data.Traversable    (Traversable (traverse))
+import Data.Traversable                    (Traversable (traverse))
+import HaskellWorks.Data.FingerTree.Strict (FingerTree, Measured (..), ViewL (..), (<|), (><))
 
+import qualified Data.Semigroup                      as S
+import qualified HaskellWorks.Data.FingerTree.Strict as FT
+
 ----------------------------------
 -- 4.8 Application: interval trees
 ----------------------------------
@@ -79,12 +80,17 @@
 -- rightmost interval (including largest lower bound) and largest upper bound.
 data IntInterval v = NoInterval | IntInterval !(Interval v) !v
 
+instance Ord v => S.Semigroup (IntInterval v) where
+  NoInterval        <> i                    = i
+  i                 <> NoInterval           = i
+  IntInterval _ hi1 <> IntInterval int2 hi2 = IntInterval int2 (max hi1 hi2)
+  {-# INLINE (<>) #-}
+
 instance Ord v => Monoid (IntInterval v) where
-    mempty = NoInterval
-    NoInterval `mappend` i  = i
-    i `mappend` NoInterval  = i
-    IntInterval _ hi1 `mappend` IntInterval int2 hi2 =
-        IntInterval int2 (max hi1 hi2)
+  mempty = NoInterval
+  {-# INLINE mempty #-}
+  mappend = (<>)
+  {-# INLINE mappend #-}
 
 instance (Ord v) => Measured (IntInterval v) (Node v a) where
     measure (Node i _) = IntInterval i (high i)
@@ -106,10 +112,16 @@
     traverse f (IntervalMap t) =
         IntervalMap <$> FT.unsafeTraverse (traverse f) t
 
+instance (Ord v) => S.Semigroup (IntervalMap v a) where
+  (<>) = union
+  {-# INLINE (<>) #-}
+
 -- | 'empty' and 'union'.
 instance (Ord v) => Monoid (IntervalMap v a) where
     mempty = empty
-    mappend = union
+    {-# INLINE mempty #-}
+    mappend = (<>)
+    {-# INLINE mappend #-}
 
 -- | /O(1)/.  The empty interval map.
 empty :: (Ord v) => IntervalMap v a
diff --git a/src/HaskellWorks/Data/PriorityQueue/Strict.hs b/src/HaskellWorks/Data/PriorityQueue/Strict.hs
--- a/src/HaskellWorks/Data/PriorityQueue/Strict.hs
+++ b/src/HaskellWorks/Data/PriorityQueue/Strict.hs
@@ -54,14 +54,15 @@
     minViewWithKey
     ) where
 
-import           HaskellWorks.Data.FingerTree.Strict (FingerTree, Measured (..), ViewL (..), (<|), (><), (|>))
-import qualified HaskellWorks.Data.FingerTree.Strict as FT
-
-import Control.Arrow ((***))
-import Data.Foldable (Foldable (foldMap))
+import Control.Arrow                       ((***))
+import Data.Foldable                       (Foldable (foldMap))
 import Data.Monoid
-import Prelude       hiding (null)
+import HaskellWorks.Data.FingerTree.Strict (FingerTree, Measured (..), ViewL (..), (<|), (><), (|>))
+import Prelude                             hiding (null)
 
+import qualified Data.Semigroup                      as S
+import qualified HaskellWorks.Data.FingerTree.Strict as FT
+
 data Entry k v = Entry k v
 
 instance Functor (Entry k) where
@@ -72,13 +73,17 @@
 
 data Prio k v = NoPrio | Prio k v
 
+instance Ord k => S.Semigroup (Prio k v) where
+  x             <> NoPrio         = x
+  NoPrio        <> y              = y
+  x@(Prio kx _) <> y@(Prio ky _)  = if kx <= ky then x else y
+  {-# INLINE (<>) #-}
+
 instance Ord k => Monoid (Prio k v) where
-    mempty                  = NoPrio
-    x `mappend` NoPrio      = x
-    NoPrio `mappend` y      = y
-    x@(Prio kx _) `mappend` y@(Prio ky _)
-      | kx <= ky            = x
-      | otherwise           = y
+    mempty  = NoPrio
+    {-# INLINE mempty #-}
+    mappend = (<>)
+    {-# INLINE mappend #-}
 
 instance Ord k => Measured (Prio k v) (Entry k v) where
     measure (Entry k v) = Prio k v
@@ -94,9 +99,15 @@
         Nothing      -> mempty
         Just (v, q') -> f v `mappend` foldMap f q'
 
+instance Ord k => S.Semigroup (PQueue k v) where
+  (<>) = union
+  {-# INLINE (<>) #-}
+
 instance Ord k => Monoid (PQueue k v) where
-    mempty = empty
-    mappend = union
+  mempty = empty
+  {-# INLINE mempty #-}
+  mappend = (<>)
+  {-# INLINE mappend #-}
 
 -- | /O(1)/. The empty priority queue.
 empty :: Ord k => PQueue k v