Add keysSet

* Add `keysSet`

* Rearrange modules to make things work.

Author: treeowl

CHANGES.md

@@ -2,6 +2,8 @@
 
  * Add `HashMap.alterF`.
 
+ * Add `HashMap.keysSet`.
+
 ## 0.2.9.0
 
  * Add `Ord/Ord1/Ord2` instances. (Thanks, Oleg Grenrus)

Data/HashMap/Lazy.hs

@@ -34,10 +34,10 @@ module Data.HashMap.Lazy
     , singleton
 
       -- * Basic interface
-    , HM.null
+    , null
     , size
     , member
-    , HM.lookup
+    , lookup
     , lookupDefault
     , (!)
     , insert
@@ -56,7 +56,7 @@ module Data.HashMap.Lazy
     , unions
 
       -- * Transformations
-    , HM.map
+    , map
     , mapWithKey
     , traverseWithKey
 
@@ -70,11 +70,11 @@ module Data.HashMap.Lazy
       -- * Folds
     , foldl'
     , foldlWithKey'
-    , HM.foldr
+    , foldr
     , foldrWithKey
 
       -- * Filter
-    , HM.filter
+    , filter
     , filterWithKey
     , mapMaybe
     , mapMaybeWithKey
@@ -87,9 +87,14 @@ module Data.HashMap.Lazy
     , toList
     , fromList
     , fromListWith
+
+      -- ** HashSets
+    , HS.keysSet
     ) where
 
 import Data.HashMap.Base as HM
+import qualified Data.HashSet.Base as HS
+import Prelude ()
 
 -- $strictness
 --

Data/HashMap/Strict.hs

