Avoid systematic potentially heavy equality check at first

Author: satabin

.scalafmt.conf

@@ -1,4 +1,4 @@
-version = "3.7.2"
+version = "3.7.1"
 maxColumn = 120
 danglingParentheses.preset = false
 align.preset = some

core/src/main/scala/diffson/jsonpatch/JsonDiff.scala

@@ -20,30 +20,30 @@ package jsonpatch
 import lcs._
 import jsonpointer._
 
-import cats.implicits._
+import cats.syntax.all._
+import cats.data.Chain
+import cats.Eval
 
 import scala.annotation.tailrec
-import cats.data.Chain
 
 class JsonDiff[Json](diffArray: Boolean, rememberOld: Boolean)(implicit J: Jsony[Json], Lcs: Lcs[Json])
     extends Diff[Json, JsonPatch[Json]] {
   def diff(json1: Json, json2: Json): JsonPatch[Json] =
-    JsonPatch(diff(json1, json2, Pointer.Root).toList)
+    JsonPatch(diff(json1, json2, Pointer.Root).value.toList)
 
-  private def diff(json1: Json, json2: Json, pointer: Pointer): Chain[Operation[Json]] =
-    if (json1 === json2)
-      // if they are equal, this one is easy...
-      Chain.empty
-    else
-      (json1, json2) match {
-        case (JsObject(fields1), JsObject(fields2))      => fieldsDiff(fields1.toList, fields2.toList, pointer)
-        case (JsArray(arr1), JsArray(arr2)) if diffArray => arraysDiff(arr1.toList, arr2.toList, pointer)
-        case (_, _) => Chain.one(Replace(pointer, json2, if (rememberOld) Some(json1) else None))
-      }
+  private def diff(json1: Json, json2: Json, pointer: Pointer): Eval[Chain[Operation[Json]]] =
+    (json1, json2) match {
+      case (JsObject(fields1), JsObject(fields2))      => fieldsDiff(fields1.toList, fields2.toList, pointer)
+      case (JsArray(arr1), JsArray(arr2)) if diffArray => arraysDiff(arr1.toList, arr2.toList, pointer)
+      case _ if json1 === json2                        =>
+        // if they are equal, this one is easy...
+        Eval.now(Chain.empty)
+      case _ => Eval.now(Chain.one(Replace(pointer, json2, if (rememberOld) Some(json1) else None)))
+    }
 
   private def fieldsDiff(fields1: List[(String, Json)],
                          fields2: List[(String, Json)],
-                         path: Pointer): Chain[Operation[Json]] = {
+                         path: Pointer): Eval[Chain[Operation[Json]]] = {
     // sort fields by name in both objects
     val sorted1 = fields1.sortBy(_._1)
     val sorted2 = fields2.sortBy(_._1)
@@ -67,28 +67,27 @@ class JsonDiff[Json](diffArray: Boolean, rememberOld: Boolean)(implicit J: Jsony
         Chain.fromSeq(fields2.map(None -> Some(_))) ++ acc
     }
 
-    @tailrec
     def fields(fs: List[(Option[(String, Json)], Option[(String, Json)])],
-               acc: Chain[Operation[Json]]): Chain[Operation[Json]] = fs match {
-      case (Some(f1), Some(f2)) :: tl if f1 == f2 =>
+               acc: Chain[Operation[Json]]): Eval[Chain[Operation[Json]]] = fs match {
+      case (Some(f1), Some(f2)) :: tl if f1._2 === f2._2 =>
         // all right, nothing changed
         fields(tl, acc)
       case (Some(f1), Some(f2)) :: tl =>
         // same field name, different values
-        fields(tl, diff(f1._2, f2._2, path / f1._1) ++ acc)
+        diff(f1._2, f2._2, path / f1._1).flatMap(d => fields(tl, d ++ acc))
       case (Some(f1), None) :: tl =>
         // the field was deleted
         fields(tl, acc.prepend(Remove[Json](path / f1._1, if (rememberOld) Some(f1._2) else None)))
       case (None, Some(f2)) :: tl =>
         // the field was added
         fields(tl, acc.prepend(Add(path / f2._1, f2._2)))
       case _ =>
-        acc
+        Eval.now(acc)
     }
     fields(associate(sorted1, sorted2, Chain.empty).toList, Chain.empty)
   }
 
-  private def arraysDiff(arr1: List[Json], arr2: List[Json], path: Pointer): Chain[Operation[Json]] = {
+  private def arraysDiff(arr1: List[Json], arr2: List[Json], path: Pointer): Eval[Chain[Operation[Json]]] = {
     // get the longest common subsequence in the array
     val lcs = Lcs.lcs(arr1, arr2)
 
@@ -118,7 +117,6 @@ class JsonDiff[Json](diffArray: Boolean, rememberOld: Boolean)(implicit J: Jsony
           yield Remove[Json](path / idx, if (rememberOld) Some(arr(idx - shift)) else None))
 
     // now iterate over the first array to computes what was added, what was removed and what was modified
-    @tailrec
     def loop(
         arr1: List[Json], // the first array
         arr2: List[Json], // the second array
@@ -127,7 +125,7 @@ class JsonDiff[Json](diffArray: Boolean, rememberOld: Boolean)(implicit J: Jsony
         idx2: Int, // current index in the second array
         lcs: List[(Int, Int)], // the list of remaining matching indices
         acc: Chain[Operation[Json]] // the already accumulated result
-    ): Chain[Operation[Json]] = (arr1, arr2) match {
+    ): Eval[Chain[Operation[Json]]] = (arr1, arr2) match {
       case (_ :: tl1, _) if isCommon1(idx1, lcs) =>
         // all values in arr2 were added until the index of common value
         val until = lcs.head._2
@@ -150,13 +148,13 @@ class JsonDiff[Json](diffArray: Boolean, rememberOld: Boolean)(implicit J: Jsony
              acc ++ remove(idx1 + shift1, until - 1 + shift1, idx1 + shift1, arr1))
       case (v1 :: tl1, v2 :: tl2) =>
         // values are different, recursively compute the diff of these values
-        loop(tl1, tl2, idx1 + 1, shift1, idx2 + 1, lcs, acc ++ diff(v1, v2, path / (idx1 + shift1)))
+        diff(v1, v2, path / (idx1 + shift1)).flatMap(d => loop(tl1, tl2, idx1 + 1, shift1, idx2 + 1, lcs, acc ++ d))
       case (_, Nil) =>
         // all subsequent values in arr1 were removed
-        acc ++ remove(idx1 + shift1, idx1 + arr1.size - 1 + shift1, idx1 + shift1, arr1)
+        Eval.now(acc ++ remove(idx1 + shift1, idx1 + arr1.size - 1 + shift1, idx1 + shift1, arr1))
       case (Nil, _) =>
         // all subsequent value in arr2 were added
-        acc ++ Chain.fromSeq(arr2.map(Add(path / "-", _)))
+        Eval.now(acc ++ Chain.fromSeq(arr2.map(Add(path / "-", _))))
     }
 
     loop(arr1, arr2, 0, 0, 0, lcs, Chain.empty)