**Course Title:** Mastering Rust: From Basics to Systems Programming **Section Title:** Introduction to Rust and Setup **Topic:** Basic Rust syntax: Variables, data types, and functions. ### Overview In this topic, we will explore the basic syntax of Rust, including variables, data types, and functions. You will learn how to declare and use variables, understand Rust's type system, and define reusable code using functions. By the end of this topic, you will have a solid foundation in Rust's syntax and be ready to start building your own Rust programs. ### Variables in Rust In Rust, a variable is a named storage location that holds a value. Variables are declared using the `let` keyword followed by the variable name and its type. For example: ```rust let x: i32 = 10; ``` Here, `x` is the variable name, `i32` is its type (a 32-bit integer), and `10` is the value assigned to it. **Key Concepts:** * **Immutability**: By default, variables in Rust are immutable, meaning their value cannot be changed once assigned. * **Type Inference**: Rust can often infer the type of a variable based on the assigned value. However, specifying the type explicitly is generally good practice. **Example:** ```rust fn main() { let x: i32 = 10; println!("Value of x: {}", x); // x = 20; // This will result in a compile-time error because x is immutable let mut y: i32 = 10; println!("Initial value of y: {}", y); y = 20; println!("New value of y: {}", y); } ``` **Best Practice:** Use descriptive variable names and explicitly specify their types to ensure readability and maintainability. ### Data Types in Rust Rust has a rich set of built-in data types, including integers, floating-point numbers, booleans, characters, and more. **Integer Types:** * `i8` (8-bit signed integer) * `i16` (16-bit signed integer) * `i32` (32-bit signed integer) * `i64` (64-bit signed integer) * `u8` (8-bit unsigned integer) * `u16` (16-bit unsigned integer) * `u32` (32-bit unsigned integer) * `u64` (64-bit unsigned integer) **Floating-Point Types:** * `f32` (32-bit floating-point number) * `f64` (64-bit floating-point number) **Boolean Type:** * `bool` (true or false) **Character Type:** * `char` (a single Unicode character) **Example:** ```rust fn main() { let x: i32 = 10; let y: f64 = 10.5; let z: bool = true; let c: char = 'A'; println!("Integer x: {}", x); println!("Float y: {}", y); println!("Boolean z: {}", z); println!("Character c: {}", c); } ``` **Key Concept:** Use the correct data type to store values, considering factors such as memory usage and precision requirements. ### Functions in Rust Functions are reusable blocks of code that take arguments and return values. In Rust, functions are declared using the `fn` keyword followed by the function name and its parameters. **Example:** ```rust fn add(x: i32, y: i32) -> i32 { x + y } fn main() { let result = add(10, 20); println!("Result: {}", result); } ``` **Key Concepts:** * **Function Parameters**: Values passed to a function when it's called. * **Function Return Type**: The type of value returned by a function. **Best Practice:** Use descriptive function names and parameter names to ensure readability and maintainability. **Additional Resources:** * [Rust Documentation - Variables](https://doc.rust-lang.org/book/ch03-01-variables-and-mutability.html) * [Rust Documentation - Data Types](https://doc.rust-lang.org/book/ch03-02-data-types.html) * [Rust Documentation - Functions](https://doc.rust-lang.org/book/ch03-03-how-functions-work.html) **Exercise:** Try declaring and using variables with different data types. Define a simple function that takes two integers as arguments and returns their sum. **Next Topic:** Writing your first Rust program: Hello, World!. Do you have any questions about the topic? Feel free to ask, and I'll do my best to help. Additionally, please note that comments on this topic will be closed, as there will be no discussion thread available.