In Rust, we have various data types that represent numbers, truth values, characters, and more. In this lesson, we will focus on i32, f32, bool, char, and String.

The i32 data type represents 32-bit integers. The maximum value an i32 can store is 2147483647, or $2^{31} - 1$, and the minimum is -2147483648, or $-2^{31}$. Here's an example of i32:

Rust
Copy to clipboard
1let days_in_week: i32 = 7;
2println!("{}", days_in_week);  // This will print: 7
3
4let maximal_integer: i32 = 2147483647;
5println!("{}", maximal_integer);  // This will print: 2147483647
6
7let too_big_integer: i32 = 2147483648; // Oops! This will cause a compile error. The number is too large.

Next, we have the f32 data type in Rust, used for floating-point numbers — that is, numbers with decimal points. It can contain up to 7 decimal digits:

Rust
Copy to clipboard
1let pi: f32 = 3.141592;
2println!("{}", pi);  // This will print: 3.141592

Beyond numbers, we have the bool data type, which can hold either true or false. This type is commonly used in logical expressions and decision making:

Rust
Copy to clipboard
1let is_earth_round: bool = true;
2println!("{}", is_earth_round);  // This will print: true
3
4let is_earth_flat: bool = false;
5println!("{}", is_earth_flat); // This will print: false

We also have the char data type. This type is used to represent single Unicode character. char variables must be surrounded by single quotes (')

Rust
Copy to clipboard
1let first_letter_of_alphabet: char = 'A';
2println!("{}", first_letter_of_alphabet); // This will print: A

Last but not least, we have String. String is used to store a sequence of char elements.
There are two types of Strings in Rust.

String literals are immutable and have a type of &str.

Rust
Copy to clipboard
1let welcome1 = "Hello World!"; // Creates a string literal
2println!("{}", welcome1); // This will print: Hello World!

On the other hand, a String is by default immutable, but can be made mutable using the mut keyword.

Rust
Copy to clipboard
1let mut welcome2 = String::from("Welcome to Rust!"); // Creates a new String
2println!("{}", welcome2); // This will print: Welcome to Rust!
3
4welcome2 = String::from("Hello Rust World!"); // Changing the value of welcome2
5println!("{}", welcome2); // This will print: Hello Rust World!

Excellent! You've just explored the basic data types in Rust. You can now handle i32 and f32 for numerical operations, bool for decision-making, char to manage characters, and String to work with textual data.

That's a significant amount of new knowledge! Let's consolidate it through practice. The upcoming exercises are designed to help you apply these concepts. Brace yourself, and get ready to dive deeper into the world of Rust!