diff --git a/expiring-containers.cabal b/expiring-containers.cabal
--- a/expiring-containers.cabal
+++ b/expiring-containers.cabal
@@ -1,7 +1,7 @@
 name:
   expiring-containers
 version:
-  0.1.0.2
+  0.1.1.1
 synopsis:
   Expiring containers
 category:
@@ -49,5 +49,5 @@
     hashable >=1.2 && <2,
     timestamp >=0.2 && <0.3,
     containers >=0.5.10 && <0.5.15,
-    int-multimap >=0.1 && <0.2,
+    int-multimap >=0.2 && <0.3,
     unordered-containers >=0.2.8.0 && <0.3
diff --git a/library/ExpiringContainers/ExpiringMap.hs b/library/ExpiringContainers/ExpiringMap.hs
--- a/library/ExpiringContainers/ExpiringMap.hs
+++ b/library/ExpiringContainers/ExpiringMap.hs
@@ -1,21 +1,27 @@
 module ExpiringContainers.ExpiringMap
-  where
+(
+  ExpiringMap,
+  insert,
+  lookup,
+  setCurrentTime,
+)
+where
 
-import ExpiringContainers.ExpiringSet as A
-import Data.HashMap.Strict as B
+import qualified ExpiringContainers.ExpiringSet as A
+import qualified Data.HashMap.Strict as B
 import Data.Time
 import Data.Maybe
-import Prelude
+import Prelude hiding (lookup)
 import Data.Hashable
-import Data.List
+import qualified Data.List as C
 
 {-|
 
 -}
 data ExpiringMap key value =
   ExpiringMap
-    (ExpiringSet key)
-    (HashMap key value)
+    (A.ExpiringSet key)
+    (B.HashMap key value)
 
 insert :: (Eq key, Ord key, Hashable key) => UTCTime {-^ Expiry time -} -> key -> value -> ExpiringMap key value -> ExpiringMap key value
 insert time key value (ExpiringMap expSet hashMap) =
@@ -30,4 +36,4 @@
   ExpiringMap newExpSet newHashMap
     where
       (keys, newExpSet) = A.clean time expSet
-      newHashMap = Data.List.foldl' (flip B.delete) hashMap keys
+      newHashMap = C.foldl' (flip B.delete) hashMap keys
diff --git a/library/ExpiringContainers/ExpiringSet.hs b/library/ExpiringContainers/ExpiringSet.hs
--- a/library/ExpiringContainers/ExpiringSet.hs
+++ b/library/ExpiringContainers/ExpiringSet.hs
@@ -1,27 +1,97 @@
 module ExpiringContainers.ExpiringSet
-  where
+(
+  ExpiringSet,
+  -- * Construction
+  empty,
+  singleton,
 
-import Data.HashMap.Strict as A
-import IntMultiMap as B
-import Data.HashSet as C
+  -- * List
+  toList,
+  fromList,
+
+  -- * Transformations
+  map,
+
+  -- * Basic interface
+  null,
+  insert,
+  member,
+  memberTime,
+  size,
+
+  -- * Filter
+  clean,
+)
+where
+
+import qualified Data.HashMap.Strict as A
+import qualified IntMultimap as B
+import qualified Data.HashSet as C
+import qualified Data.Foldable as D
+import qualified GHC.Exts as G
 import Data.Time
 import Data.Int
-import Prelude
+import Prelude hiding(map, null)
+import GHC.Generics
 import Timestamp
 import Data.Hashable
-import Data.Foldable
 
 {-|
-
+Set that expiring with time
 -}
 data ExpiringSet element =
   ExpiringSet
     {-| Elements indexed by timestamps -}
-    (IntMultiMap element)
+    (B.IntMultiMap element)
     {-| Timestamps indexed by elements -}
-    (HashMap element Int)
+    (A.HashMap element Int)
+    deriving(Eq, Show, Generic)
 
 
+
+{--------------------------------------------------------------------
+  Transformations
+--------------------------------------------------------------------}
+map :: (Eq b, Hashable b) => (a -> b) -> ExpiringSet a -> ExpiringSet b
+map f (ExpiringSet intMultiMap _) = construct $ B.map f intMultiMap
+{-# INLINE map #-}
+
+construct :: (Eq a, Hashable a) => B.IntMultiMap a -> ExpiringSet a
+construct intMultiMap = ExpiringSet intMultiMap $
+  A.fromList $ fmap (\(k, v) -> (v, k)) (B.toList intMultiMap)
+
+{--------------------------------------------------------------------
+  Lists
+--------------------------------------------------------------------}
+instance (Eq a, Hashable a) => G.IsList (ExpiringSet a) where
+  type Item (ExpiringSet a) = (Int, a)
+  toList = toList
+  fromList = fromList
+
+toList :: ExpiringSet b -> [(Int, b)]
+toList (ExpiringSet intMultiMap _) = B.toList intMultiMap
+
+fromList :: (Eq a, Hashable a) =>
+     [(Int, a)] -> ExpiringSet a
+fromList = construct . B.fromList
+
+{--------------------------------------------------------------------
+  Construction
+--------------------------------------------------------------------}
+empty :: (Eq a, Hashable a) => ExpiringSet a
+empty = ExpiringSet B.empty A.empty
+
+singleton :: (Eq a, Hashable a) => Int -> a -> ExpiringSet a
+singleton k v = construct $ B.singleton k v
+{-# INLINABLE singleton #-}
+
+
+{--------------------------------------------------------------------
+  Filter
+--------------------------------------------------------------------}
+{-|
+Clean expiringset
+-}
 clean :: (Hashable element, Ord element) => UTCTime -> ExpiringSet element -> ([element], ExpiringSet element)
 clean time (ExpiringSet intMultiMap hashMap) =
   (listElem, ExpiringSet newMultiMap newHash)
@@ -29,8 +99,27 @@
     key = fromIntegral $ (timestampMicroSecondsInt64 . utcTimeTimestamp) time
     newHash = A.filterWithKey (\_ k -> k >= key) hashMap
     (oldMultiMap, newMultiMap) = (B.split key intMultiMap)
-    listElem = Data.Foldable.toList oldMultiMap
+    listElem = D.toList oldMultiMap
 
+{--------------------------------------------------------------------
+  Basic interface
+--------------------------------------------------------------------}
+null :: ExpiringSet a -> Bool
+null (ExpiringSet _ hashMap) = A.null hashMap
+{-# INLINE null #-}
+
+size :: ExpiringSet a -> Int
+size (ExpiringSet _ hashMap) = A.size hashMap
+
+member :: (Eq a, Hashable a) => a -> ExpiringSet a -> Bool
+member a (ExpiringSet _ hashMap) = A.member a hashMap
+
+memberTime :: Int -> ExpiringSet a -> Bool
+memberTime key (ExpiringSet intMultiMap _) = B.member key intMultiMap
+
+{-|
+
+-}
 insert :: (Hashable element, Ord element) => UTCTime {-^ Expiry time -} -> element -> ExpiringSet element -> ExpiringSet element
 insert time value (ExpiringSet intMultiMap hashMap) =
   ExpiringSet newMultiMap (A.insert value key hashMap)