# 1.0.0[−][src]Trait core::convert::Into

    pub trait Into<T>: Sized {
        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.

Loading content...

## Implementors

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

#### `fn into(self) -> U`[src]

Loading content...

# 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`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)