support for default value for optional argument without custom setting

[sehz]

Reference: #231.

I have many use cases where to provide default value for optional argument. Reason for optional argument is that I want to provide reasonable default value but to disable if need to be. For example,

#[derive(Builder)]
pub struct MyGenerator {    
    #[builder(into, required, default = Some("default_world"))]
    default_export_world_name: Option<String>
}

[Veetaha]

Hi! I may be misinterpreting the issue, but here is how I understand this. You want to have different behavior for when the setter is not called vs when you explicitly set None for it.

So for example, this should return a struct with default_export_world_name: Some("default_world")

MyGenerator::builder().build()

vs this should havedefault_export_world_name: None:

MyGenerator::builder().default_export_world_name(None).build()

The provided code example already generates the builder API like the above. However, it also creates a second method maybe_default_export_world_name(Option<Option<String>>) just so that you could dynamically pass either None to get the default value, or Some(None) to explicitly disable the default value and assign None.

---

The issue title mentions "without custom setting". I'm not sure how such behavior could be requested without an explicit attribute. Do you have any ideas of the desired syntax?

[markin-io]

@Veetaha hey! I stumbled upon the same issue and would like to share my use case.

I have a struct with a dozen of fields, some of them are optional by demand of the business logic.
When it comes to testing, the boilerplate calls to setters start spreading pretty quickly.
So I thought of providing reasonable defaults for test target only, hence making easy fixture out of this struct.

Here's my code.

#[derive(Builder)]
struct Foo {
    #[cfg_attr(test, builder(default = Some(1)))]
    bar: Option<u32>,
}

Do you have any ideas of the desired syntax?

Could be something like builder(fixture, default = Some(1))

[Veetaha]

Hey @markin-io, the behavior that you want can already be achieved with the released version of bon using a combination of required, with = Some and default attributes:

#[derive(bon::Builder)]
struct Foo {
    #[cfg_attr(test, builder(required, with = Some, default = Some(1)))]
    bar: Option<u32>,
}

#[test]
fn example() {
    let foo = Foo::builder().build();
    assert_eq!(foo.bar, Some(1));

    let foo = Foo::builder().bar(2).build();
    assert_eq!(foo.bar, Some(2));
}

fn main() {}

required + default is a bit of an oxymoron (which maybe means required could be named better), but what required does is that it disables the special handling of Option<T>, then with = Some removes a layer of Option<_> from the setter signature and default applies the desired default value