Reduce allocations create unnecessary HashMaps and Strings (#133)

For me, the `rust_i18n::i18n!` macro created tens of thousands of
hashmaps, and allocated tens of thousands of strings. Both of which were
unnecessary. This was such a problem, that it caused stack overflows (on
Windows only). This PR makes 2 optimizations:

- Reduce how `HashMap`s are created: from one for every pair, to one for
every language. Bringing the amount of HashMaps created from 14,000 to
32
- Reduce how many `String`s are created from `&'static str` by using
`Cow<'static, str>`

**Optimization 1**: Don't create so many hashmaps. The expansion of
`i18n!` creates a `HashMap` for every translation pair. I have a lot of
translations, so for me thousands of translations were being created.
Creating `HashMap` is expensive, there's no reason to do it once for
every pair

In this PR Ive changed the expansion so only a single HashMap is created
**per language**. That brings up the count of HashMap from thousands to
a only a couple.

**Optimization 2**: Don't allocate so many strings. Every call to
`add_translations` allocates both for the key, and each individual inner
pair too. Here is the body of the `add_translations` function:

```rust
pub fn add_translations(&mut self, locale: &str, data: &HashMap<&str, &str>) {
    let data = data
        .iter()
        .map(|(k, v)| ((*k).into(), (*v).into()))
        .collect::<HashMap<_, _>>();

    let trs = self.translations.entry(locale.into()).or_default();
    trs.extend(data);
}
```

It's considered best practice to make your function signature clear.
Usually, it's better to require a `String` rather than `&str` if you're
just going to `.to_string()` it in the function body.

it also iterates over the entire passed `data` to clone everything, and
then creates **another** hashmap (the `collect`)

All of this was causing `stack overflow` for me on Windows. The
expansion of `i18n!` generated 14,000 HashMaps and spanned over 50,000
lines. With this PR, that's not an issue anymore.

`add_translations` was changed to this:

```rust
pub fn add_translations(
    &mut self,
    locale: Cow<'static, str>,
    data: HashMap<Cow<'static, str>, Cow<'static, str>>,
) {
    let trs = self.translations.entry(locale.into()).or_default();
    trs.extend(data);
}
```

Most inputs to it are static strings. There's no need to turn them into
a `String`, so they are passed as `Cow<'static, str>`.

I also added an `impl IntoIterator for SimpleBackend`.

The example expansion is located at `examples/app-egui/src/main.rs`

# Old expansion

```rust
static _RUST_I18N_BACKEND: std::sync::LazyLock<Box<dyn rust_i18n::Backend>> =
    std::sync::LazyLock::new(|| {
        let mut backend = rust_i18n::SimpleBackend::new();
        backend.add_translations(
            "en",
            &std::collections::HashMap::from([("Arthur", "Arthur")]),
        );
        backend.add_translations("en", &std::collections::HashMap::from([("age", "age")]));
```

Note that then every of the `&'static str` you see will be
`.to_string()`d in the function call

# New expansion

This expansion both has way less overhead, and won't cause any stack
overflows

```rust
static _RUST_I18N_BACKEND: std::sync::LazyLock<Box<dyn rust_i18n::Backend>> = std::sync::LazyLock::new(||
{
    let mut backend = rust_i18n::SimpleBackend::new();
    backend
        .add_translations(
            ::std::borrow::Cow::Borrowed("en"),
            {
                let map = std::collections::HashMap::with_capacity(278usize);
                map.insert(
                    ::std::borrow::Cow::Borrowed("Arthur", "Arthur"),
                    ::std::borrow::Cow::Borrowed("age", "age"),
                );
```

Author: nik-rev

crates/macro/src/lib.rs

@@ -271,15 +271,29 @@ fn generate_code(
     translations: BTreeMap<String, BTreeMap<String, String>>,
     args: Args,
 ) -> proc_macro2::TokenStream {
-    let mut all_translations = Vec::<proc_macro2::TokenStream>::new();
-
-    translations.iter().for_each(|(locale, trs)| {
-        trs.iter().for_each(|(k, v)| {
-            all_translations.push(quote! {
-                backend.add_translations(#locale, &std::collections::HashMap::from([(#k, #v)]));
-            });
-        });
+    let all_translations = translations.iter().map(|(locale, translation)| {
+        let translation_length = translation.len();
+        let translation = translation.iter().map(
+            |(k, v)| quote! { ::std::borrow::Cow::Borrowed(#k), ::std::borrow::Cow::Borrowed(#v) },
+        );
+        quote! {
+            ::std::borrow::Cow::Borrowed(#locale),
+            {
+                let mut map = std::collections::HashMap::with_capacity(#translation_length);
+                #(
+                    map.insert(#translation);
+                )*
+                map
+            }
+        }
     });
+    let all_translations = quote! {
+        let mut backend  = rust_i18n::SimpleBackend::new();
+
+        #(
+            backend.add_translations(#all_translations);
+        )*
+    };
 
     let default_locale = if let Some(default_locale) = args.default_locale {
         quote! {
@@ -325,8 +339,7 @@ fn generate_code(
         /// [PUBLIC] This is a public API, and as an example in examples/
         #[allow(missing_docs)]
         static _RUST_I18N_BACKEND: std::sync::LazyLock<Box<dyn rust_i18n::Backend>> = std::sync::LazyLock::new(|| {
-            let mut backend = rust_i18n::SimpleBackend::new();
-            #(#all_translations)*
+            #all_translations
             #extend_code
             #default_locale
 

crates/support/src/backend.rs

@@ -68,7 +68,29 @@ where
 /// Simple KeyValue storage backend
 pub struct SimpleBackend {
     /// All translations key is flatten key, like `en.hello.world`
-    translations: HashMap<String, HashMap<String, String>>,
+    translations: HashMap<Cow<'static, str>, HashMap<Cow<'static, str>, Cow<'static, str>>>,
+}
+
+impl
+    FromIterator<(
+        Cow<'static, str>,
+        HashMap<Cow<'static, str>, Cow<'static, str>>,
+    )> for SimpleBackend
+{
+    fn from_iter<
+        I: IntoIterator<
+            Item = (
+                Cow<'static, str>,
+                HashMap<Cow<'static, str>, Cow<'static, str>>,
+            ),
+        >,
+    >(
+        iter: I,
+    ) -> Self {
+        Self {
+            translations: iter.into_iter().collect(),
+        }
+    }
 }
 
 impl SimpleBackend {
@@ -85,47 +107,40 @@ impl SimpleBackend {
     /// # use std::collections::HashMap;
     /// # use rust_i18n_support::SimpleBackend;
     /// # let mut backend = SimpleBackend::new();
-    /// let mut trs = HashMap::<&str, &str>::new();
-    /// trs.insert("hello", "Hello");
-    /// trs.insert("foo", "Foo bar");
-    /// backend.add_translations("en", &trs);
+    /// let mut trs = HashMap::new();
+    /// trs.insert("hello".into(), "Hello".into());
+    /// trs.insert("foo".into(), "Foo bar".into());
+    /// backend.add_translations("en".into(), trs);
     /// ```
-    pub fn add_translations(&mut self, locale: &str, data: &HashMap<&str, &str>) {
-        let data = data
-            .iter()
-            .map(|(k, v)| ((*k).into(), (*v).into()))
-            .collect::<HashMap<_, _>>();
-
+    pub fn add_translations(
+        &mut self,
+        locale: Cow<'static, str>,
+        data: HashMap<Cow<'static, str>, Cow<'static, str>>,
+    ) {
         let trs = self.translations.entry(locale.into()).or_default();
         trs.extend(data);
     }
 }
 
 impl Backend for SimpleBackend {
     fn available_locales(&self) -> Vec<Cow<'_, str>> {
-        let mut locales = self
-            .translations
-            .keys()
-            .map(|k| Cow::from(k.as_str()))
-            .collect::<Vec<_>>();
+        let mut locales = self.translations.keys().cloned().collect::<Vec<_>>();
         locales.sort();
         locales
     }
 
     fn translate(&self, locale: &str, key: &str) -> Option<Cow<'_, str>> {
         if let Some(trs) = self.translations.get(locale) {
-            return trs.get(key).map(|s| Cow::from(s.as_str()));
+            return trs.get(key).cloned();
         }
 
         None
     }
 
     fn messages_for_locale(&self, locale: &str) -> Option<Vec<(Cow<'_, str>, Cow<'_, str>)>> {
-        self.translations.get(locale).map(|trs| {
-            trs.iter()
-                .map(|(k, v)| (Cow::from(k.as_str()), Cow::from(v.as_str())))
-                .collect()
-        })
+        self.translations
+            .get(locale)
+            .map(|trs| trs.iter().map(|(k, v)| (k.clone(), v.clone())).collect())
     }
 }
 
@@ -148,15 +163,15 @@ mod tests {
     #[test]
     fn test_simple_backend() {
         let mut backend = SimpleBackend::new();
-        let mut data = HashMap::<&str, &str>::new();
-        data.insert("hello", "Hello");
-        data.insert("foo", "Foo bar");
-        backend.add_translations("en", &data);
+        let mut data = HashMap::new();
+        data.insert("hello".into(), "Hello".into());
+        data.insert("foo".into(), "Foo bar".into());
+        backend.add_translations("en".into(), data);
 
-        let mut data_cn = HashMap::<&str, &str>::new();
-        data_cn.insert("hello", "你好");
-        data_cn.insert("foo", "Foo 测试");
-        backend.add_translations("zh-CN", &data_cn);
+        let mut data_cn = HashMap::new();
+        data_cn.insert("hello".into(), "你好".into());
+        data_cn.insert("foo".into(), "Foo 测试".into());
+        backend.add_translations("zh-CN".into(), data_cn);
 
         assert_eq!(backend.translate("en", "hello"), Some(Cow::from("Hello")));
         assert_eq!(backend.translate("en", "foo"), Some(Cow::from("Foo bar")));
@@ -172,24 +187,24 @@ mod tests {
     #[test]
     fn test_combined_backend() {
         let mut backend = SimpleBackend::new();
-        let mut data = HashMap::<&str, &str>::new();
-        data.insert("hello", "Hello");
-        data.insert("foo", "Foo bar");
-        backend.add_translations("en", &data);
+        let mut data = HashMap::new();
+        data.insert("hello".into(), "Hello".into());
+        data.insert("foo".into(), "Foo bar".into());
+        backend.add_translations("en".into(), data);
 
-        let mut data_cn = HashMap::<&str, &str>::new();
-        data_cn.insert("hello", "你好");
-        data_cn.insert("foo", "Foo 测试");
-        backend.add_translations("zh-CN", &data_cn);
+        let mut data_cn = HashMap::new();
+        data_cn.insert("hello".into(), "你好".into());
+        data_cn.insert("foo".into(), "Foo 测试".into());
+        backend.add_translations("zh-CN".into(), data_cn);
 
         let mut backend2 = SimpleBackend::new();
-        let mut data2 = HashMap::<&str, &str>::new();
-        data2.insert("hello", "Hello2");
-        backend2.add_translations("en", &data2);
+        let mut data2 = HashMap::new();
+        data2.insert("hello".into(), "Hello2".into());
+        backend2.add_translations("en".into(), data2);
 
-        let mut data_cn2 = HashMap::<&str, &str>::new();
-        data_cn2.insert("hello", "你好2");
-        backend2.add_translations("zh-CN", &data_cn2);
+        let mut data_cn2 = HashMap::new();
+        data_cn2.insert("hello".into(), "你好2".into());
+        backend2.add_translations("zh-CN".into(), data_cn2);
 
         let combined = backend.extend(backend2);
         assert_eq!(combined.translate("en", "hello"), Some(Cow::from("Hello2")));