Introduction to Scope in Rust

Scope in Rust defines the region of code where a variable or item is valid and accessible. Understanding scope is crucial for mastering Rust's ownership model, memory management, and borrowing rules. Rust's scope system is designed to prevent common bugs like use-after-free, double-free, and data races.

Key Concepts

• Block Scope: Variables are valid only within their defining block
• Ownership: Values are dropped when their owner goes out of scope
• Lifetime: The period during which a reference is valid
• Shadowing: Reusing variable names in nested scopes
• Visibility: Control over item accessibility with pub

1. Basic Block Scope

Simple Block Scope

fn main() {
// Outer scope
let x = 5;
println!("Outer x: {}", x);
{
// Inner scope
let y = 10;
println!("Inner x: {}, y: {}", x, y); // Can access outer x
} // y goes out of scope here
// println!("y: {}", y); // Error: y not found in this scope
println!("Outer x still: {}", x); // x is still valid
}

Nested Blocks

fn main() {
let a = 1;
{
let b = 2;
println!("Level 1: a={}, b={}", a, b);
{
let c = 3;
println!("Level 2: a={}, b={}, c={}", a, b, c);
{
let d = 4;
println!("Level 3: a={}, b={}, c={}, d={}", a, b, c, d);
} // d dropped
// println!("d: {}", d); // Error: d not found
} // c dropped
// println!("c: {}", c); // Error: c not found
} // b dropped
// println!("b: {}", b); // Error: b not found
println!("a still: {}", a); // a still valid
}

Function Scope

fn main() {
let main_var = 42;
println!("In main: {}", main_var);
helper_function();
// println!("In helper: {}", helper_var); // Error: not in scope
{
let block_var = 100;
println!("Block var: {}", block_var);
helper_function(); // Can still call functions
}
// println!("Block var: {}", block_var); // Error: out of scope
}
fn helper_function() {
let helper_var = 10;
println!("In helper: {}", helper_var);
// println!("Main var: {}", main_var); // Error: main_var not in scope
}

2. Ownership and Scope

Basic Ownership Rules

fn main() {
// Simple ownership
let s1 = String::from("hello"); // s1 owns the string
println!("s1: {}", s1);
{
let s2 = String::from("world"); // s2 owns this string
println!("s2: {}", s2);
} // s2 goes out of scope, memory is freed
println!("s1 still: {}", s1); // s1 still valid
// Move semantics
let s3 = String::from("rust");
let s4 = s3; // Ownership moves to s4
// println!("s3: {}", s3); // Error: s3 no longer valid
println!("s4: {}", s4); // s4 is valid
// Copy types
let x = 5;
let y = x; // x is copied, not moved
println!("x: {}, y: {}", x, y); // Both valid
}

Drop Behavior

struct Custom {
name: String,
}
impl Drop for Custom {
fn drop(&mut self) {
println!("Dropping Custom with name: {}", self.name);
}
}
fn main() {
println!("Creating custom1");
let custom1 = Custom { name: String::from("first") };
{
println!("Creating custom2");
let custom2 = Custom { name: String::from("second") };
println!("custom2 active");
} // custom2 dropped here
println!("custom1 still active");
let custom3 = Custom { name: String::from("third") };
println!("End of main");
} // custom3 dropped, then custom1 dropped

3. Reference Scope

Borrowing and Lifetimes

fn main() {
let s = String::from("hello");
// References must not outlive their data
let r = &s; // r borrows s
println!("r: {}", r);
// r goes out of scope here, but s continues
// Scope of borrows
let mut s2 = String::from("world");
let r1 = &s2; // Immutable borrow
let r2 = &s2; // Another immutable borrow
println!("r1: {}, r2: {}", r1, r2);
// r1 and r2 go out of scope here
let r3 = &mut s2; // Mutable borrow now allowed
r3.push_str("!");
println!("r3: {}", r3);
// Nested reference scopes
let x = 10;
let result = {
let y = 20;
&x // Returning reference to x (lives longer)
// &y // Error: y doesn't live long enough
};
println!("result: {}", result);
}

Dangling References (Prevented)

