array-init 0.0.4

Safe wrapper for initializing fixed-size arrays
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

# array-init

[Documentation](https://docs.rs/array-init)

[Crates.io](https://crates.io/crates/array-init)


(still kinda experimental, API may change, may be secretly unsafe)

The `array-init` crate allows you to initialize arrays
with an initializer closure that will be called
once for each element until the array is filled.

This way you do not need to default-fill an array
before running initializers. Rust currently only
lets you either specify all initializers at once,
individually (`[a(), b(), c(), ...]`), or specify
one initializer for a `Copy` type (`[a(); N]`),
which will be called once with the result copied over.

# Examples:

```rust
# #![allow(unused)]
# extern crate array_init;

// Initialize an array of length 50 containing
// successive squares

let arr: [u32; 50] = array_init::array_init(|i| (i*i) as u32);

// Initialize an array from an iterator
// producing an array of [1,2,3,4] repeated

let four = [1u32,2,3,4];
let mut iter = four.iter().cloned().cycle();
let arr: [u32; 50] = array_init::from_iter(iter).unwrap();

// Closures can also mutate state. We guarantee that they will be called
// in order from lower to higher indices.

let mut last = 1u64;
let mut secondlast = 0;
let fibonacci: [u64; 50] = array_init::array_init(|_| {
    let this = last + secondlast;
    secondlast = last;
    last = this;
    this
});
```

Currently, using `from_iter` and `array_init` will incur additional
memcpys, which may be undesirable for a large array. This can be eliminated
by using the nightly feature of this crate, which uses unions to provide
panic-safety. Alternatively, if your array only contains `Copy` types,
you can use `array_init_copy` and `from_iter_copy`.

Sadly, cannot guarantee right now that any of these solutions will completely
eliminate a memcpy.