Rust from the beginning, functions
Tags: rust, beginners, tutorial
Published: 2022-06-10 14:53:48

---
title: Rust from the beginning, functions
published: true
description: This Rust tutorial covers working with functions
tags: rust, beginners, tutorial
series: Rust series
cover_image: https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ww052ip4ankmz1uxptmu.jpg
---

> in this part of the Rust from the beginning series, we will look at functions and how they can help us create reusable part of code.

{% embed https://youtube.com/watch?v=xblL5Vo3KhU %}

## Resources

- [What is Rust, module](https://docs.microsoft.com/en-us/learn/modules/rust-introduction?wt.mc_id=academic-0000-chnoring)
- [Create your first Rust program](https://docs.microsoft.com/en-us/learn/modules/rust-create-program?wt.mc_id=academic-0000-chnoring)
- [Rust Docs](https://www.rust-lang.org/learn)

## Functions what are they and why do I need them

A function is a named reference containing at least one and often many statements. Some of the benefits of functions are:

- **reusability & clean up**. When you create a function, you often do so, because you find there are pieces of code that repeats itself. By creating a function, you can use it elsewhere and replace it with the repeating pattern. Imagine the following taking place in your code:

   ```rust
   let mut account_balance = 100.20;
   let stock_sales = 50;
   let mut actual_deposit = 50 * 0.51;
   account_balance += actual_deposit;
   // some other lines of code
   let stock_sales = 100;
   actual_deposit = 100 * 0.51;
   account_balance += actual_deposit;
   ```

   Here you see that selling stocks is about first off selling it, secondly it's about giving a certain percentage to the tax office. Lastly, apply the proceeds to the account balance. That's a behavior repeating itself in the code, albeit the values are slightly different.

   A simpler version of the above code can be achieved by creating a function `get_stock_procceed()` that hides some of the behavior as well:

   ```rust
   let mut account_balance = 100.20;
   account_balance = get_stock_proceed(50);
   // some other lines of code
   account_balance = get_stock_proceed(100);
   ```

- **readability**. Another thing adding a function will achieve is readability, a function is named after what it does, adding or multiplying something is not as expressive as saying "getting the proceeds" of something. Also, the fewer lines there is, the easier it is to read, (to a point).

## A first function

Oki then, we hopefully understand a bit more about the what and the whys of functions, how do we create them? We create a function using the `fn` keyword, a name for the function, parenthesis and curly braces.

Here's an example:

```rust
fn say_hi() {
  println!("Hi");
}
```

To invoke it, you refer to it by name and add open and close parenthesis:

```rust
say_hi();
```

### Returning a value

The `say_hi()` function above doesn't return anything. Often, you want a function to have that capability. The reason is that you want the function to perform some sort of calculation like adding two numbers, or product maybe a random number.

There are two ways to return a value:

- **Using a `return` keyword**. The idea is that you signal to function that at this point you are ready to return the value and exit the function, like so:

   ```rust
   fn get_message(temperature_in_celsius:i32) -> &'static str {
      if temperature_in_celsius < 0 {
        return "Freezing";
      } 
      return "Ok temp";
   }
   ```

   In this code, the code has two different execution paths depending on what value I provide to the function, at this point, I need a `return` statement to explicitly say, this is where I need to exit the function.

- **the last line**. The other way to return a value from a function is to place what you want on the last line of function like so:

   ```rust
   fn produce_number() -> i32 {
     let number = 3;
     let another_number = 5;
     number + another_number;
   }
   ```

   The last line of the function is what's being returned, to receive the returned value, invoke the function and assign it like so:

   ```rust
   let value = produce_number();
   println!("{}", value);
   ```

   or use the value straight away like so:

   ```rust
   println!("{}", produce_number());
   ```

You've seen something so far, an arrow `->` right after the parenthesis of the function, what is that? That's the return type of the function. It's needed if the function returns something. For the `produce_number()` function the return type is `i32`, and we write it like so: `-> i32`. For an `divide()` function below we make the return type `f32` as we mean to deal with decimals:

```rust
fn divide() -> f32 {
  5 as f32 / 2 as f32
}
``` 

So what's going on here, `f32` but also `as f32`? Let's back it up, and start with a simpler version of this function:

```rust
fn divide2() -> i32 {
  5 / 2
}
```

Were you to run this, you would get 2 as response, which is probably not what you want? However, because you made the return type `i32`, you get a whole number and cut out the decimal. Let's change it to decimal then:

```rust
fn divide() -> f32 {
  5 / 2
}
```

At this point, you get a compilation error:

```output
  --> app.rs:21:3
   |
20 | fn divide() -> f32 {
   |                 --- expected `f32` because of return type
21 |   5 / 2
   |   ^^^^^ expected `f32`, found integer
```

It states that 5 and to are integers, we need to change that. We an either write them as 5.0 and 2.0 or use the operator `as` and turn them into floating points. We went with the latter, `5 as f32` and that's how we got there. This is very static function, we can't do much with it, it would be neat if we could pass it any value to do the calculation for us, for that, we need parameters.

### Adding parameters

A parameter is something we send into a function. To send something into a function, we need a placeholder, a parameter that catches the value we pass in, like so:

```rust
fn divide(placeholder:f32, second_placeholder: f32) {
  placeholder / second_placeholder;
}
```

Now we have removed 5 and 2, adding the parameters `placeholder` and `second_placeholder`. When we now invoke the function, we can send it values:

```rust
println!("{}", divide(5,2)); // 2.5
println!("{}", divide(10,2)); // 5
```

## Exercise - build a calculator

In this exercise, you will build a calculator that can handle addition, subtraction, multiplication and division.

1. Create a file _main.rs_ and add the following code:

   ```rust
   fn add(first_number: i32, second_number: i32) -> i32 {
     first_number + second_number
   }

   fn main() {
     let sum = add(2,2);
     let quotient = divide(10 as f32, 2 as f32);
     let product = multiply(2, 5);
     println!("{}", sum); // 8
   }
   ```

   Can you add what's missing? Give it some minutes and try to implement `divide()` and `multiply()`. The full solution can be found in the next section.

## Full solution - calculator

```rust
fn add(first_number: i32, second_number: i32) -> i32 {
  first_number + second_number
}

fn divide(first_number: f32, second_number: f32) -> f32 {
  first_number / second_number
}

fn multiply(first_number: i32, second_number: i32) -> i32 {
  first_number * second_number;
}

fn main() {
  let sum = add(2,2);
  let quotient = divide(10 as f32, 2 as f32);
  let product = multiply(2, 5);
  println!("{}", sum);
  println!("{:.2}", quotient);
  println!("{}", product);
}
```

### Extra credit

See if you can implement a `subtract()` function as well. 

## Summary

In this tutorial, you learned about functions, why you have them and how to create them yourself. Hopefully, you feel empowered to create your own functions.