diff --git a/cabal.project b/cabal.project
new file mode 100644
--- /dev/null
+++ b/cabal.project
@@ -0,0 +1,1 @@
+packages: .
diff --git a/changelog.md b/changelog.md
--- a/changelog.md
+++ b/changelog.md
@@ -1,5 +1,13 @@
 # Hashtables changelog
 
+## 1.2.3.2
+
+  - CPP fix for breakage caused by primitive 0.7 (thx Carter)
+
+  - Fix some haddock syntax errors (thx Frederik Hanghøj Iversen)
+
+  - Fix typo in module reference (thx Don Allen)
+
 ## 1.2.3.1
 
   - Fix building with GHC <7.10 (thx Vanessa McHale)
@@ -7,9 +15,9 @@
 ## 1.2.3.0
 
   - update for Semigroup/monoid breakage with GHC 8.4 (thx Fumiaki Kinoshita)
-  
+
   - Implement mutateST and mutateIO (thx Andy Morris)
-  
+
   - Fix build breakage w/ "pre" function (thx Andy Morris)
 
 ## 1.2.2.1
diff --git a/hashtables.cabal b/hashtables.cabal
--- a/hashtables.cabal
+++ b/hashtables.cabal
@@ -1,5 +1,5 @@
 Name:                hashtables
-Version:             1.2.3.1
+Version:             1.2.3.2
 Synopsis:            Mutable hash tables in the ST monad
 Homepage:            http://github.com/gregorycollins/hashtables
 License:             BSD3
@@ -29,7 +29,7 @@
        the table can perform acceptably well even when approaching 90% full.
        Randomized testing shows this implementation of cuckoo hashing to be
        slightly faster on insert and slightly slower on lookup than
-       "Data.Hashtable.ST.Basic", while being more space efficient by about a
+       "Data.HashTable.ST.Basic", while being more space efficient by about a
        half-word per key-value mapping. Cuckoo hashing, like the basic hash
        table implementation using linear probing, can suffer from long delays
        when the table is resized.
@@ -96,6 +96,7 @@
 
 Extra-Source-Files:
   README.md,
+  cabal.project,
   haddock.sh,
   benchmark/hashtable-benchmark.cabal,
   benchmark/LICENSE,
diff --git a/src/Data/HashTable/IO.hs b/src/Data/HashTable/IO.hs
--- a/src/Data/HashTable/IO.hs
+++ b/src/Data/HashTable/IO.hs
@@ -99,7 +99,7 @@
 
 
 ------------------------------------------------------------------------------
