Type Safe Builder Pattern

Infallible compile-time checked builders for your structs.

License: GPL v3

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.

Example

```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);

} ```

Field Attributes

All attributes must be wrapped by builder, eg. builder(optional).

Known Downside

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::*;

[derive(Builder)]

struct Point { x: u8, y: u8, z: u8, }

// Ugly type name here... fn preset() -> GenericPointBuilder { Point::builder().z(0) }

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.

How does it work?

Const generic one-hot bitfields. What you get is similar to this:

```rust pub struct Builder { x: Option, y: Option, }

impl Builder { fn set_x(self, x: u8) -> Builder

impl Builder { fn set_y(self, y: u8) -> Builder { unimplemented!() } }

// The build function is only available once all fields are set: impl Builder { fn build() {

}

} ```

TODOs