> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Rust Else If
The `else if` construct in Rust is a control flow expression used to chain multiple mutually exclusive conditional branches. It evaluates subsequent boolean expressions sequentially if the preceding `if` or `else if` conditions evaluate to `false`.
```rust theme={"dark"}
if condition_a {
// Executes if condition_a is true
} else if condition_b {
// Executes if condition_a is false AND condition_b is true
} else if condition_c {
// Executes if condition_a and condition_b are false AND condition_c is true
} else {
// Executes if all preceding conditions are false
}
```
## Technical Mechanics and Syntax Rules
* **Strict Boolean Typing:** Rust enforces strict type safety. The condition evaluated by an `else if` must resolve exactly to the `bool` type. Rust does not perform implicit type coercion (there are no "truthy" or "falsy" integers, strings, or pointers).
* **Mandatory Braces:** The execution block associated with an `else if` must be enclosed in curly braces `{}`, even if the block contains only a single statement.
* **Omitted Parentheses:** Idiomatic Rust omits parentheses around the condition. While syntactically permissible, including them will trigger a compiler warning (`warning: unnecessary parentheses around `if` condition`).
* **Short-Circuit Evaluation:** The chain is evaluated strictly top-to-bottom. The first condition that evaluates to `true` triggers its corresponding block, and all subsequent `else if` or `else` branches are immediately bypassed without evaluation.
## Expression Semantics and Type Matching
In Rust, `if` / `else if` / `else` chains are **expressions**, meaning the entire construct evaluates to a value. This allows the result of the chain to be directly assigned to a variable or returned from a function.
When used as an expression, the compiler enforces strict type matching across all branches:
1. Every block in the `if`, `else if`, and `else` chain must evaluate to the exact same type.
2. An exhaustive `else` block is mandatory if the chain is returning a value other than the unit type `()`. Without the final `else`, the compiler cannot guarantee a value will be produced if all `else if` conditions fail.
```rust theme={"dark"}
let val = 15;
// The chain acts as an expression binding a value to `result`.
// Every branch implicitly returns an `i32`.
let result: i32 = if val % 4 == 0 {
10
} else if val % 3 == 0 {
20
} else if val % 2 == 0 {
30
} else {
40 // Mandatory fallback to ensure an i32 is always returned
};
```
If the `else if` chain is used purely for side effects (as a statement), every block implicitly evaluates to the unit type `()`. In this scenario, a terminating `else` block is optional.
Tired of Poor Rust Skills? Fix That With Deep Grasping!
Learn More
