Type conversion is not special in Rust. It's just a function that takes the ownership of the value and returns the other type. So you can name convert functions anything. However, it's a convention to use
into_ prefixed name or to use
from_ prefixed constructor.
You can create any function for type conversion. However, if you want to provide generic interfaces, you'd better implement the
From trait. For instance, you should implement
Y when you want to convert from the
X type value to the
Y type value
From trait have an associated function named
from. You can call this function like
From::from(x). You also can call it like
Y::from(x) if the compiler cannot infer the type of the destination type.
From have an associated function, it makes you be able to specify the destination type.
From has an associated function instead of a method, but on the other hands, you cannot use it as a method, like
You should implement the
Into trait to use a method for type conversion. This trait allows a variable to be converted to another type with the method. You can use
Into::into, but no one needs to do it. It's merely a verbose code. Use
x.into() as long as the compiler can infer the destination type. Otherwise, use
Into are traits to provide a conversion function that would not fail. However, some conversions can fail.
For instance, converting from To do these conversions, you can use
i32 can fail because some values of
i128 are not in the range of
TryInto. For instance, Rust uses
TryFrom that returns
TryFromIntError on the failure for the above example.
into should have the same behavior. The different behavior confuses the users; in fact, you cannot implement them differently. If you simultaneously implement
Y, you would see the below error message.
error[E0119]: conflicting implementations of trait `std::convert::Into<X>` for type `Y`:
Into. It's called a blanket implementation.
Because of this blanket implementation, you'd better implement
From instead of
Into when you need a type converting method.
As far as I know, there is only one exception that you should implement
Into instead of
From. If the target type is a generic type that is not declared in the current crate, you cannot implement
From. It's the only case(at least as far as I know). The same rule is applied to