Merge pull request #1623 from remlse/clippy-warnings

fix new clippy and shellcheck errors

Author: petertseng

_test/count_ignores.sh

@@ -25,6 +25,12 @@ for e in "$repo"/exercises/*/*; do
       done
       want_ignores=$((total_tests - 1))
       if [ "$total_ignores" != "$want_ignores" ]; then
+        # ShellCheck wants us to use printf,
+        # but there are no other uses of printf in this repo,
+        # so printf hasn't been tested to work yet.
+        # (We would not be opposed to using printf and removing this disable;
+        # we just haven't tested it to confirm it works yet).
+        # shellcheck disable=SC2028
         echo "\033[1;31m$e: Has $total_tests tests and $total_ignores ignores (should be $want_ignores)\033[0m"
         exitcode=1
       fi

bin/test-exercise

@@ -92,7 +92,7 @@ done
 # run tests from within exercise directory
 # (use subshell so we auto-reset to current pwd after)
 (
-   cd $exercise
+   cd "$exercise"
    if [ -n "$CLIPPY" ]; then
      # Consider any Clippy to be an error in tests only.
      # For now, not the example solutions since they have many Clippy warnings,

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
 }
 ```