split-spare 0.1.0

A trait to allow referencing the already initialized part of a collection while pushing into it's reserved capacity.
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

Allows referring to already initialized elements in a `Vec<T>` and similar data-types while pushing more elements into its reserved capacity.

```rust
// Create a vec with 3 elements.
let mut vec = vec![1, 2, 3];

// Reserve room for 3 more elements and split the vec into initialized and spare parts.
let (init, mut spare) = vec.reserve_split_spare(3);

assert_eq!(init, &[1, 2, 3]);

// Add the initial vec length to the initial elements, and push those new elements into the reserved space.
spare.extend(init.iter().copied().map(|i| i + init.len()));

assert_eq!(vec, &[1, 2, 3, 4, 5, 6]);
```

Without this library, you can't use `Extend` because it mutably borrows the `Vec<T>` that you need to read items out of (index).
You would have to write something like:

```rust
let mut vec = vec![1, 2, 3];

let init_len = vec.len();

vec.reserve(init_len);

for i in 0..init_len {
    let item = vec[i];
    vec.push(item + init_len);
}

assert_eq!(vec, &[1, 2, 3, 4, 5, 6]);
```