Go

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#

Go has no generics-free way to express some Faber types, so the emitter materialises helpers the source never wrote. Borrow modes (ref / mut / from) erase here — they lower, but they do not survive as distinctions.

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.

Not fully supported#

Terms the matrix records as partial, planned, or unsupported for this target. A term here is a measured gap, not an omission.

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
}

Go — 10 lines in, 221 out (22.1×)

// Generated by radix - do not edit

package main

import (
    "fmt"
    "strconv"
    "strings"
)

type faberTensor[T any] struct {
    data []T
    shape []int
}

func faberTensorElementCount(shape []int) int {
    const maxInt = int(^uint(0) >> 1)
    total := 1
    for _, dim := range shape {
        if dim < 0 { panic("tensor shape dimension must be non-negative") }
        if dim > 0 && total > maxInt/dim { panic("tensor shape element count overflow") }
        total *= dim
    }
    return total
}

func faberIndexSlice(indices any) []int {
    switch values := indices.(type) {
        case []int:
            return append([]int{}, values...)
        case []uint32:
            out := make([]int, len(values)); for i, value := range values { out[i] = int(value) }; return out
        case []uint64:
            out := make([]int, len(values)); for i, value := range values { out[i] = int(value) }; return out
        case []int32:
            out := make([]int, len(values)); for i, value := range values { out[i] = int(value) }; return out
        case []int64:
            out := make([]int, len(values)); for i, value := range values { out[i] = int(value) }; return out
        default:
            panic("tensor index must be a numeric list")
    }
}

func faberTensorOffset(shape []int, rawIndices any) *int {
    const maxInt = int(^uint(0) >> 1)
    indices := faberIndexSlice(rawIndices)
    if len(indices) != len(shape) { return nil }
    offset := 0
    stride := 1
    for axis := len(shape) - 1; axis >= 0; axis-- {
        idx := indices[axis]
        dim := shape[axis]
        if dim < 0 || idx < 0 || idx >= dim { return nil }
        if idx > 0 && stride > (maxInt-offset)/idx { return nil }
        offset += idx * stride
        if dim > 0 && stride > maxInt/dim { return nil }
        stride *= dim
    }
    return &offset
}

func (t faberTensor[T]) Crea(fill T, shape []int) faberTensor[T] {
    data := make([]T, faberTensorElementCount(shape))
    for i := range data { data[i] = fill }
    return faberTensor[T]{data: data, shape: append([]int{}, shape...)}
}

func (t faberTensor[T]) Strue(data []T, shape []int) faberTensor[T] {
    if faberTensorElementCount(shape) != len(data) { panic("tensor structa element count does not match shape") }
    return faberTensor[T]{data: append([]T{}, data...), shape: append([]int{}, shape...)}
}

func (t faberTensor[T]) Longitudo() int { return len(t.shape) }
func (t faberTensor[T]) Magnitudines() []int { return append([]int{}, t.shape...) }
func (t faberTensor[T]) Planata() []T { return append([]T{}, t.data...) }
func (t faberTensor[T]) Materialize() faberTensor[T] { return faberTensor[T]{data: append([]T{}, t.data...), shape: append([]int{}, t.shape...)} }

func faberTensorAdd[T any](left T, right T) T {
    switch value := any(left).(type) {
        case int: return any(value + any(right).(int)).(T)
        case int32: return any(value + any(right).(int32)).(T)
        case int64: return any(value + any(right).(int64)).(T)
        case uint: return any(value + any(right).(uint)).(T)
        case uint32: return any(value + any(right).(uint32)).(T)
        case uint64: return any(value + any(right).(uint64)).(T)
        case float32: return any(value + any(right).(float32)).(T)
        case float64: return any(value + any(right).(float64)).(T)
        default: panic("tensor arithmetic requires numeric elements")
    }
}

func faberTensorMul[T any](left T, right T) T {
    switch value := any(left).(type) {
        case int: return any(value * any(right).(int)).(T)
        case int32: return any(value * any(right).(int32)).(T)
        case int64: return any(value * any(right).(int64)).(T)
        case uint: return any(value * any(right).(uint)).(T)
        case uint32: return any(value * any(right).(uint32)).(T)
        case uint64: return any(value * any(right).(uint64)).(T)
        case float32: return any(value * any(right).(float32)).(T)
        case float64: return any(value * any(right).(float64)).(T)
        default: panic("tensor arithmetic requires numeric elements")
    }
}

