Learn U

f add(first: I, second: I) -> I
	r => first + second

f greet(name: S) -> S
	r => "Hello, {{name}}!"

f log_it(msg: S)
	System.stderr(msg)

f area(width: N, height: N) -> N
	r => width * height

f is_even(num: I) -> L
	r => num % 2 == 0

f even_squares(nums: [I]) -> [I]
	r => nums.filter(num => num % 2 == 0).map(num => num * nn)

// Accumulator needs +M — locals are immutable by default
f total(prices: [N]) -> N
	sum: N +M = 0.0
	prices.on(price => (
		sum = sum + price
		none
	))
	r => sum

d Point
	x: N             // +M by default — instance field
	y: N
	id: I -M          // frozen after construction

	f move(dx: N, dy: N)
		t.x = t.x + dx   // t = self
		t.y = t.y + dy

	f distance() -> N
		r => Math.sqrt(t.x * t.x + t.y * t.y)

d Session
	token: S
	user: S

f open(tok: S, user: S) -> Session +R
	r => Session({ token: tok, user: user })

// -M parameter: can't modify the Point through it
f describe(pt: Point) -> S
	// pt.x = 5.0  ← compile error: -M propagates
	r => "(" + pt.x.__string__() + ", " + pt.y.__string__() + ")"

// +M parameter: declares intent to modify
f zero_out(pt: Point +M)
	pt.x = 0.0
	pt.y = 0.0

// Element +M hole-punch: container frozen, elements writable
f normalize(pts: [Point +M])
	// pts.push(...)  ← compile error: container is -M
	[1..pts.len].on(idx => (
		pts[idx].x = pts[idx].x / 100.0  // ok — element is +M
		pts[idx].y = pts[idx].y / 100.0
		none
	))

d DivideByZero : Error

f safe_div(num: N, den: N) -> N ! DivideByZero
	den == 0.0 ? x DivideByZero()
	r => num / den

f try_it() -> S
	x.on((err: DivideByZero) => (
		r => "cannot divide by zero"
	))
	result = safe_div(10.0, 0.0)
	r => result.__string__()

d Config
	MAX_RETRIES: I +G = 3        // global constant — no annotation needed
	APP_NAME: S +G = "MyApp"     // global constant

d Counter
	val: I +G +M = 0             // global mutable — MVCC-managed

	f+G increment()              // +G = static method (no t)
		Counter << { val: Counter.val + 1 }

	// Counter.val = 5  ← compile error: use << for +G +M

d Metrics
	requests: I +G +M = 0
	errors: I +G +M = 0
	last_path: S +G +M = ""

f on_request(path: S)
	// Patch two of three fields atomically
	Metrics << { requests: Metrics.requests + 1, last_path: path }

f on_error(path: S)
	Metrics << { errors: Metrics.errors + 1, last_path: path }

// Instance MVCC — t can use << too
d Account +R
	balance: Q
	holder: S
	status: S

	f deposit(amount: Q)
		// Patch balance and status, leave holder unchanged
		t << { balance: t.balance + amount, status: "active" }

d AccA
	bal: Q +G +M = 0.0
	name: S +G +M = ""
	last_tx: I +G +M = 0
d AccB
	bal: Q +G +M = 0.0
	name: S +G +M = ""
	last_tx: I +G +M = 0

f transfer(amount: Q, tx_id: I) ! InsufficientFunds
	rate = get_rate()             // +D — before the block
	<< (
		fee = compute_fee(AccA.bal, rate)    // -E -D only ✓
		AccA.bal < amount + fee ? x Rollback("insufficient")
		AccA << { bal: AccA.bal - amount - fee, last_tx: tx_id }
		AccB << { bal: AccB.bal + amount, last_tx: tx_id }
		// name is NOT patched — stays unchanged
	)                             // all-or-nothing
	log("transferred")            // +E — after the block

a f fetch(url: S) -> S
	resp = a HTTP.get(url)
	r => resp.text()

// Fan-out: fetch all URLs concurrently
f fetch_all(urls: [S]) -> [S]
	tasks = urls.map(url => a fetch(url))
	r => tasks

d ClickEvent
	x: I -M
	y: I -M

d Button +R
	label: S
	f click(x: I, y: I)
		e(t).emit(ClickEvent({ x: x, y: y }))

