Rust/Variable

• Rust/Variable/Constant
  • const THREE_HOURS_IN_SECONDS: u32 = 60 * 60 * 3;
  • const can be used in global or function scope
  • const can be initialized with a specific subset of all possible expressions; see Rust Reference’s section on constant evaluation
  • const is required to have a type parameter
• Rust/Variable/let

  • Examples
    • rust

      let foo = 1; // implicit typing
      let foo: u32 = 1; // explicit typing

  • let can only be used in function local scope
  • unlike const, it's not required to have a type annotation, but Rust/analyzer will likely make it difficult to create a new one without inserting the type, e.g. it will change let foo = 1 to let foo: u32 = 1
  • Rust/mut - let mut count = FOUR;
    • mut is a let suffix that makes the variable mutable

  • comparison - Typescript's let keyword vs Rust's let keyword

    • Typescript let
      • mutable by default
      • reassignment is always allowed:
        • ts

          let x = 4;
          x += 1;
          console.log(`${x}`); // 5

    • Rust let
      • immutable by default
      • reassignment is only allowed
        • 1 - if followed with Rust/mut keyword
          • rust

            let mut x = 5;

        • 2 - if let is redeclared, which is what rustacians call Rust/Variable/Shadowing
          • rust

            let x = 5;
            let x += 1;
            println!("{x}"); // 6

  • doesn't need initialization

    • this compiles just fine:
      • rust

        let x;
        let cond: bool = false
        if cond { x = 5; } else { x = 6; }
        println!({x}); // 6

      • Lesson: just because x is immutable by default doesn't mean it has to be initialized with a value. It can be a placeholder for something that's filled up later.
• Rust/Variable/Shadowing

  • you can use Rust/Variable/let on the same var more than once. Subsequent or nested use "shadows" prior use, following traditional scoping rules in c-family languages. Technically this is just a new binding.
  • rust

     let x = 5;
     println!("Initial x: {x}"); // 5
     let x = x + 1; // Shadowing
     println!("Shadowed x: {x}"); // 6
     {
         let x = x * 2; // Shadowing in inner scope
         println!("Inner scope x: {x}"); // 8
     }
     println!("Outer scope x: {x}"); // 6

  • The rules of shadowing also work with Rust/mut - but mutations, in this case can only happen in the scope in which they are (re-)defined.
    • rust

      let mut x = 20;
      println!("Initial x: {x}"); // 20
      {
          let mut x = x;
          x += 2;
      }
      println!("After mutation x: {x}"); // 20