diff --git a/anagrams/src/lib.rs b/anagrams/src/lib.rs
index a6a82e4..9003efe 100644
--- a/anagrams/src/lib.rs
+++ b/anagrams/src/lib.rs
@@ -20,7 +20,7 @@ impl Dict {
         let words: std::io::Result<Vec<_>> = file
             .lines()
             .enumerate()
-            .filter_map(|(i, e)| (i != 0).then_some(e)) // Skip the first line ( = to size of the dict)
+            .filter_map(|(i, e)| (i != 0).then(|| e)) // Skip the first line ( = to size of the dict)
             .into_iter()
             .collect();
         let words = words?;
@@ -76,8 +76,8 @@ impl From<&Dict> for AnagramDict {
     fn from(dict: &Dict) -> Self {
         let mut map = Self {
             map: HashMap::<FrequencyHash, Vec<String>>::new(),
-            nb_wild_cards: dict.nb_wild_cards,
-            wild_card_char: dict.wild_card_char,
+            nb_wild_cards: dict.nb_wild_cards.clone(),
+            wild_card_char: dict.wild_card_char.clone(),
             letters: HashSet::<char>::new(),
         };
 
@@ -87,16 +87,15 @@ impl From<&Dict> for AnagramDict {
         let len = dict.words.len();
         for word in dict.words.iter() {
             let freq = FrequencyHash::compute(word);
-            word.chars().for_each(|char_| {
+            for char_ in word.chars() {
                 if char_ != map.wild_card_char {
                     map.letters.insert(char_);
                 }
-            });
+            }
 
             map.add_word_with_wild_card(freq, word, dict.nb_wild_cards, dict.wild_card_char);
             #[cfg(not(target_arch = "wasm32"))]
             {
-                // Show avancement when running with a stding available
                 i += 1;
                 print!("{}%\r", (100 * i) / len);
                 io::stdout().flush().unwrap();
@@ -117,15 +116,15 @@ impl AnagramDict {
         if freq.get_freq(self.wild_card_char) > self.nb_wild_cards {
             let mut result = vec![];
             freq.remove_one_char(self.wild_card_char);
-            self.letters.iter().for_each(|char_| {
+            for char_ in self.letters.iter() {
                 let mut freq = freq.clone();
-                freq.add_one_char(*char_);
+                freq.add_one_char(char_.clone());
                 if let Some(anagrams) = self.find_freq(freq) {
-                    anagrams
-                        .iter()
-                        .for_each(|anagram| result.push(anagram.clone()));
+                    for anagram in anagrams {
+                        result.push(anagram);
+                    }
                 }
-            });
+            }
             if result.is_empty() {
                 None
             } else {
@@ -146,11 +145,11 @@ impl AnagramDict {
         self.map
             .entry(freq.clone())
             .and_modify(|anagrams| anagrams.push(word.to_string()))
-            .or_insert_with(|| vec![word.to_string()]);
+            .or_insert(vec![word.to_string()]);
         if nb_wild_card != 0 {
-            for char_ in freq.0.keys() {
+            for char_ in freq.0.clone().keys() {
                 let mut freq = freq.clone();
-                freq.remove_one_char(*char_);
+                freq.remove_one_char(char_.clone());
                 freq.add_one_char(wild_card_symbole);
                 self.add_word_with_wild_card(freq, word, nb_wild_card - 1, wild_card_symbole);
             }
@@ -165,18 +164,18 @@ impl AnagramDict {
 /// We use the [`char`] type for simplicity. The initial problem was in ascii
 /// anyway, but keep in mind that [`char`]s are utf-8 scalar values, and in
 /// some alphabet those do not match characters.
-#[derive(Debug, Eq, Clone)]
+#[derive(Debug, PartialEq, Eq, Clone)]
 struct FrequencyHash(HashMap<char, u8>);
 
 impl FrequencyHash {
     /// Compute the [`FrequencyHash`] of a slice.
     fn compute(string: &str) -> Self {
         let mut map = HashMap::<char, u8>::new();
-        string.chars().for_each(|char_| {
+        for char_ in string.chars() {
             map.entry(char_)
                 .and_modify(|counter| *counter += 1)
                 .or_insert(1);
-        });
+        }
         Self(map)
     }
 
@@ -210,7 +209,7 @@ impl FrequencyHash {
     /// Return the number of occurence of a char in the word
     fn get_freq(&self, char_: char) -> u8 {
         if let Some(freq) = self.0.get(&char_) {
-            *freq
+            freq.clone()
         } else {
             0
         }
@@ -222,9 +221,3 @@ impl Hash for FrequencyHash {
         self.get_unique_vec().hash(state);
     }
 }
-
-impl PartialEq for FrequencyHash {
-    fn eq(&self, other: &Self) -> bool {
-        self.get_unique_vec() == other.get_unique_vec()
-    }
-}
diff --git a/web_gui/src/lib.rs b/web_gui/src/lib.rs
index 4c566bf..17dc624 100644
--- a/web_gui/src/lib.rs
+++ b/web_gui/src/lib.rs
@@ -71,18 +71,19 @@ fn update_letters() {
     while let Some(child) = result.first_element_child() {
         child.remove();
     }
-    if let Some(anagrms) = DICTIONNARY
+    DICTIONNARY
         .lock()
         .expect("Failed to access DICTIONNARY")
         .as_ref()
-        .and_then(|dict| dict.find(&val))
-    {
-        for anagram in anagrms {
-            let val = document().create_element("li").unwrap();
-            val.set_text_content(Some(&anagram));
-            result.append_child(&val).unwrap();
-        }
-    };
+        .map(|dict| dict.find(&val))
+        .flatten()
+        .map(|anagrms| {
+            for anagram in anagrms {
+                let val = document().create_element("li").unwrap();
+                val.set_text_content(Some(&anagram));
+                result.append_child(&val).unwrap();
+            }
+        });
 }
 
 fn load_dict(text: JsValue) {
@@ -112,8 +113,8 @@ fn load_dict(text: JsValue) {
 // Called when the wasm module is instantiated
 #[wasm_bindgen(start)]
 fn main() -> Result<(), JsValue> {
-    let load_dict_c1 = Closure::<dyn FnMut(_)>::new(load_dict);
-    let load_dict_c2 = Closure::<dyn FnMut(_)>::new(load_dict);
+    let load_dict_c1 = Closure::<dyn FnMut(_)>::new(move |text: JsValue| load_dict(text));
+    let load_dict_c2 = Closure::<dyn FnMut(_)>::new(move |text: JsValue| load_dict(text));
 
     let update_dict = Closure::<dyn FnMut(_)>::new(move |event: Event| {
         display_spinner();