style: inline format args

FreezyLemon · YeungOnion · commit 1f8e00ab6773 · 2024-09-10T10:58:25.000-05:00
Stable since 1.58.0
diff --git a/src/distribution/chi.rs b/src/distribution/chi.rs
@@ -381,7 +381,7 @@ mod tests {
     fn test_large_dof_mean_not_nan() {
         for i in 1..1000 {
             let mean = Chi::new(i as f64).unwrap().mean().unwrap();
-            assert!(!mean.is_nan(), "Chi mean for {} dof was {}", i, mean);
+            assert!(!mean.is_nan(), "Chi mean for {i} dof was {mean}");
         }
     }
 
diff --git a/src/distribution/empirical.rs b/src/distribution/empirical.rs
@@ -159,13 +159,13 @@ impl std::fmt::Display for Empirical {
             .flat_map(|(&NonNan(x), &count)| std::iter::repeat(x).take(count as usize));
 
         if let Some(x) = enumerated_values.next() {
-            write!(f, "Empirical([{:.3e}", x)?;
+            write!(f, "Empirical([{x:.3e}")?;
         } else {
             return write!(f, "Empirical(∅)");
         }
 
         for val in enumerated_values.by_ref().take(4) {
-            write!(f, ", {:.3e}", val)?;
+            write!(f, ", {val:.3e}")?;
         }
         if enumerated_values.next().is_some() {
             write!(f, ", ...")?;
diff --git a/src/distribution/internal.rs b/src/distribution/internal.rs
@@ -377,8 +377,8 @@ pub mod test {
             let cdf = dist.cdf(x);
             if (sum - cdf).abs() > 1e-3 {
                 println!("Integral of pdf doesn't equal cdf!");
-                println!("Integration from {} by {} to {} = {}", x_min, step, x, sum);
-                println!("cdf = {}", cdf);
+                println!("Integration from {x_min} by {step} to {x} = {sum}");
+                println!("cdf = {cdf}");
                 panic!();
             }
 
diff --git a/src/distribution/laplace.rs b/src/distribution/laplace.rs
@@ -588,9 +588,7 @@ mod tests {
             });
             assert!(
                 result > -tolerance && result < tolerance,
-                "Balance is {} for seed {}",
-                result,
-                seed
+                "Balance is {result} for seed {seed}"
             );
         }
     }
diff --git a/src/distribution/uniform.rs b/src/distribution/uniform.rs
@@ -168,7 +168,7 @@ impl ContinuousCDF<f64, f64> for Uniform {
     /// Finds the value of `x` where `F(p) = x`
     fn inverse_cdf(&self, p: f64) -> f64 {
         if !(0.0..=1.0).contains(&p) {
-            panic!("p must be in [0, 1], was {}", p);
+            panic!("p must be in [0, 1], was {p}");
         } else if p == 0.0 {
             self.min
         } else if p == 1.0 {
diff --git a/src/error.rs b/src/error.rs
@@ -56,50 +56,50 @@ impl fmt::Display for StatsError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
             StatsError::BadParams => write!(f, "Bad distribution parameters"),
-            StatsError::ArgFinite(s) => write!(f, "Argument {} must be finite", s),
-            StatsError::ArgMustBePositive(s) => write!(f, "Argument {} must be positive", s),
-            StatsError::ArgNotNegative(s) => write!(f, "Argument {} must be non-negative", s),
+            StatsError::ArgFinite(s) => write!(f, "Argument {s} must be finite"),
+            StatsError::ArgMustBePositive(s) => write!(f, "Argument {s} must be positive"),
+            StatsError::ArgNotNegative(s) => write!(f, "Argument {s} must be non-negative"),
             StatsError::ArgIntervalIncl(s, min, max) => {
-                write!(f, "Argument {} not within interval [{}, {}]", s, min, max)
+                write!(f, "Argument {s} not within interval [{min}, {max}]")
             }
             StatsError::ArgIntervalExcl(s, min, max) => {
-                write!(f, "Argument {} not within interval ({}, {})", s, min, max)
+                write!(f, "Argument {s} not within interval ({min}, {max})")
             }
             StatsError::ArgIntervalExclMin(s, min, max) => {
-                write!(f, "Argument {} not within interval ({}, {}]", s, min, max)
+                write!(f, "Argument {s} not within interval ({min}, {max}]")
             }
             StatsError::ArgIntervalExclMax(s, min, max) => {
-                write!(f, "Argument {} not within interval [{}, {})", s, min, max)
+                write!(f, "Argument {s} not within interval [{min}, {max})")
             }
-            StatsError::ArgGt(s, val) => write!(f, "Argument {} must be greater than {}", s, val),
+            StatsError::ArgGt(s, val) => write!(f, "Argument {s} must be greater than {val}"),
             StatsError::ArgGtArg(s, val) => {
-                write!(f, "Argument {} must be greater than {}", s, val)
+                write!(f, "Argument {s} must be greater than {val}")
             }
             StatsError::ArgGte(s, val) => {
-                write!(f, "Argument {} must be greater than or equal to {}", s, val)
+                write!(f, "Argument {s} must be greater than or equal to {val}")
             }
             StatsError::ArgGteArg(s, val) => {
-                write!(f, "Argument {} must be greater than or equal to {}", s, val)
+                write!(f, "Argument {s} must be greater than or equal to {val}")
             }
-            StatsError::ArgLt(s, val) => write!(f, "Argument {} must be less than {}", s, val),
-            StatsError::ArgLtArg(s, val) => write!(f, "Argument {} must be less than {}", s, val),
+            StatsError::ArgLt(s, val) => write!(f, "Argument {s} must be less than {val}"),
+            StatsError::ArgLtArg(s, val) => write!(f, "Argument {s} must be less than {val}"),
             StatsError::ArgLte(s, val) => {
-                write!(f, "Argument {} must be less than or equal to {}", s, val)
+                write!(f, "Argument {s} must be less than or equal to {val}")
             }
             StatsError::ArgLteArg(s, val) => {
-                write!(f, "Argument {} must be less than or equal to {}", s, val)
+                write!(f, "Argument {s} must be less than or equal to {val}")
             }
             StatsError::ContainersMustBeSameLength => {
                 write!(f, "Expected containers of same length")
             }
             StatsError::ComputationFailedToConverge => write!(f, "Computation failed to converge"),
             StatsError::ContainerExpectedSum(s, sum) => {
-                write!(f, "Elements in container {} expected to sum to {}", s, sum)
+                write!(f, "Elements in container {s} expected to sum to {sum}")
             }
             StatsError::ContainerExpectedSumVar(s, sum) => {
-                write!(f, "Elements in container {} expected to sum to {}", s, sum)
+                write!(f, "Elements in container {s} expected to sum to {sum}")
             }
-            StatsError::SpecialCase(s) => write!(f, "{}", s),
+            StatsError::SpecialCase(s) => write!(f, "{s}"),
         }
     }
 }
diff --git a/src/generate.rs b/src/generate.rs
@@ -83,7 +83,7 @@ impl InfinitePeriodic {
 
 impl std::fmt::Display for InfinitePeriodic {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{:#?}", self)
+        write!(f, "{self:#?}")
     }
 }
 
diff --git a/src/statistics/slice_statistics.rs b/src/statistics/slice_statistics.rs
@@ -14,11 +14,11 @@ where
         write!(f, "Data([")?;
 
         if let Some(v) = tee.next() {
-            write!(f, "{}", v)?;
+            write!(f, "{v}")?;
         }
         for _ in 1..5 {
             if let Some(v) = tee.next() {
-                write!(f, ", {}", v)?;
+                write!(f, ", {v}")?;
             }
         }
         if tee.next().is_some() {
diff --git a/src/stats_tests/fisher.rs b/src/stats_tests/fisher.rs
@@ -111,7 +111,7 @@ impl std::fmt::Display for FishersExactTestError {
             FishersExactTestError::TableInvalidForHypergeometric(hg_err) => {
                 writeln!(f, "Cannot create a Hypergeometric distribution from the data in the contingency table.")?;
                 writeln!(f, "Is it in row-major order?")?;
-                write!(f, "Inner error: '{}'", hg_err)
+                write!(f, "Inner error: '{hg_err}'")
             }
         }
     }
diff --git a/tests/nist_tests.rs b/tests/nist_tests.rs
@@ -76,7 +76,7 @@ fn nist_strd_univariate_mean() {
     for fname in FILENAMES {
         let filepath = get_path(fname, env::var(NIST_DATA_DIR_ENV).ok().as_deref());
         let case = parse_file(filepath)
-            .unwrap_or_else(|e| panic!("failed parsing file {} with `{:?}`", fname, e));
+            .unwrap_or_else(|e| panic!("failed parsing file {fname} with `{e:?}`"));
         assert_relative_eq!(case.values.mean(), case.certified.mean, epsilon = 1e-12);
     }
 }
@@ -87,7 +87,7 @@ fn nist_strd_univariate_std_dev() {
     for fname in FILENAMES {
         let filepath = get_path(fname, env::var(NIST_DATA_DIR_ENV).ok().as_deref());
         let case = parse_file(filepath)
-            .unwrap_or_else(|e| panic!("failed parsing file {} with `{:?}`", fname, e));
+            .unwrap_or_else(|e| panic!("failed parsing file {fname} with `{e:?}`"));
         assert_relative_eq!(
             case.values.std_dev(),
             case.certified.std_dev,

Original file line number	Diff line number	Diff line change
`@@ -381,7 +381,7 @@ mod tests {`
`381`	`381`	`fn test_large_dof_mean_not_nan() {`
`382`	`382`	`for i in 1..1000 {`
`383`	`383`	`let mean = Chi::new(i as f64).unwrap().mean().unwrap();`
`384`		`- assert!(!mean.is_nan(), "Chi mean for {} dof was {}", i, mean);`
	`384`	`+ assert!(!mean.is_nan(), "Chi mean for {i} dof was {mean}");`
`385`	`385`	`}`
`386`	`386`	`}`
`387`	`387`
Original file line number	Diff line number	Diff line change
`@@ -159,13 +159,13 @@ impl std::fmt::Display for Empirical {`
`159`	`159`	`.flat_map(\|(&NonNan(x), &count)\| std::iter::repeat(x).take(count as usize));`
`160`	`160`
`161`	`161`	`if let Some(x) = enumerated_values.next() {`
`162`		`- write!(f, "Empirical([{:.3e}", x)?;`
	`162`	`+ write!(f, "Empirical([{x:.3e}")?;`
`163`	`163`	`} else {`
`164`	`164`	`return write!(f, "Empirical(∅)");`
`165`	`165`	`}`
`166`	`166`
`167`	`167`	`for val in enumerated_values.by_ref().take(4) {`
`168`		`- write!(f, ", {:.3e}", val)?;`
	`168`	`+ write!(f, ", {val:.3e}")?;`
`169`	`169`	`}`
`170`	`170`	`if enumerated_values.next().is_some() {`
`171`	`171`	`write!(f, ", ...")?;`
Original file line number	Diff line number	Diff line change
`@@ -588,9 +588,7 @@ mod tests {`
`588`	`588`	`});`
`589`	`589`	`assert!(`
`590`	`590`	`result > -tolerance && result < tolerance,`
`591`		`- "Balance is {} for seed {}",`
`592`		`- result,`
`593`		`- seed`
	`591`	`+ "Balance is {result} for seed {seed}"`
`594`	`592`	`);`
`595`	`593`	`}`
`596`	`594`	`}`
Original file line number	Diff line number	Diff line change
`@@ -56,50 +56,50 @@ impl fmt::Display for StatsError {`
`56`	`56`	`fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`57`	`57`	`match *self {`
`58`	`58`	`StatsError::BadParams => write!(f, "Bad distribution parameters"),`
`59`		`- StatsError::ArgFinite(s) => write!(f, "Argument {} must be finite", s),`
`60`		`- StatsError::ArgMustBePositive(s) => write!(f, "Argument {} must be positive", s),`
`61`		`- StatsError::ArgNotNegative(s) => write!(f, "Argument {} must be non-negative", s),`
	`59`	`+ StatsError::ArgFinite(s) => write!(f, "Argument {s} must be finite"),`
	`60`	`+ StatsError::ArgMustBePositive(s) => write!(f, "Argument {s} must be positive"),`
	`61`	`+ StatsError::ArgNotNegative(s) => write!(f, "Argument {s} must be non-negative"),`
`62`	`62`	`StatsError::ArgIntervalIncl(s, min, max) => {`
`63`		`- write!(f, "Argument {} not within interval [{}, {}]", s, min, max)`
	`63`	`+ write!(f, "Argument {s} not within interval [{min}, {max}]")`
`64`	`64`	`}`
`65`	`65`	`StatsError::ArgIntervalExcl(s, min, max) => {`
`66`		`- write!(f, "Argument {} not within interval ({}, {})", s, min, max)`
	`66`	`+ write!(f, "Argument {s} not within interval ({min}, {max})")`
`67`	`67`	`}`
`68`	`68`	`StatsError::ArgIntervalExclMin(s, min, max) => {`
`69`		`- write!(f, "Argument {} not within interval ({}, {}]", s, min, max)`
	`69`	`+ write!(f, "Argument {s} not within interval ({min}, {max}]")`
`70`	`70`	`}`
`71`	`71`	`StatsError::ArgIntervalExclMax(s, min, max) => {`
`72`		`- write!(f, "Argument {} not within interval [{}, {})", s, min, max)`
	`72`	`+ write!(f, "Argument {s} not within interval [{min}, {max})")`
`73`	`73`	`}`
`74`		`- StatsError::ArgGt(s, val) => write!(f, "Argument {} must be greater than {}", s, val),`
	`74`	`+ StatsError::ArgGt(s, val) => write!(f, "Argument {s} must be greater than {val}"),`
`75`	`75`	`StatsError::ArgGtArg(s, val) => {`
`76`		`- write!(f, "Argument {} must be greater than {}", s, val)`
	`76`	`+ write!(f, "Argument {s} must be greater than {val}")`
`77`	`77`	`}`
`78`	`78`	`StatsError::ArgGte(s, val) => {`
`79`		`- write!(f, "Argument {} must be greater than or equal to {}", s, val)`
	`79`	`+ write!(f, "Argument {s} must be greater than or equal to {val}")`
`80`	`80`	`}`
`81`	`81`	`StatsError::ArgGteArg(s, val) => {`
`82`		`- write!(f, "Argument {} must be greater than or equal to {}", s, val)`
	`82`	`+ write!(f, "Argument {s} must be greater than or equal to {val}")`
`83`	`83`	`}`
`84`		`- StatsError::ArgLt(s, val) => write!(f, "Argument {} must be less than {}", s, val),`
`85`		`- StatsError::ArgLtArg(s, val) => write!(f, "Argument {} must be less than {}", s, val),`
	`84`	`+ StatsError::ArgLt(s, val) => write!(f, "Argument {s} must be less than {val}"),`
	`85`	`+ StatsError::ArgLtArg(s, val) => write!(f, "Argument {s} must be less than {val}"),`
`86`	`86`	`StatsError::ArgLte(s, val) => {`
`87`		`- write!(f, "Argument {} must be less than or equal to {}", s, val)`
	`87`	`+ write!(f, "Argument {s} must be less than or equal to {val}")`
`88`	`88`	`}`
`89`	`89`	`StatsError::ArgLteArg(s, val) => {`
`90`		`- write!(f, "Argument {} must be less than or equal to {}", s, val)`
	`90`	`+ write!(f, "Argument {s} must be less than or equal to {val}")`
`91`	`91`	`}`
`92`	`92`	`StatsError::ContainersMustBeSameLength => {`
`93`	`93`	`write!(f, "Expected containers of same length")`
`94`	`94`	`}`
`95`	`95`	`StatsError::ComputationFailedToConverge => write!(f, "Computation failed to converge"),`
`96`	`96`	`StatsError::ContainerExpectedSum(s, sum) => {`
`97`		`- write!(f, "Elements in container {} expected to sum to {}", s, sum)`
	`97`	`+ write!(f, "Elements in container {s} expected to sum to {sum}")`
`98`	`98`	`}`
`99`	`99`	`StatsError::ContainerExpectedSumVar(s, sum) => {`
`100`		`- write!(f, "Elements in container {} expected to sum to {}", s, sum)`
	`100`	`+ write!(f, "Elements in container {s} expected to sum to {sum}")`
`101`	`101`	`}`
`102`		`- StatsError::SpecialCase(s) => write!(f, "{}", s),`
	`102`	`+ StatsError::SpecialCase(s) => write!(f, "{s}"),`
`103`	`103`	`}`
`104`	`104`	`}`
`105`	`105`	`}`
Original file line number	Diff line number	Diff line change
`@@ -83,7 +83,7 @@ impl InfinitePeriodic {`
`83`	`83`
`84`	`84`	`impl std::fmt::Display for InfinitePeriodic {`
`85`	`85`	`fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {`
`86`		`- write!(f, "{:#?}", self)`
	`86`	`+ write!(f, "{self:#?}")`
`87`	`87`	`}`
`88`	`88`	`}`
`89`	`89`
Original file line number	Diff line number	Diff line change
`@@ -14,11 +14,11 @@ where`
`14`	`14`	`write!(f, "Data([")?;`
`15`	`15`
`16`	`16`	`if let Some(v) = tee.next() {`
`17`		`- write!(f, "{}", v)?;`
	`17`	`+ write!(f, "{v}")?;`
`18`	`18`	`}`
`19`	`19`	`for _ in 1..5 {`
`20`	`20`	`if let Some(v) = tee.next() {`
`21`		`- write!(f, ", {}", v)?;`
	`21`	`+ write!(f, ", {v}")?;`
`22`	`22`	`}`
`23`	`23`	`}`
`24`	`24`	`if tee.next().is_some() {`
Original file line number	Diff line number	Diff line change
`@@ -111,7 +111,7 @@ impl std::fmt::Display for FishersExactTestError {`
`111`	`111`	`FishersExactTestError::TableInvalidForHypergeometric(hg_err) => {`
`112`	`112`	`writeln!(f, "Cannot create a Hypergeometric distribution from the data in the contingency table.")?;`
`113`	`113`	`writeln!(f, "Is it in row-major order?")?;`
`114`		`- write!(f, "Inner error: '{}'", hg_err)`
	`114`	`+ write!(f, "Inner error: '{hg_err}'")`
`115`	`115`	`}`
`116`	`116`	`}`
`117`	`117`	`}`