finchie/l10n_embed - Change RA3H7PWCI7WHONXB32IWYECQ3VKPKEXXYAJDIOHWNAGHDO7L5ZLQC

Refactor `Localize` for performance

Main change is switching from individual String allocations to a shared buffer, along with caching icu4x formatters to reduce duplicated work.

Created by finchie on August 27, 2025

RA3H7PWCI7WHONXB32IWYECQ3VKPKEXXYAJDIOHWNAGHDO7L5ZLQC

Dependencies

In channels

main

Change contents

Replacement in l10n_embed_interaction/src/prompt/select.rs at line 16 [19.109]

∅:D[35.100] → [34.217:290]

B:BD[34.217] → [34.217:290]

        let localized_prompt = prompt.localize_for(&environment.locale);

[35.100]

[34.290]

        let mut localized_prompt = String::new();
        prompt.localize(&environment.localization_context, &mut localized_prompt);

Replacement in l10n_embed_interaction/src/prompt/select.rs at line 30 [19.109]

B:BD[19.685] → [32.0:69]

            .map(|item| item.localize_for(&self.environment.locale))

[19.685]

[22.98]

            .map(|item| {
                let mut localized_item = String::new();
                item.localize(&self.environment.localization_context, &mut localized_item);
                localized_item
            })

Replacement in l10n_embed_interaction/src/prompt/select.rs at line 43 [19.109]
B:BD[31.590] → [31.590:631]
```
        match self.environment.context {
```
[31.590]
[19.1286]
```
        match self.environment.interaction_context {
```
Replacement in l10n_embed_interaction/src/prompt/password.rs at line 6 [19.2012]
B:BD[19.2243] → [34.506:536]
```
    localized_prompt: String,
```
[19.2243]
[19.2263]
```
    prompt: String,
```

Replacement in l10n_embed_interaction/src/prompt/password.rs at line 20 [19.2012]

B:BD[31.829] → [35.101:130]

∅:D[35.130] → [34.611:778]

