1.0.0[−][src]Trait tract_nnef::internal::tract_downcast_rs::__std::prelude::v1::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);

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

Required methods

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

Performs the conversion.

Loading content...

Implementations on Foreign Types

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

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

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

impl From<u8> for u32[src]

Converts u8 to u32 losslessly.

impl From<u8> for i128[src]

Converts u8 to i128 losslessly.

impl From<u8> for i16[src]

Converts u8 to i16 losslessly.

impl From<i8> for i128[src]

Converts i8 to i128 losslessly.

impl From<u16> for f64[src]

Converts u16 to f64 losslessly.

impl From<u64> for i128[src]

Converts u64 to i128 losslessly.

impl From<u8> for isize[src]

Converts u8 to isize losslessly.

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

impl From<i8> for f32[src]

Converts i8 to f32 losslessly.

impl From<i32> for f64[src]

Converts i32 to f64 losslessly.

impl From<u32> for i64[src]

Converts u32 to i64 losslessly.

impl From<i16> for i32[src]

Converts i16 to i32 losslessly.

impl From<i32> for i64[src]

Converts i32 to i64 losslessly.

impl From<NonZeroI32> for i32[src]

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

Converts a NonZeroI32 into an i32

impl From<i16> for f32[src]

Converts i16 to f32 losslessly.

impl From<u32> for i128[src]

Converts u32 to i128 losslessly.

impl From<NonZeroU128> for u128[src]

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

Converts a NonZeroU128 into an u128

impl From<i8> for isize[src]

Converts i8 to isize losslessly.

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

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

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

impl From<u16> for i64[src]

Converts u16 to i64 losslessly.

impl From<u8> for u64[src]

Converts u8 to u64 losslessly.

impl From<u8> for u16[src]

Converts u8 to u16 losslessly.

impl From<u32> for f64[src]

Converts u32 to f64 losslessly.

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

impl From<u16> for u64[src]

Converts u16 to u64 losslessly.

impl From<u32> for u128[src]

Converts u32 to u128 losslessly.

impl From<f32> for f64[src]

Converts f32 to f64 losslessly.

impl From<u64> for u128[src]

Converts u64 to u128 losslessly.

impl From<i8> for i64[src]

Converts i8 to i64 losslessly.

impl From<u16> for usize[src]

Converts u16 to usize losslessly.

impl From<NonZeroU16> for u16[src]

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

Converts a NonZeroU16 into an u16

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

impl From<i8> for i32[src]

Converts i8 to i32 losslessly.

impl From<i16> for f64[src]

Converts i16 to f64 losslessly.

impl From<u16> for f32[src]

Converts u16 to f32 losslessly.

impl From<u16> for u128[src]

Converts u16 to u128 losslessly.

impl From<NonZeroU64> for u64[src]

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

Converts a NonZeroU64 into an u64

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

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

impl From<u16> for u32[src]

Converts u16 to u32 losslessly.

impl From<u8> for f64[src]

Converts u8 to f64 losslessly.

impl From<NonZeroU32> for u32[src]

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

Converts a NonZeroU32 into an u32

impl From<NonZeroU8> for u8[src]

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

Converts a NonZeroU8 into an u8

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

impl From<i16> for isize[src]

Converts i16 to isize losslessly.

impl From<NonZeroI8> for i8[src]

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

Converts a NonZeroI8 into an i8

impl From<i8> for f64[src]

Converts i8 to f64 losslessly.

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

impl From<NonZeroI128> for i128[src]

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

Converts a NonZeroI128 into an i128

impl From<NonZeroUsize> for usize[src]

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

Converts a NonZeroUsize into an usize

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

impl From<NonZeroI64> for i64[src]

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

Converts a NonZeroI64 into an i64

impl From<u8> for usize[src]

Converts u8 to usize losslessly.

impl From<u32> for u64[src]

Converts u32 to u64 losslessly.

impl From<u8> for u128[src]

Converts u8 to u128 losslessly.

impl From<i32> for i128[src]

Converts i32 to i128 losslessly.

impl From<i16> for i64[src]

Converts i16 to i64 losslessly.

impl From<i16> for i128[src]

Converts i16 to i128 losslessly.

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

impl From<u8> for i64[src]

Converts u8 to i64 losslessly.

impl From<u8> for f32[src]

Converts u8 to f32 losslessly.

impl From<i64> for i128[src]

Converts i64 to i128 losslessly.

impl From<u16> for i32[src]

Converts u16 to i32 losslessly.

