Matching on a struct variant enum

[nicolaction]

I have been playing with rust enums recently, but I found that I can't seem to make them work the way I expect.

I defined struct variants for an enum:

pub enum Entity {
    Character {
        money: f64,
        ....
    },
    ...
}

And I want to match on them. If I match on self, in the module, I get this:

match self {
    Entity::Character(entity) => {
        entity.money = ...

But I get the following error message:

error[E0532]: expected tuple struct/variant, found struct variant types::Entity::Character

What to do? Am I doing this wrong?

PS: I know I can destructure the content of the enum, but I want to use it as if it was defined locally with the correct variant.

[hanna-kruppe]

The syntax you want would be very inconsistent with what Character(entity) means for tuple variants. Besides, this is already possible using @ (regardless of whether it's a tuple variant or struct variant):

match self {
    entity @ Entity::Character { .. } => {
        entity.money = ...

[petrochenkov]

I suspect that @nicolaction wants something like rust-lang/rfcs#1450 and entity is expected to have such variant type, and money is not a field of Entity, but a field of Entity::Character variant type.

So this issue is an RFC material and kinda duplicate of rust-lang/rfcs#1450, and not a bug, so it should probably be closed.

What to do? Am I doing this wrong?
PS: I know I can destructure the content of the enum, but I want to use it as if it was defined locally with the correct variant.

Destructuring is not a bad variant

match self {
    Entity::Character { money, .. } => { .... }
}

but if you don't want to use it, then you can define a separate new type for characters:

struct Character { money: f64, .... }

enum Entity {
    Character(Character),
    ....
}

match self {
    Entity::Character(ref mut ch) { ch.money = .... }
}

[nicolaction]

Thank you, I didn't know about @ bindings.
I tried to use:

&mut entity @ Entity::Character{..} => {

But the binding seems to occur before the variant selection somehow, so entity is an Entity, not an Entity::Character.

I think I will have to use a dedicated struct for each struct variant.

[0X1A]

This is an old issue, but I believe the match expression @nicolaction wanted was:

match self {
    Entity::Character { mut entity } => {
        entity.money = ...

[johnbchron]

For posterity, the example provided by @0X1A adapted to the original problem without introducing a separate type for the fields of a given variant is as follows:

pub enum Entity {
    Character {
        money: f64,
        ....
    },
    ...
}

pub fn modify(&mut self) {
    match self {
        Entity::Character {ref mut money, ..} => {
            money = ...

As of Rust 1.26, the explicit ref and ref mut keywords are no longer required. I included them for clarity.