The Type System & Inference

Rust is statically typed: every value has a type known at compile time. The compiler infers types when possible; annotations clarify intent at API boundaries and resolve ambiguity.

Recipe

fn main() {
    let x = 10;           // inferred i32
    let y: u64 = 10;      // explicit
    let items = vec![1, 2, 3]; // Vec<i32>
    let mapped: Vec<_> = items.iter().map(|n| n * 2).collect();
    println!("{x} {y} {:?}", mapped);
}

When to reach for this: Choosing explicit types at public APIs, turbofish ::<T>, and understanding why inference sometimes needs a hint.

Working Example

use std::io::{self, BufRead};
 
fn read_numbers<R: BufRead>(reader: R) -> io::Result<Vec<i32>> {
    let mut out = Vec::new();
    for line in reader.lines() {
        let n: i32 = line?.trim().parse()?;
        out.push(n);
    }
    Ok(out)
}
 
fn main() -> io::Result<()> {
    let stdin = io::stdin();
    let nums = read_numbers(stdin.lock())?;
    let sum: i32 = nums.iter().sum();
    println!("sum={sum}");
    Ok(())
}

What this demonstrates:

• Generic R: BufRead inferred at call site
• ? on parse() propagates ParseIntError via From
• Explicit i32 on parse target
• Return type io::Result<Vec<i32>> guides error conversions

Deep Dive

How Inference Works

• Compiler assigns types based on constraints from assignments, function signatures, and trait impls
• Integer literals default to i32, floats to f64 without other hints
• collect() often needs turbofish: collect::<Vec<_>>()
• Type errors often point to the first place constraints conflict

Annotations vs Turbofish

let v = Vec::<String>::new();
let v: Vec<String> = Vec::new();
let nums = "1 2 3".split_whitespace().map(|s| s.parse::<u32>().unwrap()).collect::<Vec<_>>();

Never Type !

fn exit(code: i32) -> ! {
    std::process::exit(code);
}

Expressions of type ! unify with any type in match arms (diverging).

Gotchas

• Ambiguous collect() - let v = iter.collect(); errors. Fix: collect::<Vec<_>>() or annotate let v: Vec<T>.
• Numeric literal ambiguity in generics - let x: T = 1; may fail. Fix: Use T::from(1) or literal suffix.
• Over-annotating locals - Noise without benefit. Fix: Annotate public items and where inference fails.
• Assuming usize == u64 - Platform-dependent usize. Fix: Cast explicitly for FFI/serialization.
• Shadowing changes inferred type - let x = 1; let x = "a"; changes type silently. Fix: Use distinct names in long scopes.

383k393a3c3q3e393a3o1r3e3k3x383c3e3k1u211z3x1v1t1v1z1t20

Alternatives

FAQs

Related

• Scalar & Compound Types - primitive types
• Generics - parametric types
• Trait Bounds - constraining generics
• Functions & Expressions - return type expressions

External Related Links

• The Rust Programming Language (The Book) - Canonical beginner-to-intermediate guide (ownership, borrowing, traits, etc.).
• The Rust Reference - Formal language reference (precise semantics).
• Rust By Example - Runnable examples covering language features and standard library.
• Programming Rust: Fast, Safe Systems Development (Amazon) - Blandy, Orendorff, Tindall.
• The Rust Programming Language, 3rd Edition (O'Reilly) - Klabnik, Nichols, Krycho.

Stack versions: This page was written for Rust 1.97.0 (edition 2024), Tokio 1.x, Axum 0.8, serde 1.0, sqlx 0.8, clap 4, and Polars 0.46+.