How to map a parametrized enum from a generic type to another?

Some languages (like C++), use Duck Typing: if it quacks like a duck, it must be a duck, and therefore names matter. Rust does not.

In Rust, names are just some display utility for us mere humans, the B in MyEnum<u32> and MyEnum<String> may happen to have the same visual representation, but they are completely different syntactic entities as far as the language is concerned.

---

There are multiple ways to alleviate your pain, though:

• a code generation plugin or build.rs script can be used as well
• a macro can be used to automate the mapping
• a manual mapping can be done, it's a one shot effort after all
• the code can be restructured to separate type-dependent from type-independent variants

I'll show-case the latter:

enum MyEnumImpl {
    A,
    B,
    C,
}

enum MyEnum<T> {
    Independent(MyEnumImpl),
    Dependent(T),
}

Obviously, the latter makes it much easier to manually map things.

Well, this is actually an answer:

enum MyEnum<T> {
    B,
    C,
    D(T),
}

fn trans(a: MyEnum<u32>) -> MyEnum<String> {
    match a {
        MyEnum::D(i) => MyEnum::D(i.to_string()),
        MyEnum::B => MyEnum::B,
        MyEnum::C => MyEnum::C
    }
}

fn main() {
}

But repeating all variants isn't acceptable when there's a lot of them..

I'd create a map method on your enum:

#[derive(Debug)]
enum MyEnum<T> {
    B,
    C,
    D(T),
}

impl<T> MyEnum<T> {
    fn map<U>(self, f: impl FnOnce(T) -> U) -> MyEnum<U> {
        use MyEnum::*;

        match self {
            B => B,
            C => C,
            D(x) => D(f(x)),
        }
    }
}

fn main() {
    let answer = MyEnum::D(42);
    let answer2 = answer.map(|x| x.to_string());
    println!("{:?}", answer2);
}

This is similar to existing map methods, such as Option::map.