Is there any difference between matching on a reference to a pattern or a dereferenced value?

by

Yes, these are the same to the compiler. In this case, there’s not much benefit. The real benefit comes from the match equivalent:

fn func(data: &Foo) {
    match data {
        &Foo::One => {}
        &Foo::Two => {}
        &Foo::Three => {}
    }
}

Here, you only have to place a single dereference, not 3 references in the patterns:

fn func(data: &Foo) {
    match *data {
        Foo::One => {}
        Foo::Two => {}
        Foo::Three => {}
    }
}

And since Rust 1.26, you don’t even have to dereference the expression being matched on:

fn func(data: &Foo) {
    match data {
        Foo::One => {}
        Foo::Two => {}
        Foo::Three => {}
    }
}

That’s why it’s the idiomatic choice.

The if let concept is just an extension from this.

You can’t always dereference the value. If you tried to do the same thing for a pair of items:

fn func(data: &Foo, data2: &Foo) {
    match (*data, *data2) {
        (Foo::One, _) => {}
        (Foo::Two, _) => {}
        (Foo::Three, _) => {}
    }
}

You get the error

error[E0507]: cannot move out of borrowed content
 --> src/main.rs:8:12
  |
8 |     match (*data, *data2) {
  |            ^^^^^ cannot move out of borrowed content

In this case, you can use the reference form:

fn func(data: &Foo, data2: &Foo) {
    match (data, data2) {
        (&Foo::One, _) => {}
        (&Foo::Two, _) => {}
        (&Foo::Three, _) => {}
    }
}

Or, since Rust 1.26, perform some implicit references:

fn func(data: &Foo, data2: &Foo) {
    match (data, data2) {
        (Foo::One, x) => {}
        (Foo::Two, _) => {}
        (Foo::Three, _) => {}
    }
}

More Related Contents:

  1. Why can’t I store a value and a reference to that value in the same struct?
  2. How do I stop iteration and return an error when Iterator::map returns a Result::Err?
  3. Are polymorphic variables allowed?
  4. Why does Iterator::take_while take ownership of the iterator?
  5. When should I implement std::convert::From vs std::convert::Into?
  6. Efficiently mutate a vector while also iterating over the same vector
  7. How can I call a mutating method while holding a reference to self?
  8. How do I use the Entry API with an expensive key that is only constructed if the Entry is Vacant?
  9. “parameter `’a` is never used” error when ‘a is used in type parameter bound
  10. Borrowing references to attributes in a struct
  11. How do I split a string in Rust?
  12. How can I put an async function into a map in Rust?
  13. Is it possible to implement methods on type aliases?
  14. How can I modify self in a closure called from a member function?
  15. How do I synchronously return a value calculated in an asynchronous Future?
  16. How do I move out of a struct field that is an Option?
  17. Removing elements from a Vec based on some condition [duplicate]
  18. How can I change enum variant while moving the field to the new variant?
  19. What is unwrap in Rust, and what is it used for?
  20. What’s the difference between using the return statement and omitting the semicolon in Rust?
  21. The trait `FnMut` is not implemented for `String` when trying to split a string
  22. HashMap borrow issue when trying to implement find or insert
  23. How can I define an async method in a trait?
  24. Why am I getting “parameter is never used [E0392]”?
  25. How do I specify that a struct field must implement a trait?
  26. What does Rust’s unary || (parallel pipe) mean?
  27. How to create and write to memory mapped files?
  28. Downcast traits inside Rc for AST manipulation
  29. How to check in Rust if architecture is 32 or 64 bit?
  30. Is there any way to restrict a generic type to one of several types?

Leave a Comment