Default Array-of-Option\

Macros to make your life easier when dealing with default-initialized arrays of Option<T> or Cell<Option<T>> for non-Copy types of T to [None, ..].

You may need it if ...

• You need an array of [Option<T>; N] initialized to [None; N], or
• You need an array of [Cell<Option<T>>; N] initialized to [Cell::new(None); N], or
• You need an array of [RefCell<Option<T>>; N] initialized to [RefCell::new(None); N].

You will not need it if ...

• Your types already implement Copy or Clone and you don't need cells.
• You require #![forbid(unsafe_code)].

Examples

```rust use std::cell::Cell; use arraysetcell::ArraySetCell;

// This type does not implement Copy. struct Complicated;

fn it_works() { // This doesn't compile: let arr: [Option; 10] = [None; 10];

// This does:
let arr = none_arr![Complicated; 10];

// [None, None, None, ...]
assert_eq!(arr.len(), 10);
for item in arr.into_iter() {
    assert!(item.is_none());
}

// The created type is an array.
let arr: [Option<Complicated>; 10] = arr;
assert_eq!(arr.len(), 10);

} ```

Likewise, arrays of Cell<Option<T>> can be created.

rust fn cell_works() { let arr: [Cell<Option<Complicated>>; 10] = none_cell_arr![Complicated; 10]; let arr: [RefCell<Option<Complicated>>; 10] = none_refcell_arr![Complicated; 10]; }

I cannot have unsafe code

If you cannot have unsafe code in your project, something like the following can be used:

rust fn not_fun() { let arr: [Option<Complicated>; 10] = (0..10) .into_iter() .map(|_| None) .collect::<Vec<_>>() .try_into() .map_err(|_| "try_into failed") // Debug required otherwise .expect("initialization failed"); }