d Page +R(RAII)
	f setup(btn: Button +R)
		// owner defaults to t — auto-removed on Page cleanup
		e(btn).on(click => Log.info("clicked"))

		// need the source? second param is EventContext
		e(btn).on((click, ctx) => (
			Log.info(ctx.target.label + " at " + click.x.__string__())
		))

f list_users(req: Request) -> Response
	users = Database.Query({ store: "users" })
		.select(["name", "email"])
		.orderBy("name", "ASC")
		.limit(50)
		.fetchAll()
	r => Response.json(users)

f main()
	serve(8080, {
		"GET /users": list_users,
		"POST /users": create_user
	})

d User : Database.Row
	name: S
	email: S
	score: I

f top_users(min_score: I) -> [User]
	r => Database.Query({ store: "users" })
		.where("score", ">=", min_score)
		.orderBy("score", "DESC")
		.limit(10)
		.fetchAll()

// Transactions work with database rows too
f award(from_id: I, to_id: I, points: I) ! NotEnough
	<< (
		sender = Database.Query({ store: "users" }).where("id", "=", from_id).fetchRow()
		recipient = Database.Query({ store: "users" }).where("id", "=", to_id).fetchRow()
		sender.score < points ? x Rollback("not enough")
		sender << { score: sender.score - points }
		recipient << { score: recipient.score + points }
	)

// HTML template — injection-safe
f page(title: S, body: S) -> S
	r => HTML`<html><head><title>{{title}}</title></head>
		<body>{{body}}</body></html>`

// SQL template — compiles to prepared statement
f find_user(email: S) -> Tree
	r => SQL`SELECT * FROM users WHERE email = {{email}}`

// Pure, deterministic — safe for transactions, memoization, vectorization
f compute_fee(balance: Q, rate: Q) -> Q
	r => balance * rate * 0.01

// Effectful — writes to the outside world
f+E save_log(msg: S)
	File.append("/var/log/app.log", msg)

// Nondeterministic — reads from unpredictable source
f+D roll_dice() -> I
	r => Random.int(1, 6)

// Both — effectful AND nondeterministic
f+E+D record_timestamp()
	ts = Time.now()                  // +D: reads clock
	File.append("log.txt", ts.__string__())  // +E: writes file

// This is why transactions work:
<< (
	fee = compute_fee(bal, rate)    // -E -D ✓ — allowed
	// save_log("hi")              // +E — compile error!
	// dice = roll_dice()          // +D — compile error!
	Account << { balance: bal - fee }
)

// Fibonacci generator — infinite stream
f fib() -> I +W
	prev = 1
	curr = 1
	[1..w].on(idx => (
		e curr                    // yield current value
		next = prev + curr
		prev = curr
		curr = next
		none
	))

// Consume: take first 10 Fibonacci numbers
f first_ten() -> [I]
	r => fib().take(10)

// Pipelines work on infinite streams
f even_fibs() -> [I]
	r => fib().filter(num => num % 2 == 0).take(5)

// Computed at compile time — no runtime cost
z f factorial(num: I) -> I
	num <= 1 ? r => 1
	r => num * factorial(num - 1)

// The compiler evaluates this and emits: result = 120
f main() -> I
	result = factorial(5)
	r => result

// z f __load__() runs at module load time
z f __load__()
	Config << { root: load_config_tree() }
	r => none

d State +R
	data: [I]

f snapshot(state: State +R) -> State +R
	r => c state             // deep copy — independent of original

// c+R promotes a stack value to the heap
f make_heap(val: I) -> [I] +R
	local_list = [val, val * 2, val * 3]
	r => c+R local_list      // copy to heap, return +R

f scale_all(arr: [I +V] +R) -> [I +V] +R
	r => arr.map(val => val * 3)

f dot_product(values: [N], weights: [N]) -> N
	sum: N +M = 0.0
	[1..values.len].on(idx => (
		sum = sum + values[idx] * weights[idx]
		none
	))
	r => sum
	// -M default on sum forces local accumulator
	// → GCC/Clang auto-vectorizes into SIMD

f brighten(pixels: [I] +R(GPU)) -> [I] +R(GPU)
	r => pixels.map(px => px * 3 + 1)