refactor: replace for_each() with for loop

src/checks/mod.rs

@@ -194,7 +194,7 @@ pub fn print() {
             .bold()
     );
 
-    vec![
+    for problem in vec![
         Problem {
             code: "2023-0001",
             name: "Unterformular mit Markierung 'hat Unterformulare'",
@@ -246,7 +246,7 @@ pub fn print() {
             ",
             fixable: false,
         },
-    ]
+    ] {
-    .iter()
+        println!("{problem}\n");
-    .for_each(|problem| println!("{problem}\n"));
+    }
 }

src/commands.rs

@@ -301,9 +301,9 @@ pub fn handle(command: SubCommand) -> Result<(), Box<dyn Error>> {
                                 ))
                                 .count()
                         );
-                        notices
+                        for notice in notices {
-                            .iter()
+                            println!("{notice}");
-                            .for_each(|check_notice| println!("{check_notice}"));
+                        }
                     }
                     Err(err) => {
                         println!("{err}");

src/model/form.rs

@@ -269,11 +269,11 @@ impl<Type: 'static> Sortable for Form<Type> {
         if let Some(ref mut plausibility_rule) = self.plausibility_rules.plausibility_rule {
             plausibility_rule.sort_unstable_by_key(|item| item.bezeichnung.clone());
 
-            plausibility_rule.iter_mut().for_each(|item| {
+            for item in plausibility_rule {
                 if let Some(ref mut data_form_entry_names) = item.data_form_entries.entry_name {
                     data_form_entry_names.sort_unstable();
                 }
-            });
+            }
         }
         self
     }

src/model/onkostar_editor.rs

@@ -164,8 +164,9 @@ impl OnkostarEditor {
             " - Inhalte der Systembibliothek sind mit ({}), der Benutzerbibliothek mit (u) markiert",
             style("S").yellow()
         );
-        list.iter()
+        for entry in list {
-            .for_each(|entry| println!("{}", entry.to_listed_string()));
+            println!("{}", entry.to_listed_string());
+        }
     }
 
     pub fn print_tree(&self) {
@@ -205,8 +206,9 @@ impl OnkostarEditor {
             " - Inhalte der Systembibliothek sind mit ({}), der Benutzerbibliothek mit (u) markiert",
             style("S").yellow()
         );
-        list.iter()
+        for entry in list {
-            .for_each(|entry| println!("{}", entry.to_requirement_string(self)));
+            println!("{}", entry.to_requirement_string(self));
+        }
     }
 
     pub fn sorted(&mut self) {
@@ -328,22 +330,22 @@ impl OnkostarEditor {
         let names_a = list_a.iter().map(Comparable::get_name).collect::<Vec<_>>();
         let names_b = list_b.iter().map(Comparable::get_name).collect::<Vec<_>>();
 
-        names_b.iter().for_each(|entry| {
+        for entry in &names_b {
             if !names_a.contains(entry) {
                 println!("{}: {}", entry, style("Nicht in Datei A enthalten!").red());
                 has_diff = true;
             }
-        });
+        }
 
-        names_a.iter().for_each(|entry| {
+        for entry in &names_a {
             if !names_b.contains(entry) {
                 println!("{}: {}", entry, style("Nicht in Datei B enthalten!").red());
                 has_diff = true;
             }
-        });
+        }
 
-        list_a.iter().for_each(|entry_a| {
+        for entry_a in list_a {
-            list_b.iter().for_each(|entry_b| {
+            for entry_b in list_b {
                 if entry_a.get_name() == entry_b.get_name() {
                     match entry_a.get_revision().cmp(&entry_b.get_revision()) {
                         Ordering::Less => {
@@ -380,8 +382,8 @@ impl OnkostarEditor {
                         }
                     }
                 }
-            });
+            }
-        });
+        }
 
         if !has_diff {
             println!("Keine Unterschiede");

src/model/property_catalogue.rs

@@ -72,9 +72,9 @@ impl Sortable for PropertyCatalogue {
     fn sorted(&mut self) -> &Self {
         if let Some(ref mut versions) = self.versions.entry {
             versions.sort_unstable_by_key(|item| item.version_number);
-            versions.iter_mut().for_each(|version| {
+            for version in versions {
                 version.sorted();
-            });
+            }
         }
         self
     }
@@ -148,9 +148,9 @@ impl Sortable for Version {
     {
         if let Some(ref mut abbildung) = self.abbildung {
             abbildung.sort_unstable_by_key(Abbildung::sorting_key);
-            abbildung.iter_mut().for_each(|item| {
+            for item in abbildung {
                 item.sorted();
-            });
+            }
         }
 
         if let Some(ref mut entries) = self.entries {