Estou escrevendo um Rust crate onde tenho uma struct cujo campo implementa uma característica, e gostaria de fornecer um recurso onde:

• #[cfg(not(feature = "dyn"))]: o campo struct é Tdespachado estaticamente (mais eficiente, mas menos flexível em tempo de execução)
• #[cfg(feature = "dyn")]: struct field é Box<dyn MyTrait>um objeto de característica despachado dinamicamente (flexibilidade de tempo de execução com pequeno custo de desempenho)

trait MyTrait {}

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

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

Meu problema é que cada implbloco precisa ser duplicado por completo, quando as alterações deveriam afetar apenas algumas linhas.

#[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) }
    }
}

Existe uma maneira mais elegante de fazer isso? Macro black magic? Isso é apenas uma má ideia e não vale a pena fazer?

Link do playground Rust

Editar

Por resposta de @cdhowie

Isso quase chega à compilação bem-sucedida! No entanto, MyTraitna verdade tem um método (que eu retirei para obter um exemplo mínimo):

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

a referência &MyStruct<Self>é necessária porque esse método precisa acessar dados para cálculos.

Tentar implementar como sugerido não funciona... algo sobre isso quebra a compatibilidade dinâmica

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

Se eu tentar implementar a característica para Box (não tenho certeza se isso resolveria meu problema), esse é o problema:

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>>

    }
}

Para meu DataFrame multi-indexado fornecido:

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

Gostaria de dividi-lo de forma que eu mantenha apenas as linhas onde o segundo nível de índice contém AMBOS 1 e 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

Como posso fazer isso?

Eu tenho as seguintes estruturas:

#[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>,
}

Para este caso:

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

Quero a seguinte saída YAML (já que docis None):

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

Claro, a configuração derivada resulta nisto:

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

onde valé serializado em uma nova linha

Tentei implementar Serializesozinho Field, mas não tinha certeza de como fazer com que o nome da chave desaparecesse e como colocar o valor na mesma linha do nome

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()
        }
    }
}

resultando na saída:

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

Como devo proceder para implementá-lo? Existe uma maneira mais fácil/limpa?

🦀 LINK DO RUST PLAYGROUND 🦀