Variables & Scope

// All variables are immutable by default
let name = "John Topaz"
let age = 25
let isActive = true

// Cannot be changed once defined
// name = "Different Name"  // Compile error!

// Use let mut when you need to change values
let mut score = 100
let mut message = "Initial message"

// Value can be changed
score = 95
message = "Updated message"

print("Current score: {score}")  // "Current score: 95"

// Constants determined at compile time
const MAX_SIZE: int = 1000
const APP_NAME: string = "Topaz Calculator"
const PI: float = 3.141592653589793

// Top-level constants available below in this file
const defaultConfig = {
    language: "English",
    theme: "dark",
    autoSave: true
}

// Type inference (recommended)
let inferredNumber = 42           // int
let inferredString = "Hello"      // string
let inferredArray = [1, 2, 3]     // Array<int>

// Explicit types (when needed)
let explicitNumber: int = 42
let explicitString: string = "Hello"
let explicitArray: Array<int> = [1, 2, 3]

// Explicit types help with complex cases
let userData: { name: string, age: int } = {
    name: "Developer Kim",
    age: 30
}

// File top level - global scope
let globalVariable = "Accessible everywhere"
const globalConstant = 100

function useAnywhere() {
    print(globalVariable)      // Accessible
    print("{globalConstant}")  // Accessible
}

function calculator(a: int, b: int) -> int {
    // Function parameters also belong to function scope
    let result = a + b        // Function scope
    let mut tempValue = a * 2     // Function scope
    
    print("Result: {result}")
    return result
}

// print(result)  // Error! Cannot access outside function

function scopeExample() {
    let outerVariable = "outside"
    
    if true {
        let innerVariable = "inside"      // Block scope
        let mut blockMutable = 10            // Block scope
        
        print(outerVariable)             // Accessible (outer scope)
        print(innerVariable)             // Accessible (same scope)
    }
    
    print(outerVariable)                 // Accessible
    // print(innerVariable)              // Error! Cannot access outside block
}

// for loop variables have loop scope
for i in 0..5 {
    let loopVariable = i * 2
    print("i: {i}, value: {loopVariable}")
}

// print(i)  // Error! Cannot access outside loop

let name = "John Topaz"

function shadowingExample() {
    let name = "Developer Park"        // Shadows global name
    print("In function: {name}")       // "In function: Developer Park"
    
    {
        let name = "Designer Lee"       // Shadows function name
        print("In block: {name}")       // "In block: Designer Lee"
    }
    
    print("After block: {name}")       // "After block: Developer Park"
}

print("Global: {name}")               // "Global: John Topaz"
shadowingExample()

function createCounter(initialValue: int) -> () -> int {
    let mut count = initialValue           // Captured by closure
    
    return () => {
        count += 1                     // Access outer scope variable
        count
    }
}

let counter1 = createCounter(0)
let counter2 = createCounter(100)

print("{counter1()}")  // 1
print("{counter1()}")  // 2
print("{counter2()}")  // 101
print("{counter1()}")  // 3

let user = {
    name: "John Topaz",
    age: 28,
    job: "Developer"
}

// Destructuring creates new variables
let { name, age } = user
print("Name: {name}, Age: {age}")

// Variable binding in match
match user.age {
    case age if age < 20 => print("Likely a student")
    case age if age < 30 => print("Young professional")
    case age => print("Experienced: {age} years old")
}

// Array pattern matching
let scores = [95, 87, 92, 88]
match scores {
    case [first, second, ..rest] => {
        print("First: {first}")
        print("Second: {second}")
        print("Rest: {rest}")
    }
    case _ => print("Need at least two scores")
}

// Block expression for scope isolation
let result = {
    let tempCalculation = 10 * 20
    let adjustment = 50
    tempCalculation + adjustment
}

print("{result}")  // 250
// tempCalculation, adjustment are not accessible outside the block

// Good: Use let by default
let config = {
    theme: "dark",
    language: "English"
}

// Use let mut only when necessary
let mut progressStatus = "started"
progressStatus = "in-progress"
progressStatus = "completed"

// Bad example
let a = userList.length
let b = a * 2

// Good example  
let totalUsers = userList.length
let doubledCapacity = totalUsers * 2

function processData(rawData: Array<int>) -> Array<int> {
    let mut result: Array<int> = []
    
    for item in rawData {
        // Variables needed only in loop should be declared in loop
        let transformedValue = item * 2 + 1
        let validatedValue = if transformedValue > 0 { transformedValue } else { 0 }
        
        result.push(validatedValue)
    }
    
    return result
}

// Trace bindings with interpolated prints
let globalLabel = "build-42"

function printScopeInfo() {
    let localVariable = "local"
    
    print("Variables in current function:")
    print("- localVariable: {localVariable}")
    print("- globalLabel: {globalLabel}")   // outer bindings stay reachable
}