# 1.0.0[−][src]Trait std::convert::From

    pub trait From<T> {
    #[lang = "from"]    fn from(T) -> Self;
    }

Used to do value-to-value conversions while consuming the input value. It is the reciprocal of `Into`.

One should always prefer implementing `From` over `Into` because implementing `From` automatically provides one with an implementation of `Into` thanks to the blanket implementation in the standard library.

Only implement `Into` when targeting a version prior to Rust 1.41 and converting to a type outside the current crate. `From` was not able to do these types of conversions in earlier versions because of Rust's orphaning rules. See `Into` for more details.

Prefer using `Into` over using `From` when specifying trait bounds on a generic function. This way, types that directly implement `Into` can be used as arguments as well.

The `From` is also very useful when performing error handling. When constructing a function that is capable of failing, the return type will generally be of the form `Result<T, E>`. The `From` trait simplifies error handling by allowing a function to return a single error type that encapsulate multiple error types. See the "Examples" section and the book for more details.

Note: This trait must not fail. If the conversion can fail, use `TryFrom`.

# Generic Implementations

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

# Examples

`String` implements `From<&str>`:

An explicit conversion from a `&str` to a String is done as follows:

    let string = "hello".to_string();
    let other_string = String::from("hello");

    assert_eq!(string, other_string);

Run

While performing error handling it is often useful to implement `From` for your own error type. By converting underlying error types to our own custom error type that encapsulates the underlying error type, we can return a single error type without losing information on the underlying cause. The '?' operator automatically converts the underlying error type to our custom error type by calling `Into<CliError>::into` which is automatically provided when implementing `From`. The compiler then infers which implementation of `Into` should be used.

    use std::fs;
    use std::io;
    use std::num;

    enum CliError {
        IoError(io::Error),
        ParseError(num::ParseIntError),
    }

    impl From<io::Error> for CliError {
        fn from(error: io::Error) -> Self {
            CliError::IoError(error)
        }
    }

    impl From<num::ParseIntError> for CliError {
        fn from(error: num::ParseIntError) -> Self {
            CliError::ParseError(error)
        }
    }

    fn open_and_parse_file(file_name: &str) -> Result<i32, CliError> {
        let mut contents = fs::read_to_string(&file_name)?;
        let num: i32 = contents.trim().parse()?;
        Ok(num)
    }

Run

## Required methods

### `#[lang = "from"]fn from(T) -> Self`

Performs the conversion.

Loading content...

## Implementors

### `impl From<Infallible> for TryFromSliceError`[src]

#### `fn from(x: Infallible) -> TryFromSliceError`[src]

### `impl From<Infallible> for TryFromIntError`[src]

#### `fn from(x: Infallible) -> TryFromIntError`[src]

### `impl From<ErrorKind> for Error`[src]

Intended for use for errors not exposed to the user, where allocating onto the heap (for normal construction via Error::new) is too costly.

#### `fn from(kind: ErrorKind) -> Error`[src]

Converts an `ErrorKind` into an `Error`.

This conversion allocates a new error with a simple representation of error kind.

# Examples

    use std::io::{Error, ErrorKind};

    let not_found = ErrorKind::NotFound;
    let error = Error::from(not_found);
    assert_eq!("entity not found", format!("{}", error));

Run

### `impl From<[u8; 4]> for IpAddr`[src]

#### `fn from(octets: [u8; 4]) -> IpAddr`[src]

Creates an `IpAddr::V4` from a four element byte array.

# Examples

    use std::net::{IpAddr, Ipv4Addr};

    let addr = IpAddr::from([13u8, 12u8, 11u8, 10u8]);
    assert_eq!(IpAddr::V4(Ipv4Addr::new(13, 12, 11, 10)), addr);

Run

### `impl From<[u8; 4]> for Ipv4Addr`[src]

#### `fn from(octets: [u8; 4]) -> Ipv4Addr`[src]

Creates an `Ipv4Addr` from a four element byte array.

# Examples

    use std::net::Ipv4Addr;

    let addr = Ipv4Addr::from([13u8, 12u8, 11u8, 10u8]);
    assert_eq!(Ipv4Addr::new(13, 12, 11, 10), addr);

Run

### `impl From<[u8; 16]> for IpAddr`[src]

#### `fn from(octets: [u8; 16]) -> IpAddr`[src]

Creates an `IpAddr::V6` from a sixteen element byte array.

# Examples

    use std::net::{IpAddr, Ipv6Addr};

    let addr = IpAddr::from([
        25u8, 24u8, 23u8, 22u8, 21u8, 20u8, 19u8, 18u8,
        17u8, 16u8, 15u8, 14u8, 13u8, 12u8, 11u8, 10u8,
    ]);
    assert_eq!(
        IpAddr::V6(Ipv6Addr::new(
            0x1918, 0x1716,
            0x1514, 0x1312,
            0x1110, 0x0f0e,
            0x0d0c, 0x0b0a
        )),
        addr
    );

Run

### `impl From<[u8; 16]> for Ipv6Addr`[src]

#### `fn from(octets: [u8; 16]) -> Ipv6Addr`[src]

Creates an `Ipv6Addr` from a sixteen element byte array.

# Examples

    use std::net::Ipv6Addr;

    let addr = Ipv6Addr::from([
        25u8, 24u8, 23u8, 22u8, 21u8, 20u8, 19u8, 18u8,
        17u8, 16u8, 15u8, 14u8, 13u8, 12u8, 11u8, 10u8,
    ]);
    assert_eq!(
        Ipv6Addr::new(
            0x1918, 0x1716,
            0x1514, 0x1312,
            0x1110, 0x0f0e,
            0x0d0c, 0x0b0a
        ),
        addr
    );

Run

### `impl From<[u16; 8]> for IpAddr`[src]

#### `fn from(segments: [u16; 8]) -> IpAddr`[src]

Creates an `IpAddr::V6` from an eight element 16-bit array.

# Examples

    use std::net::{IpAddr, Ipv6Addr};

    let addr = IpAddr::from([
        525u16, 524u16, 523u16, 522u16,
        521u16, 520u16, 519u16, 518u16,
    ]);
    assert_eq!(
        IpAddr::V6(Ipv6Addr::new(
            0x20d, 0x20c,
            0x20b, 0x20a,
            0x209, 0x208,
            0x207, 0x206
        )),
        addr
    );

Run

### `impl From<[u16; 8]> for Ipv6Addr`[src]

#### `fn from(segments: [u16; 8]) -> Ipv6Addr`[src]

Creates an `Ipv6Addr` from an eight element 16-bit array.

# Examples

    use std::net::Ipv6Addr;

    let addr = Ipv6Addr::from([
        525u16, 524u16, 523u16, 522u16,
        521u16, 520u16, 519u16, 518u16,
    ]);
    assert_eq!(
        Ipv6Addr::new(
            0x20d, 0x20c,
            0x20b, 0x20a,
            0x209, 0x208,
            0x207, 0x206
        ),
        addr
    );

Run

### `impl From<bool> for i8`[src]

Converts a `bool` to a `i8`. The resulting value is `0` for `false` and `1` for `true` values.

# Examples

    assert_eq!(i8::from(true), 1);
    assert_eq!(i8::from(false), 0);

Run

#### `fn from(small: bool) -> i8`[src]

### `impl From<bool> for i16`[src]

Converts a `bool` to a `i16`. The resulting value is `0` for `false` and `1` for `true` values.

# Examples

    assert_eq!(i16::from(true), 1);
    assert_eq!(i16::from(false), 0);

Run

#### `fn from(small: bool) -> i16`[src]

### `impl From<bool> for i32`[src]

Converts a `bool` to a `i32`. The resulting value is `0` for `false` and `1` for `true` values.

# Examples

    assert_eq!(i32::from(true), 1);
    assert_eq!(i32::from(false), 0);

Run

#### `fn from(small: bool) -> i32`[src]

### `impl From<bool> for i64`[src]

Converts a `bool` to a `i64`. The resulting value is `0` for `false` and `1` for `true` values.

# Examples

    assert_eq!(i64::from(true), 1);
    assert_eq!(i64::from(false), 0);

Run

#### `fn from(small: bool) -> i64`[src]

### `impl From<bool> for i128`[src]

Converts a `bool` to a `i128`. The resulting value is `0` for `false` and `1` for `true` values.

# Examples

    assert_eq!(i128::from(true), 1);
    assert_eq!(i128::from(false), 0);

Run

#### `fn from(small: bool) -> i128`[src]

### `impl From<bool> for isize`[src]

Converts a `bool` to a `isize`. The resulting value is `0` for `false` and `1` for `true` values.

# Examples

    assert_eq!(isize::from(true), 1);
    assert_eq!(isize::from(false), 0);

Run

#### `fn from(small: bool) -> isize`[src]

### `impl From<bool> for u8`[src]

Converts a `bool` to a `u8`. The resulting value is `0` for `false` and `1` for `true` values.

# Examples

    assert_eq!(u8::from(true), 1);
    assert_eq!(u8::from(false), 0);

