TypeScript

HIR projection with file emission and end-to-end floors.

Part of the HIR lane. Every panel below is compiler output.

How to read it#

The largest expansion among the host languages, because Faber's typed numerics and tensors have no TypeScript counterpart and arrive as generated runtime scaffolding.

Measured support#

From the target matrix: how many corpus exempla lower to this target. Coverage is not a quality score — an emitter can lower a term and still erase a distinction.

No measured gaps in the scored sections.

Typed tensors#

Builds two shaped matrices, multiplies them, and reduces the product to a scalar. Exercises shape-bearing types and a reduction.

Faber source

main {
    const list<f32> flat_a ← [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]
    const list<f32> flat_b ← [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0]
    const tf32[] seed ← empty
    const tf32[2, 3] a ← seed.from_flat(flat_a, [2, 3])
    const tf32[3, 4] b ← seed.from_flat(flat_b, [3, 4])
    const tf32[2, 4] product ← a.matmul(b)
    const f32 mean ← product.mean()
    print mean
}

incipit {
    fixum lista<f32> flat_a ← [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]
    fixum lista<f32> flat_b ← [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0]
    fixum tf32[] seed ← vacua
    fixum tf32[2, 3] a ← seed.strue(flat_a, [2, 3])
    fixum tf32[3, 4] b ← seed.strue(flat_b, [3, 4])
    fixum tf32[2, 4] product ← a.matmul(b)
    fixum f32 mean ← product.media()
    nota mean
}

เริ่ม {
    คงที่ รายการ<f32> flat_a ← [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]
    คงที่ รายการ<f32> flat_b ← [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0]
    คงที่ tf32[] seed ← เซตว่าง
    คงที่ tf32[2, 3] a ← seed.สร้างจากข้อมูลแบน(flat_a, [2, 3])
    คงที่ tf32[3, 4] b ← seed.สร้างจากข้อมูลแบน(flat_b, [3, 4])
    คงที่ tf32[2, 4] product ← a.คูณเมทริกซ์(b)
    คงที่ f32 mean ← product.ค่าเฉลี่ย()
    บันทึก mean
}

入口 {
    常量 列表<f32> flat_a ← [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]
    常量 列表<f32> flat_b ← [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0]
    常量 tf32[] seed ← 空集
    常量 tf32[2, 3] a ← seed.由扁平构造(flat_a, [2, 3])
    常量 tf32[3, 4] b ← seed.由扁平构造(flat_b, [3, 4])
    常量 tf32[2, 4] product ← a.矩阵乘法(b)
    常量 f32 mean ← product.均值()
    显示 mean
}

入口 {
    定值 列表<f32> flat_a ← [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]
    定值 列表<f32> flat_b ← [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0]
    定值 tf32[] seed ← 空集
    定值 tf32[2, 3] a ← seed.由扁平建構(flat_a, [2, 3])
    定值 tf32[3, 4] b ← seed.由扁平建構(flat_b, [3, 4])
    定值 tf32[2, 4] product ← a.矩陣乘法(b)
    定值 f32 mean ← product.平均值()
    註記 mean
}

bắt_đầu {
    hằng danh_sách<f32> flat_a ← [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]
    hằng danh_sách<f32> flat_b ← [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0]
    hằng tf32[] seed ← tập_rỗng
    hằng tf32[2, 3] a ← seed.dựng_từ_phẳng(flat_a, [2, 3])
    hằng tf32[3, 4] b ← seed.dựng_từ_phẳng(flat_b, [3, 4])
    hằng tf32[2, 4] product ← a.nhân_ma_trận(b)
    hằng f32 mean ← product.trung_bình()
    ghi_chú mean
}

بداية {
    ثابت قائمة<f32> flat_a ← [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]
    ثابت قائمة<f32> flat_b ← [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0]
    ثابت tf32[] seed ← فارغ
    ثابت tf32[2, 3] a ← seed.ابن_من_مسطح(flat_a, [2, 3])
    ثابت tf32[3, 4] b ← seed.ابن_من_مسطح(flat_b, [3, 4])
    ثابت tf32[2, 4] product ← a.ضرب_المصفوفات(b)
    ثابت f32 mean ← product.المتوسط()
    اعرض mean
}

