Rust Data Types

We use data types in Rust to determine the type of data associated with the variables. For example,

let alphabet: char;

Here, char is the data type that specifies that the alphabet variable can only store the character data.

Data Types in Rust

There are four primary data types in Rust also known as scalar types:

• Integer
• Floating-Point
• Boolean
• Character

1. Integer Type

In Rust, we use integer data types to store whole numbers. For example,

let number: i32 = 200;

Here, we have created the number variable of type i32 (integer) and stored the value 200.

The integer type i32 has two parts to it:

• i - specifies signed integer type (can store both positive or negative value)
• 32 - size of the data type (takes 32 bits of space in memory)

Signed Integer Type in Rust

fn main() {
    // Signed integer type 
    let x: i32 = -200;
    let y: i32 = 200;

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

Output:

x = -200
y = 200

Here, we have defined two integers x and y with values -200 and 200 respectively and printed it to the screen.

Unsigned Integer Type

We can also create variables that can only store positive integer values. For example,

fn main() {
    // Unsigned integer type
    let x: u32 = 300;

    println!("x = {}", x);
}

Output:

x = 300

Here, u32 specifies that the x variable can only store positive values. u specifies unsigned integer type.

If we try to store negative numbers to u32 type variables, we will get an error. For example,

fn main() {
    let x: u32 = -200;

    println!("x = {}", x);
}

Error:

error[E0600]: cannot apply unary operator `-` to type `u32`
 --> main.rs:2:18
  |
2 |   let x: u32 = -200;
  |                ^^^^ cannot apply unary operator `-`
  |
  = note: unsigned values cannot be negated

Categories of Integer Data Types in Rust

Depending on the size of data, we can further classify the signed and unsigned integer type into various categories:

2. Rust Floating Point Type

Floating point types are used to store fractional numbers (numbers with decimal points). In Rust, floating-point data types can be divided into:

• f32
• f64

Here, the f character represents a floating point number, 32 and 64 represent the size in bits.

Let's take a look at an example,

let x: f32 = 3.1;

Here, f32 is a type declaration for the floating point value. In this case, x is assigned to a floating point value of 3.1.

Example: Floating Point Data Type

fn main() {
    // f32 floating point type
    let x: f32 = 3.1;

    // f64 floating point type
    let y: f64 = 45.0000031;

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

Output:

x = 3.1
y = 45.0000031

Note: f32 is a single-precision floating type whereas f64 is double-precision type. With double-precision, f64 can store data with a larger decimal range and is considered more precise.

3. Rust Boolean Type

In Rust, a boolean data type can have two possible values: true or false. For example,

// boolean value true
let flag1: bool = true;

// boolean value false
let flag2: bool = false;

Here, we have used the bool keyword to represent the boolean type in Rust.

Example: Boolean Type

fn main() {
    // boolean type
    let flag1: bool = true;
    let flag2: bool = false;

    println!("flag1 = {}", flag1);
    println!("flag2 = {}", flag2);
}

Output:

flag1 = true
flag2 = false

Note: Booleans are frequently used in conditional statements like if/else expressions.

4. Rust Character Type

The character data type in Rust is used to store a character. For example,

fn main() {
    // char type
    let character: char = 'z';

    println!("character = {}", character);
}

Output:

character = z

Here, char represents the character type variable and we use single quotes to represent a character.

We can also store special characters like $, @, &, etc. using the character type. For example,

fn main() {
    // char type
    let character: char = 'z';
    let special_character: char = '$';

    println!("character = {}", character);
    println!("special_character = {}", special_character);
}

Output:

character = z
special_character = $

let numeric_character: char = '5';

Type Inference in Rust

So far we have mentioned the data type during the variable declaration. However, in Rust we can create variables without mentioning a data type. For example,

let x = 51;

In this case, Rust automatically identifies the data type by looking at the value of the variable x and associates it with the variable. This process is known as Type Inference.

Let's see an example,

fn main() {
    let x = 51;

    println!("x = {}", x);
}

Output:

x = 51

Here, you can see that we haven't mentioned the data type of x variable. It is because Rust will automatically set i32 as the type (default type for integer variable) by looking at the value 51.