Ticket #2717: nub.patch

Data/List.hs

@@ -157 +157 @@
    -- ** \"Set\" operations
 
    , nub               -- :: (Eq a) => [a] -> [a]
+   , nubWith           -- :: (a -> b -> Maybe b) -> b -> [a] -> [a]
 
    , delete            -- :: (Eq a) => a -> [a] -> [a]
    , (\\)              -- :: (Eq a) => [a] -> [a] -> [a]
@@ -302 +303 @@
 isInfixOf               :: (Eq a) => [a] -> [a] -> Bool
 isInfixOf needle haystack = any (isPrefixOf needle) (tails haystack)
 
--- | The 'nub' function removes duplicate elements from a list.
--- In particular, it keeps only the first occurrence of each element.
--- (The name 'nub' means \`essence\'.)
--- It is a special case of 'nubBy', which allows the programmer to supply
--- their own equality test.
+-- | The 'nub' function removes duplicate elements from a
+-- list.  In particular, it keeps only the first occurrence
+-- of each element.  (The name \"nub\" means \"essence\".)
+-- 
+-- The 'nub' function is a special case of 'nubBy', which
+-- allows the programmer to supply their own equality test.
+-- It is also a special case of 'nubWith', which allows the
+-- programmer to supply their own filtering function.
+--
+-- The 'nub' function is /O(mn)/ on lists of length /n/
+-- containing /m/ duplicate elements.  'nubOrd'
+-- is an /O(n log m)/ nub function for 'Ord' data.
 nub                     :: (Eq a) => [a] -> [a]
 #ifdef USE_REPORT_PRELUDE
 nub                     =  nubBy (==)
@@ -320 +328 @@
         | otherwise     = x : nub' xs (x:ls)    -- '
 #endif
 
+-- | The 'nubWith' function accepts as an argument a \"stop
+-- list\" update function and an initial stop list. The stop
+-- list is a set of list elements that 'nubWith' uses as a
+-- filter to remove duplicate elements.  The stop list is
+-- normally initially empty.
+-- 
+-- The stop list update function is given a list element a
+-- and the current stop list b, and returns 'Nothing' if the
+-- element is already in the stop list, else 'Just' b', where
+-- b' is a new stop list updated to contain a.
+nubWith :: (a -> b -> Maybe b) -> b -> [a] -> [a]
+nubWith _ _ [] = []
+nubWith f s (e:es) =
+    case f e s of
+       Just s' -> e : nubWith f s' es
+       Nothing -> nubWith f s es
+
 -- | The 'nubBy' function behaves just like 'nub', except it uses a
 -- user-supplied equality predicate instead of the overloaded '=='
 -- function.

Data/Set.hs

@@ -93 +93 @@
             , toAscList
             , fromAscList
             , fromDistinctAscList
-                        
+
+            -- * Misc
+            , nubOrd
+
             -- * Debugging
             , showTree
             , showTreeWith
@@ -981 +984 @@
 withEmpty bars = "   ":bars
 
 {--------------------------------------------------------------------
+  Misc
+--------------------------------------------------------------------}
+
+-- | The 'nubOrd' function is /O(n log m)/ on 'Ord' data,
+-- where /n/ is the length of the list and /m/ is the number
+-- of duplicate elements.  If your target type only supports
+-- 'Eq', use 'nub'.  The 'nubOrd' function is a
+-- special case of 'nubWith' with a 'Set' stop
+-- list.
+nubOrd :: Ord e => [e] -> [e]
+nubOrd = List.nubWith f empty where
+    f e s = if member e s then Nothing else Just (insert e s)
+
+{--------------------------------------------------------------------
   Assertions
 --------------------------------------------------------------------}
 -- | /O(n)/. Test if the internal set structure is valid.
@@ -1176 +1193 @@
 prop_List :: [Int] -> Bool
 prop_List xs
   = (sort (nub xs) == toList (fromList xs))
+
+{--------------------------------------------------------------------
+  Misc
+--------------------------------------------------------------------}
+
+nubl :: [a] -> Gen [a]
+nubl l = do
+  l' <- mapM rep l
+  return (concat l')
+    where
+      rep e = do
+        k <- choose (0, 10)
+        return (replicate k e)
+
+prop_NubOrd :: [Int] -> Property
+prop_NubOrd l = forAll (nubl l) $ \l0 -> nub l0 == nubOrd l0
+
 -}