4.10Numeric conversions with as

Last updated June 11, 2026

This chapter has repeatedly slammed a door: no implicit conversions, not between i32 and u32, not even from i32 up to roomy, harmless i64 (lesson 4.2's quiz made sure you felt it). This lesson opens the door that was always meant to be used instead: explicit conversion, where you write the cast and thereby sign for its consequences.

If you're keeping score against C++: this single lesson replaces their entire implicit-conversion apparatus (promotions, narrowing rules, a chapter of "what converts to what when"), because a system with no automatic conversions has no automatic-conversion rules to memorize. There's one keyword, and it always means "I asked for this."

The as keyword

fn main() {
    let small: i32 = 100;
    let big: i64 = small as i64;
    println!("{big}");
}

value as Type converts between numeric types (and a few friends, like the char-to-code casts of lesson 4.8). Conversions up in size, like this one, are exact: every i32 value fits in an i64, nothing can go wrong, and the cast is just paperwork the compiler demands so the reader can see the type change happening.

The interesting cases are the lossy directions, and as performs them without complaint, which is exactly why it must be written explicitly. Know the three behaviors:

Narrowing integer casts truncate. Converting to a smaller type keeps only the bits that fit:

fn main() {
    let n: i32 = 300;
    println!("{}", n as u8);
    println!("{}", (-1i32) as u8);
}

44
255

300 doesn't fit in a u8, so the excess bits are discarded, leaving 44 (300 − 256, the odometer arithmetic of lesson 4.4). And −1's bit pattern reinterpreted as unsigned is 255. Neither is an error, a panic, or a warning: as does what you asked, literally, and "what you asked" for a narrowing cast is "keep what fits."

Float-to-int casts drop the fraction, then saturate. The fractional part is discarded (toward zero, not rounded), and values beyond the target's range pin at its boundaries instead of wrapping:

fn main() {
    println!("{}", 3.9 as i32);
    println!("{}", (-3.9) as i32);
    println!("{}", 1e10 as i32);
    println!("{}", (-7.5) as u8);
    println!("{}", f64::NAN as i32);
}

3
-3
2147483647
0
0

3.9 becomes 3 (not 4; this is truncation, not rounding), ten billion pins at i32::MAX, negative values pin at a u8's floor of 0, and NaN converts to 0 by decree. Defined, predictable, and occasionally surprising, which is the recurring theme.

Int-to-float casts can lose precision. Every i32 survives the trip to f64 exactly, but lesson 4.5 told you an f64 only carries 15-ish significant digits, and big 64-bit integers have more:

fn main() {
    let exact: i64 = 9_007_199_254_740_993;
    println!("{}", exact as f64);
}

9007199254740992

Off by one: the integer landed between representable floats and snapped to a neighbor. Rare in practice, memorable when met.

For completeness, the conversions this lesson is not about: numbers-from-text is parse (lesson 5.6), text-from-numbers is format! (5.5), and the ergonomic, can't-lose conversions between types get a nicer spelling (From/Into) in chapter 16. as is specifically the low-level numeric tool: blunt, total, explicit.

Quiz time

Question #1

Predict each output:

fn main() {
    println!("{}", 9.99 as i32);
    let n = 256;
    println!("{}", n as u8);
    println!("{}", 255 as u8);
    println!("{}", (-1.0) as u32);
}

9
0
255
0

Question #2

This program reports the size of a 5 GB file. Predict its output, then diagnose.

fn file_size_in_bytes() -> u64 {
    5_000_000_000
}

fn main() {
    let size = file_size_in_bytes();
    let reported = size as u32;
    println!("file is {reported} bytes");
}

file is 705032704 bytes

Question #3

Why does Rust make you write as i64 even for the always-safe i32 → i64 direction?

One lesson left before the chapter quiz, and it answers a question chapter 2 planted: functions return exactly one value... so how do you return two?