From 03862a553839ad51c24bad8e6742eb1fb2612817 Mon Sep 17 00:00:00 2001
From: Maybe Waffle <waffle.lapkin@gmail.com>
Date: Mon, 30 Jan 2023 08:56:37 +0000
Subject: [PATCH 1/2] Implement `FromIterator<(AE, BE)>` for `(impl
 Default+Extend<AE>, impl Default+Extend<BE>)`

---
 library/core/src/iter/traits/collect.rs | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/library/core/src/iter/traits/collect.rs b/library/core/src/iter/traits/collect.rs
index d89801bce2b6d..788edfc3f8f9e 100644
--- a/library/core/src/iter/traits/collect.rs
+++ b/library/core/src/iter/traits/collect.rs
@@ -150,6 +150,20 @@ pub trait FromIterator<A>: Sized {
     fn from_iter<T: IntoIterator<Item = A>>(iter: T) -> Self;
 }
 
+#[stable(feature = "from_iterator_for_tuple", since = "CURRENT_RUSTC_VERSION")]
+impl<A, B, AE, BE> FromIterator<(AE, BE)> for (A, B)
+where
+    A: Default + Extend<AE>,
+    B: Default + Extend<BE>,
+{
+    fn from_iter<I: IntoIterator<Item = (AE, BE)>>(iter: I) -> Self {
+        let mut res = <(A, B)>::default();
+        res.extend(iter);
+
+        res
+    }
+}
+
 /// Conversion into an [`Iterator`].
 ///
 /// By implementing `IntoIterator` for a type, you define how it will be

From 7b5af57303d0b870959e8171240d8aa03bf0eec9 Mon Sep 17 00:00:00 2001
From: Maybe Waffle <waffle.lapkin@gmail.com>
Date: Wed, 3 Apr 2024 17:48:54 +0000
Subject: [PATCH 2/2] Add docs for `FromIterator<(AE, BE)> for (A, B)`

---
 library/core/src/iter/traits/collect.rs | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/library/core/src/iter/traits/collect.rs b/library/core/src/iter/traits/collect.rs
index 788edfc3f8f9e..2ebbe2bf2743c 100644
--- a/library/core/src/iter/traits/collect.rs
+++ b/library/core/src/iter/traits/collect.rs
@@ -150,6 +150,25 @@ pub trait FromIterator<A>: Sized {
     fn from_iter<T: IntoIterator<Item = A>>(iter: T) -> Self;
 }
 
+/// This implementation turns an iterator of tuples into a tuple of types which implement
+/// [`Default`] and [`Extend`].
+///
+/// This is similar to [`Iterator::unzip`], but is also composable with other [`FromIterator`]
+/// implementations:
+///
+/// ```rust
+/// # fn main() -> Result<(), core::num::ParseIntError> {
+/// let string = "1,2,123,4";
+///
+/// let (numbers, lengths): (Vec<_>, Vec<_>) = string
+///     .split(',')
+///     .map(|s| s.parse().map(|n: u32| (n, s.len())))
+///     .collect::<Result<_, _>>()?;
+///
+/// assert_eq!(numbers, [1, 2, 123, 4]);
+/// assert_eq!(lengths, [1, 1, 3, 1]);
+/// # Ok(()) }
+/// ```
 #[stable(feature = "from_iterator_for_tuple", since = "CURRENT_RUSTC_VERSION")]
 impl<A, B, AE, BE> FromIterator<(AE, BE)> for (A, B)
 where