# Trait bitflags::__core::prelude::v1::Into [−] [src]

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

A conversion that consumes `self`, which may or may not be expensive.

Note: this trait must not fail. If the conversion can fail, use 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.

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

# Generic Impls

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

## Required Methods

### `fn into(self) -> T`

Performs the conversion.

## Implementors

- `impl Into for PathBuf`
- `impl<T, U> Into for T where U: From<T>`
- `impl Into for String`

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result

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