Use Pattern more directly (#5531)

* Removed the `Store` generic from `Pattern`. It now always uses the
unsized `PatternBackend::Store`. Instead of using `Pattern<B, String>`
for the owned version, it's now `Box<Pattern<B>>`
* Implemented `ToOwned` for `Pattern` so that we can use
`Cow<Pattern<B>>`. The owned type is `Box<Pattern<B>>`
* Replaced the `FromStr` implementation by `try_from_str`, which returns
`Box<Self>`
* Together these changes completely remove the need of downstream users
to fuss around with the store.

Author: robertbastian

components/experimental/Cargo.toml

@@ -38,7 +38,7 @@ icu_properties = { workspace = true }
 databake = { workspace = true, optional = true, features = ["derive"] }
 either = { workspace = true }
 fixed_decimal = { workspace = true }
-icu_pattern = { workspace = true , features = ["alloc", "yoke", "zerofrom"]}
+icu_pattern = { workspace = true , features = ["alloc", "yoke", "zerovec"]}
 litemap = { workspace = true }
 tinystr = { workspace = true, features = ["alloc", "zerovec"] }
 potential_utf = { workspace = true, features = ["zerovec"] }

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

@@ -14,6 +14,8 @@ use icu_provider::prelude::*;
 use tinystr::UnvalidatedTinyAsciiStr;
 use zerovec::{VarZeroVec, ZeroMap};
 
+#[cfg(feature = "serde")]
+use icu_pattern::DoublePlaceholder;
 use icu_pattern::DoublePlaceholderPattern;
 
 #[cfg(feature = "compiled_data")]
@@ -50,15 +52,27 @@ pub struct CurrencyEssentialsV1<'data> {
     /// Represents the standard pattern.
     /// NOTE: place holder 0 is the place of the currency value.
     ///       place holder 1 is the place of the currency sign `¤`.
-    #[cfg_attr(feature = "serde", serde(borrow))]
-    pub standard_pattern: Option<DoublePlaceholderPattern<Cow<'data, str>>>,
+    #[cfg_attr(
+        feature = "serde",
+        serde(
+            borrow,
+            deserialize_with = "icu_pattern::deserialize_option_borrowed_cow::<DoublePlaceholder, _>"
+        )
+    )]
+    pub standard_pattern: Option<Cow<'data, DoublePlaceholderPattern>>,
 
     // TODO(#4677): Implement the pattern to accept the signed negative and signed positive patterns.
     /// Represents the standard alpha_next_to_number pattern.
     /// NOTE: place holder 0 is the place of the currency value.
     ///       place holder 1 is the place of the currency sign `¤`.
-    #[cfg_attr(feature = "serde", serde(borrow))]
-    pub standard_alpha_next_to_number_pattern: Option<DoublePlaceholderPattern<Cow<'data, str>>>,
+    #[cfg_attr(
+        feature = "serde",
+        serde(
+            borrow,
+            deserialize_with = "icu_pattern::deserialize_option_borrowed_cow::<DoublePlaceholder, _>"
+        )
+    )]
+    pub standard_alpha_next_to_number_pattern: Option<Cow<'data, DoublePlaceholderPattern>>,
 
     /// Contains all the place holders.
     #[cfg_attr(feature = "serde", serde(borrow))]

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

@@ -9,8 +9,8 @@
 //!
 //! Read more about data providers: [`icu_provider`]
 
-use crate::relativetime::provider::PluralPatterns;
-use icu_pattern::DoublePlaceholder;
+use icu_pattern::DoublePlaceholderPattern;
+use icu_plurals::provider::PluralElementsPackedCow;
 use icu_provider::prelude::*;
 
 /// Currency Extended V1 data struct.
@@ -23,5 +23,5 @@ use icu_provider::prelude::*;
 pub struct CurrencyPatternsDataV1<'data> {
     /// Contains the unit patterns for a currency based on plural rules.
     #[cfg_attr(feature = "serde", serde(borrow))]
-    pub patterns: PluralPatterns<'data, DoublePlaceholder>,
+    pub patterns: PluralElementsPackedCow<'data, DoublePlaceholderPattern>,
 }

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

@@ -13,6 +13,9 @@ use alloc::borrow::Cow;
 use icu_pattern::{DoublePlaceholderPattern, SinglePlaceholderPattern};
 use icu_provider::prelude::*;
 
+#[cfg(feature = "serde")]
+use icu_pattern::{DoublePlaceholder, SinglePlaceholder};
+
 #[cfg(feature = "compiled_data")]
 /// Baked data
 ///
