Complete Guide to Rust Variables

Introduction to Rust Variables

Variables are fundamental building blocks in any programming language, used to store and manipulate data. Rust's approach to variables is unique, emphasizing safety, immutability by default, and clear ownership semantics. Understanding variables in Rust is crucial for writing efficient and safe code.

Key Concepts

Immutability by Default: Variables are immutable unless explicitly made mutable
Type Safety: Every variable has a compile-time known type
Ownership: Each value has a single owner variable
Shadowing: Reusing variable names with new bindings
Memory Safety: Automatic memory management without garbage collection

1. Variable Declaration

Basic Syntax

fn main() { // Immutable variable (default) let x = 5; // x = 6; // This would cause a compile error! // Mutable variable let mut y = 5; y = 6; // This is allowed println!("y = {}", y); // Type annotation let z: i32 = 10; let name: &str = "Alice"; let is_active: bool = true; // Multiple declarations let a = 5; let b = 10; // Declare without initializing (rare, but possible) let uninitialized_var; // Cannot use uninitialized_var here uninitialized_var = 42; // Now it's initialized println!("uninitialized_var = {}", uninitialized_var); }

Naming Conventions

fn main() { // Valid variable names let name = "Alice"; let first_name = "Bob"; let _unused = 42; // Underscore prefix suppresses unused warning let r#type = "special"; // Raw identifier (rare, for keywords) // Case conventions let snake_case = "variables"; // Rust uses snake_case for variables let SCREAMING_SNAKE_CASE = "constants"; // For constants and statics let camelCase = "not_typical"; // Not idiomatic in Rust // Numbers in names let version2 = "2.0"; let item_1 = "first"; // Unicode is allowed (but not recommended) let 名字 = "name in Chinese"; // Valid but avoid for portability }

2. Immutability vs Mutability

Immutable Variables (Default)

fn main() { // Immutable by default - cannot change let x = 5; println!("x = {}", x); // This would fail: // x = 10; // ERROR: cannot assign twice to immutable variable // Benefits of immutability: // - Thread safety // - Easier to reason about code // - Prevents accidental modifications // Immutable reference let s1 = String::from("hello"); let s2 = &s1; // Borrow immutably println!("s1 = {}, s2 = {}", s1, s2); // Both can be read // Immutable struct struct Point { x: i32, y: i32, } let point = Point { x: 10, y: 20 }; // point.x = 30; // ERROR: cannot mutate immutable struct field }

Mutable Variables

fn main() { // Mutable variable - can change let mut x = 5; println!("Initial x = {}", x); x = 10; println!("Modified x = {}", x); x += 5; println!("After addition x = {}", x); // Mutable string let mut s = String::from("hello"); s.push_str(", world"); println!("s = {}", s); // Mutable struct struct Point { x: i32, y: i32, } let mut point = Point { x: 10, y: 20 }; point.x = 30; // Allowed because point is mutable println!("point.x = {}", point.x); // Mutable array let mut arr = [1, 2, 3, 4, 5]; arr[0] = 10; println!("arr = {:?}", arr); // Mutable vector let mut vec = Vec::new(); vec.push(1); vec.push(2); vec.push(3); println!("vec = {:?}", vec); }

Performance Considerations

fn main() { // Immutable variables can enable compiler optimizations let x = 5; // Compiler knows this never changes // Mutable variables have a small overhead but enable flexibility let mut counter = 0; for i in 0..10 { counter += i; // Need mutability here } // Large immutable data structures can be shared safely let large_data = vec![0; 1_000_000]; // Cloning vs mutating let mut data = vec![1, 2, 3]; // Mutation (efficient) data.push(4); // Immutable approach (creates new allocation) let data2 = [&data[..], &[4]].concat(); }

3. Type Annotations and Inference

Type Inference

fn main() { // Rust infers types from usage let x = 5; // i32 (default integer type) let y = 3.14; // f64 (default float type) let z = "hello"; // &str let v = vec![1, 2, 3]; // Vec<i32> // Type inference works with generics let mut numbers = Vec::new(); numbers.push(1); // Now numbers is Vec<i32> // Complex inference let result = (1..10) .filter(|&x| x % 2 == 0) .map(|x| x * x) .collect::<Vec<_>>(); // Type specified at the end println!("result = {:?}", result); }

Explicit Type Annotations

fn main() { // Basic type annotations let x: i32 = 5; let y: f64 = 3.14; let z: bool = true; let c: char = 'a'; let s: String = String::from("hello"); // Integer types let a: i8 = 127; // -128 to 127 let b: u8 = 255; // 0 to 255 let c: i16 = 32767; // -32768 to 32767 let d: i32 = 2147483647; // -2^31 to 2^31-1 let e: i64 = 9223372036854775807; let f: isize = 100; // Architecture-dependent // Floating point let g: f32 = 3.14; let h: f64 = 2.71828; // Complex types let tuple: (i32, f64, &str) = (10, 3.14, "hello"); let array: [i32; 5] = [1, 2, 3, 4, 5]; let slice: &[i32] = &array[1..3]; // Reference types let ref_i: &i32 = &x; let ref_mut: &mut i32 = &mut 5; // Function pointers let func: fn(i32) -> i32 = |x| x * 2; }

Type Casting and Conversion

fn main() { // Using 'as' for primitive conversion let x: i32 = 5; let y: f64 = x as f64; let z: i16 = x as i16; // Potential loss of data let big_num: i32 = 1000; let small_num: i8 = big_num as i8; // Wraps around (becomes -24) println!("1000 as i8 = {}", small_num); // -24 // Safe conversions with From/Into let num = 5; let num_str: String = num.to_string(); // Parsing strings let parsed: i32 = "42".parse().unwrap(); let parsed2 = "42".parse::<i32>().unwrap(); // Using try_from for safe conversions use std::convert::TryFrom; let large = 256; match i8::try_from(large) { Ok(val) => println!("Converted: {}", val), Err(e) => println!("Failed: {}", e), } }

4. Variable Scope and Lifetime

Block Scope

fn main() { // Variables are scoped to blocks let x = 5; { // Inner scope let y = 10; println!("Inner x = {}, y = {}", x, y); // Can access outer x // y is valid here } // y goes out of scope // println!("y = {}", y); // ERROR: y not found // Shadowing in nested scopes let z = 15; { let z = 20; // Shadows outer z println!("Inner z = {}", z); // 20 } println!("Outer z = {}", z); // 15 }

Function Scope

fn main() { let outer_var = 10; // Function call passes ownership or borrows process_value(outer_var); // outer_var moved or copied // println!("outer_var = {}", outer_var); // If moved, this fails let reference = &outer_var; process_ref(reference); // Borrowing println!("Still can use: {}", outer_var); } fn process_value(x: i32) { println!("Processing: {}", x); } // x dropped here fn process_ref(x: &i32) { println!("Processing reference: {}", x); } // Only reference dropped, original value remains

Lifetime Annotations

// Lifetime annotations specify how long references live fn longest<'a>(x: &'a str, y: &'a str) -> &'a str { if x.len() > y.len() { x } else { y } } fn main() { let string1 = String::from("long string is long"); let result; { let string2 = String::from("xyz"); result = longest(&string1, &string2); println!("Longest: {}", result); // Valid here } // string2 dropped // println!("Longest: {}", result); // ERROR: string2 dropped }

5. Shadowing

Basic Shadowing

fn main() { // Shadowing with same type let x = 5; let x = x + 1; // Shadows previous x let x = x * 2; println!("x = {}", x); // 12 // Shadowing with different type let name = "Alice"; let name = name.len(); // Now name is usize println!("name length = {}", name); // Shadowing in loops let mut counter = 0; let result = loop { counter += 1; if counter == 10 { break counter * 2; } }; // Shadowing with mutability change let value = 5; let mut value = value; // Now mutable value += 5; println!("value = {}", value); }

Advanced Shadowing Patterns

fn main() { // Parsing with shadowing let input = "42"; let input: i32 = input.parse().unwrap(); let input = input * 2; println!("input = {}", input); // Option handling with shadowing let maybe_value: Option<i32> = Some(10); if let Some(value) = maybe_value { // 'value' shadows the outer scope's variable println!("Got value: {}", value); } // Shadowing in match expressions let x = Some(5); match x { Some(x) => println!("Matched: {}", x), // x shadows outer x None => (), } // Shadowing for transformations let data = vec![1, 2, 3, 4, 5]; let data = data.iter().map(|&x| x * 2).collect::<Vec<_>>(); let data = data.iter().filter(|&&x| x > 5).collect::<Vec<_>>(); println!("Transformed data: {:?}", data); }

6. Constants and Statics

Constants

// Constants are always immutable, evaluated at compile time const MAX_POINTS: u32 = 100_000; const GRAVITY: f64 = 9.81; const APPLICATION_NAME: &str = "My Rust App"; // Constants can be computed at compile time const SECONDS_IN_HOUR: u32 = 60 * 60; const ARRAY_SIZE: usize = 5 * 4 * 3; // Constants in different scopes fn example() { const LOCAL_CONST: i32 = 42; println!("Local constant: {}", LOCAL_CONST); } fn main() { println!("MAX_POINTS = {}", MAX_POINTS); println!("GRAVITY = {}", GRAVITY); println!("SECONDS_IN_HOUR = {}", SECONDS_IN_HOUR); example(); // Constants can be used in array sizes let arr: [i32; ARRAY_SIZE] = [0; ARRAY_SIZE]; println!("Array length: {}", arr.len()); }

Static Variables

// Static variables have a fixed memory location static APP_NAME: &str = "My Application"; static VERSION: &str = "1.0.0"; // Mutable static (unsafe) static mut COUNTER: u32 = 0; // Static with complex type static DEFAULT_CONFIG: Config = Config { timeout: 30, retries: 3, }; struct Config { timeout: u32, retries: u32, } fn main() { // Reading static is safe println!("App: {}, Version: {}", APP_NAME, VERSION); // Modifying mutable static requires unsafe unsafe { COUNTER += 1; println!("Counter: {}", COUNTER); } // Statics have 'static lifetime let static_ref: &'static str = APP_NAME; }

Constants vs Statics

// Key differences: // - Constants are inlined, statics have fixed memory location // - Constants can only be primitive types, statics can be more complex // - Constants are always immutable, statics can be mutable (unsafe) const CONST_VAL: i32 = 42; // Inlined at compile time static STATIC_VAL: i32 = 42; // Single memory location fn main() { // Each usage of CONST_VAL might create a new copy let a = CONST_VAL; let b = CONST_VAL; // STATIC_VAL has the same address everywhere println!("Static address: {:p}", &STATIC_VAL); // Constants work in pattern matching, statics don't match a { CONST_VAL => println!("Matched constant!"), _ => println!("No match"), } }

7. Variable Binding Patterns

Destructuring

fn main() { // Tuple destructuring let tuple = (1, "hello", 3.14); let (a, b, c) = tuple; println!("a = {}, b = {}, c = {}", a, b, c); // Ignoring values with _ let (x, _, z) = (10, 20, 30); println!("x = {}, z = {}", x, z); // Struct destructuring struct Point { x: i32, y: i32, z: i32, } let point = Point { x: 10, y: 20, z: 30 }; let Point { x, y, z } = point; println!("x = {}, y = {}, z = {}", x, y, z); // Destructuring with renaming let Point { x: a, y: b, z: c } = point; println!("a = {}, b = {}, c = {}", a, b, c); // Array destructuring let arr = [1, 2, 3, 4, 5]; let [first, second, ..] = arr; println!("first = {}, second = {}", first, second); // Nested destructuring let nested = (1, (2, 3), 4); let (a, (b, c), d) = nested; println!("a = {}, b = {}, c = {}, d = {}", a, b, c, d); }

Pattern Matching in Bindings

fn main() { // Conditional binding with if let let optional = Some(5); if let Some(x) = optional { println!("x = {}", x); } // while let for loops let mut stack = Vec::new(); stack.push(1); stack.push(2); stack.push(3); while let Some(top) = stack.pop() { println!("Popped: {}", top); } // match bindings let value = Some(10); match value { Some(x) if x < 5 => println!("Small: {}", x), Some(x) => println!("Large: {}", x), None => println!("Nothing"), } // Reference patterns let x = 5; let y = &x; match y { &val => println!("Got value: {}", val), } // Equivalent with deref match *y { val => println!("Got value: {}", val), } }

8. Ownership and Borrowing

Ownership Rules

fn main() { // Rule 1: Each value has an owner let s1 = String::from("hello"); // s1 owns the string // Rule 2: Only one owner at a time let s2 = s1; // Ownership moves to s2 // println!("{}", s1); // ERROR: s1 no longer valid // Rule 3: When owner goes out of scope, value is dropped { let s3 = String::from("temporary"); } // s3 dropped here // Copy types (implement Copy trait) let x = 5; // i32 implements Copy let y = x; // x is copied, not moved println!("x = {}, y = {}", x, y); // Both valid }

Borrowing

fn main() { let s = String::from("hello"); // Immutable borrow let len = calculate_length(&s); println!("Length of '{}' is {}", s, len); // Mutable borrow let mut s = String::from("hello"); change(&mut s); println!("Modified: {}", s); // Multiple borrows let s = String::from("hello"); let r1 = &s; let r2 = &s; // Multiple immutable borrows are fine println!("{} and {}", r1, r2); // r1 and r2 are no longer used let r3 = &mut s; // Now we can mutably borrow println!("{}", r3); } fn calculate_length(s: &String) -> usize { s.len() } fn change(s: &mut String) { s.push_str(", world"); }

Borrowing Rules

fn main() { // Rule: Can't have mutable and immutable borrows simultaneously let mut s = String::from("hello"); let r1 = &s; // immutable borrow let r2 = &s; // immutable borrow // let r3 = &mut s; // ERROR: cannot borrow as mutable println!("{}, {}", r1, r2); // r1 and r2 go out of scope here let r3 = &mut s; // Now this is fine println!("{}", r3); // Rule: Can't have two mutable borrows let mut s = String::from("hello"); let r1 = &mut s; // let r2 = &mut s; // ERROR: cannot borrow as mutable more than once // println!("{}", r1); // This would cause error if uncommented }

9. Variable Storage Locations

Stack vs Heap

fn main() { // Stack allocated (fixed size, known at compile time) let x = 5; // i32 goes on stack let y = true; // bool on stack let z = 3.14; // f64 on stack let arr = [1, 2, 3]; // array on stack (if size known) // Heap allocated (dynamic size) let s = String::from("hello"); // String data on heap let vec = vec![1, 2, 3, 4, 5]; // Vec data on heap let boxed = Box::new(5); // Box puts value on heap // Box for recursive types #[derive(Debug)] enum List { Cons(i32, Box<List>), Nil, } let list = List::Cons(1, Box::new(List::Cons(2, Box::new(List::Nil)))); println!("{:?}", list); }

Memory Layout

use std::mem; fn main() { // Size of types println!("Size of i32: {} bytes", mem::size_of::<i32>()); println!("Size of bool: {} bytes", mem::size_of::<bool>()); println!("Size of String: {} bytes", mem::size_of::<String>()); println!("Size of Vec<i32>: {} bytes", mem::size_of::<Vec<i32>>()); // Alignment println!("Alignment of i32: {}", mem::align_of::<i32>()); // Custom struct layout struct MyStruct { a: u8, // 1 byte b: u32, // 4 bytes (requires padding) c: u16, // 2 bytes } // Actual layout: a(1) + padding(3) + b(4) + c(2) + padding(2) = 12 bytes println!("Size of MyStruct: {} bytes", mem::size_of::<MyStruct>()); }

10. Advanced Variable Techniques

Lazy Initialization

use std::cell::RefCell; use std::sync::Once; // Lazy static with Once static mut LAZY_VAR: Option<String> = None; static INIT: Once = Once::new(); fn get_lazy_var() -> &'static String { unsafe { INIT.call_once(|| { LAZY_VAR = Some(String::from("Initialized lazily")); }); LAZY_VAR.as_ref().unwrap() } } // Using lazy_static crate pattern struct LazyStatic { value: RefCell<Option<String>>, } impl LazyStatic { fn new() -> Self { LazyStatic { value: RefCell::new(None), } } fn get(&self) -> String { let mut value = self.value.borrow_mut(); if value.is_none() { *value = Some(String::from("Computed lazily")); } value.clone().unwrap() } } fn main() { println!("First access: {}", get_lazy_var()); println!("Second access: {}", get_lazy_var()); let lazy = LazyStatic::new(); println!("First: {}", lazy.get()); println!("Second: {}", lazy.get()); }

Thread-Local Variables

use std::cell::RefCell; use std::thread; thread_local! { static THREAD_COUNTER: RefCell<u32> = RefCell::new(0); } fn main() { // Each thread gets its own copy THREAD_COUNTER.with(|counter| { *counter.borrow_mut() += 1; println!("Main thread counter: {}", *counter.borrow()); }); let handle = thread::spawn(|| { THREAD_COUNTER.with(|counter| { *counter.borrow_mut() += 10; println!("Spawned thread counter: {}", *counter.borrow()); }); }); handle.join().unwrap(); THREAD_COUNTER.with(|counter| { println!("Main thread still has: {}", *counter.borrow()); }); }

Atomic Variables

use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering}; use std::sync::Arc; use std::thread; fn main() { // Atomic variables for thread-safe sharing let counter = Arc::new(AtomicUsize::new(0)); let running = Arc::new(AtomicBool::new(true)); let mut handles = vec![]; for _ in 0..10 { let counter = counter.clone(); let running = running.clone(); handles.push(thread::spawn(move || { while running.load(Ordering::Relaxed) { counter.fetch_add(1, Ordering::SeqCst); thread::sleep(std::time::Duration::from_millis(10)); } })); } thread::sleep(std::time::Duration::from_millis(100)); running.store(false, Ordering::SeqCst); for handle in handles { handle.join().unwrap(); } println!("Final counter: {}", counter.load(Ordering::SeqCst)); }

11. Pattern Matching with Variables

Match Guards and Bindings

fn main() { let pair = (2, -2); match pair { (x, y) if x == y => println!("Equal"), (x, y) if x + y == 0 => println!("Opposites"), (x, _) if x % 2 == 0 => println!("First is even"), _ => println!("No match"), } // @ bindings let value = Some(5); match value { Some(x @ 1..=5) => println!("Small number: {}", x), Some(x @ 6..=10) => println!("Medium number: {}", x), Some(x) => println!("Large number: {}", x), None => println!("None"), } // Binding with destructuring struct Person { name: String, age: u32, } let person = Person { name: String::from("Alice"), age: 30, }; match person { Person { name: n @ _, age: 30 } => println!("Age 30 person"), Person { name: ref n, age } => println!("Person: {}", n), } }

Ref Patterns

fn main() { let x = 5; // ref borrows a value let ref r = x; // Equivalent to let r = &x; println!("{}", r); // ref mut for mutable borrow let mut y = 5; let ref mut r2 = y; *r2 = 10; println!("y = {}", y); // In patterns let maybe_value = Some(String::from("hello")); match maybe_value { Some(ref s) => println!("Borrowed: {}", s), // s is &String None => (), } // Now we can still use maybe_value println!("Still have: {:?}", maybe_value); }

12. Performance Considerations

Copy vs Move Semantics

#[derive(Debug, Clone)] struct LargeStruct { data: [u8; 1024], // 1KB of data } fn main() { // Copy types (cheap) let x = 5; let y = x; // Copy (no performance cost) println!("x = {}, y = {}", x, y); // Move types (ownership transfer) let large = LargeStruct { data: [0; 1024] }; let large2 = large; // Move (no copy, just ownership transfer) // println!("{:?}", large); // ERROR: large moved // Clone (expensive, copies data) let large = LargeStruct { data: [0; 1024] }; let large2 = large.clone(); // Copies 1KB of data println!("Both exist: {:?} and {:?}", large.data[0], large2.data[0]); // Best practice: borrow instead of move/clone when possible let large = LargeStruct { data: [0; 1024] }; process_large(&large); // Borrow println!("Still own large: {:?}", large.data[0]); } fn process_large(large: &LargeStruct) { println!("Processing: {:?}", large.data[0]); }

Variable Reuse and Optimization

fn main() { // Reusing variable with shadowing (no new allocation necessarily) let mut data = vec![1, 2, 3, 4, 5]; // Transform in place for item in &mut data { *item *= 2; } println!("Doubled: {:?}", data); // Transform with new variable (may allocate) let data_squared: Vec<_> = data.iter().map(|&x| x * x).collect(); println!("Squared: {:?}", data_squared); // Reusing allocation with clear let mut buffer = String::with_capacity(100); for i in 0..10 { buffer.clear(); // Reuse allocation buffer.push_str(&format!("Line {}", i)); println!("{}", buffer); } }

Conclusion

Rust's variable system is designed around key principles:

Key Takeaways

Immutability by Default: Variables are immutable unless explicitly marked mut
Type Safety: Strong, static typing with excellent inference
Ownership: Clear rules about who owns data
Shadowing: Reuse variable names with new bindings
Constants and Statics: Compile-time and runtime constants
Pattern Matching: Destructuring and binding in patterns
Memory Safety: No dangling references or data races

Best Practices

Prefer immutable variables by default
Use mut only when mutation is necessary
Leverage shadowing for type conversions
Use const for compile-time constants
Use borrowing instead of ownership transfer when possible
Be explicit with types in public APIs
Use pattern matching for complex destructuring

Performance Guidelines

Use copy types for small, frequently copied data
Use references to avoid cloning large data
Reuse allocations when possible
Profile before optimizing variable usage
Consider Box for large types on the heap

Rust's variable system provides a solid foundation for writing safe, efficient, and maintainable code. Understanding these concepts is essential for mastering the language.