func faberTensorSub[T any](left T, right T) T {
    switch value := any(left).(type) {
        case int: return any(value - any(right).(int)).(T)
        case int32: return any(value - any(right).(int32)).(T)
        case int64: return any(value - any(right).(int64)).(T)
        case uint: return any(value - any(right).(uint)).(T)
        case uint32: return any(value - any(right).(uint32)).(T)
        case uint64: return any(value - any(right).(uint64)).(T)
        case float32: return any(value - any(right).(float32)).(T)
        case float64: return any(value - any(right).(float64)).(T)
        default: panic("tensor arithmetic requires numeric elements")
    }
}

func faberTensorShapeEqual(left []int, right []int) bool {
    if len(left) != len(right) { return false }
    for i, dim := range left { if dim != right[i] { return false } }
    return true
}

func faberTensorMean[T any](data []T) T {
    if len(data) == 0 { panic("tensor media requires non-empty data") }
    switch any(data[0]).(type) {
        case float32:
            var total float32
            for _, value := range data { total += any(value).(float32) }
            return any(total / float32(len(data))).(T)
        case float64:
            var total float64
            for _, value := range data { total += any(value).(float64) }
            return any(total / float64(len(data))).(T)
        default: panic("tensor media requires floating-point elements")
    }
}

func (t faberTensor[T]) Summa() T {
    var total T
    for _, value := range t.data { total = faberTensorAdd(total, value) }
    return total
}

func (t faberTensor[T]) Media() T { return faberTensorMean(t.data) }

func (a faberTensor[T]) Addita(b faberTensor[T]) faberTensor[T] {
    if !faberTensorShapeEqual(a.shape, b.shape) { panic("tensor elementwise arithmetic requires equal shapes") }
    data := make([]T, len(a.data))
    for i := range data { data[i] = faberTensorAdd(a.data[i], b.data[i]) }
    return faberTensor[T]{data: data, shape: append([]int{}, a.shape...)}
}

func (a faberTensor[T]) Subtrahe(b faberTensor[T]) faberTensor[T] {
    if !faberTensorShapeEqual(a.shape, b.shape) { panic("tensor elementwise arithmetic requires equal shapes") }
    data := make([]T, len(a.data))
    for i := range data { data[i] = faberTensorSub(a.data[i], b.data[i]) }
    return faberTensor[T]{data: data, shape: append([]int{}, a.shape...)}
}

func (a faberTensor[T]) Multiplica(b faberTensor[T]) faberTensor[T] {
    if !faberTensorShapeEqual(a.shape, b.shape) { panic("tensor elementwise arithmetic requires equal shapes") }
    data := make([]T, len(a.data))
    for i := range data { data[i] = faberTensorMul(a.data[i], b.data[i]) }
    return faberTensor[T]{data: data, shape: append([]int{}, a.shape...)}
}

func (a faberTensor[T]) Matmul(b faberTensor[T]) faberTensor[T] {
    if len(a.shape) != 2 || len(b.shape) != 2 || a.shape[1] != b.shape[0] { panic("tensor matmul requires compatible rank-2 shapes") }
    rows, inner, cols := a.shape[0], a.shape[1], b.shape[1]
    data := make([]T, rows*cols)
    for row := 0; row < rows; row++ {
        for col := 0; col < cols; col++ {
            var sum T
            for k := 0; k < inner; k++ { sum = faberTensorAdd(sum, faberTensorMul(a.data[row*inner+k], b.data[k*cols+col])) }
            data[row*cols+col] = sum
        }
    }
    return faberTensor[T]{data: data, shape: []int{rows, cols}}
}

func (t faberTensor[T]) Forma(shape []int) faberTensor[T] {
    if faberTensorElementCount(shape) != len(t.data) { panic("tensor forma (reshape) element count mismatch") }
    return faberTensor[T]{data: append([]T{}, t.data...), shape: append([]int{}, shape...)}
}

