# Error code E0277

You tried to use a type which doesn’t implement some trait in a place which expected that trait.

Erroneous code example:

ⓘ

    // here we declare the Foo trait with a bar method
    trait Foo {
        fn bar(&self);
    }

    // we now declare a function which takes an object implementing the Foo trait
    fn some_func<T: Foo>(foo: T) {
        foo.bar();
    }

    fn main() {
        // we now call the method with the i32 type, which doesn't implement
        // the Foo trait
        some_func(5i32); // error: the trait bound `i32 : Foo` is not satisfied
    }

Run

In order to fix this error, verify that the type you’re using does implement the trait. Example:

    trait Foo {
        fn bar(&self);
    }

    // we implement the trait on the i32 type
    impl Foo for i32 {
        fn bar(&self) {}
    }

    fn some_func<T: Foo>(foo: T) {
        foo.bar(); // we can now use this method since i32 implements the
                   // Foo trait
    }

    fn main() {
        some_func(5i32); // ok!
    }

Run

Or in a generic context, an erroneous code example would look like:

ⓘ

    fn some_func<T>(foo: T) {
        println!("{:?}", foo); // error: the trait `core::fmt::Debug` is not
                               //        implemented for the type `T`
    }

    fn main() {
        // We now call the method with the i32 type,
        // which *does* implement the Debug trait.
        some_func(5i32);
    }

Run

Note that the error here is in the definition of the generic function. Although we only call it with a parameter that does implement `Debug`, the compiler still rejects the function. It must work with all possible input types. In order to make this example compile, we need to restrict the generic type we’re accepting:

    use std::fmt;

    // Restrict the input type to types that implement Debug.
    fn some_func<T: fmt::Debug>(foo: T) {
        println!("{:?}", foo);
    }

    fn main() {
        // Calling the method is still fine, as i32 implements Debug.
        some_func(5i32);

        // This would fail to compile now:
        // struct WithoutDebug;
        // some_func(WithoutDebug);
    }

Run

Rust only looks at the signature of the called function, as such it must already specify all requirements that will be used for every type parameter.

Back to list of error codes