आरंभ {
    स्थिर सूची<f32> flat_a ← [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]
    स्थिर सूची<f32> flat_b ← [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0]
    स्थिर tf32[] seed ← खाली
    स्थिर tf32[2, 3] a ← seed.समतल_से_बनाओ(flat_a, [2, 3])
    स्थिर tf32[3, 4] b ← seed.समतल_से_बनाओ(flat_b, [3, 4])
    स्थिर tf32[2, 4] product ← a.आव्यूह_गुणन(b)
    स्थिर f32 mean ← product.माध्य()
    दिखाओ mean
}

TypeScript — 10 lines in, 251 out (25.1×)

// Generated by radix - do not edit

import { __faberDisplay } from "@faber/runtime";

declare global {
    interface Number {
        potentia(exponent: number): number;
    }
}
Number.prototype.potentia = function(this: Number, exponent: number): number {
    return Math.pow(this.valueOf(), exponent);
};

class FaberTensor<T> {
    data: T[];
    shape: number[];
    constructor(data: T[], shape: number[]) {
        this.data = data.slice();
        this.shape = shape.slice();
    }
    private static elementCount(shape: number[]): number {
        if (shape.some((dim) => dim < 0)) {
            throw new Error("tensor shape dimension must be non-negative");
        }
        return shape.reduce((total, dim) => total * dim, 1);
    }
    private static coordinates(flat: number, shape: number[]): number[] {
        const coords = new Array(shape.length).fill(0);
        for (let axis = shape.length - 1; axis >= 0; axis--) {
            const dim = shape[axis];
            coords[axis] = dim === 0 ? 0 : flat % dim;
            flat = dim === 0 ? 0 : Math.floor(flat / dim);
        }
        return coords;
    }
    private static offset(shape: number[], indices: number[]): number | null {
        if (indices.some((idx) => idx < 0)) {
            throw new Error("tensor accipe invalid index");
        }
        if (indices.length !== shape.length) {
            return null;
        }
        let offset = 0;
        let stride = 1;
        for (let axis = shape.length - 1; axis >= 0; axis--) {
            const idx = indices[axis];
            const dim = shape[axis];
            if (idx >= dim) {
                return null;
            }
            offset += idx * stride;
            stride *= dim;
        }
        return offset;
    }
    private static broadcastShape(left: number[], right: number[]): number[] {
        const rank = Math.max(left.length, right.length);
        const shape = new Array(rank);
        for (let i = 0; i < rank; i++) {
            const l = left[left.length - rank + i] ?? 1;
            const r = right[right.length - rank + i] ?? 1;
            if (l !== r && l !== 1 && r !== 1) {
                throw new Error("tensor broadcast shape mismatch");
            }
            shape[i] = Math.max(l, r);
        }
        return shape;
    }
    private static broadcastOffset(sourceShape: number[], resultCoords: number[]): number | null {
        const offset = resultCoords.length - sourceShape.length;
        const coords = sourceShape.map((dim, axis) => dim === 1 ? 0 : resultCoords[axis + offset]);
        return FaberTensor.offset(sourceShape, coords);
    }
    private static flatten(source: unknown): any[] {
        if (!Array.isArray(source)) {
            return [source];
        }
        return source.flatMap((value) => FaberTensor.flatten(value));
    }
    static empty<T>(shape: number[] = []): FaberTensor<T> {
        return new FaberTensor<T>([], shape);
    }
    static fromArray<T>(source: unknown, shape: number[], convert: (value: any) => T = (value) => value as T, fallback?: FaberTensor<T>): FaberTensor<T> {
        try {
            const data = FaberTensor.flatten(source).map(convert);
            if (FaberTensor.elementCount(shape) !== data.length) {
                throw new Error("tensor conversio element count does not match shape");
            }
            return new FaberTensor<T>(data, shape);
        } catch (error) {
            if (fallback === undefined) {
                throw error;
            }
            return fallback;
        }
    }
    crea(fill: T, shape: number[]): FaberTensor<T> {
        return new FaberTensor<T>(new Array(FaberTensor.elementCount(shape)).fill(fill), shape);
    }
    strue(data: T[], shape: number[]): FaberTensor<T> {
        if (FaberTensor.elementCount(shape) !== data.length) {
            throw new Error("tensor structa element count does not match shape");
        }
        return new FaberTensor<T>(data, shape);
    }
    longitudo(): number {
        return this.shape.length;
    }
    magnitudines(): Array<number> {
        return this.shape.slice();
    }
    forma(shape: number[]): FaberTensor<T> {
        if (FaberTensor.elementCount(shape) !== this.data.length) {
            throw new Error("tensor forma (reshape) element count mismatch");
        }
        return new FaberTensor<T>(this.data, shape);
    }
    accipe(indices: number[]): T | null {
        const offset = FaberTensor.offset(this.shape, indices);
        return offset == null ? null : this.data[offset];
    }
    ponde(indices: number[], value: T): void {
        const offset = FaberTensor.offset(this.shape, indices);
        if (offset == null) {
            throw new Error("tensor ponde invalid index");
        }
        this.data[offset] = value;
    }
    reple(value: T): void {
        this.data.fill(value);
    }
    planata(): T[] {
        return this.data.slice();
    }
    sectio(start: number, end: number): FaberTensor<T> {
        if (start < 0 || end < 0 || end < start) {
            throw new Error("tensor sectio invalid slice bounds");
        }
        const inner = FaberTensor.elementCount(this.shape.slice(1));
        const shape = [end - start, ...this.shape.slice(1)];
        return new FaberTensor<T>(this.data.slice(start * inner, end * inner), shape);
    }
    materialize(): FaberTensor<T> {
        return new FaberTensor<T>(this.data, this.shape);
    }
    private elementwise(other: FaberTensor<T>, op: (left: any, right: any) => any): FaberTensor<T> {
        const shape = FaberTensor.broadcastShape(this.shape, other.shape);
        const data = new Array(FaberTensor.elementCount(shape));
        for (let i = 0; i < data.length; i++) {
            const coords = FaberTensor.coordinates(i, shape);
            const left = FaberTensor.broadcastOffset(this.shape, coords);
            const right = FaberTensor.broadcastOffset(other.shape, coords);
            data[i] = op(this.data[left ?? 0], other.data[right ?? 0]);
        }
        return new FaberTensor<T>(data as T[], shape);
    }
    addita(other: FaberTensor<T>): FaberTensor<T> {
        return this.elementwise(other, (left, right) => left + right);
    }
    subtrahe(other: FaberTensor<T>): FaberTensor<T> {
        return this.elementwise(other, (left, right) => left - right);
    }
    multiplica(other: FaberTensor<T>): FaberTensor<T> {
        return this.elementwise(other, (left, right) => left * right);
    }
    sum(): T {
        return this.data.reduce((total: any, value: any) => total + value, 0) as T;
    }
    media(): number {
        return this.data.length === 0 ? 0 : this.data.reduce((total: any, value: any) => total + value, 0) / this.data.length;
    }
    matmul(other: FaberTensor<T>): FaberTensor<T> {
        if (this.shape.length !== 2 || other.shape.length !== 2) {
            throw new Error("matmul requires rank-2 tensor");
        }
        const [m, k1] = this.shape;
        const [k2, n] = other.shape;
        if (k1 !== k2) {
            throw new Error("matmul inner dimension mismatch");
        }
        const data = new Array(m * n).fill(0);
        for (let row = 0; row < m; row++) {
            for (let column = 0; column < n; column++) {
                let total: any = 0;
                for (let k = 0; k < k1; k++) {
                    total += (this.accipe([row, k]) as any) * (other.accipe([k, column]) as any);
                }
                data[row * n + column] = total;
            }
        }
        return new FaberTensor<T>(data as T[], [m, n]);
    }
    transpone(): FaberTensor<T> {
        if (this.shape.length <= 1) {
            return new FaberTensor<T>(this.data, this.shape);
        }
        if (this.shape.length !== 2) {
            throw new Error("transpone requires rank-1 or rank-2 tensor");
        }
        const [rows, cols] = this.shape;
        const data = new Array(rows * cols);
        for (let col = 0; col < cols; col++) {
            for (let row = 0; row < rows; row++) {
                data[col * rows + row] = this.accipe([row, col]);
            }
        }
        return new FaberTensor<T>(data as T[], [cols, rows]);
    }
    activatio_softmax(): FaberTensor<T> {
        if (this.data.length === 0 || this.shape.length === 0) {
            throw new Error("softmax empty tensor");
        }
        const lastDim = this.shape[this.shape.length - 1];
        const batch = this.data.length / lastDim;
        const data = new Array(this.data.length);
        for (let b = 0; b < batch; b++) {
            const base = b * lastDim;
            let maxVal = -Infinity;
            for (let i = 0; i < lastDim; i++) {
                const value = Number(this.data[base + i]);
                if (!Number.isFinite(value)) {
                    throw new Error("softmax non-finite input");
                }
                if (value > maxVal) maxVal = value;
            }
            let expSum = 0;
            const exps = new Array(lastDim);
            for (let i = 0; i < lastDim; i++) {
                const expVal = Math.exp(Number(this.data[base + i]) - maxVal);
                exps[i] = expVal;
                expSum += expVal;
            }
            for (let i = 0; i < lastDim; i++) {
                data[base + i] = (exps[i] / expSum) as T;
            }
        }
        return new FaberTensor<T>(data as T[], this.shape);
    }
}

