Keywords - Rust for C-Programmers

5.1 Keywords

Keywords are reserved words that have special meanings in a programming language. In Rust, they define fundamental language constructs and cannot be used as regular identifiers (like variable names) unless you employ the raw identifier syntax described below. If you have experience with C/C++, many Rust keywords will look familiar, but Rust also introduces several new keywords to support features such as ownership, borrowing, and safe concurrency.

5.1.1 Raw Identifiers

When you encounter naming conflicts with Rust keywords—especially while integrating C code or using older Rust crates—you can use raw identifiers. By prefixing a keyword with r#, you tell the compiler to treat it only as an identifier, not as a reserved word. This is particularly helpful when C libraries or legacy Rust crates use names that became keywords in newer Rust editions.

For example, Rust 2024 introduces the keyword gen, which may have been used previously in legacy crates. If you need to call a function named gen from an older crate while compiling with Rust 2024, you can write r#gen(). Similarly, if you want a struct field named type, you can write r#type instead of typ or ty.

Below is a small example demonstrating raw identifiers:

fn main() {
    {
        let r#mod = 5;
        // 'mod' is a keyword in Rust, but here it's treated as a variable name
        println!("Value is {}", r#mod);

        // 'rust' is not a keyword, so the compiler treats 'rust' and 'r#rust' as the same identifier
        let mut rust = 1; 
        r#rust = 2;
        println!("{rust}");
        // Note that in format strings, you don't prefix keywords or raw identifiers with `r#`
        // println!("{r#rust}"); // This fails to compile
    }

    {
        let mut r#rust = 1;
        rust = 2;
        println!("{rust}");
    }

    struct T {
        r#type: i32
    }
    let h = T { r#type: 0 };
}

Because mod is a keyword, if you want to use that name for your own item, you must write r#mod. Although rust is not a keyword, writing r#rust is still permitted and can future-proof your code in case rust ever becomes a keyword. Note, however, that the println!() macro requires identifiers without the r# prefix in the format string.

Rust categorizes keywords into three groups: strict, reserved, and weak. Strict keywords are actively used by the language, reserved keywords are set aside for possible future use, and weak keywords apply only in certain contexts but can otherwise be used as identifiers.

5.1.2 Strict Keywords

Keyword	Description	C/C++ Equivalent
`as`	Casts types or renames imports	`typedef` (or `as` in C++)
`async`	Declares an async function	C++20 uses `co_await`
`await`	Suspends execution until an async operation completes	None (C++20 `co_await`)
`break`	Exits a loop or block prematurely	`break`
`const`	Declares a compile-time constant	`const`
`continue`	Skips the rest of the current loop iteration	`continue`
`crate`	Refers to the current crate/package	None
`dyn`	Indicates dynamic dispatch for trait objects	No direct equivalent
`else`	Introduces an alternative branch of an `if` statement	`else`
`enum`	Declares an enumeration	`enum`
`extern`	Links to external language functions or data	`extern`
`false`	Boolean literal	`false`
`fn`	Declares a function	`int`, `void`, etc. in C
`for`	Introduces a loop over an iterator or range	`for`
`gen`	Introduced in Rust 2024 (reserved for new language features)	None
`if`	Conditional branching	`if`
`impl`	Implements traits or methods for a type	None
`in`	Used in a `for` loop to iterate over a collection	Range-based `for` in C++
`let`	Declares a variable	No direct equivalent in C
`loop`	Creates an infinite loop	`while(true)`
`match`	Pattern matching	`switch` (loosely)
`mod`	Declares a module	None
`move`	Captures variables by value in closures	None
`mut`	Marks a variable or reference as mutable	No direct C equivalent
`pub`	Makes an item public (controls visibility)	`public` (C++ classes)
`ref`	Binds a variable by reference in a pattern	Similar to C++ `&`
`return`	Returns a value from a function	`return`
`self`	Refers to the current instance in `impl` blocks	C++ `this`
`Self`	Refers to the implementing type within `impl` or trait blocks	No direct C++ equivalent
`static`	Defines a static item or lifetime	`static`
`struct`	Declares a structure	`struct`
`super`	Refers to the parent module	No direct equivalent
`trait`	Declares a trait (interface-like feature)	Similar to abstract classes
`true`	Boolean literal	`true`
`type`	Defines a type alias or associated type	`typedef`
`unsafe`	Allows operations that bypass Rust’s safety checks	C is inherently unsafe
`use`	Imports items into a scope	`#include`, `using`
`where`	Places constraints on generic type parameters	None
`while`	Declares a loop with a condition	`while`

5.1.3 Reserved Keywords (For Future Use)

These keywords are reserved for potential future use in Rust. They have no current functionality but cannot be used as identifiers:

Reserved Keyword	C/C++ Equivalent
`abstract`	`abstract` (C++)
`become`	None
`box`	None
`do`	`do` (C)
`final`	`final` (C++)
`macro`	None
`override`	`override` (C++)
`priv`	`private` (C++)
`try`	`try` (C++)
`typeof`	`typeof` (GNU C)
`unsized`	None
`virtual`	`virtual` (C++)
`yield`	`yield` (C++)

5.1.4 Weak Keywords

Weak keywords have special meaning only in certain contexts. Outside those contexts, they can be used as identifiers:

macro_rules
union
'static
safe
raw

For example, you can declare a variable or method named union unless you are defining a union type.

5.1.5 Comparison with C/C++

Rust shares some keywords with C/C++ (e.g., if, else, while), so they will seem familiar. However, Rust includes keywords for language constructs not found in C, such as async, await, trait, and unsafe. Additionally, Rust keywords like mut, move, and ref convey or enforce ownership and borrowing rules at compile time, providing greater memory safety without relying on a garbage collector or manual memory management.