diff --git a/Network/DnsCache.hs b/Network/DnsCache.hs
--- a/Network/DnsCache.hs
+++ b/Network/DnsCache.hs
@@ -111,43 +111,43 @@
 dnsCache :: NominalDiffTime -> MVar (CacheCmd res) -> IO ()
 dnsCache timeout cmdVar =
     evalStateT M.empty . forever $ do
-        cmd <- io $ takeMVar cmdVar
+        cmd <- liftIO $ takeMVar cmdVar
         case cmd of
           CacheGet dom waiter -> do
               mCache <- getField (M.lookup dom)
               case mCache of
-                Nothing       -> io $ waiter Nothing
-                Just NotFound -> io $ waiter Nothing
-                Just (Resolved _ res) -> io $ waiter (Just res)
+                Nothing       -> liftIO $ waiter Nothing
+                Just NotFound -> liftIO $ waiter Nothing
+                Just (Resolved _ res) -> liftIO $ waiter (Just res)
                 Just (Resolving ws) ->
                     modify (M.insert dom (Resolving (waiter:ws)))
 
-          CacheQuit c -> io c >> abort ()
+          CacheQuit c -> liftIO c >> abort ()
 
           CacheRequest dom c -> do
               mCache <- getField (M.lookup dom)
-              curTime <- io getCurrentTime
+              curTime <- liftIO getCurrentTime
               case mCache of
-                Just (Resolving _) -> io $ c False
+                Just (Resolving _) -> liftIO $ c False
                 Just (Resolved time _) | diffUTCTime curTime time < timeout ->
-                    io $ c False
+                    liftIO $ c False
                 _ -> do
                     modify (M.insert dom (Resolving []))
-                    io $ c True
+                    liftIO $ c True
 
           CacheSetNotFound dom -> do
               mCache <- getField (M.lookup dom)
               case mCache of
-                Just (Resolving cs) -> io $ mapM_ ($ Nothing) cs
+                Just (Resolving cs) -> liftIO $ mapM_ ($ Nothing) cs
                 _                   -> return ()
               modify (M.insert dom NotFound)
 
           CacheSetResolved dom res -> do
               mCache <- getField (M.lookup dom)
               case mCache of
-                Just (Resolving cs) -> io $ mapM_ ($ Just res) cs
+                Just (Resolving cs) -> liftIO $ mapM_ ($ Just res) cs
                 _                   -> return ()
-              curTime <- io getCurrentTime
+              curTime <- liftIO getCurrentTime
               modify (M.insert dom (Resolved curTime res))
 
 
@@ -159,20 +159,20 @@
     resultVar <- newEmptyMVar
     massResolver dns mtype domains resultVar
     execStateT M.empty . replicateM_ numDomains $ do
-        m@(MassResult dom _ _ _) <- io $ takeMVar resultVar
+        m@(MassResult dom _ _ _) <- liftIO $ takeMVar resultVar
         modify (M.insert dom m)
 
 
 -- | Perform a mass lookup with report function.
 
 massLookupReport ::
-    (Base m ~ IO, LiftBase m, Monad m) =>
+    MonadIO m =>
     DnsCache -> MassType -> [Domain] -> (MassResult -> m ()) -> m ()
 massLookupReport dns mtype domains rep = do
     let numDomains = length domains
-    resultVar <- io newEmptyMVar
-    io $ massResolver dns mtype domains resultVar
-    replicateM_ numDomains $ io (takeMVar resultVar) >>= rep
+    resultVar <- liftIO newEmptyMVar
+    liftIO $ massResolver dns mtype domains resultVar
+    replicateM_ numDomains $ liftIO (takeMVar resultVar) >>= rep
 
 
 -- | Mass resolver.
@@ -260,10 +260,10 @@
     seed <- makeResolvSeed defaultResolvConf
     withResolver seed $ \resolver ->
         evalContT . forever $ do
-            cmd <- io $ takeMVar cmdVar
+            cmd <- liftIO $ takeMVar cmdVar
             case cmd of
               Resolve dom' cacheVar dnsLookup waiter ->
-                  io $ do
+                  liftIO $ do
                       let dom = map toLower dom'
                       mayResVar <- newEmptyMVar
                       putMVar cacheVar (CacheRequest dom (putMVar mayResVar))
@@ -284,7 +284,7 @@
                             putMVar cacheVar (CacheGet dom (putMVar resVar))
                             takeMVar resVar >>= waiter
 
-              ResolverQuit c -> io c >> abort ()
+              ResolverQuit c -> liftIO c >> abort ()
 
 
 -- | Start a DNS cache with the given number of resolver threads and the
diff --git a/dnscache.cabal b/dnscache.cabal
--- a/dnscache.cabal
+++ b/dnscache.cabal
@@ -1,5 +1,5 @@
 Name:          dnscache
-Version:       0.1.1
+Version:       0.1.2
 Category:      Network
 Synopsis:      Caching DNS resolver library and mass DNS resolver utility
 Maintainer:    Ertugrul Söylemez <es@ertes.de>
@@ -19,7 +19,7 @@
     Build-depends:
         base >= 4 && <= 5,
         containers >= 0.3.0.0,
-        contstuff >= 0.7.0,
+        contstuff >= 1.0.0,
         dns >= 0.1.0,
         iproute >= 1.2.0,
         time >= 1.1.4