Thomas's questions

Estou usando a especialização genérica para ter um tipo de tempo de compilação personalizado em alguma estrutura de dados enum:

pub trait MyEnumState{}

// All state are Zero Sized Type
pub struct State1; impl MyEnumState for State1{};
pub struct State2; impl MyEnumState for State2{};

// Note : I don't know is there is a PhantomData<S> for an enum
pub enum MyEnum<S: MyEnumState> {
    A,
    B,
    C(i32), // Can also have some data
    // ... long enum
}

Agora eu gostaria de poder lançá-los: mesmo valor, tipo diferente

// How to avoid this mess ???
impl MyEnum<State1> {
    pub fn to_state2(self) -> MyEnum<State2> {
        match self {
            MyEnum::A => MyEnum::A,
            MyEnum::B => MyEnum::B,
            MyEnum::C(v) => MyEnum::C(v),
        }
    }
}

// I can proably make a generic function
// ```
// fn cast
//     <StateBegin : MyEnumState, StateEnd : MyEnumState>
// (val MyEnum<StateBegin>) -> MyEnum<StateEnd> { ... }
// ```
// to avoid repetition but I still have at least 1 giant match to implement
impl MyEnum<State2> { ... }



impl<S : MyEnumState> MyEnum<S> 
{
   pub fn to_state<NewState : MyEnumState>(self) ->  MyEnum<NewState> 
   {
      // how ?!
   }
}

Este é apenas um exemplo simples, o objetivo é ter 0 instruções de correspondência para evitar a correspondência de todas as variantes de enum existentes.