compiler/rustc_error_codes/src/error_codes/E0277.md

   1 You tried to use a type which doesn't implement some trait in a place which
   2 expected that trait.
   3
   4 Erroneous code example:
   5
   6 ```compile_fail,E0277
   7 // here we declare the Foo trait with a bar method
   8 trait Foo {
   9     fn bar(&self);
  10 }
  11
  12 // we now declare a function which takes an object implementing the Foo trait
  13 fn some_func<T: Foo>(foo: T) {
  14     foo.bar();
  15 }
  16
  17 fn main() {
  18     // we now call the method with the i32 type, which doesn't implement
  19     // the Foo trait
  20     some_func(5i32); // error: the trait bound `i32 : Foo` is not satisfied
  21 }
  22 ```
  23
  24 In order to fix this error, verify that the type you're using does implement
  25 the trait. Example:
  26
  27 ```
  28 trait Foo {
  29     fn bar(&self);
  30 }
  31
  32 // we implement the trait on the i32 type
  33 impl Foo for i32 {
  34     fn bar(&self) {}
  35 }
  36
  37 fn some_func<T: Foo>(foo: T) {
  38     foo.bar(); // we can now use this method since i32 implements the
  39                // Foo trait
  40 }
  41
  42 fn main() {
  43     some_func(5i32); // ok!
  44 }
  45 ```
  46
  47 Or in a generic context, an erroneous code example would look like:
  48
  49 ```compile_fail,E0277
  50 fn some_func<T>(foo: T) {
  51     println!("{:?}", foo); // error: the trait `core::fmt::Debug` is not
  52                            //        implemented for the type `T`
  53 }
  54
  55 fn main() {
  56     // We now call the method with the i32 type,
  57     // which *does* implement the Debug trait.
  58     some_func(5i32);
  59 }
  60 ```
  61
  62 Note that the error here is in the definition of the generic function. Although
  63 we only call it with a parameter that does implement `Debug`, the compiler
  64 still rejects the function. It must work with all possible input types. In
  65 order to make this example compile, we need to restrict the generic type we're
  66 accepting:
  67
  68 ```
  69 use std::fmt;
  70
  71 // Restrict the input type to types that implement Debug.
  72 fn some_func<T: fmt::Debug>(foo: T) {
  73     println!("{:?}", foo);
  74 }
  75
  76 fn main() {
  77     // Calling the method is still fine, as i32 implements Debug.
  78     some_func(5i32);
  79
  80     // This would fail to compile now:
  81     // struct WithoutDebug;
  82     // some_func(WithoutDebug);
  83 }
  84 ```
  85
  86 Rust only looks at the signature of the called function, as such it must
  87 already specify all requirements that will be used for every type parameter.