refactor: remove for loop

bs-community · Feb 18, 2020 · 230457f · 230457f
1 parent 4b51274
commit 230457f
Show file tree

Hide file tree

Showing 3 changed files with 45 additions and 56 deletions.
diff --git a/src/parser/pos.rs b/src/parser/pos.rs
@@ -55,8 +55,6 @@ impl Positioner<char> for Position {
 
 impl<'a> RangePositioner<char, &'a str> for Position {
     fn update_range(&mut self, range: &&'a str) {
-        for c in range.chars() {
-            self.update(&c);
-        }
+        range.chars().for_each(|c| self.update(&c));
     }
 }
diff --git a/src/shell/renderer.rs b/src/shell/renderer.rs
@@ -9,45 +9,41 @@ fn white_space(size: usize) -> String {
 fn template(template: &Template) -> String {
     match template {
         Template::Unquoted(body) => {
-            let mut output = String::with_capacity(body.parts.len() * 5);
-            for (i, part) in body.parts.iter().enumerate() {
-                match part {
-                    TemplatePart::Raw(literal) => {
-                        // User may input a switch later, so paint it with light blue.
-                        if &literal.value == "-" && i == 0 {
-                            output.push_str(&Color::Fixed(39).paint("-").to_string());
-                        } else {
-                            output.push_str(&literal.value);
+            body.parts.iter().enumerate().fold(
+                String::with_capacity(body.parts.len() * 5),
+                |output, (i, part)| {
+                    output
+                        + &match part {
+                            TemplatePart::Raw(literal) => {
+                                // User may input a switch later, so paint it with light blue.
+                                if &literal.value == "-" && i == 0 {
+                                    Color::Fixed(39).paint("-").to_string()
+                                } else {
+                                    literal.value.to_owned()
+                                }
+                            }
+                            TemplatePart::Variable(var) => variable(var),
                         }
-                    }
-                    TemplatePart::Variable(var) => {
-                        output.push_str(&variable(var));
-                    }
-                }
-            }
-
-            output
+                },
+            )
         }
         Template::Single(raw) => Color::Yellow.paint(format!("'{}'", raw.text)).to_string(),
         Template::Double(body) => {
-            let mut output = String::with_capacity(body.parts.len() * 5);
-
-            output.push_str(&Color::Yellow.paint("\"").to_string());
-
-            for part in &body.parts {
-                match part {
-                    TemplatePart::Raw(literal) => {
-                        output.push_str(&Color::Yellow.paint(&literal.value).to_string());
-                    }
-                    TemplatePart::Variable(var) => {
-                        output.push_str(&variable(var));
-                    }
-                }
-            }
-
-            output.push_str(&Color::Yellow.paint("\"").to_string());
+            let middle = body.parts.iter().fold(
+                String::with_capacity(body.parts.len() * 5),
+                |output, part| {
+                    output
+                        + &match part {
+                            TemplatePart::Raw(literal) => {
+                                Color::Yellow.paint(&literal.value).to_string()
+                            }
+                            TemplatePart::Variable(var) => variable(var),
+                        }
+                },
+            );
 
-            output
+            let quote = Color::Yellow.paint("\"");
+            format!("{}{}{}", quote, middle, quote)
         }
     }
 }
@@ -79,16 +75,16 @@ fn parameter(parameter: &Parameter) -> String {
 }
 
 fn parameters(parameters: &Parameters, prefix_spaces: usize) -> String {
-    let mut index = prefix_spaces;
-    let mut output = String::new();
-
-    for param in &parameters.params {
-        output.push_str(&white_space(param.span.start.index - index));
-        output.push_str(&parameter(param));
-        index = param.span.end.index;
-    }
-
-    output
+    parameters
+        .params
+        .iter()
+        .fold((prefix_spaces, String::new()), |(pos, output), param| {
+            (
+                param.span.end.index,
+                output + &white_space(param.span.start.index - pos) + &parameter(param),
+            )
+        })
+        .1
 }
 
 fn program<T>(program: &Program, executables: &HashMap<String, T>) -> String {

diff --git a/src/shell/transform.rs b/src/shell/transform.rs
@@ -76,17 +76,12 @@ impl<'a> Transformer<'a> {
     }
 
     fn template_body(&self, body: TemplateBody) -> String {
-        let mut text = String::new();
-
-        for part in body.parts {
-            let t = match part {
+        body.parts.into_iter().fold(String::new(), |text, part| {
+            text + &match part {
                 TemplatePart::Raw(raw) => self.template_literal(raw),
                 TemplatePart::Variable(var) => self.variable(var),
-            };
-            text.push_str(&*t);
-        }
-
-        text
+            }
+        })
     }
 
     fn template_literal(&self, literal: TemplateLiteral) -> String {