Replace PluralElementsV1 with PluralElementsPackedULE

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

@@ -9,7 +9,7 @@
 //!
 //! Read more about data providers: [`icu_provider`]
 
-use icu_plurals::provider::PluralElementsV1;
+use icu_plurals::provider::PluralElementsPackedCowStr;
 use icu_provider::prelude::*;
 
 #[cfg(feature = "compiled_data")]
@@ -43,5 +43,5 @@ pub struct CurrencyExtendedDataV1<'data> {
     ///    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>,
+    pub display_names: PluralElementsPackedCowStr<'data>,
 }

components/experimental/src/relativetime/provider.rs

@@ -103,7 +103,7 @@ pub struct PluralCategoryStr<'data>(pub PluralCategory, pub Cow<'data, str>);
 pub struct PluralPatterns<'data, B> {
     #[cfg_attr(feature = "serde", serde(borrow))]
     #[doc(hidden)] // databake only
-    pub strings: icu_plurals::provider::PluralElementsV1<'data>,
+    pub strings: icu_plurals::provider::PluralElementsPackedCowStr<'data>,
     #[cfg_attr(feature = "serde", serde(skip))]
     #[doc(hidden)] // databake only
     pub _phantom: PhantomData<B>,
@@ -126,16 +126,16 @@ impl<'data, B: PatternBackend<Store = str>> PluralPatterns<'data, B> {
 }
 
 #[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());
 

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 }

components/plurals/src/lib.rs

@@ -877,21 +877,29 @@ where
 }
 
 #[derive(Debug)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 /// A bag of values for different plural cases.
-pub struct PluralElements<'a, T: ?Sized> {
-    zero: Option<&'a T>,
-    one: Option<&'a T>,
-    two: Option<&'a T>,
-    few: Option<&'a T>,
-    many: Option<&'a T>,
-    other: &'a T,
-    explicit_zero: Option<&'a T>,
-    explicit_one: Option<&'a T>,
+pub struct PluralElements<T> {
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
+    zero: Option<T>,
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
+    one: Option<T>,
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
+    two: Option<T>,
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
+    few: Option<T>,
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
+    many: Option<T>,
+    other: T,
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
+    explicit_zero: Option<T>,
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
+    explicit_one: Option<T>,
 }
 
