> ## 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 Logical AND
The `&&` operator is the logical AND operator in Rust. It evaluates two boolean expressions and returns `true` if and only if both operands evaluate to `true`.
## Syntax and Type Constraints
The operator requires exactly two operands, both of which must strictly resolve to the `bool` primitive type. Rust does not support implicit type coercion for booleans (i.e., there are no "truthy" or "falsy" values).
```rust theme={"dark"}
let a: bool = true;
let b: bool = false;
let result: bool = a && b; // Evaluates to false
```
Attempting to use non-boolean types will result in a compile-time `E0308` (mismatched types) error:
```rust theme={"dark"}
// Compilation error: expected `bool`, found integer
let invalid = 1 && true;
```
## Short-Circuit Evaluation
The `&&` operator employs strict left-to-right short-circuit (lazy) evaluation.
1. The left-hand operand is evaluated first.
2. If the left-hand operand evaluates to `false`, the overall expression immediately yields `false`.
3. The right-hand operand is **never evaluated** if the left-hand operand is `false`.
This behavior guarantees safe execution when the right-hand expression contains operations that could panic, cause side effects, or perform expensive computations.
```rust theme={"dark"}
fn expensive_computation() -> bool {
// This function is never called in the expression below
true
}
let is_valid = false;
// The right side is ignored; no panic occurs and the function is not invoked.
let result = is_valid && expensive_computation();
```
## Operator Precedence
In Rust's expression parsing, `&&` has a specific precedence level:
* **Lower than** comparison operators (`==`, `!=`, `<`, `>`, `<=`, `>=`) and bitwise operators (`&`, `|`, `^`).
* **Higher than** the logical OR operator (`||`) and assignment operators (`=`, `+=`, etc.).
Because it binds less tightly than comparison operators, parentheses are not required when combining relational expressions:
```rust theme={"dark"}
let x = 5;
let y = 10;
// Parsed as: (x > 0) && (y < 20)
let in_range = x > 0 && y < 20;
```
However, because `&&` binds more tightly than `||`, expressions mixing the two will evaluate the `&&` segments first:
```rust theme={"dark"}
let a = true;
let b = false;
let c = true;
// Parsed as: a || (b && c)
let mixed = a || b && c;
```
## Trait Implementation Restrictions
Unlike the bitwise AND operator (`&`), which can be overloaded for custom types via the `std::ops::BitAnd` trait, the logical `&&` operator **cannot be overloaded**.
Rust enforces this restriction at the language level to preserve the guarantee of short-circuit evaluation. If `&&` were backed by a trait method (e.g., `fn logical_and(self, rhs: Self)`), both operands would have to be fully evaluated before being passed as arguments to the function, which would fundamentally break short-circuiting semantics.
Tired of Poor Rust Skills? Fix That With Deep Grasping!
Learn More
