Rust E0277 — the trait X is not implemented for Y

What causes this error

Rust's trait system requires explicit opt-in. When a function, operator, or macro requires a trait bound (`T: Debug`, `T: Clone`, `T: Send`), the type passed must implement that trait. Common triggers: using `println!("{:?}", value)` on a type without `Debug`, using `==` on a type without `PartialEq`, returning `T` from a generic function with a `Send + Sync` bound, or using `?` on a custom error type without `std::error::Error`.

How to fix it

1. 01

   step 1

   Derive common traits automatically

   Rust can automatically derive implementations for many traits if all fields also implement them. Use `#[derive(...)]` above the struct or enum definition.

   #[derive(
       Debug,      // enables {:?} printing
       Clone,      // enables .clone()
       PartialEq,  // enables == and !=
       Eq,         // total equality (requires PartialEq)
       Hash,       // enables use as HashMap key
       Default,    // enables MyStruct::default()
   )]
   struct Config {
       host: String,
       port: u16,
       timeout_ms: u64,
   }

   Copy
2. 02

   step 2

   Implement the trait manually when derive doesn't fit

   When automatic derivation isn't suitable — custom comparison logic, display format, or a trait that can't be derived — implement it manually.

   use std::fmt;
   
   struct Temperature(f64);
   
   // Custom Display (cannot be derived)
   impl fmt::Display for Temperature {
       fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
           write!(f, "{:.1}°C", self.0)
       }
   }
   
   // Custom PartialOrd for non-standard comparison
   use std::cmp::Ordering;
   impl PartialOrd for Temperature {
       fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
           self.0.partial_cmp(&other.0)
       }
   }

   Copy
3. 03

   step 3

   Implement std::error::Error to use ? operator on custom errors

   Custom error types used with `?` must implement `std::error::Error`. The easiest path is using the `thiserror` crate which derives it from an attribute.

   // Manual implementation
   use std::fmt;
   
   #[derive(Debug)]
   enum AppError {
       NotFound(String),
       IoError(std::io::Error),
   }
   
   impl fmt::Display for AppError {
       fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
           match self {
               AppError::NotFound(s) => write!(f, "not found: {}", s),
               AppError::IoError(e) => write!(f, "io error: {}", e),
           }
       }
   }
   
   impl std::error::Error for AppError {}
   
   // Or use thiserror crate (recommended for application code):
   // use thiserror::Error;
   // #[derive(Error, Debug)]
   // enum AppError {
   //     #[error("not found: {0}")]
   //     NotFound(String),
   // }

   Copy
4. 04

   step 4

   Fix Send + Sync requirements for async/thread contexts

   `tokio::spawn` and `std::thread::spawn` require `Send + Sync` on captured values. Types containing `Rc`, `RefCell`, or raw pointers are not Send. Use `Arc<Mutex<T>>` instead of `Rc<RefCell<T>>` for thread-safe shared ownership.

   use std::rc::Rc;
   
   // BAD — Rc is not Send
   let shared = Rc::new(42);
   tokio::spawn(async move {
       println!("{}", shared);  // ERROR: Rc cannot be sent between threads
   });
   
   // GOOD — Arc is Send + Sync
   use std::sync::Arc;
   let shared = Arc::new(42);
   tokio::spawn(async move {
       println!("{}", shared);  // OK
   });

   Copy

How to verify the fix

• `cargo build` passes without E0277 errors.
• All types used with `{:?}` derive `Debug`.
• `cargo clippy` shows no trait bound warnings.