Unwrap inner type when enum variant is known

by

Not really. What I have seen is introducing a new struct for each enum variant, and then methods on the enum to decompose it:

struct Dog(i32);
struct Cat(u8);

enum Animal {
    Dog(Dog),
    Cat(Cat),
}

impl Animal {
    fn cat(self) -> Cat {
        if let Animal::Cat(c) = self { c } else { panic!("Not a cat") }
    }

    fn dog(self) -> Dog {
        if let Animal::Dog(d) = self { d } else { panic!("Not a dog") }
    }
}

// Or better an impl on `Cat` ?
fn count_legs_of_cat(c: Cat) -> u8 {
    c.0
}

Of course, you don’t need the struct and you could just return the u8, but that may get hard to track.

There’s a glimmer of better support for this in the future, however. I think it’s the “efficient code reuse” RFC, but better described in the blog post Virtual Structs Part 3: Bringing Enums and Structs Together. The proposal would be to allow Animal::Cat to be a standalone type, thus your method could accept an Animal::Cat and not have to worry about it.

Personally, I almost always prefer to write the infallible code in my inherent implementation and force the caller to panic:

impl Animal {
    fn cat(self) -> Option<Cat> {
        if let Animal::Cat(c) = self {
            Some(c)
        } else {
            None
        }
    }

    fn dog(self) -> Option<Dog> {
        if let Animal::Dog(d) = self {
            Some(d)
        } else {
            None
        }
    }
}

And I’d probably use a match

impl Animal {
    fn cat(self) -> Option<Cat> {
        match self {
            Animal::Cat(c) => Some(c),
            _ => None,
        }
    }

    fn dog(self) -> Option<Dog> {
        match self {
            Animal::Dog(d) => Some(d),
            _ => None,
        }
    }
}

More Related Contents:

  1. In Rust, is there a way to iterate through the values of an enum?
  2. How do I conditionally check if an enum is one variant or another?
  3. Can traits be used on enum types?
  4. How to get names of enum entries?
  5. What is an idiomatic way of representing enums in Go?
  6. How do the different enum variants work in TypeScript?
  7. Dart How to get the name of an enum as a String
  8. How to programmatically enumerate an enum type?
  9. Enum as Parameter in TypeScript
  10. Does Dart support enumerations?
  11. Effective Enums in Kotlin with reverse lookup?
  12. How can I pull data out of an Option for independent use?
  13. Pass enums in angular2 view templates
  14. Can I convert a string to enum without macros in Rust?
  15. How can I swap in a new value for a field in a mutable reference to a structure?
  16. How to convert a String into a &’static str
  17. How do I see the expanded macro code that’s causing my compile error?
  18. Ways to save enums in database
  19. How can this instance seemingly outlive its own parameter lifetime?
  20. Thread ” has overflowed its stack when allocating a large array using Box
  21. How do you enable a Rust “crate feature”?
  22. Is there an owned version of String::chars?
  23. How to implement Iterator yielding mutable references [duplicate]
  24. How can the ref keyword be avoided when pattern matching in a function taking &self or &mut self?
  25. How to swap two variables?
  26. Can I avoid eager ambiguity resolution for trait implementations with generics?
  27. Expected bound lifetime parameter, found concrete lifetime [E0271]
  28. Why must an enumeration’s size be provided when it is forward declared?
  29. What is the null pointer optimization in Rust?
  30. How to read a struct from a file in Rust?

Leave a Comment