Is there a way to not have to initialize arrays twice?

Question

I need to initialize each element of an array to a non-constant expression. Can I do that without having to first initialize each element of the array to some meaningless expression? Here's an example of what I'd like to be able to do:

fn foo(xs: &[i32; 1000]) {
    let mut ys: [i32; 1000];

    for (x, y) in xs.iter().zip(ys.iter_mut()) {
        *y = *x / 3;
    }
    // ...
}

This code gives the compile-time error:

error[E0381]: borrow of possibly uninitialized variable: `ys`
 --> src/lib.rs:4:33
  |
4 |     for (x, y) in xs.iter().zip(ys.iter_mut()) {
  |                                 ^^ use of possibly uninitialized `ys`

To fix the problem, I need to change the first line of the function to initialize the elements of ys with some dummy values like so:

let mut ys: [i32; 1000] = [0; 1000];

Is there any way to omit that extra initialization? Wrapping everything in an unsafe block doesn't seem to make any difference.

Answer 1

NOTE: This is an old answer, std::mem::uninitialized have been deprecating in 1.38.0: use mem::MaybeUninit instead

---

In some cases, you can use std::mem::uninitialized:

let mut ys: [i32; 1000] = unsafe { std::mem::uninitialized() };

This is unsafe because accessing uninitialized values is undefined behavior in Rust and the compiler can no longer guarantee that every value of ys will be initialized before it is read. It can also easily cause undefined behavior if the type inside the array (i32 here) is not valid for all possible bit patterns. This means that something like std::mem::uninitialized::<[&i32; 1]>() is immediate undefined behavior, regardless of what you do to the array afterwards.

You cannot collect into an array, but if you had a Vec instead, you could do:

let ys: Vec<_> = xs.iter().map(|&x| x / 3).collect();

For your specific problem, you could also clone the incoming array and then mutate it:

let mut ys = xs.clone();
for y in ys.iter_mut() { *y = *y / 3 }