B:BD[34.611] → [34.611:778]

    pub fn new<L: Localize>(
        environment: &'environment InteractionEnvironment,
        prompt: L,
    ) -> Self {
        let localized_prompt = prompt.localize_for(&environment.locale);

[31.829]

[34.778]

    pub fn new<L: Localize>(environment: &'environment InteractionEnvironment, prompt: L) -> Self {
        let mut localized_prompt = String::new();
        prompt.localize(&environment.localization_context, &mut localized_prompt);

Replacement in l10n_embed_interaction/src/prompt/password.rs at line 34 [19.2012]
B:BD[19.2656] → [19.2656:2682]
```
        confirmation: L1,
```
[19.2656]
[19.2682]
```
        confirmation_prompt: L1,
```

Replacement in l10n_embed_interaction/src/prompt/password.rs at line 37 [19.2012]

B:BD[22.197] → [32.70:244]

        let confirmation_text = confirmation.localize_for(&self.environment.locale);
        let mismatch_error_text = mismatch_error.localize_for(&self.environment.locale);

[22.197]

[19.2895]

        let mut localized_prompt = String::new();
        confirmation_prompt.localize(
            &self.environment.localization_context,
            &mut localized_prompt,
        );
        let mut localized_mismatch_error = String::new();
        mismatch_error.localize(
            &self.environment.localization_context,
            &mut localized_mismatch_error,
        );

Replacement in l10n_embed_interaction/src/prompt/password.rs at line 50 [19.2012]

B:BD[19.3099] → [34.819:868]

∅:D[34.868] → [19.3138:3187]

B:BD[19.3138] → [19.3138:3187]

            localized_prompt: confirmation_text,
            mismatch_error: mismatch_error_text,

[19.3099]

[19.3187]

            prompt: localized_prompt,
            mismatch_error: localized_mismatch_error,

Replacement in l10n_embed_interaction/src/prompt/password.rs at line 58 [19.2012]
B:BD[31.1333] → [31.1333:1374]
```
        match self.environment.context {
```
[31.1333]
[19.3385]
```
        match self.environment.interaction_context {
```

Replacement in l10n_embed_interaction/src/prompt/password.rs at line 64 [19.2012]

B:BD[19.3585] → [34.997:1183]

                    prompt = prompt.with_confirmation(
                        confirmation.localized_prompt,
                        confirmation.mismatch_error,
                    );

[19.3585]

[19.3714]

                    prompt =
                        prompt.with_confirmation(confirmation.prompt, confirmation.mismatch_error);

Replacement in l10n_embed_interaction/src/prompt/macros.rs at line 23 [19.4406]

B:BD[19.5612] → [31.1729:1791]

                let locale = self.environment.locale.clone();

[19.5612]

                let localization_context =
                    std::sync::Arc::clone(&self.environment.localization_context);

Replacement in l10n_embed_interaction/src/prompt/macros.rs at line 29 [19.4406]

B:BD[19.5792] → [19.5792:5892]

B:BD[19.5892] → [32.330:393]

                        Err(message) => {
                            // Localize the error message
                            Err(message.localize_for(&locale))

[19.5792]

[19.6188]

                        Err(error_message) => {
                            let mut localized_error = String::new();
                            error_message.localize(&localization_context, &mut localized_error);
                            Err(localized_error)

Replacement in l10n_embed_interaction/src/prompt/input.rs at line 15 [19.6488]

B:BD[31.2129] → [35.131:160]

∅:D[35.160] → [34.1367:1534]

B:BD[34.1367] → [34.1367:1534]

    pub fn new<L: Localize>(
        environment: &'environment InteractionEnvironment,
        prompt: L,
    ) -> Self {
        let localized_prompt = prompt.localize_for(&environment.locale);

[31.2129]

[34.1534]

    pub fn new<L: Localize>(environment: &'environment InteractionEnvironment, prompt: L) -> Self {
        let mut localized_prompt = String::new();
        prompt.localize(&environment.localization_context, &mut localized_prompt);

Replacement in l10n_embed_interaction/src/prompt/input.rs at line 28 [19.6488]

B:BD[22.802] → [32.394:471]

∅:D[21.329] → [19.7171:7216]

∅:D[32.471] → [19.7171:7216]

∅:D[22.851] → [19.7171:7216]

∅:D[31.2452] → [19.7171:7216]

B:BD[19.7171] → [19.7171:7216]

        let localized_text = default.localize_for(&self.environment.locale);
        self.default = Some(localized_text);

[22.802]

[19.7216]

        let mut localized_default = String::new();
        default.localize(
            &self.environment.localization_context,
            &mut localized_default,
        );
        self.default = Some(localized_default);

Replacement in l10n_embed_interaction/src/prompt/input.rs at line 40 [19.6488]
B:BD[31.2525] → [31.2525:2566]
```
        match self.environment.context {
```
[31.2525]
[19.7402]
```
        match self.environment.interaction_context {
```

Replacement in l10n_embed_interaction/src/prompt/confirm.rs at line 16 [19.8140]

∅:D[35.261] → [34.1947:2020]

B:BD[34.1947] → [34.1947:2020]

        let localized_prompt = prompt.localize_for(&environment.locale);

[35.261]

[34.2020]

        let mut localized_prompt = String::new();
        prompt.localize(&environment.localization_context, &mut localized_prompt);

Replacement in l10n_embed_interaction/src/prompt/confirm.rs at line 27 [19.8140]
B:BD[31.3040] → [31.3040:3081]
```
        match self.environment.context {
```
[31.3040]
[19.8672]
```
        match self.environment.interaction_context {
```

Replacement in l10n_embed_interaction/src/progress.rs at line 23 [20.513]

B:BD[31.3311] → [32.472:544]

        let localized_text = message.localize_for(&environment.locale);

[31.3311]

[31.3389]

        let mut localized_text = String::new();
        message.localize(&environment.localization_context, &mut localized_text);

Insertion in l10n_embed_interaction/src/lib.rs at line 4 [19.9269]
[19.9294]
[19.9294]
```
use std::sync::Arc;
```
Deletion in l10n_embed_interaction/src/lib.rs at line 7 [19.9269]
B:BD[19.9295] → [31.3548:3572]
```
use icu_locale::Locale;
```
Replacement in l10n_embed_interaction/src/lib.rs at line 8 [19.9269]
∅:D[31.3602] → [29.272:298]
B:BD[19.9295] → [29.272:298]
```
use l10n_embed::Localize;
```
[31.3602]
[19.9320]
```
use l10n_embed::{Context, Localize};
```
Replacement in l10n_embed_interaction/src/lib.rs at line 41 [19.9269]
B:BD[19.10022] → [19.10022:10055]
B:BD[19.10055] → [31.3603:3623]
```
    context: InteractionContext,
    locale: Locale,
```
[19.10022]
[20.1850]
```
    localization_context: Arc<Context>,
    interaction_context: InteractionContext,
```

Replacement in l10n_embed_interaction/src/lib.rs at line 48 [19.9269]

B:BD[24.45] → [31.3624:3684]

    pub fn new(locale: Locale, interactive: bool) -> Self {

[24.45]

[19.10132]

    pub fn new(localization_context: Arc<Context>, interactive: bool) -> Self {

Replacement in l10n_embed_interaction/src/lib.rs at line 50 [19.9269]

B:BD[19.10147] → [24.90:131]

            context: match interactive {

[19.10147]

[24.131]

            localization_context,
            interaction_context: match interactive {

Deletion in l10n_embed_interaction/src/lib.rs at line 55 [19.9269]
B:BD[24.261] → [31.3685:3705]
```
            locale,
```

Replacement in l10n_embed_interaction/src/lib.rs at line 60 [19.9269]

∅:D[36.230] → [31.3706:3733]

B:BD[26.88] → [31.3706:3733]

B:BD[31.3733] → [36.231:290]

        self.progress_bars
            .println(message.localize_for(&self.locale))?;

[36.230]

[36.290]

        let mut localized_message = String::new();
        message.localize(&self.localization_context, &mut localized_message);
        self.progress_bars.println(localized_message)?;

Replacement in l10n_embed_interaction/src/editor.rs at line 25 [19.10371]
B:BD[31.5125] → [31.5125:5166]
```
        match self.environment.context {
```
[31.5125]
[19.10938]
```
        match self.environment.interaction_context {
```
Insertion in l10n_embed_interaction/examples/prompt/main.rs at line 2 [37.74]
[37.126]
[37.126]
```
use std::sync::Arc;
```
Insertion in l10n_embed_interaction/examples/prompt/main.rs at line 6 [37.74]
[37.151]
[37.151]
```
use l10n_embed::Context;
```

Replacement in l10n_embed_interaction/examples/prompt/main.rs at line 50 [37.74]

B:BD[37.1236] → [37.1236:1311]

    let environment = InteractionEnvironment::new(locale!("en-US"), true);

[37.1236]

[37.1311]

    let context = Arc::new(Context::new(locale!("en-US")));
    let environment = InteractionEnvironment::new(context, true);

Insertion in l10n_embed_interaction/examples/progress/main.rs at line 2 [37.4967]
[37.5012]
[37.5012]
```
use std::sync::Arc;
```
Insertion in l10n_embed_interaction/examples/progress/main.rs at line 6 [37.4967]
[37.5037]
[37.5037]
```
use l10n_embed::Context;
```

Replacement in l10n_embed_interaction/examples/progress/main.rs at line 18 [37.4967]

B:BD[37.5313] → [37.5313:5388]

    let environment = InteractionEnvironment::new(locale!("en-US"), true);

[37.5313]

[37.5388]

    let context = Arc::new(Context::new(locale!("en-US")));
    let environment = InteractionEnvironment::new(context, true);

Replacement in l10n_embed_derive/tests/unnamed_fields.rs at line 6 [39.42]
B:BD[39.170] → [39.170:196]
```
use l10n_embed::Localize;
```
[39.170]
[39.196]
```
use l10n_embed::{Context, Localize};
```

Replacement in l10n_embed_derive/tests/unnamed_fields.rs at line 24 [39.42]

B:BD[39.563] → [39.563:670]

    fn localize_for(&self, locale: &Locale) -> String {
        format!("Localized with locale: {locale}")

[39.563]

[39.670]

    fn localize(&self, context: &Context, buffer: &mut String) {
        buffer.push_str("Localized with locale: ");
        buffer.push_str(&context.locale.to_string());

Replacement in l10n_embed_derive/tests/common/mod.rs at line 2 [17.3053]
B:BD[25.1223] → [29.964:990]
```
use l10n_embed::Localize;
```
[25.1223]
[17.3118]
```
use l10n_embed::{Context, Localize};
```

Replacement in l10n_embed_derive/tests/common/mod.rs at line 5 [17.3053]

B:BD[25.1318] → [32.621:669]

∅:D[32.669] → [17.3399:3461]

∅:D[22.1082] → [17.3399:3461]

B:BD[17.3399] → [17.3399:3461]

    let result = message.localize_for(&locale);
    pretty_assertions::assert_eq!(result, expected.as_ref());

[25.1318]

[17.3461]

    let context = Context::new(locale);
    let mut buffer = String::new();
    message.localize(&context, &mut buffer);
    pretty_assertions::assert_eq!(expected.as_ref(), buffer);

Replacement in l10n_embed_derive/src/macro_impl/mod.rs at line 159 [10.76]
B:BD[10.1868] → [32.670:699]
```
            fn localize_for(
```
[10.1868]
[12.454]
```
            fn localize(
```

Replacement in l10n_embed_derive/src/macro_impl/mod.rs at line 161 [10.76]

B:BD[12.477] → [33.276:350]

∅:D[33.350] → [22.1177:1203]

∅:D[29.1455] → [22.1177:1203]

∅:D[25.1617] → [22.1177:1203]

B:BD[15.426] → [22.1177:1203]

                locale: &::l10n_embed::macro_prelude::icu_locale::Locale,
            ) -> String {

[12.477]

[12.646]

                context: &::l10n_embed::Context,
                buffer: &mut String,
            ) {

Deletion in l10n_embed_derive/src/macro_impl/derive.rs at line 41 [45.39]

B:BD[5.510] → [22.1204:1245]

∅:D[22.1245] → [4.903:993]

B:BD[3.626] → [4.903:993]

B:BD[4.993] → [6.2172:2231]

B:BD[6.2231] → [33.351:840]

∅:D[15.640] → [2.712:713]

∅:D[8.745] → [2.712:713]

∅:D[33.840] → [2.712:713]

∅:D[3.994] → [2.712:713]

∅:D[4.1180] → [2.712:713]

∅:D[9.1347] → [2.712:713]

∅:D[29.1780] → [2.712:713]

∅:D[6.2467] → [2.712:713]

B:BD[2.712] → [2.712:713]

B:BD[2.713] → [33.841:842]

        let mut buffer = String::new();
        // TODO: handle different rule types according to fluent code (not just cardinal)
        // TODO: only generate this when needed in message
        const PLURAL_RULE_TYPE: ::l10n_embed::macro_prelude::icu_plurals::PluralRuleType =
            ::l10n_embed::macro_prelude::icu_plurals::PluralRuleType::Cardinal;
        let plural_options = ::l10n_embed::macro_prelude::icu_plurals::PluralRulesOptions::default()
            .with_type(PLURAL_RULE_TYPE);
        let plural_rules = ::l10n_embed::macro_prelude::icu_plurals::PluralRules::try_new(
            locale.into(),
            plural_options,
        )
        .unwrap();

Replacement in l10n_embed_derive/src/macro_impl/derive.rs at line 42 [45.39]

B:BD[6.2509] → [12.677:735]

        #(if locale.normalizing_eq(#additional_locales) {

[6.2509]

[12.735]

        #(if context.locale.normalizing_eq(#additional_locales) {

Replacement in l10n_embed_derive/src/macro_impl/derive.rs at line 44 [45.39]
B:BD[12.768] → [22.1246:1273]
```
            return buffer;
```
[12.768]
[12.795]
```
            return;
```

Replacement in l10n_embed_derive/src/macro_impl/derive.rs at line 46 [45.39]

∅:D[12.812] → [6.2510:2593]

B:BD[4.1275] → [6.2510:2593]

        // Fall back to the canonical locale, if no other valid locale was matched

[12.812]

[4.1275]


        // Fall back to the canonical locale if no other valid locale was matched

Deletion in l10n_embed_derive/src/macro_impl/derive.rs at line 49 [45.39]
B:BD[4.1302] → [12.813:814]
B:BD[12.814] → [22.1274:1289]
```
        buffer
```
Replacement in l10n_embed_derive/src/macro_impl/derive.rs at line 70 [45.39]
B:BD[39.6217] → [39.6217:6271]
```
    Ok(quote!(#field_reference.localize_for(locale)))
```
[39.6217]
[39.6271]
```
    Ok(quote!(#field_reference.localize(context, buffer)))
```

Replacement in l10n_embed_derive/src/lib.rs at line 46 [46.74]

B:BD[29.2087] → [32.700:745]

                            fn localize_for(

[29.2087]

[16.2937]

                            fn localize(

Replacement in l10n_embed_derive/src/lib.rs at line 48 [46.74]

B:BD[16.2976] → [33.973:1063]

∅:D[33.1063] → [22.1404:1446]

∅:D[25.1873] → [22.1404:1446]

∅:D[29.2163] → [22.1404:1446]

B:BD[16.3113] → [22.1404:1446]

                                locale: &::l10n_embed::macro_prelude::icu_locale::Locale,
                            ) -> String {

[16.2976]

[16.3194]

                                context: &::l10n_embed::Context,
                                buffer: &mut String,
                            ) {

Replacement in l10n_embed_derive/src/fluent/ast.rs at line 57 [47.33]

∅:D[42.4528] → [40.4198:4285]

B:BD[40.4198] → [40.4198:4285]

                                quote!(plural_rules.category_for(#category_reference))

[42.4528]

[12.2520]


                                quote! {
                                    {
                                        // TODO: handle different rule types according to fluent code (not just cardinal)
                                        let plural_rules = context.plural_rule(::l10n_embed::macro_prelude::icu_plurals::PluralRuleType::Cardinal).unwrap();
                                        plural_rules.category_for(#category_reference)
                                    }
                                }

Replacement in l10n_embed_derive/src/fluent/ast.rs at line 99 [47.33]

B:BD[12.2973] → [32.746:835]

                        parse_quote!(buffer.push_str(&#expression.localize_for(locale)))

[12.2973]

[5.3995]

                        parse_quote!(#expression.localize(context, buffer))

Replacement in l10n_embed/src/time.rs at line 1 [7.53]
B:BD[7.53] → [22.1623:1644]
```
use crate::Localize;
```
[7.53]
[11.21]
```
use crate::{Context, Localize};
```
Replacement in l10n_embed/src/time.rs at line 3 [7.53]
B:BD[11.22] → [15.1476:1522]
∅:D[15.1522] → [7.105:143]
B:BD[7.105] → [7.105:143]
B:BD[7.143] → [22.1645:1720]
∅:D[22.1720] → [7.218:221]
B:BD[7.218] → [7.218:221]
B:BD[7.221] → [25.1893:1917]
```
use fixed_decimal::{Decimal, FloatPrecision};
use icu_experimental::relativetime::{
    RelativeTimeFormatter, RelativeTimeFormatterOptions, options::Numeric,
};
use icu_locale::Locale;
```
[11.22]
[22.1767]
```
use fixed_decimal::Decimal;
```
Insertion in l10n_embed/src/time.rs at line 5 [7.53]
[22.1821]
[7.350]
```
use writeable::Writeable;
```

Deletion in l10n_embed/src/time.rs at line 7 [7.53]

B:BD[7.351] → [7.351:550]

B:BD[7.748] → [7.748:749]

/// Allow the formatter to use non-numeric output (e.g. "tomorrow", "yesterday")
const FORMATTER_OPTIONS: RelativeTimeFormatterOptions = RelativeTimeFormatterOptions {
    numeric: Numeric::Auto,
};

Replacement in l10n_embed/src/time.rs at line 8 [7.53]

B:BD[18.507] → [32.836:892]

    fn localize_for(&self, locale: &Locale) -> String {

[18.507]

[7.990]

    fn localize(&self, context: &Context, buffer: &mut String) {

Replacement in l10n_embed/src/time.rs at line 65 [7.53]

∅:D[11.248] → [7.3398:3444]

B:BD[7.3398] → [7.3398:3444]

B:BD[7.3444] → [15.1570:2478]

∅:D[15.2478] → [7.4124:4186]

B:BD[7.4124] → [7.4124:4186]

        let formatter = match selected_unit {
            Unit::Year => {
                RelativeTimeFormatter::try_new_long_year(locale.into(), FORMATTER_OPTIONS)
            }
            Unit::Month => {
                RelativeTimeFormatter::try_new_long_month(locale.into(), FORMATTER_OPTIONS)
            }
            Unit::Week => {
                RelativeTimeFormatter::try_new_long_week(locale.into(), FORMATTER_OPTIONS)
            }
            Unit::Day => RelativeTimeFormatter::try_new_long_day(locale.into(), FORMATTER_OPTIONS),
            Unit::Hour => {
                RelativeTimeFormatter::try_new_long_hour(locale.into(), FORMATTER_OPTIONS)
            }
            Unit::Minute => {
                RelativeTimeFormatter::try_new_long_minute(locale.into(), FORMATTER_OPTIONS)
            }
            Unit::Second => {
                RelativeTimeFormatter::try_new_long_second(locale.into(), FORMATTER_OPTIONS)
            }
            _ => unreachable!(),
        }
        .unwrap();

[7.3293]

[7.4186]

        let formatter = context.relative_time_formatter(selected_unit).unwrap();

Replacement in l10n_embed/src/time.rs at line 67 [7.53]

B:BD[7.4187] → [7.4187:4209]

B:BD[7.4209] → [15.2479:2571]

        let decimal =
            Decimal::try_from_f64(selected_value as f64, FloatPrecision::Integer).unwrap();

[7.4187]

[12.4267]

        let decimal = Decimal::from(selected_value);

Replacement in l10n_embed/src/time.rs at line 69 [7.53]
B:BD[12.4323] → [22.1897:1932]
```
        formatted_text.to_string()
```
[12.4323]
[11.394]
```
        formatted_text.write_to(buffer).unwrap();
```
Replacement in l10n_embed/src/style.rs at line 1 [27.33]
B:BD[27.33] → [27.34:55]
```
use crate::Localize;
```
[27.33]
[27.55]
```
use crate::{Context, Localize};
```

Replacement in l10n_embed/src/style.rs at line 21 [27.33]

B:BD[27.442] → [32.893:1018]

∅:D[32.1018] → [27.579:700]

B:BD[27.579] → [27.579:700]

    fn localize_for(&self, locale: &icu_locale::Locale) -> String {
        let message = self.message.localize_for(locale);
        match self.style {
            Some(style) => format!("{style}{message}{style:#}"),
            None => message,

[27.442]

[27.700]

    fn localize(&self, context: &Context, buffer: &mut String) {
        // Prefix with the terminal color codes
        if let Some(style) = self.style {
            let prefix = style.render().to_string();
            buffer.push_str(&prefix);
        }
        self.message.localize(context, buffer);
        // Suffix with the terminal reset codes
        if let Some(style) = self.style {
            let suffix = style.render_reset().to_string();
            buffer.push_str(&suffix);

Deletion in l10n_embed/src/string.rs at line 3 [14.34]
B:BD[14.95] → [14.95:116]
```
use crate::Localize;
```
Replacement in l10n_embed/src/string.rs at line 5 [14.34]
B:BD[14.139] → [25.1981:2005]
```
use icu_locale::Locale;
```
[14.139]
[14.215]
```
use crate::{Context, Localize};
```

Replacement in l10n_embed/src/string.rs at line 10 [14.34]

B:BD[23.95] → [32.1019:1084]

∅:D[32.1084] → [23.474:510]

∅:D[25.2077] → [23.474:510]

B:BD[23.474] → [23.474:510]

            fn localize_for(&self, _locale: &Locale) -> String {
                (*self).to_string()

[23.95]

[23.510]

            fn localize(&self, _context: &Context, buffer: &mut String) {
                buffer.push_str(self.as_ref());

Replacement in l10n_embed/src/path.rs at line 3 [38.32]
B:BD[38.66] → [38.66:87]
```
use crate::Localize;
```
[38.66]
[38.87]
```
use crate::{Context, Localize};
```
Deletion in l10n_embed/src/path.rs at line 6 [38.32]
B:BD[38.125] → [38.125:149]
```
use icu_locale::Locale;
```

Replacement in l10n_embed/src/path.rs at line 10 [38.32]

B:BD[38.243] → [38.243:359]

            fn localize_for(&self, _locale: &Locale) -> String {
                self.to_string_lossy().to_string()

[38.243]

[38.359]

            fn localize(&self, _context: &Context, buffer: &mut String) {
                buffer.push_str(self.to_string_lossy().as_ref());

Replacement in l10n_embed/src/path.rs at line 20 [38.32]

B:BD[38.489] → [38.489:587]

            fn localize_for(&self, _locale: &Locale) -> String {
                self.to_string()

[38.489]

[38.587]

            fn localize(&self, _context: &Context, buffer: &mut String) {
                buffer.push_str(self.as_str())

Replacement in l10n_embed/src/list.rs at line 6 [41.32]
B:BD[41.91] → [41.91:112]
```
use crate::Localize;
```
[41.91]
[41.112]
```
use crate::{Context, Localize};
```
Replacement in l10n_embed/src/list.rs at line 8 [41.32]
B:BD[41.113] → [43.152:226]
∅:D[43.226] → [41.113:137]
B:BD[41.113] → [41.113:137]
```
use icu_list::ListFormatter;
use icu_list::options::ListFormatterOptions;
use icu_locale::Locale;
```
[41.113]
[41.137]
```
use writeable::Writeable;
```

Replacement in l10n_embed/src/list.rs at line 32 [41.32]

B:BD[43.635] → [43.635:874]

    fn localize_for(&self, locale: &Locale) -> String {
        let list_formatter = ListFormatter::try_new_and(
            locale.into(),
            ListFormatterOptions::default().with_length(self.length),
        )
        .unwrap();

[43.635]

[43.874]

    fn localize(&self, context: &Context, buffer: &mut String) {
        let list_formatter = context.list_formatter(self.length);
        let localized_messages = self.messages.iter().map(|message| {
            let mut buffer = String::new();
            message.localize(context, &mut buffer);

Replacement in l10n_embed/src/list.rs at line 39 [41.32]

B:BD[43.875] → [43.875:1013]

        let localized_messages = self
            .messages
            .iter()
            .map(|message| message.localize_for(locale));

[43.875]

[43.1013]

            buffer
        });

Replacement in l10n_embed/src/list.rs at line 42 [41.32]

B:BD[43.1014] → [43.1014:1076]

        list_formatter.format(localized_messages).to_string()

[43.1014]

[43.1076]

        let formatted_list = list_formatter.format(localized_messages);
        formatted_list.write_to(buffer).unwrap();

Insertion in l10n_embed/src/lib.rs at line 8 [6.82]
[7.4376]
[33.1488]
```
use std::sync::OnceLock;
```

Insertion in l10n_embed/src/lib.rs at line 11 [6.82]

[33.1489]

use icu_decimal::options::DecimalFormatterOptions;
use icu_decimal::{DecimalFormatter, DecimalFormatterPreferences};
use icu_experimental::relativetime::{
    RelativeTimeFormatter, RelativeTimeFormatterOptions, RelativeTimeFormatterPreferences,
};
use icu_list::options::{ListFormatterOptions, ListLength};
use icu_list::{ListFormatter, ListFormatterPreferences};

Insertion in l10n_embed/src/lib.rs at line 19 [6.82]

[33.1523]

use icu_plurals::{PluralRuleType, PluralRules, PluralRulesOptions, PluralRulesPreferences};

Replacement in l10n_embed/src/lib.rs at line 38 [6.82]

B:BD[32.1086] → [32.1086:1141]

    fn localize_for(&self, locale: &Locale) -> String;

[32.1086]

[6.807]

    fn localize(&self, context: &Context, buffer: &mut String);
}
pub struct Context {
    pub locale: Locale,
    decimal_formatter: OnceLock<DecimalFormatter>,
    list_formatters: [OnceLock<ListFormatter>; 3],
    plural_rules: [OnceLock<PluralRules>; 2],
    relative_time_formatters: [OnceLock<RelativeTimeFormatter>; 7],
}
impl Context {
    pub fn new(locale: Locale) -> Self {
        Self {
            locale,
            decimal_formatter: OnceLock::new(),
            list_formatters: [const { OnceLock::new() }; 3],
            plural_rules: [const { OnceLock::new() }; 2],
            relative_time_formatters: [const { OnceLock::new() }; 7],
        }
    }
    pub fn decimal_formatter(&self) -> &DecimalFormatter {
        self.decimal_formatter.get_or_init(|| {
            DecimalFormatter::try_new(
                DecimalFormatterPreferences::from(&self.locale),
                DecimalFormatterOptions::default(),
            )
            .unwrap()
        })
    }
    pub fn list_formatter(&self, length: ListLength) -> &ListFormatter {
        let index = match length {
            ListLength::Wide => 0,
            ListLength::Short => 1,
            ListLength::Narrow => 2,
            _ => unimplemented!(),
        };
        self.list_formatters[index].get_or_init(|| {
            ListFormatter::try_new_and(
                ListFormatterPreferences::from(&self.locale),
                ListFormatterOptions::default().with_length(length),
            )
            .unwrap()
        })
    }
    pub fn plural_rule(&self, rule_type: PluralRuleType) -> Option<&PluralRules> {
        let index = match rule_type {
            PluralRuleType::Cardinal => 0,
            PluralRuleType::Ordinal => 1,
            _ => return None,
        };
        let plural_rules = self.plural_rules[index].get_or_init(|| {
            PluralRules::try_new(
                PluralRulesPreferences::from(&self.locale),
                PluralRulesOptions::default().with_type(rule_type),
            )
            .unwrap()
        });
        Some(plural_rules)
    }
    pub fn relative_time_formatter(&self, unit: jiff::Unit) -> Option<&RelativeTimeFormatter> {
        let index = match unit {
            jiff::Unit::Year => 0,
            jiff::Unit::Month => 1,
            jiff::Unit::Week => 2,
            jiff::Unit::Day => 3,
            jiff::Unit::Hour => 4,
            jiff::Unit::Minute => 5,
            jiff::Unit::Second => 6,
            _ => return None,
        };
        let formatter = self.relative_time_formatters[index].get_or_init(|| {
            let preferences = RelativeTimeFormatterPreferences::from(&self.locale);
            const OPTIONS: RelativeTimeFormatterOptions = RelativeTimeFormatterOptions {
                numeric: icu_experimental::relativetime::options::Numeric::Auto,
            };
            match unit {
                jiff::Unit::Year => RelativeTimeFormatter::try_new_long_year(preferences, OPTIONS),
                jiff::Unit::Month => {
                    RelativeTimeFormatter::try_new_long_month(preferences, OPTIONS)
                }
                jiff::Unit::Week => RelativeTimeFormatter::try_new_long_week(preferences, OPTIONS),
                jiff::Unit::Day => RelativeTimeFormatter::try_new_long_day(preferences, OPTIONS),
                jiff::Unit::Hour => RelativeTimeFormatter::try_new_long_hour(preferences, OPTIONS),
                jiff::Unit::Minute => {
                    RelativeTimeFormatter::try_new_long_minute(preferences, OPTIONS)
                }
                jiff::Unit::Second => {
                    RelativeTimeFormatter::try_new_long_second(preferences, OPTIONS)
                }
                _ => unreachable!(),
            }
            .unwrap()
        });
        Some(formatter)
    }

Deletion in l10n_embed/src/layout.rs at line 5 [44.842]
B:BD[44.930] → [44.930:951]
```
use crate::Localize;
```
Insertion in l10n_embed/src/layout.rs at line 6 [44.842]
[44.976]
[44.976]
```
use crate::{Context, Localize};
```

Replacement in l10n_embed/src/layout.rs at line 25 [44.842]

B:BD[44.1464] → [44.1464:1685]

    fn localize_for(&self, locale: &Locale) -> String {
        let localized_items: Vec<String> = self
            .messages
            .iter()
            .map(|item| item.localize_for(locale))
            .collect();

[44.1464]

[44.1685]

    fn localize(&self, context: &Context, buffer: &mut String) {
        let separator = "\n".repeat(SEPARATOR_COUNT);
        for (index, message) in self.messages.iter().enumerate() {
            // Add the newlines before every additional line
            if index > 0 {
                buffer.push_str(&separator)
            }

Replacement in l10n_embed/src/layout.rs at line 34 [44.842]

B:BD[44.1686] → [44.1686:1746]

        localized_items.join(&"\n".repeat(SEPARATOR_COUNT))

[44.1686]

[44.1746]

            message.localize(context, buffer);
        }

Replacement in l10n_embed/src/layout.rs at line 62 [44.842]

B:BD[44.2414] → [44.2414:2510]

    fn localize_for(&self, locale: &Locale) -> String {
        let mut output = String::new();

[44.2414]

[44.2510]

    fn localize(&self, context: &Context, buffer: &mut String) {
        let mut localized_message = String::new();
        self.message.localize(context, &mut localized_message);

Insertion in l10n_embed/src/layout.rs at line 66 [44.842]

[44.2511]

        let vertical_padding = "\n".repeat(VERTICAL_PADDING);
        let horizontal_padding = " ".repeat(HORIZONTAL_PADDING);

Replacement in l10n_embed/src/layout.rs at line 70 [44.842]

B:BD[44.2583] → [44.2583:2640]

        output.push_str(&"\n".repeat(VERTICAL_PADDING));

[44.2583]

[44.2640]

        buffer.push_str(&vertical_padding);

Deletion in l10n_embed/src/layout.rs at line 72 [44.842]
B:BD[44.2641] → [44.2641:2709]
```
        let localized_message = self.message.localize_for(locale);
```
Deletion in l10n_embed/src/layout.rs at line 73 [44.842]
B:BD[44.2762] → [44.2762:2827]
```
        let horizontal_padding = " ".repeat(HORIZONTAL_PADDING);
```

Replacement in l10n_embed/src/layout.rs at line 74 [44.842]

B:BD[44.2896] → [44.2896:2950]

            // Add a newline on every additional line

[44.2896]

[44.2950]

            // Add a newline before every additional line

Replacement in l10n_embed/src/layout.rs at line 76 [44.842]
B:BD[44.2977] → [44.2977:3012]
```
                output.push('\n');
```
[44.2977]
[44.3012]
```
                buffer.push('\n');
```

Replacement in l10n_embed/src/layout.rs at line 79 [44.842]

B:BD[44.3027] → [44.3027:3112]

            output.push_str(&horizontal_padding);
            output.push_str(line);

[44.3027]

[44.3112]

            buffer.push_str(&horizontal_padding);
            buffer.push_str(line);

Deletion in l10n_embed/src/layout.rs at line 82 [44.842]
B:BD[44.3122] → [44.3122:3138]
```
        output
```
Replacement in l10n_embed/src/decimal.rs at line 4 [13.2537]
∅:D[23.774] → [13.2538:2559]
B:BD[13.2537] → [13.2538:2559]
```
use crate::Localize;
```
[23.774]
[13.2559]
```
use crate::{Context, Localize};
```
Replacement in l10n_embed/src/decimal.rs at line 7 [13.2537]
B:BD[15.4120] → [23.775:846]
B:BD[23.846] → [25.2959:2983]
```
use icu_decimal::{DecimalFormatter, options::DecimalFormatterOptions};
use icu_locale::Locale;
```
[15.4120]
[23.892]
```
use writeable::Writeable;
```

Replacement in l10n_embed/src/decimal.rs at line 12 [13.2537]

B:BD[23.991] → [32.1142:1206]

            fn localize_for(&self, locale: &Locale) -> String {

[23.991]

[23.1369]

            fn localize(&self, context: &Context, buffer: &mut String) {

Replacement in l10n_embed/src/decimal.rs at line 14 [13.2537]

B:BD[23.1427] → [32.1207:1258]

                fixed_decimal.localize_for(locale)

[23.1427]

[23.1484]

                fixed_decimal.localize(context, buffer);

Replacement in l10n_embed/src/decimal.rs at line 23 [13.2537]

B:BD[23.1614] → [32.1259:1323]

            fn localize_for(&self, locale: &Locale) -> String {

[23.1614]

[23.1992]

            fn localize(&self, context: &Context, buffer: &mut String) {

Replacement in l10n_embed/src/decimal.rs at line 26 [13.2537]

B:BD[23.2125] → [32.1324:1375]

                fixed_decimal.localize_for(locale)

[23.2125]

[23.2182]

                fixed_decimal.localize(context, buffer);

Replacement in l10n_embed/src/decimal.rs at line 49 [13.2537]

B:BD[18.1016] → [32.1376:1432]

∅:D[32.1432] → [13.4824:4848]

∅:D[22.2471] → [13.4824:4848]

∅:D[23.2571] → [13.4824:4848]

∅:D[25.3188] → [13.4824:4848]

B:BD[13.4824] → [13.4824:4848]

B:BD[13.4848] → [23.2572:2671]

    fn localize_for(&self, locale: &Locale) -> String {
        let formatter =
            DecimalFormatter::try_new(locale.into(), DecimalFormatterOptions::default()).unwrap();

[18.1016]

[13.4973]

    fn localize(&self, context: &Context, buffer: &mut String) {
        let formatter = context.decimal_formatter();

Replacement in l10n_embed/src/decimal.rs at line 53 [13.2537]
B:BD[13.5030] → [22.2472:2510]
```
        formatted_decimal.to_string()
```
[13.5030]
[13.5120]
```
        formatted_decimal.write_to(buffer).unwrap();
```
Replacement in l10n_embed/examples/time.rs at line 3 [30.54]
B:BD[30.108] → [30.108:142]
```
use icu_locale::{Locale, locale};
```
[30.108]
[30.142]
```
use icu_locale::locale;
```
Replacement in l10n_embed/examples/time.rs at line 5 [30.54]
B:BD[30.173] → [30.173:199]
```
use l10n_embed::Localize;
```
[30.173]
[30.199]
```
use l10n_embed::{Context, Localize};
```
Deletion in l10n_embed/examples/time.rs at line 7 [30.54]
B:BD[30.200] → [30.200:250]
```
const DEFAULT_LOCALE: Locale = locale!("en-US");
```

Replacement in l10n_embed/examples/time.rs at line 16 [30.54]

B:BD[30.661] → [30.661:703]

B:BD[30.703] → [32.1433:1489]

∅:D[32.1489] → [30.765:772]

B:BD[30.765] → [30.765:772]

B:BD[30.772] → [32.1490:1564]

∅:D[32.1564] → [30.772:786]

B:BD[30.772] → [30.772:786]

B:BD[30.888] → [30.888:922]

B:BD[30.922] → [32.1565:1616]

∅:D[32.1616] → [30.979:1041]

B:BD[30.979] → [30.979:1041]

B:BD[30.1041] → [32.1617:1669]

∅:D[32.1669] → [30.1099:1106]

B:BD[30.1099] → [30.1099:1106]

    println!(
        "Current time: {}",
        current_timestamp.localize_for(&DEFAULT_LOCALE)
    );
    println!("Unix epoch: {}", unix_epoch.localize_for(&DEFAULT_LOCALE));
    println!(
        "Two hours from now: {}",
        in_two_hours.localize_for(&DEFAULT_LOCALE)
    );
    println!(
        "Since start of year (UTC): {}",
        start_of_year.localize_for(&DEFAULT_LOCALE)
    );

[30.661]

[30.1106]

    let timestamps: [(&str, Timestamp); 4] = [
        ("Current time", current_timestamp),
        ("Unix epoch", unix_epoch),
        ("Two hours from now", in_two_hours),
        ("Since start of year (UTC)", start_of_year),
    ];
    let context = Context::new(locale!("en-US"));
    let mut buffer = String::new();
    for (name, timestamp) in timestamps {
        buffer.clear();
        timestamp.localize(&context, &mut buffer);
        println!("{name}: {buffer}");
    }

Replacement in l10n_embed/examples/style.rs at line 4 [30.1154]
B:BD[30.1229] → [30.1229:1263]
```
use icu_locale::{Locale, locale};
```
[30.1229]
[30.1263]
```
use icu_locale::locale;
```
Deletion in l10n_embed/examples/style.rs at line 6 [30.1154]
B:BD[30.1284] → [30.1284:1310]
```
use l10n_embed::Localize;
```
Insertion in l10n_embed/examples/style.rs at line 7 [30.1154]
[30.1341]
[30.1341]
```
use l10n_embed::{Context, Localize};
```
Deletion in l10n_embed/examples/style.rs at line 9 [30.1154]
B:BD[30.1342] → [30.1342:1391]
```
const DEFAULT_LOCALE: Locale = locale!("en-US");
```

Replacement in l10n_embed/examples/style.rs at line 14 [30.1154]

B:BD[30.1568] → [30.1568:1642]

    let five_million: Styled<u64> = Styled::new(5_000_000, STYLE_ENABLED)

[30.1568]

[30.1642]

    let bold_green: Styled<u64> = Styled::new(5_000_000, STYLE_ENABLED)

Replacement in l10n_embed/examples/style.rs at line 17 [30.1154]

B:BD[30.1692] → [30.1692:1770]

    let static_str: Styled<&'static str> = Styled::new("&str", STYLE_ENABLED)

[30.1692]

[30.1770]

    let italic_blue: Styled<&'static str> = Styled::new("&str", STYLE_ENABLED)

Replacement in l10n_embed/examples/style.rs at line 20 [30.1154]

B:BD[30.1821] → [30.1821:1911]

    let unix_epoch: Styled<Timestamp> = Styled::new(Timestamp::UNIX_EPOCH, STYLE_ENABLED)

[30.1821]

[30.1911]

    let strikethrough_red: Styled<Timestamp> = Styled::new(Timestamp::UNIX_EPOCH, STYLE_ENABLED)

Replacement in l10n_embed/examples/style.rs at line 25 [30.1154]

B:BD[30.2081] → [30.2081:2123]

B:BD[30.2123] → [32.1670:1721]

∅:D[32.1721] → [30.2180:2230]

B:BD[30.2180] → [30.2180:2230]

B:BD[30.2230] → [32.1722:1771]

∅:D[32.1771] → [30.2285:2292]

B:BD[30.2285] → [30.2285:2292]

B:BD[30.2292] → [32.1772:1846]

    println!(
        "Five million: {}",
        five_million.localize_for(&DEFAULT_LOCALE)
    );
    println!(
        "Static string: {}",
        static_str.localize_for(&DEFAULT_LOCALE)
    );
    println!("Unix epoch: {}", unix_epoch.localize_for(&DEFAULT_LOCALE));

[30.2081]

[30.2394]

    let styles: [(&str, Box<dyn Localize>); 3] = [
        ("Bold green", Box::new(bold_green)),
        ("Italic blue", Box::new(italic_blue)),
        ("Strikethrough red", Box::new(strikethrough_red)),
    ];
    let context = Context::new(locale!("en-US"));
    let mut buffer = String::new();
    for (name, style) in styles {
        buffer.clear();
        style.localize(&context, &mut buffer);
        println!("{name}: {buffer}");
    }

Replacement in l10n_embed/examples/string.rs at line 5 [30.2431]

B:BD[30.2500] → [30.2500:2560]

use icu_locale::{Locale, locale};
use l10n_embed::Localize;

[30.2500]

[30.2560]

use icu_locale::locale;
use l10n_embed::{Context, Localize};

Deletion in l10n_embed/examples/string.rs at line 8 [30.2431]
B:BD[30.2561] → [30.2561:2611]
```
const DEFAULT_LOCALE: Locale = locale!("en-US");
```

Replacement in l10n_embed/examples/string.rs at line 16 [30.2431]

B:BD[30.2931] → [30.2931:2974]

B:BD[30.2974] → [32.1847:1896]

∅:D[32.1896] → [30.3029:3087]

B:BD[30.3029] → [30.3029:3087]

B:BD[30.3087] → [32.1897:1957]

∅:D[32.1957] → [30.3153:3210]

B:BD[30.3153] → [30.3153:3210]

B:BD[30.3210] → [32.1958:2014]

∅:D[32.2014] → [30.3272:3279]

B:BD[30.3272] → [30.3272:3279]

    println!(
        "Static string: {}",
        static_str.localize_for(&DEFAULT_LOCALE)
    );
    println!(
        "Heap allocated string: {}",
        heap_allocated_string.localize_for(&DEFAULT_LOCALE)
    );
    println!(
        "Copy on write string: {}",
        copy_on_write_str.localize_for(&DEFAULT_LOCALE)
    );

[30.2931]

[30.3279]

    let strings: [(&str, Box<dyn Localize>); 3] = [
        ("Static string", Box::new(static_str)),
        ("Heap allocated string", Box::new(heap_allocated_string)),
        ("Copy on write string", Box::new(copy_on_write_str)),
    ];
    let context = Context::new(locale!("en-US"));
    let mut buffer = String::new();
    for (name, string) in strings {
        buffer.clear();
        string.localize(&context, &mut buffer);
        println!("{name}: {buffer}");
    }

Replacement in l10n_embed/examples/path.rs at line 4 [38.778]

B:BD[38.847] → [38.847:957]

use icu_locale::{Locale, locale};
use l10n_embed::Localize;
const DEFAULT_LOCALE: Locale = locale!("en-US");

[38.847]

[38.957]

use icu_locale::locale;
use l10n_embed::{Context, Localize};

Replacement in l10n_embed/examples/path.rs at line 13 [38.778]

B:BD[38.1274] → [38.1274:1507]

    println!(
        "Current directory: {}",
        current_directory.localize_for(&DEFAULT_LOCALE)
    );
    println!(
        "Current directory (UTF-8): {}",
        current_directory_utf8.localize_for(&DEFAULT_LOCALE)
    );

[38.1274]

[38.1507]

    let directories: [(&str, Box<dyn Localize>); 2] = [
        ("Current directory", Box::new(current_directory)),
        (
            "Current directory (UTF-8)",
            Box::new(current_directory_utf8),
        ),
    ];
    let context = Context::new(locale!("en-US"));
    let mut buffer = String::new();
    for (name, directory) in directories {
        buffer.clear();
        directory.localize(&context, &mut buffer);
        println!("{name}: {buffer}");
    }

Replacement in l10n_embed/examples/list.rs at line 3 [43.1144]
B:BD[43.1188] → [43.1188:1248]
```
use icu_locale::{Locale, locale};
use l10n_embed::Localize;
```
[43.1188]
[43.1248]
```
use icu_locale::locale;
```
Replacement in l10n_embed/examples/list.rs at line 5 [43.1144]
B:BD[43.1290] → [43.1290:1340]
```
const DEFAULT_LOCALE: Locale = locale!("en-US");
```
[43.1290]
[43.1340]
```
use l10n_embed::{Context, Localize};
```

Replacement in l10n_embed/examples/list.rs at line 16 [43.1144]

B:BD[43.1689] → [43.1689:1911]

    println!("Narrow list: {}", narrow_list.localize_for(&DEFAULT_LOCALE));
    println!("Short list: {}", short_list.localize_for(&DEFAULT_LOCALE));
    println!("Wide list: {}", wide_list.localize_for(&DEFAULT_LOCALE));

[43.1689]

[43.1911]

    let lists: [(&str, Box<dyn Localize>); 3] = [
        ("Narrow list", Box::new(narrow_list)),
        ("Short list", Box::new(short_list)),
        ("Wide list", Box::new(wide_list)),
    ];
    let context = Context::new(locale!("en-US"));
    let mut buffer = String::new();
    for (name, list) in lists {
        buffer.clear();
        list.localize(&context, &mut buffer);
        println!("{name}: {buffer}");
    }

Replacement in l10n_embed/examples/layout.rs at line 3 [44.3181]
B:BD[44.3240] → [44.3240:3300]
```
use icu_locale::{Locale, locale};
use l10n_embed::Localize;
```
[44.3240]
[44.3300]
```
use icu_locale::locale;
```
Replacement in l10n_embed/examples/layout.rs at line 5 [44.3181]
B:BD[44.3341] → [44.3341:3391]
```
const DEFAULT_LOCALE: Locale = locale!("en-US");
```
[44.3341]
[44.3391]
```
use l10n_embed::{Context, Localize};
```

Replacement in l10n_embed/examples/layout.rs at line 23 [44.3181]

B:BD[44.4047] → [44.4047:4741]

    let layouts = [
        (
            "Single newline",
            single_newline.localize_for(&DEFAULT_LOCALE),
        ),
        (
            "Double newlines",
            double_newlines.localize_for(&DEFAULT_LOCALE),
        ),
        (
            "Vertical padding",
            vertical_padding.localize_for(&DEFAULT_LOCALE),
        ),
        (
            "Horizontal padding",
            horizontal_padding.localize_for(&DEFAULT_LOCALE),
        ),
        (
            "Combined padding",
            combined_padding.localize_for(&DEFAULT_LOCALE),
        ),
        (
            "Padded newlines",
            padded_newlines.localize_for(&DEFAULT_LOCALE),
        ),

[44.4047]

[44.4741]

    let layouts: [(&str, Box<dyn Localize>); 6] = [
        ("Single newline", Box::new(single_newline)),
        ("Double newlines", Box::new(double_newlines)),
        ("Vertical padding", Box::new(vertical_padding)),
        ("Horizontal padding", Box::new(horizontal_padding)),
        ("Combined padding", Box::new(combined_padding)),
        ("Padded newlines", Box::new(padded_newlines)),

Insertion in l10n_embed/examples/layout.rs at line 32 [44.3181]

[44.4749]

    let context = Context::new(locale!("en-US"));
    let mut buffer = String::new();

Insertion in l10n_embed/examples/layout.rs at line 37 [44.3181]

[44.4848]

        buffer.clear();
        layout.localize(&context, &mut buffer);

Replacement in l10n_embed/examples/layout.rs at line 41 [44.3181]
B:BD[44.4888] → [44.4888:4918]
```
        println!("{layout}");
```
[44.4888]
[44.4918]
```
        println!("{buffer}");
```

Replacement in l10n_embed/examples/decimal.rs at line 4 [30.3317]

B:BD[30.3406] → [30.3406:3466]

use icu_locale::{Locale, locale};
use l10n_embed::Localize;

[30.3406]

[30.3466]

use icu_locale::locale;
use l10n_embed::{Context, Localize};

Deletion in l10n_embed/examples/decimal.rs at line 7 [30.3317]
B:BD[30.3467] → [30.3467:3517]
```
const DEFAULT_LOCALE: Locale = locale!("en-US");
```

Insertion in l10n_embed/examples/decimal.rs at line 14 [30.3317]

[30.3801]


    let context = Context::new(locale!("en-US"));
    let mut buffer = String::new();

Replacement in l10n_embed/examples/decimal.rs at line 19 [30.3317]

B:BD[30.3862] → [32.2015:2077]

∅:D[32.2077] → [30.3930:3972]

B:BD[30.3930] → [30.3930:3972]

B:BD[30.3972] → [32.2078:2129]

∅:D[32.2129] → [30.4029:4080]

B:BD[30.4029] → [30.4029:4080]

B:BD[30.4080] → [32.2130:2183]

∅:D[32.2183] → [30.4139:4199]

B:BD[30.4139] → [30.4139:4199]

B:BD[30.4199] → [32.2184:2246]

∅:D[32.2246] → [30.4267:4274]

B:BD[30.4267] → [30.4267:4274]

    println!("Zero: {}", zero.localize_for(&DEFAULT_LOCALE));
    println!(
        "Five million: {}",
        five_million.localize_for(&DEFAULT_LOCALE)
    );
    println!(
        "Zero point two: {}",
        zero_point_two.localize_for(&DEFAULT_LOCALE)
    );
    println!(
        "Negative two point five: {}",
        negative_two_point_five.localize_for(&DEFAULT_LOCALE)
    );

[30.3862]

[30.4274]

    let numbers: [(&str, Box<dyn Localize>); 4] = [
        ("Zero", Box::new(zero)),
        ("Five million", Box::new(five_million)),
        ("Zero point two", Box::new(zero_point_two)),
        ("Negative two point five", Box::new(negative_two_point_five)),
    ];
    for (name, number) in numbers {
        buffer.clear();
        number.localize(&context, &mut buffer);
        println!("{name}: {buffer}");
    }

Insertion in l10n_embed/Cargo.toml at line 27 [6.1078]
[15.5498]
```
writeable.workspace = true
```
Insertion in Cargo.toml at line 53 [48.197]
[28.3478]
```
writeable = "0.6"
```
Insertion in Cargo.lock at line 744 [49.4277]
[29.3149]
[20.2794]
```
 "writeable",
```

Refactor `Localize` for performance

Dependencies

In channels

Change contents

Replacement in l10n_embed_interaction/src/prompt/select.rs at line 16 [19.109]

Replacement in l10n_embed_interaction/src/prompt/select.rs at line 30 [19.109]

Replacement in l10n_embed_interaction/src/prompt/select.rs at line 43 [19.109]

Replacement in l10n_embed_interaction/src/prompt/password.rs at line 6 [19.2012]

Replacement in l10n_embed_interaction/src/prompt/password.rs at line 20 [19.2012]

Replacement in l10n_embed_interaction/src/prompt/password.rs at line 34 [19.2012]

Replacement in l10n_embed_interaction/src/prompt/password.rs at line 37 [19.2012]

Replacement in l10n_embed_interaction/src/prompt/password.rs at line 50 [19.2012]

Replacement in l10n_embed_interaction/src/prompt/password.rs at line 58 [19.2012]

Replacement in l10n_embed_interaction/src/prompt/password.rs at line 64 [19.2012]

Replacement in l10n_embed_interaction/src/prompt/macros.rs at line 23 [19.4406]

Replacement in l10n_embed_interaction/src/prompt/macros.rs at line 29 [19.4406]

Replacement in l10n_embed_interaction/src/prompt/input.rs at line 15 [19.6488]

Replacement in l10n_embed_interaction/src/prompt/input.rs at line 28 [19.6488]

Replacement in l10n_embed_interaction/src/prompt/input.rs at line 40 [19.6488]

Replacement in l10n_embed_interaction/src/prompt/confirm.rs at line 16 [19.8140]

Replacement in l10n_embed_interaction/src/prompt/confirm.rs at line 27 [19.8140]

Replacement in l10n_embed_interaction/src/progress.rs at line 23 [20.513]

Insertion in l10n_embed_interaction/src/lib.rs at line 4 [19.9269]

Deletion in l10n_embed_interaction/src/lib.rs at line 7 [19.9269]

Replacement in l10n_embed_interaction/src/lib.rs at line 8 [19.9269]

Replacement in l10n_embed_interaction/src/lib.rs at line 41 [19.9269]

Replacement in l10n_embed_interaction/src/lib.rs at line 48 [19.9269]

Replacement in l10n_embed_interaction/src/lib.rs at line 50 [19.9269]

Deletion in l10n_embed_interaction/src/lib.rs at line 55 [19.9269]

Replacement in l10n_embed_interaction/src/lib.rs at line 60 [19.9269]

Replacement in l10n_embed_interaction/src/editor.rs at line 25 [19.10371]

Insertion in l10n_embed_interaction/examples/prompt/main.rs at line 2 [37.74]

Insertion in l10n_embed_interaction/examples/prompt/main.rs at line 6 [37.74]

Replacement in l10n_embed_interaction/examples/prompt/main.rs at line 50 [37.74]

Insertion in l10n_embed_interaction/examples/progress/main.rs at line 2 [37.4967]

Insertion in l10n_embed_interaction/examples/progress/main.rs at line 6 [37.4967]

Replacement in l10n_embed_interaction/examples/progress/main.rs at line 18 [37.4967]

Replacement in l10n_embed_derive/tests/unnamed_fields.rs at line 6 [39.42]

Replacement in l10n_embed_derive/tests/unnamed_fields.rs at line 24 [39.42]

Replacement in l10n_embed_derive/tests/common/mod.rs at line 2 [17.3053]

Replacement in l10n_embed_derive/tests/common/mod.rs at line 5 [17.3053]

Replacement in l10n_embed_derive/src/macro_impl/mod.rs at line 159 [10.76]

Replacement in l10n_embed_derive/src/macro_impl/mod.rs at line 161 [10.76]

Deletion in l10n_embed_derive/src/macro_impl/derive.rs at line 41 [45.39]

Replacement in l10n_embed_derive/src/macro_impl/derive.rs at line 42 [45.39]

Replacement in l10n_embed_derive/src/macro_impl/derive.rs at line 44 [45.39]

Replacement in l10n_embed_derive/src/macro_impl/derive.rs at line 46 [45.39]

Deletion in l10n_embed_derive/src/macro_impl/derive.rs at line 49 [45.39]

Replacement in l10n_embed_derive/src/macro_impl/derive.rs at line 70 [45.39]

Replacement in l10n_embed_derive/src/lib.rs at line 46 [46.74]

Replacement in l10n_embed_derive/src/lib.rs at line 48 [46.74]

Replacement in l10n_embed_derive/src/fluent/ast.rs at line 57 [47.33]

Replacement in l10n_embed_derive/src/fluent/ast.rs at line 99 [47.33]

Replacement in l10n_embed/src/time.rs at line 1 [7.53]

Replacement in l10n_embed/src/time.rs at line 3 [7.53]

Insertion in l10n_embed/src/time.rs at line 5 [7.53]

Deletion in l10n_embed/src/time.rs at line 7 [7.53]

Replacement in l10n_embed/src/time.rs at line 8 [7.53]

Replacement in l10n_embed/src/time.rs at line 65 [7.53]

Replacement in l10n_embed/src/time.rs at line 67 [7.53]

Replacement in l10n_embed/src/time.rs at line 69 [7.53]

Replacement in l10n_embed/src/style.rs at line 1 [27.33]

Replacement in l10n_embed/src/style.rs at line 21 [27.33]

Deletion in l10n_embed/src/string.rs at line 3 [14.34]

Replacement in l10n_embed/src/string.rs at line 5 [14.34]

Replacement in l10n_embed/src/string.rs at line 10 [14.34]

Replacement in l10n_embed/src/path.rs at line 3 [38.32]

Deletion in l10n_embed/src/path.rs at line 6 [38.32]

Replacement in l10n_embed/src/path.rs at line 10 [38.32]

Replacement in l10n_embed/src/path.rs at line 20 [38.32]

Replacement in l10n_embed/src/list.rs at line 6 [41.32]

Replacement in l10n_embed/src/list.rs at line 8 [41.32]