// This function would create a dangling reference
// fn dangle() -> &String {
//     let s = String::from("hello");
//     &s // Error: returns reference to local variable
// } // s goes out of scope, reference would be invalid
// Correct version returns the String itself
fn no_dangle() -> String {
let s = String::from("hello");
s // Ownership moves out
}
fn main() {
// The compiler prevents dangling references
let reference_to_nothing = no_dangle();
println!("Got: {}", reference_to_nothing);
// Another example of lifetime issues
let r;
{
let x = 5;
// r = &x; // Error: x doesn't live long enough
}
// println!("r: {}", r); // Would be invalid
}

4. Lifetime Annotations

Function Lifetime Parameters

// Lifetime annotations specify relationship between references
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
// Different lifetimes example
let str1 = String::from("hello");
let str2 = "world";
let result = longest(str1.as_str(), str2);
println!("Longest: {}", result);
}

Lifetime in Structs

struct ImportantExcerpt<'a> {
part: &'a str,
}
impl<'a> ImportantExcerpt<'a> {
fn level(&self) -> i32 {
3
}
fn announce_and_return_part(&self, announcement: &str) -> &str {
println!("Attention: {}", announcement);
self.part
}
}
fn main() {
let novel = String::from("Call me Ishmael. Some years ago...");
let first_sentence = novel.split('.').next().expect("Could not find a '.'");
let excerpt = ImportantExcerpt {
part: first_sentence,
};
println!("Excerpt: {}", excerpt.part);
println!("Level: {}", excerpt.level());
// The struct cannot outlive the data it references
let excerpt2;
{
let text = String::from("temporary");
// excerpt2 = ImportantExcerpt { part: &text }; // Error
} // text dropped
}

Lifetime Elision Rules

// No explicit lifetimes needed due to elision rules
fn first_word(s: &str) -> &str {
let bytes = s.as_bytes();
for (i, &item) in bytes.iter().enumerate() {
if item == b' ' {
return &s[0..i];
}
}
&s[..]
}
// Multiple parameters with elision
fn compare(s1: &str, s2: &str) -> bool {
s1 == s2
}
// Methods follow special rules
impl ImportantExcerpt<'_> {
// Lifetime of self is elided
fn get_part(&self) -> &str {
self.part
}
}
fn main() {
let s = String::from("hello world");
let word = first_word(&s);
println!("First word: {}", word);
println!("Compare: {}", compare("a", "a"));
}

5. Static Lifetime

'static Lifetime

// 'static lifetime lives for the entire program
static GREETING: &str = "Hello, world!";
const CONSTANT: &str = "I'm a constant";
fn returns_static() -> &'static str {
"This string lives forever"
}
fn main() {
// String literals have 'static lifetime
let s: &'static str = "I am a string literal";
println!("{}", s);
println!("{}", GREETING);
println!("{}", returns_static());
// Coercion to shorter lifetimes
fn takes_str(s: &str) {
println!("Got: {}", s);
}
let static_str: &'static str = "static";
takes_str(static_str); // &'static coerces to &str
// Static variables
static mut COUNTER: i32 = 0;
unsafe {
COUNTER += 1;
println!("Counter: {}", COUNTER);
}
}

6. Generic Lifetimes

Multiple Lifetime Parameters

fn complex_function<'a, 'b>(x: &'a str, y: &'b str) -> &'a str {
println!("y: {}", y);
x // Return reference with lifetime 'a
}
struct Pair<'a, 'b> {
first: &'a str,
second: &'b str,
}
impl<'a, 'b> Pair<'a, 'b> {
fn new(first: &'a str, second: &'b str) -> Self {
Pair { first, second }
}
fn get_first(&self) -> &'a str {
self.first
}
fn get_second(&self) -> &'b str {
self.second
}
fn longest(&self) -> &str
where
'a: 'b, // 'a outlives 'b
{
if self.first.len() > self.second.len() {
self.first
} else {
self.second
}
}
}
fn main() {
let string1 = String::from("long");
let result;
{
let string2 = String::from("short");
result = complex_function(&string1, &string2);
println!("Result: {}", result);
}
// println!("Result: {}", result); // Would this be valid?
let first = String::from("first");
let second = String::from("second");
let pair = Pair::new(&first, &second);
println!("First: {}", pair.get_first());
println!("Second: {}", pair.get_second());
}

Lifetime Bounds