(() => {
    {
        const flat_a: Array<number> = [1, 2, 3, 4, 5, 6];
        const flat_b: Array<number> = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
        const seed: FaberTensor<number> = FaberTensor.empty<number>([]);
        const a: FaberTensor<number> = seed.strue(flat_a, [2, 3]);
        const b: FaberTensor<number> = seed.strue(flat_b, [3, 4]);
        const product: FaberTensor<number> = a.matmul(b);
        const mean: number = product.media();
        console.log(__faberDisplay(((x: number): string => { const v = Math.fround(x); if (!Number.isFinite(v)) { return __faberDisplay(v, "fractus"); } let e = v.toExponential(); for (let p = 0; p < 9; p++) { e = v.toExponential(p); if (Math.fround(Number(e)) === v) { break; } } const m = /^(-?)(\d)(?:\.(\d+))?e([+-]\d+)$/.exec(e) as RegExpExecArray; const sign = Object.is(v, -0) ? "-" : m[1]; const digits = m[2] + (m[3] ?? ""); const n = Number(m[4]); let body: string; if (n < 0) { body = "0." + "0".repeat(-n - 1) + digits; } else if (digits.length <= n + 1) { body = digits + "0".repeat(n + 1 - digits.length) + ".0"; } else { body = digits.slice(0, n + 1) + "." + digits.slice(n + 1); } return sign + body; })(mean), "textus"));
    }})();

