placenew 2.0.0

A crate providing the macro 'place_boxed' which allows you to create a object in-place on the heap using the normal struct initializer, the macro uses Box::new_uninit(), initializes all members using the values from the struct initializer, and then calls .assume_init() for regular value types => writes the expression in-place for array types ([T; N]) => generates a for loop for expressions such as [0; 100], and generates a sequence of arr[i] = v for an expression such as [0, 1, 2, 3]
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

# placenew

**A rust crate providing safe placement-new semantics for rust**
This crate is a procedural macro crate that provides the proc macro: `place_boxed`

The macro takes a struct initializer as an input, and generates code that initializes the items in-place in heap memory

## Usecase
In some cases, you may want to initialize memory in-place on the heap in order to avoid an expensive copy operation,
such is the case in this code:
```rust
let mut res = Box::new(
    MyStruct::new()
)
```
In some cases the rust compiler will optimize away the copy, but it's not guaranteed, and assuming it is can often lead
to undefined behavior, that is what this crate aims to solve

## Examples

**Example 1**
```rust
struct MyStruct {
    trivial_val: i32,
    name: String,
    array: [i32; 5],
    nested_array: [[i32; 10]; 5]
}

let my_box = place_boxed!(
    MyStruct {
        trivial_val: 10,
        name: String::from("Bob"),
        array: [1, 2, 3, 4, 5],
        nested_array: [[5; 10]; 5]
    }
);
```

**Example codegen (edited for readability):**
```rust
let my_box = unsafe {

    let _ensure_struct_correct = || {
         MyStruct {
            trivial_val: 10,
            name: String::from("Bob"),
            array: [1, 2, 3, 4, 5],
            nested_array: [[5; 10]; 5]
         }
    };

    let mut res = std::boxed::Box::<MyStruct>::new_uninit();

    let ptr = res.as_mut_ptr();

    (&raw mut (*ptr).trivial_val).write(10);

    (&raw mut (*ptr).name).write(String::from("Bob"));

    (&raw mut (*ptr).array[0usize]).write(1);

    (&raw mut (*ptr).array[1usize]).write(2);

    (&raw mut (*ptr).array[2usize]).write(3);

    (&raw mut (*ptr).array[3usize]).write(4);

    (&raw mut (*ptr).array[4usize]).write(5);

    for i_0 in 0..5 {
        for i_1 in 0..10 {
            (&raw mut (*ptr).nested_array[i_0][i_1]).write(5);
        }
    }

    res.assume_init()
}
```


**As of 2.0.0 you can also create non-structure types with the macro like so**
```rust
let my_boxed_slice = place_boxed!(
    [0; 100_000],  //the initializing value
    [i32, 100_000] //the type of the value
);
```

**Codegen:**
```rust
let my_boxed_slice = unsafe {
    let _ensure_correct = || { [10; 100_000] };

    let mut res = std::boxed::Box::<[i32; 100_000]>::new_uninit();
    let ptr = res.as_mut_ptr();
    for i_0 in 0..100_000 { (&raw mut (*ptr)[i_0]).write(10); }
    res.assume_init()
}
```