Primitive and Composite Types

Every type in Rust is either a primitive type built directly into the language compiler or a composite type constructed by combining existing types.

Taxonomy of Rust's Type Hierarchy

Rust Types
  ├── 1. Primitive Types (Built into the compiler)
  │        ├── Scalars:    i8..i128, isize, u8..u128, usize, f32, f64, bool, char
  │        ├── Text slice: str (unsized UTF-8 slice)
  │        ├── Unit & !:   () (1 value) and ! (never type, 0 values)
  │        └── Pointers:   &T, &mut T, *const T, *mut T, fn(...) -> R
  │
  └── 2. Composite Types (Built from other types)
           ├── Structural: Tuples `(A, B)`, Arrays `[T; N]`, Slices `[T]`
           └── Nominal:    `struct`, `enum`, `union`, Trait Objects `dyn Trait`

Reference of Built-In Primitive Types

Structural Composite Types: Tuples, Arrays, and Slices

fn analyze_packet(packet: &[u8; 4]) -> (u8, &[u8]) {
    let version = packet[0];
    let payload: &[u8] = &packet[1..];
    (version, payload)
}

fn main() {
    let raw: [u8; 4] = [1, 0xAA, 0xBB, 0xCC];
    let (ver, body) = analyze_packet(&raw);

    println!("Version: {ver}, body: {body:02X?}");
}

Version: 1, body: [AA, BB, CC]

Even though primitive types (i32, str, [T]) are built into the compiler for layout and code generation, the standard library (core and std) attaches inherent methods and trait implementations directly to them (impl i32 { ... }, impl<T> [T] { ... }) so primitives and composite types share a unified method-call syntax (42_u32.count_ones(), [1, 2, 3].len()).