typeanswer: micro-optimize vectors

Should get rid of most relocations, at the expense of over-allocating.

On Vec's (String's) behavior: https://stackoverflow.com/a/72787776

rslib/src/typeanswer.rs

@@ -71,8 +71,8 @@ trait DiffTrait {
 
     fn to_tokens(&self) -> DiffTokens {
         let mut matcher = SequenceMatcher::new(self.get_provided(), self.get_expected());
-        let mut provided_tokens = Vec::new();
-        let mut expected_tokens = Vec::new();
+        let mut provided_tokens = Vec::with_capacity(self.get_provided().len());
+        let mut expected_tokens = Vec::with_capacity(self.get_expected().len());
 
         for opcode in matcher.get_opcodes() {
             let provided_slice = slice(&self.get_provided(), opcode.first_start, opcode.first_end);
@@ -133,13 +133,16 @@ fn prepare_expected(expected: &str) -> String {
 
 // Render Functions
 fn render_tokens(tokens: &[DiffToken]) -> String {
-    tokens.iter().fold(String::new(), |mut acc, token| {
-        let isolated_text = isolate_leading_mark(&token.text);
-        let encoded_text = htmlescape::encode_minimal(&isolated_text);
-        let class = token.to_class();
-        acc.push_str(&format!("<span class={class}>{encoded_text}</span>"));
-        acc
-    })
+    tokens.iter().fold(
+        String::with_capacity(tokens.len() * 20),
+        |mut acc, token| {
+            let isolated_text = isolate_leading_mark(&token.text);
+            let encoded_text = htmlescape::encode_minimal(&isolated_text);
+            let class = token.to_class();
+            acc.push_str(&format!("<span class={class}>{encoded_text}</span>"));
+            acc
+        },
+    )
 }
 
 /// Prefixes a leading mark character with a non-breaking space to prevent
@@ -206,9 +209,10 @@ impl DiffTrait for DiffNonCombining {
 
     fn new(expected: &str, provided: &str) -> Self {
         // filter out combining elements
-        let mut expected_stripped = String::new();
+        let mut expected_stripped = String::with_capacity(expected.len());
         // tokenized into "char+combining" for final rendering
-        let mut expected_split: Vec<String> = Vec::new();
+        let mut expected_split: Vec<String> = Vec::with_capacity(expected.len());
+
         for c in normalize(&prepare_expected(expected), true) {
             if unicode_normalization::char::is_combining_mark(c) {
                 if let Some(last) = expected_split.last_mut() {
@@ -235,15 +239,18 @@ impl DiffTrait for DiffNonCombining {
     // having to otherwise e.g. include their field twice in the note template.
     fn render_expected_tokens(&self, tokens: &[DiffToken]) -> String {
         let mut idx = 0;
-        tokens.iter().fold(String::new(), |mut acc, token| {
-            let end = idx + token.text.chars().count();
-            let txt = self.expected_split[idx..end].concat();
-            idx = end;
-            let encoded_text = htmlescape::encode_minimal(&txt);
-            let class = token.to_class();
-            acc.push_str(&format!("<span class={class}>{encoded_text}</span>"));
-            acc
-        })
+        tokens.iter().fold(
+            String::with_capacity(tokens.len() * 20),
+            |mut acc, token| {
+                let end = idx + token.text.chars().count();
+                let txt = self.expected_split[idx..end].concat();
+                idx = end;
+                let encoded_text = htmlescape::encode_minimal(&txt);
+                let class = token.to_class();
+                acc.push_str(&format!("<span class={class}>{encoded_text}</span>"));
+                acc
+            },
+        )
     }
 }