Logical NOT

In Rust, the ! (bang) symbol is a heavily overloaded syntactic construct that serves five distinct roles: a unary operator for logical and bitwise negation, the uninhabited “never” type, a token indicating macro invocation, a modifier for inner attributes, and the syntax for experimental negative trait implementations.

1. The Unary Operator (Logical and Bitwise NOT)

As an operator, ! performs logical negation on boolean types and bitwise negation (one’s complement) on integer types. It is the syntactic representation of the std::ops::Not trait. Unlike C or C++, which use ~ for bitwise negation, Rust unifies both operations under !.

The compiler determines the behavior based on the operand’s type:

// Logical NOT (bool)
let is_true: bool = true;
let is_false: bool = !is_true; 

// Bitwise NOT (integer types)
let bits: u8 = 0b1111_0000;
let inverted_bits: u8 = !bits; // Evaluates to 0b0000_1111

// Custom implementation via std::ops::Not
struct CustomType(bool);

impl std::ops::Not for CustomType {
    type Output = Self;
    fn not(self) -> Self::Output {
        CustomType(!self.0)
    }
}

2. The Never Type (!)

In type signatures, ! represents the “never” type, which is Rust’s implementation of a bottom type. It is an uninhabited type (or empty type), meaning it has exactly zero valid values.

Because it is uninhabited, a value of type ! can never be instantiated. This property indicates that an expression or function will never resolve to a value or return control to the caller (a diverging function). Consequently, the Rust type system allows ! to be safely coerced into any other type during compilation.

// The return type ! indicates this function diverges
fn diverge() -> ! {
    panic!("Execution stops here");
}

// Type coercion: The ! type from the `break` or `panic!` 
// coerces into the expected `i32` type of the variable.
let x: i32 = match Some(5) {
    Some(val) => val,
    None => panic!("Coerces to i32"), // Evaluates to !
};

3. Macro Invocation Token

When appended to an identifier or a path, ! acts as a syntax token indicating a macro invocation rather than a standard function call. It instructs the compiler that the construct operates on and expands Token Streams (or Token Trees) rather than evaluating standard expressions or Abstract Syntax Tree (AST) nodes.

fn do_something() {}

// Function call (no !)
do_something();

// Macro invocation via path (requires !)
std::println!("Expanded at compile time via token streams");

4. Inner Attributes

When placed immediately after a hash symbol in an attribute declaration (#![...]), the ! token designates an inner attribute. While outer attributes (#[...]) apply to the syntax item immediately following them, inner attributes apply to the item that encloses the attribute itself. This syntax is primarily used at the top of a file to declare crate-level or module-level properties, such as enabling unstable features, configuring lints, or declaring a #![no_std] environment.

// Inner attribute: Applies to the enclosing crate or module
#![no_std]
#![warn(missing_docs)]

// Outer attribute (no !): Applies only to the struct below it
#[derive(Debug)]
struct Example;

5. Negative Trait Implementations

In the trait system, the ! symbol is used to explicitly opt out of auto traits (such as Send or Sync). This syntax declares a negative trait implementation, instructing the compiler that a type explicitly does not implement a specific trait, overriding the compiler’s default auto-derivation behavior.

Explicit negative trait implementations are currently an experimental, nightly-only feature that requires the #![feature(negative_impls)] inner attribute.

#![feature(negative_impls)]

// String is Send by default
struct LocalData(String);

// Nightly-only: Explicitly overrides the compiler to opt out of the Send auto trait
impl !Send for LocalData {}

Because the ! syntax for trait implementations is unstable, developers targeting stable Rust must achieve this by embedding a marker type that inherently lacks the target auto trait. For example, raw pointers are inherently !Send and !Sync, so embedding std::marker::PhantomData<*const ()> acts as a stable mechanism to opt out of these auto traits for a struct that would otherwise automatically derive them.

use std::marker::PhantomData;

struct LocalDataStable {
    // String is Send and Sync by default
    data: String,
    // Stable Rust: Opts out of Send and Sync via PhantomData
    _marker: PhantomData<*const ()>,
}

Master Rust with Deep Grasping Methodology!

Learn More