func (t faberTensor[T]) Accipe(indices any) *T {
    offset := faberTensorOffset(t.shape, indices)
    if offset == nil || *offset < 0 || *offset >= len(t.data) { return nil }
    return &t.data[*offset]
}

func (t *faberTensor[T]) Ponde(indices any, value T) {
    offset := faberTensorOffset(t.shape, indices)
    if offset == nil || *offset < 0 || *offset >= len(t.data) { panic("tensor ponde invalid index") }
    t.data[*offset] = value
}

func (t *faberTensor[T]) Reple(value T) {
    for i := range t.data { t.data[i] = value }
}

func (t faberTensor[T]) Sectio(start int, end int) faberTensor[T] {
    if len(t.shape) == 0 || start < 0 || end < start || end > t.shape[0] { panic("tensor sectio invalid slice bounds") }
    inner := faberTensorElementCount(t.shape[1:])
    shape := append([]int{end - start}, t.shape[1:]...)
    return faberTensor[T]{data: append([]T{}, t.data[start*inner:end*inner]...), shape: shape}
}

func main() {
    flat_a := []float32{float32(1.0), float32(2.0), float32(3.0), float32(4.0), float32(5.0), float32(6.0)}
    flat_b := []float32{float32(1.0), float32(2.0), float32(3.0), float32(4.0), float32(5.0), float32(6.0), float32(7.0), float32(8.0), float32(9.0), float32(10.0), float32(11.0), float32(12.0)}
    seed := faberTensor[float32]{}.Crea(*new(float32), []int{})
    a := seed.Strue(flat_a, []any{2, 3})
    b := seed.Strue(flat_b, []any{3, 4})
    product := a.Matmul(b)
    mean := float32(product.Media())
    fmt.Println(func(v float32) string { s := strconv.FormatFloat(float64(v), 'f', -1, 32); if s == "NaN" { return s }; if s == "+Inf" { return "inf" }; if s == "-Inf" { return "-inf" }; if !strings.Contains(s, ".") { return s + ".0" }; return s }(float32(mean)))
}

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
    }
}

Go — 13 lines in, 356 out (27.4×)

// Generated by radix - do not edit

package main

import (
    "errors"
    "fmt"
    "math"
    "math/bits"
    "os"
    "strconv"
)

type faberX struct {
	neg bool
	m   uint64
}

func faberXMk(neg bool, m uint64) faberX {
	if m == 0 {
		return faberX{}
	}
	if neg && m > 1<<63 {
		panic("numerus overflow")
	}
	return faberX{neg, m}
}

func faberXI(v int64) faberX {
	if v < 0 {
		return faberX{true, -uint64(v)}
	}
	return faberX{false, uint64(v)}
}

func faberXU(v uint64) faberX { return faberX{false, v} }

func faberXNeg(a faberX) faberX { return faberXMk(!a.neg, a.m) }

func faberXAddS(a faberX, bneg bool, bm uint64) faberX {
	if a.neg == bneg {
		s, c := bits.Add64(a.m, bm, 0)
		if c != 0 {
			panic("numerus overflow")
		}
		return faberXMk(a.neg, s)
	}
	if a.m >= bm {
		return faberXMk(a.neg, a.m-bm)
	}
	return faberXMk(bneg, bm-a.m)
}

func faberXAdd(a faberX, b faberX) faberX { return faberXAddS(a, b.neg, b.m) }

func faberXSub(a faberX, b faberX) faberX { return faberXAddS(a, !b.neg, b.m) }

func faberXMul(a faberX, b faberX) faberX {
	hi, lo := bits.Mul64(a.m, b.m)
	if hi != 0 {
		panic("numerus overflow")
	}
	return faberXMk(a.neg != b.neg, lo)
}

func faberXDiv(a faberX, b faberX) faberX {
	if b.m == 0 {
		panic("numerus division failed")
	}
	q, r := a.m/b.m, a.m%b.m
	if a.neg == b.neg {
		return faberXMk(false, q)
	}
	if r != 0 {
		q++
	}
	return faberXMk(true, q)
}

func faberXMod(a faberX, b faberX) faberX {
	if b.m == 0 {
		panic("numerus division failed")
	}
	r := a.m % b.m
	if r != 0 && a.neg != b.neg {
		r = b.m - r
	}
	return faberXMk(b.neg, r)
}

