ObjectMatcher should not relay on generic tuple type but rather has its own internal MapEntry class

Author: ghostbuster91

core/src/main/scala/com/softwaremill/diffx/Diff.scala

@@ -1,4 +1,5 @@
 package com.softwaremill.diffx
+import com.softwaremill.diffx.ObjectMatcher.{IterableEntry, MapEntry}
 import com.softwaremill.diffx.generic.{DiffMagnoliaDerivation, MagnoliaDerivedMacro}
 import com.softwaremill.diffx.instances._
 
@@ -52,7 +53,7 @@ object Diff extends MiddlePriorityDiff with TupleInstances {
   implicit def diffForMap[K, V, C[KK, VV] <: scala.collection.Map[KK, VV]](implicit
       dv: Diff[V],
       dk: Diff[K],
-      matcher: ObjectMatcher[(K, V)]
+      matcher: ObjectMatcher[MapEntry[K, V]]
   ): Diff[C[K, V]] = new DiffForMap[K, V, C](matcher, dk, dv)
   implicit def diffForOptional[T](implicit ddt: Diff[T]): Diff[Option[T]] = new DiffForOption[T](ddt)
   implicit def diffForSet[T, C[W] <: scala.collection.Set[W]](implicit
@@ -67,7 +68,7 @@ trait MiddlePriorityDiff extends DiffMagnoliaDerivation with LowPriorityDiff {
 
   implicit def diffForIterable[T, C[W] <: Iterable[W]](implicit
       dt: Diff[T],
-      matcher: ObjectMatcher[(Int, T)]
+      matcher: ObjectMatcher[IterableEntry[T]]
   ): Diff[C[T]] = new DiffForIterable[T, C](dt, matcher)
 }
 
@@ -113,12 +114,12 @@ case class DerivedDiffLens[T, U](outer: Diff[T], path: List[String]) {
   }
   def ignore(): Derived[Diff[T]] = Derived(outer.modifyUnsafe(path: _*)(Diff.ignored))
 
-  def withMapMatcher[K, V](m: ObjectMatcher[(K, V)])(implicit
+  def withMapMatcher[K, V](m: ObjectMatcher[MapEntry[K, V]])(implicit
       ev1: U <:< scala.collection.Map[K, V]
   ): Derived[Diff[T]] =
     Derived(outer.modifyMatcherUnsafe(path: _*)(m))
   def withSetMatcher[V](m: ObjectMatcher[V])(implicit ev2: U <:< scala.collection.Set[V]): Derived[Diff[T]] =
     Derived(outer.modifyMatcherUnsafe(path: _*)(m))
-  def withListMatcher[V](m: ObjectMatcher[(Int, V)])(implicit ev3: U <:< Iterable[V]): Derived[Diff[T]] =
+  def withListMatcher[V](m: ObjectMatcher[IterableEntry[V]])(implicit ev3: U <:< Iterable[V]): Derived[Diff[T]] =
     Derived(outer.modifyMatcherUnsafe(path: _*)(m))
 }

core/src/main/scala/com/softwaremill/diffx/ObjectMatcher.scala

@@ -15,10 +15,10 @@ object ObjectMatcher extends LowPriorityObjectMatcher {
     ObjectMatcher[U].isSameObject(f(left), f(right))
 
   /** Given key-value (K,V) pairs match them using V's objectMatcher */
-  def byValue[K, V: ObjectMatcher]: ObjectMatcher[(K, V)] = ObjectMatcher.by[(K, V), V](_._2)
+  def byValue[K, V: ObjectMatcher]: ObjectMatcher[MapEntry[K, V]] = ObjectMatcher.by[MapEntry[K, V], V](_.value)
 
   /** Given key-value (K,V) pairs, where V is a type of product and U is a property of V, match them using U's objectMatcher */
-  def byValue[K, V, U: ObjectMatcher](f: V => U): ObjectMatcher[(K, V)] =
+  def byValue[K, V, U: ObjectMatcher](f: V => U): ObjectMatcher[MapEntry[K, V]] =
     ObjectMatcher.byValue[K, V](ObjectMatcher.by[V, U](f))
 
   implicit def optionMatcher[T: ObjectMatcher]: ObjectMatcher[Option[T]] = (left: Option[T], right: Option[T]) => {
@@ -29,7 +29,10 @@ object ObjectMatcher extends LowPriorityObjectMatcher {
   }
 
   /** Given key-value (K,V) pairs, match them using K's objectMatcher */
-  implicit def byKey[K: ObjectMatcher, V]: ObjectMatcher[(K, V)] = ObjectMatcher.by[(K, V), K](_._1)
+  implicit def byKey[K: ObjectMatcher, V]: ObjectMatcher[MapEntry[K, V]] = ObjectMatcher.by[MapEntry[K, V], K](_.key)
+
+  type IterableEntry[T] = MapEntry[Int, T]
+  case class MapEntry[K, V](key: K, value: V)
 }
 
 trait LowPriorityObjectMatcher {

core/src/main/scala/com/softwaremill/diffx/instances/DiffForIterable.scala

@@ -1,35 +1,36 @@
 package com.softwaremill.diffx.instances
 
 import com.softwaremill.diffx.Matching.{MatchingResults, matching}
+import com.softwaremill.diffx.ObjectMatcher.{IterableEntry, MapEntry}
 import com.softwaremill.diffx._
 
 import scala.collection.immutable.{ListMap, ListSet}
 
 private[diffx] class DiffForIterable[T, C[W] <: Iterable[W]](
     dt: Diff[T],
-    matcher: ObjectMatcher[(Int, T)]
+    matcher: ObjectMatcher[IterableEntry[T]]
 ) extends Diff[C[T]] {
   override def apply(left: C[T], right: C[T], context: DiffContext): DiffResult = nullGuard(left, right) {
     (left, right) =>
       val keys = Range(0, Math.max(left.size, right.size))
 
       val leftAsMap = left.toList.lift
       val rightAsMap = right.toList.lift
-      val leftv2 = ListSet(keys.map(i => i -> leftAsMap(i)): _*).collect { case (k, Some(v)) => k -> v }
-      val rightv2 = ListSet(keys.map(i => i -> rightAsMap(i)): _*).collect { case (k, Some(v)) => k -> v }
+      val leftv2 = ListSet(keys.map(i => i -> leftAsMap(i)): _*).collect { case (k, Some(v)) => MapEntry(k, v) }
+      val rightv2 = ListSet(keys.map(i => i -> rightAsMap(i)): _*).collect { case (k, Some(v)) => MapEntry(k, v) }
 
-      val adjustedMatcher = context.getMatcherOverride[(Int, T)].getOrElse(matcher)
+      val adjustedMatcher = context.getMatcherOverride[IterableEntry[T]].getOrElse(matcher)
       val MatchingResults(unMatchedLeftInstances, unMatchedRightInstances, matchedInstances) =
         matching(leftv2, rightv2, adjustedMatcher)
       val leftDiffs = unMatchedLeftInstances
         .diff(unMatchedRightInstances)
-        .collectFirst { case (k, v) => k -> DiffResultAdditional(v) }
+        .collectFirst { case MapEntry(k, v) => k -> DiffResultAdditional(v) }
         .toList
       val rightDiffs = unMatchedRightInstances
         .diff(unMatchedLeftInstances)
-        .collectFirst { case (k, v) => k -> DiffResultMissing(v) }
+        .collectFirst { case MapEntry(k, v) => k -> DiffResultMissing(v) }
         .toList
-      val matchedDiffs = matchedInstances.map { case (l, r) => l._1 -> dt(l._2, r._2, context) }.toList
+      val matchedDiffs = matchedInstances.map { case (l, r) => l.key -> dt(l.value, r.value, context) }.toList
 
       val diffs = ListMap((matchedDiffs ++ leftDiffs ++ rightDiffs).map { case (k, v) => k.toString -> v }: _*)
       DiffResultObject("List", diffs)

core/src/main/scala/com/softwaremill/diffx/instances/DiffForMap.scala

@@ -1,10 +1,11 @@
 package com.softwaremill.diffx.instances
 
 import com.softwaremill.diffx.Matching._
+import com.softwaremill.diffx.ObjectMatcher.MapEntry
 import com.softwaremill.diffx._
 
 private[diffx] class DiffForMap[K, V, C[KK, VV] <: scala.collection.Map[KK, VV]](
-    matcher: ObjectMatcher[(K, V)],
+    matcher: ObjectMatcher[MapEntry[K, V]],
     diffKey: Diff[K],
     diffValue: Diff[V]
 ) extends Diff[C[K, V]] {
@@ -13,19 +14,27 @@ private[diffx] class DiffForMap[K, V, C[KK, VV] <: scala.collection.Map[KK, VV]]
       right: C[K, V],
       context: DiffContext
   ): DiffResult = nullGuard(left, right) { (left, right) =>
-    val adjustedMatcher = context.getMatcherOverride[(K, V)].getOrElse(matcher)
+    val adjustedMatcher = context.getMatcherOverride[MapEntry[K, V]].getOrElse(matcher)
     val MatchingResults(unMatchedLeftKeys, unMatchedRightKeys, matchedKeys) =
-      matching(left.toSet, right.toSet, adjustedMatcher, diffKey.contramap[(K, V)](_._1), context)
+      matching(
+        left.map { case (k, v) => MapEntry.apply(k, v) }.toSet,
+        right.map { case (k, v) => MapEntry.apply(k, v) }.toSet,
+        adjustedMatcher,
+        diffKey.contramap[MapEntry[K, V]](_.key),
+        context
+      )
 
     val leftDiffs = unMatchedLeftKeys
       .diff(unMatchedRightKeys)
-      .collectFirst { case (k, v) => DiffResultAdditional(k) -> DiffResultAdditional(v) }
+      .collectFirst { case MapEntry(k, v) => DiffResultAdditional(k) -> DiffResultAdditional(v) }
       .toList
     val rightDiffs = unMatchedRightKeys
       .diff(unMatchedLeftKeys)
-      .collectFirst { case (k, v) => DiffResultMissing(k) -> DiffResultMissing(v) }
+      .collectFirst { case MapEntry(k, v) => DiffResultMissing(k) -> DiffResultMissing(v) }
       .toList
-    val matchedDiffs = matchedKeys.map { case (l, r) => diffKey(l._1, r._1) -> diffValue(l._2, r._2, context) }.toList
+    val matchedDiffs = matchedKeys.map { case (l, r) =>
+      diffKey(l.key, r.key) -> diffValue(l.value, r.value, context)
+    }.toList
 
     val diffs = leftDiffs ++ rightDiffs ++ matchedDiffs
     DiffResultMap(diffs.toMap)

core/src/test/scala/com/softwaremill/diffx/test/DiffTest.scala

@@ -1,5 +1,6 @@
 package com.softwaremill.diffx.test
 
+import com.softwaremill.diffx.ObjectMatcher.{IterableEntry, MapEntry}
 import com.softwaremill.diffx.generic.auto._
 import com.softwaremill.diffx._
 import org.scalatest.freespec.AnyFreeSpec
@@ -373,7 +374,15 @@ class DiffTest extends AnyFreeSpec with Matchers {
       "compare lists using object matcher comparator" in {
         val o1 = Organization(List(p1, p2))
         val o2 = Organization(List(p2, p1))
-        implicit val om: ObjectMatcher[(Int, Person)] = ObjectMatcher.byValue(_.name)
+        implicit val om: ObjectMatcher[IterableEntry[Person]] = ObjectMatcher.byValue(_.name)
+        compare(o1, o2).isIdentical shouldBe true
+      }
+
+      "compare lists using object matcher comparator when matching by pair" in {
+        val p2WithSameNameAsP1 = p2.copy(name = p1.name)
+        val o1 = Organization(List(p1, p2WithSameNameAsP1))
+        val o2 = Organization(List(p2WithSameNameAsP1, p1))
+        implicit val om: ObjectMatcher[IterableEntry[Person]] = ObjectMatcher.byValue(p => (p.name, p.age))
         compare(o1, o2).isIdentical shouldBe true
       }
 
@@ -652,7 +661,7 @@ class DiffTest extends AnyFreeSpec with Matchers {
       }
 
       "match map entries by values" in {
-        implicit val om: ObjectMatcher[(KeyModel, String)] = ObjectMatcher.byValue
+        implicit val om: ObjectMatcher[MapEntry[KeyModel, String]] = ObjectMatcher.byValue
         val uuid1 = UUID.randomUUID()
         val uuid2 = UUID.randomUUID()
         val a1 = MyLookup(Map(KeyModel(uuid1, "k1") -> "val1"))

docs-sources/usage/sequences.md

@@ -34,10 +34,11 @@ In below example we tell `diffx` to compare these maps by paring entries by valu
 ```scala mdoc:reset:silent
 import com.softwaremill.diffx._
 import com.softwaremill.diffx.generic.auto._
+import com.softwaremill.diffx.ObjectMatcher.MapEntry
 case class Person(id: String, name: String)
 
 val personMatcher: ObjectMatcher[Person] = ObjectMatcher.by(_.id)
-implicit val om: ObjectMatcher[(String, Person)] = ObjectMatcher.byValue(personMatcher)
+implicit val om: ObjectMatcher[MapEntry[String, Person]] = ObjectMatcher.byValue(personMatcher)
 val bob = Person("1","Bob")
 ```
 
@@ -47,14 +48,15 @@ compare(Map("1" -> bob), Map("2" -> bob))
 
 Last but not least you can use `objectMatcher` to customize paring when comparing indexed collections.
 Such collections are treated similarly to maps (they use key-value object matcher),
-but the key type is bound to `Int`.
+but the key type is bound to `Int` (`IterableEntry` is an alias for `MapEntry[Int,V]`).
 
 ```scala mdoc:reset:silent
 import com.softwaremill.diffx._
 import com.softwaremill.diffx.generic.auto._
+import com.softwaremill.diffx.ObjectMatcher.IterableEntry
 case class Person(id: String, name: String)
 
-implicit val personMatcher: ObjectMatcher[(Int, Person)] = ObjectMatcher.byValue(_.id)
+implicit val personMatcher: ObjectMatcher[IterableEntry[Person]] = ObjectMatcher.byValue(_.id)
 val bob = Person("1","Bob")
 val alice = Person("2","Alice")
 ```