Default Struct Builder

Generates builder methods of every field of a struct. It is meant to be used on structs that implement Default. There is no separate builder struct generated and no need to call a build() method at the end or .unwrap().

This crate is used by the crate leptos-use for the option structs that can be passed to the various functions.

Installation

In your project folder run

sh cargo add default-struct-builder

Usage

It is very easy to use:

```rust use defaultstructbuilder::DefaultBuilder;

[derive(DefaultBuilder, Default)]

pub struct SomeOptions { throttle: f64,

#[builder(into)]
offset: Option<f64>,

#[builder(skip)]
not_included: u32,

} ```

you can then use the struct like this:

```rust let options = SomeOptions::default().offset(4.0);

asserteq!(options.offset, Some(4.0)); asserteq!(options.throttle, 0.0); asserteq!(options.notincluded, 0); ```

Generics

The macro is ready to be used on generic structs.

```rust use defaultstructbuilder::DefaultBuilder;

[derive(DefaultBuilder, Default)]

pub struct SomeOptions where T: Default, { some_field: T, } ```

Doc comments

All doc comments on fields are directly passed on to their generated setter methods.

How it works

The derive macro generates the following code:

``rust impl SomeOptions { // setter methods are given that consumeselfand return a newSelf` with the field value changed pub fn throttle(self, value: f64) -> Self { Self { throttle: value, ..self } }

// because `into` was specified this method is generic and calls `.into()` when setting the value
pub fn offset<T>(self, value: T) -> Self
where
    T: Into<Option<f64>>,
{
    Self {
        offset: value.into(),
        ..self
    }
}

// no method for field `not_included` because `skip` was specified

} ```

Generics

In the case of a generic field the generated method is a bit more complex because by calling the method the type of the type parameter can be different than before.

Let's look at the following example.

```rust use defaultstructbuilder::DefaultBuilder;

[derive(DefaultBuilder, Default)]

pub struct SomeOptions where T: Default, { somefield: T, otherfield: i16, }

impl SomeOptions { pub fn new() -> Self { Self { somefield: 42.0, otherfield: 0, }
} } ```

This generates the setter method below.

```rust impl SomeOptions where T: Default, { pub fn somefield(self, value: NewT) -> SomeOptions where NewT: Default, { SomeOptions:: { somefield: value, otherfield: self.otherfield, } } }

fn main() { let options = SomeOptions::new() // at first SomeOptions .some_field("string"); // changed to SomeOptions<&str> } ```

Related Work

For more general purposes please check out the much more powerful derive_builder crate.