@@ -34,15 +37,27 @@ pub use crate::provider::Baked;
 /// <https://www.unicode.org/reports/tr35/tr35-numbers.html#approximate-number-formatting>
 /// <https://www.unicode.org/reports/tr35/tr35-numbers.html#explicit-plus-signs>
 pub struct PercentEssentialsV1<'data> {
-    #[cfg_attr(feature = "serde", serde(borrow))]
+    #[cfg_attr(
+        feature = "serde",
+        serde(
+            borrow,
+            deserialize_with = "icu_pattern::deserialize_borrowed_cow::<DoublePlaceholder, _>"
+        )
+    )]
     /// Represents the standard pattern for signed percents.
     /// NOTE: place holder 0 is the place of the percent value.
     ///       place holder 1 is the place of the plus, minus, or approximate signs.
-    pub signed_pattern: DoublePlaceholderPattern<Cow<'data, str>>,
+    pub signed_pattern: Cow<'data, DoublePlaceholderPattern>,
 
-    #[cfg_attr(feature = "serde", serde(borrow))]
+    #[cfg_attr(
+        feature = "serde",
+        serde(
+            borrow,
+            deserialize_with = "icu_pattern::deserialize_borrowed_cow::<SinglePlaceholder, _>"
+        )
+    )]
     /// Represents the standard pattern for unsigned percents.
-    pub unsigned_pattern: SinglePlaceholderPattern<Cow<'data, str>>,
+    pub unsigned_pattern: Cow<'data, SinglePlaceholderPattern>,
 
     #[cfg_attr(feature = "serde", serde(borrow))]
     /// The localize approximate sign.

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

@@ -9,8 +9,8 @@
 //!
 //! Read more about data providers: [`icu_provider`]
 
-use crate::relativetime::provider::PluralPatterns;
-use icu_pattern::SinglePlaceholder;
+use icu_pattern::SinglePlaceholderPattern;
+use icu_plurals::provider::PluralElementsPackedCow;
 use icu_provider::prelude::*;
 
 #[icu_provider::data_struct(marker(
@@ -26,7 +26,7 @@ pub struct UnitsDisplayNameV1<'data> {
     // TODO: use `MeasureUnit` for the units key instead of strings.
     /// Contains the long width patterns for the units.
     #[cfg_attr(feature = "serde", serde(borrow))]
