Why does pattern matching on &Option yield something of type Some(&T)?

by

The type of the expression &l you match against is &Option<i32>, so if we are strict the patterns should be &None and &Some(x), and if we use these patterns, the type of x indeed is i32. If we omit the ampersand in the patterns, as you did in your code, it first looks like the patterns should not be able to match at all, and the compiler should throw an error similar to “expected Option, found reference”, and indeed this is what the compiler did before Rust version 1.26.

Current versions of Rust support “match ergonomics” introduced by RFC 2005, and matching a reference to an enum against a pattern without the ampersand is now allowed. In general, if your match expression is only a reference, you can’t move any members out of the enum, so matching a reference against Some(x) is equivalent to matching against the pattern &Some(ref x), i.e. x becomes a reference to the inner value of the Option. In your particular case, the inner value is an i32, which is Copy, so you would be allowed to match against &Some(x) and get an i32, but this is not possible for general types.

The idea of the RFC is to make it easier to get the ampersands and refs in patterns right, but I’m not completely convinced whether the new rules actually simplified things, or whether they added to the confusion by making things magically work in some cases, thereby making it more difficult for people to get a true understanding of the underlying logic. (This opinion is controversial – see the comments.)

More Related Contents:

  1. Is there any way to return a reference to a variable created in a function?
  2. Why can I return a reference to a local literal but not a variable?
  3. Cannot move out of borrowed content / cannot move out of behind a shared reference
  4. Why are explicit lifetimes needed in Rust?
  5. Cannot borrow as mutable because it is also borrowed as immutable
  6. How do I implement the Add trait for a reference to a struct?
  7. Cannot move out of borrowed content when trying to transfer ownership
  8. How to avoid writing duplicate accessor functions for mutable and immutable references in Rust?
  9. Iterator returning items by reference, lifetime issue
  10. What is the purpose of `&` before the loop variable?
  11. Why is “&&” being used in closure arguments?
  12. When should I not implement a trait for references to implementors of that trait?
  13. What is an idiomatic way to collect an iterator of &T into a collection of Ts?
  14. How to abstract over a reference to a value or a value itself?
  15. Rust lifetime error expected concrete lifetime but found bound lifetime
  16. Why can’t I store a value and a reference to that value in the same struct?
  17. Why is it discouraged to accept a reference to a String (&String), Vec (&Vec), or Box (&Box) as a function argument?
  18. How can I pass a reference to a stack variable to a thread?
  19. What are Rust’s exact auto-dereferencing rules?
  20. What’s the difference between placing “mut” before a variable name and after the “:”?
  21. Why does linking lifetimes matter only with mutable references?
  22. Why is the return type of Deref::deref itself a reference?
  23. Convert Vec into a slice of &str in Rust?
  24. What lifetimes do I use to create Rust structs that reference each other cyclically?
  25. How to query mongodb with DBRef
  26. Finding all references of a variable or a method in Xcode4
  27. How can I conditionally provide a default reference without performing unnecessary computation when it isn’t used?
  28. Pass by reference problem with PHP 5.3.1 [duplicate]
  29. How do I return a reference to something inside a RefCell without breaking encapsulation?
  30. What are classes, references, and objects?

Leave a Comment