How do I fix “cannot find derive macro in this scope”?

by

The compiler has a small set of built-in derive macros. For any others, you have to import the custom derives before they can be used.

Before Rust 1.30, you need to use #[macro_use] on the extern crate line of the crate providing the macros. With Rust 1.30 and up, you can use them instead.

In this case, you need to import FromPrimitive from the num_derive crate:

After Rust 1.30

use num_derive::FromPrimitive; // 0.2.4 (the derive)
use num_traits::FromPrimitive; // 0.2.6 (the trait)

Before Rust 1.30

#[macro_use]
extern crate num_derive; // 0.2.4
extern crate num_traits; // 0.2.6

use num_traits::FromPrimitive;

Usage

#[derive(Debug, FromPrimitive)]
pub enum MyEnum {
    Var1 = 1,
    Var2,
}

fn main() {
    println!("{:?}", MyEnum::from_u8(2));
}

Each project has their own crate containing their own derive macros. A small sample:

  • Num (e.g. FromPrimitive) => num_derive
  • Serde (e.g. Serialize, Deserialize) => serde_derive
  • Diesel (e.g. Insertable, Queryable) => diesel (it’s actually the same as the regular crate!)

Some crates re-export their derive macros. For example, you can use the derive feature of Serde and then import it from the serde crate directly:

[dependencies]
serde = { version = "1.0", features = ["derive"] }

use serde::{Serialize, Deserialize}; // imports both the trait and the derive macro

FromPrimitive was actually part of the standard library before Rust 1.0. It wasn’t useful enough to continue existing in the standard library, so it was moved to the external num crate. Some very old references might not have been updated for this change.

For more information about converting C-like enums to and from integers, see:

More Related Contents:

  1. Why is it legal to borrow a temporary?
  2. Package with both a library and a binary?
  3. How can I create my own data structure with an iterator that returns mutable references?
  4. Do mutable references have move semantics?
  5. What are the options to end a mutable borrow in Rust?
  6. How do I match enum values with an integer?
  7. How does Rust provide move semantics?
  8. How do I convert a Rust closure to a C-style callback?
  9. How do I use static lifetimes with threads?
  10. How can I create a function with a variable number of arguments?
  11. cannot borrow `self.x` as immutable because `*self` is also borrowed as mutable
  12. Using the same iterator multiple times in Rust
  13. Is it possible to return either a borrowed or owned type in Rust?
  14. How do I overcome match arms with incompatible types for structs implementing same trait?
  15. Example of how to use Conditional Compilation Macros in Rust
  16. How can I call a raw address from Rust?
  17. Is there a way to perform an index access to an instance of a struct?
  18. How to take ownership of T from Arc?
  19. Is there any trait that specifies numeric functionality?
  20. Why would I use divergent functions?
  21. How to generate statically linked executables?
  22. When is it necessary to circumvent Rust’s borrow checker?
  23. Why is Rust’s assert_eq! implemented using a match?
  24. Is there a list of all cfg features?
  25. Comparing every element in a vector with the next one
  26. How to repeat a static string at compile time
  27. Is there a good way to convert a Vec to an array?
  28. How to concatenate static strings in Rust
  29. How can I conditionally provide a default reference without performing unnecessary computation when it isn’t used?
  30. How can I build multiple binaries with Cargo?

Leave a Comment