core::convert::Into - Rust
Description: API documentation for the Rust `Into` trait in crate `core`.
Keywords: rust, rustlang, rust-lang, Into

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

    pub trait Into<T>: Sized {
        fn into(self) -> T;
    }

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` implies `Into<U> for T`
- `Into` `is reflexive, which means that`Into 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:

ⓘ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

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.

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