E0283 - Error codes index
Description: Book listing all Rust error codes

## Keyboard shortcuts

Press `←` or `→` to navigate between chapters

Press `S` or `/` to search in the book

Press `?` to show this help

Press `Esc` to hide this help

# Error code E0283

The compiler could not infer a type and asked for a type annotation.

Erroneous code example:

    #![allow(unused)]
    fn main() {
    let x = "hello".chars().rev().collect();
    }

This error indicates that type inference did not result in one unique possible type, and extra information is required. In most cases this can be provided by adding a type annotation. Sometimes you need to specify a generic type parameter manually.

A common example is the `collect` method on `Iterator`. It has a generic type parameter with a `FromIterator` bound, which for a `char` iterator is implemented by `Vec` and `String` among others. Consider the following snippet that reverses the characters of a string:

In the first code example, the compiler cannot infer what the type of `x` should be: `Vec<char>` and `String` are both suitable candidates. To specify which type to use, you can use a type annotation on `x`:

    #![allow(unused)]
    fn main() {
    let x: Vec<char> = "hello".chars().rev().collect();
    }

It is not necessary to annotate the full type. Once the ambiguity is resolved, the compiler can infer the rest:

    #![allow(unused)]
    fn main() {
    let x: Vec<_> = "hello".chars().rev().collect();
    }

Another way to provide the compiler with enough information, is to specify the generic type parameter:

    #![allow(unused)]
    fn main() {
    let x = "hello".chars().rev().collect::<Vec<char>>();
    }

Again, you need not specify the full type if the compiler can infer it:

    #![allow(unused)]
    fn main() {
    let x = "hello".chars().rev().collect::<Vec<_>>();
    }

We can see a self-contained example below:

    #![allow(unused)]
    fn main() {
    struct Foo;

    impl Into<u32> for Foo {
        fn into(self) -> u32 { 1 }
    }

    let foo = Foo;
    let bar: u32 = foo.into() * 1u32;
    }

This error can be solved by adding type annotations that provide the missing information to the compiler. In this case, the solution is to specify the trait’s type parameter:

    #![allow(unused)]
    fn main() {
    struct Foo;

    impl Into<u32> for Foo {
        fn into(self) -> u32 { 1 }
    }

    let foo = Foo;
    let bar: u32 = Into::<u32>::into(foo) * 1u32;
    }