application Hello {
	def new(args string[]) int {
		println("Hello, 🌍")
		return 0
	}
}

module greet {
	interface IStringer {
		def str() string
	}

	type Thing {
		def str() string {
			return "Thing"
		}
	}
}

application Interpolation {
	use greet

	def new(args string[]) int {
		let n = 3
		let t = greet.Thing{}
		let si greet.IStringer = t

		println("n={n}")              // n=3
		println("t={t}")              // t=Thing
		println("sum={n + n * 2}")     // sum=9
		return 0
	}
}

application Collections {
	def new(args string[]) int {
		let a = int[1, 2, 3, 4]
		let b = int[3, 4, 5, 6]

		println(a & b)        // [3, 4]     intersection
		println(a | b)        // [1..6]     union
		println(a - b)        // [1, 2]     difference
		println(a[-2:])       // [3, 4]     last two

		a[:] *= 10            // scale every element in place
		println(a)            // [10, 20, 30, 40]

		let stock = map<string, int>{
			"widget": 12,
			"gasket": 3,
		}

		stock["bolt"] = 40
		for let (name, count) in stock {
			println("{name}: {count}")
		}
		return 0
	}
}

application Regex {
	def new(args string[]) int {
		let r = /[0-9]+/

		r.test("a1b")                // true
		r.matchAll("a1b22c")          // ["1", "22"]
		r.split("a1b22c")             // ["a", "b", "c"]
		r.replace("a1b22c", "X", -1)  // "aXbXc"

		// the g flag replaces every match without a count
		let rg = /[0-9]+/g
		rg.replace("a1b22c", "X")      // "aXbXc"

		// capture groups, reordered in the replacement
		let cap = /(a)([0-9]+)/
		cap.replace("a12 b a3", "$2-$1", -1)  // "12-a b 3-a"

		// RE2 syntax: Perl classes, named groups, inline flags
		let mail = /(?P<user>\w+)@(\w+)\.com/
		mail.replace("ana@example.com", "$\{user\} at $2")  // "ana at example"
		/(?i)hello/.test("Say HELLO")                      // true

		// strings accept a regex directly
		"hello123".contains(/\d+/)       // true
		"hello123".endsWith(/\d+/)       // true
		return 0
	}
}

application BigNumbers {
	def new(args string[]) int {
		let x bigint = bigint(0x1234567890abcdef)
		let y bigint = bigint(7)

		// exponentiation on a value far past 64 bits
		let z bigint = (x**3) - (3*x) + y

		if (x < z) && (z != x) {
			println(z)
		}
		return 0
	}
}

module shapes {
	struct User {
		id    int
		email string
	}

	def classify(x int) string {
		match x {
			case 0:
				return "zero"
			case (n); n > 0:
				return "positive: {n}"
			default:
				return "negative"
		}
	}

	def sum(t (int, int)) int {
		match t {
			case (a, b):
				return a + b
			default:
				return 0
		}
	}

	def userId(u User) int {
		match u {
			case {id int, email string}; id > 0:
				return id
			default:
				return 0
		}
	}
}

module inventory {
	struct Item {
		name  string
		stock int
	}

	def restock(item Item, qty int) !Item {
		if qty <= 0 {
			fail "quantity must be positive"
		}
		return Item{name: item.name, stock: item.stock + qty}
	}
}

application Warehouse {
	use inventory

	def new(args string[]) int {
		let item = inventory.Item{name: "widget", stock: 12}

		// recover with a fallback value
		let a = inventory.restock(item, -1) onerror recover item

		// inspect the error before deciding
		let b = inventory.restock(item, 8) onerror (err error) {
			println("restock failed: {err.message}")
			recover item
		}

		println(b.stock)
		return 0
	}
}

module accounts {
	def withdraw(balance int, amount int) !int {
		expects {
			assert amount > 0 onerror fail "amount must be positive"
			assert amount <= balance onerror fail "insufficient funds"
		}

		let remaining = balance - amount
		return remaining

		provides {
			assert remaining >= 0
			assert remaining < balance
		}
	}
}

