Implicit Conversions
Rust will not automatically apply implicit conversions between types (unlike C++). You can see this in a program like this:
fn multiply(x: i16, y: i16) -> i16 { x * y } fn main() { let x: i8 = 15; let y: i16 = 1000; println!("{x} * {y} = {}", multiply(x, y)); }
The Rust integer types all implement the From<T>
and Into<T>
traits to let us convert between them. The From<T>
trait has a single from()
method and similarly, the Into<T>
trait has a single into()
method.
Implementing these traits is how a type expresses that it can be converted into
another type.
The standard library has an implementation of From<i8> for i16
, which means
that we can convert a variable x
of type i8
to an i16
by calling
i16::from(x)
. Or, simpler, with x.into()
, because From<i8> for i16
implementation automatically create an implementation of Into<i16> for i8
.
The same applies for your own From
implementations for your own types, so it is
sufficient to only implement From
to get a respective Into
implementation automatically.
-
Execute the above program and look at the compiler error.
-
Update the code above to use
into()
to do the conversion. -
Change the types of
x
andy
to other things (such asf32
,bool
,i128
) to see which types you can convert to which other types. Try converting small types to big types and the other way around. Check the standard library documentation to see ifFrom<T>
is implemented for the pairs you check.