Renderingen-US

Experimental through version 1. Version 0 was alpha. This is the first language release: the interface is relatively stable, not frozen. Nothing is promised stable until version 2.

Control flow

Branching#

if / elif / else — if, else-if, else.

main {
    let int n ← 2

    if n ≡ 1 {
        print "one"
    }
    elif n ≡ 2 {
        print "two"
    }
    else {
        print "many"
    }
}

One-line branch#

then takes a single statement instead of a block. Useful for guards.

reader locale
faber convert --to en — English reader surface
fn abs(int n) → int {
    if n ≺ 0 then return 0 - n
    return n
}

main {
    print abs(-5)
}
faber convert --to la — canonical Faber
functio abs(numerus n) → numerus {
    si n ≺ 0 ergo redde 0 - n
    redde n
}

incipit {
    nota abs(-5)
}
faber convert --to th-TH — Thai
ฟังก์ชัน abs(จํานวน n) → จํานวน {
    ถ้า n ≺ 0 ดังนั้น คืน 0 - n
    คืน n
}

เริ่ม {
    บันทึก abs(-5)
}
faber convert --to zh-Hans — Simplified Chinese
函数 abs(整数 n) → 整数 {
    如果 n ≺ 0 则 返回 0 - n
    返回 n
}

入口 {
    显示 abs(-5)
}
faber convert --to zh-Hant — Traditional Chinese
函式 abs(整數 n) → 整數 {
    若 n ≺ 0 則 傳回 0 - n
    傳回 n
}

入口 {
    註記 abs(-5)
}
faber convert --to vi — Vietnamese
hàm abs(số n) → số {
    nếu n ≺ 0 do_đó trả 0 - n
    trả n
}

bắt_đầu {
    ghi_chú abs(-5)
}
faber convert --to ar — Arabic
دالة abs(عدد n) → عدد {
    إذا n ≺ 0 إذن أعد 0 - n
    أعد n
}

بداية {
    اعرض abs(-5)
}
faber convert --to hi — Hindi
फलन abs(संख्या n) → संख्या {
    यदि n ≺ 0 अतः लौटाओ 0 - n
    लौटाओ n
}

आरंभ {
    दिखाओ abs(-5)
}

Selecting over a value#

switch picks an arm by value. default is the fallback.

main {
    let int n ← 2

    switch n {
        case 1 {
            print "one"
        }
        case 2 {
            print "two"
        }
        default {
            print "many"
        }
    }
}

Matching a union#

match matches over a union-typed value. This is how a union hole gets read back out.

main {
    let string ∪ int signum ← 7

    match signum {
        case int let n {
            print "a number"
        }
        case string let s {
            print "a text"
        }
    }
}

The difference from switch is intent: switch chooses among values of one type, match discriminates among the members of a union.

Returning#

return returns a value. A function with no → returns nothing and needs no return.

fn duplica(int n) → int {
    return n * 2
}

fn saluta(string name) → void {
    print name
}

main {
    print duplica(21)
    saluta("Marcus")
}

To exit by the error channel instead, see Errors and catching.

Related: Loops · Functions and flow