The error channel#

A function that may fail, and a caller that catches. Shows how the ⇥ channel becomes each target's own error idiom.

Faber source

fn divide(int a, int b) → int ⇥ string {
    if b ≡ 0 {
        throw "division by zero"
    }
    return a / b
}

main {
    do {
        print divide(10, 2)
    }
    catch err {
        warn err
    }
}

functio divide(numerus a, numerus b) → numerus ⇥ textus {
    si b ≡ 0 {
        iace "division by zero"
    }
    redde a / b
}

incipit {
    fac {
        nota divide(10, 2)
    }
    cape err {
        mone err
    }
}

ฟังก์ชัน divide(จำนวน a, จำนวน b) → จำนวน ⇥ ข้อความ {
    ถ้า b ≡ 0 {
        โยน "division by zero"
    }
    คืน a / b
}

เริ่ม {
    ทำ {
        บันทึก divide(10, 2)
    }
    จับ err {
        เตือน err
    }
}

函数 divide(整数 a, 整数 b) → 整数 ⇥ 文本 {
    如果 b ≡ 0 {
        抛错 "division by zero"
    }
    返回 a / b
}

入口 {
    执行 {
        显示 divide(10, 2)
    }
    捕获 err {
        警告 err
    }
}

函式 divide(整數 a, 整數 b) → 整數 ⇥ 文字 {
    若 b ≡ 0 {
        拋出 "division by zero"
    }
    傳回 a / b
}

