No more worrying whether the build
call on your builder will return Ok
or not. Maybe you forgot to set a field? typesafe-builders
solves this by using the Rust type-system to ensure correct usage.
```rust use typesafe_builders::prelude::*;
fn main() {
#[derive(Builder)]
struct Point {
#[builder(constructor)]
x: u8,
y: u8,
#[builder(optional)]
z: Option
// `builder` requires `x` since it is marked as `constructor`.
let builder = Point::builder(1);
// These do not compile:
// partial.x(6); // `x` is already set
// partial.build(); // `y` is not set
// `build` is only available once all required fields are set:
let result = builder.y(2).build();
assert_eq!(result.x, 1);
assert_eq!(result.y, 2);
assert_eq!(result.z, None);
} ```
All attributes must be wrapped by builder
, eg. builder(optional)
.
optional
- A field can be set, but is not required to.constructor
- A field must already be set in the builder
function.Although having everything known at compile time it nice - it comes at the cost of having verbose types in cases where that information needs to be passed on.
For example when you want to return a builder from a function, it normally looks like this:
```rust use typesafe_builders::prelude::*;
struct Point { x: u8, y: u8, z: u8, }
// Ugly type name here...
fn preset() -> GenericPointBuilder
fn main() { // Luckily we dont need to type it here again: let partial = preset(); let point = partial.x(1).y(2).build(); } ```
Please open an MR/Issue if you know how to improve this.
Const generic one-hot bitfields. What you get is similar to this:
```rust
pub struct Builder
impl impl // The build function is only available once all fields are set:
impl Builder }
```}
TODOs
optional
fields.rename
field attribute.constructor
or something like this to have mandatory args directly in the builder
function.Into
or whatever to cast types.Some
automatically.