application Ledger {
	let state int = 0

	def apply(x int) {
		begin {
			state = state + x
		}

		rollback {
			state = state - x
		}

		state = state + 1
	}

	def boom() !int {
		fail "boom"
	}

	def run() !none {
		transaction {
			apply(5)
			let v = try boom()   // fails - every rollback runs
			println(v)
		} onerror (err error) {
			println("rolled back: {err.message}")
			recover none
		}
		return none
	}

	def new(args string[]) int {
		run() onerror return 1
		return 0
	}
}

module demo {
	struct Pair<A, B> {
		first  A
		second B
	}

	type Box<T> {
		value T

		def new(v T) { self.value = v }
		def get() T { return self.value }
	}

	type Admin {}
	type Account {}

	type User<T> {
		name string

		where T is Admin | Account {
			permissions string[]

			def tag() string { return "privileged" }
		}
	}

	def run() int {
		let p Pair<int, string> = Pair<int, string>{first: 1, second: "hi"}

		let b = new Box<int>(10)
		let c = new Box<string>("x")

		let u User<Admin> = new(name="bob")
		return b.get() + c.get().len() + u.permissions.len()
	}
}

module bits {
	type Flags {
		value int

		infix def | (other Flags) Flags {
			return Flags{value: value | other.value}
		}

		infix def & (other Flags) Flags {
			return Flags{value: value & other.value}
		}

		infix def <<< (count int) Flags {
			return Flags{value: value <<< count}
		}
	}
}

application Bits {
	use bits

	def new(args string[]) int {
		let read  = bits.Flags{value: 1}
		let write = bits.Flags{value: 2}

		let rw = read | write     // calls infix def |
		let hi = rw <<< 4          // calls infix def <<<

		// the standard library does this too - strings repeat with *
		println("ha" * 3)          // hahaha
		return 0
	}
}

application Lambdas {
	def new(args string[]) int {
		let a = int[1, 2, 3]

		let doubled = a.mapElem(v => v * 2)
		let labels  = a.mapElem(v => sprint(v))

		// an anonymous function that names itself can recurse
		let f = def fib(n int) int {
			return n when n < 2
			return fib(n-1) + fib(n-2)
		}

		println(doubled.len())
		println(f(10))
		return 0
	}
}

application Parallel {
	def new(args string[]) int {
		let values = [10, 20, 30, 40]

		forall let (idx, v) in values {
			println("worker got {v} at {idx}")
		} finish {
			println("all workers done")
		}

		return 0
	}
}

module work {
	async def slow() int {
		let acc = 0
		for let i in 0..2000000 {
			acc = i
		}
		return 7
	}

	async def fast() string {
		return "ok"
	}
}

application Concurrency {
	use work

	def new(args string[]) int {
		let a = work.slow()
		let b = work.fast()

		// resume as soon as either finishes
		let first = await (a || b)
		println("string won") when first is string

		// futures can be cancelled or given a deadline
		let stuck = work.slow().timeout(50ms)
		let dropped = work.slow().cancel()

		// a channel between workers
		let ch channel<int> = new(size=4)
		ch <- 42
		ch.close()

		select {
			case ch:
				println(<-ch)
			default:
				println("nothing ready")
		}

		// or drain a channel in parallel across cores
		forall let v in ch {
			println(v)
		} empty {
			println("channel was empty")
		}
		return 0
	}
}

module demo.tags {
	type Request {
		id int
		def new(v int) {
			id = v
		}
	}

	def deliver(message string) !none {
		fail "unsigned message" unless message.tags().has("signed")
		println("delivered: {message}")
		return none
	}
}

application TagsDemo {
	use demo.tags::(*)

	def new(args string[]) int {
		let message = "hello"
		message.tags().set("+signed")
		deliver(message) onerror (err error) {
			println("rejected: {err.message}")
			recover none
		}

		let copy = message + "!"          // a new value: no tags
		deliver(copy) onerror (err error) {
			println("rejected: {err.message}")
			recover none
		}

		let request = new Request(7)
		request.tags().add("Network/primary").add("pii")
		let queue channel<Request> = new(size=1)
		queue <- request
		let got = <-queue
		if got is Request {
			for let tag in got.tags().list() {
				println(tag)                 // Network/primary, then pii
			}
		}
		return 0
	}
}

module demo {
	use std.services::(*)