入口 {
    執行 {
        註記 divide(10, 2)
    }
    捕捉 err {
        警告 err
    }
}

hàm divide(số a, số b) → số ⇥ văn_bản {
    nếu b ≡ 0 {
        ném "division by zero"
    }
    trả a / b
}

bắt_đầu {
    làm {
        ghi_chú divide(10, 2)
    }
    bắt err {
        cảnh_báo err
    }
}

دالة divide(عدد a, عدد b) → عدد ⇥ نص {
    إذا b ≡ 0 {
        ارم "division by zero"
    }
    أعد a / b
}

بداية {
    افعل {
        اعرض divide(10, 2)
    }
    التقط err {
        نبه err
    }
}

फलन divide(संख्या a, संख्या b) → संख्या ⇥ पाठ {
    यदि b ≡ 0 {
        इधरफेंको "division by zero"
    }
    लौटाओ a / b
}

आरंभ {
    करो {
        दिखाओ divide(10, 2)
    }
    पकड़ो err {
        चेताओ err
    }
}

TypeScript — 13 lines in, 59 out (4.5×)

// Generated by radix - do not edit

import { __faberDisplay } from "@faber/runtime";

type FaberResult<T, E> = { ok: true; value: T } | { ok: false; error: E };

declare global {
    interface Number {
        potentia(exponent: number): number;
    }
}
Number.prototype.potentia = function(this: Number, exponent: number): number {
    return Math.pow(this.valueOf(), exponent);
};

function __faberXChk(v: number): number { if (v > 9007199254740991 || v < -9007199254740991) { throw new Error("numerus overflow"); } return v + 0; }
function __faberXAdd(a: number, b: number): number { return __faberXChk(a + b); }
function __faberXSub(a: number, b: number): number { return __faberXChk(a - b); }
function __faberXMul(a: number, b: number): number { return __faberXChk(a * b); }
function __faberXDiv(a: number, b: number): number { if (b === 0) { throw new Error("numerus division failed"); } const r = a % b; const q = (a - r) / b; return __faberXChk(r !== 0 && (r < 0) !== (b < 0) ? q - 1 : q); }
function __faberXMod(a: number, b: number): number { if (b === 0) { throw new Error("numerus division failed"); } const r = a % b; return (r !== 0 && (r < 0) !== (b < 0) ? r + b : r) + 0; }
function __faberXShl(a: number, n: number): number { if (n < 0) { throw new Error("negative shift count"); } if (a === 0) { return 0; } if (n > 62) { throw new Error("numerus overflow"); } return __faberXChk(a * Math.pow(2, n)); }
function __faberXShr(a: number, n: number): number { if (n < 0) { throw new Error("negative shift count"); } if (n > 62) { return a < 0 ? -1 : 0; } return Math.floor(a / Math.pow(2, n)) + 0; }
function __faberFRem(a: number, b: number): number { const r = a % b; return r === 0 ? (b < 0 ? -0 : 0) : (r < 0) !== (b < 0) ? r + b : r; }
function __faberXNeg(a: number): number { return __faberXChk(-a); }
function __faberXNot(a: number): number { return __faberXChk(-a - 1); }
function __faberXAbs(a: number): number { return __faberXChk(Math.abs(a)); }
function __faberXPow(base: number, exponent: number): number { if (exponent < 0) { throw new Error("numerus potentia failed: negative exponent"); } let accumulator = 1; let b = base; let e = exponent; while (e > 0) { if (e % 2 !== 0) { accumulator = __faberXMul(accumulator, b); } e = Math.floor(e / 2); if (e > 0) { b = __faberXMul(b, b); } } return accumulator; }
function __faberXHi(a: number): number { return Math.floor(__faberXChk(a) / 4294967296); }
function __faberXLo(a: number): number { return a - __faberXHi(a) * 4294967296; }
function __faberXJoin(hi: number, lo: number): number { return __faberXChk(hi * 4294967296 + (lo >>> 0)); }
function __faberXAnd(a: number, b: number): number { return __faberXJoin(__faberXHi(a) & __faberXHi(b), __faberXLo(a) & __faberXLo(b)); }
function __faberXOr(a: number, b: number): number { return __faberXJoin(__faberXHi(a) | __faberXHi(b), __faberXLo(a) | __faberXLo(b)); }
function __faberXXor(a: number, b: number): number { return __faberXJoin(__faberXHi(a) ^ __faberXHi(b), __faberXLo(a) ^ __faberXLo(b)); }
function __faberXStore(v: number, lo: number, hi: number, ty: string, pos: string, extra: string): number { if (v < lo || v > hi) { throw new Error(String(v) + " does not fit in `" + ty + "` (" + pos + ")" + extra + (lo === 0 && v < 0 ? " (a negative value cannot be stored in an unsigned slot)" : "")); } return v + 0; }
function __faberXClamp(v: number, lo: number, hi: number): number { return v < lo ? lo : v > hi ? hi : v + 0; }
function __faberXWrap(v: number, bits: number, signed: boolean): number { const m = Math.pow(2, bits); let r = v % m; if (r < 0) { r += m; } if (signed && r >= m / 2) { r -= m; } return r + 0; }
function __faberXTrueDiv(a: number, b: number): number { if (b === 0) { throw new Error("numerus division failed"); } return a / b; }
function __faberXTrueDivF32(a: number, b: number): number { if (b === 0) { throw new Error("numerus division failed"); } return Math.fround(a / b); }