func faberXShl(a faberX, n faberX) faberX {
	if n.neg {
		panic("negative shift count")
	}
	if a.m == 0 {
		return faberX{}
	}
	if n.m > 64 || uint64(bits.LeadingZeros64(a.m)) < n.m {
		panic("numerus overflow")
	}
	return faberXMk(a.neg, a.m<<n.m)
}

func faberXShr(a faberX, n faberX) faberX {
	if n.neg {
		panic("negative shift count")
	}
	if n.m >= 64 {
		if a.neg {
			return faberX{true, 1}
		}
		return faberX{}
	}
	m := a.m >> n.m
	if a.neg && a.m&(1<<n.m-1) != 0 {
		m++
	}
	return faberXMk(a.neg, m)
}

func faberXW(a faberX) (uint64, uint64) {
	if !a.neg {
		return 0, a.m
	}
	return ^uint64(0), -a.m
}

func faberXFromW(hi uint64, lo uint64) faberX {
	if hi == 0 {
		return faberX{false, lo}
	}
	if hi == ^uint64(0) && lo>>63 == 1 {
		return faberXMk(true, -lo)
	}
	panic("numerus overflow")
}

func faberXAnd(a faberX, b faberX) faberX {
	ah, al := faberXW(a)
	bh, bl := faberXW(b)
	return faberXFromW(ah&bh, al&bl)
}

func faberXOr(a faberX, b faberX) faberX {
	ah, al := faberXW(a)
	bh, bl := faberXW(b)
	return faberXFromW(ah|bh, al|bl)
}

func faberXXor(a faberX, b faberX) faberX {
	ah, al := faberXW(a)
	bh, bl := faberXW(b)
	return faberXFromW(ah^bh, al^bl)
}

func faberXNot(a faberX) faberX { return faberXSub(faberXNeg(a), faberXU(1)) }

func faberXAbs(a faberX) faberX { return faberXMk(false, a.m) }

func faberXPow(base faberX, exponent faberX) faberX {
	if exponent.neg {
		panic("numerus potentia failed: negative exponent")
	}
	accumulator := faberXU(1)
	for !exponent.neg && exponent.m > 0 {
		if exponent.m%2 != 0 {
			accumulator = faberXMul(accumulator, base)
		}
		exponent = faberXU(exponent.m / 2)
		if exponent.m > 0 {
			base = faberXMul(base, base)
		}
	}
	return accumulator
}

func faberXCmp(a faberX, b faberX) int {
	if a.neg != b.neg {
		if a.neg {
			return -1
		}
		return 1
	}
	c := 0
	if a.m < b.m {
		c = -1
	} else if a.m > b.m {
		c = 1
	}
	if a.neg {
		return -c
	}
	return c
}

// faberXApprox is `≈` on integers: 10^9 * |a - b| <= max(|a|, |b|), exactly.
// |a - b| reaches 2^64 + 2^63, so the scaled distance is a 128-bit value.
func faberXApprox(a faberX, b faberX) bool {
	var hi, lo uint64
	if a.neg == b.neg {
		lo = a.m - b.m
		if a.m < b.m {
			lo = b.m - a.m
		}
	} else {
		lo, hi = bits.Add64(a.m, b.m, 0)
	}
	mulHi, mulLo := bits.Mul64(lo, 1000000000)
	if hi*1000000000+mulHi != 0 {
		return false
	}
	limit := a.m
	if b.m > limit {
		limit = b.m
	}
	return mulLo <= limit
}

func faberXCmpF(a faberX, f float64) (int, bool) {
	if f != f {
		return 0, false
	}
	if f >= 18446744073709551616.0 {
		return -1, true
	}
	if f < -9223372036854775808.0 {
		return 1, true
	}
	w := math.Trunc(f)
	wx := faberX{false, uint64(w)}
	if w < 0 {
		wx = faberX{true, uint64(-w)}
	}
	if c := faberXCmp(a, wx); c != 0 {
		return c, true
	}
	fr := f - w
	if fr > 0 {
		return -1, true
	}
	if fr < 0 {
		return 1, true
	}
	return 0, true
}

func faberXLtF(a faberX, f float64) bool { c, ok := faberXCmpF(a, f); return ok && c < 0 }

