Derive macro
A Rust derive macro is an attribute that automatically generates implementations of specified traits or related functionality for a type.
Write Powerful Rust Macros
A Rust derive attribute requests compiler or procedural generation of trait implementations for a type.
- How it is used
- Adds predictable functions or trait implementations to structs, enums, and unions while avoiding repetitive boilerplate.
- How deep it goes
- Explains additive token generation and gives a procedural-macro project setup, but defers detailed macro implementation.
- Examples
- Uses Debug, Clone, Default, PartialEq, and a custom Hello derive backed by Cargo, quote, syn, and two Rust crates.
- What you can do after
- Build it from scratch as a procedural-macro library and apply a custom derive to an application type.
Learn Rust in a Month of Lunches
A derive attribute is a Rust attribute that requests automatic implementation of specified traits for a type.
- How it is used
- Uses derive attributes to give structs and enums trait implementations without writing them manually.
- How deep it goes
- Explains attribute placement, multiple derives, compiler feedback, and when manual implementations are needed; does not teach writing derive macros.
- Examples
- Shows Debug-printed types, a struct deriving several traits, a failed Display derive, and a newtype combining derived and manual implementations.
- What you can do after
- Apply it via Rust’s `#[derive(...)]` attribute to request supported traits and recognize when a manual implementation is needed.
Read how Learn Rust in a Month of Lunches explains derive macro →
Idiomatic Rust
A derive attribute instructs the Rust compiler to generate implementations for specified traits or other derived functionality.
- How it is used
- Automates trait implementations and boilerplate for Rust types, while also serving as a common procedural-macro form.
- How deep it goes
- Explains built-in derives and sketches a custom procedural derive, but stops short of broader procedural-macro treatment.
- Examples
- Uses Clone, Debug, and Default on Pumpkin, contrasts a custom Default implementation, and derives PrintName for a struct.
- What you can do after
- Build it from scratch by implementing a procedural derive in a separate library crate that generates Rust syntax.
Refactoring to Rust
A derive is a Rust compiler directive that generates implementations of selected traits for a type.
- How it is used
- Generates Debug implementations so Result::unwrap can print error values during simple panic-based error handling.
- How deep it goes
- Defines compiler-generated trait implementations and demonstrates Debug through compilation errors and panic output, without covering custom derive mechanics.
- Examples
- Uses a FizzBuzz Error enum with GotNegative, #[derive(Debug)], cargo run, and compiler and panic diagnostics.
- What you can do after
- Apply it via #[derive(Debug)] to make an error type satisfy unwrap's Debug requirement and produce readable panic output.
Code Like a Pro in Rust
Trait derivation is Rust compiler support for automatically generating implementations of eligible traits for a type.
- How it is used
- Reduces handwritten trait implementations and declares clap command-line interfaces from Rust data definitions.
- How deep it goes
- Explains generated standard traits, field requirements, customization boundaries, and clap-based command declarations without detailing macro expansion internals.
- Examples
- Uses DebuggableStruct and a clap todo CLI with Parser and Subcommand derives.
- What you can do after
- Apply derive attributes to generate standard trait behavior and define clap command-line parsing structures.
Related concepts
- procedural macrokind of · A procedural macro is a Rust macro implemented as a program that transforms an input token stream into generated code during compilation.
- attribute macrocontrasts with · An attribute macro is a compile-time procedural transformation attached to a language item that generates replacement or additional code.
- traitproduces · A trait is a type-level construct that defines reusable behavior or members that types can implement or compose.
- functioncontrasts with · A function is a callable program unit that performs an operation, may accept inputs, and can produce a result or side effect.
- Debugconfigures · Debug is a Rust standard-library trait for formatting values in programmer-oriented diagnostic representations.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.