Functions in Rust
Tags: rust, tutorial, beginners, programming
Published: 2024-03-16 18:30:00

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:
```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.

```rust
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.

```rust
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.

```rust
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.

```rust
/// 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.