Run

#### `fn from(small: bool) -> u8`[src]

### `impl From<bool> for u16`[src]

Converts a `bool` to a `u16`. The resulting value is `0` for `false` and `1` for `true` values.

# Examples

    assert_eq!(u16::from(true), 1);
    assert_eq!(u16::from(false), 0);

Run

#### `fn from(small: bool) -> u16`[src]

### `impl From<bool> for u32`[src]

Converts a `bool` to a `u32`. The resulting value is `0` for `false` and `1` for `true` values.

# Examples

    assert_eq!(u32::from(true), 1);
    assert_eq!(u32::from(false), 0);

Run

#### `fn from(small: bool) -> u32`[src]

### `impl From<bool> for u64`[src]

Converts a `bool` to a `u64`. The resulting value is `0` for `false` and `1` for `true` values.

# Examples

    assert_eq!(u64::from(true), 1);
    assert_eq!(u64::from(false), 0);

Run

#### `fn from(small: bool) -> u64`[src]

### `impl From<bool> for u128`[src]

Converts a `bool` to a `u128`. The resulting value is `0` for `false` and `1` for `true` values.

# Examples

    assert_eq!(u128::from(true), 1);
    assert_eq!(u128::from(false), 0);

Run

#### `fn from(small: bool) -> u128`[src]

### `impl From<bool> for usize`[src]

Converts a `bool` to a `usize`. The resulting value is `0` for `false` and `1` for `true` values.

# Examples

    assert_eq!(usize::from(true), 1);
    assert_eq!(usize::from(false), 0);

Run

#### `fn from(small: bool) -> usize`[src]

### `impl From<bool> for AtomicBool`[src]

#### `fn from(b: bool) -> AtomicBool`[src]

Converts a `bool` into an `AtomicBool`.

# Examples

    use std::sync::atomic::AtomicBool;
    let atomic_bool = AtomicBool::from(true);
    assert_eq!(format!("{:?}", atomic_bool), "true")

Run

### `impl From<char> for u32`[src]

#### `fn from(c: char) -> u32`[src]

Converts a `char` into a `u32`.

# Examples

    use std::mem;

    let c = 'c';
    let u = u32::from(c);
    assert!(4 == mem::size_of_val(&u))

Run

### `impl From<char> for String`[src]

#### `fn from(c: char) -> String`[src]

### `impl From<f32> for f64`[src]

Converts `f32` to `f64` losslessly.

#### `fn from(small: f32) -> f64`[src]

### `impl From<i8> for f32`[src]

Converts `i8` to `f32` losslessly.

#### `fn from(small: i8) -> f32`[src]

### `impl From<i8> for f64`[src]

Converts `i8` to `f64` losslessly.

#### `fn from(small: i8) -> f64`[src]

### `impl From<i8> for i16`[src]

Converts `i8` to `i16` losslessly.

#### `fn from(small: i8) -> i16`[src]

### `impl From<i8> for i32`[src]

Converts `i8` to `i32` losslessly.

#### `fn from(small: i8) -> i32`[src]

### `impl From<i8> for i64`[src]

Converts `i8` to `i64` losslessly.

#### `fn from(small: i8) -> i64`[src]

### `impl From<i8> for i128`[src]

Converts `i8` to `i128` losslessly.

#### `fn from(small: i8) -> i128`[src]

### `impl From<i8> for isize`[src]

Converts `i8` to `isize` losslessly.

#### `fn from(small: i8) -> isize`[src]

### `impl From<i8> for AtomicI8`[src]

#### `fn from(v: i8) -> AtomicI8`[src]

Converts an `i8` into an `AtomicI8`.

### `impl From<i16> for f32`[src]

Converts `i16` to `f32` losslessly.

#### `fn from(small: i16) -> f32`[src]

### `impl From<i16> for f64`[src]

Converts `i16` to `f64` losslessly.

#### `fn from(small: i16) -> f64`[src]

### `impl From<i16> for i32`[src]

Converts `i16` to `i32` losslessly.

#### `fn from(small: i16) -> i32`[src]

### `impl From<i16> for i64`[src]

Converts `i16` to `i64` losslessly.

#### `fn from(small: i16) -> i64`[src]

### `impl From<i16> for i128`[src]

Converts `i16` to `i128` losslessly.

#### `fn from(small: i16) -> i128`[src]

### `impl From<i16> for isize`[src]

Converts `i16` to `isize` losslessly.

#### `fn from(small: i16) -> isize`[src]

### `impl From<i16> for AtomicI16`[src]

#### `fn from(v: i16) -> AtomicI16`[src]

Converts an `i16` into an `AtomicI16`.

### `impl From<i32> for f64`[src]

Converts `i32` to `f64` losslessly.

#### `fn from(small: i32) -> f64`[src]

### `impl From<i32> for i64`[src]

Converts `i32` to `i64` losslessly.

#### `fn from(small: i32) -> i64`[src]

### `impl From<i32> for i128`[src]

Converts `i32` to `i128` losslessly.

#### `fn from(small: i32) -> i128`[src]

### `impl From<i32> for AtomicI32`[src]

#### `fn from(v: i32) -> AtomicI32`[src]

Converts an `i32` into an `AtomicI32`.

### `impl From<i64> for i128`[src]

Converts `i64` to `i128` losslessly.

#### `fn from(small: i64) -> i128`[src]

### `impl From<i64> for AtomicI64`[src]

#### `fn from(v: i64) -> AtomicI64`[src]

Converts an `i64` into an `AtomicI64`.

### `impl From<isize> for AtomicIsize`[src]

#### `fn from(v: isize) -> AtomicIsize`[src]

Converts an `isize` into an `AtomicIsize`.

### `impl From<!> for Infallible`[src]

#### `fn from(x: !) -> Infallible`[src]

### `impl From<!> for TryFromIntError`[src]

#### `fn from(never: !) -> TryFromIntError`[src]

### `impl From<u8> for char`[src]

Maps a byte in 0x00..=0xFF to a `char` whose code point has the same value, in U+0000..=U+00FF.

Unicode is designed such that this effectively decodes bytes with the character encoding that IANA calls ISO-8859-1. This encoding is compatible with ASCII.

Note that this is different from ISO/IEC 8859-1 a.k.a. ISO 8859-1 (with one less hyphen), which leaves some "blanks", byte values that are not assigned to any character. ISO-8859-1 (the IANA one) assigns them to the C0 and C1 control codes.

Note that this is also different from Windows-1252 a.k.a. code page 1252, which is a superset ISO/IEC 8859-1 that assigns some (not all!) blanks to punctuation and various Latin characters.

To confuse things further, on the Web `ascii`, `iso-8859-1`, and `windows-1252` are all aliases for a superset of Windows-1252 that fills the remaining blanks with corresponding C0 and C1 control codes.

#### `fn from(i: u8) -> char`[src]

Converts a `u8` into a `char`.

# Examples

    use std::mem;

    let u = 32 as u8;
    let c = char::from(u);
    assert!(4 == mem::size_of_val(&c))

Run

### `impl From<u8> for f32`[src]

Converts `u8` to `f32` losslessly.

#### `fn from(small: u8) -> f32`[src]

### `impl From<u8> for f64`[src]

Converts `u8` to `f64` losslessly.

#### `fn from(small: u8) -> f64`[src]

### `impl From<u8> for i16`[src]

Converts `u8` to `i16` losslessly.

#### `fn from(small: u8) -> i16`[src]

### `impl From<u8> for i32`[src]

Converts `u8` to `i32` losslessly.

#### `fn from(small: u8) -> i32`[src]

### `impl From<u8> for i64`[src]

Converts `u8` to `i64` losslessly.

#### `fn from(small: u8) -> i64`[src]

### `impl From<u8> for i128`[src]

Converts `u8` to `i128` losslessly.

#### `fn from(small: u8) -> i128`[src]

### `impl From<u8> for isize`[src]

Converts `u8` to `isize` losslessly.

#### `fn from(small: u8) -> isize`[src]

### `impl From<u8> for u16`[src]

Converts `u8` to `u16` losslessly.

#### `fn from(small: u8) -> u16`[src]

### `impl From<u8> for u32`[src]

Converts `u8` to `u32` losslessly.

#### `fn from(small: u8) -> u32`[src]

### `impl From<u8> for u64`[src]

Converts `u8` to `u64` losslessly.

#### `fn from(small: u8) -> u64`[src]

### `impl From<u8> for u128`[src]

Converts `u8` to `u128` losslessly.

#### `fn from(small: u8) -> u128`[src]

### `impl From<u8> for usize`[src]

Converts `u8` to `usize` losslessly.

#### `fn from(small: u8) -> usize`[src]

### `impl From<u8> for AtomicU8`[src]

#### `fn from(v: u8) -> AtomicU8`[src]

Converts an `u8` into an `AtomicU8`.

### `impl From<u16> for f32`[src]

Converts `u16` to `f32` losslessly.

#### `fn from(small: u16) -> f32`[src]

### `impl From<u16> for f64`[src]

