> ## 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 Bitwise NOT
The `!` operator in Rust is a unary prefix operator that performs logical negation on boolean types and bitwise negation (one's complement) on integer types. Under the hood, applying the `!` operator is syntactic sugar for calling the `not` method provided by the `std::ops::Not` trait.
## Mechanics and Syntax
The operator is placed directly before the expression to be negated.
```rust theme={"dark"}
let negated = !expression;
```
During compilation, Rust desugars this operation into a trait method call:
```rust theme={"dark"}
let negated = std::ops::Not::not(expression);
```
## Type-Specific Behavior
**1. Logical Negation (`bool`)**
When applied to a `bool`, the `!` operator performs a logical NOT operation, yielding the inverse boolean value.
```rust theme={"dark"}
let t: bool = true;
let f: bool = !t; // Evaluates to false
```
**2. Bitwise Negation (Integers)**
When applied to signed or unsigned integer types (`u8`, `i32`, `usize`, etc.), the `!` operator acts as a bitwise NOT. It flips every bit in the underlying binary representation. Unlike C or C++, which use the `~` token for bitwise negation, Rust overloads the `!` token for both logical and bitwise operations.
```rust theme={"dark"}
let a: u8 = 0b0000_1111;
let b: u8 = !a; // Evaluates to 0b1111_0000 (240 in decimal)
```
## The `std::ops::Not` Trait
Custom types can overload the `!` operator by implementing the `std::ops::Not` trait. The trait defines an associated `Output` type, meaning the result of the negation does not strictly have to match the input type.
```rust theme={"dark"}
use std::ops::Not;
struct CustomType(bool);
impl Not for CustomType {
type Output = CustomType;
fn not(self) -> Self::Output {
CustomType(!self.0)
}
}
```
## Syntactic Disambiguation
In the Rust grammar, the `!` token serves three distinct, context-dependent roles. The unary operator must not be confused with:
* **Macro Invocation:** When appended to an identifier (e.g., `vec![]`, `println!()`), `!` denotes a macro call rather than a standard function call.
* **The Never Type:** When used in a type signature (e.g., `fn dead_end() -> !`), `!` represents the "never" type (an empty type), indicating a computation that diverges and never returns to its caller.
Tired of Poor Rust Skills? Fix That With Deep Grasping!
Learn More
