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.

let negated = !expression;

During compilation, Rust desugars this operation into a trait method call:

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.

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.

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.

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.

Master Rust with Deep Grasping Methodology!

Learn More