# Functions

* Declare function using `fn`, reference: <https://doc.rust-lang.org/std/primitive.fn.html>
* Rust code uses snake case as the conventional style for function and variable names.
* In function signatures, you must declare the type of each parameter.
* When defining multiple parameters, separate the parameter declarations with commas.
* Functions can return values to the code that calls them. We don’t name return values, but we must declare their type after an arrow `->`.
* Rust have **statements** and **expressions**:
  * **Statements** are instructions that perform some action and do not return a value.
  * **Expressions** evaluate to a resultant value. Let’s look at some examples.
  * If you add a semicolon to the end of an expression, you turn it into a statement, and it will then not return a value.
* You can return early from a function by using the `return` keyword and specifying a value, but most functions return the last expression implicitly.
* Reference: [Functions](https://doc.rust-lang.org/book/ch03-03-how-functions-work.html)

## functions1.rs

```rust
// Add some function with the name `call_me` without arguments or a return value.
fn call_me() {
    println!("called")
}

fn main() {
    call_me(); // Don't change this line
}
```

* We just need to add a new function called `call_me` without any return value.
* Rust code uses snake case as the conventional style for function and variable names, in which all letters are lowercase and underscores separate words.
* Reference: <https://doc.rust-lang.org/book/ch03-03-how-functions-work.html>

## functions2.rs

```rust
// Add the missing type of the argument `num` after the colon `:`.
// Lets use i32 for the argument tyoe.
fn call_me(num: i32) {
    for i in 0..num {
        println!("Ring! Call number {}", i + 1);
    }
}

fn main() {
    call_me(3);
}
```

* In function signatures, you must declare the type of each parameter.

  > This is a deliberate decision in Rust’s design: requiring type annotations in function definitions means the compiler almost never needs you to use them elsewhere in the code to figure out what type you mean. The compiler is also able to give more helpful error messages if it knows what types the function expects.
* When defining multiple parameters, separate the parameter declarations with commas.
* So we just need to add `i32` as the arguments/parameter type.

## functions3.rs

```rust
fn call_me(num: u8) {
    for i in 0..num {
        println!("Ring! Call number {}", i + 1);
    }
}

fn main() {
    // Add parameters to call_me function.
    call_me(5);
}
```

* `call_me` function expect an argument/parameter, add `5` as parameter since the function expect type `u8`.

## functions4.rs

```rust
// This store is having a sale where if the price is an even number, you get 10
// Rustbucks off, but if it's an odd number, it's 3 Rustbucks off.
// Don't worry about the function bodies themselves, we are only interested in
// the signatures for now.

fn is_even(num: i64) -> bool {
    num % 2 == 0
}

// 
fn sale_price(price: i64) -> i64 {
    if is_even(price) {
        price - 10
    } else {
        price - 3
    }
}

fn main() {
    let original_price = 51;
    println!("Your sale price is {}", sale_price(original_price));
}
```

* Functions can return values to the code that calls them. We don’t name return values, but we must declare their type after an arrow `->`.
* In this exercise we just need to add return type as `i64`.

## functions5.rs

```rust
// Remove the semicolon to make it as expression
fn square(num: i32) -> i32 {
    num * num
}

fn main() {
    let answer = square(3);
    println!("The square of 3 is {answer}");
}
```

* Rust have **statements** and **expressions**:
  * **Statements** are instructions that perform some action and do not return a value.
  * **Expressions** evaluate to a resultant value. Let’s look at some examples.
  * If you add a semicolon to the end of an expression, you turn it into a statement, and it will then not return a value.
* You can return early from a function by using the return keyword and specifying a value, but most functions return the last expression implicitly.
* In this exercise the `square` functions expect a return value, but the function body only have one line statement. By removing the semicolon `;` we make it as an expression and will return the value of `num * num`


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://bagus-cahyono.gitbook.io/programming-notes/rust/rustlings_exercise/02_functions.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.