Converts `u16` to `f64` losslessly.

#### `fn from(small: u16) -> f64`[src]

### `impl From<u16> for i32`[src]

Converts `u16` to `i32` losslessly.

#### `fn from(small: u16) -> i32`[src]

### `impl From<u16> for i64`[src]

Converts `u16` to `i64` losslessly.

#### `fn from(small: u16) -> i64`[src]

### `impl From<u16> for i128`[src]

Converts `u16` to `i128` losslessly.

#### `fn from(small: u16) -> i128`[src]

### `impl From<u16> for u32`[src]

Converts `u16` to `u32` losslessly.

#### `fn from(small: u16) -> u32`[src]

### `impl From<u16> for u64`[src]

Converts `u16` to `u64` losslessly.

#### `fn from(small: u16) -> u64`[src]

### `impl From<u16> for u128`[src]

Converts `u16` to `u128` losslessly.

#### `fn from(small: u16) -> u128`[src]

### `impl From<u16> for usize`[src]

Converts `u16` to `usize` losslessly.

#### `fn from(small: u16) -> usize`[src]

### `impl From<u16> for AtomicU16`[src]

#### `fn from(v: u16) -> AtomicU16`[src]

Converts an `u16` into an `AtomicU16`.

### `impl From<u32> for f64`[src]

Converts `u32` to `f64` losslessly.

#### `fn from(small: u32) -> f64`[src]

### `impl From<u32> for i64`[src]

Converts `u32` to `i64` losslessly.

#### `fn from(small: u32) -> i64`[src]

### `impl From<u32> for i128`[src]

Converts `u32` to `i128` losslessly.

#### `fn from(small: u32) -> i128`[src]

### `impl From<u32> for u64`[src]

Converts `u32` to `u64` losslessly.

#### `fn from(small: u32) -> u64`[src]

### `impl From<u32> for u128`[src]

Converts `u32` to `u128` losslessly.

#### `fn from(small: u32) -> u128`[src]

### `impl From<u32> for Ipv4Addr`[src]

#### `fn from(ip: u32) -> Ipv4Addr`[src]

Converts a host byte order `u32` into an `Ipv4Addr`.

# Examples

    use std::net::Ipv4Addr;

    let addr = Ipv4Addr::from(0xcafebabe);
    assert_eq!(Ipv4Addr::new(0xca, 0xfe, 0xba, 0xbe), addr);

Run

### `impl From<u32> for AtomicU32`[src]

#### `fn from(v: u32) -> AtomicU32`[src]

Converts an `u32` into an `AtomicU32`.

### `impl From<u64> for i128`[src]

Converts `u64` to `i128` losslessly.

#### `fn from(small: u64) -> i128`[src]

### `impl From<u64> for u128`[src]

Converts `u64` to `u128` losslessly.

#### `fn from(small: u64) -> u128`[src]

### `impl From<u64> for AtomicU64`[src]

#### `fn from(v: u64) -> AtomicU64`[src]

Converts an `u64` into an `AtomicU64`.

### `impl From<u128> for Ipv6Addr`[src]

#### `fn from(ip: u128) -> Ipv6Addr`[src]

Convert a host byte order `u128` into an `Ipv6Addr`.

# Examples

    use std::net::Ipv6Addr;

    let addr = Ipv6Addr::from(0x102030405060708090A0B0C0D0E0F00D_u128);
    assert_eq!(
        Ipv6Addr::new(
            0x1020, 0x3040, 0x5060, 0x7080,
            0x90A0, 0xB0C0, 0xD0E0, 0xF00D,
        ),
        addr);

Run

### `impl From<usize> for AtomicUsize`[src]

#### `fn from(v: usize) -> AtomicUsize`[src]

Converts an `usize` into an `AtomicUsize`.

### `impl From<LayoutErr> for TryReserveError`[src]

#### `fn from(LayoutErr) -> TryReserveError`[src]

### `impl From<Box<str>> for Box<[u8]>`[src]

#### `fn from(s: Box<str>) -> Box<[u8]>ⓘ

### Notable traits for Box<F>

`impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<I> Iterator for Box<I> where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<R: Read + ?Sized> Read for Box<R>impl<W: Write + ?Sized> Write for Box<W>`
`[src]

Converts a `Box<str>>` into a `Box<[u8]>`

This conversion does not allocate on the heap and happens in place.

# Examples

    // create a Box<str> which will be used to create a Box<[u8]>
    let boxed: Box<str> = Box::from("hello");
    let boxed_str: Box<[u8]> = Box::from(boxed);

    // create a &[u8] which will be used to create a Box<[u8]>
    let slice: &[u8] = &[104, 101, 108, 108, 111];
    let boxed_slice = Box::from(slice);

    assert_eq!(boxed_slice, boxed_str);

Run

### `impl From<Box<str>> for String`[src]

#### `fn from(s: Box<str>) -> String`[src]

Converts the given boxed `str` slice to a `String`. It is notable that the `str` slice is owned.

# Examples

Basic usage:

    let s1: String = String::from("hello world");
    let s2: Box<str> = s1.into_boxed_str();
    let s3: String = String::from(s2);

    assert_eq!("hello world", s3)

Run

### `impl From<Box<CStr>> for CString`[src]

#### `fn from(s: Box<CStr>) -> CString`[src]

Converts a `Box``<CStr>` into a `CString` without copying or allocating.

### `impl From<Box<OsStr>> for OsString`[src]

#### `fn from(boxed: Box<OsStr>) -> OsString`[src]

Converts a `Box``<``OsStr``>` into a `OsString` without copying or allocating.

### `impl From<Box<Path>> for PathBuf`[src]

#### `fn from(boxed: Box<Path>) -> PathBuf`[src]

Converts a `Box<Path>` into a `PathBuf`

This conversion does not allocate or copy memory.

### `impl From<CString> for Box<CStr>`[src]

#### `fn from(s: CString) -> Box<CStr>ⓘ

### Notable traits for Box<F>

`impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<I> Iterator for Box<I> where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<R: Read + ?Sized> Read for Box<R>impl<W: Write + ?Sized> Write for Box<W>`
`[src]

Converts a `CString` into a `Box``<CStr>` without copying or allocating.

### `impl From<CString> for Rc<CStr>`[src]

#### `fn from(s: CString) -> Rc<CStr>`[src]

Converts a `CString` into a `Rc``<CStr>` without copying or allocating.

### `impl From<CString> for Arc<CStr>`[src]

#### `fn from(s: CString) -> Arc<CStr>`[src]

Converts a `CString` into a `Arc``<CStr>` without copying or allocating.

### `impl From<CString> for Vec<u8>`[src]

#### `fn from(s: CString) -> Vec<u8>ⓘ

### Notable traits for Vec<u8>

`impl Write for Vec<u8>`
`[src]

Converts a `CString` into a `Vec``<u8>`.

The conversion consumes the `CString`, and removes the terminating NUL byte.

### `impl From<NulError> for Error`[src]

#### `fn from(_: NulError) -> Error`[src]

Converts a `NulError` into a `io::Error`.

### `impl From<OsString> for Box<OsStr>`[src]

#### `fn from(s: OsString) -> Box<OsStr>ⓘ

### Notable traits for Box<F>

`impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<I> Iterator for Box<I> where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<R: Read + ?Sized> Read for Box<R>impl<W: Write + ?Sized> Write for Box<W>`
`[src]

Converts a `OsString` into a `Box``<OsStr>` without copying or allocating.

### `impl From<OsString> for PathBuf`[src]

#### `fn from(s: OsString) -> PathBuf`[src]

Converts a `OsString` into a `PathBuf`

This conversion does not allocate or copy memory.

### `impl From<OsString> for Rc<OsStr>`[src]

#### `fn from(s: OsString) -> Rc<OsStr>`[src]

Converts a `OsString` into a `Rc``<OsStr>` without copying or allocating.

### `impl From<OsString> for Arc<OsStr>`[src]

#### `fn from(s: OsString) -> Arc<OsStr>`[src]

Converts a `OsString` into a `Arc``<OsStr>` without copying or allocating.

### `impl From<File> for Stdio`[src]

#### `fn from(file: File) -> Stdio`[src]

Converts a `File` into a `Stdio`

# Examples

`File` will be converted to `Stdio` using `Stdio::from` under the hood.

    use std::fs::File;
    use std::process::Command;

    // With the `foo.txt` file containing `Hello, world!"
    let file = File::open("foo.txt").unwrap();

    let reverse = Command::new("rev")
        .stdin(file)  // Implicit File conversion into a Stdio
        .output()
        .expect("failed reverse command");

    assert_eq!(reverse.stdout, b"!dlrow ,olleH");

Run

### `impl From<Ipv4Addr> for IpAddr`[src]

#### `fn from(ipv4: Ipv4Addr) -> IpAddr`[src]

Copies this address to a new `IpAddr::V4`.

# Examples

    use std::net::{IpAddr, Ipv4Addr};

    let addr = Ipv4Addr::new(127, 0, 0, 1);

    assert_eq!(
        IpAddr::V4(addr),
        IpAddr::from(addr)
    )