impl From<NonZeroI16> for i16[src]

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

Converts a NonZeroI16 into an i16

impl From<u16> for i128[src]

Converts u16 to i128 losslessly.

impl From<u8> for i32[src]

Converts u8 to i32 losslessly.

impl From<i8> for i16[src]

Converts i8 to i16 losslessly.

impl From<NonZeroIsize> for isize[src]

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

Converts a NonZeroIsize into an isize

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

impl<R> From<R> for DebugFrame<R> where
    R: Reader, 

impl<R> From<R> for DebugTypes<R>

impl<R> From<R> for DebugRanges<R>

impl<R> From<R> for DebugStrOffsets<R>

impl<T> From<T> for DebugFrameOffset<T>

impl<R> From<R> for DebugAranges<R> where
    R: Reader, 

impl<R> From<R> for DebugLoc<R>

impl<R> From<R> for DebugAbbrev<R>

impl<R> From<R> for DebugLocLists<R>

impl<R> From<R> for EhFrame<R> where
    R: Reader, 

impl<T> From<T> for EhFrameOffset<T>

impl<R> From<R> for DebugLine<R>

impl<R> From<R> for DebugAddr<R>

impl<R> From<R> for DebugInfo<R>

impl<R> From<R> for DebugPubTypes<R> where
    R: Reader, 

impl<R> From<R> for DebugLineStr<R>

impl<R> From<R> for DebugRngLists<R>

impl<R> From<R> for EhFrameHdr<R> where
    R: Reader, 

impl<R> From<R> for DebugPubNames<R> where
    R: Reader, 

impl<R> From<R> for DebugStr<R>

impl<E> From<Rel64<E>> for Rela64<E> where
    E: Endian, 

impl<E> From<Rel32<E>> for Rela32<E> where
    E: Endian, 

impl From<MZFlush> for TDEFLFlush

impl From<MZFlush> for TDEFLFlush

impl From<String> for ErrorKind[src]

impl<'a> From<&'a str> for Error[src]

impl From<Error> for Error[src]

Link to another ErrorChain.

impl<'a> From<&'a str> for ErrorKind[src]

impl From<ErrorKind> for Error[src]

impl From<String> for Error[src]

impl From<ErrorKind> for Error[src]

impl<'a> From<&'a str> for ErrorKind[src]

impl From<Error> for ErrorKind[src]

impl<'a> From<&'a str> for Error[src]

impl From<String> for Error[src]

impl From<ErrorKind> for ErrorKind[src]

Link to another ErrorChain.

impl From<Error> for Error[src]

Link to a std::io::Error type.

impl From<String> for ErrorKind[src]

impl From<Error> for ErrorKind[src]

impl From<Vec<BacktraceFrame>> for Backtrace[src]

impl<R> From<R> for DebugStrOffsets<R>

impl<R> From<R> for DebugPubTypes<R> where
    R: Reader, 

impl<R> From<R> for DebugLineStr<R>

impl<R> From<R> for DebugRanges<R>

impl<R> From<R> for DebugFrame<R> where
    R: Reader, 

impl<R> From<R> for DebugAranges<R> where
    R: Reader, 

impl<R> From<R> for DebugStr<R>

impl<T> From<T> for DebugFrameOffset<T>

impl<R> From<R> for DebugAbbrev<R>

impl<R> From<R> for DebugLoc<R>

impl<R> From<R> for DebugLocLists<R>

impl<R> From<R> for DebugInfo<R>

impl<R> From<R> for DebugAddr<R>

impl<T> From<T> for EhFrameOffset<T>

impl<R> From<R> for EhFrameHdr<R> where
    R: Reader, 

impl<R> From<R> for DebugLine<R>

impl<R> From<R> for DebugPubNames<R> where
    R: Reader, 

impl<R> From<R> for DebugTypes<R>

impl<R> From<R> for EhFrame<R> where
    R: Reader, 

impl<R> From<R> for DebugRngLists<R>

impl<E> From<Rel64<E>> for Rela64<E> where
    E: Endian, 

impl<E> From<Rel32<E>> for Rela32<E> where
    E: Endian, 

impl<A, B, C, D> From<(A, B, C, D)> for Zip<(<A as IntoIterator>::IntoIter, <B as IntoIterator>::IntoIter, <C as IntoIterator>::IntoIter, <D as IntoIterator>::IntoIter)> where
    A: IntoIterator,
    B: IntoIterator,
    C: IntoIterator,
    D: IntoIterator, [src]

