diff --git a/hashtables.cabal b/hashtables.cabal
--- a/hashtables.cabal
+++ b/hashtables.cabal
@@ -1,5 +1,5 @@
 Name:                hashtables
-Version:             1.1.0.0
+Version:             1.1.0.1
 Synopsis:            Mutable hash tables in the ST monad
 Homepage:            http://github.com/gregorycollins/hashtables
 License:             BSD3
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
@@ -92,6 +92,9 @@
 new :: C.HashTable h => IO (IOHashTable h k v)
 new = stToIO C.new
 {-# INLINE new #-}
+{-# SPECIALIZE INLINE new :: IO (BasicHashTable k v) #-}
+{-# SPECIALIZE INLINE new :: IO (LinearHashTable k v) #-}
+{-# SPECIALIZE INLINE new :: IO (CuckooHashTable k v) #-}
 
 ------------------------------------------------------------------------------
 -- | See the documentation for this function in
@@ -99,6 +102,9 @@
 newSized :: C.HashTable h => Int -> IO (IOHashTable h k v)
 newSized = stToIO . C.newSized
 {-# INLINE newSized #-}
+{-# SPECIALIZE INLINE newSized :: Int -> IO (BasicHashTable k v) #-}
+{-# SPECIALIZE INLINE newSized :: Int -> IO (LinearHashTable k v) #-}
+{-# SPECIALIZE INLINE newSized :: Int -> IO (CuckooHashTable k v) #-}
 
 
 ------------------------------------------------------------------------------
@@ -107,6 +113,12 @@
             IOHashTable h k v -> k -> v -> IO ()
 insert h k v = stToIO $ C.insert h k v
 {-# INLINE insert #-}
+{-# SPECIALIZE INLINE insert :: (Eq k, Hashable k) =>
+                         BasicHashTable  k v -> k -> v -> IO () #-}
+{-# SPECIALIZE INLINE insert :: (Eq k, Hashable k) =>
+                         LinearHashTable k v -> k -> v -> IO () #-}
+{-# SPECIALIZE INLINE insert :: (Eq k, Hashable k) =>
+                         CuckooHashTable k v -> k -> v -> IO () #-}
 
 
 ------------------------------------------------------------------------------
@@ -115,6 +127,12 @@
             IOHashTable h k v -> k -> IO ()
 delete h k = stToIO $ C.delete h k
 {-# INLINE delete #-}
+{-# SPECIALIZE INLINE delete :: (Eq k, Hashable k) =>
+                         BasicHashTable  k v -> k -> IO () #-}
+{-# SPECIALIZE INLINE delete :: (Eq k, Hashable k) =>
+                         LinearHashTable k v -> k -> IO () #-}
+{-# SPECIALIZE INLINE delete :: (Eq k, Hashable k) =>
+                         CuckooHashTable k v -> k -> IO () #-}
 
 
 ------------------------------------------------------------------------------
@@ -123,6 +141,12 @@
             IOHashTable h k v -> k -> IO (Maybe v)
 lookup h k = stToIO $ C.lookup h k
 {-# INLINE lookup #-}
+{-# SPECIALIZE INLINE lookup :: (Eq k, Hashable k) =>
+                         BasicHashTable  k v -> k -> IO (Maybe v) #-}
+{-# SPECIALIZE INLINE lookup :: (Eq k, Hashable k) =>
+                         LinearHashTable k v -> k -> IO (Maybe v) #-}
+{-# SPECIALIZE INLINE lookup :: (Eq k, Hashable k) =>
+                         CuckooHashTable k v -> k -> IO (Maybe v) #-}
 
 
 ------------------------------------------------------------------------------
@@ -132,6 +156,12 @@
             [(k,v)] -> IO (IOHashTable h k v)
 fromList = stToIO . C.fromList
 {-# INLINE fromList #-}
+{-# SPECIALIZE INLINE fromList :: (Eq k, Hashable k) =>
+                           [(k,v)] -> IO (BasicHashTable  k v) #-}
+{-# SPECIALIZE INLINE fromList :: (Eq k, Hashable k) =>
+                           [(k,v)] -> IO (LinearHashTable k v) #-}
+{-# SPECIALIZE INLINE fromList :: (Eq k, Hashable k) =>
+                           [(k,v)] -> IO (CuckooHashTable k v) #-}
 
 
 ------------------------------------------------------------------------------
@@ -149,6 +179,12 @@
             IOHashTable h k v -> IO [(k,v)]
 toList = stToIO . C.toList
 {-# INLINE toList #-}
+{-# SPECIALIZE INLINE toList :: (Eq k, Hashable k) =>
+                         BasicHashTable  k v -> IO [(k,v)] #-}
+{-# SPECIALIZE INLINE toList :: (Eq k, Hashable k) =>
+                         LinearHashTable k v -> IO [(k,v)] #-}
+{-# SPECIALIZE INLINE toList :: (Eq k, Hashable k) =>
+                         CuckooHashTable k v -> IO [(k,v)] #-}
 
 
 ------------------------------------------------------------------------------
@@ -161,6 +197,12 @@
   where
     f' !i !t = unsafeIOToST $ f i t
 {-# INLINE foldM #-}
+{-# SPECIALIZE INLINE foldM :: (a -> (k,v) -> IO a) -> a
+                            -> BasicHashTable  k v -> IO a #-}
+{-# SPECIALIZE INLINE foldM :: (a -> (k,v) -> IO a) -> a
+                            -> LinearHashTable k v -> IO a #-}
+{-# SPECIALIZE INLINE foldM :: (a -> (k,v) -> IO a) -> a
+                            -> CuckooHashTable k v -> IO a #-}
 
 
 ------------------------------------------------------------------------------
@@ -170,6 +212,12 @@
   where
     f' = unsafeIOToST . f
 {-# INLINE mapM_ #-}
+{-# SPECIALIZE INLINE mapM_ :: ((k,v) -> IO a) -> BasicHashTable  k v
+                            -> IO () #-}
+{-# SPECIALIZE INLINE mapM_ :: ((k,v) -> IO a) -> LinearHashTable k v
+                            -> IO () #-}
+{-# SPECIALIZE INLINE mapM_ :: ((k,v) -> IO a) -> CuckooHashTable k v
+                            -> IO () #-}
 
 
 ------------------------------------------------------------------------------