func faberXLeF(a faberX, f float64) bool { c, ok := faberXCmpF(a, f); return ok && c <= 0 }

func faberXGtF(a faberX, f float64) bool { c, ok := faberXCmpF(a, f); return ok && c > 0 }

func faberXGeF(a faberX, f float64) bool { c, ok := faberXCmpF(a, f); return ok && c >= 0 }

func faberXEqF(a faberX, f float64) bool { c, ok := faberXCmpF(a, f); return ok && c == 0 }

func faberXStr(a faberX) string {
	s := strconv.FormatUint(a.m, 10)
	if a.neg {
		return "-" + s
	}
	return s
}

func faberXTrap(a faberX, ty string, pos string, extra string, unsigned bool) {
	msg := faberXStr(a) + " does not fit in `" + ty + "` (" + pos + ")" + extra
	if unsigned && a.neg {
		msg += " (a negative value cannot be stored in an unsigned slot)"
	}
	panic(msg)
}

func faberXFloat(a faberX) float64 {
	f := float64(a.m)
	if a.neg {
		return -f
	}
	return f
}

func faberXFitsI(a faberX, lo int64, hi int64) bool {
	return (!a.neg && a.m <= uint64(hi)) || (a.neg && a.m <= -uint64(lo))
}

func faberXFitsU(a faberX, hi uint64) bool { return !a.neg && a.m <= hi }

func faberXStoreI(a faberX, lo int64, hi int64, ty string, pos string, extra string) int64 {
	if !a.neg && a.m <= uint64(hi) {
		return int64(a.m)
	}
	if a.neg && a.m <= -uint64(lo) {
		return -int64(a.m)
	}
	faberXTrap(a, ty, pos, extra, false)
	return 0
}

func faberXStoreU(a faberX, hi uint64, ty string, pos string, extra string) uint64 {
	if !a.neg && a.m <= hi {
		return a.m
	}
	faberXTrap(a, ty, pos, extra, true)
	return 0
}

func faberXWrap(a faberX) uint64 {
	if a.neg {
		return -a.m
	}
	return a.m
}

func faberXClampI(a faberX, lo int64, hi int64) int64 {
	if a.neg {
		if a.m > -uint64(lo) {
			return lo
		}
		return -int64(a.m)
	}
	if a.m > uint64(hi) {
		return hi
	}
	return int64(a.m)
}

func faberXClampU(a faberX, hi uint64) uint64 {
	if a.neg {
		return 0
	}
	if a.m > hi {
		return hi
	}
	return a.m
}

func divide(a int, b int) (int, error) {
    if (b == 0) {
        return 0, errors.New("division by zero")
    }
    return int(faberXStoreI(faberXDiv(faberXI(int64(a)), faberXI(int64(b))), -9223372036854775808, 9223372036854775807, "i64", "return", "")), nil
}

func main() {
    faberErr0 := func() error {
        faberVal1, faberErr1 := divide(10, 2)
        if faberErr1 != nil {
            return faberErr1
        }
        fmt.Println(faberVal1)
        return nil
    }()
    if faberErr0 != nil {
        err := faberErr0
        fmt.Fprintln(os.Stderr, err)
    }
}

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)
}

Go — 12 lines in, 345 out (28.8×)

// Generated by radix - do not edit

package main

import (
    "fmt"
    "math"
    "math/bits"
    "strconv"
)

type faberX struct {
	neg bool
	m   uint64
}

func faberXMk(neg bool, m uint64) faberX {
	if m == 0 {
		return faberX{}
	}
	if neg && m > 1<<63 {
		panic("numerus overflow")
	}
	return faberX{neg, m}
}

func faberXI(v int64) faberX {
	if v < 0 {
		return faberX{true, -uint64(v)}
	}
	return faberX{false, uint64(v)}
}

func faberXU(v uint64) faberX { return faberX{false, v} }

func faberXNeg(a faberX) faberX { return faberXMk(!a.neg, a.m) }

func faberXAddS(a faberX, bneg bool, bm uint64) faberX {
	if a.neg == bneg {
		s, c := bits.Add64(a.m, bm, 0)
		if c != 0 {
			panic("numerus overflow")
		}
		return faberXMk(a.neg, s)
	}
	if a.m >= bm {
		return faberXMk(a.neg, a.m-bm)
	}
	return faberXMk(bneg, bm-a.m)
}

