DOCUMENTATION

Functions & Fibers

DOCUMENTATION

XCX 4.4.1 Functions and Fibers

IMPORTANT:

Global Scope Rule: Functions and fibers must be declared at the top level of a file. They cannot be nested inside if/while/for blocks or other functions/fibers in a way that affects scoping - all function and fiber names are registered globally during compilation.

Functions

Definition Styles

Parameters follow the type: name pattern (e.g., i: count).

NOTE:

Semicolons after blocks are optional (recommended style: without). The

; after a function's or fiber's closing } may be omitted and is

removed in XCX 5.0a. Statement semicolons inside the body stay required.

$ xcx

_ ⛶ ×

--- No parameters, no return value
func hello() {
    >! "Hello!";
};

--- No parameters, with return value
func get_pi(-> f) {
    return 3.14159;
};

--- With parameters, no return value
func greet(s: who) {
    >! "Hello, " + who + "!";
};

--- With parameters and return value
func add(i: x, i: y -> i) {
    return x + y;
};

Calling Functions

$ xcx

_ ⛶ ×

hello();
f: pi = get_pi();
greet("Alice");
i: result = add(3, 4);

Recursion

Max depth: 800 frames. Exceeding this triggers halt.error.

$ xcx

_ ⛶ ×

func factorial(i: n -> i) {
    if (n <= 1) then;
        return 1;
    else;
        return n * factorial(n - 1);
    end;
};
>! factorial(5);   --- 120

Fibers (Coroutines)

Fibers can suspend execution with yield and be resumed. There are two variants: typed (yield returns a value) and void (yield without a value).

Definition

$ xcx

_ ⛶ ×

--- Typed Fiber: each yield returns a value of type T
fiber generator(i: max -> i) {
    for i in 1 to max do;
        yield i;
    end;
    return 0;
};

--- Void Fiber: yield without a value
fiber logger(s: msg) {
    if (msg == "") then; return; end;
    >! msg;
    yield;
};

Instantiation

$ xcx

_ ⛶ ×

1fiber:i: gen = generator(10); --- typed

2fiber: log = logger("init"); --- void

Fiber Methods

Method	Works on	Returns	Description
`.next()`	`fiber:T`	`T`	Resumes; returns next yielded value
`.run()`	`fiber:`	`b`	Resumes void fiber one step
`.isDone()`	both	`b`	`true` when fiber has finished
`.close()`	both	`b`	Forcefully terminates the fiber

Calling .next() when isDone() == true triggers halt.alert (R306).

yield

$ xcx

_ ⛶ ×

--- In a typed fiber
yield true;
yield score + 10;

--- In a void fiber
yield;

return in Fibers

1. Typed fiber (fiber ... -> T): Typed fiber requires return expr; not plain return;. Returning without a value throws a compile error (S210).

2. Void fiber: Uses return; to exit early.

$ xcx

_ ⛶ ×

fiber:i: gen(i: max -> i) {
    for i in 1 to max do;
        if (i == 3) then;
            return 99;   --- Valid: terminates and returns 99
        end;
        yield i;
    end;
    return 0;            --- Required at end of typed fiber
};

fiber logger(s: msg) {
    if (msg == "") then;
        return;          --- Valid for void fiber
    end;
    >! msg;
};

for Loop over a Fiber

$ xcx

_ ⛶ ×

fiber:i: f = generator(5);
for val in f do;
    >! val;
end;

Equivalent to while (!f.isDone()) { val = f.next(); ... }. break inside the loop automatically calls .close().

NOTE:

The fiber's return value is the last iteration item. Once the yields

are exhausted, the final next() executes the fiber's return and the

loop delivers that value as the last element (a fiber ending with

return 99 emits 99 last). This follows directly from the

while (!isDone()) { next() } equivalence above and is intentional. It

does not apply through yield from - see Delegation below.

Fiber as Function Parameter

$ xcx

_ ⛶ ×

func run_checks(fiber:b: f) {
    while (f.isDone() == false) do;
        b: result = f.next();
        if (result == false) then;
            halt.alert >! "Step failed";
            return;
        end;
    end;
};

fiber:b: checks = login_pipeline(user, pass);
run_checks(checks);

yield from (Delegation)

Delegates execution to a sub-fiber. The compiler desugars this into a loop that yields every value from the sub-fiber.

NOTE:

The sub-fiber's return value is not re-yielded. Delegation runs the

sub-fiber to completion and yields only its yielded values (in the example

below, count's return 0 never surfaces). This is intentional and

differs from a direct for over the same fiber, whose last iteration item

is the return value - see the note in the previous section.

$ xcx

_ ⛶ ×

fiber count(i: n -> i) {
    i: x = 0;
    while (x < n) do;
        yield x;
        x = x + 1;
    end;
    return 0;
};

fiber delegator(-> i) {
    fiber:i: sub = count(3);
    yield from sub;   --- yields: 0, 1, 2
    yield 100;        --- then yields: 100
    return 0;
};

Manual Delegation

$ xcx

_ ⛶ ×

fiber pipeline(s: user, s: pass -> b) {
    fiber:b: step1 = check_user(user);
    yield step1.next();

    fiber:b: step2 = check_pass(user, pass);
    yield step2.next();

    return false;
};

← All documentation

LEARN

ECOSYSTEM

COMMUNITY

Functions & Fibers

XCX 4.4.1 Functions and Fibers

Functions

Definition Styles

Calling Functions

Recursion

Fibers (Coroutines)

Definition

Instantiation

Fiber Methods

yield

return in Fibers

for Loop over a Fiber

Fiber as Function Parameter

yield from (Delegation)

Manual Delegation