What is the difference between a let-rebinding and a standard assignment?

by

The second let x introduces a second binding that shadows the first one for the rest of the block. That is, there are two variables named x, but you can only access the second one within the block statement after the let x = 12; statement. These two variables don’t need to have the same type!

Then, after the block statement, the second x is out of scope, so you access the first x again.

However, if you write x = 12; instead, that’s an assignment expression: the value in x is overwritten. This doesn’t introduce a new variable, so the type of the value being assigned must be compatible with the variable’s type.

This difference is important if you write a loop. For example, consider this function:

fn fibonacci(mut n: u32) -> u64 {
    if n == 0 {
        return 1;
    }

    let mut a = 1;
    let mut b = 1;

    loop {
        if n == 1 {
            return b;
        }

        let next = a + b;
        a = b;
        b = next;
        n -= 1;
    }
}

This function reassigns variables, so that each iteration of the loop can operate on the values assigned on the preceding iteration.

However, you might be tempted to write the loop like this:

loop {
    if n == 1 {
        return b;
    }

    let (a, b) = (b, a + b);
    n -= 1;
}

This doesn’t work, because the let statement introduces new variables, and these variables will go out of scope before the next iteration begins. On the next iteration, (b, a + b) will still use the original values.

More Related Contents:

  1. What is the difference between Early and Late Binding?
  2. JavaScript Callback Scope [duplicate]
  3. How do I do bindings in ItemContainerStyle in WinRT?
  4. Angular 2 output from router-outlet
  5. How do I make format! return a &str from a conditional expression?
  6. Bind jQuery UI autocomplete using .live()
  7. Variable scope + eval in Clojure
  8. UITableView – Better Editing through Binding?
  9. Is it possible to control the size of an array using the type parameter of a generic?
  10. How do I require a generic type implement an operation like Add, Sub, Mul, or Div in a generic function?
  11. What’s the scope of a variable initialized in an if statement?
  12. Does println! borrow or own the variable?
  13. Binding List to DataGridView in WinForm
  14. Why is it possible to implement Read on an immutable reference to File?
  15. Compare enums only by variant, not value
  16. How can I move a captured variable into a closure within a closure?
  17. How to operate on 2 mutable slices of a Rust array?
  18. Mutating one field while iterating over another immutable field
  19. Multiple return types from a method
  20. Can I have a static borrowed reference to a trait object?
  21. How to end a borrow in a match or if let expression?
  22. Why does creating a mutable reference to a dereferenced mutable reference work?
  23. Cannot borrow `x` as mutable more than once at a time
  24. How do I make an HTTP request from Rust?
  25. What are the differences between using the New keyword and calling CreateObject in Excel VBA?
  26. Why can’t redefine type names in class in C++?
  27. Why is Rust’s assert_eq! implemented using a match?
  28. How can I store function pointers in an array? [duplicate]
  29. Convert two types into a single type with Serde
  30. How can I conditionally provide a default reference without performing unnecessary computation when it isn’t used?

Leave a Comment