Question

我想使用模式匹配来检查结构的内部而不构建新的结构。我试图将结构的值作为练习交换（我知道mem::swap存在）。

交换意味着匹配struct的值，然后交换匹配的值。就像让x = {10,20,30}; x.swap(10,30)产生{30,20,10}一样。

我想要的是什么，但不能

#[derive(Debug, Clone, Copy)]
struct Color {
    r: u8,
    g: u8,
    b: u8,
    a: u8,
}

impl Color {
    fn swap(mut self, first: u8, second: u8) -> Color {
        match (first) {
            self.r => {
                match (second) {
                    self.b => {
                        self.r = second;
                        self.b = first;
                    },
                    self.g => {
                        self.r = second;
                        self.g = first;
                    },
                    self.a => {
                        self.r = second;
                        self.a = first;
                    },
                    _ => {},
                }
            },
            _ => {}
        }

        Color {
            r: self.r,
            g: self.g,
            b: self.b,
            a: self.a,
        }
    }
}
fn main() {
    let c = Color {
        r: 255,
        g: 200,
        b: 10,
        a: 30,
    };

    let color = c.swap(c.r, c.a);

    println!("{:?}", color);
}

代码无效，这是我想要完成的。有没有办法做到这一点？我假设我已经基于这种方法了。

Answer 1

从技术上讲，有一种方法可以通过模式匹配来实现这一点，但在实践中你可能永远不会看到这一点。缺少的部分是使用match guard：

match first {
    v if v == self.r => {
        match second {
            v if v == self.b => {
                self.r = second;
                self.b = first;
            },
            v if v == self.g => {
                self.r = second;
                self.g = first;
            },
            v if v == self.a => {
                self.r = second;
                self.a = first;
            },
            _ => {},
        }
    },
    _ => {}
}

但这并没有真正使用模式匹配的任何有用部分;它只是一堆if else子句：

if first == self.r {
    if second == self.b {
        self.r = second;
        self.b = first;
    } else if second == self.g {
        self.r = second;
        self.g = first;
    } else if second == self.a {
        self.r = second;
        self.a = first;
    }
}

你可以选择以某些模式进行鞋拔：

let x1 = (first == self.r, first == self.g, first == self.b, first == self.a);
let x2 = (second == self.r, second == self.g, second == self.b, second == self.a);

match (x1, x2) {
    ((true, _, _, _), (_, true, _, _)) => {
        self.r = second;
        self.b = first;
        }
    ((true, _, _, _), (_, _, true, _)) => {
        self.r = second;
        self.g = first;
        }
    ((true, _, _, _), (_, _, _, true)) => {
        self.r = second;
        self.a = first;
    }
    _ => {}
}

结构内部的模式匹配

1 个答案: