Data types

Faber has a static, type-first type system. Every declaration places the type before the name: textus nomen, not nomen: textus. The type system covers scalar primitives, generic collections, sized numerics, tensors, and GPU-facing register types.

Primitive types

Sized numeric types

numerus and fractus have default widths (i64 and f64) and explicit width forms:

fixum numerus<i32> narrow ← 7 ∷ numerus<i32>
fixum numerus<u64> wide ← 255 ∷ numerus<u64>
fixum fractus<f32> single ← 1.5 ∷ fractus<f32>

Width sugar is available in type position: i8 … u64, f16, f32, f64 are equivalent to numerus<W> / fractus<W>.

Nullable types

Nullable values use the union syntax T ∪ nihil:

functio find(textus key) → numerus ∪ nihil {
    redde nihil
}

functio maybe() → textus ∪ nihil {
    redde nihil
}

There is no T? or Option<T> syntax in Faber. The union is explicit.

Type aliases

typus UserId = numerus

Generics

Functions, type aliases, genus, and implendum accept type parameters with <T> syntax:

functio identitas<T>(T valor) → T {
    redde valor
}

functio primum<T>(lista<T> res) → T ∪ nihil {
    redde res.primus()
}

Explicit call-site type arguments are supported:

functio identitas<T>(T valor) → T { redde valor }

fixum numerus value ← identitas<numerus>(7)

Collections

fixum lista<numerus> nums ← [1, 2, 3]
fixum tabula<textus, numerus> scores ← { "alice": 10, "bob": 20 }

Tensor types

tensor<T, Figura> is the dense fixed-shape container:

fixum tensor<fractus<f32>, []> scalar ← vacua
fixum tensor<numerus, [4]> vector ← [1, 2, 3, 4] ↦ tensor<numerus, [4]>
fixum numerus ∪ nihil first ← vector[0]

GPU core types

These are recognised by the systems lane for GPU and register work. Package targets that lack hardware support reject them:

functio half(f16 x) → f16 { redde x }

functio add(matrix<f32, [2, 2]> a, matrix<f32, [2, 2]> b) → matrix<f32, [2, 2]> {
    redde a.addita(b)
}

functio swap(atomic<i32> cell, i32 value) → i32 {
    redde cell.exchange(value)
}

Borrow markers on types

Borrow markers (de, in, ex) can appear on types in parameter positions to indicate how a value is passed:

# shared borrow — caller retains ownership
functio imprime(de textus label) → vacuum { }

# mutable borrow — caller lends mutable access
functio duplica(in numerus value) → vacuum { }

# move — caller gives up ownership
functio consume(ex textus buffer) → textus {
    redde buffer
}

Comparison policy