## Functions

- define using `fn` and curly braces

- Rust doesn't care if function is defined before or after its caller
- Parameters e.g. `fn print_labeled_measurement(value: i32, unit_label: char)`
- type must be specified
- Statements and Expressions
- Rust is expression-based language
- In Rust statements e.g. `let a = 6` doesn't return a value (unlike C and
Ruby)
- Expressions evaluate to a value, e.g `5+6` expression evaluates to `11`
- Expression can be part of a statement
- Expressions don't have semicolon `;`. Once semicolon is used it becomes a
statement and doesn't have a return value.
E.g. here `x + 1` doesn't have `;`, so the block returns 4.
```rust
{
let x = 3;
x + 1
}
```
- Return Values
- declare type of the return value e.g. below.
5 is the return value (note it doesn't have a semicolon at the end)
```rust
fn five() -> i32 {
5
}
```

## Comments

- one line and multi line `//`

- documentation comments will be discussed in “Publishing a Crate to Crates.io”
section of Chapter 14.

## Control Flow

### if Expressions

```rust
fn main() {
let number = 3;

if number < 5 {
println!("condition was true");
} else {
println!("condition was false");
}
}
```

The condition must be alway bool. Otherwise - error. (so `if number {}` won't
work)

```rust
fn main() {
 let number = 6;

if number % 4 == 0 {
println!("number is divisible by 4");
} else if number % 3 == 0 {
println!("number is divisible by 3");
} else if number % 2 == 0 {
println!("number is divisible by 2");
} else {
println!("number is not divisible by 4, 3, or 2");
}
}
```

```rust
fn main() {
let condition = true;
let number = if condition { 5 } else { 6 };

println!("The value of number is: {}", number);

}
```
Both values in the if condition should be of the same type as rust need to know the
type of number at compile time.

### Repetition with Loops

- `loop`
- infinite loop until `break` used explicitly
- can specify a loop label `'label_name: loop {}`
- can break loop by label `break 'label_name`
```rust
fn main() {
let mut count = 0;
'counting_up: loop {
println!("count = {}", count);
let mut remaining = 10;

loop {
println!("remaining = {}", remaining);
if remaining == 9 {
break;
}
if count == 2 {
break 'counting_up;
}
remaining -= 1;
}

count += 1;
}
println!("End count = {}", count);
}
```
- can return value by `break value;`
- `while`
- slower than for due to the condition check
- `for`
- `for element in arr {}`
 - use Range from standard lib like `(1..4)` - 4 not incl
- use `(1..4).rev()` to reverse the range

`continue` is used to jump to the next iteration of the loop.