func faberXAdd(a faberX, b faberX) faberX { return faberXAddS(a, b.neg, b.m) }

func faberXSub(a faberX, b faberX) faberX { return faberXAddS(a, !b.neg, b.m) }

func faberXMul(a faberX, b faberX) faberX {
	hi, lo := bits.Mul64(a.m, b.m)
	if hi != 0 {
		panic("numerus overflow")
	}
	return faberXMk(a.neg != b.neg, lo)
}

func faberXDiv(a faberX, b faberX) faberX {
	if b.m == 0 {
		panic("numerus division failed")
	}
	q, r := a.m/b.m, a.m%b.m
	if a.neg == b.neg {
		return faberXMk(false, q)
	}
	if r != 0 {
		q++
	}
	return faberXMk(true, q)
}

func faberXMod(a faberX, b faberX) faberX {
	if b.m == 0 {
		panic("numerus division failed")
	}
	r := a.m % b.m
	if r != 0 && a.neg != b.neg {
		r = b.m - r
	}
	return faberXMk(b.neg, r)
}

func faberXShl(a faberX, n faberX) faberX {
	if n.neg {
		panic("negative shift count")
	}
	if a.m == 0 {
		return faberX{}
	}
	if n.m > 64 || uint64(bits.LeadingZeros64(a.m)) < n.m {
		panic("numerus overflow")
	}
	return faberXMk(a.neg, a.m<<n.m)
}

func faberXShr(a faberX, n faberX) faberX {
	if n.neg {
		panic("negative shift count")
	}
	if n.m >= 64 {
		if a.neg {
			return faberX{true, 1}
		}
		return faberX{}
	}
	m := a.m >> n.m
	if a.neg && a.m&(1<<n.m-1) != 0 {
		m++
	}
	return faberXMk(a.neg, m)
}

func faberXW(a faberX) (uint64, uint64) {
	if !a.neg {
		return 0, a.m
	}
	return ^uint64(0), -a.m
}

func faberXFromW(hi uint64, lo uint64) faberX {
	if hi == 0 {
		return faberX{false, lo}
	}
	if hi == ^uint64(0) && lo>>63 == 1 {
		return faberXMk(true, -lo)
	}
	panic("numerus overflow")
}

func faberXAnd(a faberX, b faberX) faberX {
	ah, al := faberXW(a)
	bh, bl := faberXW(b)
	return faberXFromW(ah&bh, al&bl)
}

func faberXOr(a faberX, b faberX) faberX {
	ah, al := faberXW(a)
	bh, bl := faberXW(b)
	return faberXFromW(ah|bh, al|bl)
}

func faberXXor(a faberX, b faberX) faberX {
	ah, al := faberXW(a)
	bh, bl := faberXW(b)
	return faberXFromW(ah^bh, al^bl)
}

func faberXNot(a faberX) faberX { return faberXSub(faberXNeg(a), faberXU(1)) }

func faberXAbs(a faberX) faberX { return faberXMk(false, a.m) }

func faberXPow(base faberX, exponent faberX) faberX {
	if exponent.neg {
		panic("numerus potentia failed: negative exponent")
	}
	accumulator := faberXU(1)
	for !exponent.neg && exponent.m > 0 {
		if exponent.m%2 != 0 {
			accumulator = faberXMul(accumulator, base)
		}
		exponent = faberXU(exponent.m / 2)
		if exponent.m > 0 {
			base = faberXMul(base, base)
		}
	}
	return accumulator
}

func faberXCmp(a faberX, b faberX) int {
	if a.neg != b.neg {
		if a.neg {
			return -1
		}
		return 1
	}
	c := 0
	if a.m < b.m {
		c = -1
	} else if a.m > b.m {
		c = 1
	}
	if a.neg {
		return -c
	}
	return c
}