impl<A, B, C> From<(A, B, C)> for Zip<(<A as IntoIterator>::IntoIter, <B as IntoIterator>::IntoIter, <C as IntoIterator>::IntoIter)> where
    A: IntoIterator,
    B: IntoIterator,
    C: IntoIterator, [src]

impl<A> From<(A,)> for Zip<(<A as IntoIterator>::IntoIter,)> where
    A: IntoIterator, [src]

impl<A, B> From<(A, B)> for Zip<(<A as IntoIterator>::IntoIter, <B as IntoIterator>::IntoIter)> where
    A: IntoIterator,
    B: IntoIterator, [src]

impl<A, B, C, D, E, F, G> From<(A, B, C, D, E, F, G)> for Zip<(<A as IntoIterator>::IntoIter, <B as IntoIterator>::IntoIter, <C as IntoIterator>::IntoIter, <D as IntoIterator>::IntoIter, <E as IntoIterator>::IntoIter, <F as IntoIterator>::IntoIter, <G as IntoIterator>::IntoIter)> where
    A: IntoIterator,
    B: IntoIterator,
    C: IntoIterator,
    D: IntoIterator,
    E: IntoIterator,
    F: IntoIterator,
    G: IntoIterator, [src]

impl<A, B, C, D, E, F> From<(A, B, C, D, E, F)> for Zip<(<A as IntoIterator>::IntoIter, <B as IntoIterator>::IntoIter, <C as IntoIterator>::IntoIter, <D as IntoIterator>::IntoIter, <E as IntoIterator>::IntoIter, <F as IntoIterator>::IntoIter)> where
    A: IntoIterator,
    B: IntoIterator,
    C: IntoIterator,
    D: IntoIterator,
    E: IntoIterator,
    F: IntoIterator, [src]

impl<A, B, C, D, E, F, G, H> From<(A, B, C, D, E, F, G, H)> for Zip<(<A as IntoIterator>::IntoIter, <B as IntoIterator>::IntoIter, <C as IntoIterator>::IntoIter, <D as IntoIterator>::IntoIter, <E as IntoIterator>::IntoIter, <F as IntoIterator>::IntoIter, <G as IntoIterator>::IntoIter, <H as IntoIterator>::IntoIter)> where
    A: IntoIterator,
    B: IntoIterator,
    C: IntoIterator,
    D: IntoIterator,
    E: IntoIterator,
    F: IntoIterator,
    G: IntoIterator,
    H: IntoIterator, [src]

impl<A, B, C, D, E> From<(A, B, C, D, E)> for Zip<(<A as IntoIterator>::IntoIter, <B as IntoIterator>::IntoIter, <C as IntoIterator>::IntoIter, <D as IntoIterator>::IntoIter, <E as IntoIterator>::IntoIter)> where
    A: IntoIterator,
    B: IntoIterator,
    C: IntoIterator,
    D: IntoIterator,
    E: IntoIterator, [src]

impl<'a, T> From<&'a T> for Complex<T> where
    T: Clone + Num, [src]

impl<T> From<T> for Complex<T> where
    T: Clone + Num, [src]

impl<A> From<Vec<<A as Array>::Item>> for SmallVec<A> where
    A: Array, 

impl<'a, A> From<&'a [<A as Array>::Item]> for SmallVec<A> where
    A: Array,
    <A as Array>::Item: Clone, 

impl From<LayoutErr> for CollectionAllocErr

impl<A> From<A> for SmallVec<A> where
    A: Array, 

impl From<i8> for f16[src]

impl From<u8> for bf16[src]

impl From<bf16> for f64[src]

impl From<u8> for f16[src]

impl From<f16> for f64[src]

impl From<f16> for f32[src]

impl From<i8> for bf16[src]

impl From<bf16> for f32[src]

impl From<ErrorCode> for Error

impl From<(ErrorCode, usize)> for Error

impl<A> From<A> for ArrayVec<A> where
    A: Array, [src]

Create an ArrayVec from an array.

use arrayvec::ArrayVec;

let mut array = ArrayVec::from([1, 2, 3]);
assert_eq!(array.len(), 3);
assert_eq!(array.capacity(), 3);

impl From<SystemTime> for FileTime

Loading content...

Implementors

impl From<TDim> for Tensor[src]

impl From<TractErrorKind> for TractError[src]

impl From<Infallible> for TractError[src]

impl From<Infallible> for TryFromSliceError[src]

impl From<Infallible> for TryFromIntError[src]

