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; }