-impl<'a, T: ?Sized + PartialEq> PluralElements<'a, T> {
+impl<T> PluralElements<T> {
     /// Creates a new [`PluralElements`] with the given default value.
-    pub fn new(other: &'a T) -> Self {
+    pub fn new(other: T) -> Self {
         Self {
             other,
             zero: None,
@@ -904,99 +912,116 @@ impl<'a, T: ?Sized + PartialEq> PluralElements<'a, T> {
         }
     }
 
+    /// The value for [`PluralCategory::Zero`]
+    pub fn zero(&self) -> &T {
+        self.zero.as_ref().unwrap_or(&self.other)
+    }
+
+    /// The value for [`PluralCategory::One`]
+    pub fn one(&self) -> &T {
+        self.one.as_ref().unwrap_or(&self.other)
+    }
+
+    /// The value for [`PluralCategory::Two`]
+    pub fn two(&self) -> &T {
+        self.two.as_ref().unwrap_or(&self.other)
+    }
+
+    /// The value for [`PluralCategory::Few`]
+    pub fn few(&self) -> &T {
+        self.few.as_ref().unwrap_or(&self.other)
+    }
+
+    /// The value for [`PluralCategory::Many`]
+    pub fn many(&self) -> &T {
+        self.many.as_ref().unwrap_or(&self.other)
+    }
+
+    /// The value for [`PluralCategory::Other`]
+    pub fn other(&self) -> &T {
+        &self.other
+    }
+
+    /// The value used when the [`PluralOperands`] are exactly 0.
+    pub fn explicit_zero(&self) -> Option<&T> {
+        self.explicit_zero.as_ref()
+    }
+
+    /// The value used when the [`PluralOperands`] are exactly 1.
+    pub fn explicit_one(&self) -> Option<&T> {
+        self.explicit_one.as_ref()
+    }
+
+    /// Applies a function `f` to map all values to another type.
+    pub fn map<B, F: Fn(T) -> B>(self, f: F) -> PluralElements<B> {
+        let f = &f;
+        PluralElements {
+            other: f(self.other),
+            zero: self.zero.map(f),
+            one: self.one.map(f),
+            two: self.two.map(f),
+            few: self.few.map(f),
+            many: self.many.map(f),
+            explicit_zero: self.explicit_zero.map(f),
+            explicit_one: self.explicit_one.map(f),
+        }
+    }
+}
+
+impl<T: PartialEq> PluralElements<T> {
     /// Sets the value for [`PluralCategory::Zero`].
-    pub fn with_zero_value(self, zero: Option<&'a T>) -> Self {
+    pub fn with_zero_value(self, zero: Option<T>) -> Self {
         Self {
-            zero: zero.filter(|&t| t != self.other),
+            zero: zero.filter(|t| *t != self.other),
             ..self
         }
     }
 
     /// Sets the value for [`PluralCategory::One`].
-    pub fn with_one_value(self, one: Option<&'a T>) -> Self {
+    pub fn with_one_value(self, one: Option<T>) -> Self {
         Self {
-            one: one.filter(|&t| t != self.other),
+            one: one.filter(|t| *t != self.other),
             ..self
         }
     }
 
     /// Sets the value for [`PluralCategory::Two`].
-    pub fn with_two_value(self, two: Option<&'a T>) -> Self {
+    pub fn with_two_value(self, two: Option<T>) -> Self {
         Self {
-            two: two.filter(|&t| t != self.other),
+            two: two.filter(|t| *t != self.other),
             ..self
         }
     }
 
     /// Sets the value for [`PluralCategory::Few`].
-    pub fn with_few_value(self, few: Option<&'a T>) -> Self {
+    pub fn with_few_value(self, few: Option<T>) -> Self {
         Self {
-            few: few.filter(|&t| t != self.other),
+            few: few.filter(|t| *t != self.other),
             ..self
         }
     }
 
     /// Sets the value for [`PluralCategory::Many`].
-    pub fn with_many_value(self, many: Option<&'a T>) -> Self {
+    pub fn with_many_value(self, many: Option<T>) -> Self {
         Self {
-            many: many.filter(|&t| t != self.other),
+            many: many.filter(|t| *t != self.other),
             ..self
         }
     }
 
     /// Sets the value for explicit 0.
-    pub fn with_explicit_zero_value(self, explicit_zero: Option<&'a T>) -> Self {
+    pub fn with_explicit_zero_value(self, explicit_zero: Option<T>) -> Self {
         Self {
             explicit_zero,
             ..self
         }
     }
 
     /// Sets the value for explicit 1.
-    pub fn with_explicit_one_value(self, explicit_one: Option<&'a T>) -> Self {
+    pub fn with_explicit_one_value(self, explicit_one: Option<T>) -> Self {
         Self {
             explicit_one,
             ..self
         }
     }
-
-    /// The value for [`PluralCategory::Zero`]
-    pub fn zero(&self) -> &'a T {
-        self.zero.unwrap_or(self.other)
-    }
-
-    /// The value for [`PluralCategory::One`]
-    pub fn one(&self) -> &'a T {
-        self.one.unwrap_or(self.other)
-    }
-
-    /// The value for [`PluralCategory::Two`]
-    pub fn two(&self) -> &'a T {
-        self.two.unwrap_or(self.other)
-    }
-
-    /// The value for [`PluralCategory::Few`]
-    pub fn few(&self) -> &'a T {
-        self.few.unwrap_or(self.other)
-    }
-
-    /// The value for [`PluralCategory::Many`]
-    pub fn many(&self) -> &'a T {
-        self.many.unwrap_or(self.other)
-    }
-
-    /// The value for [`PluralCategory::Other`]
-    pub fn other(&self) -> &'a T {
-        self.other
-    }
-
-    /// The value used when the [`PluralOperands`] are exactly 0.
-    pub fn explicit_zero(&self) -> Option<&'a T> {
-        self.explicit_zero
-    }
-
-    /// The value used when the [`PluralOperands`] are exactly 1.
-    pub fn explicit_one(&self) -> Option<&'a T> {
-        self.explicit_one
-    }
 }