concepts/*: 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: petertseng

concepts/destructuring/about.md

@@ -32,7 +32,7 @@ struct ArabianNights {
 let teller = ArabianNights { name: "Scheherazade".into(), stories: 1001 };
 {
     let ArabianNights { name, stories } = teller;
-    println!("{} told {} stories", name, stories);
+    println!("{name} told {stories} stories");
 }
 ```
 
@@ -42,7 +42,7 @@ The `..` operator can be used to ignore some fields when destructuring:
 
 ```rust
 let ArabianNights { name, .. } = teller;
-println!("{} survived by her wits", name);
+println!("{name} survived by her wits");
 ```
 
 ## Conditional Destructuring
@@ -51,6 +51,6 @@ Destructuring structs and tuples is infallible. However, enums can also be destr
 
 ```rust
 if let Some(foo) = foo {
-    println!("{:?}", foo);
+    println!("{foo:?}");
 }
 ```

concepts/fold/about.md

@@ -12,7 +12,7 @@ Once the iterator drains, the final value of the accumulator is returned.
 ```rust
 pub fn main() {
     let even_sum = (1..=10).fold(0, |acc, num| if num % 2 == 0 { acc + num } else { acc });
-    println!("{:?}", even_sum);
+    println!("{even_sum:?}");
 }
 ```
 
@@ -39,7 +39,7 @@ pub fn giant_grunts(initial: char) -> String {
 
 pub fn main() {
     let song = giant_grunts('F');
-    println!("{:?}", song);
+    println!("{song:?}");
 }
 ```
 

concepts/functions/about.md

@@ -23,7 +23,7 @@ In the following example the function takes in one parameter of type `i32`, bind
 
 ```rust
 fn print_integer(value: i32) {
-    println!("{:?}", value);
+    println!("{value:?}");
 }
 ```
 

concepts/hashmap/about.md

@@ -25,7 +25,7 @@ Other than the indexing operator, there are two other ways of accessing values s
 
 ```rust
 if let Some(blue_score) = scores.get("Blue") {
-    println!("Blue scored: {} \n", blue_score);
+    println!("Blue scored: {blue_score} \n");
 }
 ```
 
@@ -41,7 +41,7 @@ for vote in votes {
     *count += 1;
 }
 
-println!("{:#?}", vote_counter);
+println!("{vote_counter:#?}");
 ```
 
 This API makes certain common access patterns very convenient; it has an entire concept (Entry API) dedicated to it.

concepts/iterators/introduction.md

@@ -23,6 +23,6 @@ assert_eq!(None, iter.next());
 
 // Loop over iterators with built-in methods, such as `map` and `collect`
 let w: HashMap<_, _> = v.into_iter().map(|x| (x, x + 1)).collect();
-println!("{:?}", w);
+println!("{w:?}");
 // => {1: 2, 0: 1, 2: 3}
-```
+```

concepts/loops/about.md

@@ -36,7 +36,7 @@ fn main() {
     let a = [10, 20, 30, 40, 50];
 
     for x in a {
-        println!("the value is: {}", x);
+        println!("the value is: {x}");
     }
 }
 ```
@@ -46,7 +46,7 @@ Ranges are iterators too, which makes iterating through them with the `for` loop
 ```rust
 fn main() {
     for x in 0..10 {
-        println!("the value is: {}", x);
+        println!("the value is: {x}");
     }
 }
 ```

concepts/match-basics/about.md

@@ -36,7 +36,7 @@ fn ordinal(n: u32) -> String {
         3 => "rd",
         _ => "th",
     };
-    format!("{}{}", n, ordinal)
+    format!("{n}{ordinal}")
 }
 ```
 
@@ -105,7 +105,7 @@ impl<E: std::fmt::Display> OrLog for Result<(), E> {
             // discard Ok results
             Ok(()) => {},
             // log errors
-            Err(err) => println!("ERROR: {}", err),
+            Err(err) => println!("ERROR: {err}"),
         }
     }
 }

concepts/references/about.md

@@ -7,13 +7,13 @@ For example:
 fn log(msg: String) { // msg takes ownership of the value passed to it
     let formatted_datetime = String::new();
     // code  to format current datetime snipped
-    println!("{} at {}", msg, formatted_datetime);
+    println!("{msg} at {formatted_datetime}");
 } // msg is dropped here
 
 pub fn main() {
     let my_string = "Something happened".to_string();
     log(my_string); // passing my_string transfers ownership of its value to msg
-    //println!("{:?}", my_string); // uncommenting this line will error because my_string's value has been dropped while owned by msg
+    //println!("{my_string:?}"); // uncommenting this line will error because my_string's value has been dropped while owned by msg
 }
 ```
 
@@ -30,13 +30,13 @@ for the duration of that function.
 fn log(msg: &String) { //msg is defined as a reference with an ampersand
     let formatted_datetime: String;
     // code  to format current datetime snipped
-    println!("{} at {}", msg, formatted_datetime);
+    println!("{msg} at {formatted_datetime}");
 }
 
 pub fn main() {
     let my_string = "Something happened".to_string();
     log(&my_string); // my_string is passed as a reference with an ampersand
-    println!("{:?}", my_string);
+    println!("{my_string:?}");
 }
 ```
 
@@ -119,9 +119,9 @@ fn add_five(counter: &mut i32) { //counter is defined as a mutable reference
 
 pub fn main() {
     let mut my_count = 0; // my_count must be defined as mutable
-    println!("{:?}", my_count);
+    println!("{my_count:?}");
     add_five(&mut my_count); // my_count is passed as a mutable reference
-    println!("{:?}", my_count);
+    println!("{my_count:?}");
 }
 ```
 
@@ -138,11 +138,11 @@ fn add_five(counter: &mut i32) {
 
 pub fn main() {
     let mut my_count = 0;
-    println!("{:?}", my_count);
+    println!("{my_count:?}");
     let mut my_count2 = &mut my_count; // first mutable reference to my_count
     add_five(&mut my_count); // this errors because my_count's mutable borrow by my_count2 will be used on the next line
     add_five(my_count2);
-    println!("{:?}", my_count);
+    println!("{my_count:?}");
 }
 ```
 
@@ -155,11 +155,11 @@ fn add_five(counter: &mut i32) {
 
 pub fn main() {
     let mut my_count = 0;
-    println!("{:?}", my_count);
+    println!("{my_count:?}");
     let mut my_count2 = &mut my_count; // first mutable reference to my_count
     add_five(my_count2); // my_count2's borrow of my_count is not used afer this point
     add_five(&mut my_count); // compiler allows second mutable borrow of my_count
-    println!("{:?}", my_count); // because it does not conflict with first mutable borrow
+    println!("{my_count:?}"); // because it does not conflict with first mutable borrow
 }
 ```
 

concepts/string-slices/about.md

@@ -41,7 +41,7 @@ pub fn main() {
 }
 
 fn say_hi(phrase: &String) {
-    println!("{:?}", phrase);
+    println!("{phrase:?}");
 }
 
 // mismatched types
@@ -58,7 +58,7 @@ pub fn main() {
 }
 
 fn say_hi(phrase: &str) {
-    println!("{:?}", phrase);
+    println!("{phrase:?}");
 }
 ```
 

concepts/string-vs-str/about.md

@@ -39,7 +39,7 @@ println!("n_chars = {}", n_chars);             // 25
 println!("example.len() = {}", example.len()); // 27
 
 println!("final char: {}", example.chars().nth(n_chars-1).unwrap()); // ❤
-println!("final byte: {}", final_byte);                              // 164
+println!("final byte: {final_byte}");                                // 164
 println!("char of final byte: {}", final_byte as char);              // ¤
 ```