How does ownership interact with pattern matching

Pattern matching in Rust moves ownership of values into the pattern bindings by default, meaning the original variable can no longer be used after the match. To access the data without taking ownership, use the ref keyword to bind by reference or & to match against a reference directly.

enum Message {
    Quit,
    Move { x: i32, y: i32 },
}

let msg = Message::Move { x: 10, y: 20 };

// Takes ownership of the fields
match msg {
    Message::Move { x, y } => println!("Moved to {}, {}", x, y),
    _ => (),
}
// msg is now unusable here

// Borrowing instead of moving
let msg2 = Message::Move { x: 10, y: 20 };
match msg2 {
    Message::Move { ref x, ref y } => println!("Borrowed: {}, {}", x, y),
    _ => (),
}
// msg2 is still usable here

When you match a value in Rust, the code usually takes full control (ownership) of that data, preventing you from using the original variable again. Think of it like handing a physical object to someone; once they have it, you don't. If you only need to look at the data without taking it, you can ask to borrow it instead, leaving the original item in your possession.