default-constructor 0.4.2

Macros for creating pseudo-dsls that constructs structs through default construction and field conversion.
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
101
102
103
104
105
106
107
108
109
110
111
112

# default-constructor

Macros for creating pseudo-dsls that constructs structs through
default construction and field conversion.

## Motivation

This crates is primary designed for `bevy` where constructing large bundles
with `..Default::default()` is common.

## Syntax

Take `construct!` that uses `Into`.

```rust
construct! {
    Student {
        name: "Timmy",
        age: 10,
        father: Parent {
            name: "Tommy",
            age: 42
        }
    }
}
```

This expands to

```rust
Student {
    name: Into::into("Timmy"),
    age: Into::into(10),
    father: construct! {
        Parent {
            name: "Tommy",
            age: 42
        }
    }
    ..Default::default()
}
```

The macro is recursive on nested struct declarations,
if the behavior is not desired, wrap nested structs in brackets.

```rust
construct! {
    Student {
        name: "Timmy",
        age: 10,
        father: { Parent {
            name: "Tommy",
            age: 42
        }}
    }
}
```

## Tuple Construction

To create a tuple, concatenate multiple structs with comma.

```rust
construct! {
    Student {
        name: "Timmy",
        age: 10,
    },
    Son::<2> {
        of: "Tommy"
    },
    Age(16),
}
```

## Meta Constructor

The meta constructor macro allows you to define your own macro with
custom configurations.

See documentation on `meta_default_constructor!` for details.

## `InferInto`

InferInto allows the user to bypass the orphan rule to create conversions.

By default we provide `i32` (integer literal) to all numeric types
and `i64` -> `f64` in addition to the standard `From` and `Into`.

If multiple conversion paths are found, the conversion will fail,
thus failing the `infer_construct` macro.

## ChangeLog

* 0.4
  * `meta_default_constructor` no longer takes a list of imports as the first argument.
  * `meta_default_constructor` can now create tuples by chaining with comma.

## License

License under either of

Apache License, Version 2.0 (LICENSE-APACHE or <http://www.apache.org/licenses/LICENSE-2.0>)
MIT license (LICENSE-MIT or <http://opensource.org/licenses/MIT>)
at your option.

## Contribution

Contributions are welcome!

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.