Add a toMap operation that returns a Map wrapper for HashMap

core/src/main/scala-2.12/cats/data/HashMapCompatCompanion.scala

@@ -0,0 +1,28 @@
+package cats.data
+
+import scala.collection.immutable.AbstractMap
+import scala.util.hashing.MurmurHash3
+
+private[data] trait HashMapCompatCompanion {
+  private[data] class WrappedHashMap[K, V](private[WrappedHashMap] val hashMap: HashMap[K, V]) extends AbstractMap[K, V] {
+    final def iterator: collection.Iterator[(K, V)] = hashMap.iterator
+    final def get(key: K): Option[V] = hashMap.get(key)
+    final def +[V1 >: V](kv: (K, V1)): Map[K, V1] = new WrappedHashMap(hashMap.updated(kv._1, kv._2))
+    final def -(key: K): Map[K, V] = new WrappedHashMap(hashMap.removed(key))
+    final override def size: Int = hashMap.size
+    final override def contains(key: K): Boolean = hashMap.contains(key)
+    final override def foreach[U](f: ((K, V)) => U): Unit = hashMap.foreach(Function.untupled(f))
+    final override def getOrElse[V1 >: V](key: K, default: => V1): V1 = hashMap.getOrElse(key, default)
+    final override def keysIterator: Iterator[K] = hashMap.keysIterator
+    final override def valuesIterator: Iterator[V] = hashMap.valuesIterator
+    final override def isEmpty: Boolean = hashMap.isEmpty
+    final override def nonEmpty: Boolean = hashMap.nonEmpty
+    final override def hashCode: Int = MurmurHash3.mapHash(this)
+    final override def equals(that: Any): Boolean = that match {
+      case map: WrappedHashMap[_, _] =>
+        (this eq map) || (this.hashMap == map.hashMap)
+      case other =>
+        super.equals(other)
+    }
+  }
+}

core/src/main/scala-2.13+/cats/data/HashMapCompatCompanion.scala

@@ -0,0 +1,31 @@
+package cats.data
+
+import scala.collection.immutable.AbstractMap
+import scala.util.hashing.MurmurHash3
+
+private[data] trait HashMapCompatCompanion {
+  private[data] class WrappedHashMap[K, V](private[WrappedHashMap] val hashMap: HashMap[K, V]) extends AbstractMap[K, V] {
+    final def iterator: collection.Iterator[(K, V)] = hashMap.iterator
+    final def get(key: K): Option[V] = hashMap.get(key)
+    final def updated[V1 >: V](key: K, value: V1): Map[K, V1] = new WrappedHashMap(hashMap.updated(key, value))
+    final def removed(key: K): Map[K, V] = new WrappedHashMap(hashMap.removed(key))
+    final override def size: Int = hashMap.size
+    final override def knownSize: Int = hashMap.size
+    final override def contains(key: K): Boolean = hashMap.contains(key)
+    final override def foreach[U](f: ((K, V)) => U): Unit = hashMap.foreach(Function.untupled(f))
+    final override def getOrElse[V1 >: V](key: K, default: => V1): V1 = hashMap.getOrElse(key, default)
+    final override def keysIterator: Iterator[K] = hashMap.keysIterator
+    final override def valuesIterator: Iterator[V] = hashMap.valuesIterator
+    final override def isEmpty: Boolean = hashMap.isEmpty
+    final override def nonEmpty: Boolean = hashMap.nonEmpty
+    final override def concat[V2 >: V](suffix: IterableOnce[(K, V2)]): Map[K, V2] =
+      new WrappedHashMap(hashMap.concat(suffix))
+    final override def hashCode: Int = MurmurHash3.mapHash(this)
+    final override def equals(that: Any): Boolean = that match {
+      case map: WrappedHashMap[_, _] =>
+        (this eq map) || (this.hashMap == map.hashMap)
+      case other =>
+        super.equals(other)
+    }
+  }
+}

core/src/main/scala/cats/data/HashMap.scala

@@ -60,6 +60,7 @@ import cats.syntax.eq._
 import java.util.Arrays
 
 import HashMap.improve
+import HashMap.WrappedHashMap
 
 /**
  * An immutable hash map using [[cats.kernel.Hash]] for hashing.
@@ -90,6 +91,14 @@ final class HashMap[K, +V] private[data] (private[data] val rootNode: HashMap.No
   final def keysIterator: Iterator[K] =
     iterator.map { case (k, _) => k }
 
+  /**
+    * An iterator for the values of this map that can be used only once.
+    *
+    * @return an iterator that iterates through the keys of this map.
+    */
+  final def valuesIterator: Iterator[V] =
+    iterator.map { case (_, v) => v }
+
   /**
     * The size of this map.
     *
@@ -177,6 +186,9 @@ final class HashMap[K, +V] private[data] (private[data] val rootNode: HashMap.No
       new HashMap(newRootNode)
   }
 
+  final def toMap: collection.immutable.Map[K, V] =
+    new WrappedHashMap(this)
+
   /**
    * Typesafe equality operator.
    *
@@ -233,7 +245,7 @@ final class HashMap[K, +V] private[data] (private[data] val rootNode: HashMap.No
     iterator.map { case (k, v) => s"$k -> $v" }.mkString("HashMap(", ", ", ")")
 }
 
-object HashMap extends HashMapInstances {
+object HashMap extends HashMapInstances with HashMapCompatCompanion {
   final private[data] def improve(hash: Int): Int =
     scala.util.hashing.byteswap32(hash)
 
@@ -275,7 +287,7 @@ object HashMap extends HashMapInstances {
   *
   * @param iterable the iterable source of elements to add to the [[cats.data.HashMap]].
   * @param hashKey the [[cats.kernel.Hash]] instance used for hashing values.
-  * @return a new [[cats.data.HashMap]] which contains all elements of `seq`.
+  * @return a new [[cats.data.HashMap]] which contains all elements of `iterable`.
   */
   final def fromIterableOnce[K, V](iterable: IterableOnce[(K, V)])(implicit hashKey: Hash[K]): HashMap[K, V] = {
     iterable match {
@@ -295,7 +307,7 @@ object HashMap extends HashMapInstances {
   * @param fkv the [[cats.Foldable]] structure of elements to add to the [[cats.data.HashMap]].
   * @param F the [[cats.Foldable]] instance used for folding the structure.
   * @param hashKey the [[cats.kernel.Hash]] instance used for hashing values.
-  * @return a new [[cats.data.HashMap]] which contains all elements of `seq`.
+  * @return a new [[cats.data.HashMap]] which contains all elements of `fkv`.
   */
   final def fromFoldable[F[_], K, V](fkv: F[(K, V)])(implicit F: Foldable[F], hashKey: Hash[K]): HashMap[K, V] = {
     val rootNode = F.foldLeft(fkv, Node.empty[K, V]) { case (node, (k, v)) =>

tests/shared/src/test/scala/cats/tests/HashMapSuite.scala

@@ -264,4 +264,12 @@ class HashMapSuite extends CatsSuite {
         assertEquals(left, right)
     }
   }
+
+  property("toMap consistent with fromIterableOnce") {
+    forAll { (scalaMap: Map[Int, String]) =>
+      val hashMap = HashMap.fromIterableOnce(scalaMap)
+      val wrappedHashMap = hashMap.toMap
+      assertEquals(scalaMap, wrappedHashMap)
+    }
+  }
 }