1.0.0[−][src]Trait std::convert::Into
A value-to-value conversion that consumes the input value. The
opposite of From
.
One should only implement Into
if a conversion to a type outside the current crate is
required. Otherwise one should always prefer implementing From
over Into
because
implementing From
automatically provides one with a implementation of Into
thanks to
the blanket implementation in the standard library. From
cannot do these type of
conversions because of Rust's orphaning rules.
Note: This trait must not fail. If the conversion can fail, use TryInto
.
Generic Implementations
From
<T> for U
impliesInto<U> for T
Into
is reflexive, which means thatInto<T> for T
is implemented
Implementing Into
for conversions to external types
If the destination type is not part of the current crate
then you can't implement From
directly.
For example, take this code:
struct Wrapper<T>(Vec<T>); impl<T> From<Wrapper<T>> for Vec<T> { fn from(w: Wrapper<T>) -> Vec<T> { w.0 } }Run
This will fail to compile because we cannot implement a trait for a type
if both the trait and the type are not defined by the current crate.
This is due to Rust's orphaning rules. To bypass this, you can implement Into
directly:
struct Wrapper<T>(Vec<T>); impl<T> Into<Vec<T>> for Wrapper<T> { fn into(self) -> Vec<T> { self.0 } }Run
It is important to understand that Into
does not provide a From
implementation
(as From
does with Into
). Therefore, you should always try to implement From
and then fall back to Into
if From
can't be implemented.
Prefer using Into
over From
when specifying trait bounds on a generic function
to ensure that types that only implement Into
can be used as well.
Examples
String
implements Into<Vec<u8>>
:
In order to express that we want a generic function to take all arguments that can be
converted to a specified type T
, we can use a trait bound of Into<T>
.
For example: The function is_hello
takes all arguments that can be converted into a
Vec<u8>
.
fn is_hello<T: Into<Vec<u8>>>(s: T) { let bytes = b"hello".to_vec(); assert_eq!(bytes, s.into()); } let s = "hello".to_string(); is_hello(s);Run
Required methods
fn into(self) -> T
Performs the conversion.