attrimpl 0.2.1

The crate provides attributes to automatically implement common traits and reduce boilerplate code.
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

# Warning
This package is under construction, handle with care!


# attrimpl
The aim of the package is to reduce boilerplate code by adding implementations in trivial cases.

## Directives
Directives that can be added before fields
- `from`: implements `From` trait for the given type
- `into`: implements `Into` trait for the given type
- `convert`: add both `from` and `into` directives for the given field
- `deref`: implements `Deref` trait for the given type
- `deref_mut`: implements `Deref` and `DerefMut` traits for the given type

### Upcoming implementations:
- Traits
  - `Into`
  - `From`
  - `Deref`
  - `DerefMut`
  - `Asref`
  - `AsMut`
- Getter methods

## Examples
**Named struct:**
```rust
#[attrimpl::attrimpl]
struct NamedStruct {
    #[attrimpl(from, into, deref_mut)]
    name: String,
}

// non-boxed
let mut value = NamedStruct::from("test".to_string());
value.push_str("ing");
let value: String = value.into();

// boxed
let mut value = Box::<NamedStruct>::from("test".to_string());
value.push_str("ing");
let value: String = (*value).into();
```

**Tuple struct:**
```rust
#[attrimpl::attrimpl]
struct TupleStruct1(#[attrimpl(from, into, deref_mut)] String);

// non-boxed
let mut value = TupleStruct1::from("test".to_string());
value.push_str("ing");
let value: String = value.into();

// boxed
let mut value = Box::<TupleStruct1>::from("test".to_string());
value.push_str("ing");
let value: String = (*value).into();
```

**Enum:**
```rust
#[attrimpl::attrimpl]
enum Enum {
    S(#[attrimpl(convert)] String),
    U8 {
        #[attrimpl(from)]
        byte: u8,
    },
    F64(#[attrimpl(convert)] f64),
}

// non-boxed
let value = Enum::from("test".to_string());

// boxed
let value = Box::<Enum>::from("test".to_string());
```


## Todo
* handle errors in the package instead of relying on the Rust compiler where possible
* examine whether it is possible to implement deref, deref_mut, into, as_ref, as_mut on enums if every variant contains the same type
* `#[attrimpl(from)]` should work with multiple field structs and enums. Should be able to set the default values of the other fields (e.g., `#[attrimpl(from(field_default | container_default))]`).
* write test framework for compile time errors
* write a failing test where non-defined directive is given
* implement the following directives
  * `#[attrimpl(convert)]`
    * `#[attrimpl(from)]`
    * `#[attrimpl(into)]`
  * `#[attrimpl(deref_both)]`
    * `#[attrimpl(deref)]`
    * `#[attrimpl(deref_mut)]`
  * `#[access(copy | clone | ref)]`
    * `#[attrimpl(get_ref)]`
    * `#[attrimpl(get_mut)]`
    * `#[attrimpl(get_copy)]`
    * `#[attrimpl(get_clone)]`
  * `#[attrimpl(as)]`
    * `#[attrimpl(as_ref)]`
    * `#[attrimpl(as_mut)]`
  * `#[attrimpl(display("asdasd {}"))]`
  * not sure whether to implement that one: #[attrimpl(borrow)]
  * search for othe possibilities of useful directives