如何为返回正确类型的枚举实现 get 方法？

Question

我有一个枚举，其中包含包含某些类型的变体。 如果枚举变体包含此类型，我想编写一个自动返回正确类型的get方法。

pub enum Var {
    Switch(bool),
    PositiveInteger(u32),
    Integer(i32),
    PositiveFloat(f64),
    Float(f64),
    Phase(f64), // a float x, where 0.0 <= x < 2Pi
    Turn(f64), // the same, but with 0.0 <= x < 1.0
}

在代码的其他地方，我想获取value内部的值，例如PositiveFloat( value ) 。 但是（对我而言）似乎不可能编写一个通用的 function，如下所示：

impl Var {
    pub fn get<T>(&self) -> T 
where
    T: Default,
{
        match self {
            Var::Switch(value) => value,
            Var::PositiveInteger(value) => value,
            // etc
}

相反，我似乎必须为枚举的每个变体实现不同的获取方法： get_positive_integer() 、 get_integer()等。也许我以错误的方式看待问题。 我想要实现这样的目标：

let positive_integer = Var::PositiveInteger(1);
let x: u32 = positive_integer.get();

let float = Var::Float(0.1);
let y: f64 = float.get();

Answer 1

您可以为此创建一个特征：

pub trait VarTypes: Sized {
    fn get(var: &Var) -> Option<Self>;
}

impl VarTypes for bool {
    fn get(var: &Var) -> Option<Self> {
        match *var {
            Var::Switch(v) => Some(v),
            _ => None,
        }
    }
}

impl VarTypes for u32 {
    fn get(var: &Var) -> Option<Self> {
        match *var {
            Var::PositiveInteger(v) => Some(v),
            _ => None,
        }
    }
}

impl VarTypes for i32 {
    fn get(var: &Var) -> Option<Self> {
        match *var {
            Var::Integer(v) => Some(v),
            _ => None,
        }
    }
}

impl VarTypes for f64 {
    fn get(var: &Var) -> Option<Self> {
        match *var {
            Var::PositiveFloat(v) | Var::Float(v) | Var::Phase(v) | Var::Turn(v) => Some(v),
            _ => None,
        }
    }
}

然后你可以用它来实现get() ：

impl Var {
    pub fn get<T>(&self) -> T
    where
        T: VarTypes + Default,
    {
        T::get(self).unwrap_or_default()
    }
}

Answer 2

您不能直接在impl Var中定义方法，因为每种类型都需要不同的实现。 您可以做的是定义一个通用特征并为您想要的每种类型实现它：

trait Get<T> {
    fn get(&self) -> Option<T>;
}

impl Get<bool> for Var {
    fn get(&self) -> Option<bool> {
        match self {
            Var::Switch(value) => Some(*value),
            _ => None,
        }
    }
}

impl Get<u32> for Var {
    fn get(&self) -> Option<u32> {
        match self {
            Var::PositiveInteger(v) => Some(*v),
            _ => None,
        }
    }
}

impl Get<f64> for Var {
    fn get(&self) -> Option<f64> {
        match self {
            Var::PositiveFloat(v) | Var::Float(v) | Var::Phase(v) | Var::Turn(v) => Some(*v),
            _ => None,
        }
    }
}
// …

我将返回类型更改为Option<T>因为这放宽了对T的要求并且更符合其他类似方法（ slice::get ，...）并且您可以使用简单的unwrap_or_default()重新获得语义：

let positive_integer = Var::PositiveInteger(1);
let x: u32 = positive_integer.get().unwrap_or_default();