# Array EX
This crate provides an easy and powerful method of initializing arrays at compile time.
```rust
const ARRAY: [usize; 8] = array_ex::array![
// specify element type
usize,
// add 1, 2, 3
[1, 2, 3],
// add zero until 8 elements
[0; ..8]
];
assert_eq!(
ARRAY,
[1, 2, 3, 0, 0, 0, 0, 0],
)
```
There are multiple methods of adding array elements:
```rust
array![usize,
// directly add elements
[1, 2, 3, 4],
[1; 4],
// cycle all elements n times
[* [1, 2, 3]; 3]
// repeat element until array contains n elements
[0; ..10],
// cycle elements until array contains n elements
[* [1, 2, 3]; ..10],
// add another instantiated array
[* array![usize, [1, 2, 3], [0; ..5]] ],
// cycle another instantiated array
[* array![usize, [1, 2], [0; ..4]]; 3],
// add another constant array
[* OTHER_CONSTANT_ARRAY],
];
```
## Why?
By default, rust's compile-time array initialization methods are not very useful.
You either have to manually specify every element (`[a, b, c]`) or you are restricted to only a single element (`[a; n]`).
This macro covers many more use-cases for initializing static arrays.
## Caveats
- The `*` symbol is needed to diambiguate cycling elements with constructing an array of arrays.
For example, `array![ [usize; 2], [[1, 2]; 3] ]` would not be parsed correctly otherwise.
- Error messages are NOT pretty.
- Unsafe code is used to avoid requiring `Default` to be derived for the element type.
The code is safe - arrays are guaranteed to be constructed at compile-time, which automatically checks for UB.
- There may be cases that elements defined by function calls (such as `array![u8, [* gen_array(); 100]]`) will be constructed multiple times.
This may lead to bloated compile times. You can extract these function calls out to avoid regenerating arrays.
- Constructing large arrays in general will degrade compile times. Construction is generally instantaneous up to 10_000 elements.