// faberXApprox is `≈` on integers: 10^9 * |a - b| <= max(|a|, |b|), exactly.
// |a - b| reaches 2^64 + 2^63, so the scaled distance is a 128-bit value.
func faberXApprox(a faberX, b faberX) bool {
	var hi, lo uint64
	if a.neg == b.neg {
		lo = a.m - b.m
		if a.m < b.m {
			lo = b.m - a.m
		}
	} else {
		lo, hi = bits.Add64(a.m, b.m, 0)
	}
	mulHi, mulLo := bits.Mul64(lo, 1000000000)
	if hi*1000000000+mulHi != 0 {
		return false
	}
	limit := a.m
	if b.m > limit {
		limit = b.m
	}
	return mulLo <= limit
}

func faberXCmpF(a faberX, f float64) (int, bool) {
	if f != f {
		return 0, false
	}
	if f >= 18446744073709551616.0 {
		return -1, true
	}
	if f < -9223372036854775808.0 {
		return 1, true
	}
	w := math.Trunc(f)
	wx := faberX{false, uint64(w)}
	if w < 0 {
		wx = faberX{true, uint64(-w)}
	}
	if c := faberXCmp(a, wx); c != 0 {
		return c, true
	}
	fr := f - w
	if fr > 0 {
		return -1, true
	}
	if fr < 0 {
		return 1, true
	}
	return 0, true
}

func faberXLtF(a faberX, f float64) bool { c, ok := faberXCmpF(a, f); return ok && c < 0 }

func faberXLeF(a faberX, f float64) bool { c, ok := faberXCmpF(a, f); return ok && c <= 0 }

func faberXGtF(a faberX, f float64) bool { c, ok := faberXCmpF(a, f); return ok && c > 0 }

func faberXGeF(a faberX, f float64) bool { c, ok := faberXCmpF(a, f); return ok && c >= 0 }

func faberXEqF(a faberX, f float64) bool { c, ok := faberXCmpF(a, f); return ok && c == 0 }

func faberXStr(a faberX) string {
	s := strconv.FormatUint(a.m, 10)
	if a.neg {
		return "-" + s
	}
	return s
}

func faberXTrap(a faberX, ty string, pos string, extra string, unsigned bool) {
	msg := faberXStr(a) + " does not fit in `" + ty + "` (" + pos + ")" + extra
	if unsigned && a.neg {
		msg += " (a negative value cannot be stored in an unsigned slot)"
	}
	panic(msg)
}

func faberXFloat(a faberX) float64 {
	f := float64(a.m)
	if a.neg {
		return -f
	}
	return f
}

func faberXFitsI(a faberX, lo int64, hi int64) bool {
	return (!a.neg && a.m <= uint64(hi)) || (a.neg && a.m <= -uint64(lo))
}

func faberXFitsU(a faberX, hi uint64) bool { return !a.neg && a.m <= hi }

func faberXStoreI(a faberX, lo int64, hi int64, ty string, pos string, extra string) int64 {
	if !a.neg && a.m <= uint64(hi) {
		return int64(a.m)
	}
	if a.neg && a.m <= -uint64(lo) {
		return -int64(a.m)
	}
	faberXTrap(a, ty, pos, extra, false)
	return 0
}

func faberXStoreU(a faberX, hi uint64, ty string, pos string, extra string) uint64 {
	if !a.neg && a.m <= hi {
		return a.m
	}
	faberXTrap(a, ty, pos, extra, true)
	return 0
}

func faberXWrap(a faberX) uint64 {
	if a.neg {
		return -a.m
	}
	return a.m
}

func faberXClampI(a faberX, lo int64, hi int64) int64 {
	if a.neg {
		if a.m > -uint64(lo) {
			return lo
		}
		return -int64(a.m)
	}
	if a.m > uint64(hi) {
		return hi
	}
	return int64(a.m)
}

func faberXClampU(a faberX, hi uint64) uint64 {
	if a.neg {
		return 0
	}
	if a.m > hi {
		return hi
	}
	return a.m
}

func sum(numeri []int) int {
    total := 0
    for _, n := range numeri {
        total = int(faberXStoreI(faberXAdd(faberXI(int64(total)), faberXI(int64(n))), -9223372036854775808, 9223372036854775807, "i64", "assignment to `total`", ""))
    }
    return total
}

func main() {
    valores := []int{1, 2, 3, 4, 5}
    fmt.Println(sum(valores))
}

---

All targets · Measured support per term