	service Storage {
		description  = "Counts opened files"
		dependencies = Dependencies{hard: [], soft: []}
		lifecycle    = Lifecycle{start: StartMode.Manual, restart: RestartMode.Never}
		permissions  = []

		opened int

		def config<T>(val T) !none {
			return none
		}

		async def start() !none {
			return none
		}

		async def stop() !none {
			return none
		}

		async def restart() !none {
			return none
		}

		@query()
		def openCount() int {
			return opened
		}

		@commit()
		def open(id int) int {
			opened += 1
			return id
		}
	}

	@on(Storage.open)
	def logOpen(ev Event<int>) {
		println("opened {ev.result}, total {Storage.openCount()}")
	}
}

module demo {
	use std.reflection as reflection

	meta def setTo(ctx reflection.ParameterMetaContext, value int) {
		ctx.set(value)
	}

	def id(@setTo(42) x int) int {
		return x
	}

	def run() bool {
		return id(1) == 42   // the argument was rewritten on the way in
	}
}

module demo {
	use std.reflection

	meta def mark(target reflection.DeclarationMetaContext, name string) {}

	@mark("t")
	type Thing {}

	@mark("f")
	def handler(x int) int {
		return x
	}

	def run() int {
		let hits = reflection.attrs(mark)
		return hits.len()   // 2 - the type and the function
	}
}

module demo {
	use std.reflection as reflection
	use std.data.encoding as encoding

	type T {
		@encoding.json(name="a", omitempty=true)
		x int
	}

	def run() bool {
		let t = T{x: 1}
		let md = reflection.fieldMetadataOf(t, "x")
		return md.load("encoder.json.name") == "a"
	}
}

application Simd {
	def new(args string[]) int {
		let data = float[1.0, 2.0, 3.0, 4.0]

		let v vec4<float>
		let a = v.load(data, 0)

		let w vec4<float>
		let b = w.splat(2.0)

		let scaled = a * b          // all four lanes at once
		let big    = a.gt(b)        // mask4<float>
		let picked = big.blend(a, b) // branchless select

		scaled.store(data, 0)
		return 0
	}
}

@link("GL")
module gl {
	const GL_TRIANGLES uint32 = 0x00000004

	def glClear(mask uint32);
	def glViewport(x, y, width, height int);
}

@c("libm.so")
module libm {
	def sin(x float64) float64;
	def cos(x float64) float64;
}

export function total(items) {
    return items.reduce((sum, item) => sum + item.price * item.quantity, 0)
}

export function discount(amount, code) {
    if (code !== "SPRING") throw new Error("unknown code " + code)
    return amount * 0.1
}

module shop {
	use adm.interop.js::*

	struct Item {
		name     string
		price    float
		quantity int
	}

	@js("pricing.js")
	def total(items Item[]) float;

	// Fails with a js.ScriptError when the script throws.
	@js("pricing.js")
	def discount(amount float, code string) !float;
}

application Shop {
	use (
		shop
		shop::(Item)
	)

	def new(args string[]) !int {
		let cart = [Item{name: "notebook", price: 4.5, quantity: 3}, Item{name: "pen", price: 1.2, quantity: 10}]
		let due = shop.total(cart)
		println("total  {"%.2f".format(due)}")
		println("spring {"%.2f".format(try shop.discount(due, "SPRING"))} off")
		shop.discount(due, "FREE") onerror (err error) {
			println("free   {err.message}")
			recover 0.0
		}
		return 0
	}
}

module books {
	use (
		std.data.db
		std.time
	)

	struct Book {
		id     int
		title  string
		author string
		// The column is called `published`.
		@db.column("published")
		year   int
		rating ?float
		// Text in the row, a time in the program.
		@db.column(stored = db.Stored.Text)
		added  time.Time
	}

	// The statements as methods; `{name}` is a bound argument.
	type Shelf {
		@db.connection()
		conn db.Queryable

		def new(conn db.Queryable) {
			self.conn = conn
		}

		sql def find(id int) !?Book {
			SELECT * FROM books WHERE id = {id}
		}

		sql def by(author string) !Book[] {
			SELECT * FROM books WHERE author = {author} ORDER BY published
		}

		sql def rate(id int, rating float) !db.Result {
			UPDATE books SET rating = {rating} WHERE id = {id}
		}

		sql def best() !(string, float) {
			SELECT title, rating FROM books WHERE rating IS NOT NULL ORDER BY rating DESC LIMIT 1
		}
	}
}

