Personally I am against this idea. For me adopting a builder pattern is more about safety than passing good defaults. Builder pattern is an good example of using type system to avoid potential errors.
For example:
let builder = Builder::new();
let built = builder.build();
// if you forget finalize the construction step, it's a compile time error
Instead if you have init pattern
let mydata = MyData::new().settings_a(); // And if you forget call init, compiler will silently pass
mydata.some_method(); // this may be problematic
In addition, the init pattern introduce a lot of problems. For example if you have something following
struct MyType {
file: File, // If you want to pass the path to the file later, there's no way to construct it
}
You could use Option<File>
instead, but this increases the complexity in other places (and also unnecessary runtime checks may hurt performance and option type may increase memory usage).
Finally, it's not difficult to implement a procedural macro helps us make builders. Beyond that I personally think writing code that having more compile time guarantee is way more important than so called DRY dogma anyway and this is the reason why type system is important.