Added toAscUnfoldable in place of toAscList

Author: joshuahhh

src/Data/Map.purs

@@ -19,8 +19,8 @@ module Data.Map
   , fromFoldable
   , fromFoldableWith
   , toList
-  , toAscList
   , toUnfoldable
+  , toAscUnfoldable
   , delete
   , pop
   , member
@@ -36,15 +36,13 @@ module Data.Map
   ) where
 
 import Prelude
-
 import Data.Foldable (foldl, foldMap, foldr, class Foldable)
 import Data.List (List(..), (:), length, nub)
 import Data.Maybe (Maybe(..), maybe, isJust, fromMaybe)
 import Data.Monoid (class Monoid)
 import Data.Traversable (traverse, class Traversable)
 import Data.Tuple (Tuple(Tuple), snd)
 import Data.Unfoldable (class Unfoldable, unfoldr)
-
 import Partial.Unsafe (unsafePartial)
 
 -- | `Map k v` represents maps from keys of type `k` to values of type `v`.
@@ -53,14 +51,18 @@ data Map k v
   | Two (Map k v) k v (Map k v)
   | Three (Map k v) k v (Map k v) k v (Map k v)
 
+-- Internal use
+toAscArray :: forall k v. Map k v -> Array (Tuple k v)
+toAscArray = toAscUnfoldable
+
 instance eqMap :: (Eq k, Eq v) => Eq (Map k v) where
-  eq m1 m2 = toAscList m1 == toAscList m2
+  eq m1 m2 = toAscArray m1 == toAscArray m2
 
 instance ordMap :: (Ord k, Ord v) => Ord (Map k v) where
-  compare m1 m2 = compare (toAscList m1) (toAscList m2)
+  compare m1 m2 = compare (toAscArray m1) (toAscArray m2)
 
 instance showMap :: (Show k, Show v) => Show (Map k v) where
-  show m = "(fromList " <> show (toAscList m) <> ")"
+  show m = "(fromFoldable " <> show (toAscArray m) <> ")"
 
 instance semigroupMap :: Ord k => Semigroup (Map k v) where
   append = union
@@ -381,13 +383,7 @@ fromFoldableWith f = foldl (\m (Tuple k v) -> alter (combine v) k m) empty where
 
 -- | Convert a map to a list of key/value pairs
 toList :: forall k v. Map k v -> List (Tuple k v)
-toList Leaf = Nil
-toList (Two left k v right) = toList left <> Tuple k v : toList right
-toList (Three left k1 v1 mid k2 v2 right) = toList left <> Tuple k1 v1 : toList mid <> Tuple k2 v2 : toList right
-
--- | Convert a map to a list of key/value pairs where the keys are in ascending order
-toAscList :: forall k v. Map k v -> List (Tuple k v)
-toAscList = toList
+toList = toUnfoldable
 
 -- | Convert a map to an unfoldable structure of key/value pairs
 toUnfoldable :: forall f k v. Unfoldable f => Map k v -> f (Tuple k v)
@@ -400,6 +396,21 @@ toUnfoldable m = unfoldr go (m : Nil) where
     Three left k1 v1 mid k2 v2 right ->
       Just $ Tuple (Tuple k1 v1) (singleton k2 v2 : left : mid : right : tl)
 
+-- | Convert a map to an unfoldable structure of key/value pairs where the keys are in ascending order
+toAscUnfoldable :: forall f k v. Unfoldable f => Map k v -> f (Tuple k v)
+toAscUnfoldable m = unfoldr go (m : Nil) where
+  go Nil = Nothing
+  go (hd : tl) = case hd of
+    Leaf -> go tl
+    Two Leaf k v Leaf ->
+      Just $ Tuple (Tuple k v) tl
+    Two Leaf k v right ->
+      Just $ Tuple (Tuple k v) (right : tl)
+    Two left k v right ->
+      go $ left : singleton k v : right : tl
+    Three left k1 v1 mid k2 v2 right ->
+      go $ left : singleton k1 v1 : mid : singleton k2 v2 : right : tl
+
 -- | Get a list of the keys contained in a map
 keys :: forall k v. Map k v -> List k
 keys Leaf = Nil