use std::fmt::Debug;
// Trait with lifetime bound
trait Print<'a> {
fn print(&self) -> &'a str;
}
struct Wrapper<'a, T: 'a> {
value: &'a T,
}
impl<'a, T> Wrapper<'a, T>
where
T: Debug + 'a,
{
fn print(&self) {
println!("Value: {:?}", self.value);
}
}
// Higher-ranked trait bounds
fn with_callback<F>(f: F)
where
F: for<'a> Fn(&'a str) -> &'a str,
{
let s = "hello";
let result = f(s);
println!("Result: {}", result);
}
fn main() {
let x = 42;
let wrapper = Wrapper { value: &x };
wrapper.print();
with_callback(|s| s);
with_callback(|s| &s[0..2]);
}

7. Scope and Closures

Closure Scope

fn main() {
let x = 5;
// Closure captures variables from scope
let print_x = || {
println!("x = {}", x); // Captures x by reference
};
print_x();
println!("x still: {}", x); // x still accessible
// Move closures
let s = String::from("hello");
let move_closure = move || {
println!("s = {}", s); // s is moved into closure
};
move_closure();
// println!("s: {}", s); // Error: s moved
// Closure with different capture modes
let mut counter = 0;
let mut increment = || {
counter += 1; // Captures counter by mutable reference
println!("Counter: {}", counter);
};
increment();
increment();
// println!("counter: {}", counter); // Can't borrow here
drop(increment); // Release the mutable borrow
println!("counter: {}", counter); // Now accessible
}

Returning Closures

fn create_adder(x: i32) -> impl Fn(i32) -> i32 {
// Closure captures x from scope
move |y| x + y
}
fn create_counter() -> impl FnMut() -> i32 {
let mut count = 0;
move || {
count += 1;
count
}
}
fn main() {
let add_five = create_adder(5);
println!("5 + 3 = {}", add_five(3));
println!("5 + 7 = {}", add_five(7));
let mut counter = create_counter();
println!("Count: {}", counter());
println!("Count: {}", counter());
println!("Count: {}", counter());
// Closure in different scope
let values = vec![1, 2, 3, 4, 5];
let evens: Vec<_> = values
.into_iter()
.filter(|&x| x % 2 == 0)
.collect();
println!("Evens: {:?}", evens);
}

8. Module and Visibility Scope

Module Scope

// Public items are visible outside module
pub mod outer {
pub fn public_function() {
println!("Called outer::public_function");
private_function();
}
fn private_function() {
println!("Called outer::private_function");
}
pub mod inner {
pub fn inner_function() {
println!("Called outer::inner::inner_function");
super::private_function(); // Can call parent's private
}
}
}
// Re-exporting
pub mod utils {
pub fn utility() {
println!("Utility function");
}
}
pub use utils::utility;
fn main() {
outer::public_function();
// outer::private_function(); // Error: private
outer::inner::inner_function();
utility(); // Re-exported
}

Struct Field Visibility

pub struct Person {
name: String,      // Private field
pub age: u32,      // Public field
}
impl Person {
pub fn new(name: String, age: u32) -> Self {
Person { name, age }
}
pub fn name(&self) -> &str {
&self.name // Getter for private field
}
}
mod internal {
pub struct InternalStruct {
pub public_field: i32,
private_field: i32,
}
impl InternalStruct {
pub fn new(value: i32) -> Self {
InternalStruct {
public_field: value,
private_field: value * 2,
}
}
pub fn get_private(&self) -> i32 {
self.private_field
}
}
}
fn main() {
let person = Person::new(String::from("Alice"), 30);
println!("Age: {}", person.age); // Public
// println!("Name: {}", person.name); // Error: private
println!("Name: {}", person.name()); // Use getter
let internal = internal::InternalStruct::new(10);
println!("Public: {}", internal.public_field);
// println!("Private: {}", internal.private_field); // Error
println!("Private via getter: {}", internal.get_private());
}

9. Loop and Control Flow Scope

Loop Scope

fn main() {
// Variables in loop scope
let mut counter = 0;
let result = loop {
counter += 1;
if counter == 5 {
break counter * 2;
}
};
println!("Result: {}", result);
// For loop scope
for i in 0..3 {
let temp = i * 2;
println!("temp: {}", temp);
// temp goes out of scope each iteration
}
// println!("temp: {}", temp); // Error
// While loop scope
let mut x = 5;
while x > 0 {
let squared = x * x;
println!("{} squared = {}", x, squared);
x -= 1;
}
// println!("squared: {}", squared); // Error
// Shadowing in loops
let mut value = 10;
for i in 0..3 {
let value = i; // Shadows outer value
println!("Inner value: {}", value);
}
println!("Outer value: {}", value); // Still 10
}