Run

### `impl From<Ipv4Addr> for u32`[src]

#### `fn from(ip: Ipv4Addr) -> u32`[src]

Converts an `Ipv4Addr` into a host byte order `u32`.

# Examples

    use std::net::Ipv4Addr;

    let addr = Ipv4Addr::new(0xca, 0xfe, 0xba, 0xbe);
    assert_eq!(0xcafebabe, u32::from(addr));

Run

### `impl From<Ipv6Addr> for IpAddr`[src]

#### `fn from(ipv6: Ipv6Addr) -> IpAddr`[src]

Copies this address to a new `IpAddr::V6`.

# Examples

    use std::net::{IpAddr, Ipv6Addr};

    let addr = Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff);

    assert_eq!(
        IpAddr::V6(addr),
        IpAddr::from(addr)
    );

Run

### `impl From<Ipv6Addr> for u128`[src]

#### `fn from(ip: Ipv6Addr) -> u128`[src]

Convert an `Ipv6Addr` into a host byte order `u128`.

# Examples

    use std::net::Ipv6Addr;

    let addr = Ipv6Addr::new(
        0x1020, 0x3040, 0x5060, 0x7080,
        0x90A0, 0xB0C0, 0xD0E0, 0xF00D,
    );
    assert_eq!(0x102030405060708090A0B0C0D0E0F00D_u128, u128::from(addr));

Run

### `impl From<SocketAddrV4> for SocketAddr`[src]

#### `fn from(sock4: SocketAddrV4) -> SocketAddr`[src]

Converts a `SocketAddrV4` into a `SocketAddr::V4`.

### `impl From<SocketAddrV6> for SocketAddr`[src]

#### `fn from(sock6: SocketAddrV6) -> SocketAddr`[src]

Converts a `SocketAddrV6` into a `SocketAddr::V6`.

### `impl From<NonZeroI8> for i8`[src]

#### `fn from(nonzero: NonZeroI8) -> i8`[src]

Converts a `NonZeroI8` into an `i8`

### `impl From<NonZeroI8> for NonZeroI16`[src]

Converts `NonZeroI8` to `NonZeroI16` losslessly.

#### `fn from(small: NonZeroI8) -> NonZeroI16`[src]

### `impl From<NonZeroI8> for NonZeroI32`[src]

Converts `NonZeroI8` to `NonZeroI32` losslessly.

#### `fn from(small: NonZeroI8) -> NonZeroI32`[src]

### `impl From<NonZeroI8> for NonZeroI64`[src]

Converts `NonZeroI8` to `NonZeroI64` losslessly.

#### `fn from(small: NonZeroI8) -> NonZeroI64`[src]

### `impl From<NonZeroI8> for NonZeroI128`[src]

Converts `NonZeroI8` to `NonZeroI128` losslessly.

#### `fn from(small: NonZeroI8) -> NonZeroI128`[src]

### `impl From<NonZeroI8> for NonZeroIsize`[src]

Converts `NonZeroI8` to `NonZeroIsize` losslessly.

#### `fn from(small: NonZeroI8) -> NonZeroIsize`[src]

### `impl From<NonZeroI16> for i16`[src]

#### `fn from(nonzero: NonZeroI16) -> i16`[src]

Converts a `NonZeroI16` into an `i16`

### `impl From<NonZeroI16> for NonZeroI32`[src]

Converts `NonZeroI16` to `NonZeroI32` losslessly.

#### `fn from(small: NonZeroI16) -> NonZeroI32`[src]

### `impl From<NonZeroI16> for NonZeroI64`[src]

Converts `NonZeroI16` to `NonZeroI64` losslessly.

#### `fn from(small: NonZeroI16) -> NonZeroI64`[src]

### `impl From<NonZeroI16> for NonZeroI128`[src]

Converts `NonZeroI16` to `NonZeroI128` losslessly.

#### `fn from(small: NonZeroI16) -> NonZeroI128`[src]

### `impl From<NonZeroI16> for NonZeroIsize`[src]

Converts `NonZeroI16` to `NonZeroIsize` losslessly.

#### `fn from(small: NonZeroI16) -> NonZeroIsize`[src]

### `impl From<NonZeroI32> for i32`[src]

#### `fn from(nonzero: NonZeroI32) -> i32`[src]

Converts a `NonZeroI32` into an `i32`

### `impl From<NonZeroI32> for NonZeroI64`[src]

Converts `NonZeroI32` to `NonZeroI64` losslessly.

#### `fn from(small: NonZeroI32) -> NonZeroI64`[src]

### `impl From<NonZeroI32> for NonZeroI128`[src]

Converts `NonZeroI32` to `NonZeroI128` losslessly.

#### `fn from(small: NonZeroI32) -> NonZeroI128`[src]

### `impl From<NonZeroI64> for i64`[src]

#### `fn from(nonzero: NonZeroI64) -> i64`[src]

Converts a `NonZeroI64` into an `i64`

### `impl From<NonZeroI64> for NonZeroI128`[src]

Converts `NonZeroI64` to `NonZeroI128` losslessly.

#### `fn from(small: NonZeroI64) -> NonZeroI128`[src]

### `impl From<NonZeroI128> for i128`[src]

#### `fn from(nonzero: NonZeroI128) -> i128`[src]

Converts a `NonZeroI128` into an `i128`

### `impl From<NonZeroIsize> for isize`[src]

#### `fn from(nonzero: NonZeroIsize) -> isize`[src]

Converts a `NonZeroIsize` into an `isize`

### `impl From<NonZeroU8> for u8`[src]

#### `fn from(nonzero: NonZeroU8) -> u8`[src]

Converts a `NonZeroU8` into an `u8`

### `impl From<NonZeroU8> for NonZeroI16`[src]

Converts `NonZeroU8` to `NonZeroI16` losslessly.

#### `fn from(small: NonZeroU8) -> NonZeroI16`[src]

### `impl From<NonZeroU8> for NonZeroI32`[src]

Converts `NonZeroU8` to `NonZeroI32` losslessly.

#### `fn from(small: NonZeroU8) -> NonZeroI32`[src]

### `impl From<NonZeroU8> for NonZeroI64`[src]

Converts `NonZeroU8` to `NonZeroI64` losslessly.

#### `fn from(small: NonZeroU8) -> NonZeroI64`[src]

### `impl From<NonZeroU8> for NonZeroI128`[src]

Converts `NonZeroU8` to `NonZeroI128` losslessly.

#### `fn from(small: NonZeroU8) -> NonZeroI128`[src]

### `impl From<NonZeroU8> for NonZeroIsize`[src]

Converts `NonZeroU8` to `NonZeroIsize` losslessly.

#### `fn from(small: NonZeroU8) -> NonZeroIsize`[src]

### `impl From<NonZeroU8> for NonZeroU16`[src]

Converts `NonZeroU8` to `NonZeroU16` losslessly.

#### `fn from(small: NonZeroU8) -> NonZeroU16`[src]

### `impl From<NonZeroU8> for NonZeroU32`[src]

Converts `NonZeroU8` to `NonZeroU32` losslessly.

#### `fn from(small: NonZeroU8) -> NonZeroU32`[src]

### `impl From<NonZeroU8> for NonZeroU64`[src]

Converts `NonZeroU8` to `NonZeroU64` losslessly.

#### `fn from(small: NonZeroU8) -> NonZeroU64`[src]

### `impl From<NonZeroU8> for NonZeroU128`[src]

Converts `NonZeroU8` to `NonZeroU128` losslessly.

#### `fn from(small: NonZeroU8) -> NonZeroU128`[src]

### `impl From<NonZeroU8> for NonZeroUsize`[src]

Converts `NonZeroU8` to `NonZeroUsize` losslessly.

#### `fn from(small: NonZeroU8) -> NonZeroUsize`[src]

### `impl From<NonZeroU16> for u16`[src]

#### `fn from(nonzero: NonZeroU16) -> u16`[src]

Converts a `NonZeroU16` into an `u16`

### `impl From<NonZeroU16> for NonZeroI32`[src]

Converts `NonZeroU16` to `NonZeroI32` losslessly.

#### `fn from(small: NonZeroU16) -> NonZeroI32`[src]

### `impl From<NonZeroU16> for NonZeroI64`[src]

Converts `NonZeroU16` to `NonZeroI64` losslessly.

#### `fn from(small: NonZeroU16) -> NonZeroI64`[src]

### `impl From<NonZeroU16> for NonZeroI128`[src]

Converts `NonZeroU16` to `NonZeroI128` losslessly.

#### `fn from(small: NonZeroU16) -> NonZeroI128`[src]

### `impl From<NonZeroU16> for NonZeroU32`[src]

Converts `NonZeroU16` to `NonZeroU32` losslessly.

#### `fn from(small: NonZeroU16) -> NonZeroU32`[src]

### `impl From<NonZeroU16> for NonZeroU64`[src]

