🦀 Rust – Data Types: Understand the Building Blocks of Rust Programs

Introduction – Why Learn Rust Data Types?

Rust is a statically typed language, which means every variable has a known type at compile time. Rust’s data type system is designed for performance and safety, allowing fine-grained control over memory and operations—critical for systems-level programming.

In this guide, you’ll learn:

• The two main categories: Scalar and Compound types
• How to declare and use different data types
• Numeric types, booleans, characters, tuples, and arrays
• Type inference and explicit typing rules

Categories of Rust Data Types

Scalar Data Types in Rust

1. Integer Types

fn main() {
    let a: i32 = -10;
    let b: u8 = 255;
    println!("a = {}, b = {}", a, b);
}

Rust defaults to i32 if you don’t specify a type.

2. Floating-Point Types

fn main() {
    let x = 2.5;       // f64 by default
    let y: f32 = 3.14; // explicitly f32
    println!("x = {}, y = {}", x, y);
}

3. Boolean Type

fn main() {
    let is_rust_fun: bool = true;
    println!("Is Rust fun? {}", is_rust_fun);
}

4. Character Type

fn main() {
    let letter: char = 'R';
    let emoji: char = '🦀';
    println!("{} {}", letter, emoji);
}

Compound Data Types in Rust

1. Tuples

fn main() {
    let person: (&str, i32) = ("Alice", 30);
    println!("Name: {}, Age: {}", person.0, person.1);
}

Tuples group values of different types, and are accessed using dot notation (.0, .1, etc.).

2. Arrays

fn main() {
    let scores: [i32; 3] = [85, 90, 95];
    println!("Top score: {}", scores[2]);
}

Arrays hold multiple values of the same type and have fixed size.

Type Inference and Annotations

Rust often infers types:

let x = 42; // inferred as i32

But you can add explicit annotations for clarity:

let x: u8 = 42;

When in doubt, explicit typing helps with clarity and compiler errors.

Common Data Type Mistakes

Summary – Recap & Next Steps

Rust’s strong and explicit type system gives you predictable, performant, and bug-free code. Knowing how and when to use different data types is foundational to mastering Rust.

Key Takeaways:

• Rust has scalar types (i32, f64, bool, char) and compound types (tuple, array)
• Type safety and inference help prevent logic errors
• Always annotate types when clarity or correctness is needed
• Rust provides full Unicode support via char and precise memory use with array sizing

Next up: Deep dive into Rust – Strings to learn about string slices, ownership, and formatting.

FAQs

What is the default integer type in Rust?
i32 is the default for integer literals.

How is a tuple different from an array?
Tuples can hold different types and have named or indexed fields. Arrays are fixed-size and homogeneous.

Is char a single-byte type in Rust?
No. Rust’s char is 4 bytes and represents a Unicode scalar value, not just ASCII.

Can I change array sizes dynamically in Rust?
No. For dynamic, growable arrays, use a Vec<T> instead of a fixed-size array.