impl From<ErrorKind> for tract_nnef::internal::tract_downcast_rs::__std::io::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));

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

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

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

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

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

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

impl From<bool> for Literal[src]

impl From<bool> for Tensor[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")

impl From<char> for String[src]

impl From<f32> for Literal[src]

impl From<f32> for Tensor[src]

impl From<f32> for tract_nnef::internal::tract_linalg::f16::f16

impl From<f64> for Tensor[src]

impl From<i8> for Tensor[src]

impl From<i8> for AtomicI8[src]

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

Converts an i8 into an AtomicI8.

impl From<i16> for Tensor[src]

impl From<i16> for AtomicI16[src]

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

Converts an i16 into an AtomicI16.

impl From<i32> for TDim[src]

impl From<i32> for SliceOrIndex[src]

impl From<i32> for Tensor[src]

impl From<i32> for AtomicI32[src]

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

Converts an i32 into an AtomicI32.

impl From<i64> for Literal[src]

impl From<i64> for TDim[src]

impl From<i64> for Tensor[src]

impl From<i64> for AtomicI64[src]

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

Converts an i64 into an AtomicI64.

impl From<isize> for TDim[src]

impl From<isize> for SliceOrIndex[src]

impl From<isize> for AtomicIsize[src]

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

Converts an isize into an AtomicIsize.

impl From<!> for Infallible[src]

impl From<!> for TryFromIntError[src]

impl From<(usize, usize)> for OutletId[src]

impl From<u8> for Tensor[src]

impl From<u8> for AtomicU8[src]

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

Converts an u8 into an AtomicU8.

impl From<u16> for Tensor[src]

impl From<u16> for AtomicU16[src]

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

Converts an u16 into an AtomicU16.

impl From<u32> for Tensor[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);

impl From<u32> for AtomicU32[src]

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

Converts an u32 into an AtomicU32.

impl From<u64> for Tensor[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);

impl From<usize> for TDim[src]

impl From<usize> for SliceOrIndex[src]

impl From<usize> for OutletId[src]

impl From<usize> for AtomicUsize[src]

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

Converts an usize into an AtomicUsize.

impl From<Arc<Tensor>> for TypedFact[src]

impl From<Blob> for Tensor[src]

impl From<Tensor> for TypedFact[src]

impl From<TractError> for TractErrorKind[src]

impl From<LayoutErr> for TryReserveError[src]

impl From<LayoutErr> for TractError[src]

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

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

Notable traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, 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;
[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);

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)

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<String> for TractErrorKind[src]

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

impl From<String> for Tensor[src]

impl From<String> for TractError[src]

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

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

Notable traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, 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;
[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)

impl From<String> for Box<dyn Error + 'static + Sync + Send>[src]

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

Notable traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, 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;
[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))

impl From<String> for Box<dyn Error + 'static>[src]

fn from(str_err: String) -> Box<dyn Error + 'static>ⓘ

Notable traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, 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;
[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))

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

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]

