cargo format

examples/floating-point.rs

@@ -9,10 +9,10 @@ fn main() {
     // Strict comparison would show many differences due to measurement noise
     // FP comparison with 0.05 tolerance treats small variations as equal
     let ops = capture_diff_slices_fp(
-        Algorithm::Myers, 
+        Algorithm::Myers,
-        &baseline_readings, 
+        &baseline_readings,
-        &current_readings, 
+        &current_readings,
-        0.05
+        0.05,
     );
 
     println!("Baseline: {:?}", baseline_readings);
@@ -20,7 +20,9 @@ fn main() {
     println!("With epsilon=0.05: {} diff operations", ops.len());
 
     for op in &ops {
-        let changes: Vec<_> = op.iter_changes(&baseline_readings, &current_readings).collect();
+        let changes: Vec<_> = op
+            .iter_changes(&baseline_readings, &current_readings)
+            .collect();
         for change in changes {
             match change.tag() {
                 ChangeTag::Equal => println!("  ✓ Equal: {}", change.value()),
@@ -41,8 +43,16 @@ fn main() {
     for &epsilon in &[0.0001, 0.001, 0.01] {
         let ops = capture_diff_slices_fp(Algorithm::Myers, &old, &new, epsilon);
         let all_equal = ops.len() == 1 && matches!(ops[0], likewise::DiffOp::Equal { len: 3, .. });
-        println!("  epsilon={}: {} ({})", epsilon, ops.len(), 
+        println!(
-                if all_equal { "all equal" } else { "differences found" });
+            "  epsilon={}: {} ({})",
+            epsilon,
+            ops.len(),
+            if all_equal {
+                "all equal"
+            } else {
+                "differences found"
+            }
+        );
     }
 
     // Example 3: Edge cases with NaN and infinity
@@ -61,5 +71,8 @@ fn main() {
     let new_f64 = vec![1.0000000000002, 2.0, 3.141592653589794];
 
     let ops_f64 = capture_diff_slices_fp_f64(Algorithm::Myers, &old_f64, &new_f64, 1e-12);
-    println!("f64 comparison with epsilon=1e-12: {} operations", ops_f64.len());
+    println!(
-}
+        "f64 comparison with epsilon=1e-12: {} operations",
+        ops_f64.len()
+    );
+}

src/algorithms/lcs.rs

@@ -320,5 +320,7 @@ pub fn diff_fp_f64_deadline<D>(
 where
     D: DiffHook,
 {
-    crate::algorithms::myers::diff_fp_f64_deadline(d, old, old_range, new, new_range, epsilon, deadline)
+    crate::algorithms::myers::diff_fp_f64_deadline(
+        d, old, old_range, new, new_range, epsilon, deadline,
+    )
 }

src/algorithms/mod.rs

@@ -132,4 +132,3 @@ where
 {
     diff_deadline(alg, d, old, 0..old.len(), new, 0..new.len(), deadline)
 }
-

src/algorithms/myers.rs

@@ -21,7 +21,10 @@
 
 use std::ops::{Index, IndexMut, Range};
 
-use crate::algorithms::utils::{common_prefix_len, common_suffix_len, common_prefix_len_fp, common_suffix_len_fp, common_prefix_len_fp_f64, common_suffix_len_fp_f64, is_empty_range};
+use crate::algorithms::utils::{
+    common_prefix_len, common_prefix_len_fp, common_prefix_len_fp_f64, common_suffix_len,
+    common_suffix_len_fp, common_suffix_len_fp_f64, is_empty_range,
+};
 use crate::algorithms::DiffHook;
 use crate::deadline_support::{deadline_exceeded, Instant};
 
@@ -457,7 +460,9 @@ where
     let max_d = max_d(old_range.len(), new_range.len());
     let mut vb = V::new(max_d);
     let mut vf = V::new(max_d);
-    conquer_fp(d, old, old_range, new, new_range, epsilon, &mut vf, &mut vb, deadline)?;
+    conquer_fp(
+        d, old, old_range, new, new_range, epsilon, &mut vf, &mut vb, deadline,
+    )?;
     d.finish()
 }
 
@@ -477,7 +482,9 @@ where
     let max_d = max_d(old_range.len(), new_range.len());
     let mut vb = V::new(max_d);
     let mut vf = V::new(max_d);
-    conquer_fp_f64(d, old, old_range, new, new_range, epsilon, &mut vf, &mut vb, deadline)?;
+    conquer_fp_f64(
+        d, old, old_range, new, new_range, epsilon, &mut vf, &mut vb, deadline,
+    )?;
     d.finish()
 }
 
@@ -681,7 +688,8 @@ where
     D: DiffHook,
 {
     // Check for common prefix
-    let common_prefix_len = common_prefix_len_fp(old, old_range.clone(), new, new_range.clone(), epsilon);
+    let common_prefix_len =
+        common_prefix_len_fp(old, old_range.clone(), new, new_range.clone(), epsilon);
     if common_prefix_len > 0 {
         d.equal(old_range.start, new_range.start, common_prefix_len)?;
     }
@@ -689,7 +697,8 @@ where
     new_range.start += common_prefix_len;
 
     // Check for common suffix
-    let common_suffix_len = common_suffix_len_fp(old, old_range.clone(), new, new_range.clone(), epsilon);
+    let common_suffix_len =
+        common_suffix_len_fp(old, old_range.clone(), new, new_range.clone(), epsilon);
     let common_suffix = (
         old_range.end - common_suffix_len,
         new_range.end - common_suffix_len,
@@ -753,7 +762,8 @@ where
     D: DiffHook,
 {
     // Check for common prefix
-    let common_prefix_len = common_prefix_len_fp_f64(old, old_range.clone(), new, new_range.clone(), epsilon);
+    let common_prefix_len =
+        common_prefix_len_fp_f64(old, old_range.clone(), new, new_range.clone(), epsilon);
     if common_prefix_len > 0 {
         d.equal(old_range.start, new_range.start, common_prefix_len)?;
     }
@@ -761,7 +771,8 @@ where
     new_range.start += common_prefix_len;
 
     // Check for common suffix
-    let common_suffix_len = common_suffix_len_fp_f64(old, old_range.clone(), new, new_range.clone(), epsilon);
+    let common_suffix_len =
+        common_suffix_len_fp_f64(old, old_range.clone(), new, new_range.clone(), epsilon);
     let common_suffix = (
         old_range.end - common_suffix_len,
         new_range.end - common_suffix_len,

src/algorithms/patience.rs

@@ -224,5 +224,7 @@ pub fn diff_fp_f64_deadline<D>(
 where
     D: DiffHook,
 {
-    crate::algorithms::myers::diff_fp_f64_deadline(d, old, old_range, new, new_range, epsilon, deadline)
+    crate::algorithms::myers::diff_fp_f64_deadline(
+        d, old, old_range, new, new_range, epsilon, deadline,
+    )
 }

src/common.rs

@@ -124,9 +124,15 @@ fn capture_diff_fp_deadline(
 ) -> Vec<DiffOp> {
     let mut d = Compact::new(Replace::new(Capture::new()), old, new);
     let result = match alg {
-        Algorithm::Myers => crate::algorithms::myers::diff_fp_deadline(&mut d, old, old_range, new, new_range, epsilon, deadline),
+        Algorithm::Myers => crate::algorithms::myers::diff_fp_deadline(
-        Algorithm::Patience => crate::algorithms::patience::diff_fp_deadline(&mut d, old, old_range, new, new_range, epsilon, deadline),
+            &mut d, old, old_range, new, new_range, epsilon, deadline,
-        Algorithm::Lcs => crate::algorithms::lcs::diff_fp_deadline(&mut d, old, old_range, new, new_range, epsilon, deadline),
+        ),
+        Algorithm::Patience => crate::algorithms::patience::diff_fp_deadline(
+            &mut d, old, old_range, new, new_range, epsilon, deadline,
+        ),
+        Algorithm::Lcs => crate::algorithms::lcs::diff_fp_deadline(
+            &mut d, old, old_range, new, new_range, epsilon, deadline,
+        ),
     };
     result.unwrap();
     d.into_inner().into_inner().into_ops()
@@ -143,9 +149,15 @@ fn capture_diff_fp_f64_deadline(
 ) -> Vec<DiffOp> {
     let mut d = Compact::new(Replace::new(Capture::new()), old, new);
     let result = match alg {
-        Algorithm::Myers => crate::algorithms::myers::diff_fp_f64_deadline(&mut d, old, old_range, new, new_range, epsilon, deadline),
+        Algorithm::Myers => crate::algorithms::myers::diff_fp_f64_deadline(
-        Algorithm::Patience => crate::algorithms::patience::diff_fp_f64_deadline(&mut d, old, old_range, new, new_range, epsilon, deadline),
+            &mut d, old, old_range, new, new_range, epsilon, deadline,
-        Algorithm::Lcs => crate::algorithms::lcs::diff_fp_f64_deadline(&mut d, old, old_range, new, new_range, epsilon, deadline),
+        ),
+        Algorithm::Patience => crate::algorithms::patience::diff_fp_f64_deadline(
+            &mut d, old, old_range, new, new_range, epsilon, deadline,
+        ),
+        Algorithm::Lcs => crate::algorithms::lcs::diff_fp_f64_deadline(
+            &mut d, old, old_range, new, new_range, epsilon, deadline,
+        ),
     };
     result.unwrap();
     d.into_inner().into_inner().into_ops()
@@ -268,10 +280,10 @@ fn test_non_string_iter_change() {
 fn test_fp_epsilon() {
     let old = vec![1.0, 2.0, 3.0];
     let new = vec![1.001, 2.0, 2.999];
-    
+
     let ops_tight = capture_diff_slices_fp(Algorithm::Myers, &old, &new, 0.0001);
     assert!(ops_tight.len() > 1);
-    
+
     let ops_loose = capture_diff_slices_fp(Algorithm::Myers, &old, &new, 0.01);
     assert_eq!(ops_loose.len(), 1);
 }
@@ -280,9 +292,7 @@ fn test_fp_epsilon() {
 fn test_fp_nan() {
     let old = vec![f32::NAN];
     let new = vec![f32::NAN];
-    
+
     let ops = capture_diff_slices_fp(Algorithm::Myers, &old, &new, 0.001);
     assert_eq!(ops.len(), 1);
 }
-
-