fieldwork 0.5.1

derivable accessors for struct fields
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

# `set` — mutating field setters

The `set` method generates a mutating setter prefixed with `set_`. By default it returns `&mut Self`
for chaining — see [`set::chain`](crate::set::chain) to change this.

```rust
#[derive(fieldwork::Fieldwork)]
#[fieldwork(set)]
struct Server {
    /// server hostname
    host: String,

    /// port number
    port: u16,

    /// whether TLS is required
    tls_required: bool,
}
```

```rust
// GENERATED
# struct Server { host: String, port: u16, tls_required: bool, }
impl Server {
    ///Sets server hostname, returning `&mut Self` for chaining
    pub fn set_host(&mut self, host: String) -> &mut Self {
        self.host = host;
        self
    }
    ///Sets port number, returning `&mut Self` for chaining
    pub fn set_port(&mut self, port: u16) -> &mut Self {
        self.port = port;
        self
    }
    ///Sets whether TLS is required, returning `&mut Self` for chaining
    pub fn set_tls_required(&mut self, tls_required: bool) -> &mut Self {
        self.tls_required = tls_required;
        self
    }
}

```

## Enums

On enums, `set` is only generated for full-coverage fields (those that appear
in every variant). Partial-coverage fields are silently skipped. See
[`enums`](crate::enums).

## Options

| Option | Description |
|--------|-------------|
| [`chain`](crate::set::chain) | Control whether setters return `&mut Self` or `()` |
| [`into`](crate::set::into) | Accept `impl Into<T>` instead of `T` |
| [`option_set_some`](crate::set::option_set_some) | Accept `T` and wrap in `Some` for `Option<T>` fields |

`into` and `option_set_some` apply equally to `set` and `with` and are documented at the crate
level as well: [`into`](crate::into), [`option_set_some`](crate::option_set_some).

See [`configuration`](crate::configuration) for how options cascade across item, method, field,
and field-method levels.