improve old diff API

common/src/commonMain/kotlin/dev/inmo/micro_utils/common/DiffUtils.kt

@@ -200,20 +200,18 @@ inline fun <T> Iterable<T>.calculateStrictDiff(
 ) = calculateDiff(other, strictComparison = true)
 
 /**
- * This method call [calculateDiff] with strict mode [strictComparison] and then apply differences to [this]
- * mutable list
+ * Applies [diff] to [this] [MutableList]
  */
 fun <T> MutableList<T>.applyDiff(
-    source: Iterable<T>,
-    strictComparison: Boolean = false
-): Diff<T> = calculateDiff(source, strictComparison).also {
-    for (i in it.removed.indices.sortedDescending()) {
-        removeAt(it.removed[i].index)
+    diff: Diff<T>
+) {
+    for (i in diff.removed.indices.sortedDescending()) {
+        removeAt(diff.removed[i].index)
     }
-    it.added.forEach { (i, t) ->
+    diff.added.forEach { (i, t) ->
         add(i, t)
     }
-    it.replaced.forEach { (_, new) ->
+    diff.replaced.forEach { (_, new) ->
         set(new.index, new.value)
     }
 }
@@ -222,17 +220,30 @@ fun <T> MutableList<T>.applyDiff(
  * This method call [calculateDiff] with strict mode [strictComparison] and then apply differences to [this]
  * mutable list
  */
+fun <T> MutableList<T>.applyDiff(
+    source: Iterable<T>,
+    strictComparison: Boolean = false
+): Diff<T> = calculateDiff(source, strictComparison).also {
+    applyDiff(it)
+}
+
+/**
+ * This method call [calculateDiff] and then apply differences to [this]
+ * mutable list
+ */
 fun <T> MutableList<T>.applyDiff(
     source: Iterable<T>,
     comparisonFun: (T?, T?) -> Boolean
 ): Diff<T> = calculateDiff(source, comparisonFun).also {
-    for (i in it.removed.indices.sortedDescending()) {
-        removeAt(it.removed[i].index)
-    }
-    it.added.forEach { (i, t) ->
-        add(i, t)
-    }
-    it.replaced.forEach { (_, new) ->
-        set(new.index, new.value)
-    }
+    applyDiff(it)
 }
+
+/**
+ * Reverse [this] [Diff]. Result will contain [Diff.added] on [Diff.removed] (and vice-verse), all the
+ * [Diff.replaced] values will be reversed too
+ */
+fun <T> Diff<T>.reversed() = Diff(
+    removed = added,
+    replaced = replaced.map { it.second to it.first },
+    added = removed
+)

common/src/commonMain/kotlin/dev/inmo/micro_utils/common/MapDiff.kt

@@ -76,15 +76,12 @@ fun <K, V> Map<K, V>.diff(
 )
 
 /**
- * Will apply changes with [other] map into [this] one
- *
- * @param compareFun Will be used to determine changed values
+ * Will apply [mapDiff] to [this] [MutableMap]
  */
 fun <K, V> MutableMap<K, V>.applyDiff(
-    from: Map<K, V>,
-    compareFun: (K, V, V) -> Boolean = { _, first, second -> first == second }
+    mapDiff: MapDiff<K, V>
 ) {
-    diff(from, compareFun).apply {
+    mapDiff.apply {
         removed.keys.forEach { remove(it) }
         changed.forEach { (k, oldNew) ->
             put(k, oldNew.second)
@@ -96,15 +93,43 @@ fun <K, V> MutableMap<K, V>.applyDiff(
 }
 
 /**
- * Will apply changes with [other] map into [this] one
+ * Will apply changes with [from] map into [this] one
+ *
+ * @param compareFun Will be used to determine changed values
+ *
+ * @return [MapDiff] applied to [this] [MutableMap]
+ */
+fun <K, V> MutableMap<K, V>.applyDiff(
+    from: Map<K, V>,
+    compareFun: (K, V, V) -> Boolean
+): MapDiff<K, V> {
+    return diff(from, compareFun).also {
+        applyDiff(it)
+    }
+}
+
+/**
+ * Will apply changes with [from] map into [this] one
  *
  * @param strictComparison If true, will use strict (===) comparison for the values' comparison. Otherwise, standard
  * `equals` will be used
+ *
+ * @return [MapDiff] applied to [this] [MutableMap]
  */
 fun <K, V> MutableMap<K, V>.applyDiff(
-    other: Map<K, V>,
+    from: Map<K, V>,
     strictComparison: Boolean = false
-) = applyDiff(
-    other,
+): MapDiff<K, V> = applyDiff(
+    from,
     compareFun = createCompareFun(strictComparison)
 )
+
+/**
+ * Reverse [this] [MapDiff]. Result will contain [MapDiff.added] on [MapDiff.removed] (and vice-verse), all the
+ * [MapDiff.changed] values will be reversed too
+ */
+fun <K, V> MapDiff<K, V>.reversed(): MapDiff<K, V> = MapDiff(
+    removed = added,
+    changed = changed.mapValues { (_, oldNew) -> oldNew.second to oldNew.first },
+    added = removed
+)