Add index/iter methods for MaybeUninit<[T; N]>

[kpp]

While it's possible to create a MaybeUninit::<[T; N]> there is no way to index elements to initialize them other than to call .as_mut_ptr() and index over a raw pointer. I added several methods to make life a little bit easier. The idea is to get &[mut] MaybeUninit<T> from MaybeUninit<[T; N]> either through index or iter methods.

Use cases

#[test]
fn uninit_array_iter_mut() {
    let mut v = MaybeUninit::<[i32; 4]>::uninit();

    v.iter_mut().zip(1..=4).for_each(|(v, val)| {
        v.write(val);
    });

    let v = unsafe { v.assume_init() };
    assert_eq!(v, [1, 2, 4, 8]);
}

[rust-highfive]

r? @yaahc

(rust-highfive has picked a reviewer for you, use r? to override)

[the8472]

That seems redundant with uninit_array and array_assume_init.

Maybe conversions between [MaybeUninit<T>; N] and MaybeUninit<[T; N]> should be added instead?

[nbdd0121]

I agree with @the8472 that this is redundant, and uninit_array and array_assume_init should be used instead.

Plus, implementation of stable trait of stable type is insta-stable. The unstable annotation has no effect. Therefore this would need libs team signoff.

[kpp]

I guess you are right. ::transpose()?

[nbdd0121]

What code would benefit from the transpose method?

[kpp]

Same as assume_init_ref/mut. This can be useful when we want to access it but don’t have ownership of the MaybeUninit.

[the8472]

No new method is needed, two From impls should do the job.

[crlf0710]

@kpp Ping from triage, seems CI is still red here.

[rust-log-analyzer]

The job mingw-check failed! Check out the build log: (web) (plain)

Click to see the possible cause of the failure (guessed by this bot)

   Compiling unwind v0.0.0 (/checkout/library/unwind)
error: implementation has missing stability attribute
    --> library/core/src/mem/maybe_uninit.rs:1164:1
     |
1164 | / impl<T, const N: usize> Index<usize> for MaybeUninit<[T; N]> {
1165 | |     type Output = MaybeUninit<T>;
1167 | |     #[inline]
...    |
1170 | |     }
1171 | | }
1171 | | }
     | |_^

error: implementation has missing stability attribute
    --> library/core/src/mem/maybe_uninit.rs:1173:1
     |
1173 | / impl<T, const N: usize> IndexMut<usize> for MaybeUninit<[T; N]> {
1175 | |     fn index_mut(&mut self, index: usize) -> &mut Self::Output {
1176 | |         IndexMut::index_mut(self.as_mut(), index)
1177 | |     }
1178 | | }
1178 | | }
     | |_^

error: implementation has missing stability attribute
    --> library/core/src/mem/maybe_uninit.rs:1180:1
     |
1180 | / impl<T, const N: usize> AsRef<[MaybeUninit<T>]> for MaybeUninit<[T; N]> {
1181 | |     #[inline]
1182 | |     fn as_ref(&self) -> &[MaybeUninit<T>] {
1183 | |         let data = self.as_ptr().cast::<MaybeUninit<T>>();
1187 | |     }
1188 | | }
     | |_^


error: implementation has missing stability attribute
    --> library/core/src/mem/maybe_uninit.rs:1190:1
     |
1190 | / impl<T, const N: usize> AsMut<[MaybeUninit<T>]> for MaybeUninit<[T; N]> {
1191 | |     #[inline]
1192 | |     fn as_mut(&mut self) -> &mut [MaybeUninit<T>] {
1193 | |         let data = self.as_mut_ptr().cast::<MaybeUninit<T>>();
1197 | |     }
1198 | | }
     | |_^


error: implementation has missing stability attribute
    --> library/core/src/mem/maybe_uninit.rs:1200:1
     |
1200 | / impl<'a, T, const N: usize> IntoIterator for &'a mut MaybeUninit<[T; N]> {
1201 | |     type Item = &'a mut MaybeUninit<T>;
1202 | |     type IntoIter = IterMut<'a, MaybeUninit<T>>;
...    |
1206 | |     }
1207 | | }
     | |_^
     | |_^

error: missing documentation for an associated function
    --> library/core/src/mem/maybe_uninit.rs:1211:5
     |
1211 |     pub fn iter_mut(&mut self) -> IterMut<'_, MaybeUninit<T>> {
     |
     |
     = note: `-D missing-docs` implied by `-D warnings`
error: could not compile `core` due to 6 previous errors
Build completed unsuccessfully in 0:01:16

[kpp]

I can't fight with implementation has missing stability attribute vs this stability annotation is useless. Would you please help me?

[the8472]

The impl block for a trait needs a stability attribute, not the methods. But it must be stable since trait impls are insta-stable.
For inherent impls it's the other way around, the methods need the annotation but not the block. And there methods can be unstable.

[JohnCSimon]

Ping from triage:
@kpp Can you please address the comment from the reviewer, and, if necessary set S-waiting-on-review? Thank you.

[bors]

☔ The latest upstream changes (presumably #91311) made this pull request unmergeable. Please resolve the merge conflicts.

[JohnCSimon]

Ping from triage:
@kpp
I'm closing this due to inactivity, please feel to reopen when you are ready to continue with this. Thank you.