function divide(a: number, b: number): FaberResult<number, string> {
    if (((b as number) === (0 as number))) {
        return { ok: false as const, error: "division by zero" };
    }
    return (() => { try { return { ok: true as const, value: __faberXStore(__faberXDiv(a, b), -9007199254740991, 9007199254740991, "i64", "return", "") }; } catch (__e) { return { ok: false as const, error: (__e instanceof Error ? __e.message : String(__e)) }; } })();
    return { ok: true as const, value: 0 };
}
(() => {
    {
        const t24 = (() => { try { while (true) {
            console.log(__faberDisplay((<T>(r: FaberResult<T, any>): T => { if (!r.ok) { throw { __faberFail: true, error: r.error }; } return r.value; })(divide(10, 2)), "numerus"));
             break;
        }return { ok: true as const, value: undefined }; } catch (__e: any) { if (__e !== null && typeof __e === "object" && __e.__faberFail === true) { return { ok: false as const, error: __e.error }; } throw __e; } })() as FaberResult<any, string>;
        if (!t24.ok) {
            const err = t24.error;
            {
                console.warn(__faberDisplay(err, "textus"));
            }}
    }})();

Collections and iteration#

A list folded to a total with for from. The plainest possible read on how loops lower.

Faber source

fn sum(list<int> numeri) → int {
    var int total ← 0
    for from numeri const n {
        total ← total + n
    }
    return total
}

main {
    const list<int> valores ← [1, 2, 3, 4, 5]
    print sum(valores)
}

TypeScript — 12 lines in, 51 out (4.2×)

// Generated by radix - do not edit

import { __faberDisplay } from "@faber/runtime";

declare global {
    interface Number {
        potentia(exponent: number): number;
    }
}
Number.prototype.potentia = function(this: Number, exponent: number): number {
    return Math.pow(this.valueOf(), exponent);
};