Converts `NonZeroU16` to `NonZeroU64` losslessly.

#### `fn from(small: NonZeroU16) -> NonZeroU64`[src]

### `impl From<NonZeroU16> for NonZeroU128`[src]

Converts `NonZeroU16` to `NonZeroU128` losslessly.

#### `fn from(small: NonZeroU16) -> NonZeroU128`[src]

### `impl From<NonZeroU16> for NonZeroUsize`[src]

Converts `NonZeroU16` to `NonZeroUsize` losslessly.

#### `fn from(small: NonZeroU16) -> NonZeroUsize`[src]

### `impl From<NonZeroU32> for u32`[src]

#### `fn from(nonzero: NonZeroU32) -> u32`[src]

Converts a `NonZeroU32` into an `u32`

### `impl From<NonZeroU32> for NonZeroI64`[src]

Converts `NonZeroU32` to `NonZeroI64` losslessly.

#### `fn from(small: NonZeroU32) -> NonZeroI64`[src]

### `impl From<NonZeroU32> for NonZeroI128`[src]

Converts `NonZeroU32` to `NonZeroI128` losslessly.

#### `fn from(small: NonZeroU32) -> NonZeroI128`[src]

### `impl From<NonZeroU32> for NonZeroU64`[src]

Converts `NonZeroU32` to `NonZeroU64` losslessly.

#### `fn from(small: NonZeroU32) -> NonZeroU64`[src]

### `impl From<NonZeroU32> for NonZeroU128`[src]

Converts `NonZeroU32` to `NonZeroU128` losslessly.

#### `fn from(small: NonZeroU32) -> NonZeroU128`[src]

### `impl From<NonZeroU64> for u64`[src]

#### `fn from(nonzero: NonZeroU64) -> u64`[src]

Converts a `NonZeroU64` into an `u64`

### `impl From<NonZeroU64> for NonZeroI128`[src]

Converts `NonZeroU64` to `NonZeroI128` losslessly.

#### `fn from(small: NonZeroU64) -> NonZeroI128`[src]

### `impl From<NonZeroU64> for NonZeroU128`[src]

Converts `NonZeroU64` to `NonZeroU128` losslessly.

#### `fn from(small: NonZeroU64) -> NonZeroU128`[src]

### `impl From<NonZeroU128> for u128`[src]

#### `fn from(nonzero: NonZeroU128) -> u128`[src]

Converts a `NonZeroU128` into an `u128`

### `impl From<NonZeroUsize> for usize`[src]

#### `fn from(nonzero: NonZeroUsize) -> usize`[src]

Converts a `NonZeroUsize` into an `usize`

### `impl From<PathBuf> for Box<Path>`[src]

#### `fn from(p: PathBuf) -> Box<Path>ⓘ

### Notable traits for Box<F>

`impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<I> Iterator for Box<I> where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<R: Read + ?Sized> Read for Box<R>impl<W: Write + ?Sized> Write for Box<W>`
`[src]

Converts a `PathBuf` into a `Box<Path>`

This conversion currently should not allocate memory, but this behavior is not guaranteed on all platforms or in all future versions.

### `impl From<PathBuf> for OsString`[src]

#### `fn from(path_buf: PathBuf) -> OsString`[src]

Converts a `PathBuf` into a `OsString`

This conversion does not allocate or copy memory.

### `impl From<PathBuf> for Rc<Path>`[src]

#### `fn from(s: PathBuf) -> Rc<Path>`[src]

Converts a `PathBuf` into an `Rc` by moving the `PathBuf` data into a new `Rc` buffer.

### `impl From<PathBuf> for Arc<Path>`[src]

#### `fn from(s: PathBuf) -> Arc<Path>`[src]

Converts a `PathBuf` into an `Arc` by moving the `PathBuf` data into a new `Arc` buffer.

### `impl From<ChildStderr> for Stdio`[src]

#### `fn from(child: ChildStderr) -> Stdio`[src]

Converts a `ChildStderr` into a `Stdio`

# Examples

    use std::process::{Command, Stdio};

    let reverse = Command::new("rev")
        .arg("non_existing_file.txt")
        .stderr(Stdio::piped())
        .spawn()
        .expect("failed reverse command");

    let cat = Command::new("cat")
        .arg("-")
        .stdin(reverse.stderr.unwrap()) // Converted into a Stdio here
        .output()
        .expect("failed echo command");

    assert_eq!(
        String::from_utf8_lossy(&cat.stdout),
        "rev: cannot open non_existing_file.txt: No such file or directory\n"
    );

Run

### `impl From<ChildStdin> for Stdio`[src]

#### `fn from(child: ChildStdin) -> Stdio`[src]

Converts a `ChildStdin` into a `Stdio`

# Examples

`ChildStdin` will be converted to `Stdio` using `Stdio::from` under the hood.

    use std::process::{Command, Stdio};

    let reverse = Command::new("rev")
        .stdin(Stdio::piped())
        .spawn()
        .expect("failed reverse command");

    let _echo = Command::new("echo")
        .arg("Hello, world!")
        .stdout(reverse.stdin.unwrap()) // Converted into a Stdio here
        .output()
        .expect("failed echo command");

    // "!dlrow ,olleH" echoed to console

Run

### `impl From<ChildStdout> for Stdio`[src]

#### `fn from(child: ChildStdout) -> Stdio`[src]

Converts a `ChildStdout` into a `Stdio`

# Examples

`ChildStdout` will be converted to `Stdio` using `Stdio::from` under the hood.

    use std::process::{Command, Stdio};

    let hello = Command::new("echo")
        .arg("Hello, world!")
        .stdout(Stdio::piped())
        .spawn()
        .expect("failed echo command");

    let reverse = Command::new("rev")
        .stdin(hello.stdout.unwrap())  // Converted into a Stdio here
        .output()
        .expect("failed reverse command");

    assert_eq!(reverse.stdout, b"!dlrow ,olleH\n");

Run

### `impl From<String> for Box<str>`[src]

#### `fn from(s: String) -> Box<str>ⓘ

### Notable traits for Box<F>

`impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<I> Iterator for Box<I> where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<R: Read + ?Sized> Read for Box<R>impl<W: Write + ?Sized> Write for Box<W>`
`[src]

Converts the given `String` to a boxed `str` slice that is owned.

# Examples

Basic usage:

    let s1: String = String::from("hello world");
    let s2: Box<str> = Box::from(s1);
    let s3: String = String::from(s2);

    assert_eq!("hello world", s3)

Run

### `impl From<String> for Box<dyn Error + Send + Sync>`[src]

#### `fn from(err: String) -> Box<dyn Error + Send + Sync>ⓘ

### Notable traits for Box<F>

`impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<I> Iterator for Box<I> where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<R: Read + ?Sized> Read for Box<R>impl<W: Write + ?Sized> Write for Box<W>`
`[src]

Converts a `String` into a box of dyn `Error` + `Send` + `Sync`.

# Examples

    use std::error::Error;
    use std::mem;

    let a_string_error = "a string error".to_string();
    let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_string_error);
    assert!(
        mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))

Run

### `impl From<String> for Box<dyn Error>`[src]

#### `fn from(str_err: String) -> Box<dyn Error>ⓘ

### Notable traits for Box<F>

`impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<I> Iterator for Box<I> where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<R: Read + ?Sized> Read for Box<R>impl<W: Write + ?Sized> Write for Box<W>`
`[src]

Converts a `String` into a box of dyn `Error`.

# Examples

    use std::error::Error;
    use std::mem;

    let a_string_error = "a string error".to_string();
    let a_boxed_error = Box::<dyn Error>::from(a_string_error);
    assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))

Run

### `impl From<String> for OsString`[src]

#### `fn from(s: String) -> OsString`[src]

Converts a `String` into a `OsString`.

The conversion copies the data, and includes an allocation on the heap.

### `impl From<String> for PathBuf`[src]

#### `fn from(s: String) -> PathBuf`[src]

Converts a `String` into a `PathBuf`

This conversion does not allocate or copy memory.

### `impl From<String> for Rc<str>`[src]

#### `fn from(v: String) -> Rc<str>`[src]

### `impl From<String> for Arc<str>`[src]

#### `fn from(v: String) -> Arc<str>`[src]

### `impl From<String> for Vec<u8>`[src]

#### `fn from(string: String) -> Vec<u8>ⓘ

### Notable traits for Vec<u8>

`impl Write for Vec<u8>`
`[src]

Converts the given `String` to a vector `Vec` that holds values of type `u8`.

# Examples

Basic usage:

    let s1 = String::from("hello world");
    let v1 = Vec::from(s1);

    for b in v1 {
        println!("{}", b);
    }

Run

### `impl From<RecvError> for RecvTimeoutError`[src]

#### `fn from(err: RecvError) -> RecvTimeoutError`[src]

### `impl From<RecvError> for TryRecvError`[src]

#### `fn from(err: RecvError) -> TryRecvError`[src]

### `impl From<Vec<NonZeroU8>> for CString`[src]

#### `fn from(v: Vec<NonZeroU8>) -> CString`[src]

Converts a `Vec``<``NonZeroU8``>` into a `CString` without copying nor checking for inner null bytes.

### `impl From<StreamResult> for Result<MZStatus, MZError>`

#### `fn from(res: StreamResult) -> Result<MZStatus, MZError>`

### `impl<'_> From<&'_ str> for Box<str>`[src]

#### `fn from(s: &str) -> Box<str>ⓘ

### Notable traits for Box<F>

`impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<I> Iterator for Box<I> where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<R: Read + ?Sized> Read for Box<R>impl<W: Write + ?Sized> Write for Box<W>`
`[src]

Converts a `&str` into a `Box<str>`

This conversion allocates on the heap and performs a copy of `s`.

# Examples

    let boxed: Box<str> = Box::from("hello");
    println!("{}", boxed);

Run

### `impl<'_> From<&'_ str> for Box<dyn Error>`[src]

#### `fn from(err: &str) -> Box<dyn Error>ⓘ

### Notable traits for Box<F>

`impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<I> Iterator for Box<I> where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<R: Read + ?Sized> Read for Box<R>impl<W: Write + ?Sized> Write for Box<W>`
`[src]

Converts a `str` into a box of dyn `Error`.

# Examples

    use std::error::Error;
    use std::mem;

    let a_str_error = "a str error";
    let a_boxed_error = Box::<dyn Error>::from(a_str_error);
    assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))

Run

### `impl<'_> From<&'_ str> for Rc<str>`[src]

#### `fn from(v: &str) -> Rc<str>`[src]

### `impl<'_> From<&'_ str> for String`[src]

#### `fn from(s: &str) -> String`[src]

### `impl<'_> From<&'_ str> for Arc<str>`[src]

#### `fn from(v: &str) -> Arc<str>`[src]

### `impl<'_> From<&'_ str> for Vec<u8>`[src]

#### `fn from(s: &str) -> Vec<u8>ⓘ

### Notable traits for Vec<u8>

`impl Write for Vec<u8>`
`[src]

### `impl<'_> From<&'_ CStr> for Box<CStr>`[src]

#### `fn from(s: &CStr) -> Box<CStr>ⓘ

### Notable traits for Box<F>

`impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<I> Iterator for Box<I> where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<R: Read + ?Sized> Read for Box<R>impl<W: Write + ?Sized> Write for Box<W>`
`[src]

### `impl<'_> From<&'_ CStr> for CString`[src]

#### `fn from(s: &CStr) -> CString`[src]

### `impl<'_> From<&'_ CStr> for Rc<CStr>`[src]

#### `fn from(s: &CStr) -> Rc<CStr>`[src]

### `impl<'_> From<&'_ CStr> for Arc<CStr>`[src]

#### `fn from(s: &CStr) -> Arc<CStr>`[src]

### `impl<'_> From<&'_ OsStr> for Box<OsStr>`[src]

#### `fn from(s: &OsStr) -> Box<OsStr>ⓘ

### Notable traits for Box<F>

`impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<I> Iterator for Box<I> where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<R: Read + ?Sized> Read for Box<R>impl<W: Write + ?Sized> Write for Box<W>`
`[src]

### `impl<'_> From<&'_ OsStr> for Rc<OsStr>`[src]

#### `fn from(s: &OsStr) -> Rc<OsStr>`[src]

### `impl<'_> From<&'_ OsStr> for Arc<OsStr>`[src]

#### `fn from(s: &OsStr) -> Arc<OsStr>`[src]

### `impl<'_> From<&'_ Path> for Box<Path>`[src]

#### `fn from(path: &Path) -> Box<Path>ⓘ

### Notable traits for Box<F>

`impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<I> Iterator for Box<I> where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<R: Read + ?Sized> Read for Box<R>impl<W: Write + ?Sized> Write for Box<W>`
`[src]

### `impl<'_> From<&'_ Path> for Rc<Path>`[src]

#### `fn from(s: &Path) -> Rc<Path>`[src]

Converts a `Path` into an `Rc` by copying the `Path` data into a new `Rc` buffer.

### `impl<'_> From<&'_ Path> for Arc<Path>`[src]

#### `fn from(s: &Path) -> Arc<Path>`[src]

Converts a `Path` into an `Arc` by copying the `Path` data into a new `Arc` buffer.

### `impl<'_> From<&'_ String> for String`[src]

#### `fn from(s: &String) -> String`[src]

### `impl<'_> From<&'_ StreamResult> for Result<MZStatus, MZError>`

#### `fn from(res: &StreamResult) -> Result<MZStatus, MZError>`

### `impl<'_> From<&'_ mut str> for String`[src]

#### `fn from(s: &mut str) -> String`[src]

Converts a `&mut str` into a `String`.

The result is allocated on the heap.

### `impl<'_> From<Cow<'_, str>> for Box<str>`[src]

#### `fn from(cow: Cow<'_, str>) -> Box<str>ⓘ

### Notable traits for Box<F>

`impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<I> Iterator for Box<I> where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<R: Read + ?Sized> Read for Box<R>impl<W: Write + ?Sized> Write for Box<W>`
`[src]

### `impl<'_> From<Cow<'_, CStr>> for Box<CStr>`[src]

#### `fn from(cow: Cow<'_, CStr>) -> Box<CStr>ⓘ

### Notable traits for Box<F>

`impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<I> Iterator for Box<I> where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<R: Read + ?Sized> Read for Box<R>impl<W: Write + ?Sized> Write for Box<W>`
`[src]

### `impl<'_> From<Cow<'_, OsStr>> for Box<OsStr>`[src]

#### `fn from(cow: Cow<'_, OsStr>) -> Box<OsStr>ⓘ

### Notable traits for Box<F>

`impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<I> Iterator for Box<I> where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<R: Read + ?Sized> Read for Box<R>impl<W: Write + ?Sized> Write for Box<W>`
`[src]

### `impl<'_> From<Cow<'_, Path>> for Box<Path>`[src]

#### `fn from(cow: Cow<'_, Path>) -> Box<Path>ⓘ

### Notable traits for Box<F>

`impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<I> Iterator for Box<I> where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<R: Read + ?Sized> Read for Box<R>impl<W: Write + ?Sized> Write for Box<W>`
`[src]

### `impl<'_, T> From<Cow<'_, [T]>> for Box<[T]> where
T: Copy,` [src]

#### `fn from(cow: Cow<'_, [T]>) -> Box<[T]>ⓘ

### Notable traits for Box<F>

`impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<I> Iterator for Box<I> where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<R: Read + ?Sized> Read for Box<R>impl<W: Write + ?Sized> Write for Box<W>`
`[src]

### `impl<'_, T> From<&'_ T> for NonNull<T> where
T: ?Sized,` [src]

#### `fn from(reference: &T) -> NonNull<T>`[src]

### `impl<'_, T> From<&'_ mut T> for NonNull<T> where
T: ?Sized,` [src]

#### `fn from(reference: &mut T) -> NonNull<T>`[src]

### `impl<'_, T> From<&'_ [T]> for Box<[T]> where
T: Copy,` [src]

#### `fn from(slice: &[T]) -> Box<[T]>ⓘ

### Notable traits for Box<F>

`impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<I> Iterator for Box<I> where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<R: Read + ?Sized> Read for Box<R>impl<W: Write + ?Sized> Write for Box<W>`
`[src]

Converts a `&[T]` into a `Box<[T]>`

This conversion allocates on the heap and performs a copy of `slice`.

# Examples

    // create a &[u8] which will be used to create a Box<[u8]>
    let slice: &[u8] = &[104, 101, 108, 108, 111];
    let boxed_slice: Box<[u8]> = Box::from(slice);

    println!("{:?}", boxed_slice);

Run

### `impl<'_, T> From<&'_ [T]> for Rc<[T]> where
T: Clone,` [src]

#### `fn from(v: &[T]) -> Rc<[T]>`[src]

### `impl<'_, T> From<&'_ [T]> for Arc<[T]> where
T: Clone,` [src]

#### `fn from(v: &[T]) -> Arc<[T]>`[src]

### `impl<'_, T> From<&'_ [T]> for Vec<T> where
T: Clone,` [src]

#### `fn from(s: &[T]) -> Vec<T>ⓘ

### Notable traits for Vec<u8>

`impl Write for Vec<u8>`
`[src]

### `impl<'_, T> From<&'_ mut [T]> for Vec<T> where
T: Clone,` [src]

#### `fn from(s: &mut [T]) -> Vec<T>ⓘ

### Notable traits for Vec<u8>

`impl Write for Vec<u8>`
`[src]

### `impl<'a> From<&'a str> for Cow<'a, str>`[src]

#### `fn from(s: &'a str) -> Cow<'a, str>`[src]

### `impl<'a> From<&'a CStr> for Cow<'a, CStr>`[src]

#### `fn from(s: &'a CStr) -> Cow<'a, CStr>`[src]

### `impl<'a> From<&'a CString> for Cow<'a, CStr>`[src]

#### `fn from(s: &'a CString) -> Cow<'a, CStr>`[src]

### `impl<'a> From<&'a OsStr> for Cow<'a, OsStr>`[src]

#### `fn from(s: &'a OsStr) -> Cow<'a, OsStr>`[src]

### `impl<'a> From<&'a OsString> for Cow<'a, OsStr>`[src]

#### `fn from(s: &'a OsString) -> Cow<'a, OsStr>`[src]

### `impl<'a> From<&'a Path> for Cow<'a, Path>`[src]

#### `fn from(s: &'a Path) -> Cow<'a, Path>`[src]

### `impl<'a> From<&'a PathBuf> for Cow<'a, Path>`[src]

#### `fn from(p: &'a PathBuf) -> Cow<'a, Path>`[src]

### `impl<'a> From<&'a String> for Cow<'a, str>`[src]

#### `fn from(s: &'a String) -> Cow<'a, str>`[src]

### `impl<'a> From<Cow<'a, str>> for Box<dyn Error>`[src]

#### `fn from(err: Cow<'a, str>) -> Box<dyn Error>ⓘ

### Notable traits for Box<F>

`impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<I> Iterator for Box<I> where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<R: Read + ?Sized> Read for Box<R>impl<W: Write + ?Sized> Write for Box<W>`
`[src]

Converts a `Cow` into a box of dyn `Error`.

# Examples

    use std::error::Error;
    use std::mem;
    use std::borrow::Cow;

    let a_cow_str_error = Cow::from("a str error");
    let a_boxed_error = Box::<dyn Error>::from(a_cow_str_error);
    assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))

Run

### `impl<'a> From<Cow<'a, str>> for String`[src]

#### `fn from(s: Cow<'a, str>) -> String`[src]

### `impl<'a> From<Cow<'a, CStr>> for CString`[src]

#### `fn from(s: Cow<'a, CStr>) -> Self`[src]

### `impl<'a> From<Cow<'a, OsStr>> for OsString`[src]

#### `fn from(s: Cow<'a, OsStr>) -> Self`[src]

### `impl<'a> From<Cow<'a, Path>> for PathBuf`[src]

#### `fn from(p: Cow<'a, Path>) -> Self`[src]

### `impl<'a> From<CString> for Cow<'a, CStr>`[src]

#### `fn from(s: CString) -> Cow<'a, CStr>`[src]

### `impl<'a> From<OsString> for Cow<'a, OsStr>`[src]

#### `fn from(s: OsString) -> Cow<'a, OsStr>`[src]

### `impl<'a> From<PathBuf> for Cow<'a, Path>`[src]

#### `fn from(s: PathBuf) -> Cow<'a, Path>`[src]

### `impl<'a> From<String> for Cow<'a, str>`[src]

#### `fn from(s: String) -> Cow<'a, str>`[src]

### `impl<'a, '_> From<&'_ str> for Box<dyn Error + Send + Sync + 'a>`[src]

#### `fn from(err: &str) -> Box<dyn Error + Send + Sync + 'a>ⓘ

### Notable traits for Box<F>

`impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<I> Iterator for Box<I> where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<R: Read + ?Sized> Read for Box<R>impl<W: Write + ?Sized> Write for Box<W>`
`[src]

Converts a `str` into a box of dyn `Error` + `Send` + `Sync`.

# Examples

    use std::error::Error;
    use std::mem;

    let a_str_error = "a str error";
    let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_str_error);
    assert!(
        mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))

Run

### `impl<'a, 'b> From<Cow<'b, str>> for Box<dyn Error + Send + Sync + 'a>`[src]

#### `fn from(err: Cow<'b, str>) -> Box<dyn Error + Send + Sync + 'a>ⓘ

### Notable traits for Box<F>

`impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<I> Iterator for Box<I> where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<R: Read + ?Sized> Read for Box<R>impl<W: Write + ?Sized> Write for Box<W>`
`[src]

Converts a `Cow` into a box of dyn `Error` + `Send` + `Sync`.

# Examples

    use std::error::Error;
    use std::mem;
    use std::borrow::Cow;

    let a_cow_str_error = Cow::from("a str error");
    let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_cow_str_error);
    assert!(
        mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))

Run

### `impl<'a, B> From<Cow<'a, B>> for Rc<B> where
B: ToOwned + ?Sized,
Rc<B>: From<&'a B>,
Rc<B>: From<<B as ToOwned>::Owned>,` [src]

#### `fn from(cow: Cow<'a, B>) -> Rc<B>`[src]

### `impl<'a, B> From<Cow<'a, B>> for Arc<B> where
B: ToOwned + ?Sized,
Arc<B>: From<&'a B>,
Arc<B>: From<<B as ToOwned>::Owned>,` [src]

#### `fn from(cow: Cow<'a, B>) -> Arc<B>`[src]

### `impl<'a, E: Error + 'a> From<E> for Box<dyn Error + 'a>`[src]

#### `fn from(err: E) -> Box<dyn Error + 'a>ⓘ

### Notable traits for Box<F>

`impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<I> Iterator for Box<I> where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<R: Read + ?Sized> Read for Box<R>impl<W: Write + ?Sized> Write for Box<W>`
`[src]

Converts a type of `Error` into a box of dyn `Error`.

# Examples

    use std::error::Error;
    use std::fmt;
    use std::mem;

    #[derive(Debug)]
    struct AnError;

    impl fmt::Display for AnError {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            write!(f , "An error")
        }
    }

    impl Error for AnError {}

    let an_error = AnError;
    assert!(0 == mem::size_of_val(&an_error));
    let a_boxed_error = Box::<dyn Error>::from(an_error);
    assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))

Run

### `impl<'a, E: Error + Send + Sync + 'a> From<E> for Box<dyn Error + Send + Sync + 'a>`[src]

#### `fn from(err: E) -> Box<dyn Error + Send + Sync + 'a>ⓘ

### Notable traits for Box<F>

`impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<I> Iterator for Box<I> where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<R: Read + ?Sized> Read for Box<R>impl<W: Write + ?Sized> Write for Box<W>`
`[src]

Converts a type of `Error` + `Send` + `Sync` into a box of dyn `Error` + `Send` + `Sync`.

# Examples

    use std::error::Error;
    use std::fmt;
    use std::mem;

    #[derive(Debug)]
    struct AnError;

    impl fmt::Display for AnError {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            write!(f , "An error")
        }
    }

    impl Error for AnError {}

    unsafe impl Send for AnError {}

    unsafe impl Sync for AnError {}

    let an_error = AnError;
    assert!(0 == mem::size_of_val(&an_error));
    let a_boxed_error = Box::<dyn Error + Send + Sync>::from(an_error);
    assert!(
        mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))

Run

### `impl<'a, T> From<&'a Option<T>> for Option<&'a T>`[src]

#### `fn from(o: &'a Option<T>) -> Option<&'a T>`[src]

Converts from `&Option<T>` to `Option<&T>`.

# Examples

Converts an `Option<``String``>` into an `Option<``usize``>`, preserving the original. The `map` method takes the `self` argument by value, consuming the original, so this technique uses `as_ref` to first take an `Option` to a reference to the value inside the original.

    let s: Option<String> = Some(String::from("Hello, Rustaceans!"));
    let o: Option<usize> = Option::from(&s).map(|ss: &String| ss.len());

    println!("Can still print s: {:?}", s);

    assert_eq!(o, Some(18));

Run

### `impl<'a, T> From<&'a Vec<T>> for Cow<'a, [T]> where
T: Clone,` [src]

#### `fn from(v: &'a Vec<T>) -> Cow<'a, [T]>`[src]

### `impl<'a, T> From<&'a mut Option<T>> for Option<&'a mut T>`[src]

#### `fn from(o: &'a mut Option<T>) -> Option<&'a mut T>`[src]

Converts from `&mut Option<T>` to `Option<&mut T>`

# Examples

    let mut s = Some(String::from("Hello"));
    let o: Option<&mut String> = Option::from(&mut s);

    match o {
        Some(t) => *t = String::from("Hello, Rustaceans!"),
        None => (),
    }

    assert_eq!(s, Some(String::from("Hello, Rustaceans!")));

Run

### `impl<'a, T> From<Cow<'a, [T]>> for Vec<T> where
[T]: ToOwned,
<[T] as ToOwned>::Owned == Vec<T>,` [src]

#### `fn from(s: Cow<'a, [T]>) -> Vec<T>ⓘ

### Notable traits for Vec<u8>

`impl Write for Vec<u8>`
`[src]

### `impl<'a, T> From<&'a [T]> for Cow<'a, [T]> where
T: Clone,` [src]

#### `fn from(s: &'a [T]) -> Cow<'a, [T]>`[src]

### `impl<'a, T> From<Vec<T>> for Cow<'a, [T]> where
T: Clone,` [src]

#### `fn from(v: Vec<T>) -> Cow<'a, [T]>`[src]

### `impl<I: Into<IpAddr>> From<(I, u16)> for SocketAddr`[src]

#### `fn from(pieces: (I, u16)) -> SocketAddr`[src]

Converts a tuple struct (Into<`IpAddr`>, `u16`) into a `SocketAddr`.

This conversion creates a `SocketAddr::V4` for a `IpAddr::V4` and creates a `SocketAddr::V6` for a `IpAddr::V6`.

`u16` is treated as port of the newly created `SocketAddr`.

### `impl<T> From<!> for T`[src]

Stability note: This impl does not yet exist, but we are "reserving space" to add it in the future. See rust-lang/rust#64715 for details.

#### `fn from(t: !) -> T`[src]

### `impl<T> From<*mut T> for AtomicPtr<T>`[src]

#### `fn from(p: *mut T) -> AtomicPtr<T>`[src]

### `impl<T> From<Box<[T]>> for Vec<T>`[src]

#### `fn from(s: Box<[T]>) -> Vec<T>ⓘ

### Notable traits for Vec<u8>

`impl Write for Vec<u8>`
`[src]

### `impl<T> From<Box<T>> for Pin<Box<T>> where
T: ?Sized,` [src]

#### `fn from(boxed: Box<T>) -> Pin<Box<T>>ⓘ

### Notable traits for Pin<P>

`impl<P> Future for Pin<P> where
P: Unpin + DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;`
`[src]

Converts a `Box<T>` into a `Pin<Box<T>>`

This conversion does not allocate on the heap and happens in place.

### `impl<T> From<Box<T>> for Rc<T> where
T: ?Sized,` [src]

#### `fn from(v: Box<T>) -> Rc<T>`[src]

### `impl<T> From<Box<T>> for Arc<T> where
T: ?Sized,` [src]

#### `fn from(v: Box<T>) -> Arc<T>`[src]

### `impl<T> From<BinaryHeap<T>> for Vec<T>`[src]

#### `fn from(heap: BinaryHeap<T>) -> Vec<T>ⓘ

### Notable traits for Vec<u8>

`impl Write for Vec<u8>`
`[src]

### `impl<T> From<VecDeque<T>> for Vec<T>`[src]

#### `fn from(other: VecDeque<T>) -> Vec<T>ⓘ

### Notable traits for Vec<u8>

`impl Write for Vec<u8>`
`[src]

Turn a `VecDeque<T>` into a `Vec<T>`.

This never needs to re-allocate, but does need to do O(n) data movement if the circular buffer doesn't happen to be at the beginning of the allocation.

# Examples

    use std::collections::VecDeque;

    // This one is *O*(1).
    let deque: VecDeque<_> = (1..5).collect();
    let ptr = deque.as_slices().0.as_ptr();
    let vec = Vec::from(deque);
    assert_eq!(vec, [1, 2, 3, 4]);
    assert_eq!(vec.as_ptr(), ptr);

    // This one needs data rearranging.
    let mut deque: VecDeque<_> = (1..5).collect();
    deque.push_front(9);
    deque.push_front(8);
    let ptr = deque.as_slices().1.as_ptr();
    let vec = Vec::from(deque);
    assert_eq!(vec, [8, 9, 1, 2, 3, 4]);
    assert_eq!(vec.as_ptr(), ptr);

Run

### `impl<T> From<SendError<T>> for TrySendError<T>`[src]

#### `fn from(err: SendError<T>) -> TrySendError<T>`[src]

### `impl<T> From<PoisonError<T>> for TryLockError<T>`[src]

#### `fn from(err: PoisonError<T>) -> TryLockError<T>`[src]

### `impl<T> From<Vec<T>> for Box<[T]>`[src]

#### `fn from(v: Vec<T>) -> Box<[T]>ⓘ

### Notable traits for Box<F>

`impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<I> Iterator for Box<I> where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<R: Read + ?Sized> Read for Box<R>impl<W: Write + ?Sized> Write for Box<W>`
`[src]

### `impl<T> From<Vec<T>> for BinaryHeap<T> where
T: Ord,` [src]

#### `fn from(vec: Vec<T>) -> BinaryHeap<T>`[src]

Converts a `Vec<T>` into a `BinaryHeap<T>`.

This conversion happens in-place, and has O(n) time complexity.

### `impl<T> From<Vec<T>> for VecDeque<T>`[src]

#### `fn from(other: Vec<T>) -> VecDeque<T>`[src]

Turn a `Vec<T>` into a `VecDeque<T>`.

This avoids reallocating where possible, but the conditions for that are strict, and subject to change, and so shouldn't be relied upon unless the `Vec<T>` came from `From<VecDeque<T>>` and hasn't been reallocated.

### `impl<T> From<Vec<T>> for Rc<[T]>`[src]

#### `fn from(v: Vec<T>) -> Rc<[T]>`[src]

### `impl<T> From<Vec<T>> for Arc<[T]>`[src]

#### `fn from(v: Vec<T>) -> Arc<[T]>`[src]

### `impl<T> From<T> for Option<T>`[src]

#### `fn from(val: T) -> Option<T>`[src]

Copies `val` into a new `Some`.

# Examples

    let o: Option<u8> = Option::from(67);

    assert_eq!(Some(67), o);

Run

### `impl<T> From<T> for Poll<T>`[src]

#### `fn from(t: T) -> Poll<T>`[src]

### `impl<T> From<T> for Box<T>`[src]

#### `fn from(t: T) -> Box<T>ⓘ

### Notable traits for Box<F>

`impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<I> Iterator for Box<I> where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<R: Read + ?Sized> Read for Box<R>impl<W: Write + ?Sized> Write for Box<W>`
`[src]

Converts a generic type `T` into a `Box<T>`

The conversion allocates on the heap and moves `t` from the stack into it.

# Examples

    let x = 5;
    let boxed = Box::new(5);

    assert_eq!(Box::from(x), boxed);

Run

### `impl<T> From<T> for Cell<T>`[src]

#### `fn from(t: T) -> Cell<T>`[src]

### `impl<T> From<T> for RefCell<T>`[src]

#### `fn from(t: T) -> RefCell<T>`[src]

### `impl<T> From<T> for UnsafeCell<T>`[src]

#### `fn from(t: T) -> UnsafeCell<T>`[src]

### `impl<T> From<T> for OnceCell<T>`[src]

#### `fn from(value: T) -> OnceCell<T>`[src]

### `impl<T> From<T> for SyncOnceCell<T>`[src]

#### `fn from(value: T) -> Self`[src]

### `impl<T> From<T> for Rc<T>`[src]

#### `fn from(t: T) -> Rc<T>`[src]

### `impl<T> From<T> for Arc<T>`[src]

#### `fn from(t: T) -> Arc<T>`[src]

### `impl<T> From<T> for Mutex<T>`[src]

#### `fn from(t: T) -> Self`[src]

Creates a new mutex in an unlocked state ready for use. This is equivalent to `Mutex::new`.

### `impl<T> From<T> for RwLock<T>`[src]

#### `fn from(t: T) -> Self`[src]

Creates a new instance of an `RwLock<T>` which is unlocked. This is equivalent to `RwLock::new`.

### `impl<T> From<T> for T`[src]

#### `fn from(t: T) -> T`[src]

### `impl<T> From<Unique<T>> for NonNull<T> where
T: ?Sized,` [src]

#### `fn from(unique: Unique<T>) -> NonNull<T>`[src]

### `impl<T, const N: usize> From<[T; N]> for Box<[T]>`[src]

#### `fn from(array: [T; N]) -> Box<[T]>ⓘ

### Notable traits for Box<F>

`impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<I> Iterator for Box<I> where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<R: Read + ?Sized> Read for Box<R>impl<W: Write + ?Sized> Write for Box<W>`
`[src]

Converts a `[T; N]` into a `Box<[T]>`

This conversion moves the array to newly heap-allocated memory.

# Examples

    let boxed: Box<[u8]> = Box::from([4, 2]);
    println!("{:?}", boxed);

Run

### `impl<T, const N: usize> From<[T; N]> for Vec<T>`[src]

#### `fn from(s: [T; N]) -> Vec<T>ⓘ

### Notable traits for Vec<u8>

`impl Write for Vec<u8>`
`[src]

### `impl<T: ?Sized + AsRef<OsStr>, '_> From<&'_ T> for OsString`[src]

#### `fn from(s: &T) -> OsString`[src]

### `impl<T: ?Sized + AsRef<OsStr>, '_> From<&'_ T> for PathBuf`[src]

#### `fn from(s: &T) -> PathBuf`[src]

### `impl<W> From<IntoInnerError<W>> for Error`[src]

#### `fn from(iie: IntoInnerError<W>) -> Error`[src]

### `impl<W> From<Arc<W>> for RawWaker where
W: 'static + Wake + Send + Sync,` [src]

#### `fn from(waker: Arc<W>) -> RawWaker`[src]

### `impl<W> From<Arc<W>> for Waker where
W: 'static + Wake + Send + Sync,` [src]

#### `fn from(waker: Arc<W>) -> Waker`[src]

Loading content...