Why is a borrow still held in the else block of an if let?

by

I put together an example to show off the scoping rules here:

struct Foo {
    a: i32,
}

impl Drop for Foo {
    fn drop(&mut self) {
        println!("Foo: {}", self.a);
    }
}

fn generate_temporary(a: i32) -> Option<Foo> {
    if a != 0 { Some(Foo { a: a }) } else { None }
}

fn main() {
    {
        println!("-- 0");
        if let Some(foo) = generate_temporary(0) {
            println!("Some Foo {}", foo.a);
        } else {
            println!("None");
        }
        println!("-- 1");
    }
    {
        println!("-- 0");
        if let Some(foo) = generate_temporary(1) {
            println!("Some Foo {}", foo.a);
        } else {
            println!("None");
        }
        println!("-- 1");
    }
    {
        println!("-- 0");
        if let Some(Foo { a: 1 }) = generate_temporary(1) {
            println!("Some Foo {}", 1);
        } else {
            println!("None");
        }
        println!("-- 1");
    }
    {
        println!("-- 0");
        if let Some(Foo { a: 2 }) = generate_temporary(1) {
            println!("Some Foo {}", 1);
        } else {
            println!("None");
        }
        println!("-- 1");
    }
}

This prints:

-- 0
None
-- 1
-- 0
Some Foo 1
Foo: 1
-- 1
-- 0
Some Foo 1
Foo: 1
-- 1
-- 0
None
Foo: 1
-- 1

In short, it seems that the expression in the if clause lives through both the if block and the else block.

On the one hand it is not surprising since it is indeed required to live longer than the if block, but on the other hand it does indeed prevent useful patterns.

If you prefer a visual explanation:

if let pattern = foo() {
    if-block
} else {
    else-block
}

desugars into:

{
    let x = foo();
    match x {
    pattern => { if-block }
    _ => { else-block }
    }
}

while you would prefer that it desugars into:

bool bypass = true;
{
    let x = foo();
    match x {
    pattern => { if-block }
    _ => { bypass = false; }
    }
}
if not bypass {
    else-block
}

You are not the first one being tripped by this, so this may be addressed at some point, despite changing the meaning of some code (guards, in particular).

More Related Contents:

  1. Traits and Rust
  2. Why do try!() and ? not compile when used in a function that doesn’t return Option or Result?
  3. Why does linking lifetimes matter only with mutable references?
  4. How do I collect into an array?
  5. Cannot borrow as mutable more than once at a time in one code – but can in another very similar
  6. How do I convert a Vec to a Vec without copying the vector?
  7. How do you access enum values in Rust?
  8. Situations where Cell or RefCell is the best choice
  9. Cannot infer an appropriate lifetime for autoref due to conflicting requirements
  10. Why does this read input before printing?
  11. How to create an in-memory object that can be used as a Reader, Writer, or Seek in Rust?
  12. Why does my variable not live long enough?
  13. What is the syntax to match on a reference to an enum?
  14. If BufReader takes ownership of a stream, how can I read and write lines on it?
  15. Why can’t I return an &str value generated from a String?
  16. How to fix lifetime error when function returns a serde Deserialize type?
  17. Why are recursive struct types illegal in Rust?
  18. Understanding Traits and Object Safety
  19. How can I create enums with constant values in Rust?
  20. What is the prelude?
  21. How to embed resources in Rust executable?
  22. Sized is not implemented for the type Fn
  23. Extend lifetime of variable
  24. Can’t implement a trait I don’t own for all types that implement a trait I do own
  25. How do I print an integer in binary with leading zeros?
  26. What does Rust’s unary || (parallel pipe) mean?
  27. How does Rust’s type inference work across multiple statements?
  28. Why does Valgrind not detect a memory leak in a Rust program using nightly 1.29.0?
  29. What is the null pointer optimization in Rust?
  30. How to pass rustc flags to cargo?

Leave a Comment