function __faberXChk(v: number): number { if (v > 9007199254740991 || v < -9007199254740991) { throw new Error("numerus overflow"); } return v + 0; }
function __faberXAdd(a: number, b: number): number { return __faberXChk(a + b); }
function __faberXSub(a: number, b: number): number { return __faberXChk(a - b); }
function __faberXMul(a: number, b: number): number { return __faberXChk(a * b); }
function __faberXDiv(a: number, b: number): number { if (b === 0) { throw new Error("numerus division failed"); } const r = a % b; const q = (a - r) / b; return __faberXChk(r !== 0 && (r < 0) !== (b < 0) ? q - 1 : q); }
function __faberXMod(a: number, b: number): number { if (b === 0) { throw new Error("numerus division failed"); } const r = a % b; return (r !== 0 && (r < 0) !== (b < 0) ? r + b : r) + 0; }
function __faberXShl(a: number, n: number): number { if (n < 0) { throw new Error("negative shift count"); } if (a === 0) { return 0; } if (n > 62) { throw new Error("numerus overflow"); } return __faberXChk(a * Math.pow(2, n)); }
function __faberXShr(a: number, n: number): number { if (n < 0) { throw new Error("negative shift count"); } if (n > 62) { return a < 0 ? -1 : 0; } return Math.floor(a / Math.pow(2, n)) + 0; }
function __faberFRem(a: number, b: number): number { const r = a % b; return r === 0 ? (b < 0 ? -0 : 0) : (r < 0) !== (b < 0) ? r + b : r; }
function __faberXNeg(a: number): number { return __faberXChk(-a); }
function __faberXNot(a: number): number { return __faberXChk(-a - 1); }
function __faberXAbs(a: number): number { return __faberXChk(Math.abs(a)); }
function __faberXPow(base: number, exponent: number): number { if (exponent < 0) { throw new Error("numerus potentia failed: negative exponent"); } let accumulator = 1; let b = base; let e = exponent; while (e > 0) { if (e % 2 !== 0) { accumulator = __faberXMul(accumulator, b); } e = Math.floor(e / 2); if (e > 0) { b = __faberXMul(b, b); } } return accumulator; }
function __faberXHi(a: number): number { return Math.floor(__faberXChk(a) / 4294967296); }
function __faberXLo(a: number): number { return a - __faberXHi(a) * 4294967296; }
function __faberXJoin(hi: number, lo: number): number { return __faberXChk(hi * 4294967296 + (lo >>> 0)); }
function __faberXAnd(a: number, b: number): number { return __faberXJoin(__faberXHi(a) & __faberXHi(b), __faberXLo(a) & __faberXLo(b)); }
function __faberXOr(a: number, b: number): number { return __faberXJoin(__faberXHi(a) | __faberXHi(b), __faberXLo(a) | __faberXLo(b)); }
function __faberXXor(a: number, b: number): number { return __faberXJoin(__faberXHi(a) ^ __faberXHi(b), __faberXLo(a) ^ __faberXLo(b)); }
function __faberXStore(v: number, lo: number, hi: number, ty: string, pos: string, extra: string): number { if (v < lo || v > hi) { throw new Error(String(v) + " does not fit in `" + ty + "` (" + pos + ")" + extra + (lo === 0 && v < 0 ? " (a negative value cannot be stored in an unsigned slot)" : "")); } return v + 0; }
function __faberXClamp(v: number, lo: number, hi: number): number { return v < lo ? lo : v > hi ? hi : v + 0; }
function __faberXWrap(v: number, bits: number, signed: boolean): number { const m = Math.pow(2, bits); let r = v % m; if (r < 0) { r += m; } if (signed && r >= m / 2) { r -= m; } return r + 0; }
function __faberXTrueDiv(a: number, b: number): number { if (b === 0) { throw new Error("numerus division failed"); } return a / b; }
function __faberXTrueDivF32(a: number, b: number): number { if (b === 0) { throw new Error("numerus division failed"); } return Math.fround(a / b); }

function sum(numeri: Array<number>): number {
    let total: number = 0;
    for (const n of numeri) {
        total = __faberXStore(__faberXAdd(total, n), -9007199254740991, 9007199254740991, "i64", "assignment to `total`", "");
    }
    return total;
    return 0;
}
(() => {
    {
        const valores: Array<number> = [1, 2, 3, 4, 5];
        console.log(__faberDisplay(sum(valores), "numerus"));
    }})();

---

All targets · Measured support per term