Some minor cleanup

Just some stylistic changes.

Author: ehuss

mdbook-spec/src/grammar.rs

@@ -106,17 +106,13 @@ impl Expression {
             | ExpressionKind::RepeatPlus(e)
             | ExpressionKind::RepeatPlusNonGreedy(e)
             | ExpressionKind::RepeatRange(e, _, _)
-            | ExpressionKind::NegExpression(e) => {
-                e.visit_nt(callback);
-            }
+            | ExpressionKind::NegExpression(e) => e.visit_nt(callback),
             ExpressionKind::Alt(es) | ExpressionKind::Sequence(es) => {
                 for e in es {
                     e.visit_nt(callback);
                 }
             }
-            ExpressionKind::Nt(nt) => {
-                callback(&nt);
-            }
+            ExpressionKind::Nt(nt) => callback(nt),
             ExpressionKind::Terminal(_)
             | ExpressionKind::Prose(_)
             | ExpressionKind::Break(_)
@@ -314,7 +310,7 @@ fn render_names(
     let railroad_link_map = updated_link_map(render_railroad::railroad_id);
 
     if let Err(e) = grammar.render_markdown(
-        &names,
+        names,
         &markdown_link_map,
         &railroad_link_map,
         &mut output,
@@ -340,7 +336,7 @@ fn render_names(
     );
 
     if let Err(e) = grammar.render_railroad(
-        &names,
+        names,
         &railroad_link_map,
         &markdown_link_map,
         &mut output,

mdbook-spec/src/grammar/parser.rs

@@ -65,8 +65,7 @@ impl Parser<'_> {
     fn take_while(&mut self, f: &dyn Fn(char) -> bool) -> &str {
         let mut upper = 0;
         let i = self.index;
-        let mut ci = self.input[i..].chars();
-        while let Some(ch) = ci.next() {
+        for ch in self.input[i..].chars() {
             if !f(ch) {
                 break;
             }

mdbook-spec/src/grammar/render_markdown.rs

@@ -18,14 +18,14 @@ impl Grammar {
         output: &mut String,
         for_summary: bool,
     ) -> anyhow::Result<()> {
-        let mut iter = names.into_iter().peekable();
+        let mut iter = names.iter().peekable();
         while let Some(name) = iter.next() {
             let Some(prod) = self.productions.get(*name) else {
                 bail!("could not find grammar production named `{name}`");
             };
             prod.render_markdown(link_map, rr_link_map, output, for_summary);
             if iter.peek().is_some() {
-                output.push_str("\n");
+                output.push('\n');
             }
         }
         Ok(())
@@ -52,7 +52,7 @@ impl Production {
         let dest = rr_link_map
             .get(&self.name)
             .map(|path| path.to_string())
-            .unwrap_or_else(|| format!("missing"));
+            .unwrap_or_else(|| "missing".to_string());
         write!(
             output,
             "<span class=\"grammar-text grammar-production\" id=\"{id}\" \

mdbook-spec/src/grammar/render_railroad.rs

@@ -75,7 +75,7 @@ impl Production {
         let dest = md_link_map
             .get(&self.name)
             .map(|path| path.to_string())
-            .unwrap_or_else(|| format!("missing"));
+            .unwrap_or_else(|| "missing".to_string());
         let seq: Sequence<Box<dyn Node>> =
             Sequence::new(vec![Box::new(SimpleStart), n.unwrap(), Box::new(SimpleEnd)]);
         let vert = VerticalGrid::<Box<dyn Node>>::new(vec![
@@ -105,7 +105,7 @@ impl Expression {
                 let choices: Vec<_> = es
                     .iter()
                     .map(|e| e.render_railroad(stack, link_map))
-                    .filter_map(|n| n)
+                    .flatten()
                     .collect();
                 Box::new(Choice::<Box<dyn Node>>::new(choices))
             }
@@ -115,7 +115,7 @@ impl Expression {
                     let seq: Vec<_> = es
                         .iter()
                         .map(|e| e.render_railroad(stack, link_map))
-                        .filter_map(|n| n)
+                        .flatten()
                         .collect();
                     let seq: Sequence<Box<dyn Node>> = Sequence::new(seq);
                     Box::new(seq)
@@ -138,11 +138,10 @@ impl Expression {
                     ) {
                         &es[..es.len() - 1]
                     } else {
-                        &es[..]
+                        es
                     };
 
-                    let mut breaks: Vec<_> =
-                        es.split(|e| e.is_break()).map(|es| make_seq(es)).collect();
+                    let mut breaks: Vec<_> = es.split(|e| e.is_break()).map(&make_seq).collect();
                     // If there aren't any breaks, don't bother stacking.
                     if breaks.len() == 1 {
                         breaks.pop().unwrap()
@@ -229,7 +228,7 @@ fn node_for_nt(link_map: &HashMap<String, String>, name: &str) -> Box<dyn Node>
     let dest = link_map
         .get(name)
         .map(|path| path.to_string())
-        .unwrap_or_else(|| format!("missing"));
+        .unwrap_or_else(|| "missing".to_string());
     let n = NonTerminal::new(name.to_string());
     Box::new(Link::new(n, dest))
 }

mdbook-spec/src/lib.rs

@@ -188,8 +188,7 @@ impl Spec {
                 let blockquote = &caps["blockquote"];
                 let initial_spaces = blockquote.chars().position(|ch| ch != ' ').unwrap_or(0);
                 let space = &blockquote[..initial_spaces];
-                if lower.starts_with("edition-") {
-                    let edition = &lower[8..];
+                if let Some(edition) = lower.strip_prefix("edition-") {
                     return format!("{space}<div class=\"alert alert-edition\">\n\
                         \n\
                         {space}> <p class=\"alert-title\">\