--- | See the documentation for this function in "Data.HashTable.Class#v:new".
+-- | See the documentation for this function in 'Data.HashTable.Class.new'.
 new :: C.HashTable h => IO (IOHashTable h k v)
 new = stToIO C.new
 {-# INLINE new #-}
@@ -109,7 +109,7 @@
 
 ------------------------------------------------------------------------------
 -- | See the documentation for this function in
--- "Data.HashTable.Class#v:newSized".
+-- 'Data.HashTable.Class.newSized'.
 newSized :: C.HashTable h => Int -> IO (IOHashTable h k v)
 newSized = stToIO . C.newSized
 {-# INLINE newSized #-}
@@ -119,7 +119,7 @@
 
 
 ------------------------------------------------------------------------------
--- | See the documentation for this function in "Data.HashTable.Class#v:insert".
+-- | See the documentation for this function in 'Data.HashTable.Class.insert'.
 insert   :: (C.HashTable h, Eq k, Hashable k) =>
             IOHashTable h k v -> k -> v -> IO ()
 insert h k v = stToIO $ C.insert h k v
@@ -133,7 +133,7 @@
 
 
 ------------------------------------------------------------------------------
--- | See the documentation for this function in "Data.HashTable.Class#v:delete".
+-- | See the documentation for this function in 'Data.HashTable.Class.delete'.
 delete   :: (C.HashTable h, Eq k, Hashable k) =>
             IOHashTable h k v -> k -> IO ()
 delete h k = stToIO $ C.delete h k
@@ -147,7 +147,7 @@
 
 
 ------------------------------------------------------------------------------
--- | See the documentation for this function in "Data.HashTable.Class#v:lookup".
+-- | See the documentation for this function in 'Data.HashTable.Class.lookup'.
 lookup   :: (C.HashTable h, Eq k, Hashable k) =>
             IOHashTable h k v -> k -> IO (Maybe v)
 lookup h k = stToIO $ C.lookup h k
@@ -160,7 +160,7 @@
                          CuckooHashTable k v -> k -> IO (Maybe v) #-}
 
 ------------------------------------------------------------------------------
--- | See the documentation for this function in "Data.HashTable.Class#v:lookupIndex".
+-- | See the documentation for this function in 'Data.HashTable.Class.lookupIndex'.
 lookupIndex   :: (C.HashTable h, Eq k, Hashable k) =>
                  IOHashTable h k v -> k -> IO (Maybe Word)
 lookupIndex h k = stToIO $ C.lookupIndex h k
@@ -173,7 +173,7 @@
                          CuckooHashTable k v -> k -> IO (Maybe Word) #-}
 
 ------------------------------------------------------------------------------
--- | See the documentation for this function in "Data.HashTable.Class#v:nextByIndex".
+-- | See the documentation for this function in 'Data.HashTable.Class.nextByIndex'.
 nextByIndex   :: (C.HashTable h, Eq k, Hashable k) =>
                  IOHashTable h k v -> Word -> IO (Maybe (Word,k,v))
 nextByIndex h k = stToIO $ C.nextByIndex h k
@@ -186,7 +186,7 @@
                          CuckooHashTable k v -> Word -> IO (Maybe (Word,k,v)) #-}
 
 ------------------------------------------------------------------------------
--- | See the documentation for this function in "Data.HashTable.Class#v:mutateST".
+-- | See the documentation for this function in 'Data.HashTable.Class.mutateST'.
 mutateIO   :: (C.HashTable h, Eq k, Hashable k) =>
               IOHashTable h k v -> k -> (Maybe v -> IO (Maybe v, a)) -> IO a
 mutateIO h k f = stToIO $ C.mutateST h k (ioToST . f)
@@ -199,7 +199,7 @@
                          CuckooHashTable k v -> k -> (Maybe v -> IO (Maybe v, a)) -> IO a #-}
 
 ------------------------------------------------------------------------------
--- | See the documentation for this function in "Data.HashTable.Class#v:mutate".
+-- | See the documentation for this function in 'Data.HashTable.Class.mutate'.
 mutate   :: (C.HashTable h, Eq k, Hashable k) =>
             IOHashTable h k v -> k -> (Maybe v -> (Maybe v, a)) -> IO a
 mutate h k f = stToIO $ C.mutate h k f
@@ -214,7 +214,7 @@
 
 ------------------------------------------------------------------------------
 -- | See the documentation for this function in
--- "Data.HashTable.Class#v:fromList".
+-- 'Data.HashTable.Class.fromList'.
 fromList :: (C.HashTable h, Eq k, Hashable k) =>
             [(k,v)] -> IO (IOHashTable h k v)
 fromList = stToIO . C.fromList
@@ -229,7 +229,7 @@
 
 ------------------------------------------------------------------------------
 -- | See the documentation for this function in
--- "Data.HashTable.Class#v:fromListWithSizeHint".
+-- 'Data.HashTable.Class.fromListWithSizeHint'.
 fromListWithSizeHint :: (C.HashTable h, Eq k, Hashable k) =>
                         Int -> [(k,v)] -> IO (IOHashTable h k v)
 fromListWithSizeHint n = stToIO . C.fromListWithSizeHint n
@@ -243,7 +243,7 @@
 
 
 ------------------------------------------------------------------------------
--- | See the documentation for this function in "Data.HashTable.Class#v:toList".
+-- | See the documentation for this function in 'Data.HashTable.Class.toList'.
 toList   :: (C.HashTable h, Eq k, Hashable k) =>
             IOHashTable h k v -> IO [(k,v)]
 toList = stToIO . C.toList
@@ -257,7 +257,7 @@
 
 
 ------------------------------------------------------------------------------
--- | See the documentation for this function in "Data.HashTable.Class#v:foldM".
+-- | See the documentation for this function in 'Data.HashTable.Class.foldM'.
 foldM :: (C.HashTable h) =>
          (a -> (k,v) -> IO a)
       -> a
@@ -275,7 +275,7 @@
 
 
 ------------------------------------------------------------------------------
--- | See the documentation for this function in "Data.HashTable.Class#v:mapM_".
+-- | See the documentation for this function in 'Data.HashTable.Class.mapM_'.
 mapM_ :: (C.HashTable h) => ((k,v) -> IO a) -> IOHashTable h k v -> IO ()
 mapM_ f ht = stToIO $ C.mapM_ f' ht
   where
@@ -291,7 +291,7 @@
 
 ------------------------------------------------------------------------------
 -- | See the documentation for this function in
--- "Data.HashTable.Class#v:computeOverhead".
+-- 'Data.HashTable.Class.computeOverhead'.
 computeOverhead :: (C.HashTable h) => IOHashTable h k v -> IO Double
 computeOverhead = stToIO . C.computeOverhead
 {-# INLINE computeOverhead #-}
diff --git a/src/Data/HashTable/Internal/IntArray.hs b/src/Data/HashTable/Internal/IntArray.hs
--- a/src/Data/HashTable/Internal/IntArray.hs
+++ b/src/Data/HashTable/Internal/IntArray.hs
@@ -112,4 +112,8 @@
 toPtr :: IntArray s -> Ptr a
 toPtr (IA a) = Ptr a#
   where
+#if MIN_VERSION_primitive(0,7,0)
+    !(Ptr !a#) = A.mutableByteArrayContents a
+#else
     !(Addr !a#) = A.mutableByteArrayContents a
+#endif
diff --git a/src/Data/HashTable/ST/Basic.hs b/src/Data/HashTable/ST/Basic.hs
--- a/src/Data/HashTable/ST/Basic.hs
+++ b/src/Data/HashTable/ST/Basic.hs
@@ -185,7 +185,7 @@
 
 ------------------------------------------------------------------------------
 -- | See the documentation for this function in
--- "Data.HashTable.Class#v:new".
+-- 'Data.HashTable.Class.new'.
 new :: ST s (HashTable s k v)
 new = newSized 1
 {-# INLINE new #-}
@@ -193,7 +193,7 @@
 
 ------------------------------------------------------------------------------
 -- | See the documentation for this function in
--- "Data.HashTable.Class#v:newSized".
+-- 'Data.HashTable.Class.newSized'.
 newSized :: Int -> ST s (HashTable s k v)
 newSized n = do
     debug $ "entering: newSized " ++ show n
@@ -219,7 +219,7 @@
 
 ------------------------------------------------------------------------------
 -- | See the documentation for this function in
--- "Data.HashTable.Class#v:delete".
+-- 'Data.HashTable.Class.delete'.
 delete :: (Hashable k, Eq k) =>
           (HashTable s k v)
        -> k
@@ -235,7 +235,7 @@
 
 ------------------------------------------------------------------------------
 -- | See the documentation for this function in
--- "Data.HashTable.Class#v:lookup".
+-- 'Data.HashTable.Class.lookup'.
 lookup :: (Eq k, Hashable k) => (HashTable s k v) -> k -> ST s (Maybe v)
 lookup htRef !k = do
     ht <- readRef htRef
@@ -287,7 +287,7 @@
 
 ------------------------------------------------------------------------------
 -- | See the documentation for this function in
--- "Data.HashTable.Class#v:insert".
+-- 'Data.HashTable.Class.insert'.
 insert :: (Eq k, Hashable k) =>
           (HashTable s k v)
        -> k
@@ -312,7 +312,7 @@
 
 ------------------------------------------------------------------------------
 -- | See the documentation for this function in
--- "Data.HashTable.Class#v:mutate".
+-- 'Data.HashTable.Class.mutate'.
 mutate :: (Eq k, Hashable k) =>
           (HashTable s k v)
        -> k
@@ -324,7 +324,7 @@
 
 ------------------------------------------------------------------------------
 -- | See the documentation for this function in
--- "Data.HashTable.Class#v:mutateST".
+-- 'Data.HashTable.Class.mutateST'.
 mutateST :: (Eq k, Hashable k) =>
             (HashTable s k v)
          -> k
@@ -362,7 +362,7 @@
 
 ------------------------------------------------------------------------------
 -- | See the documentation for this function in
--- "Data.HashTable.Class#v:foldM".
+-- 'Data.HashTable.Class.foldM'.
 foldM :: (a -> (k,v) -> ST s a) -> a -> HashTable s k v -> ST s a
 foldM f seed0 htRef = readRef htRef >>= work
   where
@@ -382,7 +382,7 @@
 
 ------------------------------------------------------------------------------
 -- | See the documentation for this function in
--- "Data.HashTable.Class#v:mapM_".
+-- 'Data.HashTable.Class.mapM_'.
 mapM_ :: ((k,v) -> ST s b) -> HashTable s k v -> ST s ()
 mapM_ f htRef = readRef htRef >>= work
   where
@@ -402,7 +402,7 @@
 
 ------------------------------------------------------------------------------
 -- | See the documentation for this function in
--- "Data.HashTable.Class#v:computeOverhead".
+-- 'Data.HashTable.Class.computeOverhead'.
 computeOverhead :: HashTable s k v -> ST s Double
 computeOverhead htRef = readRef htRef >>= work
   where
diff --git a/src/Data/HashTable/ST/Cuckoo.hs b/src/Data/HashTable/ST/Cuckoo.hs
--- a/src/Data/HashTable/ST/Cuckoo.hs
+++ b/src/Data/HashTable/ST/Cuckoo.hs
@@ -149,7 +149,7 @@
 
 ------------------------------------------------------------------------------
 -- | See the documentation for this function in
--- "Data.HashTable.Class#v:new".
+-- 'Data.HashTable.Class.new'.
 new :: ST s (HashTable s k v)
 new = newSizedReal 2 >>= newRef
 {-# INLINE new #-}
@@ -157,7 +157,7 @@
 
 ------------------------------------------------------------------------------
 -- | See the documentation for this function in
--- "Data.HashTable.Class#v:newSized".
+-- 'Data.HashTable.Class.newSized'.
 newSized :: Int -> ST s (HashTable s k v)
 newSized n = do
     let n' = (n + numElemsInCacheLine - 1) `div` numElemsInCacheLine
@@ -168,7 +168,7 @@
 
 ------------------------------------------------------------------------------
 -- | See the documentation for this function in
--- "Data.HashTable.Class#v:insert".
+-- 'Data.HashTable.Class.insert'.
 insert :: (Eq k, Hashable k) => HashTable s k v -> k -> v -> ST s ()
 insert ht !k !v = readRef ht >>= \h -> insert' h k v >>= writeRef ht
 
@@ -199,7 +199,7 @@
 
 ------------------------------------------------------------------------------
 -- | See the documentation for this function in
--- "Data.HashTable.Class#v:computeOverhead".
+-- 'Data.HashTable.Class.computeOverhead'.
 computeOverhead :: HashTable s k v -> ST s Double
 computeOverhead htRef = readRef htRef >>= work
   where
@@ -222,7 +222,7 @@
 
 ------------------------------------------------------------------------------
 -- | See the documentation for this function in
--- "Data.HashTable.Class#v:delete".
+-- 'Data.HashTable.Class.delete'.
 delete :: (Hashable k, Eq k) =>
           HashTable s k v
        -> k
@@ -243,7 +243,7 @@
 
 ------------------------------------------------------------------------------
 -- | See the documentation for this function in
--- "Data.HashTable.Class#v:lookup".
+-- 'Data.HashTable.Class.lookup'.
 lookup :: (Eq k, Hashable k) =>
           HashTable s k v
        -> k
@@ -321,7 +321,7 @@
 
 ------------------------------------------------------------------------------
 -- | See the documentation for this function in
--- "Data.HashTable.Class#v:foldM".
+-- 'Data.HashTable.Class.foldM'.
 foldM :: (a -> (k,v) -> ST s a)
       -> a
       -> HashTable s k v
@@ -356,7 +356,7 @@
 
 ------------------------------------------------------------------------------
 -- | See the documentation for this function in
--- "Data.HashTable.Class#v:mapM_".
+-- 'Data.HashTable.Class.mapM_'.
 mapM_ :: ((k,v) -> ST s a)
       -> HashTable s k v
       -> ST s ()