MaybeUninit
Initially added:
In previous releases of Rust, the mem::uninitialized function has allowed
you to bypass Rust's initialization checks by pretending that you've
initialized a value at type T without doing anything. One of the main uses
of this function has been to lazily allocate arrays.
However, mem::uninitialized is an incredibly dangerous operation that
essentially cannot be used correctly as the Rust compiler assumes that values
are properly initialized. For example, calling mem::uninitialized::<bool>()
causes instantaneous undefined behavior as, from Rust's point of view,
the uninitialized bits are neither 0 (for false) nor 1 (for true) -
the only two allowed bit patterns for bool.
To remedy this situation, in Rust 1.36.0, the type MaybeUninit<T> has
been stabilized. The Rust compiler will understand that it should not assume
that a MaybeUninit<T> is a properly initialized T. Therefore, you can
do gradual initialization more safely and eventually use .assume_init()
once you are certain that maybe_t: MaybeUninit<T> contains an initialized
T.
As MaybeUninit<T> is the safer alternative, starting with Rust 1.39, the
function mem::uninitialized will be deprecated.