perf: Use Cow to avoid creates String on format. (#248)

This pull request focuses on improving the performance and memory usage
of the formatting functions by changing their return types to
`Cow<str>`. This allows the functions to return either borrowed or owned
data, reducing unnecessary allocations when the input is not modified.

Most benchmarks gain 10% ~ 20% improvement on my local PC:

```
format_json             time:   [171.73 µs 172.00 µs 172.28 µs]
                        change: [-17.792% -17.409% -17.049%] (p = 0.00 < 0.05)
                        Performance has improved.
Found 4 outliers among 100 measurements (4.00%)
  4 (4.00%) high mild

format_javascript       time:   [360.43 µs 360.88 µs 361.32 µs]
                        change: [-15.179% -13.906% -12.966%] (p = 0.00 < 0.05)
                        Performance has improved.
Found 3 outliers among 100 measurements (3.00%)
  3 (3.00%) high severe

format_json_2k          time:   [21.865 ms 21.882 ms 21.900 ms]
                        change: [-15.133% -14.999% -14.869%] (p = 0.00 < 0.05)
                        Performance has improved.
Found 3 outliers among 100 measurements (3.00%)
  2 (2.00%) high mild
  1 (1.00%) high severe

format_jupyter          time:   [275.67 µs 276.03 µs 276.38 µs]
                        change: [-7.5263% -7.2771% -7.0001%] (p = 0.00 < 0.05)
                        Performance has improved.
Found 7 outliers among 100 measurements (7.00%)
  4 (4.00%) high mild
  3 (3.00%) high severe

format_markdown         time:   [2.2873 ms 2.2896 ms 2.2923 ms]
                        change: [-14.583% -14.448% -14.325%] (p = 0.00 < 0.05)
                        Performance has improved.
Found 3 outliers among 100 measurements (3.00%)
  1 (1.00%) high mild
  2 (2.00%) high severe

lint_markdown           time:   [2.3867 ms 2.3939 ms 2.4021 ms]
                        change: [-15.337% -15.092% -14.799%] (p = 0.00 < 0.05)
                        Performance has improved.
Found 10 outliers among 100 measurements (10.00%)
  5 (5.00%) high mild
  5 (5.00%) high severe

lint_json               time:   [180.12 µs 180.38 µs 180.64 µs]
                        change: [-19.382% -18.912% -18.449%] (p = 0.00 < 0.05)
                        Performance has improved.
Found 6 outliers among 100 measurements (6.00%)
  3 (3.00%) high mild
  3 (3.00%) high severe

lint_html               time:   [694.02 µs 694.96 µs 695.95 µs]
                        change: [-15.000% -14.666% -14.362%] (p = 0.00 < 0.05)
                        Performance has improved.
Found 5 outliers among 100 measurements (5.00%)
  4 (4.00%) high mild
  1 (1.00%) high severe

lint_javascript         time:   [367.04 µs 367.55 µs 368.05 µs]
                        change: [-27.115% -23.420% -20.369%] (p = 0.00 < 0.05)
                        Performance has improved.
Found 5 outliers among 100 measurements (5.00%)

```

---------

Co-authored-by: Jason Lee <huacnlee@gmail.com>

Author: quake

autocorrect/src/format.rs

@@ -23,7 +23,7 @@ use crate::{
 /// // => "既に、世界中の数百という企業が Rust を採用し、高速で低リソースのクロスプラットフォームソリューションを実現しています。"
 /// ```
 pub fn format(text: &str) -> String {
-    format_or_lint(text, false).out
+    format_or_lint(text, false).out.into_owned()
 }
 
 /// Format a html content.

autocorrect/src/rule/fullwidth.rs

@@ -1,6 +1,6 @@
 // autocorrect: false
 use regex::Regex;
-use std::collections::HashMap;
+use std::{borrow::Cow, collections::HashMap};
 
 const SPCIAL_PUNCTUATIONS: &str = "[.:!]([ ]*)";
 const NORMAL_PUNCTUATIONS: &str = "[,?]([ ]*)";
@@ -31,24 +31,28 @@ lazy_static! {
 }
 
 // fullwidth correct punctuations near the CJK chars
-pub fn format(text: &str) -> String {
-    let out = PUNCTUATION_WITH_LEFT_CJK_RE.replace_all(text, |cap: &regex::Captures| {
-        fullwidth_replace_part(&cap[0])
-    });
+pub fn format(text: &str) -> Cow<str> {
+    let patterns = [
+        &*PUNCTUATION_WITH_LEFT_CJK_RE,
+        &*PUNCTUATION_WITH_RIGHT_CJK_RE,
+        &*PUNCTUATION_WITH_SPEICAL_CJK_RE,
+        &*PUNCTUATION_WITH_SPEICAL_LAST_CJK_RE,
+    ];
 
-    let out = PUNCTUATION_WITH_RIGHT_CJK_RE.replace_all(&out, |cap: &regex::Captures| {
-        fullwidth_replace_part(&cap[0])
-    });
-
-    let out = PUNCTUATION_WITH_SPEICAL_CJK_RE.replace_all(&out, |cap: &regex::Captures| {
-        fullwidth_replace_part(&cap[0])
-    });
-
-    let out = PUNCTUATION_WITH_SPEICAL_LAST_CJK_RE.replace_all(&out, |cap: &regex::Captures| {
-        fullwidth_replace_part(&cap[0])
-    });
+    let mut result = Cow::Borrowed(text);
+    for pattern in &patterns {
+        if let Cow::Owned(new_text) = pattern.replace_all(&result, |cap: &regex::Captures| {
+            fullwidth_replace_part(&cap[0])
+        }) {
+            result = Cow::Owned(new_text);
+        }
+    }
 
-    out.to_string()
+    if let Cow::Owned(new_text) = result {
+        Cow::Owned(new_text)
+    } else {
+        Cow::Borrowed(text)
+    }
 }
 
 fn fullwidth_replace_part(part: &str) -> String {

autocorrect/src/rule/halfwidth.rs

@@ -1,6 +1,6 @@
 // autocorrect: false
 use regex::Regex;
-use std::collections::HashMap;
+use std::{borrow::Cow, collections::HashMap};
 
 use super::CJK_RE;
 
@@ -108,37 +108,59 @@ impl CharMatching for char {
     }
 }
 
-pub fn format_punctuation(text: &str) -> String {
+pub fn format_punctuation(text: &str) -> Cow<str> {
     // Get first non space char as quote
     let wrap_quote = text.chars().find(|c| !c.is_whitespace()).unwrap_or(' ');
 
-    text.split_inclusive('\n')
-        .map(|line| format_line(line, wrap_quote))
-        .collect()
+    let mut changed = false;
+    let lines: Vec<_> = text
+        .split_inclusive('\n')
+        .map(|line| match format_line(line, wrap_quote) {
+            Cow::Borrowed(s) => Cow::Borrowed(s),
+            Cow::Owned(s) => {
+                changed = true;
+                Cow::Owned(s)
+            }
+        })
+        .collect();
+
+    if changed {
+        Cow::Owned(lines.into_iter().collect::<String>())
+    } else {
+        Cow::Borrowed(text)
+    }
 }
 
 /// Normalize chars to use general half width in Chinese contents.
-pub fn format_word(text: &str) -> String {
+pub fn format_word(text: &str) -> Cow<str> {
+    let mut changed = false;
     let out = text
         .chars()
         .map(|c| match c {
             // Unicode Fullwidth ASCII variants (Only numbers and alphabetics)
             // ０ .. ９ | Ａ .. Ｚ | ａ .. ｚ
             // https://www.unicode.org/charts/nameslist/n_FF00.html
             '\u{FF10}'..='\u{FF19}' | '\u{FF21}'..='\u{FF3A}' | '\u{FF41}'..='\u{FF5A}' => {
+                changed = true;
                 // checked char is in range of fullwidth number and alphabetic
                 unsafe { char::from_u32_unchecked(c as u32 - 0xFEE0) }
             }
             // Ideographic Space:
             // https://en.wikipedia.org/wiki/Whitespace_character#Unicode
-            '\u{3000}' => ' ',
+            '\u{3000}' => {
+                changed = true;
+                ' '
+            }
             _ => c,
         })
         .collect::<String>();
 
-    // Fix 12：00 -> 12:00
-    let out = HALF_TIME_RE.replace_all(&out, |cap: &regex::Captures| cap[0].replace('：', ":"));
-    out.into_owned()
+    if changed {
+        let out = HALF_TIME_RE.replace_all(&out, |cap: &regex::Captures| cap[0].replace('：', ":"));
+        Cow::Owned(out.into_owned())
+    } else {
+        HALF_TIME_RE.replace_all(text, |cap: &regex::Captures| cap[0].replace('：', ":"))
+    }
 }
 
 fn is_may_only_english(text: &str) -> bool {
@@ -166,12 +188,13 @@ fn is_may_only_english(text: &str) -> bool {
     false
 }
 
-fn format_line(text: &str, wrap_quote: char) -> String {
+fn format_line(text: &str, wrap_quote: char) -> Cow<str> {
     if !is_may_only_english(text) {
-        return String::from(text);
+        return Cow::Borrowed(text);
     }
 
     let mut out = String::with_capacity(text.len());
+    let mut changed = false;
 
     let mut parts = text.chars().peekable();
     while let Some(part) = parts.next() {
@@ -202,12 +225,16 @@ fn format_line(text: &str, wrap_quote: char) -> String {
                     escape_quote(&mut out, wrap_quote, rule.to);
                 }
             }
+            changed = true;
         } else {
             out.push(part);
         }
     }
-
-    out
+    if changed {
+        Cow::Owned(out)
+    } else {
+        Cow::Borrowed(text)
+    }
 }
 
 fn escape_quote(out: &mut String, wrap_quote: char, quote: char) {

autocorrect/src/rule/mod.rs

@@ -8,7 +8,7 @@ mod word;
 pub mod halfwidth;
 pub mod spellcheck;
 
-use std::collections::HashMap;
+use std::{borrow::Cow, collections::HashMap};
 
 use regex::Regex;
 use rule::{Rule, RuleResult};
@@ -81,11 +81,11 @@ pub(crate) fn format_or_lint(text: &str, lint: bool) -> RuleResult {
     format_or_lint_with_disable_rules(text, lint, &map![])
 }
 
-pub(crate) fn format_or_lint_with_disable_rules(
-    text: &str,
+pub(crate) fn format_or_lint_with_disable_rules<'a>(
+    text: &'a str,
     lint: bool,
     disable_rules: &HashMap<String, bool>,
-) -> RuleResult {
+) -> RuleResult<'a> {
     let mut result = RuleResult::default();
 
     // skip if not has CJK
@@ -98,13 +98,13 @@ pub(crate) fn format_or_lint_with_disable_rules(
             if matches!(ch, ' ' | '\n' | '\r') {
                 let mut sub_result = RuleResult::new(&part);
                 sub_result.severity = result.severity;
-
-                part.clear();
-
                 format_part(&mut sub_result, lint, disable_rules);
 
-                result.out.push_str(&sub_result.out);
+                let mut out = result.out.into_owned();
+                out.push_str(&sub_result.out);
+                result.out = Cow::Owned(out);
                 result.severity = sub_result.severity;
+                part.clear();
             }
         }
 
@@ -114,11 +114,13 @@ pub(crate) fn format_or_lint_with_disable_rules(
 
             format_part(&mut sub_result, lint, disable_rules);
 
-            result.out.push_str(&sub_result.out);
+            let mut out = result.out.into_owned();
+            out.push_str(&sub_result.out);
+            result.out = Cow::Owned(out);
             result.severity = sub_result.severity;
         }
     } else {
-        result.out = text.to_string();
+        result.out = Cow::Borrowed(text);
     }
 
     format_after_rules(&mut result, lint, disable_rules);

autocorrect/src/rule/rule.rs

@@ -1,29 +1,31 @@
+use std::borrow::Cow;
+
 use crate::config::SeverityMode;
 use crate::result::Severity;
 
 pub(crate) struct Rule {
     #[allow(dead_code)]
     pub name: String,
-    pub format_fn: fn(input: &str) -> String,
+    pub format_fn: for<'a> fn(input: &'a str) -> Cow<'a, str>,
 }
 
 #[derive(Default)]
-pub(crate) struct RuleResult {
-    pub out: String,
+pub(crate) struct RuleResult<'a> {
+    pub out: Cow<'a, str>,
     pub severity: Severity,
 }
 
-impl RuleResult {
-    pub fn new(input: &str) -> Self {
+impl<'a> RuleResult<'a> {
+    pub fn new(input: &'a str) -> Self {
         Self {
-            out: input.to_string(),
+            out: Cow::Borrowed(input),
             ..Default::default()
         }
     }
 }
 
 impl Rule {
-    pub fn new(name: &str, format: fn(input: &str) -> String) -> Self {
+    pub fn new(name: &str, format: for<'a> fn(input: &'a str) -> Cow<'a, str>) -> Self {
         Rule {
             name: name.to_string(),
             format_fn: format,
@@ -35,27 +37,27 @@ impl Rule {
             return;
         }
 
-        let new = (self.format_fn)(&result.out);
-        if result.out.ne(&new) {
+        if let Cow::Owned(new) = (self.format_fn)(&result.out) {
             result.severity = Severity::Error;
+            result.out = Cow::Owned(new);
         }
-        result.out = new;
     }
 
     pub fn lint(&self, result: &mut RuleResult) {
         if self.severity() == SeverityMode::Off {
             return;
         }
 
-        let new = (self.format_fn)(&result.out);
-        if result.out.ne(&new) && result.severity == Severity::Pass {
-            if self.severity() == SeverityMode::Warning {
-                result.severity = Severity::Warning;
-            } else {
-                result.severity = Severity::Error;
+        if let Cow::Owned(new) = (self.format_fn)(&result.out) {
+            if result.severity == Severity::Pass {
+                if self.severity() == SeverityMode::Warning {
+                    result.severity = Severity::Warning;
+                } else {
+                    result.severity = Severity::Error;
+                }
             }
+            result.out = Cow::Owned(new);
         }
-        result.out = new;
     }
 
     fn severity(&self) -> SeverityMode {
@@ -75,7 +77,7 @@ mod tests {
 
     #[test]
     fn test_rule_not_pass() {
-        let rule = Rule::new("space-word", |input| format!("{input} - foo"));
+        let rule = Rule::new("space-word", |input| Cow::Owned(format!("{input} - foo")));
         assert_eq!(rule.severity(), SeverityMode::Error);
         assert_eq!(rule.name, "space-word");
 
@@ -92,7 +94,7 @@ mod tests {
 
     #[test]
     fn test_rule_pass() {
-        let rule = Rule::new("spellcheck", |input| input.to_string());
+        let rule = Rule::new("spellcheck", |input| Cow::Borrowed(input));
 
         let mut result = RuleResult::new("test");
         rule.format(&mut result);