Data Types

Working Code

Try running this code in the Rust Playground!

fn main() {
    let age: i32 = 20;          // Integer
    let height: f64 = 175.5;    // Float
    let is_student: bool = true; // Boolean
    let grade: char = 'A';      // Character

    println!("Age: {age}");
    println!("Height: {height}cm");
    println!("Student? {is_student}");
    println!("Grade: {grade}");
}

Rust has four basic scalar types.

| Type | Example | Description | | --------- | ------- | ------------------------------------------- | | Integer | i32 | Numbers without a decimal point | | Float | f64 | Numbers with a decimal point | | Boolean | bool | true or false | | Character | char | A single character wrapped in single quotes |

You actually don't have to write the types out — Rust can figure them out on its own.

fn main() {
    let age = 20;       // Inferred as i32
    let height = 175.5; // Inferred as f64
    let is_happy = true; // Inferred as bool
    let emoji = '🦀';   // Inferred as char

    println!("{age}, {height}, {is_happy}, {emoji}");
}

Even without explicit type annotations, the Rust compiler looks at the values and determines the types. This is called type inference.

Try It Yourself

Try removing the type annotations (: i32, : f64, etc.) from the code below. Does the output change?

fn main() {
    let x: i32 = 42;
    let y: f64 = 3.14;
    let z: bool = false;

    println!("{x}, {y}, {z}");
}

You'll get the same result even without the types. Rust infers them for you. That said, writing out the types can make your code easier for others to read.

"Why?" — Why Do We Need Types?

Computers store the number 42 and the decimal 3.14 in different ways. Integers use one storage format, and floats use another. The compiler needs to know the type to store values correctly in memory and perform accurate operations.

Rust does not allow operations between different types. This helps catch unintended mistakes early.

fn main() {
    let a: i32 = 10;
    let b: f64 = 3.0;

    // This causes an error!
    // let result = a + b;

    // You need to match the types
    let result = a as f64 + b;
    println!("Result: {result}");
}

You can convert types using the as keyword. For now, just remember: "if the types differ, you need to align them."

Deep Dive

fn main() {
    let x = 5;
    let y = 2.0;
    let sum = x + y;

    println!("{sum}");
}

error[E0277]: cannot add `{float}` to `{integer}`
 --> src/main.rs:4:19
  |
4 |     let sum = x + y;
  |                   ^ no implementation for `{integer} + {float}`

fn main() {
    let x: i32 = 10;
    let y: f64 = 3.0;
    let z = x + y;
    println!("{z}");
}