types

Sounio Type System

Primitives

i8, i16, i32, i64, u8, u16, u32, u64, f32, f64, bool, char

Fixed-Size Arrays

Arrays MUST have a compile-time size. No slices.

let arr: [i64; 4] = [1, 2, 3, 4]
var buf: [i64; 256] = [0; 256]     // fill with zeros
let combined = a ++ b               // concatenation

Vec (Growable)

let v: Vec<i32> = [1, 2, 3, 4]

For manual control, use stdlib IntVec / FloatVec with impl blocks.

Structs

struct Point { x: f64, y: f64 }
let p = Point { x: 1.0, y: 2.0 }

Enums

enum Color { Red, Green, Blue }
let c = Color::Red
match c {
    Color::Red => 10
    Color::Green => 20
    Color::Blue => 30
    _ => 0
}

Tuples

let pair = (42, true)
let (x, y) = (1, 2)      // destructuring

Function Types

fn square(x: i64) -> i64 { x * x }
let f: fn(i64) -> i64 = square
let result = f(7)  // 49

fn apply(f: fn(i64) -> i64, x: i64) -> i64 { f(x) }

NO closure literals. Only named function references.

Linear Types

Must be consumed exactly once:

linear struct Handle { fd: i32 }
fn consume(h: Handle) -> i32 { h.fd }  // consumes h

Affine Types

Can be consumed at most once:

affine struct Token { id: i64 }

Units of Measure

Dimensional analysis at compile time:

unit kg
unit mg = 0.001 * kg
unit velocity = m / s

let dose: mg = 500.0
let mass: kg = 75.0

Standard 7-dimensional SI exponent vector (mass, length, time, temperature, amount, current, luminosity).

Refinement Types

Types with predicates:

type Probability = { p: f64 | p >= 0.0 && p <= 1.0 }
type SafeDose = { d: f64 | d > 0.0 && d <= 1000.0 }

Epistemic Types (Knowledge)

Sounio's unique feature — uncertainty propagation through computation:

use epistemic::{Knowledge}
let dose: Knowledge<mg> = measure(500.0, uncertainty: 2.5)
// Value + uncertainty tracked through all arithmetic

What Does NOT Exist

• No Box<T>, Rc<T>, Arc<T> — use fixed arrays or linear types
• No trait objects or dynamic dispatch — use function references
• No generics (yet) — use monomorphic types
• No Result<T, E> — return (value, error_code) tuples
• No Option<T> — use stdlib IntOption / FloatOption