Bindings: let, let mut e var

let cria um binding imutável; o tipo é inferido da expressão inicial.

// Feature: Immutable binding with `let`

// Syntax: `let name = expression`

// When to use: the default case — every value that does NOT need to

// be reassigned. Immutability by default avoids aliasing bugs.


// `let` creates an immutable binding; the type is inferred.

let name = "Alice"
let age = 30
let pi = 3.14159
let active = true

print(name)  // Alice

print(age)  // 30

print(pi)  // 3.14159

print(active)  // true


// Reassigning a `let` is a compile error (uncomment to test):

// name = "Bob"  // error: cannot assign to immutable binding


// Immutable bindings accept any expression as their initial value.

let total = 10 + 20 * 2
let greeting = "Hello, " + name + "!"
print(total)  // 50

print(greeting)  // Hello, Alice!

let mut permite reatribuição e operações de atribuição composta (+=, *=, -=).

// Feature: Mutable binding with `let mut`

// Syntax: `let mut name = value` — then `name = new_value`

// When to use: counters, accumulators, any state that changes

// inside loops or branches. The `mut` keyword is required — Zolo

// treats mutability as opt-in to keep intent visible.


// Mutable: needs `mut` in the declaration.

let mut counter = 0
counter = counter + 1
counter = counter + 1
counter = counter + 1
print(counter)  // 3


// Classic accumulator in a loop.

let mut sum = 0
for i in 1..=10 {
  sum = sum + i
}
print(sum)  // 55


// Reassignment respects the type inferred at declaration.

let mut score: int = 100
score = 90
score = 80
print(score)  // 80


// Compound assignment — equivalent to `x = x + 5`.

let mut x = 10
x += 5
x *= 2
x -= 1
print(x)  // 29

var e let mut são intercambiáveis; somente var aceita modificadores de armazenamento.

// Feature: `var` — alias for `let mut`

// Syntax: `var name = value` — then `name = new_value`

// When to use: anywhere `let mut` is valid. Same semantics, fewer

// keystrokes, and the gateway to storage classes (`var<...>`).

// `let mut` continues to work; both are accepted indefinitely.


// Mutable binding via the new shorter form.

var counter = 0
counter = counter + 1
counter = counter + 1
counter = counter + 1
print(counter)  // 3


// Equivalent in every way to `let mut counter = 0`.

let mut also_counter = 0
also_counter = also_counter + 1
print(also_counter)  // 1


// Compound assignment works the same.

var score = 100
score += 10
score -= 5
print(score)  // 105


// Type annotations also work.

var ratio: float = 0.5
ratio = ratio * 2
print(ratio)  // 1.0


// Why prefer `var`? Storage classes use the `var<...>` syntax —

// see 12-var-lazy.zolo, 13-var-persistent.zolo, etc. `let mut` does

// not accept storage classes (would be ambiguous to parse).