<link rel="stylesheet" href="../../noscript1.34.1.css">

1.0.0[][src]Trait std::convert::Into

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:

This example deliberately fails to compile
struct Wrapper<T>(Vec<T>);
impl<T> From<Wrapper<T>> for Vec<T> {
    fn from(w: Wrapper<T>) -> Vec<T> {

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> {

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.


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();

Required methods

fn into(self) -> T

Performs the conversion.

Loading content...


impl<T, U> Into<U> for T where
    U: From<T>, 

Loading content...