impl From<Vec<usize>> for IxDynImpl[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<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 Box<CStr>[src]

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

Notable traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, 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;
[src]

Converts a CString into a Box<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<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<NulError> for tract_nnef::internal::tract_downcast_rs::__std::io::Error[src]

fn from(NulError) -> Error[src]

Converts a NulError into a io::Error.

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<OsString> for Box<OsStr>[src]

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

Notable traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, 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;
[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<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");

impl From<Error> for TractError[src]

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

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

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 NonZeroI16[src]

Converts NonZeroI8 to NonZeroI16 losslessly.

impl From<NonZeroI8> for NonZeroI32[src]

Converts NonZeroI8 to NonZeroI32 losslessly.

impl From<NonZeroI8> for NonZeroI64[src]

Converts NonZeroI8 to NonZeroI64 losslessly.

impl From<NonZeroI8> for NonZeroI128[src]

Converts NonZeroI8 to NonZeroI128 losslessly.

impl From<NonZeroI8> for NonZeroIsize[src]

Converts NonZeroI8 to NonZeroIsize losslessly.

impl From<NonZeroI16> for NonZeroI32[src]

Converts NonZeroI16 to NonZeroI32 losslessly.

impl From<NonZeroI16> for NonZeroI64[src]

Converts NonZeroI16 to NonZeroI64 losslessly.

impl From<NonZeroI16> for NonZeroI128[src]

Converts NonZeroI16 to NonZeroI128 losslessly.

impl From<NonZeroI16> for NonZeroIsize[src]

Converts NonZeroI16 to NonZeroIsize losslessly.

impl From<NonZeroI32> for NonZeroI64[src]

Converts NonZeroI32 to NonZeroI64 losslessly.

impl From<NonZeroI32> for NonZeroI128[src]

Converts NonZeroI32 to NonZeroI128 losslessly.

impl From<NonZeroI64> for NonZeroI128[src]

Converts NonZeroI64 to NonZeroI128 losslessly.

impl From<NonZeroU8> for NonZeroI16[src]

Converts NonZeroU8 to NonZeroI16 losslessly.

impl From<NonZeroU8> for NonZeroI32[src]

Converts NonZeroU8 to NonZeroI32 losslessly.

impl From<NonZeroU8> for NonZeroI64[src]

Converts NonZeroU8 to NonZeroI64 losslessly.

impl From<NonZeroU8> for NonZeroI128[src]

Converts NonZeroU8 to NonZeroI128 losslessly.

impl From<NonZeroU8> for NonZeroIsize[src]

Converts NonZeroU8 to NonZeroIsize losslessly.

impl From<NonZeroU8> for NonZeroU16[src]

Converts NonZeroU8 to NonZeroU16 losslessly.

impl From<NonZeroU8> for NonZeroU32[src]

Converts NonZeroU8 to NonZeroU32 losslessly.

impl From<NonZeroU8> for NonZeroU64[src]

Converts NonZeroU8 to NonZeroU64 losslessly.

impl From<NonZeroU8> for NonZeroU128[src]

Converts NonZeroU8 to NonZeroU128 losslessly.

impl From<NonZeroU8> for NonZeroUsize[src]

Converts NonZeroU8 to NonZeroUsize losslessly.

impl From<NonZeroU16> for NonZeroI32[src]

Converts NonZeroU16 to NonZeroI32 losslessly.

impl From<NonZeroU16> for NonZeroI64[src]

Converts NonZeroU16 to NonZeroI64 losslessly.

impl From<NonZeroU16> for NonZeroI128[src]

Converts NonZeroU16 to NonZeroI128 losslessly.

impl From<NonZeroU16> for NonZeroU32[src]

Converts NonZeroU16 to NonZeroU32 losslessly.

impl From<NonZeroU16> for NonZeroU64[src]

Converts NonZeroU16 to NonZeroU64 losslessly.

impl From<NonZeroU16> for NonZeroU128[src]

Converts NonZeroU16 to NonZeroU128 losslessly.

impl From<NonZeroU16> for NonZeroUsize[src]

Converts NonZeroU16 to NonZeroUsize losslessly.

impl From<NonZeroU32> for NonZeroI64[src]

Converts NonZeroU32 to NonZeroI64 losslessly.

impl From<NonZeroU32> for NonZeroI128[src]

Converts NonZeroU32 to NonZeroI128 losslessly.

impl From<NonZeroU32> for NonZeroU64[src]

Converts NonZeroU32 to NonZeroU64 losslessly.

impl From<NonZeroU32> for NonZeroU128[src]

Converts NonZeroU32 to NonZeroU128 losslessly.

impl From<NonZeroU64> for NonZeroI128[src]

Converts NonZeroU64 to NonZeroI128 losslessly.

impl From<NonZeroU64> for NonZeroU128[src]

Converts NonZeroU64 to NonZeroU128 losslessly.

impl From<ParseIntError> for TractError[src]

impl From<Range<i32>> for SliceOrIndex[src]

impl From<Range<i32>> for Slice[src]

impl From<Range<isize>> for SliceOrIndex[src]

impl From<Range<isize>> for Slice[src]

impl From<Range<usize>> for SliceOrIndex[src]

impl From<Range<usize>> for Slice[src]

impl From<RangeFrom<i32>> for SliceOrIndex[src]

impl From<RangeFrom<i32>> for Slice[src]

impl From<RangeFrom<isize>> for SliceOrIndex[src]

impl From<RangeFrom<isize>> for Slice[src]

impl From<RangeFrom<usize>> for SliceOrIndex[src]

impl From<RangeFrom<usize>> for Slice[src]

impl From<RangeFull> for SliceOrIndex[src]

impl From<RangeFull> for Slice[src]

impl From<RangeInclusive<i32>> for SliceOrIndex[src]

impl From<RangeInclusive<i32>> for Slice[src]

impl From<RangeInclusive<isize>> for SliceOrIndex[src]

impl From<RangeInclusive<isize>> for Slice[src]

impl From<RangeInclusive<usize>> for SliceOrIndex[src]

impl From<RangeInclusive<usize>> for Slice[src]

impl From<RangeTo<i32>> for SliceOrIndex[src]

impl From<RangeTo<i32>> for Slice[src]

impl From<RangeTo<isize>> for SliceOrIndex[src]

impl From<RangeTo<isize>> for Slice[src]

impl From<RangeTo<usize>> for SliceOrIndex[src]

impl From<RangeTo<usize>> for Slice[src]

impl From<RangeToInclusive<i32>> for SliceOrIndex[src]

impl From<RangeToInclusive<i32>> for Slice[src]

impl From<RangeToInclusive<isize>> for SliceOrIndex[src]

impl From<RangeToInclusive<isize>> for Slice[src]

impl From<RangeToInclusive<usize>> for SliceOrIndex[src]

impl From<RangeToInclusive<usize>> for Slice[src]

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<PathBuf> for Box<Path>[src]

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

Notable traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, 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;
[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<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"
);

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

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

impl From<Utf8Error> for TractError[src]

impl From<RecvError> for RecvTimeoutError[src]

impl From<RecvError> for TryRecvError[src]

impl From<f16> for Tensor[src]

impl From<ShapeError> for TractError[src]

impl From<Slice> for SliceOrIndex[src]

impl From<CompressError> for tract_nnef::internal::tract_downcast_rs::__std::io::Error[src]

impl From<DecompressError> for tract_nnef::internal::tract_downcast_rs::__std::io::Error[src]

impl From<Error> for tract_nnef::internal::tract_downcast_rs::__std::io::Error[src]

fn from(walk_err: Error) -> Error[src]

Convert the Error to an io::Error, preserving the original Error as the "inner error". Note that this also makes the display of the error include the context.

This is different from into_io_error which returns the original io::Error.

impl From<SmallVec<[AxisInfo; 4]>> for Invariants[src]

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

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

impl From<TarError> for tract_nnef::internal::tract_downcast_rs::__std::io::Error[src]

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

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

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

Notable traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, 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;
[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);

impl<'_> From<&'_ str> for Box<dyn Error + 'static>[src]

fn from(err: &str) -> Box<dyn Error + 'static>ⓘ

Notable traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, 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;
[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))

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

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

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

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

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

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

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

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

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

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

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

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<&'_ Path> for Box<Path>[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<&'_ StreamResult> for Result<MZStatus, MZError>

impl<'_> From<&'_ StreamResult> for 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]

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

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

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

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

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

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

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

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

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

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

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

