Names and Scopes

// Valid identifiers
let variable_name = 42;
let _private = "hidden";
let CamelCase = true;
let snake_case_function = || {};

// Unicode identifiers are allowed
let 变量 = "Chinese variable name";
let π = 3.14159;

// Raw identifiers (escape keywords)
let r#match = "using match as identifier";
let r#type = "using type as identifier";

// Lifetime identifiers
fn function_with_lifetime<'a>(param: &'a str) -> &'a str {
    param
}

// Type parameter identifiers
struct GenericStruct {
    field1: T,
    field2: U,
}

fn demonstrate_shadowing() {
    let x = 5;
    println!("x = {}", x);  // x = 5
    
    let x = x + 1;  // Shadows previous x
    println!("x = {}", x);  // x = 6
    
    {
        let x = x * 2;  // Shadows in inner scope
        println!("x = {}", x);  // x = 12
    }
    
    println!("x = {}", x);  // x = 6 (outer shadow)
    
    // Can change type when shadowing
    let x = "Hello";  // Now x is a string
    println!("x = {}", x);  // x = Hello
}

// Different namespaces can have same names
struct Option;           // Type namespace
const Option: i32 = 42; // Value namespace
macro_rules! Option {    // Macro namespace
    () => { "macro" };
}

fn example<'Option>() {  // Lifetime namespace
    let value = Option;           // Refers to constant
    let instance: Option = Option; // Type and constant
    let result = Option!();       // Macro
    
    // Label namespace
    'Option: loop {
        break 'Option;
    }
}

// Module definitions and visibility
mod outer_module {
    // Private by default
    fn private_function() {
        println!("Private function");
    }
    
    // Explicitly public
    pub fn public_function() {
        println!("Public function");
        private_function();  // Can access private items in same module
    }
    
    pub mod inner_module {
        pub fn inner_public() {
            // Can access parent's private items
            super::private_function();
        }
        
        // Visible only to parent module
        pub(super) fn visible_to_parent() {
            println!("Visible to parent");
        }
        
        // Visible within entire crate
        pub(crate) fn crate_visible() {
            println!("Visible to entire crate");
        }
        
        // Visible only in this module and descendants
        pub(in crate::outer_module) fn restricted_visibility() {
            println!("Restricted visibility");
        }
    }
}

// Usage
fn main() {
    outer_module::public_function();
    outer_module::inner_module::inner_public();
    
    // These would be compilation errors:
    // outer_module::private_function();  // Private
    // outer_module::inner_module::visible_to_parent();  // Not visible here
}

use std::collections::HashMap;

// Module-level items
const GLOBAL_CONSTANT: i32 = 100;

fn name_resolution_example() {
    let local_var = 42;
    
    // Refers to local variable
    println!("{}", local_var);
    
    // Refers to module-level constant
    println!("{}", GLOBAL_CONSTANT);
    
    // HashMap from std::collections via use statement
    let mut map = HashMap::new();
    map.insert("key", "value");
    
    // Fully qualified syntax
    let vec = std::vec::Vec::::new();
    
    // Absolute path from crate root
    let result = crate::name_resolution_example;
}

// Disambiguation with fully qualified syntax
trait A {
    fn method(&self);
}

trait B {
    fn method(&self);
}

struct S;

impl A for S {
    fn method(&self) {
        println!("Method from trait A");
    }
}

impl B for S {
    fn method(&self) {
        println!("Method from trait B");
    }
}

fn disambiguation() {
    let s = S;
    
    // Ambiguous - compilation error
    // s.method();
    
    // Disambiguate using fully qualified syntax
    A::method(&s);
    B::method(&s);
    
    // Alternative syntax
    ::method(&s);
    ::method(&s);
}