application Bookshelf {
	use (
		std.data.db
		std.time
		adm.database.sqlite        // makes the `sqlite:` scheme known
		books::(Book, Shelf)
	)

	def new(args string[]) !int {
		let conn = try db.connect("sqlite:books.db")
		try conn.exec("CREATE TABLE IF NOT EXISTS books (id INTEGER PRIMARY KEY, title TEXT NOT NULL UNIQUE, author TEXT NOT NULL, published INTEGER NOT NULL, rating REAL, added TEXT NOT NULL)")

		// Arguments are bound to the placeholders in order.
		let res = try conn.exec("INSERT INTO books (title, author, published, added) VALUES (?, ?, ?, ?)", "Dune", "Frank Herbert", 1965, time.now())
		println("inserted id {res.lastInsertId}")

		// A struct's fields as named arguments.
		let book = Book{id: 2, title: "Solaris", author: "Stanisław Lem", year: 1961, rating: 4.5, added: time.now()}
		try conn.exec("INSERT INTO books (id, title, author, published, rating, added) VALUES (:id, :title, :author, :published, :rating, :added)", db.values(book))

		// Rows into structs, by column name.
		let all = try db.readAll<Book>(try conn.query("SELECT * FROM books ORDER BY id"))
		println("{all.len()} books")

		// A failure says what kind it is.
		conn.exec("INSERT INTO books (title, author, published, added) VALUES (?, ?, ?, ?)", "Dune", "Someone Else", 2000, time.now()) onerror (err error) {
			if err is db.DbError {
				println("{err.kind.name}: {err.message}")    // Constraint: sqlite: UNIQUE constraint failed: books.title
			}
			recover db.Result{affected: 0, lastInsertId: 0}
		}

		let shelf = new Shelf(conn)
		try shelf.rate(1, 4.8)
		let (title, rating) = try shelf.best()
		println("best: {title} ({"%.1f".format(rating)})")
		for let (_, b) in try shelf.by("Stanisław Lem") {
			println("{b.year} {b.title}")
		}
		return 0
	}
}

module shop {
	use std.services.database::(Database, db)

	// Outside a type a `sql def` runs on the service's default connection.
	sql def place(customer string, total float) !none {
		INSERT INTO orders (customer, total) VALUES ({customer}, {total})
	}

	sql def revenue() !float {
		SELECT coalesce(sum(total), 0.0) FROM orders
	}

	// `@db` names another of the service's connections.
	@db("audit")
	sql def record(event string) !none {
		INSERT INTO events (event) VALUES ({event})
	}
}

application Shop {
	use (
		std.services.database::(Database)
		adm.database.postgres
		adm.database.sqlite
		shop
	)

	def new(args string[]) !int {
		try await Database.start()
		// Each connection is a pool that tasks share.
		try Database.add("postgres://app:secret@db.internal/shop?sslmode=verify-full")
		try Database.add("audit", "sqlite:audit.db")

		try shop.place("ana", 19.90)
		try shop.record("order for ana")
		println("revenue {"%.2f".format(try shop.revenue())}")
		return 0
	}
}

application Brighten {
	use std.gpu

	cuda def brighten(pixels byte[], amount int) !none {
		int i = blockIdx.x * blockDim.x + threadIdx.x;
		if (i < pixels_len) {
			int v = pixels[i] + amount;
			pixels[i] = v > 255 ? 255 : v;
		}
	}

	def new(args string[]) int {
		let image = byte[10, 120, 250]
		brighten(image, 40) onerror recover none
		println(image[0], image[1], image[2])   // 50 160 255
		println("ran on {gpu.deviceName()}") when gpu.available()
		return 0
	}
}

application Words {
	use std.data.collections::*

	def new(args string[]) int {
		let counts = new HashMap<string, int>()
		for let word in "the cat and the hat".split(" ") {
			counts.set(word, counts.get(word, 0) + 1)
		}

		let repeated = new Deque<string>()
		for let entry in counts {
			repeated.pushBack(entry.key) when entry.value > 1
		}
		println(repeated.popFront())        // the

		let seen = new BloomFilter(1024)
		seen.add("cat")
		println(seen.mightContain("cat"))   // true
		return 0
	}
}