Notable traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, 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;
[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);

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

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

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

impl<'a> From<&'a i32> for TDim[src]

impl<'a> From<&'a i64> for TDim[src]

impl<'a> From<&'a isize> for TDim[src]

impl<'a> From<&'a str> for Literal[src]

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

impl<'a> From<&'a str> for TractErrorKind[src]

impl<'a> From<&'a str> for TractError[src]

impl<'a> From<&'a usize> for TDim[src]

impl<'a> From<&'a PulsedFact> for TypedFact[src]

impl<'a> From<&'a TypedFact> for TypedFact[src]

impl<'a> From<&'a Box<dyn PulsedOp + 'static>> for Box<dyn TypedOp + 'static>[src]

impl<'a> From<&'a Box<dyn TypedOp + 'static>> for Box<dyn TypedOp + 'static>[src]

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

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

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

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

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

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

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

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

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

Notable traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, 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;
[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))

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

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

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

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

impl<'a> From<&'a [usize]> for IxDynImpl[src]

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

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

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

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

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

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

Notable traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, 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;
[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))

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

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

Notable traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, 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;
[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))

impl<'a, A, D> From<ArrayBase<OwnedRepr<A>, D>> for ArrayBase<CowRepr<'a, A>, D> where
    D: Dimension, [src]

impl<'a, A, D> From<ArrayBase<ViewRepr<&'a A>, D>> for ArrayBase<CowRepr<'a, A>, D> where
    D: Dimension, [src]

impl<'a, A, S, D> From<&'a ArrayBase<S, D>> for ArrayBase<ViewRepr<&'a A>, D> where
    D: Dimension,
    S: Data<Elem = A>, [src]

Implementation of ArrayView::from(&A) where A is an array.

