exercises/*: inline variables in format! strings

https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args

Non-inlined code is slightly more difficult to read and understand, as
it requires arguments to be matched against the format string. The
inlined syntax, where allowed, is simpler.

Author: senekor

exercises/concept/resistor-color/.meta/exemplar.rs

@@ -22,7 +22,7 @@ pub fn color_to_value(color: ResistorColor) -> usize {
 
 pub fn value_to_color_string(value: usize) -> String {
     ResistorColor::from_int(value)
-        .map(|color| format!("{:?}", color))
+        .map(|color| format!("{color:?}"))
         .unwrap_or_else(|_| "value out of range".into())
 }
 

exercises/concept/semi-structured-logs/.meta/exemplar.rs

@@ -10,15 +10,15 @@ pub fn log(level: LogLevel, message: &str) -> String {
         LogLevel::Info => info(message),
         LogLevel::Warning => warn(message),
         LogLevel::Error => error(message),
-        LogLevel::Debug => format!("[DEBUG]: {}", message),
+        LogLevel::Debug => format!("[DEBUG]: {message}"),
     }
 }
 pub fn info(message: &str) -> String {
-    format!("[INFO]: {}", message)
+    format!("[INFO]: {message}")
 }
 pub fn warn(message: &str) -> String {
-    format!("[WARNING]: {}", message)
+    format!("[WARNING]: {message}")
 }
 pub fn error(message: &str) -> String {
-    format!("[ERROR]: {}", message)
+    format!("[ERROR]: {message}")
 }

exercises/practice/affine-cipher/tests/affine-cipher.rs

@@ -62,13 +62,9 @@ fn encode_with_a_not_coprime_to_m() {
     const EXPECTED_ERROR: AffineCipherError = AffineCipherError::NotCoprime(6);
     match encode("This is a test.", 6, 17) {
         Err(EXPECTED_ERROR) => (),
-        Err(err) => panic!(
-            "Incorrect error: expected: {:?}, actual: {:?}.",
-            EXPECTED_ERROR, err
-        ),
+        Err(err) => panic!("Incorrect error: expected: {EXPECTED_ERROR:?}, actual: {err:?}."),
         Ok(r) => panic!(
-            "Cannot encode/decode when a is coprime to m: expected: {:?}, actual: {:?}.",
-            EXPECTED_ERROR, r
+            "Cannot encode/decode when a is coprime to m: expected: {EXPECTED_ERROR:?}, actual: {r:?}."
         ),
     }
 }
@@ -134,13 +130,9 @@ fn decode_with_a_not_coprime_to_m() {
     const EXPECTED_ERROR: AffineCipherError = AffineCipherError::NotCoprime(13);
     match decode("Test", 13, 11) {
         Err(EXPECTED_ERROR) => (),
-        Err(e) => panic!(
-            "Incorrect error: expected: {:?}, actual: {:?}.",
-            EXPECTED_ERROR, e
-        ),
+        Err(e) => panic!("Incorrect error: expected: {EXPECTED_ERROR:?}, actual: {e:?}."),
         Ok(r) => panic!(
-            "Cannot encode/decode when a is coprime to m: expected: {:?}, actual: {:?}.",
-            EXPECTED_ERROR, r
+            "Cannot encode/decode when a is coprime to m: expected: {EXPECTED_ERROR:?}, actual: {r:?}."
         ),
     }
 }

exercises/practice/allergies/tests/allergies.rs

@@ -3,17 +3,13 @@ use allergies::*;
 fn compare_allergy_vectors(expected: &[Allergen], actual: &[Allergen]) {
     for element in expected {
         if !actual.contains(element) {
-            panic!(
-                "Allergen missing\n  {:?} should be in {:?}",
-                element, actual
-            );
+            panic!("Allergen missing\n  {element:?} should be in {actual:?}");
         }
     }
 
     if actual.len() != expected.len() {
         panic!(
-            "Allergy vectors are of different lengths\n  expected {:?}\n  got {:?}",
-            expected, actual
+            "Allergy vectors are of different lengths\n  expected {expected:?}\n  got {actual:?}"
         );
     }
 }

exercises/practice/circular-buffer/src/lib.rs

@@ -16,7 +16,7 @@ impl<T> CircularBuffer<T> {
             "Construct a new CircularBuffer with the capacity to hold {}.",
             match capacity {
                 1 => "1 element".to_string(),
-                _ => format!("{} elements", capacity),
+                _ => format!("{capacity} elements"),
             }
         );
     }

exercises/practice/dominoes/tests/dominoes.rs

@@ -67,16 +67,15 @@ fn check(input: &[Domino]) -> CheckResult {
 fn assert_correct(input: &[Domino]) {
     match check(input) {
         Correct => (),
-        GotInvalid => panic!("Unexpectedly got invalid on input {:?}", input),
-        ChainingFailure(output) => panic!(
-            "Chaining failure for input {:?}, output {:?}",
-            input, output
-        ),
+        GotInvalid => panic!("Unexpectedly got invalid on input {input:?}"),
+        ChainingFailure(output) => {
+            panic!("Chaining failure for input {input:?}, output {output:?}")
+        }
         LengthMismatch(output) => {
-            panic!("Length mismatch for input {:?}, output {:?}", input, output)
+            panic!("Length mismatch for input {input:?}, output {output:?}")
         }
         DominoMismatch(output) => {
-            panic!("Domino mismatch for input {:?}, output {:?}", input, output)
+            panic!("Domino mismatch for input {input:?}, output {output:?}")
         }
     }
 }

exercises/practice/fizzy/tests/fizzy.rs

@@ -92,7 +92,7 @@ fn test_minimal_generic_bounds() {
     impl fmt::Display for Fizzable {
         fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
             let Fizzable(ref n) = self;
-            write!(f, "{}", n)
+            write!(f, "{n}")
         }
     }
 

exercises/practice/grep/tests/grep.rs

@@ -87,8 +87,7 @@ fn set_up_files(files: &[(&str, &str)]) {
     for (file_name, file_content) in files {
         fs::write(file_name, file_content).unwrap_or_else(|_| {
             panic!(
-                "Error setting up file '{}' with the following content:\n{}",
-                file_name, file_content
+                "Error setting up file '{file_name}' with the following content:\n{file_content}"
             )
         });
     }
@@ -97,7 +96,7 @@ fn set_up_files(files: &[(&str, &str)]) {
 fn tear_down_files(files: &[&str]) {
     for file_name in files {
         fs::remove_file(file_name)
-            .unwrap_or_else(|_| panic!("Could not delete file '{}'", file_name));
+            .unwrap_or_else(|_| panic!("Could not delete file '{file_name}'"));
     }
 }
 

exercises/practice/leap/tests/leap.rs

@@ -95,6 +95,6 @@ fn test_years_1600_to_1699() {
         .collect::<Vec<_>>();
 
     if !incorrect_years.is_empty() {
-        panic!("incorrect result for years: {:?}", incorrect_years);
+        panic!("incorrect result for years: {incorrect_years:?}");
     }
 }

exercises/practice/macros/tests/macros.rs

@@ -207,8 +207,7 @@ mod simple_trybuild {
         if let Ok(result) = result {
             assert!(
                 !result.status.success(),
-                "Expected {:?} to fail to compile, but it succeeded.",
-                file_path
+                "Expected {file_path:?} to fail to compile, but it succeeded."
             );
         } else {
             panic!("Running subprocess failed.");