Some more saner variable names

src/algorithms/myers.rs

@@ -55,11 +55,11 @@ where
 pub(crate) fn diff_offsets<D, Old, New>(
     diff: &mut D,
     old: &Old,
-    i: usize,
+    old_current: usize,
-    i_: usize,
+    old_end: usize,
     new: &New,
-    j: usize,
+    new_current: usize,
-    j_: usize,
+    new_end: usize,
 ) -> Result<(), D::Error>
 where
     D: DiffHook + ?Sized,
@@ -67,9 +67,9 @@ where
     New: Index<usize> + ?Sized,
     New::Output: PartialEq<Old::Output>,
 {
-    if i_ > i && j_ > j {
+    if old_end > old_current && new_end > new_current {
-        let n = i_ - i;
+        let n = old_end - old_current;
-        let m = j_ - j;
+        let m = new_end - new_current;
         let l = (n + m) as isize;
         let z = (2 * min(n, m) + 2) as usize;
         let w = n as isize - m as isize;
@@ -102,7 +102,7 @@ where
                         } else {
                             (n - a - 1, m - b - 1)
                         };
-                        new[j + f_i] == old[i + e_i]
+                        new[new_current + f_i] == old[old_current + e_i]
                     } {
                         a += 1;
                         b += 1;
@@ -120,19 +120,35 @@ where
                             (n - a, m - b, n - s, m - t)
                         };
                         if h + bound > 1 || (x != u && y != v) {
-                            diff_offsets(diff, old, i, i + x, new, j, j + y)?;
+                            diff_offsets(
+                                diff,
+                                old,
+                                old_current,
+                                old_current + x,
+                                new,
+                                new_current,
+                                new_current + y,
+                            )?;
                             if x != u {
-                                diff.equal(i + x, j + y, u - x)?;
+                                diff.equal(old_current + x, new_current + y, u - x)?;
                             }
-                            diff_offsets(diff, old, i + u, i_, new, j + v, j_)?;
+                            diff_offsets(
+                                diff,
+                                old,
+                                old_current + u,
+                                old_end,
+                                new,
+                                new_current + v,
+                                new_end,
+                            )?;
                             return Ok(());
                         } else if m > n {
-                            diff.equal(i, j, n)?;
+                            diff.equal(old_current, new_current, n)?;
-                            diff.insert(i + n, j + n, m - n)?;
+                            diff.insert(old_current + n, new_current + n, m - n)?;
                             return Ok(());
                         } else if m < n {
-                            diff.equal(i, j, m)?;
+                            diff.equal(old_current, new_current, m)?;
-                            diff.delete(i + m, n - m, j + m)?;
+                            diff.delete(old_current + m, n - m, new_current + m)?;
                             return Ok(());
                         } else {
                             return Ok(());
@@ -141,10 +157,10 @@ where
                 }
             }
         }
-    } else if i_ > i {
+    } else if old_end > old_current {
-        diff.delete(i, i_ - i, j)?
+        diff.delete(old_current, old_end - old_current, new_current)?
-    } else if j_ > j {
+    } else if new_end > new_current {
-        diff.insert(i, j, j_ - j)?
+        diff.insert(old_current, new_current, new_end - new_current)?
     }
     Ok(())
 }

src/algorithms/patience.rs

@@ -68,13 +68,13 @@ where
 struct Patience<'old, 'new, 'd, Old: ?Sized, New: ?Sized, D> {
     d: &'d mut D,
     old: &'old Old,
+    old_current: usize,
+    old_end: usize,
+    old_indexes: &'old [Indexable<'old, Old>],
     new: &'new New,
-    current_old: usize,
+    new_current: usize,
-    end_old: usize,
+    new_end: usize,
-    current_new: usize,
+    new_indexes: &'new [Indexable<'new, New>],
-    end_new: usize,
-    indexes_old: &'old [Indexable<'old, Old>],
-    indexes_new: &'new [Indexable<'new, New>],
 }
 
 impl<'old, 'new, 'd, Old, New, D> DiffHook for Patience<'old, 'new, 'd, Old, New, D>
@@ -87,29 +87,29 @@ where
     type Error = D::Error;
     fn equal(&mut self, old: usize, new: usize, len: usize) -> Result<(), D::Error> {
         for (old, new) in (old..old + len).zip(new..new + len) {
-            let a0 = self.current_old;
+            let a0 = self.old_current;
-            let b0 = self.current_new;
+            let b0 = self.new_current;
-            while self.current_old < self.indexes_old[old].index
+            while self.old_current < self.old_indexes[old].index
-                && self.current_new < self.indexes_new[new].index
+                && self.new_current < self.new_indexes[new].index
-                && self.new[self.current_new] == self.old[self.current_old]
+                && self.new[self.new_current] == self.old[self.old_current]
             {
-                self.current_old += 1;
+                self.old_current += 1;
-                self.current_new += 1;
+                self.new_current += 1;
             }
-            if self.current_old > a0 {
+            if self.old_current > a0 {
-                self.d.equal(a0, b0, self.current_old - a0)?
+                self.d.equal(a0, b0, self.old_current - a0)?
             }
             myers::diff_offsets(
                 self.d,
                 self.old,
-                self.current_old,
+                self.old_current,
-                self.indexes_old[old].index,
+                self.old_indexes[old].index,
                 self.new,
-                self.current_new,
+                self.new_current,
-                self.indexes_new[new].index,
+                self.new_indexes[new].index,
             )?;
-            self.current_old = self.indexes_old[old].index;
+            self.old_current = self.old_indexes[old].index;
-            self.current_new = self.indexes_new[new].index;
+            self.new_current = self.new_indexes[new].index;
         }
         Ok(())
     }
@@ -118,9 +118,9 @@ where
         myers::diff(
             self.d,
             self.old,
-            self.current_old..self.end_old,
+            self.old_current..self.old_end,
             self.new,
-            self.current_new..self.end_new,
+            self.new_current..self.new_end,
         )
     }
 }
@@ -142,26 +142,26 @@ where
     New::Output: PartialEq<Old::Output> + Hash + Eq,
     D: DiffHook,
 {
-    let indexes_old = unique(old, old_range.start, old_range.end);
+    let old_indexes = unique(old, old_range.start, old_range.end);
-    let indexes_new = unique(new, old_range.start, old_range.end);
+    let new_indexes = unique(new, old_range.start, old_range.end);
 
     let mut d = Replace::new(Patience {
         d,
         old,
+        old_current: old_range.start,
+        old_end: old_range.end,
+        old_indexes: &old_indexes,
         new,
-        current_old: old_range.start,
+        new_current: new_range.start,
-        end_old: old_range.end,
+        new_end: new_range.end,
-        current_new: new_range.start,
+        new_indexes: &new_indexes,
-        end_new: new_range.end,
-        indexes_old: &indexes_old,
-        indexes_new: &indexes_new,
     });
     myers::diff(
         &mut d,
-        &indexes_old,
+        &old_indexes,
-        0..indexes_old.len(),
+        0..old_indexes.len(),
-        &indexes_new,
+        &new_indexes,
-        0..indexes_new.len(),
+        0..new_indexes.len(),
     )?;
     Ok(())
 }