fn from(array: &'a ArrayBase<S, D>) -> ArrayBase<ViewRepr<&'a A>, D>[src]

Create a read-only array view of the array.

impl<'a, A, S, D> From<&'a mut ArrayBase<S, D>> for ArrayBase<ViewRepr<&'a mut A>, D> where
    D: Dimension,
    S: DataMut<Elem = A>, [src]

Implementation of ArrayViewMut::from(&mut A) where A is an array.

fn from(array: &'a mut ArrayBase<S, D>) -> ArrayBase<ViewRepr<&'a mut A>, D>[src]

Create a read-write array view of the array.

impl<'a, A, Slice> From<&'a Slice> for ArrayBase<ViewRepr<&'a A>, Dim<[usize; 1]>> where
    Slice: AsRef<[A]> + ?Sized, [src]

Implementation of ArrayView::from(&S) where S is a slice or slicable.

fn from(slice: &'a Slice) -> ArrayBase<ViewRepr<&'a A>, Dim<[usize; 1]>>[src]

Create a one-dimensional read-only array view of the data in slice.

Panics if the slice length is greater than isize::MAX.

impl<'a, A, Slice> From<&'a mut Slice> for ArrayBase<ViewRepr<&'a mut A>, Dim<[usize; 1]>> where
    Slice: AsMut<[A]> + ?Sized, [src]

Implementation of ArrayViewMut::from(&mut S) where S is a slice or slicable.

fn from(slice: &'a mut Slice) -> ArrayBase<ViewRepr<&'a mut A>, Dim<[usize; 1]>>[src]

Create a one-dimensional read-write array view of the data in slice.

Panics if the slice length is greater than isize::MAX.

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]

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]

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

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

Notable traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, 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;
[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))

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

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

Notable traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, 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;
[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))

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