test/Test/Data/Map.purs

@@ -1,23 +1,19 @@
 module Test.Data.Map where
 
 import Prelude
-
+import Data.List.NonEmpty as NEL
+import Data.Map as M
 import Control.Alt ((<|>))
 import Control.Monad.Eff (Eff)
 import Control.Monad.Eff.Console (log, CONSOLE)
 import Control.Monad.Eff.Exception (EXCEPTION)
 import Control.Monad.Eff.Random (RANDOM)
-
 import Data.Foldable (foldl, for_, all)
 import Data.Function (on)
-import Data.List (List(..), groupBy, length, nubBy, sortBy, singleton)
-import Data.List.NonEmpty as NEL
-import Data.Map as M
+import Data.List (List(Cons), groupBy, length, nubBy, singleton, sort, sortBy)
 import Data.Maybe (Maybe(..), fromMaybe)
 import Data.Tuple (Tuple(..), fst)
-
 import Partial.Unsafe (unsafePartial)
-
 import Test.QuickCheck ((<?>), (===), quickCheck, quickCheck')
 import Test.QuickCheck.Arbitrary (class Arbitrary, arbitrary)
 
@@ -194,21 +190,26 @@ mapTests = do
     quickCheck (M.lookup 1 nums == Just 2  <?> "invalid lookup - 1")
     quickCheck (M.lookup 2 nums == Nothing <?> "invalid lookup - 2")
 
-  log "toList . fromFoldable = id"
-  quickCheck $ \arr -> let f x = M.toList (M.fromFoldable x)
-                       in f (f arr) == f (arr :: List (Tuple SmallKey Int)) <?> show arr
+  log "sort . toList . fromFoldable = sort (on lists without key-duplicates)"
+  quickCheck $ \(list :: List (Tuple SmallKey Int)) ->
+    let nubbedList = nubBy ((==) `on` fst) list
+        f x = M.toList (M.fromFoldable x)
+    in sort (f nubbedList) == sort nubbedList <?> show nubbedList
 
   log "fromFoldable . toList = id"
-  quickCheck $ \(TestMap m) -> let f m' = M.fromFoldable (M.toList m') in
-                     M.toList (f m) == M.toList (m :: M.Map SmallKey Int) <?> show m
+  quickCheck $ \(TestMap (m :: M.Map SmallKey Int)) ->
+    let f m' = M.fromFoldable (M.toList m')
+    in f m == m <?> show m
 
   log "fromFoldable . toUnfoldable = id"
-  quickCheck $ \(TestMap m) -> let f m' = M.fromFoldable (M.toUnfoldable m' :: List (Tuple SmallKey Int)) in
-                     f m == (m :: M.Map SmallKey Int) <?> show m
+  quickCheck $ \(TestMap (m :: M.Map SmallKey Int)) ->
+    let f m' = M.fromFoldable (M.toUnfoldable m' :: List (Tuple SmallKey Int))
+    in f m == m <?> show m
 
   log "fromFoldableWith const = fromFoldable"
-  quickCheck $ \arr -> M.fromFoldableWith const arr ==
-                       M.fromFoldable (arr :: List (Tuple SmallKey Int)) <?> show arr
+  quickCheck $ \arr ->
+    M.fromFoldableWith const arr ==
+    M.fromFoldable (arr :: List (Tuple SmallKey Int)) <?> show arr
 
   log "fromFoldableWith (<>) = fromFoldable . collapse with (<>) . group on fst"
   quickCheck $ \arr ->
@@ -218,10 +219,10 @@ mapTests = do
             groupBy ((==) `on` fst) <<< sortBy (compare `on` fst) in
     M.fromFoldableWith (<>) arr === f (arr :: List (Tuple String String))
 
-  log "toAscList is sorted version of toList"
+  log "toAscUnfoldable is sorted version of toUnfoldable"
   quickCheck $ \(TestMap m) ->
-    let list = M.toList (m :: M.Map SmallKey Int)
-        ascList = M.toAscList m
+    let list = M.toUnfoldable (m :: M.Map SmallKey Int)
+        ascList = M.toAscUnfoldable m
     in ascList === sortBy (compare `on` fst) list
 
   log "Lookup from union"