-    pub patterns: PluralPatterns<'data, SinglePlaceholder>,
+    pub patterns: PluralElementsPackedCow<'data, SinglePlaceholderPattern>,
 }
 
 impl<'data> UnitsDisplayNameV1<'data> {
@@ -37,17 +37,14 @@ impl<'data> UnitsDisplayNameV1<'data> {
     /// The bytes must represent a valid [`icu_plurals::provider::PluralElementsPackedULE`]
     pub const unsafe fn from_byte_slice_unchecked(bytes: &'data [u8]) -> Self {
         Self {
-            patterns: PluralPatterns {
-                strings: icu_plurals::provider::PluralElementsPackedCow {
-                    elements: alloc::borrow::Cow::Borrowed(
-                        // Safety: this function's safety invariant guarantees that the bytes
-                        // represent a valid `PluralElementsPackedULE`
-                        icu_plurals::provider::PluralElementsPackedULE::from_byte_slice_unchecked(
-                            bytes,
-                        ),
+            patterns: icu_plurals::provider::PluralElementsPackedCow {
+                elements: alloc::borrow::Cow::Borrowed(
+                    // Safety: this function's safety invariant guarantees that the bytes
+                    // represent a valid `PluralElementsPackedULE`
+                    icu_plurals::provider::PluralElementsPackedULE::from_byte_slice_unchecked(
+                        bytes,
                     ),
-                },
-                _phantom: core::marker::PhantomData,
+                ),
             },
         }
     }
@@ -58,7 +55,7 @@ impl databake::Bake for UnitsDisplayNameV1<'_> {
     fn bake(&self, ctx: &databake::CrateEnv) -> databake::TokenStream {
         use zerovec::ule::VarULE;
         ctx.insert("icu_experimental::dimension::provider::units");
-        let bytes = self.patterns.strings.elements.as_byte_slice().bake(ctx);
+        let bytes = self.patterns.elements.as_byte_slice().bake(ctx);
         // Safety: The bytes are returned by `PluralElementsPackedULE::as_byte_slice`.
         databake::quote! { unsafe {
             icu_experimental::dimension::provider::units::UnitsDisplayNameV1::from_byte_slice_unchecked(#bytes)

components/experimental/src/personnames/specifications/derive_missing_initials.rs

@@ -18,9 +18,11 @@ pub fn derive_missing_initials(
     initial_pattern_str: &str,
     initial_sequence_pattern_str: &str,
 ) -> String {
-    let initial_pattern: SinglePlaceholderPattern<_> = initial_pattern_str.parse().unwrap();
-    let initial_sequence_pattern: DoublePlaceholderPattern<_> =
-        initial_sequence_pattern_str.parse().unwrap();
+    let initial_pattern =
+        SinglePlaceholderPattern::try_from_str(initial_pattern_str, Default::default()).unwrap();
+    let initial_sequence_pattern =
+        DoublePlaceholderPattern::try_from_str(initial_sequence_pattern_str, Default::default())
+            .unwrap();
 
     if person_name.has_name_field(requested_field) {
         return String::from(person_name.get(requested_field));

components/experimental/src/personnames/specifications/pattern_regex_selector.rs

@@ -209,7 +209,7 @@ impl FromStr for NameField {
 pub fn to_person_name_pattern(value: &str) -> Result<PersonNamePattern, PersonNamesFormatterError> {
     let mut name_fields_map: Vec<(NameField, Cow<str>)> = Vec::new();
 
-    let parsed_pattern = MultiNamedPlaceholderPattern::from_str(value)?;
+    let parsed_pattern = MultiNamedPlaceholderPattern::try_from_str(value, Default::default())?;
 
     let mut current_name_field = None;
     let mut current_literal = None;

components/experimental/src/relativetime/provider.rs

@@ -9,14 +9,10 @@
 //!
 //! Read more about data providers: [`icu_provider`]
 
-use alloc::borrow::Cow;
-use core::marker::PhantomData;
 #[cfg(feature = "datagen")]
-use core::{fmt::Debug, str::FromStr};
-use icu_pattern::{Pattern, PatternBackend, SinglePlaceholder};
-#[cfg(feature = "datagen")]
-use icu_plurals::PluralElements;
-use icu_plurals::{PluralCategory, PluralOperands, PluralRules};
+use core::fmt::Debug;
+use icu_pattern::SinglePlaceholderPattern;
+use icu_plurals::provider::PluralElementsPackedCow;
 use icu_provider::prelude::*;
 use zerovec::ZeroMap;
 
@@ -71,127 +67,10 @@ pub struct RelativeTimePatternDataV1<'data> {
     pub relatives: ZeroMap<'data, i8, str>,
     /// How to display times in the past.
     #[cfg_attr(feature = "serde", serde(borrow))]
-    pub past: PluralPatterns<'data, SinglePlaceholder>,
+    pub past: PluralElementsPackedCow<'data, SinglePlaceholderPattern>,
     /// How to display times in the future.
     #[cfg_attr(feature = "serde", serde(borrow))]
-    pub future: PluralPatterns<'data, SinglePlaceholder>,
-}
-
-#[derive(Debug)]
-#[zerovec::make_varule(PluralCategoryStrULE)]
-#[zerovec::skip_derive(Ord)]
-#[zerovec::derive(Debug)]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Deserialize),
-    zerovec::derive(Deserialize)
-)]
-#[cfg_attr(
-    feature = "datagen",
-    derive(serde::Serialize),
-    zerovec::derive(Serialize)
-)]
-/// A tuple of [`PluralCategory`] and [`str`].
-pub struct PluralCategoryStr<'data>(pub PluralCategory, pub Cow<'data, str>);
-
-/// Display specification for relative times, split over potential plural patterns.
-#[derive(Debug, PartialEq, yoke::Yokeable, zerofrom::ZeroFrom)]
-#[cfg_attr(feature = "serde", derive(serde::Deserialize))]
-#[cfg_attr(feature = "datagen", derive(serde::Serialize, databake::Bake))]
-#[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))]
-    #[doc(hidden)] // databake only
-    pub strings: icu_plurals::provider::PluralElementsPackedCow<'data, str>,
-    #[cfg_attr(feature = "serde", serde(skip))]
-    #[doc(hidden)] // databake only
-    pub _phantom: PhantomData<B>,
-}
-
-impl<'data, B> Clone for PluralPatterns<'data, B> {
-    fn clone(&self) -> Self {
-        Self {
-            strings: self.strings.clone(),
-            _phantom: PhantomData,
-        }
-    }
-}
-
-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))
-    }
-}
-
-#[cfg(feature = "datagen")]
-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<&'data str>) -> Result<Self, Self::Error> {
-        let make_pattern = |s: &&str| Pattern::<B, String>::from_str(s).map(|p| p.take_store());
-
-        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(),
-            _phantom: PhantomData,
-        })
-    }
+    pub future: PluralElementsPackedCow<'data, SinglePlaceholderPattern>,
 }
 
 pub(crate) struct ErasedRelativeTimeFormatV1Marker;