diff --git a/Haxl/Core.hs b/Haxl/Core.hs
--- a/Haxl/Core.hs
+++ b/Haxl/Core.hs
@@ -43,7 +43,6 @@
   , Microseconds
   , Timestamp
   , emptyStats
-  , numRounds
   , numFetches
   , ppStats
   , ppFetchStats
diff --git a/Haxl/Core/Memo.hs b/Haxl/Core/Memo.hs
--- a/Haxl/Core/Memo.hs
+++ b/Haxl/Core/Memo.hs
@@ -307,8 +307,6 @@
 {-# RULES
 "memo/Text" memo = memoText :: (Typeable a) =>
             Text -> GenHaxl u a -> GenHaxl u a
-"memoUnique/Text" memoUnique = memoUniqueText :: (Typeable a) =>
-                  MemoFingerprintKey a -> Text -> GenHaxl u a -> GenHaxl u a
  #-}
 
 {-# NOINLINE memo #-}
@@ -317,8 +315,8 @@
 -- uniqueness across computations.
 memoUnique
   :: (Typeable a, Typeable k, Hashable k, Eq k)
-  => MemoFingerprintKey a -> k -> GenHaxl u a -> GenHaxl u a
-memoUnique fp key = memo (fp, key)
+  => MemoFingerprintKey a -> Text -> k -> GenHaxl u a -> GenHaxl u a
+memoUnique fp label key = withLabel label . memo (fp, key)
 
 {-# NOINLINE memoUnique #-}
 
@@ -345,16 +343,6 @@
 
 memoText :: (Typeable a) => Text -> GenHaxl u a -> GenHaxl u a
 memoText key = withLabel key . cachedComputation (MemoText key)
-
--- For Text keys, memoUnique is automatically rewritten to memoUniqueText,
--- due to the RULES pragma above.
-memoUniqueText
-  :: (Typeable a)
-  => MemoFingerprintKey a
-  -> Text
-  -> GenHaxl u a
-  -> GenHaxl u a
-memoUniqueText fp key = withLabel key . memo (fp, key)
 
 -- | A memo key derived from a 128-bit MD5 hash.  Do not use this directly,
 -- it is for use by automatically-generated memoization.
diff --git a/Haxl/Core/Monad.hs b/Haxl/Core/Monad.hs
--- a/Haxl/Core/Monad.hs
+++ b/Haxl/Core/Monad.hs
@@ -758,8 +758,13 @@
     cache <- readIORef ref
     showCache cache readIVar
 
+  let
+    body = if null entries
+      then text "return ()"
+      else vcat (map mk_cr (concatMap snd entries))
+
   return $ show $
     text (fnName ++ " :: " ++ fnType) $$
     text (fnName ++ " = do") $$
-      nest 2 (vcat (map mk_cr (concatMap snd entries))) $$
+      nest 2 body $$
     text "" -- final newline
diff --git a/Haxl/Core/StateStore.hs b/Haxl/Core/StateStore.hs
--- a/Haxl/Core/StateStore.hs
+++ b/Haxl/Core/StateStore.hs
@@ -24,6 +24,9 @@
 
 import Data.Map (Map)
 import qualified Data.Map.Strict as Map
+#if __GLASGOW_HASKELL__ < 804
+import Data.Monoid
+#endif
 import Data.Typeable
 import Unsafe.Coerce
 
@@ -46,6 +49,16 @@
 
 -- | The 'StateStore' maps a 'StateKey' to the 'State' for that type.
 newtype StateStore = StateStore (Map TypeRep StateStoreData)
+
+#if __GLASGOW_HASKELL__ >= 804
+instance Semigroup StateStore where
+  (<>) = mappend
+#endif
+
+instance Monoid StateStore where
+  mempty = stateEmpty
+  -- Left-biased union
+  mappend (StateStore m1) (StateStore m2) = StateStore $ m1 <> m2
 
 -- | Encapsulates the type of 'StateStore' data so we can have a
 -- heterogeneous collection.
diff --git a/Haxl/Core/Stats.hs b/Haxl/Core/Stats.hs
--- a/Haxl/Core/Stats.hs
+++ b/Haxl/Core/Stats.hs
@@ -23,7 +23,6 @@
   , Timestamp
   , getTimestamp
   , emptyStats
-  , numRounds
   , numFetches
   , ppStats
   , ppFetchStats
@@ -158,9 +157,6 @@
 
 emptyStats :: Stats
 emptyStats = Stats []
-
-numRounds :: Stats -> Int
-numRounds (Stats rs) = length rs        -- not really
 
 numFetches :: Stats -> Int
 numFetches (Stats rs) = sum [ fetchBatchSize | FetchStats{..} <- rs ]
diff --git a/changelog.md b/changelog.md
--- a/changelog.md
+++ b/changelog.md
@@ -1,3 +1,8 @@
+# Changes in version 2.0.1.1
+
+  * Support for GHC 8.6.1
+  * Bugfixes
+
 # Changes in version 2.0.1.0
 
   * Exported MemoVar from Haxl.Core.Memo
diff --git a/haxl.cabal b/haxl.cabal
--- a/haxl.cabal
+++ b/haxl.cabal
@@ -1,5 +1,5 @@
 name:                haxl
-version:             2.0.1.0
+version:             2.0.1.1
 synopsis:            A Haskell library for efficient, concurrent,
                      and concise data access.
 homepage:            https://github.com/facebook/Haxl
@@ -18,7 +18,7 @@
   GHC==7.10.3,
   GHC==8.0.2,
   GHC==8.2.2,
-  GHC==8.4.1
+  GHC==8.4.3
 
 description:
   Haxl is a library and EDSL for efficient scheduling of concurrent data
@@ -44,10 +44,10 @@
 
   build-depends:
     aeson >= 0.6 && < 1.5,
-    base == 4.*,
+    base >= 4.7 && < 5,
     binary >= 0.7 && < 0.10,
     bytestring >= 0.9 && < 0.11,
-    containers == 0.5.*,
+    containers >= 0.5 && < 0.7,
     deepseq,
     exceptions >=0.8 && <0.11,
     filepath >= 1.3 && < 1.5,
@@ -57,7 +57,7 @@
     -- text 1.2.1.0 required for instance Binary Text
     text >= 1.2.1.0 && < 1.3,
     time >= 1.4 && < 1.9,
-    stm == 2.4.*,
+    stm >= 2.4 && < 2.6,
     transformers,
     unordered-containers == 0.2.*,
     vector >= 0.10 && <0.13
@@ -104,7 +104,7 @@
   build-depends:
     aeson,
     HUnit >= 1.2 && < 1.7,
-    base == 4.*,
+    base >= 4.7 && < 5,
     binary,
     bytestring,
     containers,
diff --git a/readme.md b/readme.md
--- a/readme.md
+++ b/readme.md
@@ -18,7 +18,7 @@
 There are two Haskell packages here:
 
  * `haxl`: The core Haxl framework
- * `haxl-facebook` (in [example/facebook](example/facebook)): An (incomplete) example data source for accessing the Facebook Graph API
+ * `haxl-facebook` (in [https://github.com/facebook/Haxl/tree/master/example/facebook](example/facebook)): An (incomplete) example data source for accessing the Facebook Graph API
 
 To use Haxl in your own application, you will likely need to build one or more
 *data sources*: the thin layer between Haxl and the data that you want
@@ -54,6 +54,6 @@
  * [Haxl Documentation](http://hackage.haskell.org/package/haxl) on
    Hackage.
 
- * [There is no Fork: An Abstraction for Efficient, Concurrent, and Concise Data Access](http://community.haskell.org/~simonmar/papers/haxl-icfp14.pdf), our paper on Haxl, accepted for publication at ICFP'14.
+ * [There is no Fork: An Abstraction for Efficient, Concurrent, and Concise Data Access](http://simonmar.github.io/bib/papers/haxl-icfp14.pdf), our paper on Haxl, accepted for publication at ICFP'14.
 
 [![Build Status](https://travis-ci.org/facebook/Haxl.svg?branch=master)](https://travis-ci.org/facebook/Haxl)
diff --git a/tests/AdoTests.hs b/tests/AdoTests.hs
--- a/tests/AdoTests.hs
+++ b/tests/AdoTests.hs
@@ -21,14 +21,14 @@
 --
 -- Test ApplicativeDo batching
 --
-ado1 = expectRounds 1 12 ado1_
+ado1 = expectResult 12 ado1_
 
 ado1_ = do
   a <- friendsOf =<< id1
   b <- friendsOf =<< id2
   return (length (a ++ b))
 
-ado2 = expectRounds 1 12 ado2_
+ado2 = expectResult 12 ado2_
 
 ado2_ = do
   x <- id1
@@ -37,7 +37,7 @@
   b <- friendsOf y
   return (length (a ++ b))
 
-ado3 = expectRounds 2 11 ado3_
+ado3 = expectResult 11 ado3_
 
 ado3_ = do
   x <- id1
diff --git a/tests/BatchTests.hs b/tests/BatchTests.hs
--- a/tests/BatchTests.hs
+++ b/tests/BatchTests.hs
@@ -25,7 +25,7 @@
 --
 -- Test batching over multiple arguments in liftA2
 --
-batching1 = expectRounds 1 12 batching1_
+batching1 = expectResult 12 batching1_
 
 batching1_ = do
   a <- id1
@@ -35,7 +35,7 @@
 --
 -- Test batching in mapM (which is really traverse)
 --
-batching2 = expectRounds 1 12 batching2_
+batching2 = expectResult 12 batching2_
 
 batching2_ = do
   a <- id1
@@ -46,7 +46,7 @@
 --
 -- Test batching when we have a monadic bind in each branch
 --
-batching3 = expectRounds 1 12 batching3_
+batching3 = expectResult 12 batching3_
 
 batching3_ = do
   let a = id1 >>= friendsOf
@@ -56,7 +56,7 @@
 --
 -- Test batching over both arguments of (+)
 --
-batching4 = expectRounds 1 12 batching4_
+batching4 = expectResult 12 batching4_
 
 batching4_ = do
   let a = length <$> (id1 >>= friendsOf)
@@ -66,7 +66,7 @@
 --
 -- Test batching over both arguments of (+)
 --
-batching5 = expectRounds 1 2 batching5_
+batching5 = expectResult 2 batching5_
 
 batching5_ :: Haxl Int
 batching5_ = if a .> b then 1 else 2
@@ -77,14 +77,14 @@
 --
 -- Test batching when we perform all batching tests together with sequence
 --
-batching6 = expectRounds 1 [12,12,12,12,2] batching6_
+batching6 = expectResult [12,12,12,12,2] batching6_
 
 batching6_ = sequence [batching1_,batching2_,batching3_,batching4_,batching5_]
 
 --
 -- Ensure if/then/else and bool operators break batching
 --
-batching7 = expectRounds 2 12 batching7_
+batching7 = expectResult 12 batching7_
 
 batching7_ :: Haxl Int
 batching7_ = if a .> 0 then a+b else 0
@@ -93,7 +93,7 @@
   b = length <$> (id2 >>= friendsOf)
 
 -- We expect 3 rounds here due to boolean operators
-batching8 = expectRounds 3 12 batching8_
+batching8 = expectResult 12 batching8_
 
 batching8_ :: Haxl Int
 batching8_ = if (c .== 0) .|| (a .> 0 .&& b .> 0) then a+b else 0
@@ -103,7 +103,7 @@
   c = length <$> (id3 >>= friendsOf)
 
 -- (>>) should batch, so we expect one round
-batching9 = expectRounds 1 6 batching9_
+batching9 = expectResult 6 batching9_
 
 batching9_ :: Haxl Int
 batching9_ = (id1 >>= friendsOf) >> (length <$> (id2 >>= friendsOf))
@@ -135,7 +135,7 @@
 --
 cacheReuse future = do
   env <- makeTestEnv future
-  expectRoundsWithEnv 2 12 batching7_ env
+  expectResultWithEnv 12 batching7_ env
 
   -- make a new env
   tao <- MockTAO.initGlobalState future
@@ -143,7 +143,7 @@
   env2 <- initEnvWithData st testinput (caches env)
 
   -- ensure no more data fetching rounds needed
-  expectRoundsWithEnv 0 12 batching7_ env2
+  expectResultWithEnv 12 batching7_ env2
 
 noCaching future = do
   env <- makeTestEnv future
@@ -151,13 +151,12 @@
   result <- runHaxl env' caching3_
   assertEqual "result" result 18
   stats <- readIORef (statsRef env)
-  assertEqual "rounds" 2 (numRounds stats)
   assertEqual "fetches" 4 (numFetches stats)
 
-exceptionTest1 = expectRounds 1 []
+exceptionTest1 = expectResult []
   $ withDefault [] $ friendsOf 101
 
-exceptionTest2 = expectRounds 1 [7..12] $ liftA2 (++)
+exceptionTest2 = expectResult [7..12] $ liftA2 (++)
   (withDefault [] (friendsOf 101))
   (withDefault [] (friendsOf 2))
 
diff --git a/tests/TestUtils.hs b/tests/TestUtils.hs
--- a/tests/TestUtils.hs
+++ b/tests/TestUtils.hs
@@ -7,8 +7,8 @@
 {-# LANGUAGE OverloadedStrings #-}
 module TestUtils
   ( makeTestEnv
-  , expectRoundsWithEnv
-  , expectRounds
+  , expectResultWithEnv
+  , expectResult
   , expectFetches
   , testinput
   , id1, id2, id3, id4
@@ -53,18 +53,16 @@
   env <- initEnv st testinput
   return env { flags = (flags env) { report = 2 } }
 
-expectRoundsWithEnv
-  :: (Eq a, Show a) => Int -> a -> Haxl a -> Env UserEnv -> Assertion
-expectRoundsWithEnv n result haxl env = do
+expectResultWithEnv
+  :: (Eq a, Show a) => a -> Haxl a -> Env UserEnv -> Assertion
+expectResultWithEnv result haxl env = do
   a <- runHaxl env haxl
   assertEqual "result" result a
-  stats <- readIORef (statsRef env)
-  assertEqual "rounds" n (numRounds stats)
 
-expectRounds :: (Eq a, Show a) => Int -> a -> Haxl a -> Bool -> Assertion
-expectRounds n result haxl future = do
+expectResult :: (Eq a, Show a) => a -> Haxl a -> Bool -> Assertion
+expectResult result haxl future = do
   env <- makeTestEnv future
-  expectRoundsWithEnv n result haxl env
+  expectResultWithEnv result haxl env
 
 expectFetches :: (Eq a, Show a) => Int -> Haxl a -> Bool -> Assertion
 expectFetches n haxl future = do