无法移出已借用的内容和生成器模式

Question

我正在学习Rust，尝试为我的Game结构创建一个builder struct。以下是代码：

struct Input {
    keys_pressed: HashMap<VirtualKeyCode, bool>,
}

pub struct GameBuilder {
    settings: GameSettings,
    input: Input,
}

impl GameBuilder {
    pub fn new() -> GameBuilder {
        GameBuilder {
            settings: GameSettings {
                window_dimensions: (800, 600),
                title: "".to_string(),
            },
            input: Input {
                keys_pressed: HashMap::new(),
            }
        }
    }

    pub fn with_dimensions(&mut self, width: u32, height: u32) -> &mut GameBuilder {
        self.settings.window_dimensions = (width, height);
        self
    }

    pub fn with_title(&mut self, title: &str) -> &mut GameBuilder {
        self.settings.title = title.to_string();
        self
    }

    pub fn game_keys(&mut self, keys: Vec<VirtualKeyCode>) -> &mut GameBuilder {
        for key in keys {
            self.input.keys_pressed.insert(key, false);
        }
        self
    }

    pub fn build(&self) -> Game {
        let (width, height) = self.settings.window_dimensions;
        Game {
            display: glutin::WindowBuilder::new()
                        .with_dimensions(width, height)
                        .with_title(self.settings.title.to_string())
                        .build_glium()
                        .ok()
                        .expect("Error in WindowBuilder"),
            state: GameState::Running,
            input: self.input,
        }
    }
}

但是在最后一行 input: self.input，这段代码会出现以下错误：

error: cannot move out of borrowed content

我想我明白为什么了。由于在函数中传递的参数是 &self，所以我不能取得它的所有权，这也是最后一行代码所做的。

我认为将 &self 改为 self 可能会起作用，但编译器会报错表示我不能修改 self。

据我所知还有 Copy trait，也许可以解决这个问题。但是 Input 基本上是一个 HashMap，这意味着如果哈希值本身太大，复制可能很昂贵。

有什么好的方法可以解决这个问题吗？

编辑：

我尝试过这样做：

#[derive(Debug, Copy, Clone)]
struct Input {
    keys_pressed: HashMap<VirtualKeyCode, bool>,
}

但是编译器报错了:

error: the trait `Copy` may not be implemented for this type; field `keys_pressed` does not implement `Copy`

- lhahn

---

@ker：一开始我也有同样的疑问，后来意识到可能是调用with_title().build()，因此build接收&mut self并且不能拥有它... 因此实际上需要修改整个方法集以在每次传递所有权时启用链接。 - Matthieu M.

说实话，如果楼主在链式调用中包含了代码，那么问题就更明显了！ - Matthieu M.

MCVE（最小可重现实例）让世界变得更加简单易懂... - oli_obk

@lhahn: MCVE; 但是不用担心，我们都知道有时候很难将代码缩减到足够小的规模并且仍然能够展示问题。 - Matthieu M.

@lhahn，现在还不晚——我敢打赌你可以随时更新你的代码，让它更好地展示问题！ - Shepmaster

Answer 1

考虑到你的方法签名，你似乎正在追求链式结构：

let game = GameBuilder::new().with_dimensions(...)
                             .with_title(...)
                             .build();

在Rust中，这需要通过值传递GameBuilder：

pub fn with_dimensions(self, ...) -> GameBuilder {
    // ...
}

为了在方法内部能够改变 self，你需要将其声明为 mut：

pub fn with_dimensions(mut self, ...) -> GameBuilder {
}

如果你将with_dimensions，with_title，game_keys和build的签名更改为通过值传递self（如果有意进行更改，则使用mut self），那么可以使用链接。

- Matthieu M.

---

啊，我没看到链式调用……这就解释了错误的来源。 - oli_obk

你可以使用&mut self方法并返回&mut Self。这要求你在构建器内使用clone()或将非拷贝值包装在Option中，然后将其从构建器中取出。 - nuiun

Answer 2

尝试使用Option和take()构建模式

示例：

#[derive(PartialEq, Debug)]
struct Game {
    window: Window,
}

#[derive(PartialEq, Debug)]
struct Window {
    title: String,
    dimensions: (u32, u32),
}

struct GameBuilder {
    window_title: Option<String>,
    window_dimensions: Option<(u32, u32)>,
}

impl GameBuilder {
    fn new() -> Self {
        Self {
            window_title: None,
            window_dimensions: None,
        }
    }

    fn window_title(&mut self, window_title: &str) -> &mut Self {
        self.window_title = Some(window_title.to_owned());
        self
    }

    fn window_dimensions(&mut self, width: u32, height: u32) -> &mut Self {
        self.window_dimensions = Some((width, height));
        self
    }

    fn build(&mut self) -> Result<Game, Box<dyn std::error::Error>> {
        Ok(Game {
            window: Window {
                // `ok_or(&str)?` works, because From<&str> is implemented for Box<dyn Error>
                title: self.window_title.take().ok_or("window_title is unset")?,
                dimensions: self
                    .window_dimensions
                    .take()
                    .ok_or("window_dimensions are unset")?,
            },
        })
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test() {
        let mut builder = GameBuilder::new();
        builder.window_title("Awesome Builder");
        builder.window_dimensions(800, 600);
        let game = builder.build();

        assert_eq!(
            game.expect("build success"),
            Game {
                window: Window {
                    title: "Awesome Builder".into(),
                    dimensions: (800, 600)
                }
            }
        );
    }

    #[test]
    fn test_1() {
        let game2 = GameBuilder::new()
            .window_title("Busy Builder")
            .window_dimensions(1234, 123)
            .build();

        assert_eq!(
            game2.expect("build success"),
            Game {
                window: Window {
                    title: "Busy Builder".into(),
                    dimensions: (1234, 123),
                }
            }
        )
    }
}

- nuiun