Match and If-Let Scope

fn main() {
// Match expression scope
let x = Some(5);
let y = match x {
Some(value) => {
let doubled = value * 2;
println!("Doubled: {}", doubled);
doubled // Returned from match arm
}
None => 0,
};
println!("y: {}", y);
// println!("value: {}", value); // Error: value out of scope
// println!("doubled: {}", doubled); // Error
// if let scope
let data = Some(10);
if let Some(num) = data {
let processed = num + 5;
println!("Processed: {}", processed);
}
// println!("processed: {}", processed); // Error
// Multiple patterns
let pair = (2, 3);
match pair {
(x, y) if x == y => {
println!("Equal: {}", x);
}
(x, y) if x + y == 5 => {
let sum = x + y;
println!("Sum is 5: {}", sum);
}
(x, y) => {
let product = x * y;
println!("Product: {}", product);
}
}
}

10. RAII and Scope Guards

Resource Acquisition Is Initialization

use std::fs::File;
use std::io::Write;
struct FileGuard {
file: File,
path: String,
}
impl FileGuard {
fn new(path: &str) -> std::io::Result<Self> {
let file = File::create(path)?;
Ok(FileGuard {
file,
path: path.to_string(),
})
}
fn write(&mut self, content: &str) -> std::io::Result<()> {
self.file.write_all(content.as_bytes())
}
}
impl Drop for FileGuard {
fn drop(&mut self) {
println!("Closing file: {}", self.path);
// File automatically closed when dropped
}
}
struct MutexGuard<'a> {
data: &'a mut i32,
}
impl<'a> MutexGuard<'a> {
fn new(data: &'a mut i32) -> Self {
println!("Lock acquired");
MutexGuard { data }
}
}
impl<'a> Drop for MutexGuard<'a> {
fn drop(&mut self) {
println!("Lock released");
}
}
impl<'a> std::ops::Deref for MutexGuard<'a> {
type Target = i32;
fn deref(&self) -> &i32 {
self.data
}
}
impl<'a> std::ops::DerefMut for MutexGuard<'a> {
fn deref_mut(&mut self) -> &mut i32 {
self.data
}
}
fn main() -> std::io::Result<()> {
// File automatically closed when guard goes out of scope
{
let mut file = FileGuard::new("test.txt")?;
file.write("Hello, world!")?;
} // File closed here
// Mutex-like guard
let mut data = 42;
{
let mut guard = MutexGuard::new(&mut data);
*guard += 10;
println!("Inside guard: {}", *guard);
} // Lock released here
println!("Outside: {}", data);
Ok(())
}

11. Thread Scope

Thread-Local Storage

use std::thread;
use std::cell::RefCell;
thread_local! {
static THREAD_COUNTER: RefCell<u32> = RefCell::new(0);
}
fn main() {
// Each thread has its own copy
THREAD_COUNTER.with(|counter| {
*counter.borrow_mut() = 42;
println!("Main thread counter: {}", *counter.borrow());
});
let handle = thread::spawn(|| {
THREAD_COUNTER.with(|counter| {
*counter.borrow_mut() = 100;
println!("Spawned thread counter: {}", *counter.borrow());
});
});
handle.join().unwrap();
THREAD_COUNTER.with(|counter| {
println!("Main thread still has: {}", *counter.borrow());
});
// Scoped threads
let mut data = vec![1, 2, 3, 4, 5];
thread::scope(|s| {
s.spawn(|| {
data.push(6); // Can modify data in scope
});
s.spawn(|| {
println!("Data: {:?}", data);
});
}); // All threads joined here
println!("Final data: {:?}", data);
}

Cross-Thread Scope

use std::sync::{Arc, Mutex};
use std::thread;
fn main() {
// Arc shares ownership across threads
let counter = Arc::new(Mutex::new(0));
let mut handles = vec![];
for i in 0..5 {
let counter = Arc::clone(&counter);
handles.push(thread::spawn(move || {
let mut num = counter.lock().unwrap();
*num += 1;
println!("Thread {} incremented to {}", i, *num);
})); // MutexGuard dropped here
}
for handle in handles {
handle.join().unwrap();
}
println!("Final counter: {}", *counter.lock().unwrap());
// Channel scope
use std::sync::mpsc;
let (tx, rx) = mpsc::channel();
for i in 0..3 {
let tx = tx.clone();
thread::spawn(move || {
tx.send(i).unwrap();
});
}
drop(tx); // Close sending side
for received in rx {
println!("Got: {}", received);
}
}

