Initialize a large, fixed-size array with non-Copy types

As of Rust 1.79 (released in June 2024), this can be very easily achieved using inline const:

struct Thing;

fn main() {
    const SIZE: usize = 100;
    let _array: [Option<Box<Thing>>; SIZE] = [const { None }; SIZE];
}

Playground

That also works for initializing static variables.

If you need to support older Rust versions, a cleaner alternative to previously posted answers is possible using std::array::from_fn(). That requires Rust 1.63 (released in August 2022) or later and looks like this:

const SIZE: usize = 100;
let array: [Option<Box<Thing>>; SIZE] = std::array::from_fn(|_| None);

Playground

If you need to support Rust versions older than 1.63, or if you need to initialize a static, an alternative approach using an intermediate const initializer works as of Rust 1.38 (released in September 2019):

const SIZE: usize = 100;
const INIT: Option<Box<Thing>> = None; // helper
// also works with static array
let array: [Option<Box<Thing>>; SIZE] = [INIT; SIZE]; 

Playground

The first and the last approach have the limitation that the array item must have a representation that can be evaluated at compile time - a constant, enum variant, empty Vec or String, or a primitive container (enum, tuple) composed of those. None or a tuple of numbers will work, but a non-empty Vec or String won't. The array::from_fn() approach has no such limitation.

All the above examples work with or without the Box; they use Box because that was used in the question. All work for arrays of any size.

You could use the Default trait to initialize the array with default values:

let array: [Option<Box<Thing>>; SIZE] = Default::default();

See this playground for a working example.

Note that this will only work for arrays with up to 32 elements, because Default::default is only implemented for up to [T; 32]. See https://doc.rust-lang.org/std/default/trait.Default.html#impl-Default-for-%5BT%3B%2032%5D.

As of Rust 1.55.0 (which introduced <[T; N]>::map()), the following will work:

const SIZE: usize = 100;

#[derive(Debug)]
struct THING { data: i64 }

let array = [(); SIZE].map(|_| Option::<THING>::default());
for x in array {
    println!("x: {:?}", x);
}

Rust Playground

I'm copying the answer by chris-morgan and adapting it to match the question better, to follow the recommendation by dbaupp downthread, and to match recent syntax changes:

use std::mem;
use std::ptr;

#[derive(Debug)]
struct Thing {
    number: usize,
}

macro_rules! make_array {
    ($n:expr, $constructor:expr) => {{
        let mut items: [_; $n] = mem::uninitialized();
        for (i, place) in items.iter_mut().enumerate() {
            ptr::write(place, $constructor(i));
        }
        items
    }}
}

const SIZE: usize = 50;

fn main() {
    let items = unsafe { make_array!(SIZE, |i| Box::new(Some(Thing { number: i }))) };
    println!("{:?}", &items[..]);
}

Note the need to use unsafe here: The problem is that if the constructor function panic!s, this would lead to undefined behavior.

Go through the heap

If you can create a Vec of your type, you can convert it into an array:

use std::convert::TryInto;

#[derive(Clone)]
struct Thing;
const SIZE: usize = 100;

fn main() {
    let v: Vec<Option<Thing>> = vec![None; SIZE];
    let v: Box<[Option<Thing>; SIZE]> = match v.into_boxed_slice().try_into() {
        Ok(v) => v,
        Err(_) => unreachable!(),
    };
    let v: [Option<Thing>; SIZE] = *v;
}

In many cases, you actually want to leave it as a Vec<T>, Box<[T]>, or Box<[T; N]> as these types all put the data in the heap. Large arrays tend to be... large... and you don't want all that data on the stack.

See also:

• What is the use of into_boxed_slice() methods?
• How to get a slice as an array in Rust?
• How do I get an owned value out of a `Box`?

Keep it simple

Type out all the values:

struct Thing;
const SIZE: usize = 5;

fn main() {
    let array: [Option<Box<Thing>>; SIZE] = [None, None, None, None, None];
}

You could use a build script to generate this code for you. For an example of this, see:

• How to create a static string at compile time

let stackoverflow: [Option<&mut ()>;0xDEADBEEF] = std::array::from_fn(|_| None);
dbg!(stackoverflow);

playground

Since 1.79.0, you can use inline const. This is a variant of the answer by @user4815162342, but one that doesn't require you to declare a separate constant and repeat the type:

let array: [Option<Box<Thing>>; SIZE] = [const { None }; SIZE];

Until this is stabilized, you can also use the inline-const crate, but this does require you to repeat the type.

An alternative approach using the arrayvec crate that generalizes easily to situations other than initializing everything with a fixed value:

use arrayvec::ArrayVec;

let array = std::iter::repeat(None)
    .take(SIZE)
    .collect::<ArrayVec<Option<Box<Thing>>, SIZE>>()
    .into_inner()
    .unwrap();

(playground)

As of Rust 1.91.0, the following is possible:

let x= std::array::repeat::<_,10>( Vec::<u8>::new() ) ;

It works with any type supporting Clone instead of the more restrictive Copy. As Rust 1.91.0+ is adopted, it should become the most idiomatic solution.

Additionally, Rust 1.63.0 introduced function std::array::from_fn, which accepts a closure mapping indexes to the new elements. It covers a much broader range of scenarios and should also become idiomatic.