In Rust, a procedural macro is a special kind of macro that operates on the abstract syntax tree (AST) of the code at compile time. Procedural macros allow you to define custom annotations or attributes, derive implementations for traits, or generate code based on the structure of the code being compiled.

Procedural macros are defined as external crates that provide custom derive macros, attribute macros, or function-like macros. They are invoked using special syntax in Rust code and are expanded by the compiler during the compilation process.

There are three types of procedural macros in Rust :

1. Custom Derive Macros : Custom derive macros enable you to automatically generate code for implementing common traits, such as `Clone`, `Debug`, or `Serialize`, for your own types. By defining a derive macro, you can annotate a struct or an enum with a custom attribute, triggering the expansion of the macro and the generation of the corresponding code.

2. Attribute Macros : Attribute macros allow you to define custom attributes that can be applied to various Rust constructs, such as functions, structs, or modules. When an attribute macro is invoked, it processes the annotated item and can generate additional code, modify the item, or perform other code transformations based on the attributes.

3. Function-Like Macros : Function-like macros are similar to regular macros in Rust but operate on the AST of the code being compiled. They are defined using the `macro_rules!` syntax or by using the `proc_macro` crate. Function-like macros allow you to define reusable code patterns that can be expanded and transformed into other code during compilation.

Procedural macros open up powerful metaprogramming capabilities in Rust, enabling code generation, automation, and custom annotations. They can be used to reduce boilerplate code, enforce coding conventions, integrate with external systems or frameworks, and provide abstractions tailored to specific use cases.

To create a procedural macro, you need to define a separate crate with the appropriate dependencies and export the necessary macros or functions as the crate's API. By using procedural macros, you can extend the capabilities of the Rust compiler and tailor the language to specific domain-specific requirements.