# 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

- `From<T>``for U` implies `Into<U> for T`
- `into` is reflexive, which means that `Into<T> for T` is implemented

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

- [src]
  `impl<T, U> Into<U> for T where
  U: From<T>,`

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)