diff --git a/utils/preferences/src/dtf.rs b/utils/preferences/src/dtf.rs
deleted file mode 100644
index 3c9bcc11f27..00000000000
--- a/utils/preferences/src/dtf.rs
+++ /dev/null
@@ -1,123 +0,0 @@
-use super::Preferences;
-use icu_datetime::options::preferences::HourCycle;
-use icu_locid::language;
-use icu_locid::subtags::{Language, Region, Script};
-use icu_locid::unicode_ext_key;
-use icu_locid::Locale;
-
-pub struct DateTimeFormat {
-    preferences: ResolvedDTFPreferencesBag,
-}
-
-impl DateTimeFormat {
-    pub fn try_new(preferences: &impl DTFPreferences) -> Self {
-        let defaults = ResolvedDTFPreferencesBag {
-            language: Language::UND,
-            script: None,
-            region: None,
-            hour_cycle: if *preferences.language() == language!("en") {
-                HourCycle::H12
-            } else {
-                HourCycle::H24
-            },
-        };
-        Self {
-            preferences: defaults.resolve(preferences),
-        }
-    }
-
-    pub fn format(&self) -> String {
-        let hour = if self.preferences.hour_cycle == HourCycle::H24 {
-            "15:00"
-        } else {
-            "3:00pm"
-        };
-
-        let date = match self.preferences.language.as_str() {
-            "en" => String::from("05/13/2022"),
-            "fr" => String::from("13/05/2022"),
-            _ => String::from("ISO DATE"),
-        };
-        format!("{date} {hour}")
-    }
-}
-
-pub trait DTFPreferences: Preferences {
-    fn hour_cycle(&self) -> Option<HourCycle> {
-        None
-    }
-}
-
-#[derive(Default)]
-pub struct DTFPreferencesBag {
-    pub language: Option<Language>,
-    pub script: Option<Script>,
-    pub region: Option<Region>,
-    pub hour_cycle: Option<HourCycle>,
-}
-
-pub struct ResolvedDTFPreferencesBag {
-    pub language: Language,
-    pub script: Option<Script>,
-    pub region: Option<Region>,
-    pub hour_cycle: HourCycle,
-}
-
-impl ResolvedDTFPreferencesBag {
-    fn resolve(&self, prefs: &impl DTFPreferences) -> Self {
-        Self {
-            language: *prefs.language(),
-            script: prefs.script().copied(),
-            region: prefs.region().copied(),
-            hour_cycle: prefs.hour_cycle().unwrap_or(self.hour_cycle),
-        }
-    }
-}
-
-impl DTFPreferencesBag {
-    #[allow(clippy::result_unit_err)]
-    pub fn merge_locale(&mut self, locale: &Locale) -> Result<(), ()> {
-        if self.language.is_none() && !locale.id.language.is_empty() {
-            self.language = Some(locale.id.language);
-        };
-        if self.script.is_none() && locale.id.script.is_some() {
-            self.script = locale.id.script;
-        }
-        if self.region.is_none() && locale.id.region.is_some() {
-            self.region = locale.id.region;
-        }
-        if self.hour_cycle.is_none() {
-            if let Some(value) = locale
-                .extensions
-                .unicode
-                .keywords
-                .get(&unicode_ext_key!("hc"))
-            {
-                self.hour_cycle = Some(HourCycle::try_from(value)?);
-            }
-        }
-        Ok(())
-    }
-}
-
-impl Preferences for DTFPreferencesBag {
-    fn language(&self) -> &Language {
-        self.language.as_ref().unwrap_or(&Language::UND)
-    }
-
-    fn script(&self) -> Option<&Script> {
-        self.script.as_ref()
-    }
-
-    fn region(&self) -> Option<&Region> {
-        self.region.as_ref()
-    }
-}
-
-impl DTFPreferences for DTFPreferencesBag {
-    fn hour_cycle(&self) -> Option<HourCycle> {
-        self.hour_cycle
-    }
-}
-
-impl DTFPreferences for Locale {}
diff --git a/utils/preferences/src/lib.rs b/utils/preferences/src/lib.rs
index 11b77cf2a62..90998877159 100644
--- a/utils/preferences/src/lib.rs
+++ b/utils/preferences/src/lib.rs
@@ -1,80 +1,5 @@
-mod dtf;
 mod preferences;
+#[macro_use]
+mod macros;
 
