fix all clippy warnings

Author: oadam

src/game.rs

@@ -2,10 +2,11 @@ use halfbrown::HashMap;
 use smallvec::{smallvec, SmallVec};
 use std::collections::BinaryHeap;
 use std::fmt;
+use std::fmt::Write;
 
 use crate::{score::Score, score_cache::ScoreCache};
 
-const NON_WINNING_SCORES_COUNT: usize = (3 as usize).pow(5) - 1;
+const NON_WINNING_SCORES_COUNT: usize = 3_usize.pow(5) - 1;
 const SMALLVEC_MAX: usize = 4;
 
 type WordIndex = u16;
@@ -50,18 +51,18 @@ struct Guess<'a> {
 
 impl<'a> Ord for Guess<'a> {
     fn cmp(&self, other: &Self) -> std::cmp::Ordering {
-        return other.avg_score.partial_cmp(&self.avg_score).unwrap();
+        other.avg_score.partial_cmp(&self.avg_score).unwrap()
     }
 }
 impl<'a> PartialOrd for Guess<'a> {
     fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        return Some(self.cmp(other));
+        Some(self.cmp(other))
     }
 }
 impl<'a> Eq for Guess<'a> {}
 impl<'a> PartialEq for Guess<'a> {
     fn eq(&self, other: &Self) -> bool {
-        return self.guess == other.guess;
+        self.guess == other.guess
     }
 }
 
@@ -121,37 +122,33 @@ impl<'a> Game<'a> {
         }
     }
 
-    pub fn print_current_best_score(&self, words: &'a Vec<String>) -> String {
+    pub fn print_current_best_score(&self, words: &'a [String]) -> String {
         if let Game::Large(g) = self {
             if let OptimizationStatus::InProgress(ref heap) = g.optimization {
                 let mut result = String::new();
                 for c in heap.iter().take(3) {
-                    result.push_str(&format!("{}-{} ", words[c.guess as usize], c.avg_score));
+                    write!(result, "{}-{} ", words[c.guess as usize], c.avg_score).unwrap();
                 }
                 return result;
             }
         }
         String::from("optimization is over")
     }
 
-    pub fn print_tree(&self, words: &'a Vec<String>) -> String {
+    pub fn print_tree(&self, words: &'a [String]) -> String {
         match self {
             Game::Single(w) => format!("{} !", words[*w as usize]),
             Game::Double(w1, w2) => format!("{} or {} !", words[*w1 as usize], words[*w2 as usize]),
             Game::Large(g) => {
                 if let OptimizationStatus::Done(ref guess) = g.optimization {
                     let word = &words[guess.guess as usize];
-                    if guess.subgames.len() == 0 {
-                        word.clone() + "!"
-                    } else {
-                        let mut lines: Vec<String> = vec![];
-                        for (score, sub) in guess.subgames.iter() {
-                            for l in sub.print_tree(words).lines() {
-                                lines.push(format!("{} {} {}", word, score, l));
-                            }
+                    let mut result = String::new();
+                    for (score, sub) in guess.subgames.iter() {
+                        for l in sub.print_tree(words).lines() {
+                            writeln!(result, "{} {} {}", word, score, l).unwrap();
                         }
-                        lines.join("\n")
                     }
+                    result
                 } else {
                     panic!("optimization not done")
                 }
@@ -164,11 +161,7 @@ impl<'a> Game<'a> {
             Game::Single(_) => true,
             Game::Double(_, _) => true,
             Game::Large(g) => {
-                if let OptimizationStatus::Done(_) = g.optimization {
-                    true
-                } else {
-                    false
-                }
+                matches!(g.optimization, OptimizationStatus::Done(_))
             }
         }
     }

src/main.rs

@@ -14,11 +14,11 @@ use word::Word;
 
 use crate::score_cache::ScoreCache;
 
-fn write_all_words(words: &Vec<Word>) {
+fn write_all_words(words: &[Word]) {
     let filename = "all_words.csv";
     let mut file = File::create(filename).unwrap();
     for (i, w) in words.iter().enumerate() {
-        file.write(format!("{}\t \"{}\"\n", i, w).as_bytes())
+        file.write_all(format!("{}\t \"{}\"\n", i, w).as_bytes())
             .unwrap();
     }
     println!("{} written !", filename);
@@ -30,7 +30,7 @@ fn write_all_scores() {
     for code in 0..3_usize.pow(5) {
         let score = Score { code: code as u8 };
         scores_file
-            .write(format!("{}\t{}\n", code, score).as_bytes())
+            .write_all(format!("{}\t{}\n", code, score).as_bytes())
             .unwrap();
     }
     println!("{} written !", filename);
@@ -66,7 +66,7 @@ fn main() {
     let score_cache = ScoreCache::from_words(&words);
     println!("all scores computed");
 
-    let words_str = words.iter().map(|w| w.to_string()).collect();
+    let words_str: Vec<String> = words.iter().map(|w| w.to_string()).collect();
     let mut game = Game::new(&score_cache, (0..n as u16).collect());
     while !game.is_optimization_done() {
         game.refine_score();

src/score.rs

@@ -1,43 +1,39 @@
 use crate::Color;
 use std::fmt;
 
-#[derive(Debug, Hash, Copy, Clone)]
+#[derive(Debug, Hash, Copy, Clone, Eq, PartialEq)]
 pub struct Score {
     pub code: u8,
 }
 impl fmt::Display for Score {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let colors = self.to_colors();
+        let colors = self.as_colors();
         write!(
             f,
             "{}{}{}{}{}",
             colors[0], colors[1], colors[2], colors[3], colors[4]
         )
     }
 }
-impl Eq for Score {}
-impl PartialEq for Score {
-    fn eq(&self, other: &Self) -> bool {
-        return self.code == other.code;
-    }
-}
 impl Score {
-    pub fn to_colors(&self) -> [Color; 5] {
+    pub fn as_colors(&self) -> [Color; 5] {
         let mut nn = self.code;
         let mut result = [Color::Black; 5];
+        #[allow(clippy::needless_range_loop)]
         for i in 0..5 {
             result[i] = match nn % 3 {
                 0 => Color::Black,
                 1 => Color::Yellow,
                 2 => Color::Green,
                 _ => panic!("imposible modulo"),
             };
-            nn = nn / 3;
+            nn /= 3;
         }
         result
     }
     pub fn from_colors(colors: [Color; 5]) -> Self {
         let mut result: u8 = 0;
+        #[allow(clippy::needless_range_loop)]
         for i in 0..5 {
             let score = match colors[i] {
                 Color::Black => 0,
@@ -63,6 +59,6 @@ mod tests {
             Color::Yellow,
             Color::Black,
         ];
-        assert_eq!(colors, Score::from_colors(colors).to_colors());
+        assert_eq!(colors, Score::from_colors(colors).as_colors());
     }
 }

src/word.rs

@@ -19,6 +19,7 @@ impl Word {
             }
         }
         // assign yellows
+        #[allow(clippy::needless_range_loop)]
         for i in 0..5 {
             if result[i] == Color::Green {
                 continue;
@@ -39,7 +40,7 @@ impl Word {
     }
     pub fn load_words() -> Vec<Word> {
         let words_iter = include_str!("solutions.txt").lines();
-        return words_iter.map(Word::from_str).collect();
+        words_iter.map(Word::from_str).collect()
     }
 }