application Versions {
	use std.data.semver::*

	def new(args string[]) int {
		let v = parse("1.4.0-rc.1")
		return 1 when v is error

		println(v.major)                          // 1
		println(v < "1.4.0")                      // true: a prerelease precedes the release
		println(v.satisfies("^1.2.0"))            // false: prereleases need an opt-in
		println(v.satisfies(">=1.4.0-alpha"))     // true
		println(v.canonical())                    // 1.4.0-rc.1
		return 0
	}
}

application Calculator {
	use (
		std.proto.mcp
		tools.calculator as _
	)

	def new(args string[]) int {
		// Serves every marked function over standard input and output.
		mcp.serve("calculator", "1.0.0") onerror (err error) {
			return 1
		}
		return 0
	}
}

module tools.calculator {
	use std.proto.mcp

	// Adds two numbers.
	// @param a the first number
	// @param b the second number
	@mcp.tool(readOnly = true)
	def add(a int, b int) int {
		return a + b
	}

	// A note by its number.
	@mcp.resource("notes://\{id\}")
	def note(id int) !string {
		fail "there are nine notes" when id > 9
		return "Note {id}"
	}

	// Asks for a review of some code.
	// @param code the code to review
	// @param focus what to look for
	@mcp.prompt()
	def review(code string, focus string = "bugs") string {
		return "Review this code for {focus}:\n{code}"
	}
}

application Trip {
	use std.units::*

	def eta(distance Length, speed Speed) Time {
		return distance / speed
	}

	def new(args string[]) int {
		let distance = 420(km)
		let speed = 110(km/h)
		let t = eta(distance, speed)
		println(t.str(h, digits = 1))                 // 3.8 h

		let fuel = 6.2(L/100km)
		let used Volume = distance * fuel
		println(used.str(L))                          // 26.04 L

		let tank = parseUnit("45 L", L) onerror (err error) {
			println(err)
			return 1
		}
		println("{(tank / fuel).str(km, digits = 0)} on a full tank")   // 726 km

		let force = 75(kg) * 9.81(m/s²)
		println(force)                                // 735.75 kg·m/s²
		println(force.str(N))                         // 735.75 N

		let outside = 21(°C)
		println(outside.str(K))                       // 294.15 K

		let link = 1(GB) / 8(s)
		println(link.str(Mbit/s))                     // 1000 Mbit/s

		// let wrong = distance + t                   // error: cannot add Length and Time
		let level = quantity(-6, dB)                  // a gain of 0.501
		println(level.str(dB))                        // -6 dB
		return 0
	}
}

application Jukebox {
	use (
		std.media.player::*
		std.media.dsp::*
	)

	def new(args string[]) int {
		let player = new MediaPlayer()
		let added = player.playlist.addFolder("~/Music/Albums") onerror (err error) {
			println("cannot read the folder: {err}")
			return 1
		}
		player.playlist.push("https://radio.example.org/stream.mp3")
		println("{added} tracks and one radio station")

		let eq = new Equalizer(EqLayout.Graphic10)
		eq.apply(EqPreset.Rock)
		player.effects.push(eq)
		player.effects.push(new Limiter())

		player.crossfade = 3s
		player.repeat = RepeatMode.RepeatPlaylist
		player.shuffle()

		let done channel<bool> = new(size = 1)
		player.onTrackChange = def (i int) {
			return when i < 0
			let track = player.playlist.tracks[i]
			println("now playing: {track.artist} - {track.title}")
		}
		player.onStateChange = def (state PlayerState) {
			done <- true when state == PlayerState.Stopped
		}

		player.play() onerror (err error) {
			println("cannot play: {err}")
			return 1
		}
		<-done
		return 0
	}
}

@manifest(version = "1.2.0")
plugin ImageTools {
	use (
		acme.imaging
		acme.imaging.filters
	)

	export (
		acme.imaging.filters
		acme.imaging::(Image, decode)
	)
}

