Statements

A Luna program is basically a list of statements, called a Chunk.

Chunk

A list of statements with no seperator

Block

Just a list of statements like a Chunk, but it requires { at the start and } at the end.

Statement

A statement has a lot of variants, like let-bindings, function definitions, etc. But it also can as well just be a Block

Let Binding

This is what you define local variables with. The assignees can be simple identifiers or object/vector destructurings.

Examples: let a = 1, let { name, age } = person, let [first, second, third] = numbers

Assign

This is how you assign new values to existing variables. The assignees can be simple identifiers or a field/index into an object/vector

Examples: a = 2

Assign Operation

Written the same way as Assign expect with any of the following assign operators, only one assignee and only one expression:

Examples: a += 1, b *= 2

Call

This is to call functions with arguments. The callee can either be a simple identifier or a field/index of an object/vector.

Examples: print("Hello, World!"), self.add(1)

Self Call

Just like a Call only written with a : followed by an identifier. This calls the function with the first argument being the value before the :. This is used to call objects with themselfs for object-oriented design patterns.

Examples: vector:push(1), person:greet()

Function Definition

This is used to globally define functions with parameters.

Examples:

fn add(a, b) {
    return a + b
}

Let-Function Definition

This is used to locally define functions with parameters in the current scope.

Examples:

let fn add(a, b) {
    return a + b
}

If-Branch

Classical if-branch like any other. Has an optional else-case which can either be a block or another if-branch.

Examples:

if cond {
    print("yay")
}

if cond {
    print("yay")
} else {
    print("nay")
}

if cond {
    print("yay")
} else if cond2 {
    print("semi-yay")
}

Match

Classical match-case statement to check over multiple variants of one value.

Examples:

match cmd {
    "exit" => { os.exit() }
    cmd => {
        print("invalid command: %s":format(cmd))
    }
}

While-Loop

Classical while-loop like any other. body has to be a block

Examples:

while a < 10 {
    a += 1
}

For-Loop

Python-like for-loop that requires an iterable to be right of the in keyword. Only one variable can be given for each iteration. An iterable can either be an user-object with a next method, an object with the meta variable __next which is a function, or just a function.

Examples:

for n in [1, 2, 3]:iter() {
    print(n)
}

for key in keys(map) {
    print(key, map[key])
}

Return

This is used to return a value to the caller and end execution of the current function.

Examples: return a + b, return null

Break

This is used to break out of any loop.

Examples:

while true {
    if a >= 10 {
        break
    }
    a += 1
}

Continue

This is used to continue to the next iteration of the loop.

Examples:

for n in numbers:iter() {
    if n == 5 {
        continue
    }
    print(n)
}