@@ -0,0 +1,96 @@
+{-# LANGUAGE Safe #-}
+
+------------------------------------------------------------------------
+-- |
+-- Module      :  Data.HashMap.Strict
+-- Copyright   :  2010-2012 Johan Tibell
+-- License     :  BSD-style
+-- Maintainer  :  johan.tibell@gmail.com
+-- Stability   :  provisional
+-- Portability :  portable
+--
+-- A map from /hashable/ keys to values.  A map cannot contain
+-- duplicate keys; each key can map to at most one value.  A 'HashMap'
+-- makes no guarantees as to the order of its elements.
+--
+-- The implementation is based on /hash array mapped tries/.  A
+-- 'HashMap' is often faster than other tree-based set types,
+-- especially when key comparison is expensive, as in the case of
+-- strings.
+--
+-- Many operations have a average-case complexity of /O(log n)/.  The
+-- implementation uses a large base (i.e. 16) so in practice these
+-- operations are constant time.
+module Data.HashMap.Strict
+    (
+      -- * Strictness properties
+      -- $strictness
+
+      HashMap
+
+      -- * Construction
+    , empty
+    , singleton
+
+      -- * Basic interface
+    , null
+    , size
+    , member
+    , lookup
+    , lookupDefault
+    , (!)
+    , insert
+    , insertWith
+    , delete
+    , adjust
+    , update
+    , alter
+    , alterF
+
+      -- * Combine
+      -- ** Union
+    , union
+    , unionWith
+    , unionWithKey
+    , unions
+
+      -- * Transformations
+    , map
+    , mapWithKey
+    , traverseWithKey
+
+      -- * Difference and intersection
+    , difference
+    , differenceWith
+    , intersection
+    , intersectionWith
+    , intersectionWithKey
+
+      -- * Folds
+    , foldl'
+    , foldlWithKey'
+    , foldr
+    , foldrWithKey
+
+      -- * Filter
+    , filter
+    , filterWithKey
+    , mapMaybe
+    , mapMaybeWithKey
+
+      -- * Conversions
+    , keys
+    , elems
+
+      -- ** Lists
+    , toList
+    , fromList
+    , fromListWith
+
+      -- ** HashSets
+    , HS.keysSet
+    ) where
+
+import Data.HashMap.Strict.Base as HM
+import qualified Data.HashSet.Base as HS
+import Prelude ()

Data/HashMap/Strict/Base.hs

@@ -23,7 +23,7 @@
 -- Many operations have a average-case complexity of /O(log n)/.  The
 -- implementation uses a large base (i.e. 16) so in practice these
 -- operations are constant time.
-module Data.HashMap.Strict
+module Data.HashMap.Strict.Base
     (
       -- * Strictness properties
       -- $strictness

Data/HashSet.hs

@@ -0,0 +1,72 @@
+{-# LANGUAGE CPP #-}
+#if __GLASGOW_HASKELL__ >= 702
+{-# LANGUAGE Safe #-}
+#endif
+
+------------------------------------------------------------------------
+-- |
+-- Module      :  Data.HashSet
+-- Copyright   :  2011 Bryan O'Sullivan
+-- License     :  BSD-style
+-- Maintainer  :  johan.tibell@gmail.com
+-- Stability   :  provisional
+-- Portability :  portable
+--
+-- A set of /hashable/ values.  A set cannot contain duplicate items.
+-- A 'HashSet' makes no guarantees as to the order of its elements.
+--
+-- The implementation is based on /hash array mapped trie/.  A
+-- 'HashSet' is often faster than other tree-based set types,
+-- especially when value comparison is expensive, as in the case of
+-- strings.
+--
+-- Many operations have a average-case complexity of /O(log n)/.  The
+-- implementation uses a large base (i.e. 16) so in practice these
+-- operations are constant time.
+
+module Data.HashSet
+    (
+      HashSet
+
+    -- * Construction
+    , empty
+    , singleton
+
+    -- * Combine
+    , union
+    , unions
+
+    -- * Basic interface
+    , null
+    , size
+    , member
+    , insert
+    , delete
+
+    -- * Transformations
+    , map
+
+      -- * Difference and intersection
+    , difference
+    , intersection
+
+    -- * Folds
+    , foldl'
+    , foldr
+
+    -- * Filter
+    , filter
+
+    -- * Conversions
+
+    -- ** Lists
+    , toList
+    , fromList
+
+    -- * HashMaps
+    , toMap
+    , fromMap
+    ) where
+
+import Data.HashSet.Base
+import Prelude ()

Data/HashSet/Base.hs

@@ -9,7 +9,7 @@
 
 ------------------------------------------------------------------------
 -- |
--- Module      :  Data.HashSet
+-- Module      :  Data.HashSet.Base
 -- Copyright   :  2011 Bryan O'Sullivan
 -- License     :  BSD-style
 -- Maintainer  :  johan.tibell@gmail.com
@@ -28,7 +28,7 @@
 -- implementation uses a large base (i.e. 16) so in practice these
 -- operations are constant time.
 
-module Data.HashSet
+module Data.HashSet.Base
     (
       HashSet
 
@@ -70,6 +70,9 @@ module Data.HashSet
     -- * HashMaps
     , toMap
     , fromMap
+
+    -- Exported from Data.HashMap.{Strict, Lazy}
+    , keysSet
     ) where
 
 import Control.DeepSeq (NFData(..))
@@ -84,7 +87,7 @@ import Data.Monoid (Monoid(..))
 import GHC.Exts (build)
 import Prelude hiding (filter, foldr, map, null)
 import qualified Data.Foldable as Foldable
-import qualified Data.HashMap.Lazy as H
+import qualified Data.HashMap.Base as H
 import qualified Data.List as List
 import Data.Typeable (Typeable)
 import Text.Read
@@ -101,6 +104,8 @@ import Data.Functor.Classes
 import qualified Data.Hashable.Lifted as H
 #endif
 
+import Data.Functor ((<$))
+
 -- | A set of values.  A set cannot contain duplicate values.
 newtype HashSet a = HashSet {
       asMap :: HashMap a ()
@@ -133,7 +138,7 @@ instance Ord1 HashSet where
 #endif
 
 instance Foldable.Foldable HashSet where
-    foldr = Data.HashSet.foldr
+    foldr = Data.HashSet.Base.foldr
     {-# INLINE foldr #-}
 
 #if __GLASGOW_HASKELL__ >= 711
@@ -210,6 +215,12 @@ toMap = asMap
 fromMap :: HashMap a () -> HashSet a
 fromMap = HashSet
 
+-- | /O(n)/ Produce a 'HashSet' of all the keys in the given 'HashMap'.
+--
+-- @since 0.2.10.0
+keysSet :: HashMap k a -> HashSet k
+keysSet m = fromMap (() <$ m)
+
 -- | /O(n+m)/ Construct a set containing all elements from both sets.
 --
 -- To obtain good performance, the smaller set must be presented as

unordered-containers.cabal

@@ -34,9 +34,11 @@ library
   other-modules:
     Data.HashMap.Array
     Data.HashMap.Base
+    Data.HashMap.Strict.Base
     Data.HashMap.List
     Data.HashMap.Unsafe
     Data.HashMap.UnsafeShift
+    Data.HashSet.Base
 
   build-depends:
     base >= 4.7 && < 5,
@@ -177,9 +179,11 @@ benchmark benchmarks
     Data.HashMap.Base
     Data.HashMap.Lazy
     Data.HashMap.Strict
+    Data.HashMap.Strict.Base
     Data.HashMap.Unsafe
     Data.HashMap.UnsafeShift
     Data.HashSet
+    Data.HashSet.Base
     Util.ByteString
     Util.Int
     Util.String