type Callback = fn (int) int

fn add1(x int) int {
	return x + 1
}

fn double(x int) int {
	return x * 2
}

struct Box {
	op fn (int) int @[required]
}

fn apply(f fn (int) int, x int) int {
	return f(x)
}

// apply_cb takes a function-type *alias* parameter, which must be unwrapped to
// its underlying fn type for the indirect call.
fn apply_cb(f Callback, x int) int {
	return f(x)
}

// a fn-typed const, called through the const name
const cb = add1

// make_cb returns a function value, so `make_cb()(x)` is an expression callee
fn make_cb() fn (int) int {
	return double
}

// logged_box / logged_arg make the evaluation order observable: the callee
// (the receiver) must be evaluated before the argument.
fn logged_box() Box {
	println('callee')
	return Box{
		op: add1
	}
}

fn logged_arg() int {
	println('arg')
	return 100
}

fn main() {
	// a top-level fn taken as a local fn value, then called through the value
	f := add1
	println(f(10)) // 11

	// a fn value stored in a struct field, called through the field
	b := Box{
		op: double
	}
	println(b.op(20)) // 40

	// a top-level fn passed as a fn-typed argument and called indirectly
	println(apply(add1, 41)) // 42

	// a non-capturing anonymous function as a value
	h := fn (x int) int {
		return x * x
	}
	println(h(7)) // 49

	// reassign a fn value and call again (dynamic dispatch through the table)
	mut g := add1
	println(g(0)) // 1
	g = double
	println(g(50)) // 100

	// a fn-typed const, called through the const name
	println(cb(99)) // 100

	// an expression callee that evaluates to a function value
	println(make_cb()(5)) // 10

	// the callee is evaluated before the argument: prints `callee`, then `arg`
	println(logged_box().op(logged_arg())) // 101

	// function type alias as a value: passed as a param, and cast into a local
	println(apply_cb(add1, 5)) // 6
	ac := Callback(double)
	println(ac(6)) // 12

	// a real function value must be distinct from `nil` (table slot 0 is reserved)
	nf := add1
	println(unsafe { nf == nil }) // false
}