application PingPong {
	use std.net.udp

	def new(args string[]) !int {
		// Two sockets on this machine, each connected to the other: the system drops
		// datagrams from anyone else, and a send names no address.
		let left = try udp.dial("127.0.0.1:47002", local = "127.0.0.1:47001")
		let right = try udp.dial("127.0.0.1:47001", local = "127.0.0.1:47002")

		try left.send("ping".bytes(), 1s)
		let buf byte[] = []
		buf.len(64)
		let n = try right.receive(buf, 1s)
		println("right got {string(buf.slice(0, n))} from {right.remoteAddr()}")

		try right.send("pong".bytes(), 1s)
		let m = try left.receive(buf, 1s)
		println("left got {string(buf.slice(0, m))}")

		try left.close()
		try right.close()
		return 0
	}
}

application Lines {
	use (
		std.os
		std.services.storage::MapAccess
	)

	// Counts the lines of a file of any size: the pages are read as the loop
	// touches them, and none of the file is copied.
	def new(args string[]) !int {
		let path = args.len() > 1 ?? (args[1], "/usr/share/dict/words")
		let mapping = try os.mapFile(path, MapAccess.Copy)
		defer mapping.close()
		let text = try mapping.pages(0, mapping.length())
		let lines = 0
		for let b in text {
			lines += 1 when b == 10
		}
		println("{path}: {lines} lines in {text.len()} bytes")
		return 0
	}
}

module themed {
	use (
		std.math.geom::(Axes, Corners, Edges)
		std.ui::(SizeClass, StyleSheet, kind, role, rule)
		std.ui.components::*
		std.ui.styles::*
		std.units::*
	)

	// A card: a box with a background and a border, whose text follows its font.
	component Card {
		type {
			@input(value = true)
			title string = ""
		}

		view {
			Heading(title)
			children()
		}

		style {
			Box
			Layout
			Decorated
			Typography
			Compositing
			arrange  = Arrange.Column
			gap      = new Axes<Extent>(8(px))
			padding  = new Edges<Extent>(16(px))
			radius   = new Corners<Extent>(8(px))
			font     = {size: 15(px)}
			on       = {
				hover: {opacity: 0.95},
			}
			variants = {
				quiet: {opacity: 0.7},
				wide:  {width: 480(px)},
			}
		}
	}

	// House style: every button square; anything with the button role inside a card bold.
	let house = new StyleSheet([
		rule(kind<Button>(), style = {radius: new Corners<Extent>(0(px))}),
		rule(role(Role.Button).inside(kind<Card>()), style = {font: {weight: FontWeight.Bold}}),
	])

	// A sheet of its own for one part of the page.
	let compact = new StyleSheet([
		rule(kind<Card>(), style = {padding: new Edges<Extent>(6(px)), gap: new Axes<Extent>(4(px))}),
	])

	component Page {
		view {
			Card("Account", style = {variant: [wide]}) {
				Label("Signed in")
				Button("Sign out", style = {width: 140(px), on: {hover: {font: {italic: true}}}})
			}
			// Below `UIConfig.compactWidth` the second card takes the compact sheet.
			if viewport.widthClass == SizeClass.Compact {
				Styled(compact) {
					Card("Recent", style = {variant: [quiet]}) {
						Label("Nothing yet")
					}
				}
			} else {
				Card("Recent", style = {variant: [quiet]}) {
					Label("Nothing yet")
				}
			}
		}

		style {
			Box
			Layout
			Typography
			arrange = Arrange.Column
			gap     = new Axes<Extent>(12(px))
			padding = new Edges<Extent>(24(px))
			// Inherited by every text and button on the page.
			font    = Font{family: "Inter", size: 14(px)}
		}
	}
}

application Themed {
	use (
		std.ui::(UI, UIConfig)
		std.ui.renderer
		std.units::*
		themed::(Page, house)
	)

	async def new(args string[]) !int {
		try UI.config(UIConfig{rendererName: "opengl", compactWidth: 520(px)})
		try await UI.start()
		UI.addStyles(house)
		try await UI.run(Page(), new renderer.WindowConfig("Themed", 900, 640))
		return 0
	}
}

module demo.paths {
	use std.os::(base, extension)
	use std.testing::(benchmark, test)

	check "Path" {
		@test()
		def TestExtension() {
			assert extension("/path/to/file.txt") == "txt"
			assert extension("file") == ""
		}

		@benchmark()
		def BenchBase() {
			base("/path/to/file.txt")
		}
	}
}