> ## 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 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:
```rust theme={"dark"}
// 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.
```rust theme={"dark"}
// 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.
```rust theme={"dark"}
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.
```rust theme={"dark"}
// 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.
```rust theme={"dark"}
#![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.
```rust theme={"dark"}
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 ()>,
}
```
Tired of Poor Rust Skills? Fix That With Deep Grasping!
Learn More
