如何对包含 &mut 枚举的元组进行模式匹配并在匹配臂中使用该枚举？

Question

如何编译下面的代码？它看起来非常安全，但无法说服编译器。

匹配*self的版本给出错误：cannot move out of borrowed content在匹配的行

匹配self的版本给出：use of moved value: *self

enum Foo {
    Foo1(u32),
    Foo2(i16),
}

impl Foo {
    fn bar(&mut self, y: u32) -> (u32, &mut Foo) {
        match (*self, y) {
            (Foo::Foo1(ref mut a), b) if (b == 5) => {
                print!("is five");
                *a = b + 42;

                (b, self)
            }

            (Foo::Foo2(ref mut a), b) if (b == 5) => {
                print!("is five");
                *a = (b + 42) as i16;

                (*a * b, self)
            }

            _ => {
                print!("is not five!");
                (y, self)
            }
        }
    }
}

我觉得我需要一个如下所示的匹配臂，但它似乎不是有效的语法：

(ref mut f @ Foo::Foo1, b) if (b == 5) => {
    print!("is five");
    f.0 = b + 42;
    (b, f)
} 

error[E0532]: expected unit struct/variant or constant, found tuple variant `Foo::Foo1`
  --> src/main.rs:24:30
   |
24 |                 (ref mut f @ Foo::Foo1, b) if (b == 5) => {
   |                              ^^^^^^^^^ not a unit struct/variant or constant

Answer 1

不，这不安全。您正在尝试在匹配臂中引入 可变别名。可变引用a 指向与self 相同的值。可以更改 self（例如 *self = Foo::Foo1(99)），这会使 a 无效，因此不允许使用此代码。

相反，可变地重新借用 self 在match 语句中并让它返回元组的第一个值。由于该值没有对self 的引用，因此您可以使用match 的结果返回self：

enum Foo {
    Foo1(u32),
    Foo2(u32), // changed so I don't have to figure out what casting you meant
}

impl Foo {
   fn bar(&mut self, y: u32) -> (u32, &mut Foo) {
        let next = match (&mut *self, y) {
            (Foo::Foo1(a), b @ 5) => {
                *a = b + 42;
                b
            }

            (Foo::Foo2(a), b @ 5) => {
                *a = b + 42;
                *a * b
            }

            _ => y,
        };

        (next, self)
    }
}

但是，像这样返回self 在这里毫无意义。调用者已经有一个&mut Foo，所以你不需要“还给它”。这允许简化为：

impl Foo {
    fn bar(&mut self, y: u32) -> u32 {
         match (self, y) {
            (Foo::Foo1(a), b @ 5) => {
                *a = b + 42;
                b
            }

            (Foo::Foo2(a), b @ 5) => {
                *a = b + 42;
                *a * b
            }

            _ => y,
        }
    }
}

我还是会说这是一个安全的操作，尽管编译器可能无法理解

使用non-lexical lifetimes，借阅检查器变得更加智能。添加显式重借的原始代码编译：

#![feature(nll)]

enum Foo {
    Foo1(u32),
    Foo2(u32), // changed so I don't have to figure out what casting you meant
}

impl Foo {
   fn bar(&mut self, y: u32) -> (u32, &mut Foo) {
        match (&mut *self, y) {
            (Foo::Foo1(a), b @ 5) => {
                *a = b + 42;
                (b, self)
            }

            (Foo::Foo2(a), b @ 5) => {
                *a = b + 42;
                (*a * b, self)
            }

            _ => (y, self),
        }
    }
}

另见：

• Why does matching on a tuple of dereferenced references not work while dereferencing non-tuples does?
• What is the syntax to match on a reference to an enum?
• How can I use match on a pair of borrowed values without copying them?
• Is there any difference between matching on a reference to a pattern or a dereferenced value?