Callables

Callables are function values. They are Thread-Stack-managed: referencing a function allocates its frame on the heap and stores a pointer to the function in front of it.

The fn Type

// no params, no return
fn<() -> void>

// two params, one return
fn<i32, i32 -> i32>

// multiple returns: no parens
fn<i32, i32 -> i32, i32>

Special-case notations:

// params only, no return (-> void omitted)
fn<i32>

// neither params nor return
fn<>

Function References

def greet():
    print("Hello, World!\n");

def main():
    // '::' is the reference operator
    fn<() -> void> g = ::greet;
    g();

• Core module and extern functions cannot be referenced (::print is an error).
• Callables are freed/overwritten on reassignment; copying a callable clones its frame.

Callables as Values

Pass, return, and mutate callables like any value:

def apply_op(fn<i32, i32 -> i32> op, i32 x, i32 y) -> i32:
    return op(x, y);

def get_sub() -> fn<i32, i32 -> i32>:
    return ::sub;

// callables pass by reference
def set_sub(mut fn<i32, i32 -> i32> op):
    op = ::sub;

def main():
    fn<i32, i32 -> i32> op = get_sub();
    i32 res = apply_op(op, 20, 10);
    set_sub(op);
    res = apply_op(op, res, 5);

Persistent Locals

persistent keeps local state across calls; per callable instance, not static/shared:

def counter() -> i32:
    persistent i32 c = 0;
    // '++' not usable in expression contexts yet
    i32 current = c;
    c++;
    return current;

def main():
    fn<() -> i32> c1 = ::counter;
    fn<() -> i32> c2 = ::counter;
    c1(); // 0
    c1(); // 1
    c2(); // 0

• Cannot combine persistent with const.
• Direct calls (counter()) reset the state each invocation; only callable instances persist.

Use cases: counters, rate-limiters (with Core.time), state machines, accumulators.

Error Sets in Callables

// possible errors in the fn type
fn<bool {ErrAssert}> f = ::may_fail;

f(true) catch err:
    switch err:
        ErrAssert(e): print($"ErrAssert = {e}\n");
        anyerror(e):  print($"anyerror = {e}\n");

An unspecified error set expands to {anyerror}:

// This expands to the type fn<bool -> void {anyerror}>
fn<bool> f = ::may_fail;

so any function reference can be stored regardless of the errors it may throw.