Changes per @hdgarrood's comments

Author: joshuahhh

src/Data/Map.purs

@@ -381,9 +381,10 @@ fromFoldableWith f = foldl (\m (Tuple k v) -> alter (combine v) k m) empty where
   combine v (Just v') = Just $ f v v'
   combine v Nothing = Just v
 
--- | Convert a map to a list of key/value pairs
+-- | Convert a map to a list of key/value pairs.
+-- | DEPRECATED: use toUnfoldable or toAscUnfoldable instead.
 toList :: forall k v. Map k v -> List (Tuple k v)
-toList = toUnfoldable
+toList = toAscUnfoldable
 
 -- | 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)

test/Test/Data/Map.purs

@@ -166,7 +166,7 @@ mapTests = do
     in M.lookup k tree == Just v <?> ("instrs:\n  " <> show instrs <> "\nk:\n  " <> show k <> "\nv:\n  " <> show v)
 
   log "Singleton to list"
-  quickCheck $ \k v -> M.toList (M.singleton k v :: M.Map SmallKey Int) == singleton (Tuple k v)
+  quickCheck $ \k v -> M.toUnfoldable (M.singleton k v :: M.Map SmallKey Int) == singleton (Tuple k v)
 
   log "fromFoldable [] = empty"
   quickCheck (M.fromFoldable [] == (M.empty :: M.Map Unit Unit)
@@ -190,17 +190,12 @@ mapTests = do
     quickCheck (M.lookup 1 nums == Just 2  <?> "invalid lookup - 1")
     quickCheck (M.lookup 2 nums == Nothing <?> "invalid lookup - 2")
 
-  log "sort . toList . fromFoldable = sort (on lists without key-duplicates)"
+  log "sort . toUnfoldable . 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)
+        f x = M.toUnfoldable (M.fromFoldable x)
     in sort (f nubbedList) == sort nubbedList <?> show nubbedList
 
-  log "fromFoldable . toList = id"
-  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 :: M.Map SmallKey Int)) ->
     let f m' = M.fromFoldable (M.toUnfoldable m' :: List (Tuple SmallKey Int))
@@ -317,5 +312,6 @@ mapTests = do
   quickCheck $ \(TestMap m :: TestMap String Int) -> let
     f k v = k <> show v
     resultViaMapWithKey = m # M.mapWithKey f
-    resultViaLists = m # M.toList # map (\(Tuple k v) → Tuple k (f k v)) # M.fromFoldable
+    toList = M.toUnfoldable :: forall k v. M.Map k v -> List (Tuple k v)
+    resultViaLists = m # toList # map (\(Tuple k v) → Tuple k (f k v)) # M.fromFoldable
     in resultViaMapWithKey === resultViaLists