shorthand 0.1.1

A proc_macro to derive getter and setter for structs
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

shorthand
===
[![Crates.io: shorthand](https://img.shields.io/crates/v/shorthand.svg)](https://crates.io/crates/shorthand/)
[![Documentation](https://docs.rs/shorthand/badge.svg)](https://docs.rs/shorthand/)
[![Build Status](https://travis-ci.org/Luro02/shorthand.svg?branch=master)](https://travis-ci.org/Luro02/shorthand)

`shorthand` is defined as
[`a system of fast writing`](https://dictionary.cambridge.org/de/worterbuch/englisch/shorthand)
and that is exactly what this library is for; to remove the annoying
boilerplate code, that comes with writing your own library.

## What does this library do?

It makes coding in rust a lot more convenient, by deriving `getters` and
`setters` for the fields of a struct.

```rust
use shorthand::ShortHand;

#[derive(ShortHand, Default)]
pub struct Example {
    number: usize,
    data: String,
}

let mut example = Example::default();

assert_eq!(example.number(), 0);
example.set_number(1);
assert_eq!(example.number(), 1);

assert_eq!(example.data(), &"".to_string());
example.set_data("hi".to_string());
assert_eq!(example.data(), &"hi".to_string());
```

Otherwise, you would have to write the this by hand

```rust
pub struct Example {
    number: usize,
    data: String,
}

#[allow(dead_code)]
impl Example {
    #[inline(always)]
    pub fn number(&self) -> usize { self.number }

    #[inline(always)]
    pub fn set_number(&mut self, value: usize) -> &mut Self {
        self.number = value;
        self
    }

    #[inline(always)]
    pub fn data(&self) -> &String { &self.data }

    #[inline(always)]
    pub fn set_data(&mut self, value: String) -> &mut Self {
        self.data = value;
        self
    }
}
```

## How do I get started?

Simply add this library under `[dependencies]` to your `Cargo.toml`
```toml
[dependencies]
shorthand = "0.1.0"
```

You can then derive `ShortHand` for any struct

```rust
use shorthand::ShortHand;

#[derive(ShortHand)]
struct Example {
    field: usize,
}
```

You can find the [documentation here](https://docs.rs/shorthand/).

## Feature Requests and Bug Reports

Feel free to ask questions or report bugs [here](https://www.github.com/luro02/shorthand).
There are no stupid questions.

This library should be as convenient as possible, so please do not hesitate
to request a feature.

## Reference

This library has been inspired by the following crates
- [`getset`] (just the issue tracker and which features were requested)
- [`thiserror`]
- [`derive-builder`]
- [`proc-macro-workshop`]

[`getset`]: https://github.com/Hoverbear/getset
[`thiserror`]: https://github.com/dtolnay/thiserror
[`derive-builder`]: https://github.com/colin-kiegel/rust-derive-builder
[`proc-macro-workshop`]: https://github.com/dtolnay/proc-macro-workshop
[`proc_macro`]: https://doc.rust-lang.org/reference/procedural-macros.html