Trait std::convert::Into 1.0.0
[−]
[src]
pub trait Into<T> { fn into(self) -> T; }
A conversion that consumes self
, which may or may not be expensive. The
reciprocal of From
.
Note: this trait must not fail. If the conversion can fail, use
TryInto
or a dedicated method which returns an Option<T>
or a
Result<T, E>
.
Library authors should not directly implement this trait, but should prefer
implementing the From
trait, which offers greater flexibility and
provides an equivalent Into
implementation for free, thanks to a blanket
implementation in the standard library.
Generic Implementations
Implementing Into
There is one exception to implementing Into
, and it's kind of esoteric.
If the destination type is not part of the current crate, and it uses a
generic variable, then you can't implement From
directly. For example,
take this crate:
struct Wrapper<T>(Vec<T>); impl<T> From<Wrapper<T>> for Vec<T> { fn from(w: Wrapper<T>) -> Vec<T> { w.0 } }Run
To fix 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
This won't always allow the conversion: for example, try!
and ?
always use From
. However, in most cases, people use Into
to do the
conversions, and this will allow that.
In almost all cases, you should try to implement From
, then fall back
to Into
if From
can't be implemented.
Examples
String
implements Into<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.
Implementors
impl<T, U> Into<U> for T where
U: From<T>,