在Vec中混合引用的生存期

Question

我正在尝试从Vec<&'a Color>生成Vec<&'b Color> Vec<&'a Color> ：

impl <'a> Canvas<'a> {
    pub fn modify<'b>(&self, update: Update) -> Canvas<'b> {
        let x  = update.x;
        let y  = update.y;
        let colors: Vec<&'b Color> = self.colors.iter().enumerate().map(move |(index, color)| {
                if index == self.width * y + x { update.color } else { color }
            })
            .collect();
        Canvas { width: self.width, height: self.height, colors: colors }
    }
}

但是，出现以下错误：

error[E0495]: cannot infer an appropriate lifetime due to conflicting requirements
  --> src/canvas.rs:51:50
   |
51 |         let colors: Vec<&'b Color> = self.colors.iter().enumerate().map(move |(index, color)| {
   |                                                  ^^^^

如何创建Vec颜色，除了一个颜色，所有颜色的寿命为'a ，其余颜色为寿命'b ？

如果需要，相关定义如下：

#[derive(Debug, PartialEq, Eq)]
pub enum Color {
    White,
    Red,
    Blue,
    Green,
    Purple,
    Orange
}

pub struct Update<'a> {
    color: &'a Color,
    x: usize,
    y: usize
}

pub struct Canvas<'a> {
    width: usize,
    height: usize,
    colors: Vec<&'a Color>
}

Answer 1

如何创建Vec颜色，除了一个颜色，所有颜色的寿命为'a ，其余颜色为寿命'b ？

你不能 。 寿命是仿制药，只是喜欢它没有意义有“一个Vec<T>但所有的一个T的类型为String ，其余T的类型是bool ”，它没有意义做一辈子

您可以做的是统一生命周期：

impl<'a> Canvas<'a> {
    pub fn modify(&self, update: Update<'a>) -> Canvas<'a> {
        let x = update.x;
        let y = update.y;
        let colors = self.colors
            .iter()
            .enumerate()
            .map(move |(index, color)| if index == self.width * y + x {
                     update.color
                 } else {
                     color
                 })
            .collect();
        Canvas {
            width: self.width,
            height: self.height,
            colors: colors,
        }
    }
}

在这里，我们已经说过了update.color生命周期和所包含引用的生命周期有一个交集，这就是结果的生命周期。

---

一组固定类型的异构集合的另一个常见解决方案是为每个枚举引入一个带有变体的枚举：

pub enum Thing<'a, 'b>  {
    A(&'a Color),
    B(&'b Color),
}

impl<'a> Canvas<'a> {
    pub fn modify<'b>(&self, update: Update<'b>) -> Vec<Thing<'a, 'b>> {
        let x = update.x;
        let y = update.y;
        self.colors
            .iter()
            .enumerate()
            .map(move |(index, color)| if index == self.width * y + x {
                     Thing::B(update.color)
                 } else {
                     Thing::A(color)
                 })
            .collect()
    }
}