diff --git a/components/calendar/src/duration.rs b/components/calendar/src/duration.rs
index 01b8fe4035f..bb06822bf45 100644
--- a/components/calendar/src/duration.rs
+++ b/components/calendar/src/duration.rs
@@ -126,7 +126,7 @@ impl<C: Calendar + ?Sized> DateDuration<C> {
     /// ```rust
     /// # use icu::calendar::*;
     /// // two years, three months, and five days
-    /// let duration: DateDuration<Iso> = DateDuration::new(2, 3, 0, 5);
+    /// let duration = DateDuration::<Iso>::new(2, 3, 0, 5);
     /// ```
     pub fn new(years: i32, months: i32, weeks: i32, days: i32) -> Self {
         DateDuration {
diff --git a/components/calendar/src/provider.rs b/components/calendar/src/provider.rs
index 34c336de29f..505a699b438 100644
--- a/components/calendar/src/provider.rs
+++ b/components/calendar/src/provider.rs
@@ -273,9 +273,12 @@ impl serde::Serialize for WeekdaySet {
         S: serde::Serializer,
     {
         if serializer.is_human_readable() {
-            crate::week_of::WeekdaySetIterator::new(IsoWeekday::Monday, *self)
-                .collect::<alloc::vec::Vec<_>>()
-                .serialize(serializer)
+            use serde::ser::SerializeSeq;
+            let mut seq = serializer.serialize_seq(None)?;
+            for day in crate::week_of::WeekdaySetIterator::new(IsoWeekday::Monday, *self) {
+                seq.serialize_element(&day)?;
+            }
+            seq.end()
         } else {
             self.0.serialize(serializer)
         }
diff --git a/components/calendar/src/week_of.rs b/components/calendar/src/week_of.rs
index c3ec899b2b7..9abaae2c199 100644
--- a/components/calendar/src/week_of.rs
+++ b/components/calendar/src/week_of.rs
@@ -714,34 +714,38 @@ fn test_weekend() {
     use icu_locid::locale;
 
     assert_eq!(
-        WeekCalculator::try_new(&locale!("und").into())
-            .unwrap()
-            .weekend()
-            .collect::<Vec<_>>(),
+        Vec::from_iter(
+            WeekCalculator::try_new(&locale!("und").into())
+                .unwrap()
+                .weekend()
+        ),
         vec![IsoWeekday::Saturday, IsoWeekday::Sunday],
     );
 
     assert_eq!(
-        WeekCalculator::try_new(&locale!("und-FR").into())
-            .unwrap()
-            .weekend()
-            .collect::<Vec<_>>(),
+        Vec::from_iter(
+            WeekCalculator::try_new(&locale!("und-FR").into())
+                .unwrap()
+                .weekend()
+        ),
         vec![IsoWeekday::Saturday, IsoWeekday::Sunday],
     );
 
     assert_eq!(
-        WeekCalculator::try_new(&locale!("und-IQ").into())
-            .unwrap()
-            .weekend()
-            .collect::<Vec<_>>(),
+        Vec::from_iter(
+            WeekCalculator::try_new(&locale!("und-IQ").into())
+                .unwrap()
+                .weekend()
+        ),
         vec![IsoWeekday::Saturday, IsoWeekday::Friday],
     );
 
     assert_eq!(
-        WeekCalculator::try_new(&locale!("und-IR").into())
-            .unwrap()
-            .weekend()
-            .collect::<Vec<_>>(),
+        Vec::from_iter(
+            WeekCalculator::try_new(&locale!("und-IR").into())
+                .unwrap()
+                .weekend()
+        ),
         vec![IsoWeekday::Friday],
     );
 }
@@ -752,11 +756,11 @@ fn test_weekdays_iter() {
 
     // Weekend ends one day before week starts
     let default_weekend = WeekdaySetIterator::new(Monday, WeekdaySet::new(&[Saturday, Sunday]));
-    assert_eq!(vec![Saturday, Sunday], default_weekend.collect::<Vec<_>>());
+    assert_eq!(vec![Saturday, Sunday], Vec::from_iter(default_weekend));
 
     // Non-contiguous weekend
     let fri_sun_weekend = WeekdaySetIterator::new(Monday, WeekdaySet::new(&[Friday, Sunday]));
-    assert_eq!(vec![Friday, Sunday], fri_sun_weekend.collect::<Vec<_>>());
+    assert_eq!(vec![Friday, Sunday], Vec::from_iter(fri_sun_weekend));
 
     let multiple_contiguous_days = WeekdaySetIterator::new(
         Monday,
@@ -769,7 +773,7 @@ fn test_weekdays_iter() {
     );
     assert_eq!(
         vec![Tuesday, Wednesday, Thursday, Friday],
-        multiple_contiguous_days.collect::<Vec<_>>()
+        Vec::from_iter(multiple_contiguous_days)
     );
 
     // Non-contiguous days and iterator yielding elements based off first_weekday
@@ -784,6 +788,6 @@ fn test_weekdays_iter() {
     );
     assert_eq!(
         vec![Thursday, Friday, Sunday, Tuesday],
-        multiple_non_contiguous_days.collect::<Vec<_>>()
+        Vec::from_iter(multiple_non_contiguous_days)
     );
 }
diff --git a/components/casemap/src/provider/mod.rs b/components/casemap/src/provider/mod.rs
index 1de45d285ae..8e86237d57d 100644
--- a/components/casemap/src/provider/mod.rs
+++ b/components/casemap/src/provider/mod.rs
@@ -123,14 +123,11 @@ impl<'data> CaseMapV1<'data> {
         let trie_index = ZeroVec::alloc_from_slice(trie_index);
 
         #[allow(clippy::unwrap_used)] // datagen only
-        let trie_data = trie_data
-            .iter()
-            .map(|&i| {
-                CaseMapData::try_from_icu_integer(i)
-                    .unwrap()
-                    .with_updated_exception(&idx_map)
-            })
-            .collect::<ZeroVec<_>>();
+        let trie_data = ZeroVec::from_iter(trie_data.iter().map(|&i| {
+            CaseMapData::try_from_icu_integer(i)
+                .unwrap()
+                .with_updated_exception(&idx_map)
+        }));
 
         let trie = CodePointTrie::try_new(trie_header, trie_index, trie_data)
             .map_err(|_| DataError::custom("Casemapping data does not form valid trie"))?;
diff --git a/components/casemap/src/titlecase.rs b/components/casemap/src/titlecase.rs
index b532c770aa9..8d0ca060b7a 100644
--- a/components/casemap/src/titlecase.rs
+++ b/components/casemap/src/titlecase.rs
@@ -26,8 +26,8 @@ use writeable::Writeable;
 /// let cm = TitlecaseMapper::new();
 /// let root = langid!("und");
 ///
-/// let default_options = Default::default();
-/// let mut preserve_case: TitlecaseOptions = Default::default();
+/// let default_options = TitlecaseOptions::default();
+/// let mut preserve_case = TitlecaseOptions::default();
 /// preserve_case.trailing_case = TrailingCase::Unchanged;
 ///
 /// // Exhibits trailing case when set:
@@ -72,8 +72,8 @@ pub enum TrailingCase {
 /// let root = langid!("und");
 ///
 /// let default_options = Default::default(); // head adjustment set to Auto
-/// let mut no_adjust: TitlecaseOptions = Default::default();
-/// let mut adjust_to_cased: TitlecaseOptions = Default::default();
+/// let mut no_adjust = TitlecaseOptions::default();
+/// let mut adjust_to_cased = TitlecaseOptions::default();
 /// no_adjust.leading_adjustment = LeadingAdjustment::None;
 /// adjust_to_cased.leading_adjustment = LeadingAdjustment::ToCased;
 ///
@@ -383,8 +383,8 @@ impl<CM: AsRef<CaseMapper>> TitlecaseMapper<CM> {
     /// let cm = TitlecaseMapper::new();
     /// let root = langid!("und");
     ///
-    /// let default_options = Default::default();
-    /// let mut no_adjust: TitlecaseOptions = Default::default();
+    /// let default_options = TitlecaseOptions::default();
+    /// let mut no_adjust = TitlecaseOptions::default();
     /// no_adjust.leading_adjustment = LeadingAdjustment::None;
     ///
     /// // Exhibits leading adjustment when set:
@@ -423,8 +423,8 @@ impl<CM: AsRef<CaseMapper>> TitlecaseMapper<CM> {
     /// let cm = TitlecaseMapper::new();
     /// let root = langid!("und");
     ///
-    /// let default_options = Default::default();
-    /// let mut preserve_case: TitlecaseOptions = Default::default();
+    /// let default_options = TitlecaseOptions::default();
+    /// let mut preserve_case = TitlecaseOptions::default();
     /// preserve_case.trailing_case = TrailingCase::Unchanged;
     ///
     /// // Exhibits trailing case when set:
diff --git a/components/collator/README.md b/components/collator/README.md
index 57d33a7fb07..cbf9c7a148c 100644
--- a/components/collator/README.md
+++ b/components/collator/README.md
@@ -26,7 +26,7 @@ use icu::locid::locale;
 let locale_es = locale!("es-u-co-trad").into();
 let mut options = CollatorOptions::new();
 options.strength = Some(Strength::Primary);
-let collator_es: Collator = Collator::try_new(&locale_es, options).unwrap();
+let collator_es = Collator::try_new(&locale_es, options).unwrap();
 
 // "pollo" > "polvo" in traditional Spanish
 assert_eq!(collator_es.compare("pollo", "polvo"), Ordering::Greater);
@@ -34,7 +34,7 @@ assert_eq!(collator_es.compare("pollo", "polvo"), Ordering::Greater);
 let locale_en = locale!("en").into();
 let mut options = CollatorOptions::new();
 options.strength = Some(Strength::Primary);
-let collator_en: Collator = Collator::try_new(&locale_en, options).unwrap();
+let collator_en = Collator::try_new(&locale_en, options).unwrap();
 
 // "pollo" < "polvo" according to English rules
 assert_eq!(collator_en.compare("pollo", "polvo"), Ordering::Less);
@@ -234,7 +234,7 @@ use icu::collator::*;
 
 let mut options_num_off = CollatorOptions::new();
 options_num_off.numeric = Some(Numeric::Off);
-let collator_num_off: Collator =
+let collator_num_off =
     Collator::try_new(&Default::default(), options_num_off).unwrap();
 assert_eq!(collator_num_off.compare("a10b", "a2b"), Ordering::Less);
 
@@ -242,7 +242,7 @@ assert_eq!(collator_num_off.compare("a10b", "a2b"), Ordering::Less);
 
 let mut options_num_on = CollatorOptions::new();
 options_num_on.numeric = Some(Numeric::On);
-let collator_num_on: Collator =
+let collator_num_on =
     Collator::try_new(&Default::default(), options_num_on).unwrap();
 assert_eq!(collator_num_on.compare("a10b", "a2b"), Ordering::Greater);
 ```
diff --git a/components/collator/benches/bench.rs b/components/collator/benches/bench.rs
index 6e0d1f7a861..f2011ff2b34 100644
--- a/components/collator/benches/bench.rs
+++ b/components/collator/benches/bench.rs
@@ -17,69 +17,77 @@ fn to_data_locale(locale_str: &str) -> DataLocale {
 
 pub fn collator_with_locale(criterion: &mut Criterion) {
     // Load file content in reverse order vector.
-    let content_latin: (&str, Vec<&str>) = (
+    let content_latin = (
         "TestNames_Latin",
-        include_str!("data/TestNames_Latin.txt")
-            .lines()
-            .filter(|&s| !s.starts_with('#'))
-            .rev()
-            .collect::<Vec<&str>>(),
+        Vec::from_iter(
+            include_str!("data/TestNames_Latin.txt")
+                .lines()
+                .filter(|&s| !s.starts_with('#'))
+                .rev(),
+        ),
     );
-    let content_asian: (&str, Vec<&str>) = (
+    let content_asian = (
         "TestNames_Asian",
-        include_str!("data/TestNames_Asian.txt")
-            .lines()
-            .filter(|&s| !s.starts_with('#'))
-            .rev()
-            .collect(),
+        Vec::from_iter(
+            include_str!("data/TestNames_Asian.txt")
+                .lines()
+                .filter(|&s| !s.starts_with('#'))
+                .rev(),
+        ),
     );
-    let content_russian: (&str, Vec<&str>) = (
+    let content_russian = (
         "TestNames_Russian",
-        include_str!("data/TestNames_Russian.txt")
-            .lines()
-            .filter(|&s| !s.starts_with('#'))
-            .rev()
-            .collect(),
+        Vec::from_iter(
+            include_str!("data/TestNames_Russian.txt")
+                .lines()
+                .filter(|&s| !s.starts_with('#'))
+                .rev(),
+        ),
     );
-    let content_chinese: (&str, Vec<&str>) = (
+    let content_chinese = (
         "TestNames_Chinese",
-        include_str!("data/TestNames_Chinese.txt")
-            .lines()
-            .filter(|&s| !s.starts_with('#'))
-            .rev()
-            .collect(),
+        Vec::from_iter(
+            include_str!("data/TestNames_Chinese.txt")
+                .lines()
+                .filter(|&s| !s.starts_with('#'))
+                .rev(),
+        ),
     );
-    let content_jp_h: (&str, Vec<&str>) = (
+    let content_jp_h = (
         "TestNames_Japanese_h",
-        include_str!("data/TestNames_Japanese_h.txt")
-            .lines()
-            .filter(|&s| !s.starts_with('#'))
-            .rev()
-            .collect::<Vec<&str>>(),
+        Vec::from_iter(
+            include_str!("data/TestNames_Japanese_h.txt")
+                .lines()
+                .filter(|&s| !s.starts_with('#'))
+                .rev(),
+        ),
     );
-    let content_jp_k: (&str, Vec<&str>) = (
+    let content_jp_k = (
         "TestNames_Japanese_k",
-        include_str!("data/TestNames_Japanese_k.txt")
-            .lines()
-            .filter(|&s| !s.starts_with('#'))
-            .rev()
-            .collect::<Vec<&str>>(),
+        Vec::from_iter(
+            include_str!("data/TestNames_Japanese_k.txt")
+                .lines()
+                .filter(|&s| !s.starts_with('#'))
+                .rev(),
+        ),
     );
-    let content_korean: (&str, Vec<&str>) = (
+    let content_korean = (
         "TestNames_Korean",
-        include_str!("data/TestNames_Korean.txt")
-            .lines()
-            .filter(|&s| !s.starts_with('#'))
-            .rev()
-            .collect::<Vec<&str>>(),
+        Vec::from_iter(
+            include_str!("data/TestNames_Korean.txt")
+                .lines()
+                .filter(|&s| !s.starts_with('#'))
+                .rev(),
+        ),
     );
-    let content_thai: (&str, Vec<&str>) = (
+    let content_thai = (
         "TestNames_Thai",
-        include_str!("data/TestNames_Thai.txt")
-            .lines()
-            .filter(|&s| !s.starts_with('#'))
-            .rev()
-            .collect::<Vec<&str>>(),
+        Vec::from_iter(
+            include_str!("data/TestNames_Thai.txt")
+                .lines()
+                .filter(|&s| !s.starts_with('#'))
+                .rev(),
+        ),
     );
 
     // hsivonen@ : All five strengths are benched.
diff --git a/components/collator/src/lib.rs b/components/collator/src/lib.rs
index 01371be2504..d143c4f67e4 100644
--- a/components/collator/src/lib.rs
+++ b/components/collator/src/lib.rs
@@ -46,7 +46,7 @@
 //! let locale_es = locale!("es-u-co-trad").into();
 //! let mut options = CollatorOptions::new();
 //! options.strength = Some(Strength::Primary);
-//! let collator_es: Collator = Collator::try_new(&locale_es, options).unwrap();
+//! let collator_es = Collator::try_new(&locale_es, options).unwrap();
 //!
 //! // "pollo" > "polvo" in traditional Spanish
 //! assert_eq!(collator_es.compare("pollo", "polvo"), Ordering::Greater);
@@ -54,7 +54,7 @@
 //! let locale_en = locale!("en").into();
 //! let mut options = CollatorOptions::new();
 //! options.strength = Some(Strength::Primary);
-//! let collator_en: Collator = Collator::try_new(&locale_en, options).unwrap();
+//! let collator_en = Collator::try_new(&locale_en, options).unwrap();
 //!
 //! // "pollo" < "polvo" according to English rules
 //! assert_eq!(collator_en.compare("pollo", "polvo"), Ordering::Less);
@@ -254,7 +254,7 @@
 //!
 //! let mut options_num_off = CollatorOptions::new();
 //! options_num_off.numeric = Some(Numeric::Off);
-//! let collator_num_off: Collator =
+//! let collator_num_off =
 //!     Collator::try_new(&Default::default(), options_num_off).unwrap();
 //! assert_eq!(collator_num_off.compare("a10b", "a2b"), Ordering::Less);
 //!
@@ -262,7 +262,7 @@
 //!
 //! let mut options_num_on = CollatorOptions::new();
 //! options_num_on.numeric = Some(Numeric::On);
-//! let collator_num_on: Collator =
+//! let collator_num_on =
 //!     Collator::try_new(&Default::default(), options_num_on).unwrap();
 //! assert_eq!(collator_num_on.compare("a10b", "a2b"), Ordering::Greater);
 //! ```
diff --git a/components/collections/src/codepointinvlist/cpinvlist.rs b/components/collections/src/codepointinvlist/cpinvlist.rs
index 46079a2cd28..ed98ea4385a 100644
--- a/components/collections/src/codepointinvlist/cpinvlist.rs
+++ b/components/collections/src/codepointinvlist/cpinvlist.rs
@@ -196,12 +196,12 @@ impl<'data> CodePointInversionList<'data> {
     /// use icu::collections::codepointinvlist::CodePointInversionListError;
     /// use zerovec::ZeroVec;
     /// let valid = [0x0, 0x10000];
-    /// let inv_list: ZeroVec<u32> = ZeroVec::from_slice_or_alloc(&valid);
+    /// let inv_list = ZeroVec::<u32>::from_slice_or_alloc(&valid);
     /// let result = CodePointInversionList::try_from_inversion_list(inv_list);
     /// assert!(matches!(result, CodePointInversionList));
     ///
-    /// let invalid: Vec<u32> = vec![0x0, 0x80, 0x3];
-    /// let inv_list: ZeroVec<u32> = ZeroVec::from_slice_or_alloc(&invalid);
+    /// let invalid = vec![0x0, 0x80, 0x3];
+    /// let inv_list = ZeroVec::<u32>::from_slice_or_alloc(&invalid);
     /// let result = CodePointInversionList::try_from_inversion_list(inv_list);
     /// assert!(matches!(
     ///     result,
@@ -252,7 +252,7 @@ impl<'data> CodePointInversionList<'data> {
     /// let result = CodePointInversionList::try_from_inversion_list_slice(&valid);
     /// assert!(matches!(result, CodePointInversionList));
     ///
-    /// let invalid: Vec<u32> = vec![0x0, 0x80, 0x3];
+    /// let invalid = vec![0x0, 0x80, 0x3];
     /// let result =
     ///     CodePointInversionList::try_from_inversion_list_slice(&invalid);
     /// assert!(matches!(
@@ -285,14 +285,12 @@ impl<'data> CodePointInversionList<'data> {
     /// let smp_list = &[0x10000, 0x20000];
     /// let sip_list = &[0x20000, 0x30000];
     ///
-    /// let lists: Vec<CodePointInversionList> =
+    /// let lists =
     ///     [&bmp_list[..], smp_list, sip_list]
-    ///         .into_iter()
     ///         .map(|l| {
     ///             CodePointInversionList::try_clone_from_inversion_list_slice(l)
     ///                 .unwrap()
-    ///         })
-    ///         .collect();
+    ///         });
     ///
     /// let bmp = &lists[0];
     /// assert!(bmp.contains32(0xFFFF));
diff --git a/components/datetime/src/format/neo.rs b/components/datetime/src/format/neo.rs
index 6172a4aa9b7..0194d92b788 100644
--- a/components/datetime/src/format/neo.rs
+++ b/components/datetime/src/format/neo.rs
@@ -164,8 +164,8 @@ size_test!(
 /// use writeable::assert_try_writeable_eq;
 ///
 /// // Create an instance that can format abbreviated month, weekday, and day period names:
-/// let mut names: TypedDateTimeNames<Gregorian> =
-///     TypedDateTimeNames::try_new(&locale!("uk").into()).unwrap();
+/// let mut names =
+///     TypedDateTimeNames::<Gregorian>::try_new(&locale!("uk").into()).unwrap();
 /// names
 ///     .include_month_names(fields::Month::Format, FieldLength::Abbreviated)
 ///     .unwrap()
@@ -176,7 +176,7 @@ size_test!(
 ///
 /// // Create a pattern from a pattern string:
 /// let pattern_str = "E MMM d y -- h:mm a";
-/// let pattern: DateTimePattern = pattern_str.parse().unwrap();
+/// let pattern = pattern_str.parse::<DateTimePattern>().unwrap();
 ///
 /// // Test it:
 /// let datetime = DateTime::try_new_gregorian_datetime(2023, 11, 20, 11, 35, 3).unwrap();
@@ -195,12 +195,12 @@ size_test!(
 /// use writeable::assert_try_writeable_eq;
 ///
 /// // Create an instance that can format abbreviated month, weekday, and day period names:
-/// let mut names: TypedDateTimeNames<Gregorian> =
-///     TypedDateTimeNames::try_new(&locale!("en").into()).unwrap();
+/// let mut names =
+///     TypedDateTimeNames::<Gregorian>::try_new(&locale!("en").into()).unwrap();
 ///
 /// // Create a pattern from a pattern string:
 /// let pattern_str = "'It is:' E MMM d y G 'at' h:mm:ssSSS a";
-/// let pattern: DateTimePattern = pattern_str.parse().unwrap();
+/// let pattern = pattern_str.parse::<DateTimePattern>().unwrap();
 ///
 /// // The pattern string contains lots of symbols including "E", "MMM", and "a", but we did not load any data!
 /// let datetime = DateTime::try_new_gregorian_datetime(2023, 11, 20, 11, 35, 3).unwrap();
@@ -696,7 +696,7 @@ impl<C: CldrCalendar, R: DateTimeNamesMarker> TypedDateTimeNames<C, R> {
     ///
     /// // Format a pattern needing week data:
     /// let pattern_str = "'Week' w 'of' Y";
-    /// let pattern: DateTimePattern = pattern_str.parse().unwrap();
+    /// let pattern = pattern_str.parse::<DateTimePattern>().unwrap();
     /// let date = Date::try_new_gregorian_date(2023, 12, 5).unwrap();
     /// assert_try_writeable_eq!(
     ///     names.with_pattern(&pattern).format_date(&date),
@@ -798,7 +798,7 @@ impl<C: CldrCalendar, R: DateTimeNamesMarker> TypedDateTimeNames<C, R> {
     ///
     /// // Create a pattern from a pattern string:
     /// let pattern_str = "EEEE 'on week' w 'of' Y G (MMM d) 'at' h:mm a";
-    /// let pattern: DateTimePattern = pattern_str.parse().unwrap();
+    /// let pattern = pattern_str.parse::<DateTimePattern>().unwrap();
     ///
     /// // Load data for the pattern and format:
     /// let datetime =
@@ -1268,8 +1268,8 @@ impl<'a, C: CldrCalendar> DateTimePatternFormatter<'a, C> {
     /// use writeable::assert_try_writeable_eq;
     ///
     /// // Create an instance that can format wide month and era names:
-    /// let mut names: TypedDateTimeNames<Gregorian> =
-    ///     TypedDateTimeNames::try_new(&locale!("en-GB").into()).unwrap();
+    /// let mut names =
+    ///     TypedDateTimeNames::<Gregorian>::try_new(&locale!("en-GB").into()).unwrap();
     /// names
     ///     .include_month_names(fields::Month::Format, FieldLength::Wide)
     ///     .unwrap()
@@ -1278,7 +1278,7 @@ impl<'a, C: CldrCalendar> DateTimePatternFormatter<'a, C> {
     ///
     /// // Create a pattern from a pattern string:
     /// let pattern_str = "'The date is:' MMMM d, y GGGG";
-    /// let pattern: DateTimePattern = pattern_str.parse().unwrap();
+    /// let pattern = pattern_str.parse::<DateTimePattern>().unwrap();
     ///
     /// // Test it with some different dates:
     /// // Note: extended year -50 is year 51 BCE
@@ -1318,15 +1318,15 @@ impl<'a, C: CldrCalendar> DateTimePatternFormatter<'a, C> {
     /// use writeable::assert_try_writeable_eq;
     ///
     /// // Create an instance that can format abbreviated day periods:
-    /// let mut names: TypedDateTimeNames<Gregorian> =
-    ///     TypedDateTimeNames::try_new(&locale!("en-US").into()).unwrap();
+    /// let mut names =
+    ///     TypedDateTimeNames::<Gregorian>::try_new(&locale!("en-US").into()).unwrap();
     /// names
     ///     .include_day_period_names(FieldLength::Abbreviated)
     ///     .unwrap();
     ///
     /// // Create a pattern from a pattern string:
     /// let pattern_str = "'The time is:' h:mm b";
-    /// let pattern: DateTimePattern = pattern_str.parse().unwrap();
+    /// let pattern = pattern_str.parse::<DateTimePattern>().unwrap();
     ///
     /// // Test it with different times of day:
     /// let time_am = Time::try_new(11, 4, 14, 0).unwrap();
diff --git a/components/datetime/src/input.rs b/components/datetime/src/input.rs
index d412b868c3e..1cc4e9787d9 100644
--- a/components/datetime/src/input.rs
+++ b/components/datetime/src/input.rs
@@ -131,12 +131,12 @@ pub trait TimeZoneInput {
 /// }
 ///
 /// // Create an instance that can format abbreviated month, weekday, and day period names:
-/// let mut names: TypedDateTimeNames<Gregorian> =
-///     TypedDateTimeNames::try_new(&locale!("en").into()).unwrap();
+/// let mut names =
+///     TypedDateTimeNames::<Gregorian>::try_new(&locale!("en").into()).unwrap();
 ///
 /// // Create a pattern from a pattern string:
 /// let pattern_str = "'It is:' E MMM d y G 'at' h:mm:ssSSS a";
-/// let pattern: DateTimePattern = pattern_str.parse().unwrap();
+/// let pattern = pattern_str.parse::<DateTimePattern>().unwrap();
 ///
 /// // The pattern string contains lots of symbols, but our DateTimeInput is empty!
 /// let mut buffer = String::new();
diff --git a/components/datetime/src/options/components.rs b/components/datetime/src/options/components.rs
index 841f8f755b1..5fbc8a3b793 100644
--- a/components/datetime/src/options/components.rs
+++ b/components/datetime/src/options/components.rs
@@ -75,7 +75,7 @@
 //! ```
 //! use icu::datetime::options::components;
 //! use icu::datetime::DateTimeFormatterOptions;
-//! let options: DateTimeFormatterOptions = components::Bag::default().into();
+//! let options = DateTimeFormatterOptions::from(components::Bag::default());
 //! ```
 //!
 //! *Note*: The exact result returned from [`TypedDateTimeFormatter`](crate::TypedDateTimeFormatter) is a subject to change over
diff --git a/components/datetime/src/options/length.rs b/components/datetime/src/options/length.rs
index 9f62ce6019b..17e27e6726e 100644
--- a/components/datetime/src/options/length.rs
+++ b/components/datetime/src/options/length.rs
@@ -34,7 +34,7 @@
 //! ```
 //! use icu::datetime::options::length;
 //! use icu::datetime::DateTimeFormatterOptions;
-//! let options: DateTimeFormatterOptions = length::Bag::default().into();
+//! let options = DateTimeFormatterOptions::from(length::Bag::default());
 //! ```
 //!
 //! *Note*: The exact result returned from [`TypedDateTimeFormatter`](crate::TypedDateTimeFormatter) is a subject to change over
@@ -69,7 +69,7 @@ use serde::{Deserialize, Serialize};
 /// ```
 /// use icu::datetime::options::length;
 /// use icu::datetime::DateTimeFormatterOptions;
-/// let options: DateTimeFormatterOptions = length::Bag::default().into();
+/// let options = DateTimeFormatterOptions::from(length::Bag::default());
 /// ```
 ///
 /// [`UTS #35: Unicode LDML 4. Dates`]: https://unicode.org/reports/tr35/tr35-dates.html
diff --git a/components/datetime/src/pattern/runtime/generic.rs b/components/datetime/src/pattern/runtime/generic.rs
index 32357488efb..8a4cf4bf880 100644
--- a/components/datetime/src/pattern/runtime/generic.rs
+++ b/components/datetime/src/pattern/runtime/generic.rs
@@ -43,11 +43,11 @@ impl<'data> GenericPattern<'data> {
     /// ```
     /// use icu::datetime::pattern::runtime::{GenericPattern, Pattern};
     ///
-    /// let date: Pattern = "Y-m-d".parse().expect("Failed to parse pattern");
-    /// let time: Pattern = "HH:mm".parse().expect("Failed to parse pattern");
+    /// let date = "Y-m-d".parse::<Pattern>().expect("Failed to parse pattern");
+    /// let time = "HH:mm".parse::<Pattern>().expect("Failed to parse pattern");
     ///
-    /// let glue: GenericPattern = "{1} 'at' {0}"
-    ///     .parse()
+    /// let glue = "{1} 'at' {0}"
+    ///     .parse::<GenericPattern>()
     ///     .expect("Failed to parse generic pattern");
     /// assert_eq!(
     ///     glue.combined(date, time)
diff --git a/components/datetime/src/provider/calendar/skeletons.rs b/components/datetime/src/provider/calendar/skeletons.rs
index cf0d5d461f6..c55018fda5f 100644
--- a/components/datetime/src/provider/calendar/skeletons.rs
+++ b/components/datetime/src/provider/calendar/skeletons.rs
@@ -84,14 +84,10 @@ impl databake::Bake for DateSkeletonPatternsV1<'_> {
         use zerofrom::ZeroFrom;
         env.insert("icu_datetime");
         databake::Bake::bake(
-            &self
-                .0
-                .iter()
-                .map(|(skeleton, pattern)| {
-                    (skeleton.0 .0.as_slice(), PatternPlurals::zero_from(pattern))
-                })
-                .collect::<Vec<_>>()
-                .as_slice(),
+            &Vec::from_iter(self.0.iter().map(|(skeleton, pattern)| {
+                (skeleton.0 .0.as_slice(), PatternPlurals::zero_from(pattern))
+            }))
+            .as_slice(),
             env,
         )
     }
diff --git a/components/datetime/src/skeleton/runtime.rs b/components/datetime/src/skeleton/runtime.rs
index 84c1aade781..5f7852f5640 100644
--- a/components/datetime/src/skeleton/runtime.rs
+++ b/components/datetime/src/skeleton/runtime.rs
@@ -4,7 +4,6 @@
 
 use crate::fields::Field;
 use crate::skeleton::reference;
-use alloc::vec::Vec;
 use zerovec::ZeroVec;
 
 #[derive(Debug, PartialEq, Clone)]
@@ -12,8 +11,7 @@ pub struct Skeleton<'data>(pub(crate) ZeroVec<'data, Field>);
 
 impl From<reference::Skeleton> for Skeleton<'_> {
     fn from(input: reference::Skeleton) -> Self {
-        let fields = input.fields_iter().copied().collect::<Vec<_>>();
-        Self(ZeroVec::alloc_from_slice(&fields))
+        Self(ZeroVec::from_iter(input.fields_iter().copied()))
     }
 }
 
diff --git a/components/decimal/src/options.rs b/components/decimal/src/options.rs
index 7f42c421fb0..dd633be0512 100644
--- a/components/decimal/src/options.rs
+++ b/components/decimal/src/options.rs
@@ -30,7 +30,7 @@ impl From<GroupingStrategy> for FixedDecimalFormatterOptions {
 /// use writeable::assert_writeable_eq;
 ///
 /// let locale = Locale::UND;
-/// let mut options: options::FixedDecimalFormatterOptions = Default::default();
+/// let mut options = options::FixedDecimalFormatterOptions::default();
 /// options.grouping_strategy = options::GroupingStrategy::Min2;
 /// let fdf = FixedDecimalFormatter::try_new(&locale.into(), options)
 ///     .expect("locale should be present");
diff --git a/components/experimental/benches/transliterate/bench.rs b/components/experimental/benches/transliterate/bench.rs
index 18c8bbe0597..b8ec1e3f83b 100644
--- a/components/experimental/benches/transliterate/bench.rs
+++ b/components/experimental/benches/transliterate/bench.rs
@@ -22,7 +22,7 @@ fn owned_inputs(content: &str) -> Vec<String> {
         .lines()
         .filter(|&s| !s.starts_with('#'))
         .map(|s| s.split('\t').next().unwrap().to_string())
-        .collect::<Vec<String>>()
+        .collect()
 }
 
 fn bench_data_from_sources(locale_str: &str, source: &str) -> Vec<BenchDataContent> {
diff --git a/components/experimental/src/displaynames/displaynames.rs b/components/experimental/src/displaynames/displaynames.rs
index 6e27fa9ea5d..2a0e015251b 100644
--- a/components/experimental/src/displaynames/displaynames.rs
+++ b/components/experimental/src/displaynames/displaynames.rs
@@ -26,7 +26,7 @@ use zerovec::ule::UnvalidatedStr;
 /// use icu::locid::{locale, subtags::region};
 ///
 /// let locale = locale!("en-001").into();
-/// let options: DisplayNamesOptions = Default::default();
+/// let options = DisplayNamesOptions::default();
 /// let display_name = RegionDisplayNames::try_new(&locale, options)
 ///     .expect("Data should load successfully");
 ///
@@ -101,7 +101,7 @@ impl RegionDisplayNames {
 /// use icu::locid::{locale, subtags::script};
 ///
 /// let locale = locale!("en-001").into();
-/// let options: DisplayNamesOptions = Default::default();
+/// let options = DisplayNamesOptions::default();
 /// let display_name = ScriptDisplayNames::try_new(&locale, options)
 ///     .expect("Data should load successfully");
 ///
@@ -176,7 +176,7 @@ impl ScriptDisplayNames {
 /// use icu::locid::{locale, subtags::variant};
 ///
 /// let locale = locale!("en-001").into();
-/// let options: DisplayNamesOptions = Default::default();
+/// let options = DisplayNamesOptions::default();
 /// let display_name = VariantDisplayNames::try_new(&locale, options)
 ///     .expect("Data should load successfully");
 ///
@@ -246,7 +246,7 @@ impl VariantDisplayNames {
 /// use icu::locid::{locale, subtags::language};
 ///
 /// let locale = locale!("en-001").into();
-/// let options: DisplayNamesOptions = Default::default();
+/// let options = DisplayNamesOptions::default();
 /// let display_name = LanguageDisplayNames::try_new(&locale, options)
 ///     .expect("Data should load successfully");
 ///
@@ -327,7 +327,7 @@ impl LanguageDisplayNames {
 /// use icu::locid::locale;
 ///
 /// let locale = locale!("en-001").into();
-/// let options: DisplayNamesOptions = Default::default();
+/// let options = DisplayNamesOptions::default();
 /// let display_name = LocaleDisplayNamesFormatter::try_new(&locale, options)
 ///     .expect("Data should load successfully");
 ///
diff --git a/components/experimental/src/displaynames/options.rs b/components/experimental/src/displaynames/options.rs
index aa7ffd412c9..ecf9d643aa9 100644
--- a/components/experimental/src/displaynames/options.rs
+++ b/components/experimental/src/displaynames/options.rs
@@ -15,7 +15,7 @@
 /// use icu::locid::{locale, subtags::region};
 ///
 /// let locale = locale!("en-001");
-/// let mut options: DisplayNamesOptions = Default::default();
+/// let mut options = DisplayNamesOptions::default();
 /// options.style = Some(Style::Short);
 /// let display_name = RegionDisplayNames::try_new(&locale.into(), options)
 ///     .expect("Data should load successfully");
diff --git a/components/experimental/src/personnames/formatter.rs b/components/experimental/src/personnames/formatter.rs
index 9d16ab8eb23..d435879b69c 100644
--- a/components/experimental/src/personnames/formatter.rs
+++ b/components/experimental/src/personnames/formatter.rs
@@ -147,11 +147,16 @@ impl PersonNamesFormatter {
             .as_ref()
             .map(|f| f.as_ref())
             .unwrap_or("{0} {1}");
-        return Ok(best_applicable_pattern
+        Ok(best_applicable_pattern
             .format_person_name(person_name, initial_pattern, initial_sequence_pattern)
             .split_whitespace()
-            .collect::<Vec<_>>()
-            .join(space_replacement));
+            .fold(String::new(), |mut acc, s| {
+                if !acc.is_empty() {
+                    acc.push_str(space_replacement);
+                }
+                acc.push_str(s);
+                acc
+            }))
     }
 
     fn final_person_names_formatter_options<N>(
diff --git a/components/experimental/src/personnames/specifications/derive_core_prefix.rs b/components/experimental/src/personnames/specifications/derive_core_prefix.rs
index bfd428fcb03..90b5d5e23c5 100644
--- a/components/experimental/src/personnames/specifications/derive_core_prefix.rs
+++ b/components/experimental/src/personnames/specifications/derive_core_prefix.rs
@@ -171,23 +171,18 @@ mod tests {
         field_part: FieldPart,
         expected_parts: &[FieldPart],
     ) {
-        let available_fields: Vec<NameField> = available_parts
-            .iter()
-            .map(|part: &FieldPart| NameField {
+        let available_fields =
+            Vec::from_iter(available_parts.iter().map(|part: &FieldPart| NameField {
                 kind: NameFieldKind::Given,
                 modifier: FieldModifierSet::part(*part),
-            })
-            .collect::<Vec<NameField>>();
-        let expected_fields: Vec<NameField> = expected_parts
-            .iter()
-            .map(|part| NameField {
-                kind: NameFieldKind::Given,
-                modifier: FieldModifierSet::part(*part),
-            })
-            .collect::<Vec<NameField>>();
+            }));
+        let expected_fields = Vec::from_iter(expected_parts.iter().map(|part| NameField {
+            kind: NameFieldKind::Given,
+            modifier: FieldModifierSet::part(*part),
+        }));
         assert_eq!(
             super::handle_field_modifier_core_prefix(
-                &available_fields.iter().collect::<Vec<&NameField>>(),
+                &Vec::from_iter(available_fields.iter()),
                 &NameField {
                     kind: NameFieldKind::Given,
                     modifier: FieldModifierSet::part(field_part),
diff --git a/components/experimental/src/transliterate/compile/mod.rs b/components/experimental/src/transliterate/compile/mod.rs
index 71785817a07..ab7b4179917 100644
--- a/components/experimental/src/transliterate/compile/mod.rs
+++ b/components/experimental/src/transliterate/compile/mod.rs
@@ -481,7 +481,7 @@ where
             .cloned()
             .chain(exclusive_data.1.keys().cloned())
             .map(|s| s.parse().unwrap())
-            .collect::<Vec<_>>())
+            .collect())
     }
 }
 
@@ -757,7 +757,7 @@ mod tests {
             assert_eq!(*forward.get(), expected_rbt);
 
             assert_eq!(
-                forward.get().deps().collect::<HashSet<_>>(),
+                HashSet::<_>::from_iter(forward.get().deps()),
                 HashSet::from_iter([
                     Cow::Borrowed("x-any-nfc"),
                     Cow::Borrowed("x-any-remove"),
@@ -862,7 +862,7 @@ mod tests {
             assert_eq!(*reverse.get(), expected_rbt);
 
             assert_eq!(
-                reverse.get().deps().collect::<HashSet<_>>(),
+                HashSet::<_>::from_iter(reverse.get().deps()),
                 HashSet::from_iter([
                     Cow::Borrowed("und-t-d0-addrndsp-m0-fifty-s0-anyrev"),
                     Cow::Borrowed("x-any-nfd"),
diff --git a/components/experimental/src/transliterate/transliterator/mod.rs b/components/experimental/src/transliterate/transliterator/mod.rs
index a0b07c04fa6..9c4f70631a6 100644
--- a/components/experimental/src/transliterate/transliterator/mod.rs
+++ b/components/experimental/src/transliterate/transliterator/mod.rs
@@ -218,7 +218,7 @@ impl Transliterator {
     ///     }
     /// }
     ///
-    /// let override_locale: Locale = "und-t-und-Latn-d0-ascii".parse().unwrap();
+    /// let override_locale = "und-t-und-Latn-d0-ascii".parse::<Locale>().unwrap();
     /// let lookup = |lookup_locale: &Locale| -> Option<Box<dyn CustomTransliterator>> {
     ///     override_locale.eq(lookup_locale).then_some(Box::new(FunkyGermanToAscii))
     /// };
diff --git a/components/experimental/src/unicodeset_parse/parse.rs b/components/experimental/src/unicodeset_parse/parse.rs
index afef174bdaa..b75422f1cfd 100644
--- a/components/experimental/src/unicodeset_parse/parse.rs
+++ b/components/experimental/src/unicodeset_parse/parse.rs
@@ -764,8 +764,7 @@ where
                 let (single, string_set) = inner_builder.finalize();
                 // note: offset - 1, because we already consumed full set
                 let offset = self.must_peek_index()? - 1;
-                let mut strings = string_set.into_iter().collect::<Vec<_>>();
-                strings.sort();
+                let strings = Vec::from_iter(string_set);
                 let cpilasl = CodePointInversionListAndStringList::try_from(
                     single.build(),
                     VarZeroVec::from(&strings),
@@ -1637,8 +1636,7 @@ where
     let (single, string_set) = builder.finalize();
     let built_single = single.build();
 
-    let mut strings = string_set.into_iter().collect::<Vec<_>>();
-    strings.sort();
+    let strings = Vec::from_iter(string_set);
     let zerovec = (&strings).into();
 
     let cpinvlistandstrlist = CodePointInversionListAndStringList::try_from(built_single, zerovec)
diff --git a/components/experimental/tests/transliterate/cldr.rs b/components/experimental/tests/transliterate/cldr.rs
index 5c8b38e4d13..fb9bd8199ee 100644
--- a/components/experimental/tests/transliterate/cldr.rs
+++ b/components/experimental/tests/transliterate/cldr.rs
@@ -41,12 +41,9 @@ fn test_all_cldr() {
         let test_cases = data
             .lines()
             .filter(|x| !x.starts_with('#'))
-            .map(|l| l.split_once('\t').unwrap())
-            .collect::<Vec<_>>();
+            .map(|l| l.split_once('\t').unwrap());
 
-        eprintln!("Testing {:?} with {} test cases", locale, test_cases.len());
-
-        for (idx, (input, output)) in test_cases.into_iter().enumerate() {
+        for (idx, (input, output)) in test_cases.enumerate() {
             eprintln!(
                 "Testing testcase {}! Input: {:?} Output: {:?}",
                 idx + 1,
diff --git a/components/locid/benches/helpers/macros.rs b/components/locid/benches/helpers/macros.rs
index 848a360c416..d7b4df99185 100644
--- a/components/locid/benches/helpers/macros.rs
+++ b/components/locid/benches/helpers/macros.rs
@@ -17,10 +17,7 @@ macro_rules! overview {
                     .filter(|&v| v.normalizing_eq($compare))
                     .count();
 
-                values
-                    .iter()
-                    .map(|v| v.to_string())
-                    .collect::<Vec<String>>()
+                Vec::from_iter(values.iter().map(|v| v.to_string()))
             })
         });
     };
diff --git a/components/locid/src/extensions/other/mod.rs b/components/locid/src/extensions/other/mod.rs
index 8a7f36d4949..0e7e191ae41 100644
--- a/components/locid/src/extensions/other/mod.rs
+++ b/components/locid/src/extensions/other/mod.rs
@@ -16,7 +16,7 @@
 //! use icu::locid::extensions::other::Other;
 //! use icu::locid::Locale;
 //!
-//! let mut loc: Locale = "en-US-a-foo-faa".parse().expect("Parsing failed.");
+//! let mut loc = "en-US-a-foo-faa".parse::<Locale>().expect("Parsing failed.");
 //! ```
 
 mod subtag;
@@ -105,7 +105,7 @@ impl Other {
     /// ```
     /// use icu::locid::Locale;
     ///
-    /// let loc: Locale = "und-a-hello-world".parse().unwrap();
+    /// let loc = "und-a-hello-world".parse::<Locale>().unwrap();
     /// let other_ext = &loc.extensions.other[0];
     /// assert_eq!(other_ext.get_ext_str(), "a");
     /// ```
@@ -121,7 +121,7 @@ impl Other {
     /// ```
     /// use icu::locid::Locale;
     ///
-    /// let loc: Locale = "und-a-hello-world".parse().unwrap();
+    /// let loc = "und-a-hello-world".parse::<Locale>().unwrap();
     /// let other_ext = &loc.extensions.other[0];
     /// assert_eq!(other_ext.get_ext(), 'a');
     /// ```
@@ -136,7 +136,7 @@ impl Other {
     /// ```
     /// use icu::locid::Locale;
     ///
-    /// let loc: Locale = "und-a-hello-world".parse().unwrap();
+    /// let loc = "und-a-hello-world".parse::<Locale>().unwrap();
     /// let other_ext = &loc.extensions.other[0];
     /// assert_eq!(other_ext.get_ext_byte(), b'a');
     /// ```
diff --git a/components/locid/src/extensions/private/mod.rs b/components/locid/src/extensions/private/mod.rs
index fab414ab3fe..eab7b6e4c81 100644
--- a/components/locid/src/extensions/private/mod.rs
+++ b/components/locid/src/extensions/private/mod.rs
@@ -16,7 +16,7 @@
 //! use icu::locid::extensions::private::subtag;
 //! use icu::locid::{locale, Locale};
 //!
-//! let mut loc: Locale = "en-US-x-foo-faa".parse().expect("Parsing failed.");
+//! let mut loc = "en-US-x-foo-faa".parse::<Locale>().expect("Parsing failed.");
 //!
 //! assert!(loc.extensions.private.contains(&subtag!("foo")));
 //! assert_eq!(loc.extensions.private.iter().next(), Some(&subtag!("foo")));
@@ -101,7 +101,7 @@ impl Private {
     /// ```
     /// use icu::locid::extensions::private::{Private, Subtag};
     ///
-    /// let subtag: Subtag = "foo".parse().expect("Failed to parse a Subtag.");
+    /// let subtag = "foo".parse::<Subtag>().expect("Failed to parse a Subtag.");
     ///
     /// let private = Private::new_single(subtag);
     /// assert_eq!(&private.to_string(), "x-foo");
diff --git a/components/locid/src/extensions/transform/fields.rs b/components/locid/src/extensions/transform/fields.rs
index 1013fb26e8e..0cfce6e1d23 100644
--- a/components/locid/src/extensions/transform/fields.rs
+++ b/components/locid/src/extensions/transform/fields.rs
@@ -27,7 +27,7 @@ use super::Value;
 /// use icu::locid::extensions::transform::{key, Fields, Value};
 ///
 /// let value = "hybrid".parse::<Value>().expect("Failed to parse a Value.");
-/// let fields = [(key!("h0"), value)].into_iter().collect::<Fields>();
+/// let fields = Fields::from_iter([(key!("h0"), value)]);
 ///
 /// assert_eq!(&fields.to_string(), "h0-hybrid");
 /// ```
@@ -77,7 +77,7 @@ impl Fields {
     /// use icu::locid::extensions::transform::{key, Fields, Value};
     ///
     /// let value = "hybrid".parse::<Value>().expect("Failed to parse a Value.");
-    /// let mut fields = [(key!("h0"), value)].into_iter().collect::<Fields>();
+    /// let mut fields = Fields::from_iter([(key!("h0"), value)]);
     ///
     /// assert_eq!(&fields.to_string(), "h0-hybrid");
     ///
@@ -97,11 +97,11 @@ impl Fields {
     /// ```
     /// use icu::locid::extensions::transform::{Fields, Key, Value};
     ///
-    /// let key: Key = "h0".parse().expect("Failed to parse a Key.");
-    /// let value: Value = "hybrid".parse().expect("Failed to parse a Value.");
-    /// let mut fields = [(key, value)].into_iter().collect::<Fields>();
+    /// let key = "h0".parse::<Key>().expect("Failed to parse a Key.");
+    /// let value = "hybrid".parse::<Value>().expect("Failed to parse a Value.");
+    /// let mut fields = Fields::from_iter([(key, value)]);
     ///
-    /// let key: Key = "h0".parse().expect("Failed to parse a Key.");
+    /// let key = "h0".parse().expect("Failed to parse a Key.");
     /// assert!(&fields.contains_key(&key));
     /// ```
     pub fn contains_key<Q>(&self, key: &Q) -> bool
@@ -121,9 +121,7 @@ impl Fields {
     /// use icu::locid::extensions::transform::{key, Fields, Value};
     ///
     /// let value = "hybrid".parse::<Value>().unwrap();
-    /// let fields = [(key!("h0"), value.clone())]
-    ///     .into_iter()
-    ///     .collect::<Fields>();
+    /// let fields = Fields::from_iter([(key!("h0"), value.clone())]);
     ///
     /// assert_eq!(fields.get(&key!("h0")), Some(&value));
     /// ```
@@ -146,8 +144,8 @@ impl Fields {
     /// let lower = "lower".parse::<Value>().expect("valid extension subtag");
     /// let casefold = "casefold".parse::<Value>().expect("valid extension subtag");
     ///
-    /// let mut loc: Locale = "en-t-hi-d0-casefold"
-    ///     .parse()
+    /// let mut loc = "en-t-hi-d0-casefold"
+    ///     .parse::<Locale>()
     ///     .expect("valid BCP-47 identifier");
     /// let old_value = loc.extensions.transform.fields.set(key!("d0"), lower);
     ///
@@ -166,7 +164,7 @@ impl Fields {
     /// use icu::locid::extensions::transform::key;
     /// use icu::locid::Locale;
     ///
-    /// let mut loc: Locale = "und-t-h0-hybrid-d0-hex-m0-xml".parse().unwrap();
+    /// let mut loc = "und-t-h0-hybrid-d0-hex-m0-xml".parse::<Locale>().unwrap();
     ///
     /// loc.extensions
     ///     .transform
diff --git a/components/locid/src/extensions/transform/mod.rs b/components/locid/src/extensions/transform/mod.rs
index 0e0212eb2e6..1f8445865b8 100644
--- a/components/locid/src/extensions/transform/mod.rs
+++ b/components/locid/src/extensions/transform/mod.rs
@@ -15,11 +15,11 @@
 //! use icu::locid::extensions::transform::{Fields, Key, Transform, Value};
 //! use icu::locid::{LanguageIdentifier, Locale};
 //!
-//! let mut loc: Locale =
-//!     "en-US-t-es-ar-h0-hybrid".parse().expect("Parsing failed.");
+//! let mut loc =
+//!     "en-US-t-es-ar-h0-hybrid".parse::<Locale>().expect("Parsing failed.");
 //!
-//! let lang: LanguageIdentifier =
-//!     "es-AR".parse().expect("Parsing LanguageIdentifier failed.");
+//! let lang =
+//!     "es-AR".parse::<LanguageIdentifier>().expect("Parsing LanguageIdentifier failed.");
 //!
 //! let key: Key = "h0".parse().expect("Parsing key failed.");
 //! let value: Value = "hybrid".parse().expect("Parsing value failed.");
diff --git a/components/locid/src/extensions/unicode/keywords.rs b/components/locid/src/extensions/unicode/keywords.rs
index 72245a98ebf..2951bc1f512 100644
--- a/components/locid/src/extensions/unicode/keywords.rs
+++ b/components/locid/src/extensions/unicode/keywords.rs
@@ -33,9 +33,7 @@ use crate::shortvec::ShortBoxSlice;
 /// ```
 /// use icu::locid::extensions::unicode::{key, value, Keywords};
 ///
-/// let keywords = [(key!("hc"), value!("h23"))]
-///     .into_iter()
-///     .collect::<Keywords>();
+/// let keywords = Keywords::from_iter([(key!("hc"), value!("h23"))]);
 ///
 /// assert_eq!(&keywords.to_string(), "hc-h23");
 /// ```
@@ -116,9 +114,7 @@ impl Keywords {
     /// ```
     /// use icu::locid::extensions::unicode::{key, value, Keywords};
     ///
-    /// let keywords = [(key!("ca"), value!("gregory"))]
-    ///     .into_iter()
-    ///     .collect::<Keywords>();
+    /// let keywords = Keywords::from_iter([(key!("ca"), value!("gregory"))]);
     ///
     /// assert!(&keywords.contains_key(&key!("ca")));
     /// ```
@@ -138,9 +134,7 @@ impl Keywords {
     /// ```
     /// use icu::locid::extensions::unicode::{key, value, Keywords};
     ///
-    /// let keywords = [(key!("ca"), value!("buddhist"))]
-    ///     .into_iter()
-    ///     .collect::<Keywords>();
+    /// let keywords = Keywords::from_iter([(key!("ca"), value!("buddhist"))]);
     ///
     /// assert_eq!(keywords.get(&key!("ca")), Some(&value!("buddhist")));
     /// ```
@@ -161,9 +155,7 @@ impl Keywords {
     /// ```
     /// use icu::locid::extensions::unicode::{key, value, Keywords};
     ///
-    /// let mut keywords = [(key!("ca"), value!("buddhist"))]
-    ///     .into_iter()
-    ///     .collect::<Keywords>();
+    /// let mut keywords = Keywords::from_iter([(key!("ca"), value!("buddhist"))]);
     ///
     /// if let Some(value) = keywords.get_mut(&key!("ca")) {
     ///     *value = value!("gregory");
diff --git a/components/locid/src/parser/mod.rs b/components/locid/src/parser/mod.rs
index 4b02f71c9af..00357780e65 100644
--- a/components/locid/src/parser/mod.rs
+++ b/components/locid/src/parser/mod.rs
@@ -158,11 +158,11 @@ mod test {
 
         let slice = "en";
         let si = SubtagIterator::new(slice.as_bytes());
-        assert_eq!(si.map(slice_to_str).collect::<Vec<_>>(), vec!["en",]);
+        assert_eq!(Vec::from_iter(si.map(slice_to_str)), vec!["en",]);
 
         let slice = "en-";
         let si = SubtagIterator::new(slice.as_bytes());
-        assert_eq!(si.map(slice_to_str).collect::<Vec<_>>(), vec!["en", "",]);
+        assert_eq!(Vec::from_iter(si.map(slice_to_str)), vec!["en", "",]);
 
         let slice = "--";
         let mut si = SubtagIterator::new(slice.as_bytes());
@@ -181,7 +181,7 @@ mod test {
         let slice = "de_at-u-ca-foobar";
         let si = SubtagIterator::new(slice.as_bytes());
         assert_eq!(
-            si.map(slice_to_str).collect::<Vec<_>>(),
+            Vec::from_iter(si.map(slice_to_str)),
             vec!["de", "at", "u", "ca", "foobar",]
         );
     }
diff --git a/components/locid/tests/fixtures/mod.rs b/components/locid/tests/fixtures/mod.rs
index f00fd6c3b9a..f7e49bd7007 100644
--- a/components/locid/tests/fixtures/mod.rs
+++ b/components/locid/tests/fixtures/mod.rs
@@ -194,13 +194,12 @@ impl TryFrom<LocaleSubtags> for LanguageIdentifier {
         let variants = subtags
             .variants
             .iter()
-            .map(|v| v.parse().expect("Failed to parse variant subtag."))
-            .collect::<Vec<_>>();
+            .map(|v| v.parse().expect("Failed to parse variant subtag."));
         Ok(LanguageIdentifier {
             language,
             script,
             region,
-            variants: subtags::Variants::from_vec_unchecked(variants),
+            variants: subtags::Variants::from_vec_unchecked(variants.collect()),
         })
     }
 }
@@ -223,8 +222,7 @@ impl TryFrom<LocaleSubtags> for Locale {
         let variants = subtags
             .variants
             .iter()
-            .map(|v| v.parse().expect("Failed to parse variant subtag."))
-            .collect::<Vec<_>>();
+            .map(|v| v.parse().expect("Failed to parse variant subtag."));
         let extensions = if let Some(e) = subtags.extensions {
             e.try_into().expect("Failed to parse extensions.")
         } else {
@@ -235,7 +233,7 @@ impl TryFrom<LocaleSubtags> for Locale {
                 language,
                 script,
                 region,
-                variants: subtags::Variants::from_vec_unchecked(variants),
+                variants: subtags::Variants::from_vec_unchecked(variants.collect()),
             },
             extensions,
         })
diff --git a/components/locid/tests/langid.rs b/components/locid/tests/langid.rs
index 35867c9a4be..8435e4a80b1 100644
--- a/components/locid/tests/langid.rs
+++ b/components/locid/tests/langid.rs
@@ -136,13 +136,10 @@ fn test_langid_strict_cmp() {
     let tests: Vec<fixtures::LocaleTest> =
         serde_json::from_str(include_str!("fixtures/langid.json"))
             .expect("Failed to read a fixture");
-    let bcp47_strings = tests
-        .iter()
-        .map(|t| match t.input {
-            fixtures::LocaleInfo::String(ref s) => s.as_str(),
-            _ => panic!("Invalid fixture"),
-        })
-        .collect::<Vec<&str>>();
+    let bcp47_strings = Vec::from_iter(tests.iter().map(|t| match t.input {
+        fixtures::LocaleInfo::String(ref s) => s.as_str(),
+        _ => panic!("Invalid fixture"),
+    }));
     for a in bcp47_strings.iter() {
         for b in bcp47_strings.iter() {
             let a_langid = a
diff --git a/components/locid/tests/locale.rs b/components/locid/tests/locale.rs
index 209ee4f9103..a69606b4ee3 100644
--- a/components/locid/tests/locale.rs
+++ b/components/locid/tests/locale.rs
@@ -97,16 +97,13 @@ fn test_locale_strict_cmp() {
     let tests: Vec<fixtures::LocaleTest> =
         serde_json::from_str(include_str!("fixtures/locale.json"))
             .expect("Failed to read a fixture");
-    let bcp47_strings = tests
-        .iter()
-        .map(|t| match t.input {
+    let bcp47_strings = Vec::from_iter(tests.iter().map(|t| match t.input {
+        fixtures::LocaleInfo::Identifier(ref s) => s.identifier.as_str(),
+        _ => match t.output {
             fixtures::LocaleInfo::Identifier(ref s) => s.identifier.as_str(),
-            _ => match t.output {
-                fixtures::LocaleInfo::Identifier(ref s) => s.identifier.as_str(),
-                _ => panic!("No string in fixture input or output: {t:?}"),
-            },
-        })
-        .collect::<Vec<&str>>();
+            _ => panic!("No string in fixture input or output: {t:?}"),
+        },
+    }));
     for a in bcp47_strings.iter() {
         for b in bcp47_strings.iter() {
             let a_langid = a.parse::<Locale>().expect("Invalid BCP-47 in fixture");
diff --git a/components/locid_transform/README.md b/components/locid_transform/README.md
index b97fea23902..e81c4bd8fbe 100644
--- a/components/locid_transform/README.md
+++ b/components/locid_transform/README.md
@@ -27,8 +27,8 @@ use icu::locid_transform::{LocaleCanonicalizer, TransformResult};
 
 let lc = LocaleCanonicalizer::new();
 
-let mut locale: Locale = "ja-Latn-fonipa-hepburn-heploc"
-    .parse()
+let mut locale = "ja-Latn-fonipa-hepburn-heploc"
+    .parse::<Locale>()
     .expect("parse failed");
 assert_eq!(lc.canonicalize(&mut locale), TransformResult::Modified);
 assert_eq!(locale, "ja-Latn-alalc97-fonipa".parse::<Locale>().unwrap());
diff --git a/components/locid_transform/src/canonicalizer.rs b/components/locid_transform/src/canonicalizer.rs
index 09a45990c63..b91b1e82bf7 100644
--- a/components/locid_transform/src/canonicalizer.rs
+++ b/components/locid_transform/src/canonicalizer.rs
@@ -31,7 +31,7 @@ use tinystr::TinyAsciiStr;
 ///
 /// let lc = LocaleCanonicalizer::new();
 ///
-/// let mut locale: Locale = "ja-Latn-fonipa-hepburn-heploc".parse().unwrap();
+/// let mut locale = "ja-Latn-fonipa-hepburn-heploc".parse::<Locale>().unwrap();
 /// assert_eq!(lc.canonicalize(&mut locale), TransformResult::Modified);
 /// assert_eq!(locale, "ja-Latn-alalc97-fonipa".parse().unwrap());
 /// ```
@@ -331,7 +331,7 @@ impl LocaleCanonicalizer {
     ///
     /// let lc = LocaleCanonicalizer::new();
     ///
-    /// let mut locale: Locale = "ja-Latn-fonipa-hepburn-heploc".parse().unwrap();
+    /// let mut locale = "ja-Latn-fonipa-hepburn-heploc".parse::<Locale>().unwrap();
     /// assert_eq!(lc.canonicalize(&mut locale), TransformResult::Modified);
     /// assert_eq!(locale, "ja-Latn-alalc97-fonipa".parse().unwrap());
     /// ```
diff --git a/components/locid_transform/src/lib.rs b/components/locid_transform/src/lib.rs
index 77b0c1639f7..9e5ed9fa4f8 100644
--- a/components/locid_transform/src/lib.rs
+++ b/components/locid_transform/src/lib.rs
@@ -27,8 +27,8 @@
 //!
 //! let lc = LocaleCanonicalizer::new();
 //!
-//! let mut locale: Locale = "ja-Latn-fonipa-hepburn-heploc"
-//!     .parse()
+//! let mut locale = "ja-Latn-fonipa-hepburn-heploc"
+//!     .parse::<Locale>()
 //!     .expect("parse failed");
 //! assert_eq!(lc.canonicalize(&mut locale), TransformResult::Modified);
 //! assert_eq!(locale, "ja-Latn-alalc97-fonipa".parse::<Locale>().unwrap());
diff --git a/components/locid_transform/src/provider/canonicalizer.rs b/components/locid_transform/src/provider/canonicalizer.rs
index 631809fb78d..6c50ef7d319 100644
--- a/components/locid_transform/src/provider/canonicalizer.rs
+++ b/components/locid_transform/src/provider/canonicalizer.rs
@@ -90,11 +90,10 @@ impl<'data> From<AliasesV2<'data>> for AliasesV1<'data> {
             .map(|v: LanguageStrStrPair| {
                 let langid = alloc::format!("{0}-{1}", v.0, v.1);
                 StrStrPair(langid.into(), v.2)
-            })
-            .collect::<alloc::vec::Vec<StrStrPair>>();
+            });
 
         Self {
-            language_variants: VarZeroVec::from(&language_variants),
+            language_variants: VarZeroVec::from(&alloc::vec::Vec::from_iter(language_variants)),
             sgn_region: value.sgn_region,
             language_len2: value.language_len2,
             language_len3: value.language_len3,
diff --git a/components/normalizer/benches/canonical_composition.rs b/components/normalizer/benches/canonical_composition.rs
index bb1fb364f2f..c0f30659bb2 100644
--- a/components/normalizer/benches/canonical_composition.rs
+++ b/components/normalizer/benches/canonical_composition.rs
@@ -17,9 +17,13 @@ fn strip_headers(content: &str) -> String {
     content
         .lines()
         .filter(|&s| !s.starts_with('#'))
-        .map(|s| s.to_owned())
-        .collect::<Vec<String>>()
-        .join("\n")
+        .fold(String::new(), |mut acc, s| {
+            if !acc.is_empty() {
+                acc.push('\n');
+            }
+            acc.push_str(s);
+            acc
+        })
 }
 
 fn normalizer_bench_data() -> [BenchDataContent; 16] {
diff --git a/components/normalizer/benches/canonical_decomposition.rs b/components/normalizer/benches/canonical_decomposition.rs
index 0907a53fcca..57bd6419c21 100644
--- a/components/normalizer/benches/canonical_decomposition.rs
+++ b/components/normalizer/benches/canonical_decomposition.rs
@@ -19,9 +19,13 @@ fn strip_headers(content: &str) -> String {
     content
         .lines()
         .filter(|&s| !s.starts_with('#'))
-        .map(|s| s.to_owned())
-        .collect::<Vec<String>>()
-        .join("\n")
+        .fold(String::new(), |mut acc, s| {
+            if !acc.is_empty() {
+                acc.push('\n');
+            }
+            acc.push_str(s);
+            acc
+        })
 }
 
 fn normalizer_bench_data() -> [BenchDataContent; 15] {
diff --git a/components/normalizer/benches/composing_normalizer_nfc.rs b/components/normalizer/benches/composing_normalizer_nfc.rs
index e4c836d2f4f..8c412700079 100644
--- a/components/normalizer/benches/composing_normalizer_nfc.rs
+++ b/components/normalizer/benches/composing_normalizer_nfc.rs
@@ -22,9 +22,13 @@ fn strip_headers(content: &str) -> String {
     content
         .lines()
         .filter(|&s| !s.starts_with('#'))
-        .map(|s| s.to_owned())
-        .collect::<Vec<String>>()
-        .join("\n")
+        .fold(String::new(), |mut acc, s| {
+            if !acc.is_empty() {
+                acc.push('\n');
+            }
+            acc.push_str(s);
+            acc
+        })
 }
 
 fn normalizer_bench_data() -> [BenchDataContent; 15] {
diff --git a/components/normalizer/benches/composing_normalizer_nfkc.rs b/components/normalizer/benches/composing_normalizer_nfkc.rs
index 5531260b527..984b968429d 100644
--- a/components/normalizer/benches/composing_normalizer_nfkc.rs
+++ b/components/normalizer/benches/composing_normalizer_nfkc.rs
@@ -22,9 +22,13 @@ fn strip_headers(content: &str) -> String {
     content
         .lines()
         .filter(|&s| !s.starts_with('#'))
-        .map(|s| s.to_owned())
-        .collect::<Vec<String>>()
-        .join("\n")
+        .fold(String::new(), |mut acc, s| {
+            if !acc.is_empty() {
+                acc.push('\n');
+            }
+            acc.push_str(s);
+            acc
+        })
 }
 
 fn normalizer_bench_data() -> [BenchDataContent; 15] {
diff --git a/components/normalizer/benches/decomposing_normalizer_nfd.rs b/components/normalizer/benches/decomposing_normalizer_nfd.rs
index 69b3d5385d1..857c5f3c3e9 100644
--- a/components/normalizer/benches/decomposing_normalizer_nfd.rs
+++ b/components/normalizer/benches/decomposing_normalizer_nfd.rs
@@ -22,9 +22,13 @@ fn strip_headers(content: &str) -> String {
     content
         .lines()
         .filter(|&s| !s.starts_with('#'))
-        .map(|s| s.to_owned())
-        .collect::<Vec<String>>()
-        .join("\n")
+        .fold(String::new(), |mut acc, s| {
+            if !acc.is_empty() {
+                acc.push('\n');
+            }
+            acc.push_str(s);
+            acc
+        })
 }
 
 fn normalizer_bench_data() -> [BenchDataContent; 15] {
diff --git a/components/normalizer/benches/decomposing_normalizer_nfkd.rs b/components/normalizer/benches/decomposing_normalizer_nfkd.rs
index c01880a9d8f..8f0f1371d6c 100644
--- a/components/normalizer/benches/decomposing_normalizer_nfkd.rs
+++ b/components/normalizer/benches/decomposing_normalizer_nfkd.rs
@@ -22,9 +22,13 @@ fn strip_headers(content: &str) -> String {
     content
         .lines()
         .filter(|&s| !s.starts_with('#'))
-        .map(|s| s.to_owned())
-        .collect::<Vec<String>>()
-        .join("\n")
+        .fold(String::new(), |mut acc, s| {
+            if !acc.is_empty() {
+                acc.push('\n');
+            }
+            acc.push_str(s);
+            acc
+        })
 }
 
 fn normalizer_bench_data() -> [BenchDataContent; 15] {
diff --git a/components/normalizer/tests/tests.rs b/components/normalizer/tests/tests.rs
index f6bad8c21b1..d816152ade7 100644
--- a/components/normalizer/tests/tests.rs
+++ b/components/normalizer/tests/tests.rs
@@ -86,77 +86,67 @@ fn test_nfkc_basic() {
 fn test_uts46_map_normalize() {
     let mapper: Uts46Mapper = Uts46Mapper::new();
     assert_eq!(
-        mapper
-            .map_normalize("a\u{0308}".chars())
-            .collect::<String>(),
+        String::from_iter(mapper.map_normalize("a\u{0308}".chars())),
         "ä"
     );
     assert_eq!(
-        mapper
-            .map_normalize("A\u{0308}".chars())
-            .collect::<String>(),
+        String::from_iter(mapper.map_normalize("A\u{0308}".chars())),
         "ä"
     );
     assert_eq!(
-        mapper
-            .map_normalize("e\u{0323}\u{0302}".chars())
-            .collect::<String>(),
+        String::from_iter(mapper.map_normalize("e\u{0323}\u{0302}".chars())),
         "ệ"
     );
     assert_eq!(
-        mapper
-            .map_normalize("E\u{0323}\u{0302}".chars())
-            .collect::<String>(),
+        String::from_iter(mapper.map_normalize("E\u{0323}\u{0302}".chars())),
         "ệ"
     );
     assert_eq!(
-        mapper.map_normalize("𝅗𝅥".chars()).collect::<String>(),
+        String::from_iter(mapper.map_normalize("𝅗𝅥".chars())),
         "𝅗\u{1D165}"
     ); // Composition exclusion
 
     assert_eq!(
-        mapper.map_normalize("\u{2126}".chars()).collect::<String>(),
+        String::from_iter(mapper.map_normalize("\u{2126}".chars())),
         "ω"
     ); // ohm sign
-    assert_eq!(mapper.map_normalize("ﾍﾞ".chars()).collect::<String>(), "ベ"); // half-width to full-width, the compose
-    assert_eq!(mapper.map_normalize("ﾍﾟ".chars()).collect::<String>(), "ペ"); // half-width to full-width, the compose
-    assert_eq!(mapper.map_normalize("fi".chars()).collect::<String>(), "fi"); // ligature expanded
-    assert_eq!(mapper.map_normalize("\u{FDFA}".chars()).collect::<String>(), "\u{0635}\u{0644}\u{0649} \u{0627}\u{0644}\u{0644}\u{0647} \u{0639}\u{0644}\u{064A}\u{0647} \u{0648}\u{0633}\u{0644}\u{0645}");
+    assert_eq!(String::from_iter(mapper.map_normalize("ﾍﾞ".chars())), "ベ"); // half-width to full-width, the compose
+    assert_eq!(String::from_iter(mapper.map_normalize("ﾍﾟ".chars())), "ペ"); // half-width to full-width, the compose
+    assert_eq!(String::from_iter(mapper.map_normalize("fi".chars())), "fi"); // ligature expanded
+    assert_eq!(String::from_iter(mapper.map_normalize("\u{FDFA}".chars())), "\u{0635}\u{0644}\u{0649} \u{0627}\u{0644}\u{0644}\u{0647} \u{0639}\u{0644}\u{064A}\u{0647} \u{0648}\u{0633}\u{0644}\u{0645}");
     // ligature expanded
     assert_eq!(
-        mapper.map_normalize("㈎".chars()).collect::<String>(),
+        String::from_iter(mapper.map_normalize("㈎".chars())),
         "(가)"
     ); // parenthetical expanded and partially recomposed
 
     // Deviations (UTS 46, 6 Mapping Table Derivation, Step 4)
     assert_eq!(
-        mapper.map_normalize("\u{200C}".chars()).collect::<String>(),
+        String::from_iter(mapper.map_normalize("\u{200C}".chars())),
         "\u{200C}"
     );
     assert_eq!(
-        mapper.map_normalize("\u{200D}".chars()).collect::<String>(),
+        String::from_iter(mapper.map_normalize("\u{200D}".chars())),
         "\u{200D}"
     );
-    assert_eq!(mapper.map_normalize("ß".chars()).collect::<String>(), "ß");
-    assert_eq!(mapper.map_normalize("ς".chars()).collect::<String>(), "ς");
+    assert_eq!(String::from_iter(mapper.map_normalize("ß".chars())), "ß");
+    assert_eq!(String::from_iter(mapper.map_normalize("ς".chars())), "ς");
 
     // Iota subscript
     assert_eq!(
-        mapper.map_normalize("\u{0345}".chars()).collect::<String>(),
+        String::from_iter(mapper.map_normalize("\u{0345}".chars())),
         "ι"
     );
 
     // Disallowed
     assert_eq!(
-        mapper.map_normalize("\u{061C}".chars()).collect::<String>(),
+        String::from_iter(mapper.map_normalize("\u{061C}".chars())),
         "\u{FFFD}"
     );
 
     // Ignored
     assert_eq!(
-        mapper
-            .map_normalize("a\u{180B}b".chars())
-            .collect::<String>(),
+        String::from_iter(mapper.map_normalize("a\u{180B}b".chars())),
         "ab"
     );
 }
@@ -165,102 +155,82 @@ fn test_uts46_map_normalize() {
 fn test_uts46_normalize_validate() {
     let mapper: Uts46Mapper = Uts46Mapper::new();
     assert_eq!(
-        mapper
-            .normalize_validate("a\u{0308}".chars())
-            .collect::<String>(),
+        String::from_iter(mapper.normalize_validate("a\u{0308}".chars())),
         "ä"
     );
     assert_eq!(
-        mapper
-            .normalize_validate("A\u{0308}".chars())
-            .collect::<String>(),
+        String::from_iter(mapper.normalize_validate("A\u{0308}".chars())),
         "ä"
     );
     assert_eq!(
-        mapper
-            .normalize_validate("e\u{0323}\u{0302}".chars())
-            .collect::<String>(),
+        String::from_iter(mapper.normalize_validate("e\u{0323}\u{0302}".chars())),
         "ệ"
     );
     assert_eq!(
-        mapper
-            .normalize_validate("E\u{0323}\u{0302}".chars())
-            .collect::<String>(),
+        String::from_iter(mapper.normalize_validate("E\u{0323}\u{0302}".chars())),
         "ệ"
     );
     assert_eq!(
-        mapper.normalize_validate("𝅗𝅥".chars()).collect::<String>(),
+        String::from_iter(mapper.normalize_validate("𝅗𝅥".chars())),
         "𝅗\u{1D165}"
     ); // Composition exclusion
 
     assert_eq!(
-        mapper
-            .normalize_validate("\u{2126}".chars())
-            .collect::<String>(),
+        String::from_iter(mapper.normalize_validate("\u{2126}".chars())),
         "ω"
     ); // ohm sign
     assert_eq!(
-        mapper.normalize_validate("ﾍﾞ".chars()).collect::<String>(),
+        String::from_iter(mapper.normalize_validate("ﾍﾞ".chars())),
         "ベ"
     ); // half-width to full-width, the compose
     assert_eq!(
-        mapper.normalize_validate("ﾍﾟ".chars()).collect::<String>(),
+        String::from_iter(mapper.normalize_validate("ﾍﾟ".chars())),
         "ペ"
     ); // half-width to full-width, the compose
     assert_eq!(
-        mapper.normalize_validate("fi".chars()).collect::<String>(),
+        String::from_iter(mapper.normalize_validate("fi".chars())),
         "fi"
     ); // ligature expanded
-    assert_eq!(mapper.normalize_validate("\u{FDFA}".chars()).collect::<String>(), "\u{0635}\u{0644}\u{0649} \u{0627}\u{0644}\u{0644}\u{0647} \u{0639}\u{0644}\u{064A}\u{0647} \u{0648}\u{0633}\u{0644}\u{0645}");
+    assert_eq!(String::from_iter(mapper.normalize_validate("\u{FDFA}".chars())), "\u{0635}\u{0644}\u{0649} \u{0627}\u{0644}\u{0644}\u{0647} \u{0639}\u{0644}\u{064A}\u{0647} \u{0648}\u{0633}\u{0644}\u{0645}");
     // ligature expanded
     assert_eq!(
-        mapper.normalize_validate("㈎".chars()).collect::<String>(),
+        String::from_iter(mapper.normalize_validate("㈎".chars())),
         "(가)"
     ); // parenthetical expanded and partially recomposed
 
     // Deviations (UTS 46, 6 Mapping Table Derivation, Step 4)
     assert_eq!(
-        mapper
-            .normalize_validate("\u{200C}".chars())
-            .collect::<String>(),
+        String::from_iter(mapper.normalize_validate("\u{200C}".chars())),
         "\u{200C}"
     );
     assert_eq!(
-        mapper
-            .normalize_validate("\u{200D}".chars())
-            .collect::<String>(),
+        String::from_iter(mapper.normalize_validate("\u{200D}".chars())),
         "\u{200D}"
     );
     assert_eq!(
-        mapper.normalize_validate("ß".chars()).collect::<String>(),
+        String::from_iter(mapper.normalize_validate("ß".chars())),
         "ß"
     );
     assert_eq!(
-        mapper.normalize_validate("ς".chars()).collect::<String>(),
+        String::from_iter(mapper.normalize_validate("ς".chars())),
         "ς"
     );
 
     // Iota subscript
     assert_eq!(
-        mapper
-            .normalize_validate("\u{0345}".chars())
-            .collect::<String>(),
+        String::from_iter(mapper.normalize_validate("\u{0345}".chars())),
         "ι"
     );
 
     // Disallowed
     assert_eq!(
-        mapper
-            .normalize_validate("\u{061C}".chars())
-            .collect::<String>(),
+        String::from_iter(mapper.normalize_validate("\u{061C}".chars())),
         "\u{FFFD}"
     );
 
     // Ignored
     assert_eq!(
-        mapper
-            .normalize_validate("a\u{180B}b".chars())
-            .collect::<String>(),
+        String::from_iter(mapper.normalize_validate("a\u{180B}b".chars())),
         "a\u{FFFD}b"
     );
 }
diff --git a/components/plurals/src/lib.rs b/components/plurals/src/lib.rs
index c1ff7d3a663..c203371aa4b 100644
--- a/components/plurals/src/lib.rs
+++ b/components/plurals/src/lib.rs
@@ -831,8 +831,8 @@ where
     ///     PluralRuleType::Cardinal,
     /// )
     /// .expect("locale should be present");
-    /// let operands: PluralOperands =
-    ///     "0.5".parse().expect("parsing to operands should succeed");
+    /// let operands =
+    ///     "0.5".parse::<PluralOperands>().expect("parsing to operands should succeed");
     /// let operands2 = PluralOperands::from(1_usize);
     ///
     /// assert_eq!(
diff --git a/components/plurals/tests/categories.rs b/components/plurals/tests/categories.rs
index a0cce60be36..655e2fa37ae 100644
--- a/components/plurals/tests/categories.rs
+++ b/components/plurals/tests/categories.rs
@@ -5,7 +5,7 @@
 mod fixtures;
 
 use icu_locid::LanguageIdentifier;
-use icu_plurals::{PluralCategory, PluralRules};
+use icu_plurals::PluralRules;
 use std::str::FromStr;
 
 #[test]
@@ -32,7 +32,7 @@ fn test_categories() {
             test.langid,
             test.plural_type,
             test.categories,
-            pr.categories().collect::<Vec<PluralCategory>>(),
+            Vec::from_iter(pr.categories()),
         );
 
         for (expected, actual) in test.categories.iter().zip(pr.categories()) {
@@ -47,7 +47,7 @@ fn test_categories() {
                 test.langid,
                 test.plural_type,
                 test.categories,
-                pr.categories().collect::<Vec<PluralCategory>>(),
+                Vec::from_iter(pr.categories()),
             );
         }
     }
diff --git a/components/properties/src/provider/names.rs b/components/properties/src/provider/names.rs
index 283b9692383..c647693a40d 100644
--- a/components/properties/src/provider/names.rs
+++ b/components/properties/src/provider/names.rs
@@ -48,13 +48,11 @@ use zerovec::{maps::ZeroMapKV, VarZeroSlice, VarZeroVec, ZeroMap, ZeroVec};
 /// use icu::properties::provider::names::NormalizedPropertyNameStr;
 /// use zerovec::ZeroMap;
 ///
-/// let map: ZeroMap<NormalizedPropertyNameStr, usize> = [
+/// let map = ZeroMap::<NormalizedPropertyNameStr, usize>::from_iter([
 ///     (NormalizedPropertyNameStr::from_str("A_BC"), 11),
 ///     (NormalizedPropertyNameStr::from_str("dEf"), 22),
 ///     (NormalizedPropertyNameStr::from_str("G_H-I"), 33),
-/// ]
-/// .into_iter()
-/// .collect();
+/// ]);
 ///
 /// let key_approx = NormalizedPropertyNameStr::from_str("AB-C");
 /// let key_exact = NormalizedPropertyNameStr::from_str("A_BC");
diff --git a/components/properties/src/script.rs b/components/properties/src/script.rs
index db4c77ff229..0331b2b9153 100644
--- a/components/properties/src/script.rs
+++ b/components/properties/src/script.rs
@@ -207,9 +207,8 @@ impl<'a> ScriptExtensionsSet<'a> {
     /// let swe = script::script_with_extensions();
     ///
     /// assert_eq!(
-    ///     swe.get_script_extensions_val('௫' as u32) // U+0BEB TAMIL DIGIT FIVE
-    ///         .iter()
-    ///         .collect::<Vec<Script>>(),
+    ///      // U+0BEB TAMIL DIGIT FIVE
+    ///     Vec::from_iter(swe.get_script_extensions_val('௫' as u32).iter()),
     ///     vec![Script::Tamil, Script::Grantha]
     /// );
     /// ```
@@ -370,28 +369,24 @@ impl<'a> ScriptWithExtensionsBorrowed<'a> {
     ///
     /// let swe = script::script_with_extensions();
     ///
+    /// // U+104D0 OSAGE CAPITAL LETTER KHA
     /// assert_eq!(
-    ///     swe.get_script_extensions_val('𐓐' as u32) // U+104D0 OSAGE CAPITAL LETTER KHA
-    ///         .iter()
-    ///         .collect::<Vec<Script>>(),
+    ///     Vec::from_iter(swe.get_script_extensions_val('𐓐' as u32).iter()),
     ///     vec![Script::Osage]
     /// );
+    /// // U+1F973 FACE WITH PARTY HORN AND PARTY HAT
     /// assert_eq!(
-    ///     swe.get_script_extensions_val('🥳' as u32) // U+1F973 FACE WITH PARTY HORN AND PARTY HAT
-    ///         .iter()
-    ///         .collect::<Vec<Script>>(),
+    ///     Vec::from_iter(swe.get_script_extensions_val('🥳' as u32).iter()),
     ///     vec![Script::Common]
     /// );
     /// assert_eq!(
-    ///     swe.get_script_extensions_val(0x200D) // ZERO WIDTH JOINER
-    ///         .iter()
-    ///         .collect::<Vec<Script>>(),
+    ///     // ZERO WIDTH JOINER
+    ///     Vec::from_iter(swe.get_script_extensions_val(0x200D).iter()),
     ///     vec![Script::Inherited]
     /// );
+    /// // U+0BEB TAMIL DIGIT FIVE
     /// assert_eq!(
-    ///     swe.get_script_extensions_val('௫' as u32) // U+0BEB TAMIL DIGIT FIVE
-    ///         .iter()
-    ///         .collect::<Vec<Script>>(),
+    ///     Vec::from_iter(swe.get_script_extensions_val('௫' as u32).iter()),
     ///     vec![Script::Tamil, Script::Grantha]
     /// );
     /// ```
@@ -581,26 +576,26 @@ impl ScriptWithExtensionsBorrowed<'static> {
 /// assert_eq!(swe.get_script_val(0xFDF2), Script::Arabic); // U+FDF2 ARABIC LIGATURE ALLAH ISOLATED FORM
 ///
 /// // get the `Script_Extensions` property value
+/// // U+0640 ARABIC TATWEEL
 /// assert_eq!(
-///     swe.get_script_extensions_val(0x0640) // U+0640 ARABIC TATWEEL
-///         .iter().collect::<Vec<Script>>(),
+///     Vec::from_iter(swe.get_script_extensions_val(0x0640).iter()),
 ///     vec![Script::Arabic, Script::Syriac, Script::Mandaic, Script::Manichaean,
 ///          Script::PsalterPahlavi, Script::Adlam, Script::HanifiRohingya, Script::Sogdian,
 ///          Script::OldUyghur]
 /// );
+/// // U+1F973 FACE WITH PARTY HORN AND PARTY HAT
 /// assert_eq!(
-///     swe.get_script_extensions_val('🥳' as u32) // U+1F973 FACE WITH PARTY HORN AND PARTY HAT
-///         .iter().collect::<Vec<Script>>(),
+///     Vec::from_iter(swe.get_script_extensions_val('🥳' as u32).iter()),
 ///     vec![Script::Common]
 /// );
 /// assert_eq!(
-///     swe.get_script_extensions_val(0x200D) // ZERO WIDTH JOINER
-///         .iter().collect::<Vec<Script>>(),
+///     // ZERO WIDTH JOINER
+///     Vec::from_iter(swe.get_script_extensions_val(0x200D).iter()),
 ///     vec![Script::Inherited]
 /// );
+/// // U+0BEB TAMIL DIGIT FIVE
 /// assert_eq!(
-///     swe.get_script_extensions_val('௫' as u32) // U+0BEB TAMIL DIGIT FIVE
-///         .iter().collect::<Vec<Script>>(),
+///     Vec::from_iter(swe.get_script_extensions_val('௫' as u32).iter()),
 ///     vec![Script::Tamil, Script::Grantha]
 /// );
 ///
diff --git a/components/segmenter/README.md b/components/segmenter/README.md
index 00a3aa79a20..c189dc4e7f4 100644
--- a/components/segmenter/README.md
+++ b/components/segmenter/README.md
@@ -31,9 +31,8 @@ use icu::segmenter::LineSegmenter;
 
 let segmenter = LineSegmenter::new_auto();
 
-let breakpoints: Vec<usize> = segmenter
-    .segment_str("Hello World. Xin chào thế giới!")
-    .collect();
+let breakpoints = Vec::from_iter(segmenter
+    .segment_str("Hello World. Xin chào thế giới!"));
 assert_eq!(&breakpoints, &[0, 6, 13, 17, 23, 29, 36]);
 ```
 
@@ -48,9 +47,8 @@ use icu::segmenter::GraphemeClusterSegmenter;
 
 let segmenter = GraphemeClusterSegmenter::new();
 
-let breakpoints: Vec<usize> = segmenter
-    .segment_str("Hello World. Xin chào thế giới!")
-    .collect();
+let breakpoints = Vec::from_iter(segmenter
+    .segment_str("Hello World. Xin chào thế giới!"));
 assert_eq!(
     &breakpoints,
     &[
@@ -71,9 +69,8 @@ use icu::segmenter::WordSegmenter;
 
 let segmenter = WordSegmenter::new_auto();
 
-let breakpoints: Vec<usize> = segmenter
-    .segment_str("Hello World. Xin chào thế giới!")
-    .collect();
+let breakpoints = Vec::from_iter(segmenter
+    .segment_str("Hello World. Xin chào thế giới!"));
 assert_eq!(
     &breakpoints,
     &[0, 5, 6, 11, 12, 13, 16, 17, 22, 23, 28, 29, 35, 36]
@@ -91,9 +88,8 @@ use icu::segmenter::SentenceSegmenter;
 
 let segmenter = SentenceSegmenter::new();
 
-let breakpoints: Vec<usize> = segmenter
-    .segment_str("Hello World. Xin chào thế giới!")
-    .collect();
+let breakpoints = Vec::from_iter(segmenter
+    .segment_str("Hello World. Xin chào thế giới!"));
 assert_eq!(&breakpoints, &[0, 13, 36]);
 ```
 
diff --git a/components/segmenter/src/complex/lstm/mod.rs b/components/segmenter/src/complex/lstm/mod.rs
index c6fcafec580..48b3e0b1fca 100644
--- a/components/segmenter/src/complex/lstm/mod.rs
+++ b/components/segmenter/src/complex/lstm/mod.rs
@@ -99,36 +99,28 @@ impl<'l> LstmSegmenter<'l> {
 
     // For unit testing as we cannot inspect the opaque type's bies
     fn segment_str_p(&'l self, input: &'l str) -> LstmSegmenterIterator<'l> {
-        let input_seq = if let Some(grapheme) = self.grapheme {
-            GraphemeClusterSegmenter::new_and_segment_str(input, grapheme)
-                .collect::<Vec<usize>>()
-                .windows(2)
-                .map(|chunk| {
-                    let range = if let [first, second, ..] = chunk {
-                        *first..*second
-                    } else {
-                        unreachable!()
-                    };
-                    let grapheme_cluster = if let Some(grapheme_cluster) = input.get(range) {
-                        grapheme_cluster
-                    } else {
-                        return self.dic.len() as u16;
-                    };
-
-                    self.dic
-                        .get_copied(UnvalidatedStr::from_str(grapheme_cluster))
-                        .unwrap_or_else(|| self.dic.len() as u16)
-                })
-                .collect()
+        let mut input_seq = Vec::new();
+
+        if let Some(grapheme) = self.grapheme {
+            let mut iter = GraphemeClusterSegmenter::new_and_segment_str(input, grapheme);
+
+            if let Some(mut prev) = iter.next() {
+                for curr in iter {
+                    input_seq.push(
+                        input
+                            .get(prev..curr)
+                            .and_then(|g| self.dic.get_copied(UnvalidatedStr::from_str(g)))
+                            .unwrap_or_else(|| self.dic.len() as u16),
+                    );
+                    prev = curr;
+                }
+            }
         } else {
-            input
-                .chars()
-                .map(|c| {
-                    self.dic
-                        .get_copied(UnvalidatedStr::from_str(c.encode_utf8(&mut [0; 4])))
-                        .unwrap_or_else(|| self.dic.len() as u16)
-                })
-                .collect()
+            input_seq.extend(input.chars().map(|c| {
+                self.dic
+                    .get_copied(UnvalidatedStr::from_str(c.encode_utf8(&mut [0; 4])))
+                    .unwrap_or_else(|| self.dic.len() as u16)
+            }));
         };
         LstmSegmenterIterator {
             input,
@@ -139,47 +131,52 @@ impl<'l> LstmSegmenter<'l> {
 
     /// Create an LSTM based break iterator for a UTF-16 string.
     pub(super) fn segment_utf16(&'l self, input: &[u16]) -> impl Iterator<Item = usize> + 'l {
-        let input_seq = if let Some(grapheme) = self.grapheme {
-            GraphemeClusterSegmenter::new_and_segment_utf16(input, grapheme)
-                .collect::<Vec<usize>>()
-                .windows(2)
-                .map(|chunk| {
-                    let range = if let [first, second, ..] = chunk {
-                        *first..*second
-                    } else {
-                        unreachable!()
-                    };
-                    let grapheme_cluster = if let Some(grapheme_cluster) = input.get(range) {
-                        grapheme_cluster
-                    } else {
-                        return self.dic.len() as u16;
-                    };
-
-                    self.dic
-                        .get_copied_by(|key| {
-                            key.as_bytes().iter().copied().cmp(
-                                decode_utf16(grapheme_cluster.iter().copied()).flat_map(|c| {
-                                    let mut buf = [0; 4];
-                                    let len = c
-                                        .unwrap_or(REPLACEMENT_CHARACTER)
-                                        .encode_utf8(&mut buf)
-                                        .len();
-                                    buf.into_iter().take(len)
-                                }),
-                            )
-                        })
-                        .unwrap_or_else(|| self.dic.len() as u16)
-                })
-                .collect()
+        let mut input_seq = Vec::new();
+        if let Some(grapheme) = self.grapheme {
+            let mut iter = GraphemeClusterSegmenter::new_and_segment_utf16(input, grapheme);
+
+            if let Some(mut prev) = iter.next() {
+                for curr in iter {
+                    input_seq.push(
+                        input
+                            .get(prev..curr)
+                            .and_then(|gc| {
+                                fn cmp_utf8_utf16(
+                                    utf8: impl Iterator<Item = u8>,
+                                    utf16: impl Iterator<Item = u16>,
+                                ) -> core::cmp::Ordering {
+                                    utf8.cmp(decode_utf16(utf16).flat_map(|c| {
+                                        let mut buf = [0; 4];
+                                        let len = c
+                                            .unwrap_or(char::REPLACEMENT_CHARACTER)
+                                            .encode_utf8(&mut buf)
+                                            .len();
+                                        buf.into_iter().take(len)
+                                    }))
+                                }
+
+                                self.dic.get_copied_by(|key| {
+                                    cmp_utf8_utf16(
+                                        key.as_bytes().iter().copied(),
+                                        gc.iter().copied(),
+                                    )
+                                })
+                            })
+                            .unwrap_or_else(|| self.dic.len() as u16),
+                    );
+                    prev = curr;
+                }
+            }
         } else {
-            decode_utf16(input.iter().copied())
-                .map(|c| c.unwrap_or(REPLACEMENT_CHARACTER))
-                .map(|c| {
-                    self.dic
-                        .get_copied(UnvalidatedStr::from_str(c.encode_utf8(&mut [0; 4])))
-                        .unwrap_or_else(|| self.dic.len() as u16)
-                })
-                .collect()
+            input_seq.extend(
+                decode_utf16(input.iter().copied())
+                    .map(|c| c.unwrap_or(REPLACEMENT_CHARACTER))
+                    .map(|c| {
+                        self.dic
+                            .get_copied(UnvalidatedStr::from_str(c.encode_utf8(&mut [0; 4])))
+                            .unwrap_or_else(|| self.dic.len() as u16)
+                    }),
+            )
         };
         LstmSegmenterIteratorUtf16 {
             bies: BiesIterator::new(self, input_seq),
@@ -373,11 +370,14 @@ mod tests {
 
         // Testing
         for test_case in &test_text.data.testcases {
-            let lstm_output = lstm
-                .segment_str_p(&test_case.unseg)
-                .bies
-                .map(|is_e| if is_e { 'e' } else { '?' })
-                .collect::<String>();
+            let lstm_output =
+                String::from_iter(lstm.segment_str_p(&test_case.unseg).bies.map(|is_e| {
+                    if is_e {
+                        'e'
+                    } else {
+                        '?'
+                    }
+                }));
             println!("Test case      : {}", test_case.unseg);
             println!("Expected bies  : {}", test_case.expected_bies);
             println!("Estimated bies : {lstm_output}");
diff --git a/components/segmenter/src/grapheme.rs b/components/segmenter/src/grapheme.rs
index e6cbcf64f08..e45f2f33dc5 100644
--- a/components/segmenter/src/grapheme.rs
+++ b/components/segmenter/src/grapheme.rs
@@ -67,7 +67,7 @@ pub type GraphemeClusterBreakIteratorUtf16<'l, 's> =
 /// use icu::segmenter::GraphemeClusterSegmenter;
 /// let segmenter = GraphemeClusterSegmenter::new();
 ///
-/// let breakpoints: Vec<usize> = segmenter.segment_str("Hello 🗺").collect();
+/// let breakpoints = Vec::from_iter(segmenter.segment_str("Hello 🗺"));
 /// // World Map (U+1F5FA) is encoded in four bytes in UTF-8.
 /// assert_eq!(&breakpoints, &[0, 1, 2, 3, 4, 5, 6, 10]);
 /// ```
@@ -78,8 +78,7 @@ pub type GraphemeClusterBreakIteratorUtf16<'l, 's> =
 /// use icu::segmenter::GraphemeClusterSegmenter;
 /// let segmenter = GraphemeClusterSegmenter::new();
 ///
-/// let breakpoints: Vec<usize> =
-///     segmenter.segment_latin1(b"Hello World").collect();
+/// let breakpoints = Vec::from_iter(segmenter.segment_latin1(b"Hello World"));
 /// assert_eq!(&breakpoints, &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]);
 /// ```
 ///
@@ -93,11 +92,11 @@ pub type GraphemeClusterBreakIteratorUtf16<'l, 's> =
 /// #     GraphemeClusterSegmenter::new();
 /// use itertools::Itertools;
 /// let text = "मांजर";
-/// let grapheme_clusters: Vec<&str> = segmenter
+/// let grapheme_clusters = Vec::from_iter(segmenter
 ///     .segment_str(text)
 ///     .tuple_windows()
 ///     .map(|(i, j)| &text[i..j])
-///     .collect();
+///     );
 /// assert_eq!(&grapheme_clusters, &["मां", "ज", "र"]);
 /// ```
 ///
@@ -123,7 +122,7 @@ pub type GraphemeClusterBreakIteratorUtf16<'l, 's> =
 /// // நி (TAMIL LETTER NA, TAMIL VOWEL SIGN I) is an extended grapheme cluster,
 /// // but not a legacy grapheme cluster.
 /// let ni = "நி";
-/// let egc_boundaries: Vec<usize> = segmenter.segment_str(ni).collect();
+/// let egc_boundaries = Vec::from_iter(segmenter.segment_str(ni));
 /// assert_eq!(&egc_boundaries, &[0, ni.len()]);
 /// ```
 #[derive(Debug)]
diff --git a/components/segmenter/src/lib.rs b/components/segmenter/src/lib.rs
index 63fc823377a..3ef1d43ae90 100644
--- a/components/segmenter/src/lib.rs
+++ b/components/segmenter/src/lib.rs
@@ -31,9 +31,8 @@
 //!
 //! let segmenter = LineSegmenter::new_auto();
 //!
-//! let breakpoints: Vec<usize> = segmenter
-//!     .segment_str("Hello World. Xin chào thế giới!")
-//!     .collect();
+//! let breakpoints = Vec::from_iter(segmenter
+//!     .segment_str("Hello World. Xin chào thế giới!"));
 //! assert_eq!(&breakpoints, &[0, 6, 13, 17, 23, 29, 36]);
 //! ```
 //!
@@ -48,9 +47,8 @@
 //!
 //! let segmenter = GraphemeClusterSegmenter::new();
 //!
-//! let breakpoints: Vec<usize> = segmenter
-//!     .segment_str("Hello World. Xin chào thế giới!")
-//!     .collect();
+//! let breakpoints = Vec::from_iter(segmenter
+//!     .segment_str("Hello World. Xin chào thế giới!"));
 //! assert_eq!(
 //!     &breakpoints,
 //!     &[
@@ -71,9 +69,8 @@
 //!
 //! let segmenter = WordSegmenter::new_auto();
 //!
-//! let breakpoints: Vec<usize> = segmenter
-//!     .segment_str("Hello World. Xin chào thế giới!")
-//!     .collect();
+//! let breakpoints = Vec::from_iter(segmenter
+//!     .segment_str("Hello World. Xin chào thế giới!"));
 //! assert_eq!(
 //!     &breakpoints,
 //!     &[0, 5, 6, 11, 12, 13, 16, 17, 22, 23, 28, 29, 35, 36]
@@ -91,9 +88,8 @@
 //!
 //! let segmenter = SentenceSegmenter::new();
 //!
-//! let breakpoints: Vec<usize> = segmenter
-//!     .segment_str("Hello World. Xin chào thế giới!")
-//!     .collect();
+//! let breakpoints = Vec::from_iter(segmenter
+//!     .segment_str("Hello World. Xin chào thế giới!"));
 //! assert_eq!(&breakpoints, &[0, 13, 36]);
 //! ```
 //!
diff --git a/components/segmenter/src/line.rs b/components/segmenter/src/line.rs
index 4dfc98a406a..eb2132f0f17 100644
--- a/components/segmenter/src/line.rs
+++ b/components/segmenter/src/line.rs
@@ -245,14 +245,14 @@ pub type LineBreakIteratorUtf16<'l, 's> = LineBreakIterator<'l, 's, LineBreakTyp
 /// # let segmenter = LineSegmenter::new_auto();
 /// #
 /// let text = "Summary\r\nThis annex…";
-/// let breakpoints: Vec<usize> = segmenter.segment_str(text).collect();
+/// let breakpoints = Vec::from_iter(segmenter.segment_str(text));
 /// // 9 and 22 are mandatory breaks, 14 is a line break opportunity.
 /// assert_eq!(&breakpoints, &[0, 9, 14, 22]);
 ///
 /// // There is a break opportunity between emoji, but not within the ZWJ sequence 🏳️‍🌈.
 /// let flag_equation = "🏳️➕🌈🟰🏳️\u{200D}🌈";
-/// let possible_first_lines: Vec<&str> =
-///     segmenter.segment_str(flag_equation).skip(1).map(|i| &flag_equation[..i]).collect();
+/// let possible_first_lines =
+///     Vec::from_iter(segmenter.segment_str(flag_equation).skip(1).map(|i| &flag_equation[..i]));
 /// assert_eq!(
 ///     &possible_first_lines,
 ///     &[
@@ -274,8 +274,8 @@ pub type LineBreakIteratorUtf16<'l, 's> = LineBreakIterator<'l, 's, LineBreakTyp
 ///
 /// let segmenter = LineSegmenter::new_auto();
 ///
-/// let breakpoints: Vec<usize> =
-///     segmenter.segment_str("Hello World").collect();
+/// let breakpoints =
+///     Vec::from_iter(segmenter.segment_str("Hello World"));
 /// assert_eq!(&breakpoints, &[0, 6, 11]);
 /// ```
 ///
@@ -293,8 +293,8 @@ pub type LineBreakIteratorUtf16<'l, 's> = LineBreakIterator<'l, 's, LineBreakTyp
 /// options.ja_zh = false;
 /// let segmenter = LineSegmenter::new_auto_with_options(options);
 ///
-/// let breakpoints: Vec<usize> =
-///     segmenter.segment_str("Hello World").collect();
+/// let breakpoints =
+///     Vec::from_iter(segmenter.segment_str("Hello World"));
 /// assert_eq!(&breakpoints, &[0, 1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);
 /// ```
 ///
@@ -305,8 +305,8 @@ pub type LineBreakIteratorUtf16<'l, 's> = LineBreakIterator<'l, 's, LineBreakTyp
 ///
 /// let segmenter = LineSegmenter::new_auto();
 ///
-/// let breakpoints: Vec<usize> =
-///     segmenter.segment_latin1(b"Hello World").collect();
+/// let breakpoints =
+///     Vec::from_iter(segmenter.segment_latin1(b"Hello World"));
 /// assert_eq!(&breakpoints, &[0, 6, 11]);
 /// ```
 ///
@@ -320,7 +320,7 @@ pub type LineBreakIteratorUtf16<'l, 's> = LineBreakIterator<'l, 's, LineBreakTyp
 /// #
 /// let text = "Summary\r\nThis annex…";
 ///
-/// let mandatory_breaks: Vec<usize> = segmenter
+/// let mandatory_breaks = Vec::from_iter(segmenter
 ///     .segment_str(text)
 ///     .into_iter()
 ///     .filter(|&i| {
@@ -334,7 +334,7 @@ pub type LineBreakIteratorUtf16<'l, 's> = LineBreakIterator<'l, 's, LineBreakTyp
 ///             ) || i == text.len()
 ///         })
 ///     })
-///     .collect();
+///     );
 /// assert_eq!(&mandatory_breaks, &[9, 22]);
 /// ```
 #[derive(Debug)]
diff --git a/components/segmenter/src/sentence.rs b/components/segmenter/src/sentence.rs
index e88dc771836..62bd7d80043 100644
--- a/components/segmenter/src/sentence.rs
+++ b/components/segmenter/src/sentence.rs
@@ -62,8 +62,8 @@ pub type SentenceBreakIteratorUtf16<'l, 's> = SentenceBreakIterator<'l, 's, Rule
 /// use icu::segmenter::SentenceSegmenter;
 /// let segmenter = SentenceSegmenter::new();
 ///
-/// let breakpoints: Vec<usize> =
-///     segmenter.segment_str("Hello World").collect();
+/// let breakpoints =
+///     Vec::from_iter(segmenter.segment_str("Hello World"));
 /// assert_eq!(&breakpoints, &[0, 11]);
 /// ```
 ///
@@ -73,8 +73,8 @@ pub type SentenceBreakIteratorUtf16<'l, 's> = SentenceBreakIterator<'l, 's, Rule
 /// use icu::segmenter::SentenceSegmenter;
 /// let segmenter = SentenceSegmenter::new();
 ///
-/// let breakpoints: Vec<usize> =
-///     segmenter.segment_latin1(b"Hello World").collect();
+/// let breakpoints =
+///     Vec::from_iter(segmenter.segment_latin1(b"Hello World"));
 /// assert_eq!(&breakpoints, &[0, 11]);
 /// ```
 ///
@@ -87,11 +87,11 @@ pub type SentenceBreakIteratorUtf16<'l, 's> = SentenceBreakIterator<'l, 's, Rule
 /// # let segmenter = SentenceSegmenter::new();
 /// use itertools::Itertools;
 /// let text = "Ceci tuera cela. Le livre tuera l’édifice.";
-/// let sentences: Vec<&str> = segmenter
+/// let sentences = Vec::from_iter(segmenter
 ///     .segment_str(text)
 ///     .tuple_windows()
 ///     .map(|(i, j)| &text[i..j])
-///     .collect();
+///     );
 /// assert_eq!(
 ///     &sentences,
 ///     &["Ceci tuera cela. ", "Le livre tuera l’édifice."]
@@ -215,6 +215,6 @@ impl SentenceSegmenter {
 #[test]
 fn empty_string() {
     let segmenter = SentenceSegmenter::new();
-    let breaks: Vec<usize> = segmenter.segment_str("").collect();
+    let breaks = Vec::from_iter(segmenter.segment_str(""));
     assert_eq!(breaks, [0]);
 }
diff --git a/components/segmenter/src/word.rs b/components/segmenter/src/word.rs
index 193ddc7e96d..2c7b1fdfca8 100644
--- a/components/segmenter/src/word.rs
+++ b/components/segmenter/src/word.rs
@@ -110,8 +110,8 @@ pub type WordBreakIteratorUtf16<'l, 's> = WordBreakIterator<'l, 's, WordBreakTyp
 /// use icu::segmenter::WordSegmenter;
 /// let segmenter = WordSegmenter::new_auto();
 ///
-/// let breakpoints: Vec<usize> =
-///     segmenter.segment_str("Hello World").collect();
+/// let breakpoints =
+///     Vec::from_iter(segmenter.segment_str("Hello World"));
 /// assert_eq!(&breakpoints, &[0, 5, 6, 11]);
 /// ```
 ///
@@ -121,8 +121,8 @@ pub type WordBreakIteratorUtf16<'l, 's> = WordBreakIterator<'l, 's, WordBreakTyp
 /// use icu::segmenter::WordSegmenter;
 /// let segmenter = WordSegmenter::new_auto();
 ///
-/// let breakpoints: Vec<usize> =
-///     segmenter.segment_latin1(b"Hello World").collect();
+/// let breakpoints =
+///     Vec::from_iter(segmenter.segment_latin1(b"Hello World"));
 /// assert_eq!(&breakpoints, &[0, 5, 6, 11]);
 /// ```
 ///
@@ -135,11 +135,11 @@ pub type WordBreakIteratorUtf16<'l, 's> = WordBreakIterator<'l, 's, WordBreakTyp
 /// # let segmenter = WordSegmenter::new_auto();
 /// use itertools::Itertools;
 /// let text = "Mark’d ye his words?";
-/// let segments: Vec<&str> = segmenter
+/// let segments = Vec::from_iter(segmenter
 ///     .segment_str(text)
 ///     .tuple_windows()
 ///     .map(|(i, j)| &text[i..j])
-///     .collect();
+///     );
 /// assert_eq!(
 ///     &segments,
 ///     &["Mark’d", " ", "ye", " ", "his", " ", "words", "?"]
@@ -156,13 +156,13 @@ pub type WordBreakIteratorUtf16<'l, 's> = WordBreakIterator<'l, 's, WordBreakTyp
 /// # use icu::segmenter::{WordType, WordSegmenter};
 /// # let segmenter = WordSegmenter::new_auto();
 /// # let text = "Mark’d ye his words?";
-/// let words: Vec<&str> = segmenter
+/// let words = Vec::from_iter(segmenter
 ///     .segment_str(text)
 ///     .iter_with_word_type()
 ///     .tuple_windows()
 ///     .filter(|(_, (_, segment_type))| segment_type.is_word_like())
 ///     .map(|((i, _), (j, _))| &text[i..j])
-///     .collect();
+///     );
 /// assert_eq!(&words, &["Mark’d", "ye", "his", "words"]);
 /// ```
 #[derive(Debug)]
@@ -194,8 +194,8 @@ impl WordSegmenter {
     ///
     /// let segmenter = WordSegmenter::new_auto();
     ///
-    /// let th_bps = segmenter.segment_str(th_str).collect::<Vec<_>>();
-    /// let ja_bps = segmenter.segment_str(ja_str).collect::<Vec<_>>();
+    /// let th_bps = Vec::from_iter(segmenter.segment_str(th_str));
+    /// let ja_bps = Vec::from_iter(segmenter.segment_str(ja_str));
     ///
     /// assert_eq!(th_bps, [0, 9, 18, 39]);
     /// assert_eq!(ja_bps, [0, 15, 21]);
@@ -267,8 +267,8 @@ impl WordSegmenter {
     ///
     /// let segmenter = WordSegmenter::new_lstm();
     ///
-    /// let th_bps = segmenter.segment_str(th_str).collect::<Vec<_>>();
-    /// let ja_bps = segmenter.segment_str(ja_str).collect::<Vec<_>>();
+    /// let th_bps = Vec::from_iter(segmenter.segment_str(th_str));
+    /// let ja_bps = Vec::from_iter(segmenter.segment_str(ja_str));
     ///
     /// assert_eq!(th_bps, [0, 9, 18, 39]);
     ///
@@ -338,8 +338,8 @@ impl WordSegmenter {
     ///
     /// let segmenter = WordSegmenter::new_dictionary();
     ///
-    /// let th_bps = segmenter.segment_str(th_str).collect::<Vec<_>>();
-    /// let ja_bps = segmenter.segment_str(ja_str).collect::<Vec<_>>();
+    /// let th_bps = Vec::from_iter(segmenter.segment_str(th_str));
+    /// let ja_bps = Vec::from_iter(segmenter.segment_str(ja_str));
     ///
     /// assert_eq!(th_bps, [0, 9, 18, 39]);
     /// assert_eq!(ja_bps, [0, 15, 21]);
@@ -613,6 +613,6 @@ impl<'l, 's> RuleBreakType<'l, 's> for WordBreakTypeUtf16 {
 #[test]
 fn empty_string() {
     let segmenter = WordSegmenter::new_auto();
-    let breaks: Vec<usize> = segmenter.segment_str("").collect();
+    let breaks = Vec::from_iter(segmenter.segment_str(""));
     assert_eq!(breaks, [0]);
 }
diff --git a/components/segmenter/tests/complex_word.rs b/components/segmenter/tests/complex_word.rs
index c518f91ba66..2e938c51c60 100644
--- a/components/segmenter/tests/complex_word.rs
+++ b/components/segmenter/tests/complex_word.rs
@@ -14,13 +14,13 @@ fn word_break_th() {
         let utf16: Vec<u16> = s.encode_utf16().collect();
         let iter = segmenter.segment_utf16(&utf16);
         assert_eq!(
-            iter.collect::<Vec<usize>>(),
+            Vec::from_iter(iter),
             vec![0, 4, 7, 11, 14],
             "word segmenter with Thai"
         );
         let iter = segmenter.segment_str(s);
         assert_eq!(
-            iter.collect::<Vec<usize>>(),
+            Vec::from_iter(iter),
             vec![0, 12, 21, 33, 42],
             "word segmenter with Thai"
         );
@@ -30,7 +30,7 @@ fn word_break_th() {
         let utf16: Vec<u16> = s.encode_utf16().collect();
         let iter = segmenter.segment_utf16(&utf16);
         assert_eq!(
-            iter.collect::<Vec<usize>>(),
+            Vec::from_iter(iter),
             vec![0, 1, 5, 8, 12, 15, 16],
             "word segmenter with Thai and ascii"
         );
@@ -45,7 +45,7 @@ fn word_break_my() {
     let utf16: Vec<u16> = s.encode_utf16().collect();
     let iter = segmenter.segment_utf16(&utf16);
     assert_eq!(
-        iter.collect::<Vec<usize>>(),
+        Vec::from_iter(iter),
         vec![0, 8, 16, 22, 24],
         "word segmenter with Burmese"
     );
@@ -57,7 +57,7 @@ fn word_break_hiragana() {
         let s = "うなぎうなじ";
         let iter = segmenter.segment_str(s);
         assert_eq!(
-            iter.collect::<Vec<usize>>(),
+            Vec::from_iter(iter),
             vec![0, 9, 18],
             "word segmenter with Hiragana"
         );
@@ -70,7 +70,7 @@ fn word_break_mixed_han() {
         let s = "Welcome龟山岛龟山岛Welcome";
         let iter = segmenter.segment_str(s);
         assert_eq!(
-            iter.collect::<Vec<usize>>(),
+            Vec::from_iter(iter),
             vec![0, 7, 16, 25, 32],
             "word segmenter with Chinese and letter"
         );
@@ -89,7 +89,7 @@ fn word_line_th_wikipedia_auto() {
     let segmenter_word_auto = WordSegmenter::new_auto();
     let segmenter_line_auto = LineSegmenter::new_auto();
 
-    let breakpoints_word_utf8 = segmenter_word_auto.segment_str(text).collect::<Vec<_>>();
+    let breakpoints_word_utf8 = Vec::from_iter(segmenter_word_auto.segment_str(text));
     assert_eq!(
         breakpoints_word_utf8,
         [
@@ -99,7 +99,7 @@ fn word_line_th_wikipedia_auto() {
         ]
     );
 
-    let breakpoints_line_utf8 = segmenter_line_auto.segment_str(text).collect::<Vec<_>>();
+    let breakpoints_line_utf8 = Vec::from_iter(segmenter_line_auto.segment_str(text));
     assert_eq!(
         breakpoints_line_utf8,
         [
@@ -108,9 +108,7 @@ fn word_line_th_wikipedia_auto() {
         ]
     );
 
-    let breakpoints_word_utf16 = segmenter_word_auto
-        .segment_utf16(&utf16)
-        .collect::<Vec<_>>();
+    let breakpoints_word_utf16 = Vec::from_iter(segmenter_word_auto.segment_utf16(&utf16));
     assert_eq!(
         breakpoints_word_utf16,
         [
@@ -120,9 +118,7 @@ fn word_line_th_wikipedia_auto() {
         ]
     );
 
-    let breakpoints_word_utf16 = segmenter_word_auto
-        .segment_utf16(&utf16)
-        .collect::<Vec<_>>();
+    let breakpoints_word_utf16 = Vec::from_iter(segmenter_word_auto.segment_utf16(&utf16));
     assert_eq!(
         breakpoints_word_utf16,
         [
diff --git a/documents/process/style_guide.md b/documents/process/style_guide.md
index 045e3cdb437..dc3f04fac3c 100644
--- a/documents/process/style_guide.md
+++ b/documents/process/style_guide.md
@@ -1060,7 +1060,7 @@ However you can do more than just conversion types, and the [Unicode Segmentatio
 use unicode_segmentation::UnicodeSegmentation;
 
 // A vector of individual graphemes (true => extended).
-let graphemes = "a\r\nb🇷🇺🇸🇹".graphemes(true).collect::<Vec<&str>>();
+let graphemes = Vec::from_iter("a\r\nb🇷🇺🇸🇹".graphemes(true));
 
 // Print each word (according to Unicode).
 let s = "The quick (\"brown\") fox can't jump 32.3 feet, right?";
diff --git a/ffi/ecma402/src/list.rs b/ffi/ecma402/src/list.rs
index 3ff2ace41a2..a2c50b9946b 100644
--- a/ffi/ecma402/src/list.rs
+++ b/ffi/ecma402/src/list.rs
@@ -49,7 +49,7 @@ impl ecma402_traits::listformat::Format for ListFormat {
             }
         }
 
-        let values = list.into_iter().map(WriteableWrap).collect::<Vec<_>>();
+        let values = Vec::from_iter(list.into_iter().map(WriteableWrap));
         self.0.format(values.iter()).write_to(writer)
     }
 }
diff --git a/ffi/ecma402/src/pluralrules.rs b/ffi/ecma402/src/pluralrules.rs
index 101c0f5950a..fe9282f4d68 100644
--- a/ffi/ecma402/src/pluralrules.rs
+++ b/ffi/ecma402/src/pluralrules.rs
@@ -102,7 +102,7 @@ pub(crate) mod internal {
             // Take at most the number of fraction digits we're required to display.
             .take(display_fraction_digits);
         // "001234.500"
-        let nstr = i.chain(dd).chain(f).collect::<String>();
+        let nstr = String::from_iter(i.chain(dd).chain(f));
         dbg!("nstr={}", &nstr);
         nstr
     }
@@ -310,14 +310,11 @@ mod testing {
         for (i, test) in tests.into_iter().enumerate() {
             let plr = super::PluralRules::try_new(test.locale, test.opts)?;
             assert_eq!(
-                test.numbers
-                    .iter()
-                    .map(|n| {
-                        let mut result = String::new();
-                        plr.select(*n, &mut result).unwrap();
-                        result
-                    })
-                    .collect::<Vec<_>>(),
+                Vec::from_iter(test.numbers.iter().map(|n| {
+                    let mut result = String::new();
+                    plr.select(*n, &mut result).unwrap();
+                    result
+                })),
                 test.expected,
                 "for test case: {}",
                 i
diff --git a/provider/adapters/src/fallback/mod.rs b/provider/adapters/src/fallback/mod.rs
index c07ac2ca9d1..cb7d5398d98 100644
--- a/provider/adapters/src/fallback/mod.rs
+++ b/provider/adapters/src/fallback/mod.rs
@@ -151,8 +151,7 @@ impl<P> LocaleFallbackProvider<P> {
     /// );
     ///
     /// // Now we can load the "de-CH" data via fallback to "de".
-    /// let german_hello_world: DataPayload<HelloWorldV1Marker> = provider
-    ///     .load(req)
+    /// let german_hello_world = DataProvider::<HelloWorldV1Marker>::load(&provider ,req)
     ///     .expect("Loading should succeed")
     ///     .take_payload()
     ///     .expect("Data should be present");
diff --git a/provider/adapters/src/filter/impls.rs b/provider/adapters/src/filter/impls.rs
index 4d3a699d746..5889c86e269 100644
--- a/provider/adapters/src/filter/impls.rs
+++ b/provider/adapters/src/filter/impls.rs
@@ -40,8 +40,7 @@ where
     ///     locale: &langid!("de").into(),
     ///     metadata: Default::default(),
     /// };
-    /// let response: Result<DataResponse<HelloWorldV1Marker>, _> =
-    ///     provider.load(req_de);
+    /// let response = DataProvider::<HelloWorldV1Marker>::load(&provider, req_de);
     /// assert!(matches!(response, Ok(_)));
     ///
     /// // English requests should fail:
@@ -49,8 +48,7 @@ where
     ///     locale: &langid!("en-US").into(),
     ///     metadata: Default::default(),
     /// };
-    /// let response: Result<DataResponse<HelloWorldV1Marker>, _> =
-    ///     provider.load(req_en);
+    /// let response = DataProvider::<HelloWorldV1Marker>::load(&provider, req_en);
     /// assert!(matches!(
     ///     response,
     ///     Err(DataError {
@@ -60,12 +58,11 @@ where
     /// ));
     ///
     /// // English should not appear in the iterator result:
-    /// let supported_langids = provider
+    /// let supported_langids = Vec::from_iter(provider
     ///     .supported_locales()
     ///     .expect("Should successfully make an iterator of supported locales")
     ///     .into_iter()
-    ///     .map(|options| options.get_langid())
-    ///     .collect::<Vec<LanguageIdentifier>>();
+    ///     .map(|options| options.get_langid()));
     /// assert!(supported_langids.contains(&langid!("de")));
     /// assert!(!supported_langids.contains(&langid!("en")));
     /// ```
@@ -116,8 +113,7 @@ where
     ///     locale: &langid!("de").into(),
     ///     metadata: Default::default(),
     /// };
-    /// let response: Result<DataResponse<HelloWorldV1Marker>, _> =
-    ///     provider.load(req_de);
+    /// let response = DataProvider::<HelloWorldV1Marker>::load(&provider, req_de);
     /// assert!(matches!(response, Ok(_)));
     ///
     /// // English requests should fail:
@@ -125,8 +121,7 @@ where
     ///     locale: &langid!("en-US").into(),
     ///     metadata: Default::default(),
     /// };
-    /// let response: Result<DataResponse<HelloWorldV1Marker>, _> =
-    ///     provider.load(req_en);
+    /// let response = DataProvider::<HelloWorldV1Marker>::load(&provider, req_en);
     /// assert!(matches!(
     ///     response,
     ///     Err(DataError {
@@ -178,8 +173,7 @@ where
     ///     locale: &langid!("de").into(),
     ///     metadata: Default::default(),
     /// };
-    /// let response: Result<DataResponse<HelloWorldV1Marker>, _> =
-    ///     provider.load(req_with_langid);
+    /// let response = DataProvider::<HelloWorldV1Marker>::load(&provider, req_with_langid);
     /// assert!(matches!(response, Ok(_)));
     ///
     /// // Requests without a langid should fail:
@@ -187,8 +181,7 @@ where
     ///     locale: Default::default(),
     ///     metadata: Default::default(),
     /// };
-    /// let response: Result<DataResponse<HelloWorldV1Marker>, _> =
-    ///     provider.load(req_no_langid);
+    /// let response = DataProvider::<HelloWorldV1Marker>::load(&provider, req_no_langid);
     /// assert!(matches!(
     ///     response,
     ///     Err(DataError {
diff --git a/provider/adapters/src/fork/mod.rs b/provider/adapters/src/fork/mod.rs
index 9019d820c3a..98234b7e063 100644
--- a/provider/adapters/src/fork/mod.rs
+++ b/provider/adapters/src/fork/mod.rs
@@ -82,8 +82,7 @@ use predicates::MissingDataKeyPredicate;
 ///
 /// let provider = forking_provider.as_deserializing();
 ///
-/// let german_hello_world: DataPayload<HelloWorldV1Marker> = provider
-///     .load(DataRequest {
+/// let german_hello_world = DataProvider::<HelloWorldV1Marker>::load(&provider, DataRequest {
 ///         locale: &langid!("de").into(),
 ///         metadata: Default::default(),
 ///     })
diff --git a/provider/adapters/src/fork/predicates.rs b/provider/adapters/src/fork/predicates.rs
index d1926ea6146..363a7f4bd40 100644
--- a/provider/adapters/src/fork/predicates.rs
+++ b/provider/adapters/src/fork/predicates.rs
@@ -88,9 +88,8 @@ impl ForkByErrorPredicate for MissingDataKeyPredicate {
 ///
 /// // Test that we can load both "de" and "ro" data:
 ///
-/// let german_hello_world: DataPayload<HelloWorldV1Marker> = provider
-///     .as_deserializing()
-///     .load(DataRequest {
+/// let german_hello_world = DataProvider::<HelloWorldV1Marker>::load(&provider.as_deserializing(),
+///     DataRequest {
 ///         locale: &langid!("de").into(),
 ///         metadata: Default::default(),
 ///     })
@@ -100,9 +99,8 @@ impl ForkByErrorPredicate for MissingDataKeyPredicate {
 ///
 /// assert_eq!("Hallo Welt", german_hello_world.get().message);
 ///
-/// let romanian_hello_world: DataPayload<HelloWorldV1Marker> = provider
-///     .as_deserializing()
-///     .load(DataRequest {
+/// let romanian_hello_world = DataProvider::<HelloWorldV1Marker>::load(&provider.as_deserializing(),
+///     DataRequest {
 ///         locale: &langid!("ro").into(),
 ///         metadata: Default::default(),
 ///     })
diff --git a/provider/blob/src/export/blob_exporter.rs b/provider/blob/src/export/blob_exporter.rs
index 7e469739c1b..0821a730e7c 100644
--- a/provider/blob/src/export/blob_exporter.rs
+++ b/provider/blob/src/export/blob_exporter.rs
@@ -166,25 +166,25 @@ impl BlobExporter<'_> {
         let FinalizedBuffers { vzv, remap } = self.finalize_buffers();
 
         // Now build up the ZeroMap2d, changing old ID to new ID
-        let mut zm = self
-            .resources
-            .get_mut()
-            .expect("poison")
-            .iter()
-            .flat_map(|(hash, sub_map)| {
-                sub_map
-                    .iter()
-                    .map(|(locale, old_id)| (*hash, locale, old_id))
-            })
-            .map(|(hash, locale, old_id)| {
-                (
-                    hash,
-                    Index32U8::parse_byte_slice(locale)
-                        .expect("[u8] to IndexU32U8 should never fail"),
-                    remap.get(old_id).expect("in-bound index"),
-                )
-            })
-            .collect::<ZeroMap2d<DataKeyHash, Index32U8, usize>>();
+        let mut zm = ZeroMap2d::<DataKeyHash, Index32U8, usize>::from_iter(
+            self.resources
+                .get_mut()
+                .expect("poison")
+                .iter()
+                .flat_map(|(hash, sub_map)| {
+                    sub_map
+                        .iter()
+                        .map(|(locale, old_id)| (*hash, locale, old_id))
+                })
+                .map(|(hash, locale, old_id)| {
+                    (
+                        hash,
+                        Index32U8::parse_byte_slice(locale)
+                            .expect("[u8] to IndexU32U8 should never fail"),
+                        remap.get(old_id).expect("in-bound index"),
+                    )
+                }),
+        );
 
         for key in self.all_keys.lock().expect("poison").iter() {
             if zm.get0(key).is_none() {
diff --git a/provider/blob/src/export/mod.rs b/provider/blob/src/export/mod.rs
index facc1edc05a..d212e52b560 100644
--- a/provider/blob/src/export/mod.rs
+++ b/provider/blob/src/export/mod.rs
@@ -14,7 +14,7 @@
 //! use icu_datagen::prelude::*;
 //! use icu_provider_blob::export::*;
 //!
-//! let mut blob: Vec<u8> = Vec::new();
+//! let mut blob = Vec::new();
 //!
 //! // Set up the exporter
 //! let mut exporter = BlobExporter::new_v2_with_sink(Box::new(&mut blob));
diff --git a/provider/core/macros/src/lib.rs b/provider/core/macros/src/lib.rs
index d1d2a1e69a0..8cbd1193c79 100644
--- a/provider/core/macros/src/lib.rs
+++ b/provider/core/macros/src/lib.rs
@@ -288,7 +288,7 @@ fn data_struct_impl(attr: DataStructArgs, input: DeriveInput) -> TokenStream2 {
         )
         .to_compile_error();
     }
-    let lifetimes = input.generics.lifetimes().collect::<Vec<_>>();
+    let lifetimes = Vec::from_iter(input.generics.lifetimes());
 
     let name = &input.ident;
 
diff --git a/provider/core/src/any.rs b/provider/core/src/any.rs
index 4d1255efb7a..5c9e233a852 100644
--- a/provider/core/src/any.rs
+++ b/provider/core/src/any.rs
@@ -145,8 +145,8 @@ impl AnyPayload {
     ///
     /// let any_payload = AnyPayload::from_static_ref(&HELLO_DATA);
     ///
-    /// let payload: DataPayload<HelloWorldV1Marker> =
-    ///     any_payload.downcast().expect("TypeId matches");
+    /// let payload =
+    ///     any_payload.downcast::<HelloWorldV1Marker>().expect("TypeId matches");
     /// assert_eq!("Custom Hello World", payload.get().message);
     /// ```
     pub fn from_static_ref<Y>(static_ref: &'static Y) -> Self
@@ -177,15 +177,15 @@ where
     /// use icu_provider::prelude::*;
     /// use std::borrow::Cow;
     ///
-    /// let payload: DataPayload<HelloWorldV1Marker> =
-    ///     DataPayload::from_owned(HelloWorldV1 {
+    /// let payload =
+    ///     DataPayload::<HelloWorldV1Marker>::from_owned(HelloWorldV1 {
     ///         message: Cow::Borrowed("Custom Hello World"),
     ///     });
     ///
     /// let any_payload = payload.wrap_into_any_payload();
     ///
-    /// let payload: DataPayload<HelloWorldV1Marker> =
-    ///     any_payload.downcast().expect("TypeId matches");
+    /// let payload =
+    ///     any_payload.downcast::<HelloWorldV1Marker>().expect("TypeId matches");
     /// assert_eq!("Custom Hello World", payload.get().message);
     /// ```
     pub fn wrap_into_any_payload(self) -> AnyPayload {
diff --git a/provider/core/src/datagen/payload.rs b/provider/core/src/datagen/payload.rs
index 97e540b0741..4c12b8e317d 100644
--- a/provider/core/src/datagen/payload.rs
+++ b/provider/core/src/datagen/payload.rs
@@ -107,11 +107,11 @@ impl DataPayload<ExportMarker> {
     /// use icu_provider::prelude::*;
     ///
     /// // Create an example DataPayload
-    /// let payload: DataPayload<HelloWorldV1Marker> = Default::default();
-    /// let export: DataPayload<ExportMarker> = UpcastDataPayload::upcast(payload);
+    /// let payload = DataPayload::<HelloWorldV1Marker>::default();
+    /// let export = ExportMarker::upcast(payload);
     ///
     /// // Serialize the payload to a JSON string
-    /// let mut buffer: Vec<u8> = vec![];
+    /// let mut buffer = Vec::new();
     /// export
     ///     .serialize(&mut serde_json::Serializer::new(&mut buffer))
     ///     .expect("Serialization should succeed");
@@ -141,8 +141,8 @@ impl DataPayload<ExportMarker> {
     /// # use std::collections::BTreeSet;
     ///
     /// // Create an example DataPayload
-    /// let payload: DataPayload<HelloWorldV1Marker> = Default::default();
-    /// let export: DataPayload<ExportMarker> = UpcastDataPayload::upcast(payload);
+    /// let payload = DataPayload::<HelloWorldV1Marker>::default();
+    /// let export = ExportMarker::upcast(payload);
     ///
     /// let env = databake::CrateEnv::default();
     /// let tokens = export.tokenize(&env);
@@ -156,10 +156,8 @@ impl DataPayload<ExportMarker> {
     ///     tokens.to_string()
     /// );
     /// assert_eq!(
-    ///     env.into_iter().collect::<BTreeSet<_>>(),
-    ///     ["icu_provider", "alloc"]
-    ///         .into_iter()
-    ///         .collect::<BTreeSet<_>>()
+    ///     BTreeSet::from_iter(env),
+    ///     BTreeSet::from_iter(["icu_provider", "alloc"]),
     /// );
     /// ```
     pub fn tokenize(&self, env: &CrateEnv) -> TokenStream {
diff --git a/provider/core/src/hello_world.rs b/provider/core/src/hello_world.rs
index 31762e621b2..cf678d9df0f 100644
--- a/provider/core/src/hello_world.rs
+++ b/provider/core/src/hello_world.rs
@@ -64,7 +64,7 @@ impl KeyedDataMarker for HelloWorldV1Marker {
 /// use icu_provider::hello_world::*;
 /// use icu_provider::prelude::*;
 ///
-/// let german_hello_world: DataPayload<HelloWorldV1Marker> =
+/// let german_hello_world =
 ///     HelloWorldProvider
 ///         .load(DataRequest {
 ///             locale: &langid!("de").into(),
@@ -83,7 +83,7 @@ impl KeyedDataMarker for HelloWorldV1Marker {
 /// use icu_provider::hello_world::*;
 /// use icu_provider::prelude::*;
 ///
-/// let reverse_hello_world: DataPayload<HelloWorldV1Marker> =
+/// let reverse_hello_world =
 ///     HelloWorldProvider
 ///         .load(DataRequest {
 ///             locale: &"en-x-reverse".parse().unwrap(),
diff --git a/provider/core/src/request.rs b/provider/core/src/request.rs
index 9714df01f60..60cfac4c8e7 100644
--- a/provider/core/src/request.rs
+++ b/provider/core/src/request.rs
@@ -285,7 +285,7 @@ impl DataLocale {
     ///     let a = ab[0];
     ///     let b = ab[1];
     ///     assert_eq!(a.cmp(b), Ordering::Less, "strings: {} < {}", a, b);
-    ///     let a_loc: DataLocale = a.parse().unwrap();
+    ///     let a_loc = a.parse::<DataLocale>().unwrap();
     ///     assert_eq!(
     ///         a_loc.strict_cmp(a.as_bytes()),
     ///         Ordering::Equal,
@@ -300,7 +300,7 @@ impl DataLocale {
     ///         a_loc,
     ///         b
     ///     );
-    ///     let b_loc: DataLocale = b.parse().unwrap();
+    ///     let b_loc = b.parse::<DataLocale>().unwrap();
     ///     assert_eq!(
     ///         b_loc.strict_cmp(b.as_bytes()),
     ///         Ordering::Equal,
@@ -323,7 +323,7 @@ impl DataLocale {
     /// ```
     /// use icu_provider::DataLocale;
     ///
-    /// let invalid_strings: &[&str] = &[
+    /// let invalid_strings = &[
     ///     // Less than "ca-ES"
     ///     "CA",
     ///     "ar-x-gbp-FOO",
@@ -493,7 +493,7 @@ impl DataLocale {
     /// };
     /// use icu_provider::prelude::*;
     ///
-    /// let locale: DataLocale = locale!("it-IT-u-ca-coptic").into();
+    /// let locale = "it-IT-u-ca-coptic".parse::<DataLocale>().unwrap();
     ///
     /// assert_eq!(locale.get_langid(), langid!("it-IT"));
     /// assert_eq!(locale.language(), language!("it"));
@@ -510,7 +510,7 @@ impl DataLocale {
     /// use icu_provider::prelude::*;
     /// use writeable::assert_writeable_eq;
     ///
-    /// let data_locale: DataLocale = "und-u-nu-arab-x-gbp".parse().unwrap();
+    /// let data_locale = "und-u-nu-arab-x-gbp".parse::<DataLocale>().unwrap();
     /// assert_writeable_eq!(data_locale, "und-u-nu-arab-x-gbp");
     ///
     /// let recovered_locale = data_locale.into_locale();
@@ -611,7 +611,7 @@ impl DataLocale {
     /// use icu_locid::extensions::unicode::{key, value};
     /// use icu_provider::prelude::*;
     ///
-    /// let locale: DataLocale = "it-IT-u-ca-coptic".parse().expect("Valid BCP-47");
+    /// let locale = "it-IT-u-ca-coptic".parse::<DataLocale>().expect("Valid BCP-47");
     ///
     /// assert_eq!(locale.get_unicode_ext(&key!("hc")), None);
     /// assert_eq!(locale.get_unicode_ext(&key!("ca")), Some(value!("coptic")));
@@ -683,7 +683,7 @@ impl DataLocale {
     /// use icu_provider::prelude::*;
     /// use writeable::assert_writeable_eq;
     ///
-    /// let mut data_locale: DataLocale = langid!("ar-EG").into();
+    /// let mut data_locale = DataLocale::from(langid!("ar-EG"));
     /// let aux = "gbp"
     ///     .parse::<AuxiliaryKeys>()
     ///     .expect("contains valid characters");
@@ -722,7 +722,7 @@ impl DataLocale {
 /// use icu_provider::prelude::*;
 /// use writeable::assert_writeable_eq;
 ///
-/// let mut data_locale: DataLocale = langid!("ar-EG").into();
+/// let mut data_locale = DataLocale::from(langid!("ar-EG"));
 /// assert_writeable_eq!(data_locale, "ar-EG");
 /// assert!(!data_locale.has_aux());
 /// assert_eq!(data_locale.get_aux(), None);
@@ -961,9 +961,9 @@ impl AuxiliaryKeys {
     /// use icu_locid::extensions::private::subtag;
     /// use icu_provider::AuxiliaryKeys;
     ///
-    /// let aux: AuxiliaryKeys = "abc-defg".parse().unwrap();
+    /// let aux = "abc-defg".parse::<AuxiliaryKeys>().unwrap();
     /// assert_eq!(
-    ///     aux.iter().collect::<Vec<_>>(),
+    ///     Vec::from_iter(aux.iter()),
     ///     vec![subtag!("abc"), subtag!("defg")]
     /// );
     /// ```
diff --git a/provider/core/src/response.rs b/provider/core/src/response.rs
index d673bd40796..8a9715f019a 100644
--- a/provider/core/src/response.rs
+++ b/provider/core/src/response.rs
@@ -89,7 +89,7 @@ pub struct DataPayload<M: DataMarker>(pub(crate) DataPayloadInner<M>);
 /// use icu_provider::prelude::*;
 /// use icu_provider::DataPayloadOr;
 ///
-/// let payload: DataPayload<HelloWorldV1Marker> = HelloWorldProvider
+/// let payload = HelloWorldProvider
 ///     .load(DataRequest {
 ///         locale: &"de".parse().unwrap(),
 ///         metadata: Default::default(),
@@ -715,8 +715,8 @@ where
     ///     type Yokeable = HelloWorldV1<'static>;
     /// }
     ///
-    /// let hello_world: DataPayload<HelloWorldV1Marker> = todo!();
-    /// let custom: DataPayload<CustomHelloWorldV1Marker> = hello_world.cast();
+    /// let hello_world = DataPayload::<HelloWorldV1Marker>::default();
+    /// let custom = hello_world.cast::<CustomHelloWorldV1Marker>();
     /// ```
     #[inline]
     pub fn cast<M2>(self) -> DataPayload<M2>
diff --git a/provider/core/src/serde/mod.rs b/provider/core/src/serde/mod.rs
index edd827c3121..78e9d55fe31 100644
--- a/provider/core/src/serde/mod.rs
+++ b/provider/core/src/serde/mod.rs
@@ -123,11 +123,11 @@ impl DataPayload<BufferMarker> {
     /// use icu_provider::hello_world::*;
     /// use icu_provider::prelude::*;
     ///
-    /// let buffer: &[u8] = br#"{"message":"Hallo Welt"}"#;
+    /// let buffer = br#"{"message":"Hallo Welt"}"#;
     ///
-    /// let buffer_payload = DataPayload::from_owned(buffer);
-    /// let payload: DataPayload<HelloWorldV1Marker> = buffer_payload
-    ///     .into_deserialized(BufferFormat::Json)
+    /// let buffer_payload = DataPayload::from_owned(buffer.as_slice());
+    /// let payload = buffer_payload
+    ///     .into_deserialized::<HelloWorldV1Marker>(BufferFormat::Json)
     ///     .expect("Deserialization successful");
     ///
     /// assert_eq!(payload.get().message, "Hallo Welt");
diff --git a/provider/datagen/src/baked_exporter.rs b/provider/datagen/src/baked_exporter.rs
index de235064926..ea53be26d25 100644
--- a/provider/datagen/src/baked_exporter.rs
+++ b/provider/datagen/src/baked_exporter.rs
@@ -104,14 +104,6 @@ use std::io::Write;
 use std::path::PathBuf;
 use std::sync::Mutex;
 
-macro_rules! move_out {
-    ($field:expr) => {{
-        let mut tmp = Default::default();
-        core::mem::swap(&mut tmp, &mut $field);
-        tmp
-    }};
-}
-
 // TokenStream isn't Send/Sync
 type SyncTokenStream = String;
 
@@ -273,9 +265,7 @@ impl BakedExporter {
     }
 
     fn print_deps(&mut self) {
-        let mut deps = move_out!(self.dependencies)
-            .into_iter()
-            .collect::<BTreeSet<_>>();
+        let mut deps = BTreeSet::from_iter(core::mem::take(&mut self.dependencies));
         if !self.use_separate_crates {
             deps.retain(|&krate| !krate.starts_with("icu_"));
             deps.insert("icu");
@@ -510,16 +500,13 @@ impl BakedExporter {
             for (bake, locales) in values {
                 let first_locale = locales.iter().next().unwrap();
                 let anchor = proc_macro2::Ident::new(
-                    &first_locale
-                        .chars()
-                        .map(|ch| {
-                            if ch == '-' {
-                                '_'
-                            } else {
-                                ch.to_ascii_uppercase()
-                            }
-                        })
-                        .collect::<String>(),
+                    &String::from_iter(first_locale.chars().map(|ch| {
+                        if ch == '-' {
+                            '_'
+                        } else {
+                            ch.to_ascii_uppercase()
+                        }
+                    })),
                     proc_macro2::Span::call_site(),
                 );
                 let bake = bake.parse::<TokenStream>().unwrap();
@@ -635,9 +622,11 @@ impl BakedExporter {
     fn close_internal(&mut self) -> Result<(), DataError> {
         log::info!("Writing macros module...");
 
-        let data = move_out!(self.impl_data).into_inner().expect("poison");
+        let data = core::mem::take(&mut self.impl_data)
+            .into_inner()
+            .expect("poison");
 
-        let features = data
+        let features = Vec::from_iter(data
             .iter()
             .map(|(key, marker)| {
                 if !self.insert_feature_gates {
@@ -656,13 +645,12 @@ impl BakedExporter {
                     let feature = marker.split(" :: ").next().unwrap();
                     quote! { #[cfg(feature = #feature)] }
                 }
-            })
-            .collect::<Vec<_>>();
+            }));
 
-        let markers = data
-            .values()
-            .map(|marker| marker.parse::<TokenStream>().unwrap())
-            .collect::<Vec<_>>();
+        let markers = Vec::from_iter(
+            data.values()
+                .map(|marker| marker.parse::<TokenStream>().unwrap()),
+        );
 
         let (
             macro_idents,
diff --git a/provider/datagen/src/driver.rs b/provider/datagen/src/driver.rs
index eb0f520d27a..5db8da830c2 100644
--- a/provider/datagen/src/driver.rs
+++ b/provider/datagen/src/driver.rs
@@ -705,10 +705,8 @@ impl DatagenDriver {
 
         let (uses_internal_fallback, deduplication_strategy) = match &locales_fallback {
             LocalesWithOrWithoutFallback::WithoutFallback { langids } => {
-                let mut sorted_locale_strs = langids
-                    .iter()
-                    .map(|x| x.write_to_string())
-                    .collect::<Vec<_>>();
+                let mut sorted_locale_strs =
+                    Vec::from_iter(langids.iter().map(|x| x.write_to_string()));
                 sorted_locale_strs.sort_unstable();
                 log::info!(
                     "Datagen configured without fallback with these locales: {:?}",
@@ -733,11 +731,12 @@ impl DatagenDriver {
                     }
                     Some(x) => x,
                 };
-                let mut sorted_locale_strs = families
-                    .iter()
-                    .map(LocaleFamilyBorrowed::from_parts)
-                    .map(|family| family.write_to_string().into_owned())
-                    .collect::<Vec<_>>();
+                let mut sorted_locale_strs = Vec::from_iter(
+                    families
+                        .iter()
+                        .map(LocaleFamilyBorrowed::from_parts)
+                        .map(|family| family.write_to_string().into_owned()),
+                );
                 sorted_locale_strs.sort_unstable();
                 log::info!(
                     "Datagen configured with {}, {}, and these locales: {:?}",
@@ -1057,14 +1056,12 @@ fn select_locales_for_key(
     let fallbacker_with_config = fallbacker.for_config(key.fallback_config());
 
     // The "candidate" langids that could be exported is the union of requested and supported.
-    let all_candidate_langids = supported_map
-        .keys()
-        .chain(requested_families.keys())
-        .collect::<HashSet<_>>();
+    let all_candidate_langids =
+        HashSet::<_>::from_iter(supported_map.keys().chain(requested_families.keys()));
 
     // Compute a map from LanguageIdentifiers to DataLocales, including inherited auxiliary keys
     // and extensions. Also resolve the ancestors and descendants while building this map.
-    let mut selected_langids = requested_families.keys().cloned().collect::<HashSet<_>>();
+    let mut selected_langids = HashSet::<_>::from_iter(requested_families.keys().cloned());
     let expansion_map: HashMap<&LanguageIdentifier, HashSet<DataLocale>> = all_candidate_langids
         .into_iter()
         .map(|current_langid| {
@@ -1300,26 +1297,22 @@ fn test_collation_filtering() {
         },
     ];
     for cas in cases {
-        let resolved_locales = select_locales_for_key(
-            &crate::provider::DatagenProvider::new_testing(),
-            icu_collator::provider::CollationDataV1Marker::KEY,
-            &LocalesWithOrWithoutFallback::WithoutFallback {
-                langids: [cas.language.clone()].into_iter().collect(),
-            },
-            &HashSet::from_iter(cas.include_collations.iter().copied().map(String::from)),
-            &[],
-            &once_cell::sync::Lazy::new(|| Ok(LocaleFallbacker::new_without_data())),
-        )
-        .unwrap()
-        .into_iter()
-        .map(|l| l.to_string())
-        .collect::<BTreeSet<_>>();
-        let expected_locales = cas
-            .expected
-            .iter()
-            .copied()
-            .map(String::from)
-            .collect::<BTreeSet<_>>();
+        let resolved_locales = BTreeSet::from_iter(
+            select_locales_for_key(
+                &crate::provider::DatagenProvider::new_testing(),
+                icu_collator::provider::CollationDataV1Marker::KEY,
+                &LocalesWithOrWithoutFallback::WithoutFallback {
+                    langids: [cas.language.clone()].into_iter().collect(),
+                },
+                &HashSet::<_>::from_iter(cas.include_collations.iter().copied().map(String::from)),
+                &[],
+                &once_cell::sync::Lazy::new(|| Ok(LocaleFallbacker::new_without_data())),
+            )
+            .unwrap()
+            .into_iter()
+            .map(|l| l.to_string()),
+        );
+        let expected_locales = BTreeSet::from_iter(cas.expected.iter().copied().map(String::from));
         assert_eq!(resolved_locales, expected_locales, "{cas:?}");
     }
 }
@@ -1345,11 +1338,9 @@ fn test_family_precedence() {
 
     assert_eq!(
         families,
-        [
+        HashMap::from_iter([
             "@en".parse::<LocaleFamily>().unwrap().into_parts(),
             "^zh-TW".parse::<LocaleFamily>().unwrap().into_parts()
-        ]
-        .into_iter()
-        .collect::<HashMap<_, _>>()
+        ])
     );
 }
diff --git a/provider/datagen/src/provider/source.rs b/provider/datagen/src/provider/source.rs
index e78d829f31a..f2d1dc9cf0f 100644
--- a/provider/datagen/src/provider/source.rs
+++ b/provider/datagen/src/provider/source.rs
@@ -222,30 +222,28 @@ impl AbstractFs {
             Self::Fs(root) => std::fs::read_dir(root.join(path))
                 .map_err(|e| DataError::from(e).with_display_context(path))?
                 .map(|e| -> Result<_, DataError> { Ok(e?.file_name().into_string().unwrap()) })
-                .collect::<Result<HashSet<_>, DataError>>()
-                .map(HashSet::into_iter)?,
-            Self::Zip(zip) => zip
-                .read()
-                .expect("poison")
-                .as_ref()
-                .ok()
-                .unwrap() // init called
-                .file_list
-                .iter()
-                .filter_map(|p| p.strip_prefix(path))
-                .filter_map(|suffix| suffix.split('/').find(|s| !s.is_empty()))
-                .map(String::from)
-                .collect::<HashSet<_>>()
-                .into_iter(),
-            Self::Memory(map) => map
-                .keys()
-                .copied()
-                .filter_map(|p| p.strip_prefix(path))
-                .filter_map(|suffix| suffix.split('/').find(|s| !s.is_empty()))
-                .map(String::from)
-                .collect::<HashSet<_>>()
-                .into_iter(),
-        })
+                .collect::<Result<HashSet<_>, DataError>>()?,
+            Self::Zip(zip) => HashSet::from_iter(
+                zip.read()
+                    .expect("poison")
+                    .as_ref()
+                    .ok()
+                    .unwrap() // init called
+                    .file_list
+                    .iter()
+                    .filter_map(|p| p.strip_prefix(path))
+                    .filter_map(|suffix| suffix.split('/').find(|s| !s.is_empty()))
+                    .map(String::from),
+            ),
+            Self::Memory(map) => HashSet::from_iter(
+                map.keys()
+                    .copied()
+                    .filter_map(|p| p.strip_prefix(path))
+                    .filter_map(|suffix| suffix.split('/').find(|s| !s.is_empty()))
+                    .map(String::from),
+            ),
+        }
+        .into_iter())
     }
 
     fn file_exists(&self, path: &str) -> Result<bool, DataError> {
diff --git a/provider/datagen/src/provider/tests/make_testdata.rs b/provider/datagen/src/provider/tests/make_testdata.rs
index d5839373ecb..19b9075bb2e 100644
--- a/provider/datagen/src/provider/tests/make_testdata.rs
+++ b/provider/datagen/src/provider/tests/make_testdata.rs
@@ -271,21 +271,15 @@ impl<F: Write + Send + Sync> DataExporter for PostcardTestingExporter<F> {
             &mut BTreeSet::default()
         );
 
-        let violations = self
-            .zero_copy_violations
-            .get_mut()
-            .expect("poison")
-            .iter()
-            .copied()
-            .collect::<Vec<_>>();
+        let violations = Vec::from_iter(core::mem::take(
+            self.zero_copy_violations.get_mut().expect("poison"),
+        ));
 
-        let transient_violations = self
-            .zero_copy_transient_violations
-            .get_mut()
-            .expect("poison")
-            .iter()
-            .copied()
-            .collect::<Vec<_>>();
+        let transient_violations = Vec::from_iter(core::mem::take(
+            self.zero_copy_transient_violations
+                .get_mut()
+                .expect("poison"),
+        ));
 
         assert!(transient_violations == EXPECTED_TRANSIENT_VIOLATIONS && violations == EXPECTED_VIOLATIONS,
             "Expected violations list does not match found violations!\n\
diff --git a/provider/datagen/src/transform/cldr/characters/mod.rs b/provider/datagen/src/transform/cldr/characters/mod.rs
index 726657411ab..5f37aef41e5 100644
--- a/provider/datagen/src/transform/cldr/characters/mod.rs
+++ b/provider/datagen/src/transform/cldr/characters/mod.rs
@@ -169,7 +169,7 @@ fn unescape_exemplar_chars(char_block: &str) -> String {
 
     // Workaround for literal values like "\\-" that cause problems for the TOML parser.
     // In such cases, remove the '\\' character preceding the non-Unicode-escape-sequence character.
-    let mut ch_vec = char_block.chars().collect::<Vec<char>>();
+    let mut ch_vec = Vec::from_iter(char_block.chars());
     let mut ch_indices_to_remove: Vec<usize> = vec![];
     for (idx, ch) in ch_vec.iter().enumerate().rev() {
         if ch == &'\\' {
@@ -182,7 +182,7 @@ fn unescape_exemplar_chars(char_block: &str) -> String {
     for idx in ch_indices_to_remove {
         ch_vec.remove(idx);
     }
-    let ch_for_toml = ch_vec.iter().collect::<String>();
+    let ch_for_toml = String::from_iter(ch_vec);
 
     // Workaround for double quotation mark literal values, which can appear in a string as a backslash followed
     // by the quotation mark itself (\"), but for the purposes of the TOML parser, should be escaped to be 2
@@ -222,10 +222,7 @@ fn unescape_exemplar_chars(char_block: &str) -> String {
 /// which could either be an individual code point or a code point sequence) into the set.
 fn insert_chars_from_string(set: &mut HashSet<String>, input: &str) {
     let s = if input.chars().count() > 1 && input.starts_with('\\') {
-        input
-            .chars()
-            .skip_while(|ch| ch == &'\\')
-            .collect::<String>()
+        String::from_iter(input.chars().skip_while(|ch| ch == &'\\'))
     } else {
         input.to_string()
     };
diff --git a/provider/datagen/src/transform/cldr/decimal/compact_decimal_pattern.rs b/provider/datagen/src/transform/cldr/decimal/compact_decimal_pattern.rs
index 028e3ae8a1d..a8cad126cb2 100644
--- a/provider/datagen/src/transform/cldr/decimal/compact_decimal_pattern.rs
+++ b/provider/datagen/src/transform/cldr/decimal/compact_decimal_pattern.rs
@@ -321,10 +321,11 @@ impl TryFrom<&DecimalFormat> for CompactDecimalPatternDataV1<'static> {
         {
             Err(format!(
                 "Compact decimal exponents should be nondecreasing: {:?}",
-                patterns
-                    .values()
-                    .map(|plural_map| plural_map.get(&Count::Other).map(|p| p.exponent))
-                    .collect::<Vec<_>>(),
+                Vec::from_iter(
+                    patterns
+                        .values()
+                        .map(|plural_map| plural_map.get(&Count::Other).map(|p| p.exponent))
+                ),
             ))?;
         }
         // Deduplicate sequences of types that have the same plural map (up to =1), keeping the lowest type.
diff --git a/provider/datagen/src/transform/cldr/locale_canonicalizer/aliases.rs b/provider/datagen/src/transform/cldr/locale_canonicalizer/aliases.rs
index 1fcfccd0014..fa9f3ade550 100644
--- a/provider/datagen/src/transform/cldr/locale_canonicalizer/aliases.rs
+++ b/provider/datagen/src/transform/cldr/locale_canonicalizer/aliases.rs
@@ -185,10 +185,11 @@ impl From<&cldr_serde::aliases::Resource> for AliasesV2<'_> {
             } else {
                 complex_region.insert(
                     from,
-                    to.replacement
-                        .split(' ')
-                        .filter_map(|r| r.parse::<subtags::Region>().ok())
-                        .collect::<Box<[_]>>(),
+                    Box::from_iter(
+                        to.replacement
+                            .split(' ')
+                            .filter_map(|r| r.parse::<subtags::Region>().ok()),
+                    ),
                 );
             }
         }
@@ -218,20 +219,18 @@ impl From<&cldr_serde::aliases::Resource> for AliasesV2<'_> {
         language_variants.sort_unstable_by_key(|(langid, _)| appendix_c_cmp(langid));
         language.sort_unstable_by_key(|(langid, _)| appendix_c_cmp(langid));
 
-        let language_variants = language_variants
-            .iter()
-            .map(|(from, to)| {
-                LanguageStrStrPair(
-                    from.language,
-                    from.variants.to_string().into(),
-                    to.to_string().into(),
-                )
-            })
-            .collect::<Vec<_>>();
-        let language = language
-            .iter()
-            .map(|(from, to)| StrStrPair(from.to_string().into(), to.to_string().into()))
-            .collect::<Vec<_>>();
+        let language_variants = Vec::from_iter(language_variants.iter().map(|(from, to)| {
+            LanguageStrStrPair(
+                from.language,
+                from.variants.to_string().into(),
+                to.to_string().into(),
+            )
+        }));
+        let language = Vec::from_iter(
+            language
+                .iter()
+                .map(|(from, to)| StrStrPair(from.to_string().into(), to.to_string().into())),
+        );
 
         Self {
             language_variants: language_variants.as_slice().into(),
diff --git a/provider/datagen/src/transform/cldr/source.rs b/provider/datagen/src/transform/cldr/source.rs
index 272d4613135..f60389444ed 100644
--- a/provider/datagen/src/transform/cldr/source.rs
+++ b/provider/datagen/src/transform/cldr/source.rs
@@ -87,7 +87,7 @@ impl CldrCache {
         &self,
         levels: impl IntoIterator<Item = CoverageLevel>,
     ) -> Result<Vec<icu_locid::LanguageIdentifier>, DataError> {
-        let levels = levels.into_iter().collect::<HashSet<_>>();
+        let levels = HashSet::<_>::from_iter(levels);
         Ok(self
             .serde_cache
             .read_and_parse_json::<crate::provider::transform::cldr::cldr_serde::coverage_levels::Resource>(
diff --git a/provider/datagen/src/transform/cldr/time_zones/convert.rs b/provider/datagen/src/transform/cldr/time_zones/convert.rs
index d5e74e69550..9889e0103f1 100644
--- a/provider/datagen/src/transform/cldr/time_zones/convert.rs
+++ b/provider/datagen/src/transform/cldr/time_zones/convert.rs
@@ -206,38 +206,42 @@ impl From<CldrTimeZonesData<'_>> for MetazonePeriodV1<'static> {
                         }
                         None => panic!("Cannot find bcp47 for {key:?}."),
                     },
-                    ZonePeriod::LocationOrSubRegion(place) => place
-                        .iter()
-                        .flat_map(move |(inner_key, location_or_subregion)| {
-                            let mut key = key.clone();
-                            key.push('/');
-                            key.push_str(inner_key);
-                            match location_or_subregion {
-                                MetaLocationOrSubRegion::Location(periods) => {
-                                    match bcp47_tzid_data.get(&key) {
-                                        Some(bcp47) => {
-                                            vec![(*bcp47, periods, meta_zone_id_data)]
-                                        }
-                                        None => panic!("Cannot find bcp47 for {key:?}."),
-                                    }
-                                }
-                                MetaLocationOrSubRegion::SubRegion(subregion) => subregion
-                                    .iter()
-                                    .flat_map(move |(inner_inner_key, periods)| {
-                                        let mut key = key.clone();
-                                        key.push('/');
-                                        key.push_str(inner_inner_key);
+                    ZonePeriod::LocationOrSubRegion(place) => {
+                        Vec::from_iter(place.iter().flat_map(
+                            move |(inner_key, location_or_subregion)| {
+                                let mut key = key.clone();
+                                key.push('/');
+                                key.push_str(inner_key);
+                                match location_or_subregion {
+                                    MetaLocationOrSubRegion::Location(periods) => {
                                         match bcp47_tzid_data.get(&key) {
                                             Some(bcp47) => {
                                                 vec![(*bcp47, periods, meta_zone_id_data)]
                                             }
                                             None => panic!("Cannot find bcp47 for {key:?}."),
                                         }
-                                    })
-                                    .collect::<Vec<_>>(),
-                            }
-                        })
-                        .collect::<Vec<_>>(),
+                                    }
+                                    MetaLocationOrSubRegion::SubRegion(subregion) => {
+                                        Vec::from_iter(subregion.iter().flat_map(
+                                            move |(inner_inner_key, periods)| {
+                                                let mut key = key.clone();
+                                                key.push('/');
+                                                key.push_str(inner_inner_key);
+                                                match bcp47_tzid_data.get(&key) {
+                                                    Some(bcp47) => {
+                                                        vec![(*bcp47, periods, meta_zone_id_data)]
+                                                    }
+                                                    None => {
+                                                        panic!("Cannot find bcp47 for {key:?}.")
+                                                    }
+                                                }
+                                            },
+                                        ))
+                                    }
+                                }
+                            },
+                        ))
+                    }
                 })
                 .flat_map(metazone_periods_iter)
                 .collect(),
@@ -309,7 +313,7 @@ macro_rules! long_short_impls {
                                                 None => panic!("Cannot find bcp47 for {key:?}."),
                                             }
                                         }
-                                        LocationOrSubRegion::SubRegion(region) => region
+                                        LocationOrSubRegion::SubRegion(region) => Vec::from_iter(region
                                             .iter()
                                             .filter_map(|(inner_key, place)| {
                                                 let mut key = key.clone();
@@ -324,8 +328,7 @@ macro_rules! long_short_impls {
                                                         panic!("Cannot find bcp47 for {key:?}.")
                                                     }
                                                 }
-                                            })
-                                            .collect::<Vec<_>>(),
+                                            })),
                                     }
                                 })
                         })
@@ -386,18 +389,17 @@ macro_rules! long_short_impls {
                                     match place_or_region {
                                         LocationOrSubRegion::Location(place) => {
                                             match bcp47_tzid_data.get(&key) {
-                                                Some(bcp47) => [place]
+                                                Some(bcp47) => Vec::from_iter([place]
                                                     .into_iter()
                                                     .filter_map(|inner_place| {
                                                         inner_place
                                                             .$metazones_name()
                                                             .map(|format| (bcp47.clone(), format))
-                                                    })
-                                                    .collect::<Vec<_>>(),
+                                                    })),
                                                 None => panic!("Cannot find bcp47 for {key:?}."),
                                             }
                                         }
-                                        LocationOrSubRegion::SubRegion(region) => region
+                                        LocationOrSubRegion::SubRegion(region) => Vec::from_iter(region
                                             .iter()
                                             .filter_map(|(inner_key, place)| {
                                                 let mut key = key.clone();
@@ -411,8 +413,7 @@ macro_rules! long_short_impls {
                                                         panic!("Cannot find bcp47 for {key:?}.")
                                                     }
                                                 }
-                                            })
-                                            .collect::<Vec<_>>(),
+                                            })),
                                     }
                                 })
                         })
diff --git a/provider/datagen/src/transform/icuexport/collator/mod.rs b/provider/datagen/src/transform/icuexport/collator/mod.rs
index 335744a380a..5fed31a104b 100644
--- a/provider/datagen/src/transform/icuexport/collator/mod.rs
+++ b/provider/datagen/src/transform/icuexport/collator/mod.rs
@@ -47,19 +47,19 @@ impl DataProvider<CollationFallbackSupplementV1Marker> for DatagenProvider {
             .map(|c| &c.non_likely_scripts)
             != Some(&String::from("root"))
         {
-            let collation_locales = self
-                .icuexport()?
-                .list(&format!("collation/{}", self.collation_han_database()))?
-                .filter_map(|s| {
-                    Some(
-                        file_name_to_locale(
-                            s.rsplit_once('_')?.0,
-                            self.has_legacy_swedish_variants(),
-                        )?
-                        .language(),
-                    )
-                })
-                .collect::<HashSet<_>>();
+            let collation_locales = HashSet::<_>::from_iter(
+                self.icuexport()?
+                    .list(&format!("collation/{}", self.collation_han_database()))?
+                    .filter_map(|s| {
+                        Some(
+                            file_name_to_locale(
+                                s.rsplit_once('_')?.0,
+                                self.has_legacy_swedish_variants(),
+                            )?
+                            .language(),
+                        )
+                    }),
+            );
 
             parent_locales
                 .parent_locale
@@ -113,7 +113,7 @@ impl DataProvider<CollationFallbackSupplementV1Marker> for DatagenProvider {
 
 impl IterableDataProviderInternal<CollationFallbackSupplementV1Marker> for DatagenProvider {
     fn supported_locales_impl(&self) -> Result<HashSet<DataLocale>, DataError> {
-        Ok(HashSet::from_iter([Default::default()]))
+        Ok(HashSet::<_>::from_iter([Default::default()]))
     }
 }
 
diff --git a/provider/datagen/src/transform/icuexport/uprops/script.rs b/provider/datagen/src/transform/icuexport/uprops/script.rs
index f81ea88bae7..7a93036ef82 100644
--- a/provider/datagen/src/transform/icuexport/uprops/script.rs
+++ b/provider/datagen/src/transform/icuexport/uprops/script.rs
@@ -44,10 +44,11 @@ impl DataProvider<ScriptWithExtensionsPropertyV1Marker> for DatagenProvider {
         // Convert the input from Vec<Vec<u16>> to Vec<ZeroVec<Script>> so that
         // we can go through the VarZeroVec construction process for a desired result
         // type of VZV<ZeroSlice<Script>>
-        let ule_scx_array_data: Vec<ZeroVec<Script>> = scx_array_data
-            .iter()
-            .map(|v| v.iter().map(|i| Script(*i)).collect::<ZeroVec<Script>>())
-            .collect::<Vec<ZeroVec<Script>>>();
+        let ule_scx_array_data = Vec::from_iter(
+            scx_array_data
+                .iter()
+                .map(|v| ZeroVec::<Script>::from_iter(v.iter().map(|i| Script(*i)))),
+        );
         let scx_vzv: VarZeroVec<ZeroSlice<Script>> =
             VarZeroVec::from(ule_scx_array_data.as_slice());
 
@@ -105,46 +106,39 @@ mod tests {
         let swe = swe.as_borrowed();
 
         assert_eq!(
-            swe.get_script_extensions_val('𐓐' as u32) /* U+104D0 OSAGE CAPITAL LETTER KHA */
-                .iter()
-                .collect::<Vec<Script>>(),
+            /* U+104D0 OSAGE CAPITAL LETTER KHA */
+            Vec::from_iter(swe.get_script_extensions_val('𐓐' as u32).iter()),
             vec![Script::Osage]
         );
+        /* U+1F973 FACE WITH PARTY HORN AND PARTY HAT */
         assert_eq!(
-            swe.get_script_extensions_val('🥳' as u32) /* U+1F973 FACE WITH PARTY HORN AND PARTY HAT */
-                .iter()
-                .collect::<Vec<Script>>(),
+            Vec::from_iter(swe.get_script_extensions_val('🥳' as u32).iter()),
             vec![Script::Common]
         );
         assert_eq!(
-            swe.get_script_extensions_val(0x200D) // ZERO WIDTH JOINER
-                .iter()
-                .collect::<Vec<Script>>(),
+            // ZERO WIDTH JOINER
+            Vec::from_iter(swe.get_script_extensions_val(0x200D).iter(),),
             vec![Script::Inherited]
         );
         assert_eq!(
-            swe.get_script_extensions_val('௫' as u32) // U+0BEB TAMIL DIGIT FIVE
-                .iter()
-                .collect::<Vec<Script>>(),
+            // U+0BEB TAMIL DIGIT FIVE
+            Vec::from_iter(swe.get_script_extensions_val('௫' as u32).iter(),),
             vec![Script::Tamil, Script::Grantha]
         );
         assert_eq!(
-            swe.get_script_extensions_val(0x11303) // GRANTHA SIGN VISARGA
-                .iter()
-                .collect::<Vec<Script>>(),
+            // GRANTHA SIGN VISARGA
+            Vec::from_iter(swe.get_script_extensions_val(0x11303).iter(),),
             vec![Script::Tamil, Script::Grantha]
         );
         assert_eq!(
-            swe.get_script_extensions_val(0x30A0) // KATAKANA-HIRAGANA DOUBLE HYPHEN
-                .iter()
-                .collect::<Vec<Script>>(),
+            // KATAKANA-HIRAGANA DOUBLE HYPHEN
+            Vec::from_iter(swe.get_script_extensions_val(0x30A0).iter()),
             vec![Script::Hiragana, Script::Katakana]
         );
 
+        // ZERO WIDTH JOINER
         assert_eq!(
-            swe.get_script_extensions_val(0x200D) // ZERO WIDTH JOINER
-                .iter()
-                .next(),
+            swe.get_script_extensions_val(0x200D).iter().next(),
             Some(Script::Inherited)
         );
 
@@ -158,9 +152,10 @@ mod tests {
 
         // // Invalid code point
         assert_eq!(
-            swe.get_script_extensions_val(0x11_0000) // CODE_POINT_MAX + 1 is invalid
-                .iter()
-                .collect::<Vec<Script>>(),
+            Vec::from_iter(
+                swe.get_script_extensions_val(0x11_0000) // CODE_POINT_MAX + 1 is invalid
+                    .iter()
+            ),
             vec![Script::Unknown]
         );
     }
diff --git a/provider/datagen/tests/test-options.rs b/provider/datagen/tests/test-options.rs
index 7302c0e8d58..bc73e15d7bf 100644
--- a/provider/datagen/tests/test-options.rs
+++ b/provider/datagen/tests/test-options.rs
@@ -223,7 +223,7 @@ fn all_preferred() {
     ];
 
     // Should return exactly the supported locales set.
-    assert_eq!(exported.keys().collect::<Vec<_>>(), locales);
+    assert_eq!(Vec::from_iter(exported.keys()), locales);
 }
 
 #[test]
@@ -272,7 +272,7 @@ fn all_hybrid() {
     ];
 
     // Should return exactly the supported locales set.
-    assert_eq!(exported.keys().collect::<Vec<_>>(), locales);
+    assert_eq!(Vec::from_iter(exported.keys()), locales);
 }
 
 #[test]
@@ -320,7 +320,7 @@ fn all_runtime() {
     ];
 
     // Should return the supported locales set with deduplication.
-    assert_eq!(exported.keys().collect::<Vec<_>>(), locales);
+    assert_eq!(Vec::from_iter(exported.keys()), locales);
 }
 
 #[test]
@@ -364,7 +364,7 @@ fn all_runtime_retain_base() {
     ];
 
     // Should return the supported locales set with deduplication.
-    assert_eq!(exported.keys().collect::<Vec<_>>(), locales);
+    assert_eq!(Vec::from_iter(exported.keys()), locales);
 }
 
 #[test]
@@ -413,7 +413,7 @@ fn explicit_preferred() {
     ];
 
     // Should return the expanded explicit locales set above.
-    assert_eq!(exported.keys().collect::<Vec<_>>(), locales);
+    assert_eq!(Vec::from_iter(exported.keys()), locales);
 }
 
 #[test]
@@ -466,7 +466,7 @@ fn explicit_hybrid() {
     ];
 
     // Should return the expanded explicit locales set above.
-    assert_eq!(exported.keys().collect::<Vec<_>>(), locales);
+    assert_eq!(Vec::from_iter(exported.keys()), locales);
 }
 
 #[test]
@@ -518,7 +518,7 @@ fn explicit_runtime() {
     ];
 
     // Should return the expanded then deduplicated explicit locales set above.
-    assert_eq!(exported.keys().collect::<Vec<_>>(), locales);
+    assert_eq!(Vec::from_iter(exported.keys()), locales);
 }
 
 #[test]
@@ -566,7 +566,7 @@ fn explicit_runtime_retain_base() {
     ];
 
     // Should return the expanded then deduplicated explicit locales set above.
-    assert_eq!(exported.keys().collect::<Vec<_>>(), locales);
+    assert_eq!(Vec::from_iter(exported.keys()), locales);
 }
 
 #[test]
@@ -605,7 +605,7 @@ fn explicit_preresolved() {
     ];
 
     // Should return the exact explicit locales set.
-    assert_eq!(exported.keys().collect::<Vec<_>>(), locales);
+    assert_eq!(Vec::from_iter(exported.keys()), locales);
 }
 
 #[test]
@@ -650,7 +650,7 @@ fn explicit_hybrid_without_descendants() {
     ];
 
     // Should return the exact explicit locales set.
-    assert_eq!(exported.keys().collect::<Vec<_>>(), locales);
+    assert_eq!(Vec::from_iter(exported.keys()), locales);
 }
 
 #[test]
@@ -695,7 +695,7 @@ fn explicit_hybrid_without_ancestors() {
     ];
 
     // Should return the exact explicit locales set.
-    assert_eq!(exported.keys().collect::<Vec<_>>(), locales);
+    assert_eq!(Vec::from_iter(exported.keys()), locales);
 }
 
 #[test]
@@ -740,7 +740,7 @@ fn explicit_hybrid_mixed_families() {
     ];
 
     // Should return the exact explicit locales set.
-    assert_eq!(exported.keys().collect::<Vec<_>>(), locales);
+    assert_eq!(Vec::from_iter(exported.keys()), locales);
 }
 
 #[test]
@@ -764,7 +764,7 @@ fn explicit_runtime_und() {
     let locales = ["und"];
 
     // Should return the exact explicit locales set.
-    assert_eq!(exported.keys().collect::<Vec<_>>(), locales);
+    assert_eq!(Vec::from_iter(exported.keys()), locales);
 }
 
 #[test]
@@ -784,7 +784,7 @@ fn explicit_runtime_und_retain_base() {
     let locales = ["und"];
 
     // Should return the exact explicit locales set.
-    assert_eq!(exported.keys().collect::<Vec<_>>(), locales);
+    assert_eq!(Vec::from_iter(exported.keys()), locales);
 }
 
 #[test]
@@ -808,7 +808,7 @@ fn explicit_hybrid_und() {
     let locales = ["und"];
 
     // Should return the exact explicit locales set.
-    assert_eq!(exported.keys().collect::<Vec<_>>(), locales);
+    assert_eq!(Vec::from_iter(exported.keys()), locales);
 }
 
 #[test]
@@ -828,7 +828,7 @@ fn explicit_preresolved_und() {
     let locales = ["und"];
 
     // Should return the exact explicit locales set.
-    assert_eq!(exported.keys().collect::<Vec<_>>(), locales);
+    assert_eq!(Vec::from_iter(exported.keys()), locales);
 }
 
 #[test]
@@ -852,7 +852,7 @@ fn explicit_runtime_empty() {
     let locales = ["und"];
 
     // Should return the exact explicit locales set.
-    assert_eq!(exported.keys().collect::<Vec<_>>(), locales);
+    assert_eq!(Vec::from_iter(exported.keys()), locales);
 }
 
 #[test]
@@ -872,7 +872,7 @@ fn explicit_runtime_empty_retain_base() {
     let locales = ["und"];
 
     // Should return the exact explicit locales set.
-    assert_eq!(exported.keys().collect::<Vec<_>>(), locales);
+    assert_eq!(Vec::from_iter(exported.keys()), locales);
 }
 
 #[test]
@@ -896,7 +896,7 @@ fn explicit_hybrid_empty() {
     let locales = ["und"];
 
     // Should return the exact explicit locales set.
-    assert_eq!(exported.keys().collect::<Vec<_>>(), locales);
+    assert_eq!(Vec::from_iter(exported.keys()), locales);
 }
 
 #[test]
@@ -916,5 +916,5 @@ fn explicit_preresolved_empty() {
     let locales: [&str; 0] = [];
 
     // Should return the exact explicit locales set.
-    assert_eq!(exported.keys().collect::<Vec<_>>(), locales);
+    assert_eq!(Vec::from_iter(exported.keys()), locales);
 }
diff --git a/tools/bakeddata-scripts/src/main.rs b/tools/bakeddata-scripts/src/main.rs
index e3ae524ba97..05259d90c85 100644
--- a/tools/bakeddata-scripts/src/main.rs
+++ b/tools/bakeddata-scripts/src/main.rs
@@ -44,10 +44,11 @@ fn main() {
     let args = std::env::args();
 
     let components = if args.len() == 1 {
-        COMPONENTS
-            .iter()
-            .map(|(krate, keys, version)| (krate.to_string(), *keys, *version))
-            .collect::<Vec<_>>()
+        Vec::from_iter(
+            COMPONENTS
+                .iter()
+                .map(|(krate, keys, version)| (krate.to_string(), *keys, *version)),
+        )
     } else {
         let map = std::collections::HashMap::<&str, (&'static [DataKey], &'static str)>::from_iter(
             COMPONENTS
diff --git a/tools/ffi_coverage/src/main.rs b/tools/ffi_coverage/src/main.rs
index 6cd2129f829..f52cc7e2bcf 100644
--- a/tools/ffi_coverage/src/main.rs
+++ b/tools/ffi_coverage/src/main.rs
@@ -42,38 +42,40 @@ impl fmt::Display for RustLinkInfo {
 
 fn main() {
     let out_path = std::env::args().nth(1);
-    let doc_types = ["icu", "fixed_decimal", "icu_provider_adapters"]
-        .into_iter()
-        .flat_map(collect_public_types)
-        .map(|(path_vec, typ)| {
-            let mut path = ast::Path::empty();
-            path.elements = path_vec.into_iter().map(ast::Ident::from).collect();
-            RustLinkInfo { path, typ }
-        })
-        .filter(|rl| {
-            ![
-                ast::DocType::EnumVariant,
-                ast::DocType::Mod,
-                ast::DocType::Trait,
-            ]
-            .contains(&rl.typ)
-        })
-        .collect::<BTreeSet<_>>();
+    let doc_types = BTreeSet::from_iter(
+        ["icu", "fixed_decimal", "icu_provider_adapters"]
+            .into_iter()
+            .flat_map(collect_public_types)
+            .map(|(path_vec, typ)| {
+                let mut path = ast::Path::empty();
+                path.elements = path_vec.into_iter().map(ast::Ident::from).collect();
+                RustLinkInfo { path, typ }
+            })
+            .filter(|rl| {
+                ![
+                    ast::DocType::EnumVariant,
+                    ast::DocType::Mod,
+                    ast::DocType::Trait,
+                ]
+                .contains(&rl.typ)
+            }),
+    );
 
     let capi_crate = PathBuf::from(concat!(
         std::env!("CARGO_MANIFEST_DIR"),
         "/../../ffi/capi/src/lib.rs"
     ));
     eprintln!("Loading icu_capi crate from {capi_crate:?}");
-    let capi_types = ast::File::from(&syn_inline_mod::parse_and_inline_modules(&capi_crate))
-        .all_rust_links()
-        .into_iter()
-        .cloned()
-        .map(|rl| RustLinkInfo {
-            path: rl.path,
-            typ: rl.typ,
-        })
-        .collect::<BTreeSet<_>>();
+    let capi_types = BTreeSet::from_iter(
+        ast::File::from(&syn_inline_mod::parse_and_inline_modules(&capi_crate))
+            .all_rust_links()
+            .into_iter()
+            .cloned()
+            .map(|rl| RustLinkInfo {
+                path: rl.path,
+                typ: rl.typ,
+            }),
+    );
 
     let mut file_anchor = None;
     let mut stdout_anchor = None;
diff --git a/tools/testdata-scripts/src/bin/download-repo-sources.rs b/tools/testdata-scripts/src/bin/download-repo-sources.rs
index 45c46741f29..2b2741d2d73 100644
--- a/tools/testdata-scripts/src/bin/download-repo-sources.rs
+++ b/tools/testdata-scripts/src/bin/download-repo-sources.rs
@@ -8,6 +8,7 @@ use icu_datagen::DatagenProvider;
 use icu_locid::*;
 use icu_provider::DataError;
 use simple_logger::SimpleLogger;
+use std::fmt::Write as _;
 use std::fs::{self, File};
 use std::io::{self, BufWriter, Cursor, Write};
 use std::path::PathBuf;
@@ -193,32 +194,39 @@ fn main() -> eyre::Result<()> {
         &mut Default::default(),
     )?;
 
-    let cldr_data = cldr_data
-        .iter()
-        .map(|path| {
-            let path = path.replace('\\', "/");
-            format!(r#"("{path}", include_bytes!("../../../tests/data/cldr/{path}").as_slice())"#)
-        })
-        .collect::<Vec<_>>()
-        .join(",\n                            ");
-    let icuexport_data = icuexport_data
-        .iter()
-        .map(|path| {
-            let path = path.replace('\\', "/");
-            format!(
-                r#"("{path}", include_bytes!("../../../tests/data/icuexport/{path}").as_slice())"#
-            )
-        })
-        .collect::<Vec<_>>()
-        .join(",\n                            ");
-    let lstm_data = LSTM_GLOB
-        .iter()
-        .map(|path| {
-            let path = path.replace('\\', "/");
-            format!(r#"("{path}", include_bytes!("../../../tests/data/lstm/{path}").as_slice())"#)
-        })
-        .collect::<Vec<_>>()
-        .join(",\n                            ");
+    let cldr_data = cldr_data.iter().fold(String::new(), |mut acc, path| {
+        if !acc.is_empty() {
+            acc.push_str(",\n                            ");
+        }
+        let path = path.replace('\\', "/");
+        let _ = write!(
+            &mut acc,
+            r#"("{path}", include_bytes!("../../../tests/data/cldr/{path}").as_slice())"#
+        );
+        acc
+    });
+    let icuexport_data = icuexport_data.iter().fold(String::new(), |mut acc, path| {
+        if !acc.is_empty() {
+            acc.push_str(",\n                            ");
+        }
+        let path = path.replace('\\', "/");
+        let _ = write!(
+            &mut acc,
+            r#"("{path}", include_bytes!("../../../tests/data/icuexport/{path}").as_slice())"#
+        );
+        acc
+    });
+    let lstm_data = LSTM_GLOB.iter().fold(String::new(), |mut acc, path| {
+        if !acc.is_empty() {
+            acc.push_str(",\n                            ");
+        }
+        let path = path.replace('\\', "/");
+        let _ = write!(
+            &mut acc,
+            r#"("{path}", include_bytes!("../../../tests/data/lstm/{path}").as_slice())"#
+        );
+        acc
+    });
 
     write!(&mut crlify::BufWriterWithLineEndingFix::new(File::create(out_root.join("src/provider/tests/data.rs")).unwrap()), "\
 // This file is part of ICU4X. For terms of use, please see the file
diff --git a/tools/testdata-scripts/src/bin/make-testdata-legacy.rs b/tools/testdata-scripts/src/bin/make-testdata-legacy.rs
index 46685caccf3..16d81e872aa 100644
--- a/tools/testdata-scripts/src/bin/make-testdata-legacy.rs
+++ b/tools/testdata-scripts/src/bin/make-testdata-legacy.rs
@@ -46,10 +46,11 @@ fn main() {
 
     icu_datagen::datagen(
         Some(LOCALES),
-        &icu_datagen::all_keys_with_experimental()
-            .into_iter()
-            .chain([icu_provider::hello_world::HelloWorldV1Marker::KEY])
-            .collect::<Vec<_>>(),
+        &Vec::from_iter(
+            icu_datagen::all_keys_with_experimental()
+                .into_iter()
+                .chain([icu_provider::hello_world::HelloWorldV1Marker::KEY]),
+        ),
         &source,
         vec![blob_out, mod_out],
     )
diff --git a/utils/databake/src/alloc.rs b/utils/databake/src/alloc.rs
index dcbb7f2e1b1..3da95bc5d2d 100644
--- a/utils/databake/src/alloc.rs
+++ b/utils/databake/src/alloc.rs
@@ -112,7 +112,7 @@ where
 {
     fn bake(&self, ctx: &CrateEnv) -> TokenStream {
         ctx.insert("std");
-        let mut data = self.iter().map(|d| d.bake(ctx)).collect::<Vec<_>>();
+        let mut data = Vec::from_iter(self.iter().map(|d| d.bake(ctx)));
         data.sort_unstable_by_key(|data| data.to_string());
         quote! {
             std::collections::HashSet::from([#(#data),*])
@@ -136,14 +136,11 @@ where
 {
     fn bake(&self, ctx: &CrateEnv) -> TokenStream {
         ctx.insert("std");
-        let mut data = self
-            .iter()
-            .map(|(k, v)| {
-                let k = k.bake(ctx);
-                let v = v.bake(ctx);
-                quote!((#k, #v))
-            })
-            .collect::<Vec<_>>();
+        let mut data = Vec::from_iter(self.iter().map(|(k, v)| {
+            let k = k.bake(ctx);
+            let v = v.bake(ctx);
+            quote!((#k, #v))
+        }));
         data.sort_unstable_by_key(|data| data.to_string());
         quote! {
             std::collections::HashMap::from([#(#data),*])
diff --git a/utils/databake/src/lib.rs b/utils/databake/src/lib.rs
index 624b0242734..18aafc97448 100644
--- a/utils/databake/src/lib.rs
+++ b/utils/databake/src/lib.rs
@@ -181,7 +181,7 @@ macro_rules! test_bake {
         assert_eq!(bake, expected_bake);
 
         #[allow(unused_variables)]
-        let _env = env.into_iter().collect::<std::collections::HashSet<_>>();
+        let _env = std::collections::HashSet::<_>::from_iter(env);
         $(
             assert!(_env.contains(stringify!($krate)), "Crate {:?} was not added to the CrateEnv", stringify!($krate));
         )?
diff --git a/utils/fixed_decimal/README.md b/utils/fixed_decimal/README.md
index 0da508e65cd..bd5e18c606a 100644
--- a/utils/fixed_decimal/README.md
+++ b/utils/fixed_decimal/README.md
@@ -19,10 +19,10 @@ assert_eq!("2.50", format!("{}", dec));
 #[derive(Debug, PartialEq)]
 struct MagnitudeAndDigit(i16, u8);
 
-let digits: Vec<MagnitudeAndDigit> = dec
+let digits = Vec::from_iter(dec
     .magnitude_range()
     .map(|m| MagnitudeAndDigit(m, dec.digit_at(m)))
-    .collect();
+);
 
 assert_eq!(
     vec![
diff --git a/utils/fixed_decimal/src/decimal.rs b/utils/fixed_decimal/src/decimal.rs
index 959bbf575b3..53d7c8e8aee 100644
--- a/utils/fixed_decimal/src/decimal.rs
+++ b/utils/fixed_decimal/src/decimal.rs
@@ -553,7 +553,7 @@ impl FixedDecimal {
     /// ```
     /// use fixed_decimal::FixedDecimal;
     ///
-    /// let dec: FixedDecimal = "012.340".parse().expect("valid syntax");
+    /// let dec = "012.340".parse::<FixedDecimal>().expect("valid syntax");
     /// assert_eq!(-3..=2, dec.magnitude_range());
     /// ```
     pub const fn magnitude_range(&self) -> RangeInclusive<i16> {
@@ -567,7 +567,7 @@ impl FixedDecimal {
     /// ```
     /// use fixed_decimal::FixedDecimal;
     ///
-    /// let dec: FixedDecimal = "012.340".parse().expect("valid syntax");
+    /// let dec = "012.340".parse::<FixedDecimal>().expect("valid syntax");
     /// assert_eq!(1, dec.nonzero_magnitude_start());
     ///
     /// assert_eq!(0, FixedDecimal::from(0).nonzero_magnitude_start());
@@ -583,7 +583,7 @@ impl FixedDecimal {
     /// ```
     /// use fixed_decimal::FixedDecimal;
     ///
-    /// let dec: FixedDecimal = "012.340".parse().expect("valid syntax");
+    /// let dec = "012.340".parse::<FixedDecimal>().expect("valid syntax");
     /// assert_eq!(-2, dec.nonzero_magnitude_end());
     ///
     /// assert_eq!(0, FixedDecimal::from(0).nonzero_magnitude_end());
@@ -603,7 +603,7 @@ impl FixedDecimal {
     /// ```
     /// use fixed_decimal::FixedDecimal;
     ///
-    /// let dec: FixedDecimal = "000.000".parse().expect("valid syntax");
+    /// let dec = "000.000".parse::<FixedDecimal>().expect("valid syntax");
     /// assert!(dec.is_zero());
     /// ```
     #[inline]
diff --git a/utils/fixed_decimal/src/lib.rs b/utils/fixed_decimal/src/lib.rs
index 4d96963e1a6..abb8562ad25 100644
--- a/utils/fixed_decimal/src/lib.rs
+++ b/utils/fixed_decimal/src/lib.rs
@@ -19,10 +19,10 @@
 //! #[derive(Debug, PartialEq)]
 //! struct MagnitudeAndDigit(i16, u8);
 //!
-//! let digits: Vec<MagnitudeAndDigit> = dec
+//! let digits = Vec::from_iter(dec
 //!     .magnitude_range()
 //!     .map(|m| MagnitudeAndDigit(m, dec.digit_at(m)))
-//!     .collect();
+//! );
 //!
 //! assert_eq!(
 //!     vec![
diff --git a/utils/litemap/src/databake.rs b/utils/litemap/src/databake.rs
index d42085b9c6f..2253bc2401b 100644
--- a/utils/litemap/src/databake.rs
+++ b/utils/litemap/src/databake.rs
@@ -23,15 +23,14 @@ use databake::*;
 /// use litemap::LiteMap;
 ///
 /// // Construct the LiteMap fully owned and allocated:
-/// let mut litemap_alloc: LiteMap<usize, String, Vec<_>> = LiteMap::new_vec();
+/// let mut litemap_alloc = LiteMap::<usize, String, Vec<_>>::new_vec();
 /// litemap_alloc.insert(1usize, "one".to_string());
 /// litemap_alloc.insert(2usize, "two".to_string());
 /// litemap_alloc.insert(10usize, "ten".to_string());
 ///
 /// // Convert to a borrowed type for baking:
-/// let litemap_str: LiteMap<usize, &str, Vec<_>> =
-///     litemap_alloc.to_borrowed_values();
-/// let litemap_slice: LiteMap<usize, &str, &[_]> = litemap_str.as_sliced();
+/// let litemap_str = litemap_alloc.to_borrowed_values::<str, Vec<_>>();
+/// let litemap_slice = litemap_str.as_sliced();
 ///
 /// // The bake will now work for const construction:
 /// let mut ctx = Default::default();
diff --git a/utils/litemap/src/map.rs b/utils/litemap/src/map.rs
index b5abd39b990..d6e4a488210 100644
--- a/utils/litemap/src/map.rs
+++ b/utils/litemap/src/map.rs
@@ -136,7 +136,7 @@ where
     /// ```
     /// use litemap::LiteMap;
     ///
-    /// let mut map: LiteMap<&str, &str> = LiteMap::new_vec();
+    /// let mut map = LiteMap::<&str, &str>::new_vec();
     /// map.insert("one", "uno");
     /// map.insert("two", "dos");
     ///
@@ -174,7 +174,7 @@ where
     /// ```
     /// use litemap::LiteMap;
     ///
-    /// let mut map: LiteMap<&str, usize> = LiteMap::new_vec();
+    /// let mut map = LiteMap::<&str, usize>::new_vec();
     /// map.insert("one", 11);
     /// map.insert("two", 22);
     ///
@@ -211,7 +211,7 @@ where
     /// ```
     /// use litemap::LiteMap;
     ///
-    /// let mut map: LiteMap<usize, &str> = LiteMap::new_vec();
+    /// let mut map = LiteMap::<usize, &str>::new_vec();
     /// map.insert(11, "uno");
     /// map.insert(22, "dos");
     ///
@@ -403,7 +403,7 @@ where
     /// ```
     /// use litemap::LiteMap;
     ///
-    /// let mut map: LiteMap<Box<usize>, String> = LiteMap::new_vec();
+    /// let mut map = LiteMap::<Box<usize>, String>::new_vec();
     /// map.insert(Box::new(1), "one".to_string());
     /// map.insert(Box::new(2), "two".to_string());
     ///
@@ -439,7 +439,7 @@ where
     /// ```
     /// use litemap::LiteMap;
     ///
-    /// let mut map: LiteMap<Box<usize>, String> = LiteMap::new_vec();
+    /// let mut map = LiteMap::<Box<usize>, String>::new_vec();
     /// map.insert(Box::new(1), "one".to_string());
     /// map.insert(Box::new(2), "two".to_string());
     ///
@@ -473,7 +473,7 @@ where
     /// ```
     /// use litemap::LiteMap;
     ///
-    /// let mut map: LiteMap<Box<usize>, String> = LiteMap::new_vec();
+    /// let mut map = LiteMap::<Box<usize>, String>::new_vec();
     /// map.insert(Box::new(1), "one".to_string());
     /// map.insert(Box::new(2), "two".to_string());
     ///
@@ -1167,22 +1167,21 @@ mod test {
 
     #[test]
     fn from_iterator() {
-        let mut expected = LiteMap::with_capacity(4);
-        expected.insert(1, "updated-one");
-        expected.insert(2, "original-two");
-        expected.insert(3, "original-three");
-        expected.insert(4, "updated-four");
+        let expected = LiteMap::<_, _>::from_iter([
+            (1, "updated-one"),
+            (2, "original-two"),
+            (3, "original-three"),
+            (4, "updated-four"),
+        ]);
 
-        let actual = [
+        let actual = LiteMap::from_iter([
             (1, "original-one"),
             (2, "original-two"),
             (4, "original-four"),
             (4, "updated-four"),
             (1, "updated-one"),
             (3, "original-three"),
-        ]
-        .into_iter()
-        .collect::<LiteMap<_, _>>();
+        ]);
 
         assert_eq!(expected, actual);
     }
diff --git a/utils/litemap/src/testing.rs b/utils/litemap/src/testing.rs
index f52646f54d5..b4c150cf13b 100644
--- a/utils/litemap/src/testing.rs
+++ b/utils/litemap/src/testing.rs
@@ -55,8 +55,8 @@ where
     S0: StoreIntoIterator<K, V>,
     S1: StoreIntoIterator<K, V>,
 {
-    let a_vec = a.lm_into_iter().collect::<Vec<_>>();
-    let b_vec = b.lm_into_iter().collect::<Vec<_>>();
+    let a_vec = Vec::from_iter(a.lm_into_iter());
+    let b_vec = Vec::from_iter(b.lm_into_iter());
     assert_eq!(a_vec, b_vec);
 }
 
diff --git a/utils/litemap/tests/rkyv.rs b/utils/litemap/tests/rkyv.rs
index 7ab1eb3f5f0..299c36d376c 100644
--- a/utils/litemap/tests/rkyv.rs
+++ b/utils/litemap/tests/rkyv.rs
@@ -41,10 +41,7 @@ type LiteMapOfStrings = LiteMap<String, String>;
 type TupleVecOfStrings = Vec<(String, String)>;
 
 fn generate() -> AlignedVec {
-    let map = DATA
-        .iter()
-        .map(|&(k, v)| (k.to_owned(), v.to_owned()))
-        .collect::<LiteMapOfStrings>();
+    let map = LiteMapOfStrings::from_iter(DATA.iter().map(|&(k, v)| (k.to_owned(), v.to_owned())));
 
     let mut serializer = AllocSerializer::<4096>::default();
     serializer
diff --git a/utils/pattern/src/frontend/mod.rs b/utils/pattern/src/frontend/mod.rs
index d39da9d6858..753749b9c8b 100644
--- a/utils/pattern/src/frontend/mod.rs
+++ b/utils/pattern/src/frontend/mod.rs
@@ -122,8 +122,8 @@ impl<Backend, Store> Pattern<Backend, Store> {
     /// // we call `.take_store()` and `.from_store_unchecked()` on patterns
     /// // with the same backend (`SinglePlaceholder`).
     /// let store = allocated_pattern.take_store();
-    /// let borrowed_pattern: Pattern<SinglePlaceholder, &str> =
-    ///     Pattern::from_store_unchecked(&store);
+    /// let borrowed_pattern =
+    ///     Pattern::<SinglePlaceholder, &str>::from_store_unchecked(&store);
     ///
     /// assert_writeable_eq!(borrowed_pattern.interpolate([5]), "5 days");
     /// ```
diff --git a/utils/pattern/src/lib.rs b/utils/pattern/src/lib.rs
index 9e4caf4f478..63893267bc8 100644
--- a/utils/pattern/src/lib.rs
+++ b/utils/pattern/src/lib.rs
@@ -142,9 +142,7 @@ pub type DoublePlaceholderPattern<Store> = Pattern<DoublePlaceholder, Store>;
 /// // Interpolate some values into the pattern:
 /// assert_try_writeable_eq!(
 ///     pattern.try_interpolate(
-///         [("person0", "Alice"), ("person1", "Bob")]
-///             .into_iter()
-///             .collect::<BTreeMap<&str, &str>>()
+///         BTreeMap::from_iter([("person0", "Alice"), ("person1", "Bob")])
 ///     ),
 ///     "Hello, Alice and Bob!"
 /// );
diff --git a/utils/pattern/src/multi_named.rs b/utils/pattern/src/multi_named.rs
index 6541c40878a..81205ec61f0 100644
--- a/utils/pattern/src/multi_named.rs
+++ b/utils/pattern/src/multi_named.rs
@@ -190,14 +190,12 @@ where
 /// use icu_pattern::Pattern;
 /// use std::collections::BTreeMap;
 ///
-/// let placeholder_value_map: BTreeMap<&str, &str> = [
+/// let placeholder_value_map = BTreeMap::from_iter([
 ///     ("num", "5"),
 ///     ("letter", "X"),
 ///     ("", "empty"),
 ///     ("unused", "unused"),
-/// ]
-/// .into_iter()
-/// .collect();
+/// ]);
 ///
 /// // Single placeholder:
 /// assert_eq!(
@@ -261,8 +259,8 @@ where
 /// use icu_pattern::Pattern;
 /// use std::collections::BTreeMap;
 ///
-/// let placeholder_value_map: BTreeMap<&str, &str> =
-///     [("num", "5"), ("letter", "X")].into_iter().collect();
+/// let placeholder_value_map =
+///     BTreeMap::from_iter([("num", "5"), ("letter", "X")]);
 ///
 /// Pattern::<MultiNamedPlaceholder, _>::from_str("Your name is {your_name}")
 ///     .unwrap()
@@ -281,8 +279,8 @@ where
 /// use std::collections::BTreeMap;
 /// use writeable::TryWriteable;
 ///
-/// let placeholder_value_map: BTreeMap<&str, &str> =
-///     [("num", "5"), ("letter", "X")].into_iter().collect();
+/// let placeholder_value_map =
+///     BTreeMap::from_iter([("num", "5"), ("letter", "X")]);
 ///
 /// let pattern = Pattern::<MultiNamedPlaceholder, _>::from_str(
 ///     "Your name is {your_name}",
diff --git a/utils/resb/examples/time_zone_rule.rs b/utils/resb/examples/time_zone_rule.rs
index 95a5d8646fd..1ba25ae865e 100644
--- a/utils/resb/examples/time_zone_rule.rs
+++ b/utils/resb/examples/time_zone_rule.rs
@@ -56,10 +56,9 @@ impl TryFrom<ZeroUTF16String<'_>> for String {
 
 impl Debug for ZeroUTF16String<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let decoded = char::decode_utf16(self.iter())
+        char::decode_utf16(self.iter())
             .map(|r| r.unwrap_or(char::REPLACEMENT_CHARACTER))
-            .collect::<String>();
-        write!(f, "{}", decoded)
+            .try_for_each(|c| write!(f, "{c}"))
     }
 }
 
diff --git a/utils/resb/src/binary/serializer.rs b/utils/resb/src/binary/serializer.rs
index 4b950e83af5..2fb841770f5 100644
--- a/utils/resb/src/binary/serializer.rs
+++ b/utils/resb/src/binary/serializer.rs
@@ -154,10 +154,11 @@ impl<'a> From<&'a Resource<'a>> for BinResourceData<'a> {
             }
             Resource::Table(table) => {
                 // Build resource data structs for each entry in the table.
-                let map = table
-                    .iter()
-                    .map(|(key, resource)| (key.clone(), BinResourceData::from(resource)))
-                    .collect::<BTreeMap<_, _>>();
+                let map = BTreeMap::from_iter(
+                    table
+                        .iter()
+                        .map(|(key, resource)| (key.clone(), BinResourceData::from(resource))),
+                );
 
                 Self::new(BinResourceTypeData::Table { map })
             }
@@ -437,7 +438,7 @@ impl Serializer {
 
         // Sort the strings such that any suffixes occur immediately after their
         // containing string.
-        let mut sorted_strings = strings.keys().cloned().collect::<Vec<_>>();
+        let mut sorted_strings = Vec::from_iter(strings.keys().cloned());
         sorted_strings.sort_unstable_by(cmp_string_descending_suffix_aware);
 
         // Locate strings which are suffixes of other strings and link them to
@@ -497,9 +498,7 @@ impl Serializer {
         // Ascending length order allows for the maximum number of strings to be
         // addressable by 16-bit offsets in cases where there are a large number
         // of strings.
-        let mut sorted_strings = strings
-            .iter()
-            .collect::<Vec<(&&str, &Rc<RefCell<StringResourceData>>)>>();
+        let mut sorted_strings = Vec::from_iter(strings.iter());
         sorted_strings.sort_unstable_by(cmp_string_ascending_suffix_aware);
 
         for (string, data) in sorted_strings {
diff --git a/utils/tinystr/src/ascii.rs b/utils/tinystr/src/ascii.rs
index 3a5e8c01e2d..febb91de6b5 100644
--- a/utils/tinystr/src/ascii.rs
+++ b/utils/tinystr/src/ascii.rs
@@ -728,17 +728,19 @@ mod test {
     fn gen_strings(num_strings: usize, allowed_lengths: &[usize]) -> Vec<String> {
         let mut rng = SmallRng::seed_from_u64(2022);
         // Need to do this in 2 steps since the RNG is needed twice
-        let string_lengths = core::iter::repeat_with(|| *allowed_lengths.choose(&mut rng).unwrap())
-            .take(num_strings)
-            .collect::<Vec<usize>>();
+        let string_lengths = Vec::from_iter(
+            core::iter::repeat_with(|| *allowed_lengths.choose(&mut rng).unwrap())
+                .take(num_strings),
+        );
         string_lengths
-            .iter()
+            .into_iter()
             .map(|len| {
-                Standard
-                    .sample_iter(&mut rng)
-                    .filter(|b: &u8| *b > 0 && *b < 0x80)
-                    .take(*len)
-                    .collect::<Vec<u8>>()
+                Vec::from_iter(
+                    Standard
+                        .sample_iter(&mut rng)
+                        .filter(|b: &u8| *b > 0 && *b < 0x80)
+                        .take(len),
+                )
             })
             .map(|byte_vec| String::from_utf8(byte_vec).expect("All ASCII"))
             .collect()
@@ -953,11 +955,7 @@ mod test {
     fn test_to_ascii_lowercase() {
         fn check<const N: usize>() {
             check_operation(
-                |s| {
-                    s.chars()
-                        .map(|c| c.to_ascii_lowercase())
-                        .collect::<String>()
-                },
+                |s| s.to_ascii_lowercase(),
                 |t: TinyAsciiStr<N>| TinyAsciiStr::to_ascii_lowercase(t).as_str().to_owned(),
             )
         }
@@ -974,10 +972,7 @@ mod test {
         fn check<const N: usize>() {
             check_operation(
                 |s| {
-                    let mut r = s
-                        .chars()
-                        .map(|c| c.to_ascii_lowercase())
-                        .collect::<String>();
+                    let mut r = s.to_ascii_lowercase();
                     // Safe because the string is nonempty and an ASCII string
                     unsafe { r.as_bytes_mut()[0].make_ascii_uppercase() };
                     r
@@ -997,11 +992,7 @@ mod test {
     fn test_to_ascii_uppercase() {
         fn check<const N: usize>() {
             check_operation(
-                |s| {
-                    s.chars()
-                        .map(|c| c.to_ascii_uppercase())
-                        .collect::<String>()
-                },
+                |s| s.to_ascii_uppercase(),
                 |t: TinyAsciiStr<N>| TinyAsciiStr::to_ascii_uppercase(t).as_str().to_owned(),
             )
         }
diff --git a/utils/tzif/src/parse/tzif.rs b/utils/tzif/src/parse/tzif.rs
index a8fd856daaa..5eb6ca05897 100644
--- a/utils/tzif/src/parse/tzif.rs
+++ b/utils/tzif/src/parse/tzif.rs
@@ -1047,18 +1047,8 @@ mod test {
         const ONE: &[u8] = 1i64.to_be_bytes().as_slice();
         const TWO: &[u8] = 2i64.to_be_bytes().as_slice();
         const SIX: &[u8] = 6i64.to_be_bytes().as_slice();
-        let ascending = ONE
-            .iter()
-            .chain(TWO)
-            .chain(SIX)
-            .copied()
-            .collect::<Vec<u8>>();
-        let descending = SIX
-            .iter()
-            .chain(TWO)
-            .chain(ONE)
-            .copied()
-            .collect::<Vec<u8>>();
+        let ascending = Vec::from_iter(ONE.iter().chain(TWO).chain(SIX).copied());
+        let descending = Vec::from_iter(SIX.iter().chain(TWO).chain(ONE).copied());
 
         // invalid descending order
         assert_parse_err!(
@@ -1261,16 +1251,8 @@ mod test {
         const ONE_64BIT: &[u8] = 1i64.to_be_bytes().as_slice();
         const ONE_32BIT: &[u8] = 1i32.to_be_bytes().as_slice();
 
-        let record_v1 = ONE_32BIT
-            .iter()
-            .chain(ONE_32BIT)
-            .copied()
-            .collect::<Vec<u8>>();
-        let record_v2p = ONE_64BIT
-            .iter()
-            .chain(ONE_32BIT)
-            .copied()
-            .collect::<Vec<u8>>();
+        let record_v1 = Vec::from_iter(ONE_32BIT.iter().chain(ONE_32BIT).copied());
+        let record_v2p = Vec::from_iter(ONE_64BIT.iter().chain(ONE_32BIT).copied());
 
         // version 1
         assert_parse_eq!(
@@ -1305,58 +1287,59 @@ mod test {
 
     #[test]
     fn parse_leap_second_records() {
-        let invalid_first_occurrence = (-5i64)
-            .to_be_bytes()
-            .iter()
-            .copied()
-            .chain(1i32.to_be_bytes().iter().copied())
-            .collect::<Vec<u8>>();
-        let invalid_first_correction = 0i64
-            .to_be_bytes()
-            .iter()
-            .copied()
-            .chain(0i32.to_be_bytes().iter().copied())
-            .collect::<Vec<u8>>();
-        let invalid_second_occurrence = 0i64
-            .to_be_bytes()
-            .iter()
-            .copied()
-            .chain(1i32.to_be_bytes().iter().copied())
-            .chain(2419198i64.to_be_bytes().iter().copied())
-            .chain(2i32.to_be_bytes().iter().copied())
-            .chain((2 * 2419199i64).to_be_bytes().iter().copied())
-            .chain(3i32.to_be_bytes().iter().copied())
-            .collect::<Vec<u8>>();
-        let invalid_second_correction = 0i64
-            .to_be_bytes()
-            .iter()
-            .copied()
-            .chain(1i32.to_be_bytes().iter().copied())
-            .chain(2419199i64.to_be_bytes().iter().copied())
-            .chain(3i32.to_be_bytes().iter().copied())
-            .chain((2 * 2419199i64).to_be_bytes().iter().copied())
-            .chain(4i32.to_be_bytes().iter().copied())
-            .collect::<Vec<u8>>();
-        let valid_v1 = 0i32
-            .to_be_bytes()
-            .iter()
-            .copied()
-            .chain(1i32.to_be_bytes().iter().copied())
-            .chain(2419199i32.to_be_bytes().iter().copied())
-            .chain(2i32.to_be_bytes().iter().copied())
-            .chain((2 * 2419199i32).to_be_bytes().iter().copied())
-            .chain(3i32.to_be_bytes().iter().copied())
-            .collect::<Vec<u8>>();
-        let valid_v2p = 0i64
-            .to_be_bytes()
-            .iter()
-            .copied()
-            .chain(1i32.to_be_bytes().iter().copied())
-            .chain(2419199i64.to_be_bytes().iter().copied())
-            .chain(2i32.to_be_bytes().iter().copied())
-            .chain((2 * 2419199i64).to_be_bytes().iter().copied())
-            .chain(3i32.to_be_bytes().iter().copied())
-            .collect::<Vec<u8>>();
+        let invalid_first_occurrence = Vec::from_iter(
+            (-5i64)
+                .to_be_bytes()
+                .iter()
+                .copied()
+                .chain(1i32.to_be_bytes().iter().copied()),
+        );
+        let invalid_first_correction = Vec::from_iter(
+            0i64.to_be_bytes()
+                .iter()
+                .copied()
+                .chain(0i32.to_be_bytes().iter().copied()),
+        );
+        let invalid_second_occurrence = Vec::from_iter(
+            0i64.to_be_bytes()
+                .iter()
+                .copied()
+                .chain(1i32.to_be_bytes().iter().copied())
+                .chain(2419198i64.to_be_bytes().iter().copied())
+                .chain(2i32.to_be_bytes().iter().copied())
+                .chain((2 * 2419199i64).to_be_bytes().iter().copied())
+                .chain(3i32.to_be_bytes().iter().copied()),
+        );
+        let invalid_second_correction = Vec::from_iter(
+            0i64.to_be_bytes()
+                .iter()
+                .copied()
+                .chain(1i32.to_be_bytes().iter().copied())
+                .chain(2419199i64.to_be_bytes().iter().copied())
+                .chain(3i32.to_be_bytes().iter().copied())
+                .chain((2 * 2419199i64).to_be_bytes().iter().copied())
+                .chain(4i32.to_be_bytes().iter().copied()),
+        );
+        let valid_v1 = Vec::from_iter(
+            0i32.to_be_bytes()
+                .iter()
+                .copied()
+                .chain(1i32.to_be_bytes().iter().copied())
+                .chain(2419199i32.to_be_bytes().iter().copied())
+                .chain(2i32.to_be_bytes().iter().copied())
+                .chain((2 * 2419199i32).to_be_bytes().iter().copied())
+                .chain(3i32.to_be_bytes().iter().copied()),
+        );
+        let valid_v2p = Vec::from_iter(
+            0i64.to_be_bytes()
+                .iter()
+                .copied()
+                .chain(1i32.to_be_bytes().iter().copied())
+                .chain(2419199i64.to_be_bytes().iter().copied())
+                .chain(2i32.to_be_bytes().iter().copied())
+                .chain((2 * 2419199i64).to_be_bytes().iter().copied())
+                .chain(3i32.to_be_bytes().iter().copied()),
+        );
 
         // invalid count
         assert_parse_err!(
diff --git a/utils/writeable/src/try_writeable.rs b/utils/writeable/src/try_writeable.rs
index 103bcd3b22d..22ae9abe914 100644
--- a/utils/writeable/src/try_writeable.rs
+++ b/utils/writeable/src/try_writeable.rs
@@ -112,7 +112,7 @@ pub trait TryWriteable {
     ///
     /// ```
     /// # use writeable::TryWriteable;
-    /// # let my_writeable: Result<&str, &str> = Ok("");
+    /// # let my_writeable = Ok::<&str, &str>("");
     /// # let mut sink = String::new();
     /// let _ = my_writeable.try_write_to(&mut sink)?;
     /// # Ok::<(), core::fmt::Error>(())
@@ -127,7 +127,7 @@ pub trait TryWriteable {
     /// ```
     /// use writeable::TryWriteable;
     ///
-    /// let w: Result<&str, usize> = Ok("success");
+    /// let w = Ok::<&str, usize>("success");
     /// let mut sink = String::new();
     /// let result = w.try_write_to(&mut sink);
     ///
@@ -140,7 +140,7 @@ pub trait TryWriteable {
     /// ```
     /// use writeable::TryWriteable;
     ///
-    /// let w: Result<&str, usize> = Err(44);
+    /// let w = Err::<&str, usize>(44);
     /// let mut sink = String::new();
     /// let result = w.try_write_to(&mut sink);
     ///
diff --git a/utils/yoke/derive/src/lib.rs b/utils/yoke/derive/src/lib.rs
index 4d3d8843a4f..0943d34f0fe 100644
--- a/utils/yoke/derive/src/lib.rs
+++ b/utils/yoke/derive/src/lib.rs
@@ -34,21 +34,14 @@ pub fn yokeable_derive(input: TokenStream) -> TokenStream {
 }
 
 fn yokeable_derive_impl(input: &DeriveInput) -> TokenStream2 {
-    let tybounds = input
-        .generics
-        .type_params()
-        .map(|ty| {
-            // Strip out param defaults, we don't need them in the impl
-            let mut ty = ty.clone();
-            ty.eq_token = None;
-            ty.default = None;
-            ty
-        })
-        .collect::<Vec<_>>();
-    let typarams = tybounds
-        .iter()
-        .map(|ty| ty.ident.clone())
-        .collect::<Vec<_>>();
+    let tybounds = Vec::from_iter(input.generics.type_params().map(|ty| {
+        // Strip out param defaults, we don't need them in the impl
+        let mut ty = ty.clone();
+        ty.eq_token = None;
+        ty.default = None;
+        ty
+    }));
+    let typarams = Vec::from_iter(tybounds.iter().map(|ty| ty.ident.clone()));
     // We require all type parameters be 'static, otherwise
     // the Yokeable impl becomes really unweildy to generate safely
     let static_bounds: Vec<WherePredicate> = typarams
diff --git a/utils/zerofrom/derive/src/lib.rs b/utils/zerofrom/derive/src/lib.rs
index 67d40851e75..5988ff4c216 100644
--- a/utils/zerofrom/derive/src/lib.rs
+++ b/utils/zerofrom/derive/src/lib.rs
@@ -87,21 +87,14 @@ fn get_may_borrow_attr(attrs: &[syn::Attribute]) -> Result<HashSet<Ident>, Span>
 }
 
 fn zf_derive_impl(input: &DeriveInput) -> TokenStream2 {
-    let mut tybounds = input
-        .generics
-        .type_params()
-        .map(|ty| {
-            // Strip out param defaults, we don't need them in the impl
-            let mut ty = ty.clone();
-            ty.eq_token = None;
-            ty.default = None;
-            ty
-        })
-        .collect::<Vec<_>>();
-    let typarams = tybounds
-        .iter()
-        .map(|ty| ty.ident.clone())
-        .collect::<Vec<_>>();
+    let mut tybounds = Vec::from_iter(input.generics.type_params().map(|ty| {
+        // Strip out param defaults, we don't need them in the impl
+        let mut ty = ty.clone();
+        ty.eq_token = None;
+        ty.default = None;
+        ty
+    }));
+    let typarams = Vec::from_iter(tybounds.iter().map(|ty| ty.ident.clone()));
     let lts = input.generics.lifetimes().count();
     let name = &input.ident;
     let structure = Structure::new(input);
diff --git a/utils/zerotrie/README.md b/utils/zerotrie/README.md
index 1a58da76a30..3712ac526c4 100644
--- a/utils/zerotrie/README.md
+++ b/utils/zerotrie/README.md
@@ -15,9 +15,7 @@ There are multiple variants of [`ZeroTrie`] optimized for different use cases.
 ```rust
 use zerotrie::ZeroTrie;
 
-let data: &[(&str, usize)] = &[("abc", 11), ("xyz", 22), ("axyb", 33)];
-
-let trie: ZeroTrie<Vec<u8>> = data.iter().copied().collect();
+let trie = ZeroTrie::<Vec<u8>>::from_iter([("abc", 11), ("xyz", 22), ("axyb", 33)]);
 
 assert_eq!(trie.get("axyb"), Some(33));
 assert_eq!(trie.byte_len(), 18);
diff --git a/utils/zerotrie/examples/first_weekday_for_region.rs b/utils/zerotrie/examples/first_weekday_for_region.rs
index fc4027be03c..eeae7ed7af7 100644
--- a/utils/zerotrie/examples/first_weekday_for_region.rs
+++ b/utils/zerotrie/examples/first_weekday_for_region.rs
@@ -216,7 +216,7 @@ fn main(_argc: isize, _argv: *const *const u8) -> isize {
     icu_benchmark_macros::main_setup!();
 
     // Un-comment to re-generate the bytes (printed to the terminal)
-    // let trie_phf = DATA.iter().copied().collect::<ZeroTriePerfectHash<Vec<_>>>();
+    // let trie_phf = ZeroTriePerfectHash::<Vec<_>>::from_iter(DATA.iter().copied());
     // assert_eq!(trie_phf.as_bytes(), TRIE_PHF.as_bytes());
 
     if black_box(TRIE_PHF).get(b"MV") == Some(weekday::FRI) {
diff --git a/utils/zerotrie/src/builder/nonconst/builder.rs b/utils/zerotrie/src/builder/nonconst/builder.rs
index 40abf0c435b..b4755800b78 100644
--- a/utils/zerotrie/src/builder/nonconst/builder.rs
+++ b/utils/zerotrie/src/builder/nonconst/builder.rs
@@ -99,10 +99,7 @@ impl<S: TrieBuilderStore> ZeroTrieBuilder<S> {
         options: ZeroTrieBuilderOptions,
     ) -> Result<Self, Error> {
         let items = Vec::<(K, usize)>::from_iter(iter);
-        let mut items = items
-            .iter()
-            .map(|(k, v)| (k.as_ref(), *v))
-            .collect::<Vec<(&[u8], usize)>>();
+        let mut items = Vec::from_iter(items.iter().map(|(k, v)| (k.as_ref(), *v)));
         items.sort_by(|a, b| cmp_keys_values(&options, *a, *b));
         let ascii_str_slice = items.as_slice();
         let byte_str_slice = ByteStr::from_byte_slice_with_value(ascii_str_slice);
diff --git a/utils/zerotrie/src/builder/nonconst/store.rs b/utils/zerotrie/src/builder/nonconst/store.rs
index a0a2d8f5232..07162a77a8e 100644
--- a/utils/zerotrie/src/builder/nonconst/store.rs
+++ b/utils/zerotrie/src/builder/nonconst/store.rs
@@ -177,8 +177,7 @@ mod tests {
 
     #[test]
     fn test_swap_ranges() {
-        let s = b"..abcdefghijkl=";
-        let mut s = s.iter().copied().collect::<VecDeque<u8>>();
+        let mut s = VecDeque::from_iter(*b"..abcdefghijkl=");
         s.atbs_swap_ranges(2, 7, 14);
         assert_eq!(s.atbs_to_bytes(), b"..fghijklabcde=");
     }
diff --git a/utils/zerotrie/src/cursor.rs b/utils/zerotrie/src/cursor.rs
index 71f668fd209..5dd4d5b932c 100644
--- a/utils/zerotrie/src/cursor.rs
+++ b/utils/zerotrie/src/cursor.rs
@@ -254,15 +254,15 @@ impl<'a> ZeroTrieSimpleAsciiCursor<'a> {
     /// ```
     /// use zerotrie::ZeroTrieSimpleAscii;
     ///
-    /// let data: &[(String, usize)] = &[
+    /// let data = &[
     ///     ("ab".to_string(), 111),
     ///     ("abcxyz".to_string(), 22),
     ///     ("abde".to_string(), 333),
     ///     ("afg".to_string(), 44),
     /// ];
     ///
-    /// let trie: ZeroTrieSimpleAscii<Vec<u8>> =
-    ///     data.iter().map(|(s, v)| (s.as_str(), *v)).collect();
+    /// let trie = ZeroTrieSimpleAscii::<Vec<u8>>::from_iter(
+    ///     data.iter().map(|(s, v)| (s.as_str(), *v)));
     ///
     /// let mut cursor = trie.cursor();
     /// let mut key = String::new();
@@ -282,16 +282,15 @@ impl<'a> ZeroTrieSimpleAsciiCursor<'a> {
     ///
     /// ```
     /// # use zerotrie::ZeroTrieSimpleAscii;
-    /// # let data: &[(String, usize)] = &[
+    /// # let data = &[
     /// #     ("ab".to_string(), 111),
     /// #     ("abcxyz".to_string(), 22),
     /// #     ("abde".to_string(), 333),
     /// #     ("afg".to_string(), 44)
     /// # ];
-    /// # let trie: ZeroTrieSimpleAscii<Vec<u8>> = data
+    /// # let trie = ZeroTrieSimpleAscii::<Vec<u8>>::from_iter(data
     /// #     .iter()
-    /// #     .map(|(s, v)| (s.as_str(), *v))
-    /// #     .collect();
+    /// #     .map(|(s, v)| (s.as_str(), *v)));
     /// // (trie built as in previous example)
     ///
     /// // Initialize the iteration at the first child of the trie.
diff --git a/utils/zerotrie/src/lib.rs b/utils/zerotrie/src/lib.rs
index e4ff90c498f..e05a8054393 100644
--- a/utils/zerotrie/src/lib.rs
+++ b/utils/zerotrie/src/lib.rs
@@ -15,9 +15,7 @@
 //! ```
 //! use zerotrie::ZeroTrie;
 //!
-//! let data: &[(&str, usize)] = &[("abc", 11), ("xyz", 22), ("axyb", 33)];
-//!
-//! let trie: ZeroTrie<Vec<u8>> = data.iter().copied().collect();
+//! let trie = ZeroTrie::<Vec<u8>>::from_iter([("abc", 11), ("xyz", 22), ("axyb", 33)]);
 //!
 //! assert_eq!(trie.get("axyb"), Some(33));
 //! assert_eq!(trie.byte_len(), 18);
diff --git a/utils/zerotrie/src/serde.rs b/utils/zerotrie/src/serde.rs
index 48ae87193e8..d62cbd31d9a 100644
--- a/utils/zerotrie/src/serde.rs
+++ b/utils/zerotrie/src/serde.rs
@@ -227,10 +227,8 @@ where
     {
         if serializer.is_human_readable() {
             let lm = self.to_litemap();
-            let lm = lm
-                .iter()
-                .map(|(k, v)| (ByteStr::from_bytes(k), v))
-                .collect::<LiteMap<_, _>>();
+            let lm =
+                LiteMap::<_, _>::from_iter(lm.iter().map(|(k, v)| (ByteStr::from_bytes(k), v)));
             lm.serialize(serializer)
         } else {
             // Note: `impl Serialize for ByteStr` uses `serialize_bytes`
@@ -276,10 +274,8 @@ where
     {
         if serializer.is_human_readable() {
             let lm = self.to_litemap();
-            let lm = lm
-                .iter()
-                .map(|(k, v)| (ByteStr::from_bytes(k), v))
-                .collect::<LiteMap<_, _>>();
+            let lm =
+                LiteMap::<_, _>::from_iter(lm.iter().map(|(k, v)| (ByteStr::from_bytes(k), v)));
             lm.serialize(serializer)
         } else {
             // Note: `impl Serialize for ByteStr` uses `serialize_bytes`
@@ -336,10 +332,8 @@ where
     {
         if serializer.is_human_readable() {
             let lm = self.to_litemap();
-            let lm = lm
-                .iter()
-                .map(|(k, v)| (ByteStr::from_bytes(k), v))
-                .collect::<LiteMap<_, _>>();
+            let lm =
+                LiteMap::<_, _>::from_iter(lm.iter().map(|(k, v)| (ByteStr::from_bytes(k), v)));
             lm.serialize(serializer)
         } else {
             let (tag, bytes) = match &self.0 {
diff --git a/utils/zerotrie/tests/ignorecase_test.rs b/utils/zerotrie/tests/ignorecase_test.rs
index fb73ef7cc33..2c3626c5c69 100644
--- a/utils/zerotrie/tests/ignorecase_test.rs
+++ b/utils/zerotrie/tests/ignorecase_test.rs
@@ -16,23 +16,14 @@ fn test_ignore_case_coverage() {
 
     // Test both construction paths
     ZeroAsciiIgnoreCaseTrie::try_from(&litemap).unwrap();
-    let trie = litemap
-        .iter()
-        .map(|(k, v)| (*k, *v))
-        .collect::<ZeroAsciiIgnoreCaseTrie<Vec<u8>>>();
+    let trie = ZeroAsciiIgnoreCaseTrie::<Vec<u8>>::from_iter(litemap.iter().map(|(k, v)| (*k, *v)));
 
     // Test lookup
     for (k, v) in litemap.iter() {
         assert_eq!(trie.get(k), Some(*v), "normal: {k:?}");
-        let k_upper = k
-            .iter()
-            .map(|c| c.to_ascii_uppercase())
-            .collect::<Vec<u8>>();
+        let k_upper = Vec::from_iter(k.iter().map(|c| c.to_ascii_uppercase()));
         assert_eq!(trie.get(k_upper), Some(*v), "upper: {k:?}");
-        let k_lower = k
-            .iter()
-            .map(|c| c.to_ascii_lowercase())
-            .collect::<Vec<u8>>();
+        let k_lower = Vec::from_iter(k.iter().map(|c| c.to_ascii_lowercase()));
         assert_eq!(trie.get(k_lower), Some(*v), "lower: {k:?}");
     }
 
diff --git a/utils/zerovec/README.md b/utils/zerovec/README.md
index b1e2317a647..71fc426228f 100644
--- a/utils/zerovec/README.md
+++ b/utils/zerovec/README.md
@@ -76,7 +76,7 @@ let bincode_bytes =
     bincode::serialize(&data).expect("Serialization should be successful");
 assert_eq!(bincode_bytes.len(), 67);
 
-let deserialized: DataStruct = bincode::deserialize(&bincode_bytes)
+let deserialized = bincode::deserialize::<DataStruct>(&bincode_bytes)
     .expect("Deserialization should be successful");
 assert_eq!(deserialized.nums.first(), Some(211));
 assert_eq!(deserialized.chars.get(1), Some('冇'));
@@ -137,7 +137,7 @@ let person2 = Person {
 
 let important_dates = ZeroVec::alloc_from_slice(&[Date { y: 1943, m: 3, d: 20}, Date { y: 1976, m: 8, d: 2}, Date { y: 1998, m: 2, d: 15}]);
 let important_people = VarZeroVec::from(&[&person1, &person2]);
-let mut birthdays_to_people: ZeroMap<Date, PersonULE> = ZeroMap::new();
+let mut birthdays_to_people = ZeroMap::<Date, PersonULE>::new();
 // `.insert_var_v()` is slightly more convenient over `.insert()` for custom ULE types
 birthdays_to_people.insert_var_v(&person1.birthday, &person1);
 birthdays_to_people.insert_var_v(&person2.birthday, &person2);
@@ -148,7 +148,7 @@ let bincode_bytes = bincode::serialize(&data)
     .expect("Serialization should be successful");
 assert_eq!(bincode_bytes.len(), 168);
 
-let deserialized: Data = bincode::deserialize(&bincode_bytes)
+let deserialized = bincode::deserialize::<Data>(&bincode_bytes)
     .expect("Deserialization should be successful");
 
 assert_eq!(deserialized.important_dates.get(0).unwrap().y, 1943);
@@ -156,7 +156,6 @@ assert_eq!(&deserialized.important_people.get(1).unwrap().name, "Jesse");
 assert_eq!(&deserialized.important_people.get(0).unwrap().name, "Kate");
 assert_eq!(&deserialized.birthdays_to_people.get(&person1.birthday).unwrap().name, "Kate");
 
-} // feature = serde and derive
 ```
 
 ## Performance
diff --git a/utils/zerovec/benches/vzv.rs b/utils/zerovec/benches/vzv.rs
index 92f02e2a3c5..2d241787695 100644
--- a/utils/zerovec/benches/vzv.rs
+++ b/utils/zerovec/benches/vzv.rs
@@ -27,11 +27,12 @@ fn random_alphanums(lengths: RangeInclusive<usize>, count: usize, seed: u64) ->
         .sample_iter(&mut rng1)
         .take(count)
         .map(|len| {
-            (&alpha_dist)
-                .sample_iter(&mut rng2)
-                .take(len)
-                .map(char::from)
-                .collect::<String>()
+            String::from_iter(
+                (&alpha_dist)
+                    .sample_iter(&mut rng2)
+                    .take(len)
+                    .map(char::from),
+            )
         })
         .collect();
     (string_vec, rand::Rng::gen(&mut rng1))
diff --git a/utils/zerovec/benches/zeromap.rs b/utils/zerovec/benches/zeromap.rs
index ac93efdb35f..48f1ecd78be 100644
--- a/utils/zerovec/benches/zeromap.rs
+++ b/utils/zerovec/benches/zeromap.rs
@@ -139,7 +139,7 @@ fn build_zeromap(large: bool) -> ZeroMap<'static, Index32Str, Index32Str> {
         }
     }
 
-    let keys = keys.iter().map(|s| indexify(s)).collect::<Vec<_>>();
+    let keys = Vec::from_iter(keys.iter().map(|s| indexify(s)));
     // keys are sorted by construction
     unsafe { ZeroMap::from_parts_unchecked(VarZeroVec::from(&keys), VarZeroVec::from(&values)) }
 }
diff --git a/utils/zerovec/derive/src/make_ule.rs b/utils/zerovec/derive/src/make_ule.rs
index b31913f0886..a866d3d9214 100644
--- a/utils/zerovec/derive/src/make_ule.rs
+++ b/utils/zerovec/derive/src/make_ule.rs
@@ -139,7 +139,7 @@ fn make_ule_enum_impl(
         }
     }
 
-    let not_found = not_found.iter().collect::<Vec<_>>();
+    let not_found = Vec::from_iter(not_found.iter());
 
     if !not_found.is_empty() {
         return Error::new(input.span(), format!("#[make_ule] must be applied to enums with discriminants \
diff --git a/utils/zerovec/derive/src/make_varule.rs b/utils/zerovec/derive/src/make_varule.rs
index 36a6f6e7a9e..954f2bdaaf1 100644
--- a/utils/zerovec/derive/src/make_varule.rs
+++ b/utils/zerovec/derive/src/make_varule.rs
@@ -316,15 +316,12 @@ fn make_zf_impl(
         .to_compile_error();
     };
 
-    let mut field_inits = sized_fields
-        .iter()
-        .map(|f| {
-            let ty = &f.field.ty;
-            let accessor = &f.accessor;
-            let setter = f.setter();
-            quote!(#setter <#ty as zerovec::ule::AsULE>::from_unaligned(other.#accessor))
-        })
-        .collect::<Vec<_>>();
+    let mut field_inits = Vec::from_iter(sized_fields.iter().map(|f| {
+        let ty = &f.field.ty;
+        let accessor = &f.accessor;
+        let setter = f.setter();
+        quote!(#setter <#ty as zerovec::ule::AsULE>::from_unaligned(other.#accessor))
+    }));
 
     unsized_field_info.push_zf_setters(lt, &mut field_inits);
 
diff --git a/utils/zerovec/derive/src/ule.rs b/utils/zerovec/derive/src/ule.rs
index 6a03c008f4f..ba57bff9f7b 100644
--- a/utils/zerovec/derive/src/ule.rs
+++ b/utils/zerovec/derive/src/ule.rs
@@ -103,5 +103,5 @@ pub(crate) fn make_ule_fields(fields: &[FieldInfo]) -> Vec<TokenStream2> {
             let vis = &f.field.vis;
             quote!(#vis #setter #ty)
         })
-        .collect::<Vec<_>>()
+        .collect()
 }
diff --git a/utils/zerovec/src/flexzerovec/owned.rs b/utils/zerovec/src/flexzerovec/owned.rs
index 7d7bfb33d6d..816ca083501 100644
--- a/utils/zerovec/src/flexzerovec/owned.rs
+++ b/utils/zerovec/src/flexzerovec/owned.rs
@@ -69,7 +69,7 @@ impl FlexZeroVecOwned {
     /// ```
     /// use zerovec::vecs::FlexZeroVec;
     ///
-    /// let mut zv: FlexZeroVec = [22, 44, 66].iter().copied().collect();
+    /// let mut zv = FlexZeroVec::from_iter([22, 44, 66]);
     /// zv.to_mut().push(33);
     /// assert_eq!(zv.to_vec(), vec![22, 44, 66, 33]);
     /// ```
@@ -96,7 +96,7 @@ impl FlexZeroVecOwned {
     /// ```
     /// use zerovec::vecs::FlexZeroVec;
     ///
-    /// let mut zv: FlexZeroVec = [22, 44, 66].iter().copied().collect();
+    /// let mut zv = FlexZeroVec::from_iter([22, 44, 66]);
     /// zv.to_mut().insert(2, 33);
     /// assert_eq!(zv.to_vec(), vec![22, 44, 33, 66]);
     /// ```
@@ -150,7 +150,7 @@ impl FlexZeroVecOwned {
     /// ```
     /// use zerovec::vecs::FlexZeroVec;
     ///
-    /// let mut zv: FlexZeroVec = [22, 44, 66].iter().copied().collect();
+    /// let mut zv = FlexZeroVec::from_iter([22, 44, 66]);
     /// let removed_item = zv.to_mut().remove(1);
     /// assert_eq!(44, removed_item);
     /// assert_eq!(zv.to_vec(), vec![22, 66]);
@@ -184,7 +184,7 @@ impl FlexZeroVecOwned {
     /// ```
     /// use zerovec::vecs::FlexZeroVec;
     ///
-    /// let mut zv: FlexZeroVec = [22, 44, 66].iter().copied().collect();
+    /// let mut zv = FlexZeroVec::from_iter([22, 44, 66]);
     /// let popped_item = zv.to_mut().pop_sorted();
     /// assert_eq!(66, popped_item);
     /// assert_eq!(zv.to_vec(), vec![22, 44]);
diff --git a/utils/zerovec/src/flexzerovec/slice.rs b/utils/zerovec/src/flexzerovec/slice.rs
index 41cb7116f90..5a73fee11ff 100644
--- a/utils/zerovec/src/flexzerovec/slice.rs
+++ b/utils/zerovec/src/flexzerovec/slice.rs
@@ -157,7 +157,7 @@ impl FlexZeroSlice {
     /// ```
     /// use zerovec::vecs::FlexZeroSlice;
     ///
-    /// let bytes: &[u8] = &[2, 0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x80];
+    /// let bytes = &[2, 0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x80];
     /// let fzv = FlexZeroSlice::parse_byte_slice(bytes).expect("valid bytes");
     ///
     /// assert_eq!(bytes, fzv.as_bytes());
@@ -200,7 +200,7 @@ impl FlexZeroSlice {
     /// ```
     /// use zerovec::vecs::FlexZeroVec;
     ///
-    /// let fzv: FlexZeroVec = [22, 33].iter().copied().collect();
+    /// let fzv = FlexZeroVec::from_iter([22, 33]);
     /// assert_eq!(fzv.get(0), Some(22));
     /// assert_eq!(fzv.get(1), Some(33));
     /// assert_eq!(fzv.get(2), None);
@@ -286,8 +286,7 @@ impl FlexZeroSlice {
     /// ```
     /// use zerovec::vecs::FlexZeroVec;
     ///
-    /// let nums: &[usize] = &[211, 281, 421, 461];
-    /// let fzv: FlexZeroVec = nums.iter().copied().collect();
+    /// let fzv = FlexZeroVec::from_iter([211, 281, 421, 461]);
     ///
     /// let mut pairs_it = fzv.iter_pairs();
     ///
@@ -308,11 +307,10 @@ impl FlexZeroSlice {
     /// ```
     /// use zerovec::vecs::FlexZeroVec;
     ///
-    /// let nums: &[usize] = &[211, 281, 421, 461];
-    /// let fzv: FlexZeroVec = nums.iter().copied().collect();
-    /// let vec: Vec<usize> = fzv.to_vec();
+    /// let fzv = FlexZeroVec::from_iter([211, 281, 421, 461]);
+    /// let vec = fzv.to_vec();
     ///
-    /// assert_eq!(nums, vec.as_slice());
+    /// assert_eq!(vec.as_slice(), &[211, 281, 421, 461]);
     /// ```
     #[inline]
     pub fn to_vec(&self) -> Vec<usize> {
@@ -326,8 +324,7 @@ impl FlexZeroSlice {
     /// ```
     /// use zerovec::vecs::FlexZeroVec;
     ///
-    /// let nums: &[usize] = &[211, 281, 421, 461];
-    /// let fzv: FlexZeroVec = nums.iter().copied().collect();
+    /// let fzv = FlexZeroVec::from_iter([211, 281, 421, 461]);
     ///
     /// assert_eq!(fzv.binary_search(0), Err(0));
     /// assert_eq!(fzv.binary_search(211), Ok(0));
@@ -354,8 +351,7 @@ impl FlexZeroSlice {
     /// use zerovec::vecs::FlexZeroVec;
     ///
     /// // Make a FlexZeroVec with two sorted ranges: 0..3 and 3..5
-    /// let nums: &[usize] = &[111, 222, 444, 333, 555];
-    /// let fzv: FlexZeroVec = nums.iter().copied().collect();
+    /// let fzv = FlexZeroVec::from_iter([111, 222, 444, 333, 555]);
     ///
     /// // Search in the first range:
     /// assert_eq!(fzv.binary_search_in_range(0, 0..3), Some(Err(0)));
diff --git a/utils/zerovec/src/flexzerovec/vec.rs b/utils/zerovec/src/flexzerovec/vec.rs
index d83f600b572..7961145b131 100644
--- a/utils/zerovec/src/flexzerovec/vec.rs
+++ b/utils/zerovec/src/flexzerovec/vec.rs
@@ -131,7 +131,7 @@ impl<'a> FlexZeroVec<'a> {
     /// ```
     /// use zerovec::vecs::FlexZeroVec;
     ///
-    /// let zv: FlexZeroVec = FlexZeroVec::new();
+    /// let zv = FlexZeroVec::new();
     /// assert!(zv.is_empty());
     /// ```
     pub const fn new() -> Self {
@@ -158,7 +158,7 @@ impl<'a> FlexZeroVec<'a> {
     /// ```
     /// use zerovec::vecs::FlexZeroVec;
     ///
-    /// let bytes: &[u8] = &[2, 0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x01];
+    /// let bytes = &[2, 0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x01];
     /// let zv = FlexZeroVec::parse_byte_slice(bytes).expect("valid slice");
     ///
     /// assert!(matches!(zv, FlexZeroVec::Borrowed(_)));
@@ -176,7 +176,7 @@ impl<'a> FlexZeroVec<'a> {
     /// ```
     /// use zerovec::vecs::FlexZeroVec;
     ///
-    /// let bytes: &[u8] = &[2, 0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x01];
+    /// let bytes = &[2, 0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x01];
     /// let zv = FlexZeroVec::parse_byte_slice(bytes).expect("valid bytes");
     /// assert!(matches!(zv, FlexZeroVec::Borrowed(_)));
     ///
@@ -198,7 +198,7 @@ impl<'a> FlexZeroVec<'a> {
     /// ```
     /// use zerovec::vecs::FlexZeroVec;
     ///
-    /// let bytes: &[u8] = &[2, 0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x01];
+    /// let bytes = &[2, 0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x01];
     /// let mut zv = FlexZeroVec::parse_byte_slice(bytes).expect("valid bytes");
     /// assert!(matches!(zv, FlexZeroVec::Borrowed(_)));
     ///
@@ -224,7 +224,7 @@ impl<'a> FlexZeroVec<'a> {
     /// ```
     /// use zerovec::vecs::FlexZeroVec;
     ///
-    /// let mut zv: FlexZeroVec = [1, 2, 3].iter().copied().collect();
+    /// let mut zv = FlexZeroVec::from_iter([1, 2, 3]);
     /// assert!(!zv.is_empty());
     /// zv.clear();
     /// assert!(zv.is_empty());
diff --git a/utils/zerovec/src/hashmap/serde.rs b/utils/zerovec/src/hashmap/serde.rs
index 46ed3626658..7c45f5b1a91 100644
--- a/utils/zerovec/src/hashmap/serde.rs
+++ b/utils/zerovec/src/hashmap/serde.rs
@@ -127,8 +127,8 @@ mod test {
         let deserialized_hm: ZeroHashMap<u32, str> =
             serde_json::from_str(JSON_STR).expect("deserialize");
         assert_eq!(
-            hm.iter().collect::<Vec<_>>(),
-            deserialized_hm.iter().collect::<Vec<_>>()
+            Vec::from_iter(hm.iter()),
+            Vec::from_iter(deserialized_hm.iter())
         );
     }
 
@@ -140,8 +140,8 @@ mod test {
         let deserialized_hm: ZeroHashMap<u32, str> =
             bincode::deserialize(BINCODE_BYTES).expect("deserialize");
         assert_eq!(
-            hm.iter().collect::<Vec<_>>(),
-            deserialized_hm.iter().collect::<Vec<_>>()
+            Vec::from_iter(hm.iter()),
+            Vec::from_iter(deserialized_hm.iter())
         );
     }
 }
diff --git a/utils/zerovec/src/lib.rs b/utils/zerovec/src/lib.rs
index 8bb5b17e030..acaca23a7a0 100644
--- a/utils/zerovec/src/lib.rs
+++ b/utils/zerovec/src/lib.rs
@@ -77,7 +77,7 @@
 //!     bincode::serialize(&data).expect("Serialization should be successful");
 //! assert_eq!(bincode_bytes.len(), 67);
 //!
-//! let deserialized: DataStruct = bincode::deserialize(&bincode_bytes)
+//! let deserialized = bincode::deserialize::<DataStruct>(&bincode_bytes)
 //!     .expect("Deserialization should be successful");
 //! assert_eq!(deserialized.nums.first(), Some(211));
 //! assert_eq!(deserialized.chars.get(1), Some('冇'));
@@ -140,7 +140,7 @@
 //!
 //! let important_dates = ZeroVec::alloc_from_slice(&[Date { y: 1943, m: 3, d: 20}, Date { y: 1976, m: 8, d: 2}, Date { y: 1998, m: 2, d: 15}]);
 //! let important_people = VarZeroVec::from(&[&person1, &person2]);
-//! let mut birthdays_to_people: ZeroMap<Date, PersonULE> = ZeroMap::new();
+//! let mut birthdays_to_people = ZeroMap::<Date, PersonULE>::new();
 //! // `.insert_var_v()` is slightly more convenient over `.insert()` for custom ULE types
 //! birthdays_to_people.insert_var_v(&person1.birthday, &person1);
 //! birthdays_to_people.insert_var_v(&person2.birthday, &person2);
@@ -151,7 +151,7 @@
 //!     .expect("Serialization should be successful");
 //! assert_eq!(bincode_bytes.len(), 168);
 //!
-//! let deserialized: Data = bincode::deserialize(&bincode_bytes)
+//! let deserialized = bincode::deserialize::<Data>(&bincode_bytes)
 //!     .expect("Deserialization should be successful");
 //!
 //! assert_eq!(deserialized.important_dates.get(0).unwrap().y, 1943);
@@ -159,7 +159,7 @@
 //! assert_eq!(&deserialized.important_people.get(0).unwrap().name, "Kate");
 //! assert_eq!(&deserialized.birthdays_to_people.get(&person1.birthday).unwrap().name, "Kate");
 //!
-//! } // feature = serde and derive
+//! # } // feature = serde and derive
 //! ```
 //!
 //! # Performance
@@ -389,7 +389,7 @@ pub mod vecs {
 ///     bincode::serialize(&dates).expect("Serialization should be successful");
 ///
 /// // Will deserialize without allocations
-/// let deserialized: Dates = bincode::deserialize(&bincode_bytes)
+/// let deserialized = bincode::deserialize::<Dates>(&bincode_bytes)
 ///     .expect("Deserialization should be successful");
 ///
 /// assert_eq!(deserialized.dates.get(1).unwrap().y, 1970);
@@ -503,16 +503,16 @@ pub use zerovec_derive::make_ule;
 /// let bincode_bytes = bincode::serialize(&data).expect("Serialization should be successful");
 ///
 /// // Will deserialize without allocations
-/// let deserialized: Data =
-///     bincode::deserialize(&bincode_bytes).expect("Deserialization should be successful");
+/// let deserialized =
+///     bincode::deserialize::<Data>(&bincode_bytes).expect("Deserialization should be successful");
 ///
-/// assert_eq!(&deserialized.important_people.get(1).unwrap().name, "Jesse");
-/// assert_eq!(&deserialized.important_people.get(0).unwrap().name, "Kate");
+/// assert_eq!(&deserialized.important_people[1].name, "Jesse");
+/// assert_eq!(&deserialized.important_people[0].name, "Kate");
 ///
 /// // Since VarZeroVec produces PersonULE types, it's convenient to use ZeroFrom
 /// // to recoup Person values in a zero-copy way
-/// let person_converted: Person =
-///     ZeroFrom::zero_from(deserialized.important_people.get(1).unwrap());
+/// let person_converted =
+///     Person::zero_from(&deserialized.important_people[1]);
 /// assert_eq!(person_converted.name, "Jesse");
 /// assert_eq!(person_converted.birthday.y, 1960);
 /// ```
diff --git a/utils/zerovec/src/map/borrowed.rs b/utils/zerovec/src/map/borrowed.rs
index 8a9ed8acaea..b2cb2ab9a65 100644
--- a/utils/zerovec/src/map/borrowed.rs
+++ b/utils/zerovec/src/map/borrowed.rs
@@ -23,14 +23,14 @@ use super::vecs::ZeroVecLike;
 /// use zerovec::maps::ZeroMapBorrowed;
 ///
 /// // Example byte buffer representing the map { 1: "one" }
-/// let BINCODE_BYTES: &[u8; 29] = &[
+/// let BINCODE_BYTES = &[
 ///     4, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
 ///     0, 0, 111, 110, 101,
 /// ];
 ///
 /// // Deserializing to ZeroMap requires no heap allocations.
-/// let zero_map: ZeroMapBorrowed<u32, str> =
-///     bincode::deserialize(BINCODE_BYTES)
+/// let zero_map =
+///     bincode::deserialize::<ZeroMapBorrowed<u32, str>>(BINCODE_BYTES)
 ///         .expect("Should deserialize successfully");
 /// assert_eq!(zero_map.get(&1), Some("one"));
 /// ```
@@ -100,7 +100,7 @@ where
     /// ```
     /// use zerovec::maps::ZeroMapBorrowed;
     ///
-    /// let zm: ZeroMapBorrowed<u16, str> = ZeroMapBorrowed::new();
+    /// let zm = ZeroMapBorrowed::<u16, str>::new();
     /// assert!(zm.is_empty());
     /// ```
     pub fn new() -> Self {
diff --git a/utils/zerovec/src/map/map.rs b/utils/zerovec/src/map/map.rs
index 6801869c96d..664c2837d48 100644
--- a/utils/zerovec/src/map/map.rs
+++ b/utils/zerovec/src/map/map.rs
@@ -48,7 +48,7 @@ use core::iter::FromIterator;
 ///     bincode::serialize(&data).expect("Serialization should be successful");
 ///
 /// // Will deserialize without any allocations
-/// let deserialized: Data = bincode::deserialize(&bincode_bytes)
+/// let deserialized = bincode::deserialize::<Data>(&bincode_bytes)
 ///     .expect("Deserialization should be successful");
 ///
 /// assert_eq!(data.map.get(&1), Some("one"));
@@ -89,7 +89,7 @@ where
     /// ```
     /// use zerovec::ZeroMap;
     ///
-    /// let zm: ZeroMap<u16, str> = ZeroMap::new();
+    /// let zm = ZeroMap::<u16, str>::new();
     /// assert!(zm.is_empty());
     /// ```
     pub fn new() -> Self {
@@ -427,7 +427,7 @@ where
     ///     name: Cow<'a, str>,
     /// }
     ///
-    /// let mut map: ZeroMap<u32, PersonULE> = ZeroMap::new();
+    /// let mut map = ZeroMap::<u32, PersonULE>::new();
     /// map.insert_var_v(
     ///     &1,
     ///     &Person {
diff --git a/utils/zerovec/src/map/serde.rs b/utils/zerovec/src/map/serde.rs
index e82886d2ad3..abb60513b29 100644
--- a/utils/zerovec/src/map/serde.rs
+++ b/utils/zerovec/src/map/serde.rs
@@ -267,10 +267,7 @@ mod test {
         let json_str = serde_json::to_string(&map).expect("serialize");
         assert_eq!(JSON_STR, json_str);
         let new_map: ZeroMap<u32, str> = serde_json::from_str(&json_str).expect("deserialize");
-        assert_eq!(
-            new_map.iter().collect::<Vec<_>>(),
-            map.iter().collect::<Vec<_>>()
-        );
+        assert_eq!(Vec::from_iter(new_map.iter()), Vec::from_iter(map.iter()));
     }
 
     #[test]
@@ -286,10 +283,7 @@ mod test {
         );
         let new_map: ZeroMap<(u32, u32), str> =
             serde_json::from_str(&json_str).expect("deserialize");
-        assert_eq!(
-            new_map.iter().collect::<Vec<_>>(),
-            map.iter().collect::<Vec<_>>()
-        );
+        assert_eq!(Vec::from_iter(new_map.iter()), Vec::from_iter(map.iter()));
     }
 
     #[test]
@@ -298,16 +292,10 @@ mod test {
         let bincode_bytes = bincode::serialize(&map).expect("serialize");
         assert_eq!(BINCODE_BYTES, bincode_bytes);
         let new_map: ZeroMap<u32, str> = bincode::deserialize(&bincode_bytes).expect("deserialize");
-        assert_eq!(
-            new_map.iter().collect::<Vec<_>>(),
-            map.iter().collect::<Vec<_>>()
-        );
+        assert_eq!(Vec::from_iter(new_map.iter()), Vec::from_iter(map.iter()));
 
         let new_map: ZeroMapBorrowed<u32, str> =
             bincode::deserialize(&bincode_bytes).expect("deserialize");
-        assert_eq!(
-            new_map.iter().collect::<Vec<_>>(),
-            map.iter().collect::<Vec<_>>()
-        );
+        assert_eq!(Vec::from_iter(new_map.iter()), Vec::from_iter(map.iter()));
     }
 }
diff --git a/utils/zerovec/src/map/vecs.rs b/utils/zerovec/src/map/vecs.rs
index 5ee93d3fead..286aad7d91a 100644
--- a/utils/zerovec/src/map/vecs.rs
+++ b/utils/zerovec/src/map/vecs.rs
@@ -717,8 +717,8 @@ mod test {
         let mut permutation = vec![3, 2, 1, 0, 6, 5, 4];
         fzv.zvl_permute(&mut permutation);
         assert_eq!(
-            fzv.iter().collect::<Vec<_>>(),
-            [44, 33, 22, 11, 77, 66, 55].into_iter().collect::<Vec<_>>()
+            Vec::from_iter(fzv.iter()),
+            Vec::from_iter([44, 33, 22, 11, 77, 66, 55])
         );
     }
 }
diff --git a/utils/zerovec/src/map2d/borrowed.rs b/utils/zerovec/src/map2d/borrowed.rs
index acd861dcdf1..bb98c645935 100644
--- a/utils/zerovec/src/map2d/borrowed.rs
+++ b/utils/zerovec/src/map2d/borrowed.rs
@@ -23,15 +23,15 @@ use crate::map2d::ZeroMap2dCursor;
 /// use zerovec::maps::ZeroMap2dBorrowed;
 ///
 /// // Example byte buffer representing the map { 1: {2: "three" } }
-/// let BINCODE_BYTES: &[u8; 51] = &[
+/// let BINCODE_BYTES = &[
 ///     2, 0, 0, 0, 0, 0, 0, 0, 1, 0, 4, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 2, 0,
 ///     0, 0, 0, 0, 0, 0, 2, 0, 11, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 116,
 ///     104, 114, 101, 101,
 /// ];
 ///
 /// // Deserializing to ZeroMap2d requires no heap allocations.
-/// let zero_map: ZeroMap2dBorrowed<u16, u16, str> =
-///     bincode::deserialize(BINCODE_BYTES)
+/// let zero_map =
+///     bincode::deserialize::<ZeroMap2dBorrowed<u16, u16, str>>(BINCODE_BYTES)
 ///         .expect("Should deserialize successfully");
 /// assert_eq!(zero_map.get_2d(&1, &2), Some("three"));
 /// ```
@@ -116,7 +116,7 @@ where
     /// ```
     /// use zerovec::maps::ZeroMap2dBorrowed;
     ///
-    /// let zm: ZeroMap2dBorrowed<u16, u16, str> = ZeroMap2dBorrowed::new();
+    /// let zm = ZeroMap2dBorrowed::<u16, u16, str>::new();
     /// assert!(zm.is_empty());
     /// ```
     pub fn new() -> Self {
diff --git a/utils/zerovec/src/map2d/cursor.rs b/utils/zerovec/src/map2d/cursor.rs
index 4802187becf..0a44831e2b4 100644
--- a/utils/zerovec/src/map2d/cursor.rs
+++ b/utils/zerovec/src/map2d/cursor.rs
@@ -294,7 +294,7 @@ where
     /// ```rust
     /// use zerovec::ZeroMap2d;
     ///
-    /// let mut map: ZeroMap2d<u16, u16, u16> = ZeroMap2d::new();
+    /// let mut map = ZeroMap2d::<u16, u16, u16>::new();
     /// map.insert(&1, &2, &3);
     /// map.insert(&1, &4, &5);
     /// map.insert(&6, &7, &8);
diff --git a/utils/zerovec/src/map2d/map.rs b/utils/zerovec/src/map2d/map.rs
index 5a9d830548a..39413e2c5d2 100644
--- a/utils/zerovec/src/map2d/map.rs
+++ b/utils/zerovec/src/map2d/map.rs
@@ -18,14 +18,11 @@ use crate::map::{MutableZeroVecLike, ZeroVecLike};
 /// A zero-copy, two-dimensional map datastructure .
 ///
 /// This is an extension of [`ZeroMap`] that supports two layers of keys. For example,
-/// to map a pair of an integer and a string to a buffer, you can write:
+/// to map a pair of an integer and a string to a buffer, you can use the type:
 ///
-/// ```no_run
-/// # use zerovec::ZeroMap2d;
-/// let _: ZeroMap2d<u32, str, [u8]> = unimplemented!();
-/// ```
+/// `ZeroMap2d<u32, str, [u8]>`
 ///
-/// Internally, `ZeroMap2d` stores four zero-copy vectors, one for each type argument plus
+/// Internally, [`ZeroMap2d`] stores four zero-copy vectors, one for each type argument plus
 /// one more to match between the two vectors of keys.
 ///
 /// # Examples
@@ -34,15 +31,15 @@ use crate::map::{MutableZeroVecLike, ZeroVecLike};
 /// use zerovec::ZeroMap2d;
 ///
 /// // Example byte buffer representing the map { 1: {2: "three" } }
-/// let BINCODE_BYTES: &[u8; 51] = &[
+/// let BINCODE_BYTES = &[
 ///     2, 0, 0, 0, 0, 0, 0, 0, 1, 0, 4, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 2, 0,
 ///     0, 0, 0, 0, 0, 0, 2, 0, 11, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 116,
 ///     104, 114, 101, 101,
 /// ];
 ///
 /// // Deserializing to ZeroMap requires no heap allocations.
-/// let zero_map: ZeroMap2d<u16, u16, str> =
-///     bincode::deserialize(BINCODE_BYTES)
+/// let zero_map =
+///     bincode::deserialize::<ZeroMap2d<u16, u16, str>>(BINCODE_BYTES)
 ///         .expect("Should deserialize successfully");
 /// assert_eq!(zero_map.get_2d(&1, &2), Some("three"));
 /// ```
@@ -119,7 +116,7 @@ where
     /// ```
     /// use zerovec::ZeroMap2d;
     ///
-    /// let zm: ZeroMap2d<u16, str, str> = ZeroMap2d::new();
+    /// let zm = ZeroMap2d::<u16, str, str>::new();
     /// assert!(zm.is_empty());
     /// ```
     pub fn new() -> Self {
@@ -205,7 +202,7 @@ where
     /// ```
     /// use zerovec::ZeroMap2d;
     ///
-    /// let mut map: ZeroMap2d<u16, u16, str> = ZeroMap2d::new();
+    /// let mut map = ZeroMap2d::<u16, u16, str>::new();
     /// map.insert(&1, &1, "foo");
     /// map.insert(&2, &3, "bar");
     /// map.insert(&2, &4, "baz");
@@ -590,7 +587,7 @@ where
     ///
     /// ```
     /// # use zerovec::ZeroMap2d;
-    /// let mut map: ZeroMap2d<u16, u16, u16> = ZeroMap2d::new();
+    /// let mut map = ZeroMap2d::<u16, u16, u16>::new();
     /// map.insert(&1, &2, &3);
     /// map.insert(&1, &4, &5);
     /// map.insert(&6, &7, &8);
diff --git a/utils/zerovec/src/ule/chars.rs b/utils/zerovec/src/ule/chars.rs
index e4c1efc4ec2..3ad045ea544 100644
--- a/utils/zerovec/src/ule/chars.rs
+++ b/utils/zerovec/src/ule/chars.rs
@@ -34,7 +34,7 @@ use core::convert::TryFrom;
 /// ```
 /// use zerovec::ule::{CharULE, ULE};
 ///
-/// let bytes: &[u8] = &[0xFF, 0xFF, 0xFF, 0xFF];
+/// let bytes = &[0xFF, 0xFF, 0xFF, 0xFF];
 /// CharULE::parse_byte_slice(bytes).expect_err("Invalid bytes");
 /// ```
 #[repr(transparent)]
diff --git a/utils/zerovec/src/ule/encode.rs b/utils/zerovec/src/ule/encode.rs
index adea123aa22..4b19beed2b2 100644
--- a/utils/zerovec/src/ule/encode.rs
+++ b/utils/zerovec/src/ule/encode.rs
@@ -344,9 +344,10 @@ mod test {
         let c: VZV<VZS<[u8]>> = VarZeroVec::from(&u8_3d_vec);
         let d: VZV<VZS<[u8]>> = VarZeroVec::from(u8_3d_vzv_brackets);
         assert_eq!(
-            a.iter()
-                .map(|x| x.iter().map(|y| y.to_vec()).collect::<Vec<Vec<u8>>>())
-                .collect::<Vec<Vec<Vec<u8>>>>(),
+            Vec::from_iter(
+                a.iter()
+                    .map(|x| Vec::from_iter(x.iter().map(|y| y.to_vec())))
+            ),
             u8_3d_vec
         );
         assert_eq!(a, b);
@@ -358,12 +359,10 @@ mod test {
         let c: VZV<VZS<ZS<u8>>> = VarZeroVec::from(&u8_3d_vec);
         let d: VZV<VZS<ZS<u8>>> = VarZeroVec::from(u8_3d_vzv_zeroslice);
         assert_eq!(
-            a.iter()
-                .map(|x| x
-                    .iter()
-                    .map(|y| y.iter().collect::<Vec<u8>>())
-                    .collect::<Vec<Vec<u8>>>())
-                .collect::<Vec<Vec<Vec<u8>>>>(),
+            Vec::from_iter(
+                a.iter()
+                    .map(|x| Vec::from_iter(x.iter().map(|y| Vec::from_iter(y.iter()))))
+            ),
             u8_3d_vec
         );
         assert_eq!(a, b);
@@ -385,12 +384,10 @@ mod test {
         let c: VZV<VZS<ZS<u32>>> = VarZeroVec::from(&u32_3d_vec);
         let d: VZV<VZS<ZS<u32>>> = VarZeroVec::from(u32_3d_vzv);
         assert_eq!(
-            a.iter()
-                .map(|x| x
-                    .iter()
-                    .map(|y| y.iter().collect::<Vec<u32>>())
-                    .collect::<Vec<Vec<u32>>>())
-                .collect::<Vec<Vec<Vec<u32>>>>(),
+            Vec::from_iter(
+                a.iter()
+                    .map(|x| Vec::from_iter(x.iter().map(|y| Vec::from_iter(y.iter()))))
+            ),
             u32_3d_vec
         );
         assert_eq!(a, b);
diff --git a/utils/zerovec/src/ule/niche.rs b/utils/zerovec/src/ule/niche.rs
index ae61faca0b0..9559c4addf5 100644
--- a/utils/zerovec/src/ule/niche.rs
+++ b/utils/zerovec/src/ule/niche.rs
@@ -34,8 +34,8 @@ pub trait NicheBytes<const N: usize> {
 /// use zerovec::ZeroVec;
 ///
 /// let bytes = &[0x00, 0x01, 0x02, 0x00];
-/// let zv_no: ZeroVec<NichedOption<NonZeroI8, 1>> =
-///     ZeroVec::parse_byte_slice(bytes)
+/// let zv_no =
+///     ZeroVec::<NichedOption<NonZeroI8, 1>>::parse_byte_slice(bytes)
 ///         .expect("Unable to parse as NichedOption.");
 ///
 /// assert_eq!(zv_no.get(0).map(|e| e.0), Some(None));
diff --git a/utils/zerovec/src/ule/option.rs b/utils/zerovec/src/ule/option.rs
index 9b0dc5b28a1..16ce2ec13fe 100644
--- a/utils/zerovec/src/ule/option.rs
+++ b/utils/zerovec/src/ule/option.rs
@@ -129,7 +129,7 @@ impl<U: Copy + Eq> Eq for OptionULE<U> {}
 /// use zerovec::ule::OptionVarULE;
 /// use zerovec::VarZeroVec;
 ///
-/// let mut zv: VarZeroVec<OptionVarULE<str>> = VarZeroVec::new();
+/// let mut zv = VarZeroVec::<OptionVarULE<str>>::new();
 ///
 /// zv.make_mut().push(&None::<&str>);
 /// zv.make_mut().push(&Some("hello"));
diff --git a/utils/zerovec/src/ule/tuple.rs b/utils/zerovec/src/ule/tuple.rs
index 3e0f291b3fa..945a9c75027 100644
--- a/utils/zerovec/src/ule/tuple.rs
+++ b/utils/zerovec/src/ule/tuple.rs
@@ -15,10 +15,7 @@
 //! use zerovec::ZeroVec;
 //!
 //! // ZeroVec of tuples!
-//! let zerovec: ZeroVec<(u32, char)> = [(1, 'a'), (1234901, '啊'), (100, 'अ')]
-//!     .iter()
-//!     .copied()
-//!     .collect();
+//! let zerovec = ZeroVec::<(u32, char)>::from_iter([(1, 'a'), (1234901, '啊'), (100, 'अ')]);
 //!
 //! assert_eq!(zerovec.get(1), Some((1234901, '啊')));
 //! ```
diff --git a/utils/zerovec/src/ule/unvalidated.rs b/utils/zerovec/src/ule/unvalidated.rs
index 21ede231926..5763b3a20d5 100644
--- a/utils/zerovec/src/ule/unvalidated.rs
+++ b/utils/zerovec/src/ule/unvalidated.rs
@@ -28,13 +28,11 @@ use core::ops::Deref;
 /// use zerovec::ule::UnvalidatedStr;
 /// use zerovec::ZeroMap;
 ///
-/// let map: ZeroMap<UnvalidatedStr, usize> = [
+/// let map = ZeroMap::<UnvalidatedStr, usize>::from_iter([
 ///     (UnvalidatedStr::from_str("abc"), 11),
 ///     (UnvalidatedStr::from_str("def"), 22),
 ///     (UnvalidatedStr::from_str("ghi"), 33),
-/// ]
-/// .into_iter()
-/// .collect();
+/// ]);
 ///
 /// let key = "abc";
 /// let value = map.get_copied_by(|uvstr| uvstr.as_bytes().cmp(key.as_bytes()));
@@ -229,11 +227,11 @@ where
 /// // ground truth expectation
 /// let real = ['h', 'i', '👋'];
 ///
-/// let chars: &ZeroSlice<UnvalidatedChar> = ZeroSlice::parse_byte_slice(&data).expect("invalid data length");
-/// let parsed: Vec<_> = chars.iter().map(|c| unsafe { c.to_char_unchecked() }).collect();
+/// let chars = ZeroSlice::<UnvalidatedChar>::parse_byte_slice(&data).expect("invalid data length");
+/// let parsed = Vec::from_iter(chars.iter().map(|c| unsafe { c.to_char_unchecked() }));
 /// assert_eq!(&parsed, &real);
 ///
-/// let real_chars: ZeroVec<_> = real.iter().copied().map(UnvalidatedChar::from_char).collect();
+/// let real_chars = ZeroVec::from_iter(real.iter().copied().map(UnvalidatedChar::from_char));
 /// let serialized_data = chars.as_bytes();
 /// assert_eq!(serialized_data, &data);
 /// ```
diff --git a/utils/zerovec/src/varzerovec/components.rs b/utils/zerovec/src/varzerovec/components.rs
index 80f79f0a9a9..61dd34ed367 100644
--- a/utils/zerovec/src/varzerovec/components.rs
+++ b/utils/zerovec/src/varzerovec/components.rs
@@ -383,12 +383,12 @@ impl<'a, T: VarULE + ?Sized, F: VarZeroVecFormat> VarZeroVecComponents<'a, T, F>
     // Dump a debuggable representation of this type
     #[allow(unused)] // useful for debugging
     pub(crate) fn dump(&self) -> String {
-        let indices = self
-            .indices_slice()
-            .iter()
-            .copied()
-            .map(F::rawbytes_to_usize)
-            .collect::<Vec<_>>();
+        let indices = Vec::from_iter(
+            self.indices_slice()
+                .iter()
+                .copied()
+                .map(F::rawbytes_to_usize),
+        );
         format!("VarZeroVecComponents {{ indices: {indices:?} }}")
     }
 }
diff --git a/utils/zerovec/src/varzerovec/serde.rs b/utils/zerovec/src/varzerovec/serde.rs
index 8025fc085b4..a6c84660ade 100644
--- a/utils/zerovec/src/varzerovec/serde.rs
+++ b/utils/zerovec/src/varzerovec/serde.rs
@@ -245,11 +245,7 @@ mod test {
 
     #[test]
     fn test_nonascii_bincode() {
-        let src_vec = NONASCII_STR
-            .iter()
-            .copied()
-            .map(Box::<str>::from)
-            .collect::<Vec<_>>();
+        let src_vec = Vec::from_iter(NONASCII_STR.iter().copied().map(Box::<str>::from));
         let mut zerovec: VarZeroVec<str> =
             VarZeroVec::parse_byte_slice(NONASCII_BYTES).expect("parse");
         assert_eq!(zerovec.to_vec(), src_vec);
diff --git a/utils/zerovec/src/varzerovec/slice.rs b/utils/zerovec/src/varzerovec/slice.rs
index 58703ac5340..4e9dd88b63a 100644
--- a/utils/zerovec/src/varzerovec/slice.rs
+++ b/utils/zerovec/src/varzerovec/slice.rs
@@ -55,24 +55,14 @@ use core::ops::Range;
 /// let vzv_34 = VarZeroVec::from(&[vzv_3.as_slice(), vzv_4.as_slice()]);
 /// let vzv_all = VarZeroVec::from(&[vzv_12.as_slice(), vzv_34.as_slice()]);
 ///
-/// let reconstructed: Vec<Vec<Vec<String>>> = vzv_all
-///     .iter()
-///     .map(|v: &VarZeroSlice<VarZeroSlice<str>>| {
-///         v.iter()
-///             .map(|x: &VarZeroSlice<_>| {
-///                 x.as_varzerovec()
-///                     .iter()
-///                     .map(|s| s.to_owned())
-///                     .collect::<Vec<String>>()
-///             })
-///             .collect::<Vec<_>>()
-///     })
-///     .collect::<Vec<_>>();
+/// let reconstructed = Vec::from_iter(
+///     vzv_all.iter()
+///     .map(|v| Vec::from_iter(v.iter().map(|x| Vec::from_iter(x.iter().map(ToOwned::to_owned))))));
 /// assert_eq!(reconstructed, all_strings);
 ///
 /// let bytes = vzv_all.as_bytes();
-/// let vzv_from_bytes: VarZeroVec<VarZeroSlice<VarZeroSlice<str>>> =
-///     VarZeroVec::parse_byte_slice(bytes).unwrap();
+/// let vzv_from_bytes =
+///     VarZeroVec::<VarZeroSlice<VarZeroSlice<str>>>::parse_byte_slice(bytes).unwrap();
 /// assert_eq!(vzv_from_bytes, vzv_all);
 /// ```
 ///
@@ -85,7 +75,7 @@ use core::ops::Range;
 /// use zerovec::VarZeroVec;
 ///
 /// let vzv = VarZeroVec::<str>::from(&["a", "b", "c", "d"]);
-/// # let mut pairs: Vec<(&str, &str)> = Vec::new();
+/// # let mut pairs = Vec::<(&str, &str)>::new();
 ///
 /// let mut it = vzv.iter().peekable();
 /// while let (Some(x), Some(y)) = (it.next(), it.peek()) {
@@ -156,7 +146,7 @@ impl<T: VarULE + ?Sized, F: VarZeroVecFormat> VarZeroSlice<T, F> {
     /// # use zerovec::ule::ZeroVecError;
     /// # use zerovec::VarZeroVec;
     ///
-    /// let strings: Vec<String> = vec![];
+    /// let strings = Vec::<String>::new();
     /// let vec = VarZeroVec::<str>::from(&strings);
     ///
     /// assert!(vec.is_empty());
@@ -177,7 +167,7 @@ impl<T: VarULE + ?Sized, F: VarZeroVecFormat> VarZeroSlice<T, F> {
     /// let strings = vec!["foo", "bar", "baz", "quux"];
     /// let vec = VarZeroVec::<str>::from(&strings);
     ///
-    /// let mut iter_results: Vec<&str> = vec.iter().collect();
+    /// let mut iter_results = Vec::from_iter(vec.iter());
     /// assert_eq!(iter_results[0], "foo");
     /// assert_eq!(iter_results[1], "bar");
     /// assert_eq!(iter_results[2], "baz");
@@ -199,7 +189,7 @@ impl<T: VarULE + ?Sized, F: VarZeroVecFormat> VarZeroSlice<T, F> {
     /// let strings = vec!["foo", "bar", "baz", "quux"];
     /// let vec = VarZeroVec::<str>::from(&strings);
     ///
-    /// let mut iter_results: Vec<&str> = vec.iter().collect();
+    /// let mut iter_results = Vec::from_iter(vec.iter());
     /// assert_eq!(vec.get(0), Some("foo"));
     /// assert_eq!(vec.get(1), Some("bar"));
     /// assert_eq!(vec.get(2), Some("baz"));
@@ -226,7 +216,7 @@ impl<T: VarULE + ?Sized, F: VarZeroVecFormat> VarZeroSlice<T, F> {
     /// let strings = vec!["foo", "bar", "baz", "quux"];
     /// let vec = VarZeroVec::<str>::from(&strings);
     ///
-    /// let mut iter_results: Vec<&str> = vec.iter().collect();
+    /// let mut iter_results = Vec::from_iter(vec.iter());
     /// unsafe {
     ///     assert_eq!(vec.get_unchecked(0), "foo");
     ///     assert_eq!(vec.get_unchecked(1), "bar");
diff --git a/utils/zerovec/src/varzerovec/vec.rs b/utils/zerovec/src/varzerovec/vec.rs
index 95d26b62b4b..1b231a98edb 100644
--- a/utils/zerovec/src/varzerovec/vec.rs
+++ b/utils/zerovec/src/varzerovec/vec.rs
@@ -76,7 +76,7 @@ use super::*;
 ///     bincode::serialize(&data).expect("Serialization should be successful");
 ///
 /// // Will deserialize without allocations
-/// let deserialized: Data = bincode::deserialize(&bincode_bytes)
+/// let deserialized = bincode::deserialize::<Data>(&bincode_bytes)
 ///     .expect("Deserialization should be successful");
 ///
 /// assert_eq!(deserialized.strings.get(2), Some("文"));
@@ -112,7 +112,7 @@ use super::*;
 /// let bincode_bytes =
 ///     bincode::serialize(&data).expect("Serialization should be successful");
 ///
-/// let deserialized: Data = bincode::deserialize(&bincode_bytes)
+/// let deserialized = bincode::deserialize::<Data>(&bincode_bytes)
 ///     .expect("Deserialization should be successful");
 ///
 /// assert_eq!(deserialized.vecs[0].get(1).unwrap(), 25);
@@ -169,7 +169,7 @@ pub enum VarZeroVec<'a, T: ?Sized, F = Index16> {
     ///     145, 132, 131,
     /// ];
     ///
-    /// let vzv: VarZeroVec<str> = VarZeroVec::parse_byte_slice(bytes).unwrap();
+    /// let vzv = VarZeroVec::<str>::parse_byte_slice(bytes).unwrap();
     /// assert!(matches!(vzv, VarZeroVec::Borrowed(_)));
     /// ```
     Borrowed(&'a VarZeroSlice<T, F>),
@@ -240,7 +240,7 @@ impl<'a, T: VarULE + ?Sized, F: VarZeroVecFormat> VarZeroVec<'a, T, F> {
     /// ```
     /// use zerovec::VarZeroVec;
     ///
-    /// let vzv: VarZeroVec<str> = VarZeroVec::new();
+    /// let vzv = VarZeroVec::<str>::new();
     /// assert!(vzv.is_empty());
     /// ```
     #[inline]
@@ -368,7 +368,7 @@ impl<'a, T: VarULE + ?Sized, F: VarZeroVecFormat> VarZeroVec<'a, T, F> {
     /// let strings = vec!["foo", "bar", "baz"];
     /// let bytes = VarZeroVec::<str>::from(&strings).into_bytes();
     ///
-    /// let mut borrowed: VarZeroVec<str> = VarZeroVec::parse_byte_slice(&bytes)?;
+    /// let mut borrowed = VarZeroVec::<str>::parse_byte_slice(&bytes)?;
     /// assert_eq!(borrowed, &*strings);
     ///
     /// # Ok::<(), ZeroVecError>(())
diff --git a/utils/zerovec/src/zerovec/mod.rs b/utils/zerovec/src/zerovec/mod.rs
index 50cbb3dd527..a08826aab40 100644
--- a/utils/zerovec/src/zerovec/mod.rs
+++ b/utils/zerovec/src/zerovec/mod.rs
@@ -65,7 +65,7 @@ use core::ptr::{self, NonNull};
 ///     bincode::serialize(&data).expect("Serialization should be successful");
 ///
 /// // Will deserialize without allocations
-/// let deserialized: Data = bincode::deserialize(&bincode_bytes)
+/// let deserialized = bincode::deserialize::<Data>(&bincode_bytes)
 ///     .expect("Deserialization should be successful");
 ///
 /// // This deserializes without allocation!
@@ -287,7 +287,7 @@ where
     /// ```
     /// use zerovec::ZeroVec;
     ///
-    /// let zv: ZeroVec<u16> = ZeroVec::new();
+    /// let zv = ZeroVec::<u16>::new();
     /// assert!(zv.is_empty());
     /// ```
     #[inline]
@@ -365,9 +365,9 @@ where
     /// ```
     /// use zerovec::ZeroVec;
     ///
-    /// let bytes: &[u8] = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x01];
-    /// let zerovec: ZeroVec<u16> =
-    ///     ZeroVec::parse_byte_slice(bytes).expect("infallible");
+    /// let bytes = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x01];
+    /// let zerovec =
+    ///     ZeroVec::<u16>::parse_byte_slice(bytes).expect("infallible");
     ///
     /// assert!(!zerovec.is_owned());
     /// assert_eq!(zerovec.get(2), Some(421));
@@ -401,9 +401,9 @@ where
     /// ```
     /// use zerovec::ZeroVec;
     ///
-    /// let bytes: &[u8] = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x01];
-    /// let zerovec: ZeroVec<u16> =
-    ///     ZeroVec::parse_byte_slice(bytes).expect("infallible");
+    /// let bytes = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x01];
+    /// let zerovec =
+    ///     ZeroVec::<u16>::parse_byte_slice(bytes).expect("infallible");
     /// let zv_bytes = zerovec.into_bytes();
     ///
     /// assert!(!zv_bytes.is_owned());
@@ -447,7 +447,7 @@ where
     /// ```
     /// use zerovec::ZeroVec;
     ///
-    /// let bytes: &[u8] = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x80];
+    /// let bytes = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x80];
     ///
     /// let zerovec_u16: ZeroVec<u16> =
     ///     ZeroVec::parse_byte_slice(bytes).expect("infallible");
@@ -481,9 +481,9 @@ where
     /// ```
     /// use zerovec::ZeroVec;
     ///
-    /// let bytes: &[u8] = &[0x7F, 0xF3, 0x01, 0x49, 0xF6, 0x01];
-    /// let zv_char: ZeroVec<char> =
-    ///     ZeroVec::parse_byte_slice(bytes).expect("valid code points");
+    /// let bytes = &[0x7F, 0xF3, 0x01, 0x49, 0xF6, 0x01];
+    /// let zv_char =
+    ///     ZeroVec::<char>::parse_byte_slice(bytes).expect("valid code points");
     /// let zv_u8_3: ZeroVec<[u8; 3]> =
     ///     zv_char.try_into_converted().expect("infallible conversion");
     ///
@@ -496,10 +496,9 @@ where
     /// ```
     /// use zerovec::ZeroVec;
     ///
-    /// let chars: &[char] = &['🍿', '🙉'];
-    /// let zv_char = ZeroVec::alloc_from_slice(chars);
-    /// let zv_u8_3: ZeroVec<[u8; 3]> =
-    ///     zv_char.try_into_converted().expect("length is divisible");
+    /// let zv_char = ZeroVec::alloc_from_slice(&['🍿', '🙉']);
+    /// let zv_u8_3 =
+    ///     zv_char.try_into_converted::<[u8; 3]>().expect("length is divisible");
     ///
     /// assert!(zv_u8_3.is_owned());
     /// assert_eq!(zv_u8_3.get(0), Some([0x7F, 0xF3, 0x01]));
@@ -510,9 +509,9 @@ where
     /// ```should_panic
     /// use zerovec::ZeroVec;
     ///
-    /// let bytes: &[u8] = &[0x7F, 0xF3, 0x01, 0x49, 0xF6, 0x01];
-    /// let zv_char: ZeroVec<char> =
-    ///     ZeroVec::parse_byte_slice(bytes).expect("valid code points");
+    /// let bytes = &[0x7F, 0xF3, 0x01, 0x49, 0xF6, 0x01];
+    /// let zv_char =
+    ///     ZeroVec::<char>::parse_byte_slice(bytes).expect("valid code points");
     ///
     /// // Panics! mem::size_of::<char::ULE> != mem::size_of::<u16::ULE>
     /// zv_char.try_into_converted::<u16>();
@@ -523,9 +522,9 @@ where
     /// ```
     /// use zerovec::ZeroVec;
     ///
-    /// let bytes: &[u8] = &[0x7F, 0xF3, 0x01, 0x49, 0xF6, 0x01];
-    /// let zv_char: ZeroVec<char> =
-    ///     ZeroVec::parse_byte_slice(bytes).expect("valid code points");
+    /// let bytes = &[0x7F, 0xF3, 0x01, 0x49, 0xF6, 0x01];
+    /// let zv_char =
+    ///     ZeroVec::<char>::parse_byte_slice(bytes).expect("valid code points");
     /// let zv_u16: ZeroVec<u16> =
     ///     zv_char.into_bytes().try_into_parsed().expect("infallible");
     ///
@@ -628,9 +627,9 @@ impl<'a> ZeroVec<'a, u8> {
     /// ```
     /// use zerovec::ZeroVec;
     ///
-    /// let bytes: &[u8] = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x01];
+    /// let bytes = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x01];
     /// let zv_bytes = ZeroVec::new_borrowed(bytes);
-    /// let zerovec: ZeroVec<u16> = zv_bytes.try_into_parsed().expect("infallible");
+    /// let zerovec = zv_bytes.try_into_parsed::<u16>().expect("infallible");
     ///
     /// assert!(!zerovec.is_owned());
     /// assert_eq!(zerovec.get(0), Some(211));
@@ -641,9 +640,9 @@ impl<'a> ZeroVec<'a, u8> {
     /// ```
     /// use zerovec::ZeroVec;
     ///
-    /// let bytes: Vec<u8> = vec![0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x01];
+    /// let bytes = vec![0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x01];
     /// let zv_bytes = ZeroVec::new_owned(bytes);
-    /// let zerovec: ZeroVec<u16> = zv_bytes.try_into_parsed().expect("infallible");
+    /// let zerovec = zv_bytes.try_into_parsed::<u16>().expect("infallible");
     ///
     /// assert!(zerovec.is_owned());
     /// assert_eq!(zerovec.get(0), Some(211));
@@ -676,7 +675,7 @@ where
     /// use zerovec::ZeroVec;
     ///
     /// // The little-endian bytes correspond to the numbers on the following line.
-    /// let bytes: &[u8] = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x01];
+    /// let bytes = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x01];
     /// let nums: &[u16] = &[211, 281, 421, 461];
     ///
     /// let zerovec = ZeroVec::alloc_from_slice(nums);
@@ -697,7 +696,7 @@ where
     /// use zerovec::ZeroVec;
     ///
     /// let nums: &[u16] = &[211, 281, 421, 461];
-    /// let vec: Vec<u16> = ZeroVec::alloc_from_slice(nums).to_vec();
+    /// let vec = ZeroVec::alloc_from_slice(nums).to_vec();
     ///
     /// assert_eq!(nums, vec.as_slice());
     /// ```
@@ -721,7 +720,7 @@ where
     /// use zerovec::ZeroVec;
     ///
     /// // The little-endian bytes correspond to the numbers on the following line.
-    /// let bytes: &[u8] = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x01];
+    /// let bytes = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x01];
     /// let nums: &[u16] = &[211, 281, 421, 461];
     ///
     /// if let Some(zerovec) = ZeroVec::try_from_slice(nums) {
@@ -746,7 +745,7 @@ where
     /// use zerovec::ZeroVec;
     ///
     /// // The little-endian bytes correspond to the numbers on the following line.
-    /// let bytes: &[u8] = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x01];
+    /// let bytes = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x01];
     /// let nums: &[u16] = &[211, 281, 421, 461];
     ///
     /// let zerovec = ZeroVec::from_slice_or_alloc(nums);
@@ -775,9 +774,9 @@ where
     /// ```
     /// use zerovec::ZeroVec;
     ///
-    /// let bytes: &[u8] = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x01];
-    /// let mut zerovec: ZeroVec<u16> =
-    ///     ZeroVec::parse_byte_slice(bytes).expect("infallible");
+    /// let bytes = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x01];
+    /// let mut zerovec =
+    ///     ZeroVec::<u16>::parse_byte_slice(bytes).expect("infallible");
     ///
     /// zerovec.for_each_mut(|item| *item += 1);
     ///
@@ -800,9 +799,9 @@ where
     /// ```
     /// use zerovec::ZeroVec;
     ///
-    /// let bytes: &[u8] = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x01];
-    /// let mut zerovec: ZeroVec<u16> =
-    ///     ZeroVec::parse_byte_slice(bytes).expect("infallible");
+    /// let bytes = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x01];
+    /// let mut zerovec =
+    ///     ZeroVec::<u16>::parse_byte_slice(bytes).expect("infallible");
     ///
     /// zerovec.try_for_each_mut(|item| {
     ///     *item = item.checked_add(1).ok_or(())?;
@@ -833,9 +832,9 @@ where
     /// ```
     /// use zerovec::ZeroVec;
     ///
-    /// let bytes: &[u8] = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x01];
-    /// let zerovec: ZeroVec<u16> =
-    ///     ZeroVec::parse_byte_slice(bytes).expect("infallible");
+    /// let bytes = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x01];
+    /// let zerovec =
+    ///     ZeroVec::<u16>::parse_byte_slice(bytes).expect("infallible");
     /// assert!(!zerovec.is_owned());
     ///
     /// let owned = zerovec.into_owned();
@@ -861,9 +860,9 @@ where
     /// # use crate::zerovec::ule::AsULE;
     /// use zerovec::ZeroVec;
     ///
-    /// let bytes: &[u8] = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x01];
-    /// let mut zerovec: ZeroVec<u16> =
-    ///     ZeroVec::parse_byte_slice(bytes).expect("infallible");
+    /// let bytes = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x01];
+    /// let mut zerovec =
+    ///     ZeroVec::<u16>::parse_byte_slice(bytes).expect("infallible");
     /// assert!(!zerovec.is_owned());
     ///
     /// zerovec.with_mut(|v| v.push(12_u16.to_unaligned()));
@@ -892,9 +891,9 @@ where
     /// # use crate::zerovec::ule::AsULE;
     /// use zerovec::ZeroVec;
     ///
-    /// let bytes: &[u8] = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x01];
-    /// let mut zerovec: ZeroVec<u16> =
-    ///     ZeroVec::parse_byte_slice(bytes).expect("infallible");
+    /// let bytes = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x01];
+    /// let mut zerovec =
+    ///     ZeroVec::<u16>::parse_byte_slice(bytes).expect("infallible");
     /// assert!(!zerovec.is_owned());
     ///
     /// zerovec.to_mut_slice()[1] = 5u16.to_unaligned();
@@ -923,9 +922,9 @@ where
     /// # use crate::zerovec::ule::AsULE;
     /// use zerovec::ZeroVec;
     ///
-    /// let bytes: &[u8] = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x01];
-    /// let mut zerovec: ZeroVec<u16> =
-    ///     ZeroVec::parse_byte_slice(bytes).expect("infallible");
+    /// let bytes = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x01];
+    /// let mut zerovec =
+    ///     ZeroVec::<u16>::parse_byte_slice(bytes).expect("infallible");
     /// assert!(!zerovec.is_owned());
     ///
     /// let first = zerovec.take_first().unwrap();
@@ -967,9 +966,9 @@ where
     /// # use crate::zerovec::ule::AsULE;
     /// use zerovec::ZeroVec;
     ///
-    /// let bytes: &[u8] = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x01];
-    /// let mut zerovec: ZeroVec<u16> =
-    ///     ZeroVec::parse_byte_slice(bytes).expect("infallible");
+    /// let bytes = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x01];
+    /// let mut zerovec =
+    ///     ZeroVec::<u16>::parse_byte_slice(bytes).expect("infallible");
     /// assert!(!zerovec.is_owned());
     ///
     /// let last = zerovec.take_last().unwrap();
diff --git a/utils/zerovec/src/zerovec/slice.rs b/utils/zerovec/src/zerovec/slice.rs
index 12d88deff8e..1c08a4b0ee7 100644
--- a/utils/zerovec/src/zerovec/slice.rs
+++ b/utils/zerovec/src/zerovec/slice.rs
@@ -102,7 +102,7 @@ where
     /// use zerovec::ZeroVec;
     ///
     /// // The little-endian bytes correspond to the numbers on the following line.
-    /// let bytes: &[u8] = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x80];
+    /// let bytes = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x80];
     /// let nums: &[u16] = &[211, 281, 421, 32973];
     ///
     /// let zerovec = ZeroVec::alloc_from_slice(nums);
@@ -128,9 +128,9 @@ where
     /// use zerovec::ule::AsULE;
     /// use zerovec::ZeroVec;
     ///
-    /// let bytes: &[u8] = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x80];
-    /// let zerovec: ZeroVec<u16> =
-    ///     ZeroVec::parse_byte_slice(bytes).expect("infallible");
+    /// let bytes = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x80];
+    /// let zerovec =
+    ///     ZeroVec::<u16>::parse_byte_slice(bytes).expect("infallible");
     ///
     /// assert_eq!(4, zerovec.len());
     /// assert_eq!(
@@ -150,13 +150,12 @@ where
     /// ```
     /// use zerovec::ZeroVec;
     ///
-    /// let bytes: &[u8] = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x80];
-    /// let zerovec: ZeroVec<u16> =
-    ///     ZeroVec::parse_byte_slice(bytes).expect("infallible");
+    /// let zerovec =
+    ///     ZeroVec::<u16>::from_iter([1,2,3]);
     /// assert!(!zerovec.is_empty());
     ///
-    /// let emptyvec: ZeroVec<u16> =
-    ///     ZeroVec::parse_byte_slice(&[]).expect("infallible");
+    /// let emptyvec =
+    ///     ZeroVec::<u16>::new();
     /// assert!(emptyvec.is_empty());
     /// ```
     #[inline]
@@ -176,9 +175,9 @@ where
     /// ```
     /// use zerovec::ZeroVec;
     ///
-    /// let bytes: &[u8] = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x80];
-    /// let zerovec: ZeroVec<u16> =
-    ///     ZeroVec::parse_byte_slice(bytes).expect("infallible");
+    /// let bytes = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x80];
+    /// let zerovec =
+    ///     ZeroVec::<u16>::parse_byte_slice(bytes).expect("infallible");
     ///
     /// assert_eq!(zerovec.get(2), Some(421));
     /// assert_eq!(zerovec.get(4), None);
@@ -199,11 +198,11 @@ where
     /// ```
     /// use zerovec::ZeroVec;
     ///
-    /// let bytes: &[u8] = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x80];
-    /// let zerovec: ZeroVec<u16> =
-    ///     ZeroVec::parse_byte_slice(bytes).expect("infallible");
-    /// let array: [u16; 4] =
-    ///     zerovec.get_as_array().expect("should be 4 items in array");
+    /// let bytes = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x80];
+    /// let zerovec =
+    ///     ZeroVec::<u16>::parse_byte_slice(bytes).expect("infallible");
+    /// let array =
+    ///     zerovec.get_as_array::<4>().expect("should be 4 items in array");
     ///
     /// assert_eq!(array[2], 421);
     /// ```
@@ -220,9 +219,9 @@ where
     /// ```
     /// use zerovec::ZeroVec;
     ///
-    /// let bytes: &[u8] = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x80];
-    /// let zerovec: ZeroVec<u16> =
-    ///     ZeroVec::parse_byte_slice(bytes).expect("infallible");
+    /// let bytes = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x80];
+    /// let zerovec =
+    ///     ZeroVec::<u16>::parse_byte_slice(bytes).expect("infallible");
     ///
     /// assert_eq!(
     ///     zerovec.get_subslice(1..3),
@@ -295,8 +294,8 @@ where
     ///     }
     /// };
     ///
-    /// let zs_u8_4: &ZeroSlice<[u8; 4]> =
-    ///     ZS_U32.try_as_converted().expect("valid code points");
+    /// let zs_u8_4 =
+    ///     ZS_U32.try_as_converted::<[u8; 4]>().expect("valid code points");
     ///
     /// assert_eq!(ZS_U32.get(0), Some(127871));
     /// assert_eq!(zs_u8_4.get(0), Some([0x7F, 0xF3, 0x01, 0x00]));
@@ -314,9 +313,9 @@ where
     /// ```
     /// use zerovec::ZeroVec;
     ///
-    /// let bytes: &[u8] = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x80];
-    /// let zerovec: ZeroVec<u16> =
-    ///     ZeroVec::parse_byte_slice(bytes).expect("infallible");
+    /// let bytes = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x80];
+    /// let zerovec =
+    ///     ZeroVec::<u16>::parse_byte_slice(bytes).expect("infallible");
     ///
     /// assert_eq!(zerovec.first(), Some(211));
     /// ```
@@ -332,9 +331,9 @@ where
     /// ```
     /// use zerovec::ZeroVec;
     ///
-    /// let bytes: &[u8] = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x80];
-    /// let zerovec: ZeroVec<u16> =
-    ///     ZeroVec::parse_byte_slice(bytes).expect("infallible");
+    /// let bytes = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x80];
+    /// let zerovec =
+    ///     ZeroVec::<u16>::parse_byte_slice(bytes).expect("infallible");
     ///
     /// assert_eq!(zerovec.last(), Some(32973));
     /// ```
@@ -350,9 +349,9 @@ where
     /// ```
     /// use zerovec::ZeroVec;
     ///
-    /// let bytes: &[u8] = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x80];
-    /// let zerovec: ZeroVec<u16> =
-    ///     ZeroVec::parse_byte_slice(bytes).expect("infallible");
+    /// let bytes = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x80];
+    /// let zerovec =
+    ///     ZeroVec::<u16>::parse_byte_slice(bytes).expect("infallible");
     /// let mut it = zerovec.iter();
     ///
     /// assert_eq!(it.next(), Some(211));
@@ -412,9 +411,9 @@ where
     /// ```
     /// use zerovec::ZeroVec;
     ///
-    /// let bytes: &[u8] = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x80];
-    /// let zerovec: ZeroVec<u16> =
-    ///     ZeroVec::parse_byte_slice(bytes).expect("infallible");
+    /// let bytes = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x80];
+    /// let zerovec =
+    ///     ZeroVec::<u16>::parse_byte_slice(bytes).expect("infallible");
     ///
     /// assert_eq!(zerovec.binary_search(&281), Ok(1));
     /// assert_eq!(zerovec.binary_search(&282), Err(2));
@@ -440,9 +439,9 @@ where
     /// ```
     /// use zerovec::ZeroVec;
     ///
-    /// let bytes: &[u8] = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x80];
-    /// let zerovec: ZeroVec<u16> =
-    ///     ZeroVec::parse_byte_slice(bytes).expect("infallible");
+    /// let bytes = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x80];
+    /// let zerovec =
+    ///     ZeroVec::<u16>::parse_byte_slice(bytes).expect("infallible");
     ///
     /// assert_eq!(zerovec.binary_search_by(|x| x.cmp(&281)), Ok(1));
     /// assert_eq!(zerovec.binary_search_by(|x| x.cmp(&282)), Err(2));