An if expression in Rust allows you to choose which code to execute based on a certain condition. You specify a condition and then the code that will run only if the condition is true, and the code will not run if the condition is false.

```rust
let x = 15;

if x < 10 {
    println!("x is less than 10");
} else if x < 20 {
    println!("x is between 10 and 20");
} else {
    println!("x is greater than or equal to 20");
}
```
In this example, the variable \`x\` is assigned the value \`15\`. The first if expression checks if the value of \`x\` is less than 10, if it's not true, it goes to the next \`else if\` which checks if x is less than 20, if it's true, it will print "x is between 10 and 20", otherwise the last block of code will execute and print "x is greater than or equal to 20".

if-else - Rust Programming

The "loop" command in Rust tells the computer to repeatedly run a specific set of instructions, either continuously or until a specific stopping point is reached, as instructed by the programmer.

Here is an example of how the "loop" keyword might be used in a Rust program:
```rust
let mut x = 0;
loop {
    x += 1;
    println!("x is now {}", x);
    if x == 10 {
        break;
    }
}
```

This code creates a variable x and sets it to 0. Then it starts a loop. Inside the loop, it increases the value of x by 1, prints out the new value of x, and then checks if x is equal to 10. If it is, the break keyword is used to exit the loop. The loop will keep running until x becomes equal to 10. It will print the value of x from 1 to 9.

loop - Rust Programming

A common task in programming is to repeatedly execute a loop as long as a certain condition is met. When the condition is no longer met, the loop is halted by utilizing the "break" command. This behavior can be accomplished using a combination of loops, if statements, else statements, and breaks. However, Rust provides a specialized language construct, called a "while loop," that can perform this task with greater ease.

Here is an example of a while loop in Rust that repeatedly runs a block of code as long as the variable "i" is less than 5:
```rust
let mut i = 0;
while i < 5 {
    println!("i is {}", i);
    i += 1;
}
```

In this example, the while loop will continue to execute the code block that prints the value of "i" and increments it by 1, as long as the condition "i < 5" is true. Once "i" becomes greater than or equal to 5, the loop will exit and the program will continue to execute any code that comes after the loop.

while - Rust Programming

In Rust programming, a "for loop" is a type of loop that allows you to iterate over a collection of items, such as an array or a vector. The basic syntax of a for loop in Rust is as follows:

```rust
for variable in collection {
    // code to execute for each item in the collection
}
```

For example, you can use a for loop to iterate over an array of integers and print out each value:

```rust
let numbers = [1, 2, 3, 4, 5];
for num in numbers.iter() {
    println!("{}", num);
}
```

In this example, the for loop iterates over the numbers array, assigns each value to the variable num, and prints the value of num at each iteration.

for - Rust Programming

University of Michigan - Ann Arbor

By default, variables in Rust are immutable, meaning their value cannot be changed once assigned. To allow a variable to be mutable, the keyword "mut" must be used when declaring the variable.

Immutable example:
```rust
let x = 5;
```
This declares a variable named "x" and assigns it the value of 5. The type of x is inferred by the compiler to be i32.

Mutable example:
```rust
let mut y = 10;
y = 20;
```
This declares a mutable variable "y" with an initial value of 10 and then changes the value to 20.

Variable Mutability - Rust Programming

rust-lang.org

Control Structures - Rust Programming

Functions are commonly used in Rust code, with the main function being a key element and entry point for many programs. The fn keyword is used to create new functions.

Syntax:
```rust
fn function_name(parameter_name: parameter_type) -> return_type {
    // code block
}
```


For example:
```rust
fn add(a: i32, b: i32) -> i32 {
    a + b
}
```

Learn Before

Related

Learn After