Primitives and literals

Integer and float types

There is no int, no long, no byte. The size is part of the name.

f16 is the IEEE half-precision float (2 bytes), primarily a storage type for ML and graphics data. It converts to and from the wider floats with as (hardware fpext / fptrunc), and exposes a bit-preserving reinterpret to and from its raw u16:

let h: f16 = 1.5f32 as f16;          // fptrunc
let x: f32 = h as f32;               // fpext

let h2: f16 = f16::from_bits(0x3C00 as u16);   // IEEE half 1.0
let raw: u16 = h2.to_bits();

Arithmetic on f16 works, but the idiomatic hot-path pattern is to convert to f32, compute, then convert back.

Other primitives

• bool: true / false. It cannot be produced by an integer cast.
• (): the unit type, the implicit return of a function with no arrow.
• str: a string view (pointer plus length), borrowed.
• string: an owned, heap-allocated string, provided by the standard library.
• *T: a raw pointer. Operations require unsafe.
• fn(...) -> R: a function pointer.

Literals

let a: i32 = 42;
let b: u64 = 42u64;            // typed literal
let c: f64 = 3.14;
let d: bool = true;
let e: str = "hello";
let f: i32 = 0x1F;             // hex
let g: i32 = 0b1010;           // binary
let h: i32 = 1_000_000;        // underscore separators

Character literals: 'a' is a u8 byte literal, a shorter way to write 97u8. The backslash escapes '\n', '\t', '\r', '\\', '\'', '\"', '\0', and the hex form '\xFF' all work. A multi-byte UTF-8 codepoint such as 'á' is rejected at parse time, since the type is u8, not a full Unicode codepoint. For UTF-8 use a str.