Variables & Bindings¶

# Basic immutable binding
let x = 42
let message = "Hello, World"
let items = [1; 2; 3; 4; 5]

# Attempting to reassign is an error
let x = 10
x = 20                        # ERROR: Cannot reassign immutable binding 'x'

# But you can shadow with a new binding
let x = 10
let x = x + 1                 # OK: Creates new binding, x is now 11

# Shadowing is useful for transformations
let input = "  hello  "
let input = trim input        # Shadow with trimmed version
let input = toUpper input     # Shadow with uppercase version

# Mutable binding
let mut counter = 0
let mut name = "initial"

# Reassign with <- operator
counter <- counter + 1
counter <- counter + 1
println $"Counter: {counter}"    # Counter: 2

name <- "updated"

# Mutable variables in loops
let mut sum = 0
for n in [1; 2; 3; 4; 5] do
    sum <- sum + n
end
println $"Sum: {sum}"            # Sum: 15

# Mutable is required for accumulation patterns
let mut result = []
for line in $(cat file.txt) | lines do
    if startsWith line "#" then
        result <- result @ [line]
end

let mut x = 0
if true then x <- 42
print x

# Export a number — binds X = 42 and exports X="42"
let export X = 42

# Export a computed value
let export PATH_COUNT = length (split PATH ":")

# Export with mutable binding — mutations automatically re-export
let export mut LEVEL = 1
LEVEL <- LEVEL + 1            # Re-exports LEVEL="2" to the environment

# String and boolean exports
let export GREETING = "hello"
let export VERBOSE = true     # exports as "true"

# Shell alias
let cdp () = & cd ~/projects
cdp                                   # calls cdp(), changes directory

# Re-evaluation with mutable state
let mut counter = 0
let next () =
    counter <- counter + 1
    println counter
next                                  # 1
next                                  # 2

# Explicit invocation also works
print (next ())                       # 3

# Interactive TUI commands
let passthrough mc () = & mc
let passthrough htop () = & htop
mc                                    # launches mc with full terminal I/O

# Shell aliases with arguments
let passthrough ll ...args = & exa -l ...args
ll -a /tmp                            # output goes to terminal, not captured

# Without passthrough, output would be captured and discarded
let broken () = & mc                  # captures stdout — mc won't display properly

# Read-only computed property (full form)
let Pi with get () = 3.14159

# Read-write property backed by a mutable variable
let mutable _counter = 0
let Counter with
    get () = _counter
    and set (v) = _counter <- v

print Counter                         # 0
Counter <- 42
print Counter                         # 42

# Write-only property
let Logger with set (msg) =
    println $"[LOG] {msg}"

let mutable _x = 0
let mutable _log = 0
let X with
    get () =
        let v = _x
        v
    and set (v) =
        _log <- _log + 1
        _x <- v

let X
    with get () = _x
    and set (v) = _x <- v

# Write a builtin property
shell_prompt_preset <- "endo-signature"
agent_provider <- "claude"

# Read a builtin property (returns its current value)
print shell_prompt_preset
print agent_provider

# Tuple destructuring
let (x, y) = (10, 20)
let (first, second, third) = ("a", "b", "c")
let (a, _) = (1, 2)           # Ignore second element with _
let (_, _, z) = (1, 2, 3)     # Only care about third

# Record destructuring
let { name; age } = person
let { name = n; age = a } = person    # Rename bindings
let { name; _ } = person              # Ignore other fields with _

# List destructuring
let [a; b; c] = [1; 2; 3]             # Exact match
let [head; rest...] = [1; 2; 3; 4]    # head=1, rest=[2;3;4]
let [first; second; _...] = items     # Ignore tail

# Nested destructuring
let { person = { name; age }; salary } = employee

# In function parameters
let greet { name; _ } = $"Hello, {name}"
let addPair (a, b) = a + b
let sumFirst [x; y; _...] = x + y

# Statement form
ignore (File.delete path)

# Pipeline form
File.writeAll path "hello" |> ignore

# Block scope with braces
let outer = 10
let result = {
    let inner = 20            # Only visible in this block
    inner + outer
}
# 'inner' is not visible here
println $"Result: {result}"      # Result: 30

# Block scope with indentation (in functions)
let process x =
    let temp = x * 2          # Local to function
    let helper y = y + 1      # Nested function
    helper temp

# Export for child processes
export PATH
export MY_VAR = "value"
let MY_OTHER = "local"
export MY_OTHER               # Export existing variable

# Global modifier (escape local scope)
let processConfig =
    let global CONFIG_CACHE = loadConfig    # Visible outside function
    CONFIG_CACHE

let x = lazy (1 + 2)
println (force x)