Rust构建器模式必须使用冗余结构代码吗？
不。但有时候他们可能会。例如，考虑我们是否希望在构造函数周围有特殊的逻辑（甚至只是复杂的逻辑）：

/// Width must always be greater than height!
struct HorizontalEllipse {
    width: f64,
    height: f64,
}

impl HorizontalEllipse {
    fn area(&self) -> f64 {
        std::f64::consts::PI * (self.width / 2.0) * (self.height / 2.0)
    }
}

struct HorizontalEllipseBuilder {
    width: f64,
    height: f64,
}

impl HorizontalEllipseBuilder {
    fn new() -> HorizontalEllipseBuilder {
        HorizontalEllipseBuilder {
            width: 0.0,
            height: 0.0,
        }
    }

    fn width(&mut self, width: f64) -> &mut HorizontalEllipseBuilder {
        self.width = width;
        self
    }

    fn height(&mut self, height: f64) -> &mut HorizontalEllipseBuilder {
        self.height = height;
        self
    }

    fn finalize(&self) -> Result<HorizontalEllipse, String> {
        let HorizontalEllipseBuilder { height, width } = *self;
        if height >= width {
            Err("This is not horizontal".into())
        } else {
            Ok(HorizontalEllipse { width, height })
        }
    }
}

fn main() {
    let c = HorizontalEllipseBuilder::new()
        .width(1.0)
        .height(2.0)
        .finalize()
        .expect("not a valid ellipse");

    println!("area: {}", c.area());
    println!("width: {}", c.width);
    println!("height: {}", c.height);
}

现在一个HorizontalEllipse知道width > height总是真的。我们已经将检查从许多可能的地方（每个方法）移到了一个地方，即构造函数。然后我们将构造函数移到一个新的类型，因为它很复杂（不是真的，但真正复杂的例子通常是...复杂）。
我见过的许多构建器也有真实的对象的“增强”类型：

#[derive(Debug)]
struct Person {
    name: String,
}

#[derive(Debug, Default)]
struct PersonBuilder {
    name: Option<String>,
}

impl PersonBuilder {
    fn name(self, name: &str) -> Self {
        PersonBuilder { name: Some(name.into()), ..self }
    }

    fn build(self) -> Person {
        Person {
            name: self.name.unwrap_or_else(|| "Stefani Joanne Angelina Germanotta".into()),
        }
    }
}

fn main() {
    let person = PersonBuilder::default().build();
    println!("{:?}", person);

    let person = PersonBuilder::default().name("krishnab").build();
    println!("{:?}", person);
}

你在书中的例子中看不到这一点，因为它试图更简单，不涉及所有权问题。

这似乎是一个宏可以做的事情。快速搜索找到了似乎实现了此功能的derive_builder和builder_macro板条箱。

我创建了一个名为default-struct-builder的宏crate，旨在避免生成单独的构建器结构，甚至是build()方法。
它的目的是在简单的情况下用于实现构造函数（就像您所做的那样）或Default的结构。
你可以像这样把它添加到你的结构体中：

use default_struct_builder::DefaultBuilder;

#[derive(DefaultBuilder)]
struct Circle {
    x: f64,
    y: f64,
    radius: f64,
}

然后像这样简单地使用它：

let circle = Circle::new()
    .x(10.0)
    .radius(2.5);

assert_eq!(circle.x, 10.0);
assert_eq!(circle.y, 0.0);
assert_eq!(circle.radius, 2.5);