Rust 特征问题 特征不能变成对象

我正在尝试编写一些代码来生成具有随机值的随机结构。我有以下结构的特征和辅助宏：

use rand::{thread_rng, Rng};
use std::fmt;

pub trait DataType {
    /// generate a new instance of the type with a random value
    fn random() -> Box<Self>;
    /// generate a new instance of the same type with a random value
    fn gen_another(&self) -> Box<Self>;
}

macro_rules! impl_data_type_for_num {
    ($x:ident) => {
        impl DataType for $x {
            fn random() -> Box<Self> {
                Box::new(Self {
                    value: thread_rng().gen()
                })
            }

            fn gen_another(&self) -> Box<Self> {
                Self::random()
            }
        }
    };
}

macro_rules! impl_formatting {
    ($x:ident, $s:expr) => {
        impl fmt::Debug for $x {
            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
                write!(f, $s)
            }
        }

        impl fmt::Display for $x {
            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
                write!(f, "{}", self.value)
            }
        }
    };
}

然后我使用宏在一堆结构上实现所需的特征（以下是一些示例）：

pub struct VirtBool {
    value: bool
}
impl_data_type_for_num!(VirtBool);
impl_formatting!(VirtBool, "bool");

pub struct VirtU8 {
    value: u8
}
impl_data_type_for_num!(VirtU8);
impl_formatting!(VirtU8, "u8");

pub struct VirtU16 {
    value: u16
}
impl_data_type_for_num!(VirtU16);
impl_formatting!(VirtU16, "u16");

到目前为止，一切正常，但是当我尝试在具有未调整大小的字段的结构上实现相同的特征时，出现了一个问题：

pub struct VirtArray {
    _type: Box<dyn DataType>,
    value: Vec<Box<dyn DataType>>
}
impl DataType for VirtArray {
    fn random() -> Box<Self> {
        let t = random_var();
        let s = thread_rng().gen_range(0, 10);
        Box::new(Self {
            _type: *t,
            value: (0..s).map(|_| t.gen_another()).collect()
        })
    }

    fn gen_another(&self) -> Box<Self> {
        Box::new(Self {
            _type: self._type,
            value: self.value.iter().map(|t| t.gen_another()).collect::<Vec<Box<dyn DataType>>>()
        })
    }
}
impl fmt::Debug for VirtArray {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "[{:?}; {}]", self._type, self.value.len())
    }
}
impl fmt::Display for VirtArray {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let mut s = self.value.iter().map(|v| format!("{}, ",v)).collect::<String>();
        s.truncate(s.len().checked_sub(2).unwrap_or(s.len()));
        write!(f, "[{}]", s)
    }
}

这会引发错误the trait 'DataType' cannot be made into an object有好几次。然后我有一个函数来创建一个随机结构，但这也会引发相同的错误：

/// generate a random type with random value
fn random_var() -> Box<dyn DataType> {
    match thread_rng().gen_range(0,4) {
        0  => Box::new(VirtBool::random()),
        1  => Box::new(VirtU8::random()),
        2  => Box::new(VirtU16::random()),
        3  => Box::new(VirtArray::random()),
        _  => panic!("invalid")
    }
}

我最初使用枚举来完成所有这些操作，但我尝试将其切换为结构和特征以帮助扩展/使用能力。有谁知道如何修复上面的代码？我在这里遇到障碍已经有一段时间了。

另外，我知道我可以使用type_name_of_val打印类型，但我试图避免使用不稳定/夜间功能。

DataType不能制作成特征对象，因为它使用Self因为它有一个静态方法。

我意识到这似乎像是回归Box<Self>可能是合理的要求dyn DataType，因为如果你调用它dyn DataType你想要一个Box<dyn DataType>，但是 Rust 不会尝试修改方法来让你返回返回的方法，例如Box<VirtArray>进入那些返回的Box<dyn DataType>如果他们被叫去dyn DataType价值。您可以通过让方法返回来解决此问题Box<dyn DataType>反而。

特征对象不允许使用静态方法，因为特征对象类型没有实现。记住，dyn Foo实施Foo。什么会(dyn DataType)::random()是？ （您可以使用 where 子句，如上例所示，以确保dyn DataType预计不会以可以提前检测到的方式拥有此方法；这意味着您不能在您的dyn DataType对象，但听起来您可能不想这样做。）