impl<'a, T> From<&'a Vec<T>> for Cow<'a, [T]> where
    T: Clone, [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!")));

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

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

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

impl<'t> From<&'t Tensor> for TypedFact[src]

impl<A> From<(A,)> for tract_nnef::internal::tract_itertools::Zip<(<A as IntoIterator>::IntoIter,)> where
    A: IntoIterator, [src]

impl<A, B> From<(A, B)> for tract_nnef::internal::tract_itertools::Zip<(<A as IntoIterator>::IntoIter, <B as IntoIterator>::IntoIter)> where
    A: IntoIterator,
    B: IntoIterator, [src]

impl<A, B, C> From<(A, B, C)> for tract_nnef::internal::tract_itertools::Zip<(<A as IntoIterator>::IntoIter, <B as IntoIterator>::IntoIter, <C as IntoIterator>::IntoIter)> where
    A: IntoIterator,
    B: IntoIterator,
    C: IntoIterator, [src]

impl<A, B, C, D> From<(A, B, C, D)> for tract_nnef::internal::tract_itertools::Zip<(<A as IntoIterator>::IntoIter, <B as IntoIterator>::IntoIter, <C as IntoIterator>::IntoIter, <D as IntoIterator>::IntoIter)> where
    A: IntoIterator,
    B: IntoIterator,
    C: IntoIterator,
    D: IntoIterator, [src]

impl<A, B, C, D, E> From<(A, B, C, D, E)> for tract_nnef::internal::tract_itertools::Zip<(<A as IntoIterator>::IntoIter, <B as IntoIterator>::IntoIter, <C as IntoIterator>::IntoIter, <D as IntoIterator>::IntoIter, <E as IntoIterator>::IntoIter)> where
    A: IntoIterator,
    B: IntoIterator,
    C: IntoIterator,
    D: IntoIterator,
    E: IntoIterator, [src]

impl<A, B, C, D, E, F> From<(A, B, C, D, E, F)> for tract_nnef::internal::tract_itertools::Zip<(<A as IntoIterator>::IntoIter, <B as IntoIterator>::IntoIter, <C as IntoIterator>::IntoIter, <D as IntoIterator>::IntoIter, <E as IntoIterator>::IntoIter, <F as IntoIterator>::IntoIter)> where
    A: IntoIterator,
    B: IntoIterator,
    C: IntoIterator,
    D: IntoIterator,
    E: IntoIterator,
    F: IntoIterator, [src]

impl<A, B, C, D, E, F, G> From<(A, B, C, D, E, F, G)> for tract_nnef::internal::tract_itertools::Zip<(<A as IntoIterator>::IntoIter, <B as IntoIterator>::IntoIter, <C as IntoIterator>::IntoIter, <D as IntoIterator>::IntoIter, <E as IntoIterator>::IntoIter, <F as IntoIterator>::IntoIter, <G as IntoIterator>::IntoIter)> where
    A: IntoIterator,
    B: IntoIterator,
    C: IntoIterator,
    D: IntoIterator,
    E: IntoIterator,
    F: IntoIterator,
    G: IntoIterator, [src]

impl<A, B, C, D, E, F, G, H> From<(A, B, C, D, E, F, G, H)> for tract_nnef::internal::tract_itertools::Zip<(<A as IntoIterator>::IntoIter, <B as IntoIterator>::IntoIter, <C as IntoIterator>::IntoIter, <D as IntoIterator>::IntoIter, <E as IntoIterator>::IntoIter, <F as IntoIterator>::IntoIter, <G as IntoIterator>::IntoIter, <H as IntoIterator>::IntoIter)> where
    A: IntoIterator,
    B: IntoIterator,
    C: IntoIterator,
    D: IntoIterator,
    E: IntoIterator,
    F: IntoIterator,
    G: IntoIterator,
    H: IntoIterator, [src]

impl<A, S> From<Vec<A>> for ArrayBase<S, Dim<[usize; 1]>> where
    S: DataOwned<Elem = A>, [src]

fn from(v: Vec<A>) -> ArrayBase<S, Dim<[usize; 1]>>[src]

Create a one-dimensional array from a vector (no copying needed).

Panics if the length is greater than isize::MAX.

use ndarray::Array;

let array = Array::from(vec![1., 2., 3., 4.]);

impl<A, V> From<Vec<V>> for ArrayBase<OwnedRepr<A>, Dim<[usize; 2]>> where
    V: FixedInitializer<Elem = A>, [src]

fn from(xs: Vec<V>) -> ArrayBase<OwnedRepr<A>, Dim<[usize; 2]>>[src]

Converts the Vec of arrays to an owned 2-D array.

Panics if the product of non-zero axis lengths overflows isize.

impl<A, V, U> From<Vec<V>> for ArrayBase<OwnedRepr<A>, Dim<[usize; 3]>> where
    U: FixedInitializer<Elem = A>,
    V: FixedInitializer<Elem = U>, [src]

fn from(xs: Vec<V>) -> ArrayBase<OwnedRepr<A>, Dim<[usize; 3]>>[src]

Converts the Vec of arrays to an owned 3-D array.

Panics if the product of non-zero axis lengths overflows isize.

impl<D> From<D> for Shape<D> where
    D: Dimension, [src]

fn from(dimension: D) -> Shape<D>[src]

Create a Shape from dimension, using the default memory layout.

impl<D, T> From<ArrayBase<OwnedRepr<T>, D>> for Tensor where
    D: Dimension,
    T: Datum, [src]

impl<I> From<(I, u16)> for SocketAddr where
    I: Into<IpAddr>, [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<K, TA, TB, TC, TI> From<MatMatMulImpl<K, TA, TB, TC, TI>> for QMatMatMulImpl<K, TA, TB, TC, TI> where
    K: MatMatMulKer<TA, TB, TC, TI> + 'static,
    TA: Copy + Zero + SloppyHash + 'static,
    TB: Copy + Zero + SloppyHash + 'static,
    TC: Copy + Debug + SloppyHash + 'static,
    TI: Copy + Add<TI> + Mul<TI> + Zero + Debug + SloppyHash + 'static, 

impl<L, R> From<Result<R, L>> for Either<L, R>[src]

Convert from Result to Either with Ok => Right and Err => Left.

impl<O> From<O> for Box<dyn Op + 'static> where
    O: Op, [src]

impl<O> From<O> for Box<dyn PulsedOp + 'static> where
    O: PulsedOp, [src]

impl<O> From<O> for Box<dyn TypedOp + 'static> where
    O: TypedOp, [src]

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.

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

impl<T> From<BinaryHeap<T>> for Vec<T>[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);

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

impl<T> From<Box<T>> for Arc<T> where
    T: ?Sized, [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]

impl<T> From<Vec<T>> for Arc<[T]>[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 Box<[T]>[src]

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

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

impl<T> From<PoisonError<T>> for TryLockError<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);

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

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

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

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

Notable traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, 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;
[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);

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

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

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

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

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

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

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

fn from(t: T) -> Mutex<T>[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) -> RwLock<T>[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]

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

impl<T, D> From<T> for StrideShape<D> where
    D: Dimension,
    T: ShapeBuilder<Dim = D>, [src]

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

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

Notable traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, 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;
[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);

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

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

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

impl<W> From<IntoInnerError<W>> for tract_nnef::internal::tract_downcast_rs::__std::io::Error[src]

Loading content...