Casting with as - Rust for C-Programmers

16.2 Casting with `as`

Rust provides the as keyword for a direct cast between certain compatible types, similar to writing (int)x in C. However, Rust’s rules are more restrictive about when as can be applied, and there is no automatic runtime error checking. As a result, you must ensure that a cast with as will behave correctly for your use case.

16.2.1 What Can `as` Do?

Typical valid uses of as include:

Numeric Casts (e.g., i32 to f64, or u16 to u8).
Enums to Integers (to access the underlying discriminant).
Boolean to Integer (true → 1, false → 0).
Pointer Manipulations (raw pointer casts, such as *const T to *mut T).
Type Inference (using _ in places like x as _, letting the compiler infer the type).

16.2.2 Casting Between Numeric Types

Casting numerical values via as is the most common usage. Because no runtime checks occur, truncation or sign reinterpretation can silently happen:

fn main() {
    let x: u16 = 500;
    let y: u8 = x as u8; 
    println!("x: {}, y: {}", x, y); // y becomes 244, silently truncated

    let a: u8 = 255;
    let b: i8 = a as i8;
    println!("a: {}, b: {}", a, b); // b becomes -1 (two's complement interpretation)
}

16.2.3 Overflow and Precision Loss

Casting can lead to loss of precision if the target type is smaller or uses a different representation:

fn main() {
    let i: i64 = i64::MAX;
    let x: f64 = i as f64; // May lose precision
    println!("i: {}, x: {}", i, x);

    let big_float: f64 = 1e19;
    let big_int: i64 = big_float as i64; 
    println!("big_float: {}, big_int: {}", big_float, big_int); // Saturates at i64::MAX
}

Rust’s rules for float-to-integer casts result in saturation at the numeric bounds, avoiding undefined behavior but still potentially losing information.

16.2.4 Casting Enums to Integer Values

By default, Rust chooses a suitable integer type for enum discriminants. Using #[repr(...)], you can explicitly define the underlying integer:

#[derive(Debug, Copy, Clone)]
#[repr(u8)]
enum Color {
    Red = 1,
    Green = 2,
    Blue = 3,
}

fn main() {
    let color = Color::Green;
    let value = color as u8;
    println!("The value of {:?} is {}", color, value); // 2
}

16.2.5 Performance Considerations

Many conversions—particularly those between integer types of the same size—are optimized to no-ops or a single instruction. Conversions that change the size of an integer or transform integers into floating-point values (and vice versa) remain fast in typical scenarios.

16.2.6 Limitations of `as`

Designed for Simple Types: as primarily targets primitive or low-level pointer conversions. It cannot convert entire structs in one go.
No Error Handling: Casting with as never returns an error. If the result is out of range or otherwise unexpected, the cast will silently produce a compromised value.

Rust for C-Programmers

16.2 Casting with as

16.2.1 What Can as Do?