12. Advanced Scope Patterns

Scope-Based Resource Management

struct Timer {
name: String,
start: std::time::Instant,
}
impl Timer {
fn new(name: &str) -> Self {
println!("Starting: {}", name);
Timer {
name: name.to_string(),
start: std::time::Instant::now(),
}
}
}
impl Drop for Timer {
fn drop(&mut self) {
let duration = self.start.elapsed();
println!("Finished: {} in {:?}", self.name, duration);
}
}
struct Transaction {
active: bool,
}
impl Transaction {
fn begin() -> Self {
println!("Transaction started");
Transaction { active: true }
}
fn commit(mut self) {
println!("Transaction committed");
self.active = false;
}
}
impl Drop for Transaction {
fn drop(&mut self) {
if self.active {
println!("Transaction rolled back!");
}
}
}
fn main() {
// Measure function execution
let _timer = Timer::new("main operation");
// Simulate some work
std::thread::sleep(std::time::Duration::from_millis(100));
{
let _sub_timer = Timer::new("sub-operation");
std::thread::sleep(std::time::Duration::from_millis(50));
} // sub-timer logged here
// Transaction with automatic rollback
{
let transaction = Transaction::begin();
// Do some work...
if false {
transaction.commit(); // Would commit
}
// If not committed, automatically rolls back
} // Transaction rolled back here
// Explicit commit
let transaction = Transaction::begin();
transaction.commit(); // Committed, no rollback
}

Scope-Guard Pattern

struct ScopeGuard<F: FnMut()> {
cleanup: F,
}
impl<F: FnMut()> ScopeGuard<F> {
fn new(cleanup: F) -> Self {
ScopeGuard { cleanup }
}
}
impl<F: FnMut()> Drop for ScopeGuard<F> {
fn drop(&mut self) {
(self.cleanup)();
}
}
// Macro for convenience
macro_rules! defer {
($body:expr) => {
let _guard = ScopeGuard::new(|| $body);
};
}
fn main() {
// Manual scope guard
let file = std::fs::File::create("test.txt").unwrap();
let _guard = ScopeGuard::new(|| {
println!("Cleaning up: closing file");
drop(file); // Explicitly drop
});
println!("Working with file...");
// Using defer macro
defer! {
println!("This runs at end of scope");
}
{
defer! {
println!("Exiting inner scope");
}
println!("Inside inner scope");
}
println!("About to exit main");
// Multiple guards run in reverse order
defer! {
println!("First guard");
}
defer! {
println!("Second guard");
}
// Practical example: mutex unlock
use std::sync::Mutex;
let mutex = Mutex::new(42);
{
let guard = mutex.lock().unwrap();
defer! {
println!("Mutex will be unlocked");
// guard dropped automatically
}
println!("Value: {}", *guard);
} // guard dropped here
println!("Mutex unlocked");
}

13. Scope and Error Handling

Scope in Error Propagation

use std::fs::File;
use std::io::{self, Read};
fn read_file_contents(path: &str) -> Result<String, io::Error> {
let mut file = File::open(path)?; // ? propagates error
let mut contents = String::new();
file.read_to_string(&mut contents)?;
Ok(contents)
}
fn process_file() -> Result<(), Box<dyn std::error::Error>> {
let content = read_file_contents("test.txt")?;
// Processing scope
{
let lines: Vec<&str> = content.lines().collect();
println!("Found {} lines", lines.len());
for (i, line) in lines.iter().enumerate() {
if line.is_empty() {
continue;
}
println!("Line {}: {}", i + 1, line);
}
} // lines goes out of scope
// Further processing
let word_count = content.split_whitespace().count();
println!("Word count: {}", word_count);
Ok(())
}
fn main() {
match process_file() {
Ok(()) => println!("File processed successfully"),
Err(e) => println!("Error: {}", e),
}
// Try block (nightly Rust)
// let result = try {
//     let x = foo()?;
//     let y = bar()?;
//     x + y
// };
}

Scope and Panic Safety

use std::panic;
struct PanicGuard {
name: String,
}
impl PanicGuard {
fn new(name: &str) -> Self {
println!("Creating guard: {}", name);
PanicGuard {
name: name.to_string(),
}
}
}
impl Drop for PanicGuard {
fn drop(&mut self) {
println!("Dropping guard: {}", self.name);
if panic::catch_unwind(|| {
panic!("Simulated panic in drop");
}).is_err() {
println!("Caught panic in drop of {}", self.name);
}
}
}
fn main() {
// Guard runs even during panic
let result = panic::catch_unwind(|| {
let _guard = PanicGuard::new("outer");
{
let _inner = PanicGuard::new("inner");
println!("About to panic!");
panic!("Something went wrong");
} // inner guard dropped here
});
match result {
Ok(_) => println!("Success"),
Err(_) => println!("Caught panic"),
}
// Multiple guards in panic
let result = panic::catch_unwind(|| {
let _g1 = PanicGuard::new("g1");
let _g2 = PanicGuard::new("g2");
let _g3 = PanicGuard::new("g3");
panic!("Panic with multiple guards");
});
println!("Panic handled");
}

14. Best Practices and Common Patterns

Scope Guidelines

// 1. Minimize variable scope
fn good_practice() {
// Bad: variable used far from declaration
let mut result = 0;
// ... many lines of code
result = compute_something();
// Good: declare near usage
let data = load_data();
let processed = process_data(&data);
let result = finalize(processed);
result
}
// 2. Use blocks to limit scope
fn process_with_temp() -> i32 {
let final_result = {
// Temporary variables only needed here
let temp1 = setup();
let temp2 = prepare(temp1);
let temp3 = transform(temp2);
finalize(temp3)
}; // temp1, temp2, temp3 dropped
final_result
}
// 3. RAII for resource management
struct DatabaseConnection {
connected: bool,
}
impl DatabaseConnection {
fn connect() -> Self {
println!("Connecting to database");
DatabaseConnection { connected: true }
}
fn query(&self, q: &str) -> String {
format!("Result of: {}", q)
}
}
impl Drop for DatabaseConnection {
fn drop(&mut self) {
if self.connected {
println!("Disconnecting from database");
self.connected = false;
}
}
}
fn main() {
// Connection automatically closed when out of scope
let result = {
let conn = DatabaseConnection::connect();
let data = conn.query("SELECT * FROM users");
println!("Got data: {}", data);
data
}; // conn disconnected here
println!("Final result: {}", result);
// 4. Use scope to control borrows
let mut data = vec![1, 2, 3, 4, 5];
{
let first = &data[0];
let last = &data[data.len() - 1];
println!("First: {}, Last: {}", first, last);
// Immutable borrows end here
}
data.push(6); // Now we can mutate
// 5. Shadowing for type conversions
let input = "42";
let input: i32 = input.parse().unwrap();
let input = input * 2;
println!("Result: {}", input);
}
fn setup() -> i32 { 1 }
fn prepare(x: i32) -> i32 { x + 1 }
fn transform(x: i32) -> i32 { x * 2 }
fn finalize(x: i32) -> i32 { x + 10 }

Conclusion

Rust's scope system is fundamental to its memory safety guarantees:

Key Takeaways

1. Block Scope: Variables are valid only within their defining block
2. Ownership: Values are dropped when their owner goes out of scope
3. Lifetimes: References cannot outlive the data they point to
4. Shadowing: Variable names can be reused in nested scopes
5. Visibility: Module and struct fields have public/private control
6. RAII: Resources are automatically cleaned up when out of scope
7. Thread Safety: Scope ensures thread-local and shared data safety

Scope Rules Summary

• Local variables: Scope ends at the closing brace
• Function parameters: Scope ends when function returns
• Static items: Live for entire program
• References: Must not outlive their referent
• Closures: Can capture variables from their defining scope
• Generics: Lifetime parameters specify relationship between scopes

Best Practices

1. Keep scope minimal - Declare variables close to usage
2. Use blocks to limit temporary variable scope
3. Leverage RAII for automatic resource cleanup
4. Understand lifetimes to prevent dangling references
5. Use shadowing judiciously for type conversions
6. Respect visibility boundaries in modules
7. Be mindful of thread scope when sharing data

Rust's scope system, combined with ownership and borrowing, provides compile-time guarantees that would be runtime checks in other languages, leading to safer and more predictable code.