Add [Option<T>; N]::transpose

Author: Urgau

library/core/src/option.rs

@@ -557,6 +557,7 @@
 #![stable(feature = "rust1", since = "1.0.0")]
 
 use crate::iter::{self, FusedIterator, TrustedLen};
+use crate::mem::MaybeUninit;
 use crate::ops::{self, ControlFlow, Deref, DerefMut};
 use crate::panicking::{panic, panic_display};
 use crate::pin::Pin;
@@ -2545,3 +2546,43 @@ impl<T> Option<Option<T>> {
         }
     }
 }
+
+impl<T, const N: usize> [Option<T>; N] {
+    /// Transposes a `[Option<T>; N]` into a `Option<[T; N]>`.
+    ///
+    /// This will return `Some` only if every input element is `Some`. If any element is `None`,
+    /// all values are dropped and this returns `None`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(option_array_transpose)]
+    ///
+    /// let data = [Some(0); 1000];
+    /// let data: Option<[u8; 1000]> = data.transpose();
+    /// assert_eq!(data, Some([0; 1000]));
+    ///
+    /// let data = [Some(0), None];
+    /// let data: Option<[u8; 2]> = data.transpose();
+    /// assert_eq!(data, None);
+    /// ```
+    #[inline]
+    #[unstable(feature = "option_array_transpose", issue = "130828")]
+    pub fn transpose(self) -> Option<[T; N]> {
+        let mut array: MaybeUninit<[T; N]> = MaybeUninit::uninit();
+        let array_mut = array.as_mut_ptr();
+
+        for (i, e) in self.into_iter().enumerate() {
+            match e {
+                // SAFETY: `i` is always inbounds
+                Some(e) => unsafe {
+                    *(*array_mut).get_unchecked_mut(i) = e;
+                },
+                None => return None,
+            }
+        }
+
+        // SAFETY: All the elements have been initialized
+        Some(unsafe { array.assume_init() })
+    }
+}