-pub use dtf::{DTFPreferencesBag, DateTimeFormat};
 pub use preferences::Preferences;
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use icu_datetime::options::preferences::HourCycle;
-    use icu_locid::{language, locale, Locale};
-
-    #[test]
-    fn it_works() {
-        {
-            // Default locale, no prefs
-            let loc = locale!("en-US");
-            let dtf = DateTimeFormat::try_new(&loc);
-            assert_eq!(dtf.format().as_str(), "05/13/2022 3:00pm");
-        }
-
-        {
-            // Prefs, no locale
-            let p = DTFPreferencesBag {
-                hour_cycle: Some(HourCycle::H12),
-                ..Default::default()
-            };
-            let dtf = DateTimeFormat::try_new(&p);
-            assert_eq!(dtf.format().as_str(), "ISO DATE 3:00pm");
-        }
-
-        {
-            // Prefs and locale
-            let mut p = DTFPreferencesBag {
-                hour_cycle: Some(HourCycle::H24),
-                ..Default::default()
-            };
-            p.merge_locale(&locale!("fr-CA")).unwrap();
-
-            let dtf = DateTimeFormat::try_new(&p);
-            assert_eq!(dtf.format().as_str(), "13/05/2022 15:00");
-        }
-
-        {
-            // Prefs and locale, override language
-            let mut p = DTFPreferencesBag {
-                language: Some(language!("en")),
-                ..Default::default()
-            };
-            p.merge_locale(&locale!("fr-CA")).unwrap();
-
-            let dtf = DateTimeFormat::try_new(&p);
-            assert_eq!(dtf.format().as_str(), "05/13/2022 3:00pm");
-        }
-
-        {
-            // Prefs and locale, override language and set hour_cycle
-            let mut p = DTFPreferencesBag {
-                language: Some(language!("en")),
-                hour_cycle: Some(HourCycle::H24),
-                ..Default::default()
-            };
-            p.merge_locale(&locale!("fr-CA")).unwrap();
-
-            let dtf = DateTimeFormat::try_new(&p);
-            assert_eq!(dtf.format().as_str(), "05/13/2022 15:00");
-        }
-
-        {
-            let mut p = DTFPreferencesBag {
-                ..Default::default()
-            };
-            let loc: Locale = "fr-CA-u-hc-h12".parse().unwrap();
-            p.merge_locale(&loc).unwrap();
-
-            let dtf = DateTimeFormat::try_new(&p);
-            assert_eq!(dtf.format().as_str(), "13/05/2022 3:00pm");
-        }
-    }
-}
diff --git a/utils/preferences/src/macros.rs b/utils/preferences/src/macros.rs
new file mode 100644
index 00000000000..95b9339c785
--- /dev/null
+++ b/utils/preferences/src/macros.rs
@@ -0,0 +1,136 @@
+#[macro_export]
+macro_rules! preferences {
+    ($trait:ident, $name:ident, $resolved_name:ident, {$($key:ident => $pref:ty, $resolved:ty, $ue:expr),*}) => (
+        pub trait $trait: Preferences {
+            $(
+                fn $key(&self) -> $pref {
+                    None
+                }
+            )*
+        }
+
+        #[derive(Default)]
+        #[non_exhaustive]
+        pub struct $name {
+            pub lid: Option<icu_locid::LanguageIdentifier>,
+            $(
+                pub $key: $pref,
+            )*
+        }
+
+        pub struct $resolved_name {
+            pub lid: icu_locid::LanguageIdentifier,
+
+            $(
+                $key: $resolved,
+            )*
+        }
+
+        impl Preferences for $name {
+            fn language(&self) -> &icu_locid::subtags::Language {
+                self.lid
+                    .as_ref()
+                    .map(|lid| &lid.language)
+                    .unwrap_or(&icu_locid::subtags::Language::UND)
+            }
+
+            fn script(&self) -> Option<&icu_locid::subtags::Script> {
+                self.lid.as_ref().and_then(|lid| lid.script.as_ref())
+            }
+
+            fn region(&self) -> Option<&icu_locid::subtags::Region> {
+                self.lid.as_ref().and_then(|lid| lid.region.as_ref())
+            }
+        }
+
+        impl $trait for Locale {
+            $(
+                fn $key(&self) -> $pref {
+                    let ue = $ue.unwrap();
+                    if let Some(value) = self
+                        .extensions
+                        .unicode
+                        .keywords
+                        .get(&ue)
+                    {
+                        //XXX: This is fallible!
+                        if let Ok(v) = TryInto::try_into(value) {
+                            return Some(v);
+                        }
+                    }
+                    return None;
+                }
+            )*
+        }
+
+        impl $trait for $name {
+            $(
+                fn $key(&self) -> $pref {
+                    self.$key
+                }
+            )*
+        }
+
+        impl $name {
+            #[allow(clippy::result_unit_err)]
+            pub fn merge_locale(&mut self, locale: &Locale) -> Result<(), ()> {
+                if let Some(lid) = &mut self.lid {
+                    if lid.language.is_empty() && !locale.id.language.is_empty() {
+                        lid.language = locale.id.language;
+                    };
+                    if lid.script.is_none() && locale.id.script.is_some() {
+                        lid.script = locale.id.script;
+                    }
+                    if lid.region.is_none() && locale.id.region.is_some() {
+                        lid.region = locale.id.region;
+                    }
+                } else {
+                    self.lid = Some(locale.id.clone());
+                }
+
+                $(
+                    let ue = $ue.unwrap();
+                    if self.$key.is_none() {
+                        if let Some(value) = locale
+                            .extensions
+                            .unicode
+                            .keywords
+                            .get(&ue)
+                        {
+                            self.$key = Some(TryInto::try_into(value)?);
+                        }
+                    }
+                )*
+                Ok(())
+            }
+        }
+
+        impl $resolved_name {
+            fn resolve(&self, prefs: &impl $trait) -> Self {
+                let mut language = prefs.language();
+                if language.is_empty() {
+                    language = &self.lid.language;
+                }
+                let mut script = prefs.script();
+                if script.is_none() {
+                    script = self.lid.script.as_ref();
+                }
+                let mut region = prefs.region();
+                if region.is_none() {
+                    region = self.lid.region.as_ref();
+                }
+                Self {
+                    lid: icu_locid::LanguageIdentifier {
+                        language: *language,
+                        script: script.copied(),
+                        region: region.copied(),
+                        variants: icu_locid::subtags::Variants::new()
+                    },
+                    $(
+                        $key: prefs.$key().unwrap_or(self.$key),
+                    )*
+                }
+            }
+        }
+    )
+}
diff --git a/utils/preferences/tests/dtf.rs b/utils/preferences/tests/dtf.rs
index 1238008cf74..1a828d6f54a 100644
--- a/utils/preferences/tests/dtf.rs
+++ b/utils/preferences/tests/dtf.rs
@@ -1,85 +1,107 @@
-// use icu_datetime::options::preferences::HourCycle;
-// use icu_locid::{unicode_ext_key, Locale};
-// use icu_preferences::preferences;
-//
-// #[derive(Clone, Copy)]
-// enum Calendar {
-//     Gregory,
-// }
-//
-// impl TryFrom<&icu_locid::extensions::unicode::Value> for Calendar {
-//     type Error = ();
-//
-//     fn try_from(_i: &icu_locid::extensions::unicode::Value) -> Result<Self, Self::Error> {
-//         Ok(Calendar::Gregory)
-//     }
-// }
-//
-// preferences!(
-//     DTFPreferences,
-//     ResolvedDTFPreferences,
-//     {
-//         hour_cycle => Option<HourCycle>, HourCycle, Some(unicode_ext_key!("hc")),
-//         calendar => Option<Calendar>, Calendar, Some(unicode_ext_key!("ca"))
-//     }
-// );
-//
-// struct DateTimeFormat {
-//     prefs: ResolvedDTFPreferences,
-// }
-//
-// impl DateTimeFormat {
-//     pub fn new(locale: &Locale, prefs: &DTFPreferences) -> Self {
-//         let en_us_defaults = ResolvedDTFPreferences {
-//             hour_cycle: HourCycle::H12,
-//             calendar: Calendar::Gregory,
-//         };
-//
-//         let prefs = ResolvedDTFPreferences::try_from((prefs, locale, &en_us_defaults)).unwrap();
-//
-//         Self { prefs }
-//     }
-//
-//     pub fn format(&self, _input: u64) -> String {
-//         match self.prefs.hour_cycle {
-//             HourCycle::H11 => "00:13 am",
-//             HourCycle::H12 => "12:13 am",
-//             HourCycle::H23 => "00:13",
-//             HourCycle::H24 => "24:13",
-//         }
-//         .to_string()
-//     }
-// }
-//
-// #[test]
-// fn dtf_default() {
-//     let loc: Locale = "en-US".parse().unwrap();
-//     let prefs = DTFPreferences {
-//         hour_cycle: None,
-//         ..Default::default()
-//     };
-//     let dtf = DateTimeFormat::new(&loc, &prefs);
-//     assert_eq!(dtf.format(0), String::from("12:13 am"));
-// }
-//
-// #[test]
-// fn dtf_uext() {
-//     let loc: Locale = "en-US-u-hc-h11".parse().unwrap();
-//     let prefs = DTFPreferences {
-//         hour_cycle: None,
-//         ..Default::default()
-//     };
-//     let dtf = DateTimeFormat::new(&loc, &prefs);
-//     assert_eq!(dtf.format(0), String::from("00:13 am"));
-// }
-//
-// #[test]
-// fn dtf_prefs() {
-//     let loc: Locale = "en-US-u-hc-h11".parse().unwrap();
-//     let prefs = DTFPreferences {
-//         hour_cycle: Some(HourCycle::H24),
-//         ..Default::default()
-//     };
-//     let dtf = DateTimeFormat::new(&loc, &prefs);
-//     assert_eq!(dtf.format(0), String::from("24:13"));
-// }
+use icu_datetime::options::preferences::HourCycle;
+use icu_locid::{langid, language, locale, unicode_ext_key, unicode_ext_value, Locale};
+use icu_preferences::{preferences, Preferences};
+
+#[derive(Clone, Copy)]
+pub enum Calendar {
+    Gregory,
+    Buddhist,
+}
+
+impl TryFrom<&icu_locid::extensions::unicode::Value> for Calendar {
+    type Error = ();
+
+    fn try_from(i: &icu_locid::extensions::unicode::Value) -> Result<Self, Self::Error> {
+        match i {
+            _ if *i == unicode_ext_value!("gregory") => Ok(Calendar::Gregory),
+            _ if *i == unicode_ext_value!("buddhist") => Ok(Calendar::Buddhist),
+            _ => Err(()),
+        }
+    }
+}
+
+preferences!(
+    DTFPreferences,
+    DTFPreferencesBag,
+    ResolvedDTFPreferencesBag,
+    {
+        hour_cycle => Option<HourCycle>, HourCycle, Some(unicode_ext_key!("hc")),
+        calendar => Option<Calendar>, Calendar, Some(unicode_ext_key!("ca"))
+    }
+);
+
+fn get_defaults(preferences: &impl DTFPreferences) -> ResolvedDTFPreferencesBag {
+    let defaults = ResolvedDTFPreferencesBag {
+        lid: langid!("und"),
+
+        hour_cycle: if *preferences.language() == language!("en") {
+            HourCycle::H12
+        } else {
+            HourCycle::H24
+        },
+        calendar: Calendar::Gregory,
+    };
+    defaults
+}
+
+struct DateTimeFormat {
+    prefs: ResolvedDTFPreferencesBag,
+}
+
+impl DateTimeFormat {
+    pub fn new(prefs: &impl DTFPreferences) -> Self {
+        let defaults = get_defaults(prefs);
+
+        let prefs = defaults.resolve(prefs);
+
+        Self { prefs }
+    }
+
+    pub fn format(&self, _input: u64) -> String {
+        match self.prefs.hour_cycle {
+            HourCycle::H11 => "00:13 am",
+            HourCycle::H12 => "12:13 am",
+            HourCycle::H23 => "00:13",
+            HourCycle::H24 => "24:13",
+        }
+        .to_string()
+    }
+}
+
+#[test]
+fn dtf_default() {
+    let loc = locale!("en-US");
+    let dtf = DateTimeFormat::new(&loc);
+    assert_eq!(dtf.format(0), String::from("12:13 am"));
+}
+
+#[test]
+fn dtf_uext() {
+    let loc: Locale = "en-US-u-hc-h11".parse().unwrap();
+    let dtf = DateTimeFormat::new(&loc);
+    assert_eq!(dtf.format(0), String::from("00:13 am"));
+}
+
+#[test]
+fn dtf_prefs() {
+    let loc: Locale = "en-US-u-hc-h11".parse().unwrap();
+    let mut prefs = DTFPreferencesBag {
+        hour_cycle: Some(HourCycle::H24),
+        ..Default::default()
+    };
+    prefs.merge_locale(&loc).unwrap();
+    let dtf = DateTimeFormat::new(&prefs);
+    assert_eq!(dtf.format(0), String::from("24:13"));
+}
+
+#[test]
+fn dtf_prefs_with_ca() {
+    let loc: Locale = "en-US-u-hc-h11-ca-buddhist".parse().unwrap();
+    let mut prefs = DTFPreferencesBag {
+        hour_cycle: Some(HourCycle::H24),
+        ..Default::default()
+    };
+    prefs.merge_locale(&loc).unwrap();
+    let dtf = DateTimeFormat::new(&prefs);
+    assert_eq!(dtf.format(0), String::from("24:13"));
+}