我正在编写一个 Rust 板条箱，其中有一个结构体，其字段实现了一个特征，并且我想提供一个功能：

• #[cfg(not(feature = "dyn"))]：结构字段是T静态分派的（性能更高，但运行时灵活性较差）
• #[cfg(feature = "dyn")]：结构字段是Box<dyn MyTrait>，动态分派的特征对象（运行时灵活性，性能成本较低）

trait MyTrait {}

#[cfg(not(feature = "dyn"))]
struct MyStruct<T: MyTrait> {
  my_field: T
}

#[cfg(feature = "dyn")]
struct MyStruct {
  my_field: Box<dyn MyTrait>
}

我的问题是，每一个impl块都需要完全复制，但更改只会影响几行。

#[cfg(not(feature = "dyn"))]
impl<T: MyTrait> MyStruct<T> {
    fn new(field: T) -> Self {
        Self { field }
    }
}

#[cfg(feature = "dyn")]
impl MyStruct {
    fn new(field: impl MyTrait + 'static) -> Self {
        Self { field: Box::new(field) }
    }
}

有没有更优雅的方式来做到这一点？宏黑魔法？这只是一个坏主意，不值得做吗？

Rust 游乐场链接

编辑

根据@cdhowie 的回复

这几乎可以成功编译！但是MyTrait实际上有一个方法（我将其删除以获得一个最小示例）：

trait MyTrait: Sized {
  fn calculate(&self, struct: &MyStruct<Self>);
}

&MyStruct<Self>由于此方法需要访问数据进行计算，因此引用是必要的。

尝试按照建议执行，但不起作用……这会破坏动态兼容性

impl MyTrait for Box<dyn MyTrait> {
//               ^^^^^^^^^^^^^^^^
// ERROR
// the trait `MyTrait` cannot be made into an object

如果我尝试实现 Box 的特征（不确定这是否能解决我的问题），那么麻烦就来了：

impl<T: MyTrait> MyTrait for Box<T> {
    fn calculate(
        &self,
        struct: &MyStruct<Self>,
    ) {
        (**self).calculate(struct)
        //                 ^^^^^^
        // ERROR: mismatched types
        // expected reference &MyStruct<T>
        // found reference &MyStruct<Box<T>>

    }
}

对于我给定的多索引 DataFrame：

df = pd.DataFrame(
    np.random.randn(12),
    index=[
        [1,1,2,3,4,4,5,5,6,6,7,8],
        [1,2,1,1,1,2,1,2,1,2,2,2],
    ]
)

            0
1 1  1.667692
  2  0.274428
2 1  0.216911
3 1 -0.513463
4 1 -0.642277
  2 -2.563876
5 1  2.301943
  2  1.455494
6 1 -1.539390
  2 -1.344079
7 2  0.300735
8 2  0.089269

我想对其进行切片，以便只保留第二个索引级别包含 1 和 2 的行

            0
1 1  1.667692
  2  0.274428
4 1 -0.642277
  2 -2.563876
5 1  2.301943
  2  1.455494
6 1 -1.539390
  2 -1.344079

我怎样才能做到这一点？

我有以下结构：

#[derive(Debug, Serialize)]
struct Container {
    field0: Field<f64>,
    field1: Field<f64>,
}

#[derive(Debug, Serialize)]
struct Field<T> {
    val: T,
    #[serde(skip_serializing_if = "Option::is_none")]
    doc: Option<String>,
}

对于这个例子：

Container {
    field0: Field { val: 1.5, doc: Some("my documentation!") },
    field1: Field { val: 2.0, doc: None }
}

我想要以下 YAML 输出（因为doc是None）：

field0:
  val: 1.5
  doc: my documentation!
field1: 2.0

当然，派生设置的结果是：

field0:
  val: 1.5
  doc: my documentation!
field1:
  val: 2.0

其中val在新行上序列化

我尝试自己实现Serialize，Field但不太确定如何让键名消失，以及如何在与名称相同的行上获取值

impl<T> Serialize for Field<T> where T: Serialize {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        if self.doc.is_some() {
            let mut state = serializer.serialize_struct("Field", 2)?;
            state.serialize_field("val", &self.val)?;
            state.serialize_field("doc", &self.doc)?;
            state.end()
        } else {
            let mut state = serializer.serialize_struct("Field", 1)?;
            state.serialize_field("", &self.val)?;
            state.skip_field("doc")?;
            state.end()
        }
    }
}

产生输出：

field0:
  val: 1.5
  doc: my documentation!
field1:
  '': 2.0

我应该如何实施它？有没有更简单/更干净的方法？

🦀 铁锈游乐场链接🦀