Replace PluralElementsV1 with PluralElementsPackedULE

components/experimental/src/dimension/currency/long_format.rs

@@ -31,7 +31,11 @@ impl<'l> Writeable for LongFormattedCurrency<'l> {
         W: core::fmt::Write + ?Sized,
     {
         let operands = self.value.into();
-        let display_name = self.extended.display_names.get(operands, self.plural_rules);
+        let display_name = self
+            .extended
+            .display_names
+            .get(operands, self.plural_rules)
+            .1;
         let pattern = self.patterns.patterns.get(operands, self.plural_rules);
         let formatted_value = self.fixed_decimal_formatter.format(self.value);
         let interpolated = pattern.interpolate((formatted_value, display_name));

components/experimental/src/dimension/provider/extended_currency.rs

@@ -9,7 +9,9 @@
 //!
 //! Read more about data providers: [`icu_provider`]
 
-use icu_plurals::provider::PluralElementsV1;
+use alloc::borrow::Cow;
+
+use icu_plurals::provider::PluralElementsPackedULE;
 use icu_provider::prelude::*;
 
 #[cfg(feature = "compiled_data")]
@@ -42,6 +44,13 @@ pub struct CurrencyExtendedDataV1<'data> {
     /// # NOTE
     ///    Regards to the [Unicode Report TR35](https://unicode.org/reports/tr35/tr35-numbers.html#Currencies),
     ///    If no matching for specific count, the `other` count will be used.
-    #[cfg_attr(feature = "serde", serde(borrow))]
-    pub display_names: PluralElementsV1<'data>,
+    #[cfg_attr(
+        feature = "serde",
+        serde(borrow),
+        serde(
+            // Explicit disambiguation due to https://github.com/rust-lang/rust/issues/130180
+            deserialize_with = "icu_plurals::provider::deserialize_plural_elements_packed_cow::<_, str>"
+        )
+    )]
+    pub display_names: Cow<'data, PluralElementsPackedULE<str>>,
 }

components/experimental/src/relativetime/provider.rs

@@ -15,7 +15,10 @@ use core::marker::PhantomData;
 use core::{fmt::Debug, str::FromStr};
 use icu_pattern::{Pattern, PatternBackend, SinglePlaceholder};
 #[cfg(feature = "datagen")]
-use icu_plurals::PluralElements;
+use icu_plurals::{
+    provider::{FourBitMetadata, PluralElementsPackedULE},
+    PluralElements,
+};
 use icu_plurals::{PluralCategory, PluralOperands, PluralRules};
 use icu_provider::prelude::*;
 use zerovec::ZeroMap;
@@ -101,9 +104,16 @@ pub struct PluralCategoryStr<'data>(pub PluralCategory, pub Cow<'data, str>);
 #[cfg_attr(feature = "datagen", databake(path = icu_experimental::relativetime::provider))]
 #[yoke(prove_covariance_manually)]
 pub struct PluralPatterns<'data, B> {
-    #[cfg_attr(feature = "serde", serde(borrow))]
+    #[cfg_attr(
+        feature = "serde",
+        serde(borrow),
+        serde(
+            // Explicit disambiguation due to https://github.com/rust-lang/rust/issues/130180
+            deserialize_with = "icu_plurals::provider::deserialize_plural_elements_packed_cow::<_, str>"
+        )
+    )]
     #[doc(hidden)] // databake only
-    pub strings: icu_plurals::provider::PluralElementsV1<'data>,
+    pub strings: Cow<'data, icu_plurals::provider::PluralElementsPackedULE<str>>,
     #[cfg_attr(feature = "serde", serde(skip))]
     #[doc(hidden)] // databake only
     pub _phantom: PhantomData<B>,
