Primitive Types, Compound Types & Representation Mechanics

Every computational value in Rust corresponds to a concrete, bit-level memory layout. Unlike dynamically typed languages where numbers are wrapped in runtime boxed objects, Rust scalar primitives represent bare hardware representations with deterministic bit widths and hardware alignment constraints.

1. Scalar Primitives#

Scalar primitives represent single values stored directly on the stack or in CPU registers:

2. Compound Types: Tuples & Arrays#

Compound types bundle multiple values together into a single composite type:

1
2
3
4
5
6
7
8
9
10
11
12
13
use std::mem::{size_of, align_of};

fn main() {
    // 1. Fixed-size Array (homogeneous sequence, stack allocated)
    let numbers: [i32; 4] = [10, 20, 30, 40];
    
    // 2. Heterogeneous Tuple (multiple types grouped)
    let record: (u8, u64, u16) = (1, 1000, 42);

    println!("Array size: {} bytes", size_of::<[i32; 4]>()); // 16 bytes
    println!("Tuple size: {} bytes", size_of::<(u8, u64, u16)>()); // 16 bytes due to padding!
    println!("Tuple alignment: {} bytes", align_of::<(u8, u64, u16)>()); // 8 bytes
}

3. Mathematical Foundations: Alignment & Padding#

Every type in Rust has an alignment requirement $A(T)$, which is a power of two ($1, 2, 4, 8, \dots$). The CPU hardware mandates that an instance of type $T$ must be stored at a memory address that is a multiple of $A(T)$.

For a composite tuple $T = (T_1, T_2, \dots, T_n)$, the aggregate alignment requirement is determined by the maximum alignment of its constituent components:

The total footprint in bytes $S(T)$ equals the sum of member sizes plus padding bytes inserted to satisfy individual offsets $O_i$:

For a fixed array of size $N$ with elements of type $E$:

4. Slice Types & Fat Pointers#

Arrays have fixed lengths known at compile time. Slices, denoted as [T], represent dynamically sized views into contiguous sequences. Because the length is not fixed at compile time, a slice reference &[T] is stored as a fat pointer.

On a 64-bit architecture, a fat pointer requires 16 bytes (two 64-bit words):

1. Pointer Word (8 bytes): The 64-bit starting address of the backing memory buffer.
2. Length Word (8 bytes): The number of elements contained in the slice view.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
fn print_subsequence(slice: &[i32]) {
    println!("Length: {}", slice.len());
    println!("Base pointer: {:p}", slice.as_ptr());
    for item in slice {
        print!("{} ", item);
    }
    println!();
}

fn main() {
    let full_array = [100, 200, 300, 400, 500];
    
    // Borrow a view of elements at index 1 to 3
    let view: &[i32] = &full_array[1..4];
    
    print_subsequence(view);
}

5. Concept Verification#

Verify your grasp of Rust scalar memory representation and fat pointers: