**Course Title:** Mastering Rust: From Basics to Systems Programming **Section Title:** Control Flow and Functions **Topic:** Defining and using functions, including function arguments and return types. ### Introduction to Functions in Rust In the previous topics, we explored control flow constructs in Rust, including conditional statements and looping constructs. In this topic, we will delve into functions, which are a crucial aspect of programming in Rust. Functions allow us to organize our code into reusable blocks, making it easier to write, test, and maintain. ### Defining a Function In Rust, a function is defined using the `fn` keyword, followed by the function name and a set of parentheses containing the function's parameters. Here is an example of a simple function that takes no arguments and returns no value: ```rust fn greet() { println!("Hello, World!"); } fn main() { greet(); } ``` In this example, the `greet` function is defined, and then called from the `main` function. When we run this program, it will print "Hello, World!" to the console. ### Function Arguments Functions in Rust can take arguments, which are values passed to the function when it is called. Here is an example of a function that takes one argument: ```rust fn greet(name: &str) { println!("Hello, {}!", name); } fn main() { greet("Alice"); } ``` In this example, the `greet` function takes a `&str` argument, which is a reference to a string slice. When we call the `greet` function from the `main` function, we pass a string literal as an argument. The function then prints "Hello, Alice!" to the console. ### Function Return Types Functions in Rust can return values, which are returned to the caller when the function finishes executing. Here is an example of a function that returns a value: ```rust fn add(x: i32, y: i32) -> i32 { x + y } fn main() { let result = add(2, 3); println!("The result is: {}", result); } ``` In this example, the `add` function takes two `i32` arguments and returns an `i32` value. When we call the `add` function from the `main` function, we store the returned value in a variable and print it to the console. ### Multiple Return Types In Rust, functions can return multiple values using tuples. Here is an example: ```rust fn get_full_name(first_name: &str, last_name: &str) -> (&str, &str) { (first_name, last_name) } fn main() { let (first_name, last_name) = get_full_name("John", "Doe"); println!("First name: {}, Last name: {}", first_name, last_name); } ``` In this example, the `get_full_name` function takes two `&str` arguments and returns a tuple of two `&str` values. When we call the `get_full_name` function from the `main` function, we use pattern matching to unpack the returned tuple into two variables. ### Default Argument Values Rust does not support default argument values, unlike some other languages. However, you can use pattern matching to achieve similar behavior: ```rust fn greet(name: &str, greeting: &str) { println!("{} {}!", greeting, name); } fn main() { let name = "Alice"; match name { _ if name == "Alice" => greet(name, "Hello"), _ => greet(name, "Hi"), } } ``` In this example, we use pattern matching to specify a default greeting for a specific name. ### Practical Takeaways * Functions in Rust are defined using the `fn` keyword. * Functions can take arguments and return values. * Use tuples to return multiple values from a function. * Pattern matching can be used to achieve default argument values. ### Additional Resources * [The Rust Book: Functions](https://doc.rust-lang.org/book/ch03-03-how-functions-work.html) * [Rust Documentation: Functions](https://doc.rust-lang.org/std/fn/index.html) ### Exercises 1. Write a function that takes two `i32` arguments and returns their sum. 2. Write a function that takes a `&str` argument and returns its length. 3. Write a function that takes two `&str` arguments and returns a tuple of the two strings concatenated together. ### Leave a comment or ask for help if you have any questions or difficulties with this topic. In the next topic, we will explore closures and their uses in Rust.