Build trait for optionally abstracting generated builders

[nikagamkrelidze]

Hello Bon!

In our codebase, we have some trait T and a function f that needs to receive a struct that has T implemented for it. That is a dozen or so structs in our codebase that are implementing T and all of them are built using bon. Therefore, we have to use the f in the following way:

f(struct_1_builder.build());
f(struct_2_builder.build());

This seems unnecessarily repetitive and verbose. Moreover, we expose both, the builders and f to our consumers and would like to simplify API in general. If Bon-based builders could optionally generate implementation of some Build trait (also shipped by bon), we could be simply passing the builders and allow f invoking .build() on them.

Here is an example of what would such a Build trait look like and what would the implementations look like for it:

trait Build {
    type Output;

    fn build(self) -> Self::Output;
}

trait Speaker {
    fn speak(&self);
}

#[derive(bon::Builder)]
struct Dog {
    name: String,
}

impl Speaker for Dog {
    fn speak(&self) {
        println!("Woof, {}", self.name);
    }
}

impl<S> Build for DogBuilder<S>
where
    S: dog_builder::IsComplete,
{
    type Output = Dog;

    fn build(self) -> Self::Output {
        DogBuilder::build(self)
    }
}

#[derive(bon::Builder)]
struct Cat {
    name: String,
}

impl Speaker for Cat {
    fn speak(&self) {
        println!("Meow, {}", self.name);
    }
}

impl<S> Build for CatBuilder<S>
where
    S: cat_builder::IsComplete,
{
    type Output = Cat;

    fn build(self) -> Self::Output {
        CatBuilder::build(self)
    }
}

fn build_and_speak<B>(builder: B)
where
    B: Build,
    B::Output: Speaker,
{
    let item = builder.build();
    item.speak();
}

fn main() {
    build_and_speak(Dog::builder().name("Rex".to_owned()));
    build_and_speak(Cat::builder().name("Whiskers".to_owned()));
}

The generation of the implementation for the builder can be optionally triggered by whatever you see fit, for example some flag on the existing macros.

What do you think of such a feature?

[Veetaha]

Hi. You are probably looking for a #[builder(derive(Into)).

use bon::Builder;

#[derive(Builder)]
#[builder(derive(Into))]
struct Cat { /**/ }

#[derive(Builder)]
#[builder(derive(Into))]
struct Dog { /**/ }

fn build_and_speak<T: Speaker>(value: impl Into<T>) { /* */ }

fn main() {
    build_and_speak(Dog::builder().name("Rex".to_owned()));
    build_and_speak(Cat::builder().name("Whiskers".to_owned()));
}

[Veetaha]

Alternatively, if you don't need this level of flexibility with Into polymorphism, and you are fine with a function restricted to only accepting the builder value of one target type, you can avoid additional Into traits and use IsComplete trait directly with the expected builder type:

use bon::Builder;

#[derive(Builder)]
struct Cat { /**/ }

fn example(builder: CatBuilder<impl cat_builder::IsComplete>) {
    let cat = builder.build();
}

fn main() {
    example(Cat::builder().name(...));
    // Won't work with a DogBuilder
}

[nikagamkrelidze]

Thanks for the response.

The example with CatBuilder<impl cat_builder::IsComplete> does not suit us, as we want to be able to receive any builder that can produce a struct that has T implemented and there are many of them.

Regarding your example with Into - can you please expand on what you're suggesting? The snippet that you provided does no compile.

trait Speaker {
    fn speak(&self);
}

#[derive(bon::Builder)]
#[builder(derive(Into))]
struct Dog {
    name: String,
}

impl Speaker for Dog {
    fn speak(&self) {
        println!("Woof, {}", self.name);
    }
}

#[derive(bon::Builder)]
#[builder(derive(Into))]
struct Cat {
    name: String,
}

impl Speaker for Cat {
    fn speak(&self) {
        println!("Meow, {}", self.name);
    }
}

fn build_and_speak<T: Speaker>(value: impl Into<T>) { /* */ }


fn main() {
    build_and_speak(Dog::builder().name("Rex".to_owned()));
    build_and_speak(Cat::builder().name("Whiskers".to_owned()));
}

Produces:

error[E0283]: type annotations needed
  --> src\main.rs:33:5
   |
33 |     build_and_speak(Dog::builder().name("Rex".to_owned()));
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer type for type parameter `T` declared on the function `build_and_speak`
   |
   = note: cannot satisfy `_: Speaker`

[Veetaha]

Yeah, I see, it doesn't compile because impl Into<T> where T: Speaker needs to know the target T because a single type can be convertible into many different Ts that implement Speaker, so you'd need to provide that hint build_and_speak::<Dog>(...)

You could use impl Into<Cat> or impl Into<Dog> with a concrete type, thus solving the type inference problem

[nikagamkrelidze]

You could use impl Into<Cat> or impl Into<Dog> with a concrete type, thus solving the type inference problem

Yes, but that would make build_and_speak not usable for any builder that can produce a struct that implements Speaker, right? Unless I'm misunderstanding your point.

[Veetaha]

Anyhow, this won't solve this problem if you need specifically the signature where the build_and_speak needs to build a generic T: Speaker. Not a concrete Cat or Dog.

In this case, bon can't provide an all-in-one Build trait as you suggested, because that trait limits you to a safe synchronous finishing function with no parameters. Bon supports both unsafe, async and finishing functions with additional parameters. So for example:

#[derive(Builder)]
struct Example {
    #[builder(finish_fn)]
    foo: u32
}

this won't be able to generate an impl of Build trait, because the signature of the build() method for this builder is build(foo: u32) -> Example, which accepts an additional parameter.

For method-based builders:

struct Example { /**/ }

#[bon]
impl Example {
    #[builder]
    async fn new() -> Self { /**/ }
}

it generates a build() with the signature of async fn build(). And these are the reasons why there is no generic Build trait baked into bon.

---

You can, however create your own personal Build trait just like you defined it in the example in the issue, and add implementations for it via a declarative macro.

macro_rules! impl_build {
    ($target:ty, $builder:ty, $builder_module:ident) => {
		impl<S> Build for $builder<S>
		where
		    S: $builder_module::IsComplete,
		{
		    type Output = $target;
		
		    fn build(self) -> Self::Output {
		        $builder::build(self)
		    }
		}
    }
}

impl_build!(Cat, CatBuilder, cat_builder);
impl_build!(Dog, DogBuilder, dog_builder);

You can use the paste with its identifiers concatenation and case conversion tools for macros to simplify it to just impl_build!(Cat)