enums - 将函数应用于可能会改变变量类型的枚举变量的惯用方式是什么？

Question

我有一个带有两个变体的枚举，并且我有一个函数可能会更改该枚举的 Activity 变体。我也想在两个枚举变体之间拆分我的代码，但这带来了一个挑战，即变体类型的功能不能对自身进行可变引用，因为它不能更改枚举的变体，因此它不是其中的一部分。如果该函数拥有所有权，则必须使用一个虚拟变量，该变量对我的实际应用程序很好，但通常不行。

struct Integer (i32);
struct Natural (u32);
enum Number {
    I(Integer),
    N(Natural),
}

impl Integer {
    // Decrement
    fn dec(&mut self) {
        self.0 -= 1;
    }
}

impl Natural {
    // Zero is a natural number that when decremented is not a natural number
    // therefore dec cannot take a &mut self
    fn dec(self) -> Number {
        if self.0 == 0 {
            Number::I(Integer(-1))
        } else {
            Number::N(Natural(self.0 - 1))
        }
    }
}

impl Number {
    // Is there a better way to do this?
    fn dec(&mut self) {
        let result = match self {
            Number::I(int) => {
                int.dec();
                return
            }
            Number::N(nat) => {
                // For this example making a dummy is possible
                // but what if it's not?
                let dummy = Natural(0);
                let extracted = std::mem::replace(nat, dummy);
                extracted.dec()
            }
        };
        *self = result;
    }
}

// Something like this would be nice
fn transform<T, F>(val: &mut T, f: F) where F : FnOnce(T) -> T {
    todo!("Magic!");
}

所有这些都感觉有些乏味，因此我怀疑我错过了一些更简单的方法。

Answer 1

如果应用函数可以更改enum变体，则根本没有必要在enum变体的级别上实现它。我将在枚举级别实现它，如下所示:

impl Number {
    
    fn dec(&mut self) {
        *self = match self {
            Number::I(i) => Number::I(Integer(i.0-1)),
            Number::N(n) if n.0==0 => Number::I(Integer(-1)),
            Number::N(n) => Number::N(Natural(n.0-1))
        }
    }
    
}

如果您确实希望此功能在变体级别可用，那么至少在 Natural::dec的情况下，它并不总是成功的。因此，该函数需要返回一些内容以指示无法减小它并仍然保持自然数的情况。

impl Integer {
    fn dec(&mut self) {
        self.0 -= 1;
    }
}

struct NotNatural ();

impl Natural {
    fn dec(&mut self) -> Result<(), NotNatural> {
        if self.0 == 0 {
            Err(NotNatural())
        } else {
            self.0 -= 1;
            Ok(())
        }
    }
}

impl Number {
    
    fn dec(&mut self) {
        match self {
            Number::I(ref mut i) => i.dec(),
            Number::N(ref mut n) => match n.dec() {
                Ok(_) => (),
                Err(_) => {
                    *self = Number::I(Integer(-1));
                    ()
                }
            }
        }
    }
   
}

Playground