The game-first
scripting language

let x: int   = 42
let name     = "Ada"   // inferred
const PI     = 3.14159

// Destructuring
let [a, b, c] = [1, 2, 3]

// Null coalescing + optional chain
let name = user?.profile?.name ?? "Guest"

// Pipe operator
5 |> double |> add_one  // = 11

fn greet(name: string = "World") -> string {
    return f"Hello {name}!"
}

// Named args, variadics
fn sum(*args) { return args.reduce(fn(a,b){return a+b}) }

// Closures capture by reference
fn counter() {
    let n = 0
    return fn() { n += 1; return n }
}

struct Animal {
    name: string
    priv energy: float = 100.0
    fn speak() { print(self.name) }
}

struct Dog extends Animal {
    fn speak() {
        super.speak()
        print("Woof!")
    }
    fn +(other) { // operator overload
        return Dog{ name: self.name ++ "&" ++ other.name }
    }
}

// Result type — no exceptions by default
fn divide(a: float, b: float) -> Result {
    if b == 0.0 { return Err("div by zero") }
    return Ok(a / b)
}

// try-catch as expression
let safe = try { risky_fn() } catch e { 0 }

// Typed catch, finally
try { load() }
catch e: string { log(e) }
finally          { cleanup() }

enum Shape { Circle(r: float)  Rect(w: float, h: float) }

let area = match shape {
    case Shape.Circle(r) { 3.14159 * r * r }
    case Shape.Rect(w, h) { w * h }
    case _ { 0.0 }
}

// Match guards
match score {
    case n if n >= 90 { print("A") }
    case n if n >= 70 { print("B") }
    case _ { print("C") }
}

// Generator function
fn* fibonacci() {
    let a=0; let b=1
    while true { yield a; [a,b] = [b, a+b] }
}

// Array + dict comprehensions
let evens = [x for x in 1..=20 if x%2==0]
let inv  = {v: k for k,v in entries(myDict)}

// Rich array methods
scores.filter(fn(x){return x>60})
      .sorted()
      .take(10)