Functions are essential building blocks in any programming language, including Rust. They encapsulate reusable pieces of code that perform specific tasks, promoting code organization and reusability. In this article, we'll delve into the fundamentals of functions in Rust, covering their syntax, return values, and the distinction between statements and expressions. We'll also touch on passing by reference and commenting in Rust code.

Functions in Rust

In Rust, functions are declared using the fn keyword, followed by the function name, parameters (if any), and return type (if any).

Here's a basic example of a function in Rust:

// Function with no parameters and no return value
fn greet() {
    println!("Hello, Rust!");
}

// Function with parameters and a return type
fn add_numbers(a: i32, b: i32) -> i32 {
    a + b
}

fn main() {
    let result = add_numbers(3, 4);
    println!("Result: {result}");

    greet();
}

This function add_numbers takes two parameters (a and b) of type i32 and returns their sum as an i32. The greet function has no parameters and no return value.

Note: Snake case is the conventional style for naming functions and variables in Rust, where words are separated by underscores and all lowercase.

Statements and Expressions

In Rust, statements are instructions that perform actions but do not return values and end with a semicolon (;). On the other hand, expressions evaluate to a value and do not end with a semicolon. The value of the final expression in a block of code is implicitly returned.

let x = 5; // statement
println!("Value of x: {}", x); // statement

let y = {
    let a = 3;
    let b = 4;
    a + b // expression without a semicolon, returns the result
};
println!("Value of y: {}", y);

In this example, the block {} contains an expression a + b, which is the value of the block and is assigned to y.

Return Values

In Rust, return values are declared using the -> syntax. The return keyword is optional, as the value of the final expression in a function block serves as the implicit return value. If necessary, you can use the return keyword to exit a function prematurely and specify a particular value to be returned.

fn five() -> i32 {
  let a = 3;
  let b = 2;
  a + b  // Implicit return value
}

fn plus_one(x: i32) -> i32 {
  return x + 1;   // Explicit use of return keyword
}

fn main() {
  let x = five();
  let y = plus_one(5);
  println!("The value of x is: {x}"); // 5
  println!("The value of y is: {y}"); // 6
}

Passing by Reference

To pass a reference of a variable instead of the actual variable, we can use pass by reference in Rust. This is achieved by using the & symbol before the variable name.

fn calculate_length(s: &String) -> usize {
  s.len()
}

fn main() {
  let word = String::from("hello");

  // passing reference of word variable
  let len = calculate_length(&word);

  println!("The length of '{}' is {}.", word, len);
  // Prinys -> The length of 'hello' is 5.
}

In this example, the calculate_length function takes a reference to a String (&String) and returns its length (usize).

Note: We will talk about reference in details in upcoming blog.

Comments in Rust

Comments in Rust start with // for single-line comments and /* */ for multi-line comments. Rust also supports documentation comments, denoted by ///, which are used for documenting code for tools and external users.

/// This function adds two numbers together.
fn add_numbers(a: i32, b: i32) -> i32 {
    a + b
}

I know comments are unrelated to functions, but I don't want to make a seperate blog for this part.

Conclusion

Functions are a fundamental part of Rust programming, enabling code reuse and organization. Understanding how to define and use functions, handle return values, and pass arguments by reference are key concepts in Rust development. Comments also play a crucial role in documenting code, making it easier to understand and maintain.