@@ -121,76 +131,63 @@ impl<'data, B> Clone for PluralPatterns<'data, B> {
 impl<'data, B: PatternBackend<Store = str>> PluralPatterns<'data, B> {
     /// Returns the pattern for the given [`PluralCategory`].
     pub fn get(&'data self, op: PluralOperands, rules: &PluralRules) -> &'data Pattern<B, str> {
-        Pattern::from_ref_store_unchecked(self.strings.get(op, rules))
+        Pattern::from_ref_store_unchecked(self.strings.get(op, rules).1)
     }
 }
 
 #[cfg(feature = "datagen")]
-impl<'data, B: PatternBackend<Store = str>> TryFrom<PluralElements<'data, str>>
+impl<'data, B: PatternBackend<Store = str>> TryFrom<PluralElements<&'data str>>
     for PluralPatterns<'static, B>
 where
     B::PlaceholderKeyCow<'data>: FromStr,
     <B::PlaceholderKeyCow<'data> as FromStr>::Err: Debug,
 {
     type Error = icu_pattern::PatternError;
 
-    fn try_from(elements: PluralElements<str>) -> Result<Self, Self::Error> {
-        let make_pattern = |s: &str|
+    fn try_from(elements: PluralElements<&'data str>) -> Result<Self, Self::Error> {
+        let make_pattern = |s: &&str|
             // TODO: Make pattern support apostrophes
-            Pattern::<B, String>::from_str(&s.replace('\'', "''")).map(|p| p.take_store());
+            Pattern::<B, String>::from_str(&s.replace('\'', "''")).map(|p| (FourBitMetadata::zero(), p.take_store()));
+
+        let plural_elements = PluralElements::new(make_pattern(elements.other())?)
+            .with_zero_value(
+                Some(elements.zero())
+                    .filter(|&e| e != elements.other())
+                    .map(make_pattern)
+                    .transpose()?,
+            )
+            .with_one_value(
+                Some(elements.one())
+                    .filter(|&e| e != elements.other())
+                    .map(make_pattern)
+                    .transpose()?,
+            )
+            .with_two_value(
+                Some(elements.two())
+                    .filter(|&e| e != elements.other())
+                    .map(make_pattern)
+                    .transpose()?,
+            )
+            .with_few_value(
+                Some(elements.few())
+                    .filter(|&e| e != elements.other())
+                    .map(make_pattern)
+                    .transpose()?,
+            )
+            .with_many_value(
+                Some(elements.many())
+                    .filter(|&e| e != elements.other())
+                    .map(make_pattern)
+                    .transpose()?,
+            )
+            .with_explicit_zero_value(elements.explicit_zero().map(make_pattern).transpose()?)
+            .with_explicit_one_value(elements.explicit_one().map(make_pattern).transpose()?);
+
+        let packed_pattern_box =
+            zerovec::ule::encode_varule_to_box::<_, PluralElementsPackedULE<str>>(&plural_elements);
 
         Ok(Self {
-            strings: PluralElements::new(make_pattern(elements.other())?.as_str())
-                .with_zero_value(
-                    Some(elements.zero())
-                        .filter(|&e| e != elements.other())
-                        .map(make_pattern)
-                        .transpose()?
-                        .as_deref(),
-                )
-                .with_one_value(
-                    Some(elements.one())
-                        .filter(|&e| e != elements.other())
-                        .map(make_pattern)
-                        .transpose()?
-                        .as_deref(),
-                )
-                .with_two_value(
-                    Some(elements.two())
-                        .filter(|&e| e != elements.other())
-                        .map(make_pattern)
-                        .transpose()?
-                        .as_deref(),
-                )
-                .with_few_value(
-                    Some(elements.few())
-                        .filter(|&e| e != elements.other())
-                        .map(make_pattern)
-                        .transpose()?
-                        .as_deref(),
-                )
-                .with_many_value(
-                    Some(elements.many())
-                        .filter(|&e| e != elements.other())
-                        .map(make_pattern)
-                        .transpose()?
-                        .as_deref(),
-                )
-                .with_explicit_zero_value(
-                    elements
-                        .explicit_zero()
-                        .map(make_pattern)
-                        .transpose()?
-                        .as_deref(),
-                )
-                .with_explicit_one_value(
-                    elements
-                        .explicit_one()
-                        .map(make_pattern)
-                        .transpose()?
-                        .as_deref(),
-                )
-                .into(),
+            strings: Cow::Owned(packed_pattern_box),
             _phantom: PhantomData,
         })
     }

components/plurals/Cargo.toml

@@ -36,6 +36,7 @@ icu_benchmark_macros = { path = "../../tools/benchmark/macros" }
 icu_locale_core = { path = "../../components/locale_core" }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
+postcard = { workspace = true, features = ["alloc"] }
 
 [target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]
 criterion = { workspace = true }