Trait nom::lib::std::convert::From

pub trait From<T> {
    pub fn from(T) -> Self;
}

[−] Expand description

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

pub fn from(T) -> Self[−]

Performs the conversion.

Implementations on Foreign Types

impl From<u128> for Ipv6Addr

pub fn from(ip: u128) -> Ipv6Addr[−]

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<SocketAddrV4> for SocketAddr

pub fn from(sock4: SocketAddrV4) -> SocketAddr[−]

Converts a SocketAddrV4 into a SocketAddr::V4.

impl<T> From<SendError<T>> for TrySendError<T>

pub fn from(err: SendError<T>) -> TrySendError<T>[−]

Converts a SendError<T> into a TrySendError<T>.

This conversion always returns a TrySendError::Disconnected containing the data in the SendError<T>.

No data is allocated on the heap.

impl<T> From<T> for RwLock<T>

pub fn from(t: T) -> RwLock<T>[−]

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

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

[+] Show hidden undocumented items

pub fn from(s: &T) -> PathBuf

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

[+] Show hidden undocumented items

pub fn from(s: &T) -> OsString

impl From<OsString> for PathBuf

pub fn from(s: OsString) -> PathBuf[−]

Converts an OsString into a PathBuf

This conversion does not allocate or copy memory.

impl From<NulError> for Error

pub fn from(NulError) -> Error[−]

Converts a NulError into a io::Error.

impl From<Vec<NonZeroU8, Global>> for CString

pub fn from(v: Vec<NonZeroU8, Global>) -> CString[−]

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

impl From<Ipv4Addr> for u32

pub fn from(ip: Ipv4Addr) -> u32[−]

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<Ipv4Addr> for IpAddr

pub fn from(ipv4: Ipv4Addr) -> IpAddr[−]

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<ChildStderr> for Stdio

pub fn from(child: ChildStderr) -> Stdio[−]

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<&'_ CStr> for CString

[+] Show hidden undocumented items

pub fn from(s: &CStr) -> CString

impl From<[u8; 16]> for IpAddr

pub fn from(octets: [u8; 16]) -> IpAddr[−]

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<CString> for Rc<CStr>

pub fn from(s: CString) -> Rc<CStr>[−]

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

impl<T> From<PoisonError<T>> for TryLockError<T>

[+] Show hidden undocumented items

pub fn from(err: PoisonError<T>) -> TryLockError<T>

impl From<[u8; 4]> for Ipv4Addr

pub fn from(octets: [u8; 4]) -> Ipv4Addr[−]

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<ErrorKind> for Error

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

pub fn from(kind: ErrorKind) -> Error[−]

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<u32> for Ipv4Addr

pub fn from(ip: u32) -> Ipv4Addr[−]

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<'a> From<Cow<'a, OsStr>> for OsString

[+] Show hidden undocumented items

pub fn from(s: Cow<'a, OsStr>) -> OsString

impl<I> From<(I, u16)> for SocketAddr where
    I: Into<IpAddr>, 

pub fn from(pieces: (I, u16)) -> SocketAddr[−]

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 From<File> for Stdio

pub fn from(file: File) -> Stdio[−]

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<Box<OsStr, Global>> for OsString

pub fn from(boxed: Box<OsStr, Global>) -> OsString[−]

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

impl<'_> From<&'_ OsStr> for Arc<OsStr>

[+] Show hidden undocumented items

pub fn from(s: &OsStr) -> Arc<OsStr>

impl From<CString> for Arc<CStr>

pub fn from(s: CString) -> Arc<CStr>[−]

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

impl<W> From<IntoInnerError<W>> for Error

[+] Show hidden undocumented items

pub fn from(iie: IntoInnerError<W>) -> Error

impl From<OsString> for Arc<OsStr>

pub fn from(s: OsString) -> Arc<OsStr>[−]

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

impl From<ChildStdin> for Stdio

pub fn from(child: ChildStdin) -> Stdio[−]

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<&'_ CStr> for Rc<CStr>

[+] Show hidden undocumented items

pub fn from(s: &CStr) -> Rc<CStr>

impl From<PathBuf> for Arc<Path>

pub fn from(s: PathBuf) -> Arc<Path>[−]

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

impl From<SocketAddrV6> for SocketAddr

pub fn from(sock6: SocketAddrV6) -> SocketAddr[−]

Converts a SocketAddrV6 into a SocketAddr::V6.

impl<'a> From<Cow<'a, CStr>> for CString

[+] Show hidden undocumented items

pub fn from(s: Cow<'a, CStr>) -> CString

impl From<[u8; 4]> for IpAddr

pub fn from(octets: [u8; 4]) -> IpAddr[−]

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<String> for PathBuf

pub fn from(s: String) -> PathBuf[−]

Converts a String into a PathBuf

This conversion does not allocate or copy memory.

impl From<Ipv6Addr> for IpAddr

pub fn from(ipv6: Ipv6Addr) -> IpAddr[−]

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<String> for OsString

pub fn from(s: String) -> OsString[−]

Converts a String into a OsString.

This conversion does not allocate or copy memory.

impl From<PathBuf> for OsString

pub fn from(path_buf: PathBuf) -> OsString[−]

Converts a PathBuf into an OsString

This conversion does not allocate or copy memory.

impl From<[u8; 16]> for Ipv6Addr

pub fn from(octets: [u8; 16]) -> Ipv6Addr[−]

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<Ipv6Addr> for u128

pub fn from(ip: Ipv6Addr) -> u128[−]

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<&'_ CStr> for Arc<CStr>

[+] Show hidden undocumented items

pub fn from(s: &CStr) -> Arc<CStr>

impl From<ChildStdout> for Stdio

pub fn from(child: ChildStdout) -> Stdio[−]

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<PathBuf> for Rc<Path>

pub fn from(s: PathBuf) -> Rc<Path>[−]

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

impl<'_> From<&'_ Path> for Arc<Path>

pub fn from(s: &Path) -> Arc<Path>[−]

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

impl<T> From<T> for Mutex<T>

pub fn from(t: T) -> Mutex<T>[−]

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

impl<'a> From<Cow<'a, Path>> for PathBuf

[+] Show hidden undocumented items

pub fn from(p: Cow<'a, Path>) -> PathBuf

impl From<Box<CStr, Global>> for CString

pub fn from(s: Box<CStr, Global>) -> CString[−]

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

impl<'_> From<&'_ OsStr> for Rc<OsStr>

[+] Show hidden undocumented items

pub fn from(s: &OsStr) -> Rc<OsStr>

impl From<[u16; 8]> for IpAddr

pub fn from(segments: [u16; 8]) -> IpAddr[−]

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<OsString> for Rc<OsStr>

pub fn from(s: OsString) -> Rc<OsStr>[−]

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

impl<T> From<T> for SyncOnceCell<T>

[+] Show hidden undocumented items

pub fn from(value: T) -> SyncOnceCell<T>

impl From<Box<Path, Global>> for PathBuf

pub fn from(boxed: Box<Path, Global>) -> PathBuf[−]

Converts a Box<Path> into a PathBuf

This conversion does not allocate or copy memory.

impl<'_> From<&'_ Path> for Rc<Path>

pub fn from(s: &Path) -> Rc<Path>[−]

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

impl From<RecvError> for TryRecvError

pub fn from(err: RecvError) -> TryRecvError[−]

Converts a RecvError into a TryRecvError.

This conversion always returns TryRecvError::Disconnected.

No data is allocated on the heap.

impl From<RecvError> for RecvTimeoutError

pub fn from(err: RecvError) -> RecvTimeoutError[−]

Converts a RecvError into a RecvTimeoutError.

This conversion always returns RecvTimeoutError::Disconnected.

No data is allocated on the heap.

impl From<[u16; 8]> for Ipv6Addr

pub fn from(segments: [u16; 8]) -> Ipv6Addr[−]

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<NonZeroU64> for u64

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

Converts a NonZeroU64 into an u64

impl From<NonZeroU8> for NonZeroI128

pub fn from(small: NonZeroU8) -> NonZeroI128[−]

Converts NonZeroU8 to NonZeroI128 losslessly.

impl From<bool> for i64

pub fn from(small: bool) -> i64[−]

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<i16> for i128

pub fn from(small: i16) -> i128[−]

Converts i16 to i128 losslessly.

impl From<bool> for isize

pub fn from(small: bool) -> isize[−]

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<NonZeroU8> for NonZeroUsize

pub fn from(small: NonZeroU8) -> NonZeroUsize[−]

Converts NonZeroU8 to NonZeroUsize losslessly.

impl From<u8> for isize

pub fn from(small: u8) -> isize[−]

Converts u8 to isize losslessly.

impl From<NonZeroI64> for i64

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

Converts a NonZeroI64 into an i64

impl From<u32> for i64

pub fn from(small: u32) -> i64[−]

Converts u32 to i64 losslessly.

impl From<NonZeroI32> for NonZeroI128

pub fn from(small: NonZeroI32) -> NonZeroI128[−]

Converts NonZeroI32 to NonZeroI128 losslessly.

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

[+] Show hidden undocumented items

pub fn from(reference: &mut T) -> NonNull<T>

impl From<bool> for i8

pub fn from(small: bool) -> i8[−]

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<u16> for AtomicU16

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

Converts an u16 into an AtomicU16.

impl From<NonZeroU32> for u32

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

Converts a NonZeroU32 into an u32

impl From<bool> for u8

pub fn from(small: bool) -> u8[−]

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<bool> for AtomicBool

pub fn from(b: bool) -> AtomicBool[−]

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<u8> for u64

pub fn from(small: u8) -> u64[−]

Converts u8 to u64 losslessly.

impl From<u8> for u32

pub fn from(small: u8) -> u32[−]

Converts u8 to u32 losslessly.

impl From<NonZeroU16> for NonZeroU128

pub fn from(small: NonZeroU16) -> NonZeroU128[−]

Converts NonZeroU16 to NonZeroU128 losslessly.

impl From<u8> for AtomicU8

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

Converts an u8 into an AtomicU8.

impl From<u32> for u128

pub fn from(small: u32) -> u128[−]

Converts u32 to u128 losslessly.

impl From<NonZeroU16> for NonZeroU64

pub fn from(small: NonZeroU16) -> NonZeroU64[−]

Converts NonZeroU16 to NonZeroU64 losslessly.

impl From<u16> for i64

pub fn from(small: u16) -> i64[−]

Converts u16 to i64 losslessly.

impl From<u16> for usize

pub fn from(small: u16) -> usize[−]

Converts u16 to usize losslessly.

impl From<NonZeroI16> for i16

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

Converts a NonZeroI16 into an i16

impl From<NonZeroI8> for i8

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

Converts a NonZeroI8 into an i8

impl From<NonZeroU16> for NonZeroU32

pub fn from(small: NonZeroU16) -> NonZeroU32[−]

Converts NonZeroU16 to NonZeroU32 losslessly.

impl From<i8> for i16

pub fn from(small: i8) -> i16[−]

Converts i8 to i16 losslessly.

impl From<Infallible> for TryFromSliceError

[+] Show hidden undocumented items

pub fn from(x: Infallible) -> TryFromSliceError

impl From<bool> for i16

pub fn from(small: bool) -> i16[−]

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 i64

pub fn from(small: i16) -> i64[−]

Converts i16 to i64 losslessly.

impl From<!> for TryFromIntError

[+] Show hidden undocumented items

pub fn from(never: !) -> TryFromIntError

impl From<u64> for u128

pub fn from(small: u64) -> u128[−]

Converts u64 to u128 losslessly.

impl From<NonZeroU32> for NonZeroI64

pub fn from(small: NonZeroU32) -> NonZeroI64[−]

Converts NonZeroU32 to NonZeroI64 losslessly.

impl From<NonZeroU8> for NonZeroI64

pub fn from(small: NonZeroU8) -> NonZeroI64[−]

Converts NonZeroU8 to NonZeroI64 losslessly.

impl From<i8> for isize

pub fn from(small: i8) -> isize[−]

Converts i8 to isize losslessly.

impl From<NonZeroU8> for NonZeroU64

pub fn from(small: NonZeroU8) -> NonZeroU64[−]

Converts NonZeroU8 to NonZeroU64 losslessly.

impl From<NonZeroI8> for NonZeroI32

pub fn from(small: NonZeroI8) -> NonZeroI32[−]

Converts NonZeroI8 to NonZeroI32 losslessly.

impl From<NonZeroU8> for NonZeroIsize

pub fn from(small: NonZeroU8) -> NonZeroIsize[−]

Converts NonZeroU8 to NonZeroIsize losslessly.

impl From<NonZeroI16> for NonZeroI64

pub fn from(small: NonZeroI16) -> NonZeroI64[−]

Converts NonZeroI16 to NonZeroI64 losslessly.

impl From<i8> for AtomicI8

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

Converts an i8 into an AtomicI8.

impl From<NonZeroU16> for NonZeroI128

pub fn from(small: NonZeroU16) -> NonZeroI128[−]

Converts NonZeroU16 to NonZeroI128 losslessly.

impl<T> From<T> for Poll<T>

pub fn from(t: T) -> Poll<T>[−]

Convert to a Ready variant.

Example

assert_eq!(Poll::from(true), Poll::Ready(true));

impl From<u16> for f32

pub fn from(small: u16) -> f32[−]

Converts u16 to f32 losslessly.

impl From<u8> for u128

pub fn from(small: u8) -> u128[−]

Converts u8 to u128 losslessly.

impl From<u8> for char

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.

pub fn from(i: u8) -> char[−]

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<u16> for i32

pub fn from(small: u16) -> i32[−]

Converts u16 to i32 losslessly.

impl From<NonZeroU16> for NonZeroUsize

pub fn from(small: NonZeroU16) -> NonZeroUsize[−]

Converts NonZeroU16 to NonZeroUsize losslessly.

impl From<i8> for i32

pub fn from(small: i8) -> i32[−]

Converts i8 to i32 losslessly.

impl From<NonZeroU32> for NonZeroU128

pub fn from(small: NonZeroU32) -> NonZeroU128[−]

Converts NonZeroU32 to NonZeroU128 losslessly.

impl From<NonZeroI8> for NonZeroIsize

pub fn from(small: NonZeroI8) -> NonZeroIsize[−]

Converts NonZeroI8 to NonZeroIsize losslessly.

impl<T> From<T> for Cell<T>

[+] Show hidden undocumented items

pub fn from(t: T) -> Cell<T>

impl From<u32> for f64

pub fn from(small: u32) -> f64[−]

Converts u32 to f64 losslessly.

impl From<i8> for i128

pub fn from(small: i8) -> i128[−]

Converts i8 to i128 losslessly.

impl From<u8> for f32

pub fn from(small: u8) -> f32[−]

Converts u8 to f32 losslessly.

impl From<f32> for f64

pub fn from(small: f32) -> f64[−]

Converts f32 to f64 losslessly.

impl From<i64> for AtomicI64

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

Converts an i64 into an AtomicI64.

impl From<NonZeroIsize> for isize

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

Converts a NonZeroIsize into an isize

impl From<NonZeroI64> for NonZeroI128

pub fn from(small: NonZeroI64) -> NonZeroI128[−]

Converts NonZeroI64 to NonZeroI128 losslessly.

impl From<NonZeroU8> for NonZeroU32

pub fn from(small: NonZeroU8) -> NonZeroU32[−]

Converts NonZeroU8 to NonZeroU32 losslessly.

impl From<NonZeroU32> for NonZeroI128

pub fn from(small: NonZeroU32) -> NonZeroI128[−]

Converts NonZeroU32 to NonZeroI128 losslessly.

impl From<u16> for u64

pub fn from(small: u16) -> u64[−]

Converts u16 to u64 losslessly.

impl From<NonZeroI8> for NonZeroI16

pub fn from(small: NonZeroI8) -> NonZeroI16[−]

Converts NonZeroI8 to NonZeroI16 losslessly.

impl From<NonZeroI8> for NonZeroI64

pub fn from(small: NonZeroI8) -> NonZeroI64[−]

Converts NonZeroI8 to NonZeroI64 losslessly.

impl From<bool> for i128

pub fn from(small: bool) -> i128[−]

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<T> From<T> for UnsafeCell<T>

[+] Show hidden undocumented items

pub fn from(t: T) -> UnsafeCell<T>

impl From<NonZeroUsize> for usize

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

Converts a NonZeroUsize into an usize

impl From<u32> for u64

pub fn from(small: u32) -> u64[−]

Converts u32 to u64 losslessly.

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

[+] Show hidden undocumented items

pub fn from(reference: &T) -> NonNull<T>

impl From<u16> for i128

pub fn from(small: u16) -> i128[−]

Converts u16 to i128 losslessly.

impl From<NonZeroU16> for NonZeroI32

pub fn from(small: NonZeroU16) -> NonZeroI32[−]

Converts NonZeroU16 to NonZeroI32 losslessly.

impl From<i32> for i128

pub fn from(small: i32) -> i128[−]

Converts i32 to i128 losslessly.

impl From<u8> for f64

pub fn from(small: u8) -> f64[−]

Converts u8 to f64 losslessly.

impl From<NonZeroU16> for NonZeroI64

pub fn from(small: NonZeroU16) -> NonZeroI64[−]

Converts NonZeroU16 to NonZeroI64 losslessly.

impl From<bool> for i32

pub fn from(small: bool) -> i32[−]

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<NonZeroI16> for NonZeroIsize

pub fn from(small: NonZeroI16) -> NonZeroIsize[−]

Converts NonZeroI16 to NonZeroIsize losslessly.

impl From<bool> for u128

pub fn from(small: bool) -> u128[−]

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<usize> for AtomicUsize

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

Converts an usize into an AtomicUsize.

impl From<bool> for u32

pub fn from(small: bool) -> u32[−]

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<char> for u32

pub fn from(c: char) -> u32[−]

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 From<u16> for f64

pub fn from(small: u16) -> f64[−]

Converts u16 to f64 losslessly.

impl From<NonZeroI128> for i128

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

Converts a NonZeroI128 into an i128

impl From<u8> for usize

pub fn from(small: u8) -> usize[−]

Converts u8 to usize losslessly.

impl From<bool> for usize

pub fn from(small: bool) -> usize[−]

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<T> From<Unique<T>> for NonNull<T> where
    T: ?Sized, 

[+] Show hidden undocumented items

pub fn from(unique: Unique<T>) -> NonNull<T>

impl From<i8> for f64

pub fn from(small: i8) -> f64[−]

Converts i8 to f64 losslessly.

impl From<u16> for u32

pub fn from(small: u16) -> u32[−]

Converts u16 to u32 losslessly.

impl From<i16> for AtomicI16

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

Converts an i16 into an AtomicI16.

impl From<u8> for i64

pub fn from(small: u8) -> i64[−]

Converts u8 to i64 losslessly.

impl From<NonZeroI32> for NonZeroI64

pub fn from(small: NonZeroI32) -> NonZeroI64[−]

Converts NonZeroI32 to NonZeroI64 losslessly.

impl From<char> for u64

pub fn from(c: char) -> u64[−]

Converts a [char] into a [u64].

Examples

use std::mem;

let c = '👤';
let u = u64::from(c);
assert!(8 == mem::size_of_val(&u))

impl From<NonZeroU8> for u8

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

Converts a NonZeroU8 into an u8

impl From<u8> for u16

pub fn from(small: u8) -> u16[−]

Converts u8 to u16 losslessly.

impl From<u32> for AtomicU32

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

Converts an u32 into an AtomicU32.

impl From<u8> for i16

pub fn from(small: u8) -> i16[−]

Converts u8 to i16 losslessly.

impl From<i32> for i64

pub fn from(small: i32) -> i64[−]

Converts i32 to i64 losslessly.

impl From<i8> for i64

pub fn from(small: i8) -> i64[−]

Converts i8 to i64 losslessly.

impl From<u16> for u128

pub fn from(small: u16) -> u128[−]

Converts u16 to u128 losslessly.

impl<T> From<T> for OnceCell<T>

[+] Show hidden undocumented items

pub fn from(value: T) -> OnceCell<T>

impl From<NonZeroU16> for u16

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

Converts a NonZeroU16 into an u16

impl From<NonZeroU8> for NonZeroU128

pub fn from(small: NonZeroU8) -> NonZeroU128[−]

Converts NonZeroU8 to NonZeroU128 losslessly.

impl From<isize> for AtomicIsize

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

Converts an isize into an AtomicIsize.

impl From<NonZeroI16> for NonZeroI32

pub fn from(small: NonZeroI16) -> NonZeroI32[−]

Converts NonZeroI16 to NonZeroI32 losslessly.

impl From<i16> for isize

pub fn from(small: i16) -> isize[−]

Converts i16 to isize losslessly.

impl From<NonZeroU8> for NonZeroI32

pub fn from(small: NonZeroU8) -> NonZeroI32[−]

Converts NonZeroU8 to NonZeroI32 losslessly.

impl From<NonZeroU8> for NonZeroU16

pub fn from(small: NonZeroU8) -> NonZeroU16[−]

Converts NonZeroU8 to NonZeroU16 losslessly.

impl From<i16> for f64

pub fn from(small: i16) -> f64[−]

Converts i16 to f64 losslessly.

impl From<NonZeroI16> for NonZeroI128

pub fn from(small: NonZeroI16) -> NonZeroI128[−]

Converts NonZeroI16 to NonZeroI128 losslessly.

impl From<bool> for u64

pub fn from(small: bool) -> u64[−]

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<i16> for f32

pub fn from(small: i16) -> f32[−]

Converts i16 to f32 losslessly.

impl From<u64> for AtomicU64

pub fn from(v: u64) -> AtomicU64[−]

Converts an u64 into an AtomicU64.

impl From<i16> for i32

pub fn from(small: i16) -> i32[−]

Converts i16 to i32 losslessly.

impl From<NonZeroU64> for NonZeroU128

pub fn from(small: NonZeroU64) -> NonZeroU128[−]

Converts NonZeroU64 to NonZeroU128 losslessly.

impl From<NonZeroI32> for i32

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

Converts a NonZeroI32 into an i32

impl From<NonZeroU8> for NonZeroI16

pub fn from(small: NonZeroU8) -> NonZeroI16[−]

Converts NonZeroU8 to NonZeroI16 losslessly.

impl<T> From<*mut T> for AtomicPtr<T>

[+] Show hidden undocumented items

pub fn from(p: *mut T) -> AtomicPtr<T>

impl From<u8> for i128

pub fn from(small: u8) -> i128[−]

Converts u8 to i128 losslessly.

impl From<u32> for i128

pub fn from(small: u32) -> i128[−]

Converts u32 to i128 losslessly.

impl From<u64> for i128

pub fn from(small: u64) -> i128[−]

Converts u64 to i128 losslessly.

impl From<NonZeroU128> for u128

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

Converts a NonZeroU128 into an u128

impl From<u8> for i32

pub fn from(small: u8) -> i32[−]

Converts u8 to i32 losslessly.

impl From<i8> for f32

pub fn from(small: i8) -> f32[−]

Converts i8 to f32 losslessly.

impl From<bool> for u16

pub fn from(small: bool) -> u16[−]

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<i64> for i128

pub fn from(small: i64) -> i128[−]

Converts i64 to i128 losslessly.

impl From<NonZeroU32> for NonZeroU64

pub fn from(small: NonZeroU32) -> NonZeroU64[−]

Converts NonZeroU32 to NonZeroU64 losslessly.

impl From<char> for u128

pub fn from(c: char) -> u128[−]

Converts a [char] into a [u128].

Examples

use std::mem;

let c = '⚙';
let u = u128::from(c);
assert!(16 == mem::size_of_val(&u))

impl From<NonZeroU64> for NonZeroI128

pub fn from(small: NonZeroU64) -> NonZeroI128[−]

Converts NonZeroU64 to NonZeroI128 losslessly.

impl From<NonZeroI8> for NonZeroI128

pub fn from(small: NonZeroI8) -> NonZeroI128[−]

Converts NonZeroI8 to NonZeroI128 losslessly.

impl<T> From<T> for RefCell<T>

[+] Show hidden undocumented items

pub fn from(t: T) -> RefCell<T>

impl From<i32> for f64

pub fn from(small: i32) -> f64[−]

Converts i32 to f64 losslessly.

impl From<i32> for AtomicI32

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

Converts an i32 into an AtomicI32.

impl From<Infallible> for TryFromIntError

[+] Show hidden undocumented items

pub fn from(x: Infallible) -> TryFromIntError

impl<T> From<Vec<T, Global>> for Arc<[T]>

pub fn from(v: Vec<T, Global>) -> Arc<[T]>[−]

Allocate a reference-counted slice and move v’s items into it.

Example

let unique: Vec<i32> = vec![1, 2, 3];
let shared: Arc<[i32]> = Arc::from(unique);
assert_eq!(&[1, 2, 3], &shared[..]);

impl<T> From<T> for Arc<T>

[+] Show hidden undocumented items

pub fn from(t: T) -> Arc<T>

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

pub fn from(waker: Arc<W>) -> Waker[−]

Use a Wake-able type as a Waker.

No heap allocations or atomic operations are used for this conversion.

impl<T> From<Box<T, Global>> for Rc<T> where
    T: ?Sized, 

pub fn from(v: Box<T, Global>) -> Rc<T>[−]

Move a boxed object to a new, reference counted, allocation.

Example

let original: Box<i32> = Box::new(1);
let shared: Rc<i32> = Rc::from(original);
assert_eq!(1, *shared);

impl<T, A> From<Box<T, A>> for Pin<Box<T, A>> where
    T: ?Sized,
    A: Allocator + 'static, 

pub fn from(boxed: Box<T, A>) -> Pin<Box<T, A>>[−]

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

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

impl<'_> From<&'_ str> for Rc<str>

pub fn from(v: &str) -> Rc<str>[−]

Allocate a reference-counted string slice and copy v into it.

Example

let shared: Rc<str> = Rc::from("statue");
assert_eq!("statue", &shared[..]);

impl<T> From<Box<T, Global>> for Arc<T> where
    T: ?Sized, 

pub fn from(v: Box<T, Global>) -> Arc<T>[−]

Move a boxed object to a new, reference-counted allocation.

Example

let unique: Box<str> = Box::from("eggplant");
let shared: Arc<str> = Arc::from(unique);
assert_eq!("eggplant", &shared[..]);

impl<'_> From<&'_ str> for Arc<str>

pub fn from(v: &str) -> Arc<str>[−]

Allocate a reference-counted str and copy v into it.

Example

let shared: Arc<str> = Arc::from("eggplant");
assert_eq!("eggplant", &shared[..]);

impl From<String> for Arc<str>

pub fn from(v: String) -> Arc<str>[−]

Allocate a reference-counted str and copy v into it.

Example

let unique: String = "eggplant".to_owned();
let shared: Arc<str> = Arc::from(unique);
assert_eq!("eggplant", &shared[..]);

impl From<String> for Rc<str>

pub fn from(v: String) -> Rc<str>[−]

Allocate a reference-counted string slice and copy v into it.

Example

let original: String = "statue".to_owned();
let shared: Rc<str> = Rc::from(original);
assert_eq!("statue", &shared[..]);

impl<T> From<T> for Rc<T>

[+] Show hidden undocumented items

pub fn from(t: T) -> Rc<T>

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

pub fn from(v: &[T]) -> Arc<[T]>[−]

Allocate a reference-counted slice and fill it by cloning v’s items.

Example

let original: &[i32] = &[1, 2, 3];
let shared: Arc<[i32]> = Arc::from(original);
assert_eq!(&[1, 2, 3], &shared[..]);

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

pub fn from(waker: Arc<W>) -> RawWaker[−]

Use a Wake-able type as a RawWaker.

No heap allocations or atomic operations are used for this conversion.

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

pub fn from(v: &[T]) -> Rc<[T]>[−]

Allocate a reference-counted slice and fill it by cloning v’s items.

Example

let original: &[i32] = &[1, 2, 3];
let shared: Rc<[i32]> = Rc::from(original);
assert_eq!(&[1, 2, 3], &shared[..]);

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

[+] Show hidden undocumented items

pub fn from(cow: Cow<'a, B>) -> Arc<B>

impl<T> From<Vec<T, Global>> for Rc<[T]>

pub fn from(v: Vec<T, Global>) -> Rc<[T]>[−]

Allocate a reference-counted slice and move v’s items into it.

Example

let original: Box<Vec<i32>> = Box::new(vec![1, 2, 3]);
let shared: Rc<Vec<i32>> = Rc::from(original);
assert_eq!(vec![1, 2, 3], *shared);

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

[+] Show hidden undocumented items

pub fn from(cow: Cow<'a, B>) -> Rc<B>

Implementors

impl From<char> for String

[+] Show hidden undocumented items

pub fn from(c: char) -> String

impl From<!> for Infallible

[+] Show hidden undocumented items

pub fn from(x: !) -> Infallible

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

[+] Show hidden undocumented items

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

impl From<LayoutError> for TryReserveError

[+] Show hidden undocumented items

pub fn from(LayoutError) -> TryReserveError

impl From<Box<str, Global>> for String

pub fn from(s: Box<str, Global>) -> String[−]

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<String> for Box<str, Global>

pub fn from(s: String) -> Box<str, Global>[−]

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 + Send + Sync, Global>

pub fn from(err: String) -> Box<dyn Error + 'static + Send + Sync, Global>[−]

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, Global>

pub fn from(str_err: String) -> Box<dyn Error + 'static, Global>[−]

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, Global>

pub fn from(string: String) -> Vec<u8, Global>[−]

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<CString> for Box<CStr, Global>

pub fn from(s: CString) -> Box<CStr, Global>[−]

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

impl From<CString> for Vec<u8, Global>

pub fn from(s: CString) -> Vec<u8, Global>[−]

Converts a CString into a Vec<u8>.

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

impl From<OsString> for Box<OsStr, Global>

pub fn from(s: OsString) -> Box<OsStr, Global>[−]

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

impl From<PathBuf> for Box<Path, Global>

pub fn from(p: PathBuf) -> Box<Path, Global>[−]

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<&'_ str> for Box<str, Global>

pub fn from(s: &str) -> Box<str, Global>[−]

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, Global>

pub fn from(err: &str) -> Box<dyn Error + 'static, Global>[−]

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

[+] Show hidden undocumented items

pub fn from(s: &str) -> String

impl<'_> From<&'_ str> for Vec<u8, Global>

pub fn from(s: &str) -> Vec<u8, Global>[−]

Allocate a Vec<u8> and fill it with a UTF-8 string.

Examples

assert_eq!(Vec::from("123"), vec![b'1', b'2', b'3']);

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

[+] Show hidden undocumented items

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

impl<'_> From<&'_ String> for String

[+] Show hidden undocumented items

pub fn from(s: &String) -> String

impl<'_> From<&'_ CStr> for Box<CStr, Global>

[+] Show hidden undocumented items

pub fn from(s: &CStr) -> Box<CStr, Global>

impl<'_> From<&'_ OsStr> for Box<OsStr, Global>

[+] Show hidden undocumented items

pub fn from(s: &OsStr) -> Box<OsStr, Global>

impl<'_> From<&'_ Path> for Box<Path, Global>

[+] Show hidden undocumented items

pub fn from(path: &Path) -> Box<Path, Global>

impl<'_> From<&'_ mut str> for String

pub fn from(s: &mut str) -> String[−]

Converts a &mut str into a String.

The result is allocated on the heap.

impl<'_> From<Cow<'_, str>> for Box<str, Global>

[+] Show hidden undocumented items

pub fn from(cow: Cow<'_, str>) -> Box<str, Global>

impl<'_> From<Cow<'_, CStr>> for Box<CStr, Global>

[+] Show hidden undocumented items

pub fn from(cow: Cow<'_, CStr>) -> Box<CStr, Global>

impl<'_> From<Cow<'_, OsStr>> for Box<OsStr, Global>

[+] Show hidden undocumented items

pub fn from(cow: Cow<'_, OsStr>) -> Box<OsStr, Global>

impl<'_> From<Cow<'_, Path>> for Box<Path, Global>

[+] Show hidden undocumented items

pub fn from(cow: Cow<'_, Path>) -> Box<Path, Global>

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

[+] Show hidden undocumented items

pub fn from(cow: Cow<'_, [T]>) -> Box<[T], Global>

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

pub fn from(slice: &[T]) -> Box<[T], Global>[−]

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, Global> where
    T: Clone, 

pub fn from(s: &[T]) -> Vec<T, Global>[−]

Allocate a Vec<T> and fill it by cloning s’s items.

Examples

assert_eq!(Vec::from(&[1, 2, 3][..]), vec![1, 2, 3]);

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

pub fn from(s: &mut [T]) -> Vec<T, Global>[−]

Allocate a Vec<T> and fill it by cloning s’s items.

Examples

assert_eq!(Vec::from(&mut [1, 2, 3][..]), vec![1, 2, 3]);

impl<'a> From<&'a str> for Cow<'a, str>

pub fn from(s: &'a str) -> Cow<'a, str>[−]

Converts a string slice into a Borrowed variant. No heap allocation is performed, and the string is not copied.

Example

assert_eq!(Cow::from("eggplant"), Cow::Borrowed("eggplant"));

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

pub fn from(s: &'a String) -> Cow<'a, str>[−]

Converts a String reference into a Borrowed variant. No heap allocation is performed, and the string is not copied.

Example

let s = "eggplant".to_string();
assert_eq!(Cow::from(&s), Cow::Borrowed("eggplant"));

impl<'a> From<&'a CStr> for Cow<'a, CStr>

[+] Show hidden undocumented items

pub fn from(s: &'a CStr) -> Cow<'a, CStr>

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

[+] Show hidden undocumented items

pub fn from(s: &'a CString) -> Cow<'a, CStr>

impl<'a> From<&'a OsStr> for Cow<'a, OsStr>

[+] Show hidden undocumented items

pub fn from(s: &'a OsStr) -> Cow<'a, OsStr>

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

[+] Show hidden undocumented items

pub fn from(s: &'a OsString) -> Cow<'a, OsStr>

impl<'a> From<&'a Path> for Cow<'a, Path>

[+] Show hidden undocumented items

pub fn from(s: &'a Path) -> Cow<'a, Path>

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

[+] Show hidden undocumented items

pub fn from(p: &'a PathBuf) -> Cow<'a, Path>

impl<'a> From<Cow<'a, str>> for Box<dyn Error + 'static, Global>

pub fn from(err: Cow<'a, str>) -> Box<dyn Error + 'static, Global>[−]

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

[+] Show hidden undocumented items

pub fn from(s: Cow<'a, str>) -> String

impl<'a> From<String> for Cow<'a, str>

pub fn from(s: String) -> Cow<'a, str>[−]

Converts a String into an Owned variant. No heap allocation is performed, and the string is not copied.

Example

let s = "eggplant".to_string();
let s2 = "eggplant".to_string();
assert_eq!(Cow::from(s), Cow::<'static, str>::Owned(s2));

impl<'a> From<CString> for Cow<'a, CStr>

[+] Show hidden undocumented items

pub fn from(s: CString) -> Cow<'a, CStr>

impl<'a> From<OsString> for Cow<'a, OsStr>

[+] Show hidden undocumented items

pub fn from(s: OsString) -> Cow<'a, OsStr>

impl<'a> From<PathBuf> for Cow<'a, Path>

[+] Show hidden undocumented items

pub fn from(s: PathBuf) -> Cow<'a, Path>

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

pub fn from(err: &str) -> Box<dyn Error + 'a + Send + Sync, Global>[−]

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 + Send + Sync, Global>

pub fn from(err: Cow<'b, str>) -> Box<dyn Error + 'a + Send + Sync, Global>[−]

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, E> From<E> for Box<dyn Error + 'a + Send + Sync, Global> where
    E: 'a + Error + Send + Sync, 

pub fn from(err: E) -> Box<dyn Error + 'a + Send + Sync, Global>[−]

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, Global> where
    E: 'a + Error, 

pub fn from(err: E) -> Box<dyn Error + 'a, Global>[−]

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>

pub fn from(o: &'a Option<T>) -> Option<&'a T>[−]

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, Global>> for Cow<'a, [T]> where
    T: Clone, 

[+] Show hidden undocumented items

pub fn from(v: &'a Vec<T, Global>) -> Cow<'a, [T]>

impl<'a, T> From<&'a mut Option<T>> for Option<&'a mut T>

pub fn from(o: &'a mut Option<T>) -> Option<&'a mut T>[−]

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, Global> where
    [T]: ToOwned,
    <[T] as ToOwned>::Owned == Vec<T, Global>, 

pub fn from(s: Cow<'a, [T]>) -> Vec<T, Global>[−]

Convert a clone-on-write slice into a vector.

If s already owns a Vec<T>, it will be returned directly. If s is borrowing a slice, a new Vec<T> will be allocated and filled by cloning s’s items into it.

Examples

let o: Cow<[i32]> = Cow::Owned(vec![1, 2, 3]);
let b: Cow<[i32]> = Cow::Borrowed(&[1, 2, 3]);
assert_eq!(Vec::from(o), Vec::from(b));

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

pub fn from(v: Vec<T, Global>) -> Cow<'a, [T]>

impl<A> From<Box<str, A>> for Box<[u8], A> where
    A: Allocator, 

pub fn from(s: Box<str, A>) -> Box<[u8], A>[−]

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<T> From<!> for T

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.

[+] Show hidden undocumented items

pub fn from(t: !) -> T

impl<T> From<BinaryHeap<T>> for Vec<T, Global>

pub fn from(heap: BinaryHeap<T>) -> Vec<T, Global>[−]

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

This conversion requires no data movement or allocation, and has constant time complexity.

impl<T> From<VecDeque<T>> for Vec<T, Global>

pub fn from(other: VecDeque<T>) -> Vec<T, Global>[−]

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<Vec<T, Global>> for BinaryHeap<T> where
    T: Ord, 

pub fn from(vec: Vec<T, Global>) -> BinaryHeap<T>[−]

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

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

impl<T> From<Vec<T, Global>> for VecDeque<T>

pub fn from(other: Vec<T, Global>) -> VecDeque<T>[−]

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<T> for Option<T>

pub fn from(val: T) -> Option<T>[−]

Copies val into a new Some.

Examples

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

assert_eq!(Some(67), o);

impl<T> From<T> for Box<T, Global>

pub fn from(t: T) -> Box<T, Global>[−]

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 T

[+] Show hidden undocumented items

pub fn from(t: T) -> T

impl<T, A> From<Box<[T], A>> for Vec<T, A> where
    A: Allocator, 

pub fn from(s: Box<[T], A>) -> Vec<T, A>[−]

Convert a boxed slice into a vector by transferring ownership of the existing heap allocation.

Examples

let b: Box<[i32]> = vec![1, 2, 3].into_boxed_slice();
assert_eq!(Vec::from(b), vec![1, 2, 3]);

impl<T, A> From<Vec<T, A>> for Box<[T], A> where
    A: Allocator, 

pub fn from(v: Vec<T, A>) -> Box<[T], A>[−]

Convert a vector into a boxed slice.

If v has excess capacity, its items will be moved into a newly-allocated buffer with exactly the right capacity.

Examples

assert_eq!(Box::from(vec![1, 2, 3]), vec![1, 2, 3].into_boxed_slice());

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

pub fn from(array: [T; N]) -> Box<[T], Global>[−]

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, Global>

[+] Show hidden undocumented items

pub fn from(s: [T; N]) -> Vec<T, Global>

impl<N1: From<N2>, N2: Num + Clone + NumCast> From<Rad<N2>> for Deg<N1>

impl<N1: From<N2>, N2: Num + Clone + NumCast> From<Deg<N2>> for Rad<N1>

impl From<Vec<BacktraceFrame, Global>> for Backtrace

impl From<String> for Error

impl From<DateTime<Utc>> for DateTime<FixedOffset>

impl From<DateTime<Utc>> for DateTime<Local>

impl From<DateTime<FixedOffset>> for DateTime<Utc>

impl From<DateTime<FixedOffset>> for DateTime<Local>

impl From<DateTime<Local>> for DateTime<Utc>

impl From<DateTime<Local>> for DateTime<FixedOffset>

impl From<SystemTime> for DateTime<Utc>

impl From<SystemTime> for DateTime<Local>

impl<Tz: TimeZone> From<DateTime<Tz>> for SystemTime

impl<T: Channel + Float, W> From<Xyz<T, W>> for Vec3<T>

impl<T: Channel, S> From<Rgb<T, S>> for Vec3<T>

impl<T> From<SendError<T>> for TrySendError<T>

impl<T> From<SendError<T>> for SendTimeoutError<T>

impl From<RecvError> for TryRecvError

impl From<RecvError> for RecvTimeoutError

impl<T: ?Sized + Pointable> From<Owned<T>> for Atomic<T>

impl<T> From<Box<T, Global>> for Atomic<T>

impl<T> From<T> for Atomic<T>

impl<'g, T: ?Sized + Pointable> From<Shared<'g, T>> for Atomic<T>

impl<T> From<*const T> for Atomic<T>

impl<T> From<T> for Owned<T>

impl<T> From<Box<T, Global>> for Owned<T>

impl<T> From<*const T> for Shared<'_, T>

impl<T> From<T> for AtomicCell<T>

impl<T> From<T> for CachePadded<T>

impl<T> From<T> for ShardedLock<T>

impl<T> From<Style> for Fields<T>

impl<T, U: Into<Vec<T>>> From<(Style, U)> for Fields<T>

impl From<Fields> for Style

impl<'a> From<&'a Fields> for Style

impl From<Purpose> for Options

impl From<Ident> for IdentString

impl From<IdentString> for Ident

impl From<IdentString> for String

impl<T> From<Option<T>> for Override<T>

impl From<Vec<Path, Global>> for PathList

impl<T: Spanned> From<T> for SpannedValue<T>

impl From<Flag> for bool

impl From<bool> for Flag

impl From<Option<()>> for Flag

impl From<String> for Error

impl From<Compression> for CompressionOptions

impl<N: RealField> From<Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>> for DualQuaternion<N>

impl<L, R> From<Result<R, L>> for Either<L, R>

impl From<Error> for Box<dyn StdError>

impl From<Error> for Box<dyn StdError + Send + Sync>

impl<D> From<D> for Context<D> where     D: Display + Send + Sync + 'static,

impl<F: Fail> From<F> for Error

impl From<(f32, i32)> for F32Margin

impl From<(f64, i64)> for F64Margin

impl From<i32> for Format

impl<'a, T> From<FutureObj<'a, T>> for LocalFutureObj<'a, T>

impl<'a, F: Future<Output = ()> + Send + 'a> From<Box<F, Global>> for FutureObj<'a, ()>

impl<'a> From<Box<dyn Future<Output = ()> + 'a + Send, Global>> for FutureObj<'a, ()>

impl<'a, F: Future<Output = ()> + Send + 'a> From<Pin<Box<F, Global>>> for FutureObj<'a, ()>

impl<'a> From<Pin<Box<dyn Future<Output = ()> + 'a + Send, Global>>> for FutureObj<'a, ()>

impl<'a, F: Future<Output = ()> + 'a> From<Box<F, Global>> for LocalFutureObj<'a, ()>

impl<'a> From<Box<dyn Future<Output = ()> + 'a, Global>> for LocalFutureObj<'a, ()>

impl<'a, F: Future<Output = ()> + 'a> From<Pin<Box<F, Global>>> for LocalFutureObj<'a, ()>

impl<'a> From<Pin<Box<dyn Future<Output = ()> + 'a, Global>>> for LocalFutureObj<'a, ()>

impl<T> From<Option<T>> for OptionFuture<T>

impl<T> From<T> for Mutex<T>

impl<T> From<[T; 1]> for GenericArray<T, U1>

impl<T> From<GenericArray<T, UInt<UTerm, B1>>> for [T; 1]

impl<'a, T> From<&'a [T; 1]> for &'a GenericArray<T, U1>

impl<'a, T> From<&'a mut [T; 1]> for &'a mut GenericArray<T, U1>

impl<T> From<[T; 2]> for GenericArray<T, U2>

impl<T> From<GenericArray<T, UInt<UInt<UTerm, B1>, B0>>> for [T; 2]

impl<'a, T> From<&'a [T; 2]> for &'a GenericArray<T, U2>

impl<'a, T> From<&'a mut [T; 2]> for &'a mut GenericArray<T, U2>

impl<T> From<[T; 3]> for GenericArray<T, U3>

impl<T> From<GenericArray<T, UInt<UInt<UTerm, B1>, B1>>> for [T; 3]

impl<'a, T> From<&'a [T; 3]> for &'a GenericArray<T, U3>

impl<'a, T> From<&'a mut [T; 3]> for &'a mut GenericArray<T, U3>

impl<T> From<[T; 4]> for GenericArray<T, U4>

impl<T> From<GenericArray<T, UInt<UInt<UInt<UTerm, B1>, B0>, B0>>> for [T; 4]

impl<'a, T> From<&'a [T; 4]> for &'a GenericArray<T, U4>

impl<'a, T> From<&'a mut [T; 4]> for &'a mut GenericArray<T, U4>

impl<T> From<[T; 5]> for GenericArray<T, U5>

impl<T> From<GenericArray<T, UInt<UInt<UInt<UTerm, B1>, B0>, B1>>> for [T; 5]

impl<'a, T> From<&'a [T; 5]> for &'a GenericArray<T, U5>

impl<'a, T> From<&'a mut [T; 5]> for &'a mut GenericArray<T, U5>

impl<T> From<[T; 6]> for GenericArray<T, U6>

impl<T> From<GenericArray<T, UInt<UInt<UInt<UTerm, B1>, B1>, B0>>> for [T; 6]

impl<'a, T> From<&'a [T; 6]> for &'a GenericArray<T, U6>

impl<'a, T> From<&'a mut [T; 6]> for &'a mut GenericArray<T, U6>

impl<T> From<[T; 7]> for GenericArray<T, U7>

impl<T> From<GenericArray<T, UInt<UInt<UInt<UTerm, B1>, B1>, B1>>> for [T; 7]

impl<'a, T> From<&'a [T; 7]> for &'a GenericArray<T, U7>

impl<'a, T> From<&'a mut [T; 7]> for &'a mut GenericArray<T, U7>

impl<T> From<[T; 8]> for GenericArray<T, U8>

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>> for [T; 8]

impl<'a, T> From<&'a [T; 8]> for &'a GenericArray<T, U8>

impl<'a, T> From<&'a mut [T; 8]> for &'a mut GenericArray<T, U8>

impl<T> From<[T; 9]> for GenericArray<T, U9>

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>>> for [T; 9]

impl<'a, T> From<&'a [T; 9]> for &'a GenericArray<T, U9>

impl<'a, T> From<&'a mut [T; 9]> for &'a mut GenericArray<T, U9>

impl<T> From<[T; 10]> for GenericArray<T, U10>

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>>> for [T; 10]

impl<'a, T> From<&'a [T; 10]> for &'a GenericArray<T, U10>

impl<'a, T> From<&'a mut [T; 10]> for &'a mut GenericArray<T, U10>

impl<T> From<[T; 11]> for GenericArray<T, U11>

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>>> for [T; 11]

impl<'a, T> From<&'a [T; 11]> for &'a GenericArray<T, U11>

impl<'a, T> From<&'a mut [T; 11]> for &'a mut GenericArray<T, U11>

impl<T> From<[T; 12]> for GenericArray<T, U12>

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>>> for [T; 12]

impl<'a, T> From<&'a [T; 12]> for &'a GenericArray<T, U12>

impl<'a, T> From<&'a mut [T; 12]> for &'a mut GenericArray<T, U12>

impl<T> From<[T; 13]> for GenericArray<T, U13>

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>>> for [T; 13]

impl<'a, T> From<&'a [T; 13]> for &'a GenericArray<T, U13>

impl<'a, T> From<&'a mut [T; 13]> for &'a mut GenericArray<T, U13>

impl<T> From<[T; 14]> for GenericArray<T, U14>

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>>> for [T; 14]

impl<'a, T> From<&'a [T; 14]> for &'a GenericArray<T, U14>

impl<'a, T> From<&'a mut [T; 14]> for &'a mut GenericArray<T, U14>

impl<T> From<[T; 15]> for GenericArray<T, U15>

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>>> for [T; 15]

impl<'a, T> From<&'a [T; 15]> for &'a GenericArray<T, U15>

impl<'a, T> From<&'a mut [T; 15]> for &'a mut GenericArray<T, U15>

impl<T> From<[T; 16]> for GenericArray<T, U16>

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>>> for [T; 16]

impl<'a, T> From<&'a [T; 16]> for &'a GenericArray<T, U16>

impl<'a, T> From<&'a mut [T; 16]> for &'a mut GenericArray<T, U16>

impl<T> From<[T; 17]> for GenericArray<T, U17>

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>>> for [T; 17]

impl<'a, T> From<&'a [T; 17]> for &'a GenericArray<T, U17>

impl<'a, T> From<&'a mut [T; 17]> for &'a mut GenericArray<T, U17>

impl<T> From<[T; 18]> for GenericArray<T, U18>

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>>> for [T; 18]

impl<'a, T> From<&'a [T; 18]> for &'a GenericArray<T, U18>

impl<'a, T> From<&'a mut [T; 18]> for &'a mut GenericArray<T, U18>

impl<T> From<[T; 19]> for GenericArray<T, U19>

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>>> for [T; 19]

impl<'a, T> From<&'a [T; 19]> for &'a GenericArray<T, U19>

impl<'a, T> From<&'a mut [T; 19]> for &'a mut GenericArray<T, U19>

impl<T> From<[T; 20]> for GenericArray<T, U20>

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>>> for [T; 20]

impl<'a, T> From<&'a [T; 20]> for &'a GenericArray<T, U20>

impl<'a, T> From<&'a mut [T; 20]> for &'a mut GenericArray<T, U20>

impl<T> From<[T; 21]> for GenericArray<T, U21>

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>>> for [T; 21]

impl<'a, T> From<&'a [T; 21]> for &'a GenericArray<T, U21>

impl<'a, T> From<&'a mut [T; 21]> for &'a mut GenericArray<T, U21>

impl<T> From<[T; 22]> for GenericArray<T, U22>

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>>> for [T; 22]

impl<'a, T> From<&'a [T; 22]> for &'a GenericArray<T, U22>

impl<'a, T> From<&'a mut [T; 22]> for &'a mut GenericArray<T, U22>

impl<T> From<[T; 23]> for GenericArray<T, U23>

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>>> for [T; 23]

impl<'a, T> From<&'a [T; 23]> for &'a GenericArray<T, U23>

impl<'a, T> From<&'a mut [T; 23]> for &'a mut GenericArray<T, U23>

impl<T> From<[T; 24]> for GenericArray<T, U24>

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>>> for [T; 24]

impl<'a, T> From<&'a [T; 24]> for &'a GenericArray<T, U24>

impl<'a, T> From<&'a mut [T; 24]> for &'a mut GenericArray<T, U24>

impl<T> From<[T; 25]> for GenericArray<T, U25>

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>>> for [T; 25]

impl<'a, T> From<&'a [T; 25]> for &'a GenericArray<T, U25>

impl<'a, T> From<&'a mut [T; 25]> for &'a mut GenericArray<T, U25>

impl<T> From<[T; 26]> for GenericArray<T, U26>

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>>> for [T; 26]

impl<'a, T> From<&'a [T; 26]> for &'a GenericArray<T, U26>

impl<'a, T> From<&'a mut [T; 26]> for &'a mut GenericArray<T, U26>

impl<T> From<[T; 27]> for GenericArray<T, U27>

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>>> for [T; 27]

impl<'a, T> From<&'a [T; 27]> for &'a GenericArray<T, U27>

impl<'a, T> From<&'a mut [T; 27]> for &'a mut GenericArray<T, U27>

impl<T> From<[T; 28]> for GenericArray<T, U28>

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>>> for [T; 28]

impl<'a, T> From<&'a [T; 28]> for &'a GenericArray<T, U28>

impl<'a, T> From<&'a mut [T; 28]> for &'a mut GenericArray<T, U28>

impl<T> From<[T; 29]> for GenericArray<T, U29>

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>>> for [T; 29]

impl<'a, T> From<&'a [T; 29]> for &'a GenericArray<T, U29>

impl<'a, T> From<&'a mut [T; 29]> for &'a mut GenericArray<T, U29>

impl<T> From<[T; 30]> for GenericArray<T, U30>

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>>> for [T; 30]

impl<'a, T> From<&'a [T; 30]> for &'a GenericArray<T, U30>

impl<'a, T> From<&'a mut [T; 30]> for &'a mut GenericArray<T, U30>

impl<T> From<[T; 31]> for GenericArray<T, U31>

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>>> for [T; 31]

impl<'a, T> From<&'a [T; 31]> for &'a GenericArray<T, U31>

impl<'a, T> From<&'a mut [T; 31]> for &'a mut GenericArray<T, U31>

impl<T> From<[T; 32]> for GenericArray<T, U32>

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>>> for [T; 32]

impl<'a, T> From<&'a [T; 32]> for &'a GenericArray<T, U32>

impl<'a, T> From<&'a mut [T; 32]> for &'a mut GenericArray<T, U32>

impl<'a, T, N: ArrayLength<T>> From<&'a [T]> for &'a GenericArray<T, N>

impl<'a, T, N: ArrayLength<T>> From<&'a mut [T]> for &'a mut GenericArray<T, N>

impl From<NonZeroU32> for Error

impl From<Error> for Error

impl From<Error> for Error

impl From<Extension> for AnyExtension

impl From<Error> for DecodingError

impl From<DecodingFormatError> for DecodingError

impl From<Error> for EncodingError

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

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

impl<T> From<DebugInfoOffset<T>> for UnitSectionOffset<T>

impl<T> From<DebugTypesOffset<T>> for UnitSectionOffset<T>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl From<GLFWgamepadstate> for GamepadState

impl From<Format> for CompressedDataFormat

impl<T: 'static> From<Buffer<T>> for SharedBuffer<T>

impl<T: 'static> From<BufferStorage<T>> for SharedBufferStorage<T>

impl From<ErrorKind> for Error

impl<'a> From<&'a str> for Identifier

impl From<String> for Identifier

impl<'a> From<&'a str> for TypeName

impl From<String> for TypeName

impl From<TypeSpecifierNonArray> for TypeSpecifier

impl<'a> From<&'a str> for ArrayedIdentifier

impl From<Identifier> for ArrayedIdentifier

impl From<TypeSpecifierNonArray> for FullySpecifiedType

impl From<Expr> for Initializer

impl From<i32> for Expr

impl From<u32> for Expr

impl From<bool> for Expr

impl From<f32> for Expr

impl From<f64> for Expr

impl From<Expr> for Condition

impl From<bf16> for f32

impl From<bf16> for f64

impl From<i8> for bf16

impl From<u8> for bf16

impl From<f16> for f32

impl From<f16> for f64

impl From<i8> for f16

impl From<u8> for f16

impl From<u32> for Direction

impl From<Direction> for hb_direction_t

impl<T> From<RawIter<T>> for RawParIter<T>

impl From<Error> for ImageError

impl From<ImageFormat> for ImageFormatHint

impl From<&'_ Path> for ImageFormatHint

impl From<ImageFormatHint> for UnsupportedError

impl From<NeuQuant> for NeuQuant

impl From<NeuQuant> for NeuQuant

impl From<Error> for ImageError

impl From<BitmapHeader> for PnmHeader

impl From<GraymapHeader> for PnmHeader

impl From<PixmapHeader> for PnmHeader

impl From<ArbitraryHeader> for PnmHeader

impl From<Delay> for Duration

impl From<ColorType> for ExtendedColorType

impl<T: Primitive + 'static> From<[T; 3]> for Rgb<T>

impl<T: Primitive + 'static> From<[T; 3]> for Bgr<T>

impl<T: Primitive + 'static> From<[T; 1]> for Luma<T>

impl<T: Primitive + 'static> From<[T; 4]> for Rgba<T>

impl<T: Primitive + 'static> From<[T; 4]> for Bgra<T>

impl<T: Primitive + 'static> From<[T; 2]> for LumaA<T>

impl From<ImageFormat> for ImageOutputFormat

impl<A: IntoIterator> From<(A,)> for Zip<(A::IntoIter,)>

impl<A: IntoIterator, B: IntoIterator> From<(A, B)> for Zip<(A::IntoIter, B::IntoIter)>

impl<A: IntoIterator, B: IntoIterator, C: IntoIterator> From<(A, B, C)> for Zip<(A::IntoIter, B::IntoIter, C::IntoIter)>

impl<A: IntoIterator, B: IntoIterator, C: IntoIterator, D: IntoIterator> From<(A, B, C, D)> for Zip<(A::IntoIter, B::IntoIter, C::IntoIter, D::IntoIter)>

impl<A: IntoIterator, B: IntoIterator, C: IntoIterator, D: IntoIterator, E: IntoIterator> From<(A, B, C, D, E)> for Zip<(A::IntoIter, B::IntoIter, C::IntoIter, D::IntoIter, E::IntoIter)>

impl<A: IntoIterator, B: IntoIterator, C: IntoIterator, D: IntoIterator, E: IntoIterator, F: IntoIterator> From<(A, B, C, D, E, F)> for Zip<(A::IntoIter, B::IntoIter, C::IntoIter, D::IntoIter, E::IntoIter, F::IntoIter)>

impl<A: IntoIterator, B: IntoIterator, C: IntoIterator, D: IntoIterator, E: IntoIterator, F: IntoIterator, G: IntoIterator> From<(A, B, C, D, E, F, G)> for Zip<(A::IntoIter, B::IntoIter, C::IntoIter, D::IntoIter, E::IntoIter, F::IntoIter, G::IntoIter)>

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

impl From<Error> for Error

impl<R: RawMutex, T> From<T> for Mutex<R, T>

impl<R: RawMutex, G: GetThreadId, T> From<T> for ReentrantMutex<R, G, T>

impl<R: RawRwLock, T> From<T> for RwLock<R, T>

impl From<ErrorKind> for Error

impl From<Context<ErrorKind>> for Error

impl From<Error> for Error

impl From<MZFlush> for TDEFLFlush

impl From<StreamResult> for MZResult

impl From<&'_ StreamResult> for MZResult

impl<N> From<[N; 1]> for MatrixMN<N, U1, U1> where     N: Scalar,     DefaultAllocator: Allocator<N, U1, U1>,

impl<N> From<[N; 2]> for MatrixMN<N, U1, U2> where     N: Scalar,     DefaultAllocator: Allocator<N, U1, U2>,

impl<N> From<[N; 3]> for MatrixMN<N, U1, U3> where     N: Scalar,     DefaultAllocator: Allocator<N, U1, U3>,

impl<N> From<[N; 4]> for MatrixMN<N, U1, U4> where     N: Scalar,     DefaultAllocator: Allocator<N, U1, U4>,

impl<N> From<[N; 5]> for MatrixMN<N, U1, U5> where     N: Scalar,     DefaultAllocator: Allocator<N, U1, U5>,

impl<N> From<[N; 6]> for MatrixMN<N, U1, U6> where     N: Scalar,     DefaultAllocator: Allocator<N, U1, U6>,

impl<N> From<[N; 7]> for MatrixMN<N, U1, U7> where     N: Scalar,     DefaultAllocator: Allocator<N, U1, U7>,

impl<N> From<[N; 8]> for MatrixMN<N, U1, U8> where     N: Scalar,     DefaultAllocator: Allocator<N, U1, U8>,

impl<N> From<[N; 9]> for MatrixMN<N, U1, U9> where     N: Scalar,     DefaultAllocator: Allocator<N, U1, U9>,

impl<N> From<[N; 10]> for MatrixMN<N, U1, U10> where     N: Scalar,     DefaultAllocator: Allocator<N, U1, U10>,

impl<N> From<[N; 11]> for MatrixMN<N, U1, U11> where     N: Scalar,     DefaultAllocator: Allocator<N, U1, U11>,

impl<N> From<[N; 12]> for MatrixMN<N, U1, U12> where     N: Scalar,     DefaultAllocator: Allocator<N, U1, U12>,

impl<N> From<[N; 13]> for MatrixMN<N, U1, U13> where     N: Scalar,     DefaultAllocator: Allocator<N, U1, U13>,

impl<N> From<[N; 14]> for MatrixMN<N, U1, U14> where     N: Scalar,     DefaultAllocator: Allocator<N, U1, U14>,

impl<N> From<[N; 15]> for MatrixMN<N, U1, U15> where     N: Scalar,     DefaultAllocator: Allocator<N, U1, U15>,

impl<N> From<[N; 16]> for MatrixMN<N, U1, U16> where     N: Scalar,     DefaultAllocator: Allocator<N, U1, U16>,

impl<N> From<[N; 2]> for MatrixMN<N, U2, U1> where     N: Scalar,     DefaultAllocator: Allocator<N, U2, U1>,

impl<N> From<[N; 3]> for MatrixMN<N, U3, U1> where     N: Scalar,     DefaultAllocator: Allocator<N, U3, U1>,

impl<N> From<[N; 4]> for MatrixMN<N, U4, U1> where     N: Scalar,     DefaultAllocator: Allocator<N, U4, U1>,

impl<N> From<[N; 5]> for MatrixMN<N, U5, U1> where     N: Scalar,     DefaultAllocator: Allocator<N, U5, U1>,

impl<N> From<[N; 6]> for MatrixMN<N, U6, U1> where     N: Scalar,     DefaultAllocator: Allocator<N, U6, U1>,

impl<N> From<[N; 7]> for MatrixMN<N, U7, U1> where     N: Scalar,     DefaultAllocator: Allocator<N, U7, U1>,

impl<N> From<[N; 8]> for MatrixMN<N, U8, U1> where     N: Scalar,     DefaultAllocator: Allocator<N, U8, U1>,

impl<N> From<[N; 9]> for MatrixMN<N, U9, U1> where     N: Scalar,     DefaultAllocator: Allocator<N, U9, U1>,

impl<N> From<[N; 10]> for MatrixMN<N, U10, U1> where     N: Scalar,     DefaultAllocator: Allocator<N, U10, U1>,

impl<N> From<[N; 11]> for MatrixMN<N, U11, U1> where     N: Scalar,     DefaultAllocator: Allocator<N, U11, U1>,

impl<N> From<[N; 12]> for MatrixMN<N, U12, U1> where     N: Scalar,     DefaultAllocator: Allocator<N, U12, U1>,

impl<N> From<[N; 13]> for MatrixMN<N, U13, U1> where     N: Scalar,     DefaultAllocator: Allocator<N, U13, U1>,

impl<N> From<[N; 14]> for MatrixMN<N, U14, U1> where     N: Scalar,     DefaultAllocator: Allocator<N, U14, U1>,

impl<N> From<[N; 15]> for MatrixMN<N, U15, U1> where     N: Scalar,     DefaultAllocator: Allocator<N, U15, U1>,

impl<N> From<[N; 16]> for MatrixMN<N, U16, U1> where     N: Scalar,     DefaultAllocator: Allocator<N, U16, U1>,

impl<N: Scalar> From<[[N; 2]; 2]> for MatrixMN<N, U2, U2> where     DefaultAllocator: Allocator<N, U2, U2>,

impl<N: Scalar> From<[[N; 2]; 3]> for MatrixMN<N, U2, U3> where     DefaultAllocator: Allocator<N, U2, U3>,

impl<N: Scalar> From<[[N; 2]; 4]> for MatrixMN<N, U2, U4> where     DefaultAllocator: Allocator<N, U2, U4>,

impl<N: Scalar> From<[[N; 2]; 5]> for MatrixMN<N, U2, U5> where     DefaultAllocator: Allocator<N, U2, U5>,

impl<N: Scalar> From<[[N; 2]; 6]> for MatrixMN<N, U2, U6> where     DefaultAllocator: Allocator<N, U2, U6>,

impl<N: Scalar> From<[[N; 3]; 2]> for MatrixMN<N, U3, U2> where     DefaultAllocator: Allocator<N, U3, U2>,

impl<N: Scalar> From<[[N; 3]; 3]> for MatrixMN<N, U3, U3> where     DefaultAllocator: Allocator<N, U3, U3>,

impl<N: Scalar> From<[[N; 3]; 4]> for MatrixMN<N, U3, U4> where     DefaultAllocator: Allocator<N, U3, U4>,

impl<N: Scalar> From<[[N; 3]; 5]> for MatrixMN<N, U3, U5> where     DefaultAllocator: Allocator<N, U3, U5>,

impl<N: Scalar> From<[[N; 3]; 6]> for MatrixMN<N, U3, U6> where     DefaultAllocator: Allocator<N, U3, U6>,

impl<N: Scalar> From<[[N; 4]; 2]> for MatrixMN<N, U4, U2> where     DefaultAllocator: Allocator<N, U4, U2>,

impl<N: Scalar> From<[[N; 4]; 3]> for MatrixMN<N, U4, U3> where     DefaultAllocator: Allocator<N, U4, U3>,

impl<N: Scalar> From<[[N; 4]; 4]> for MatrixMN<N, U4, U4> where     DefaultAllocator: Allocator<N, U4, U4>,

impl<N: Scalar> From<[[N; 4]; 5]> for MatrixMN<N, U4, U5> where     DefaultAllocator: Allocator<N, U4, U5>,

impl<N: Scalar> From<[[N; 4]; 6]> for MatrixMN<N, U4, U6> where     DefaultAllocator: Allocator<N, U4, U6>,

impl<N: Scalar> From<[[N; 5]; 2]> for MatrixMN<N, U5, U2> where     DefaultAllocator: Allocator<N, U5, U2>,

impl<N: Scalar> From<[[N; 5]; 3]> for MatrixMN<N, U5, U3> where     DefaultAllocator: Allocator<N, U5, U3>,

impl<N: Scalar> From<[[N; 5]; 4]> for MatrixMN<N, U5, U4> where     DefaultAllocator: Allocator<N, U5, U4>,

impl<N: Scalar> From<[[N; 5]; 5]> for MatrixMN<N, U5, U5> where     DefaultAllocator: Allocator<N, U5, U5>,

impl<N: Scalar> From<[[N; 5]; 6]> for MatrixMN<N, U5, U6> where     DefaultAllocator: Allocator<N, U5, U6>,

impl<N: Scalar> From<[[N; 6]; 2]> for MatrixMN<N, U6, U2> where     DefaultAllocator: Allocator<N, U6, U2>,

impl<N: Scalar> From<[[N; 6]; 3]> for MatrixMN<N, U6, U3> where     DefaultAllocator: Allocator<N, U6, U3>,

impl<N: Scalar> From<[[N; 6]; 4]> for MatrixMN<N, U6, U4> where     DefaultAllocator: Allocator<N, U6, U4>,

impl<N: Scalar> From<[[N; 6]; 5]> for MatrixMN<N, U6, U5> where     DefaultAllocator: Allocator<N, U6, U5>,

impl<N: Scalar> From<[[N; 6]; 6]> for MatrixMN<N, U6, U6> where     DefaultAllocator: Allocator<N, U6, U6>,

impl<'a, N, R, C, RStride, CStride> From<Matrix<N, R, C, SliceStorage<'a, N, R, C, RStride, CStride>>> for Matrix<N, R, C, ArrayStorage<N, R, C>> where     N: Scalar,     R: DimName,     C: DimName,     RStride: Dim,     CStride: Dim,     R::Value: Mul<C::Value>,     Prod<R::Value, C::Value>: ArrayLength<N>,

impl<'a, N, C, RStride, CStride> From<Matrix<N, Dynamic, C, SliceStorage<'a, N, Dynamic, C, RStride, CStride>>> for Matrix<N, Dynamic, C, VecStorage<N, Dynamic, C>> where     N: Scalar,     C: Dim,     RStride: Dim,     CStride: Dim,

impl<'a, N, R, RStride, CStride> From<Matrix<N, R, Dynamic, SliceStorage<'a, N, R, Dynamic, RStride, CStride>>> for Matrix<N, R, Dynamic, VecStorage<N, R, Dynamic>> where     N: Scalar,     R: DimName,     RStride: Dim,     CStride: Dim,

impl<'a, N, R, C, RStride, CStride> From<Matrix<N, R, C, SliceStorageMut<'a, N, R, C, RStride, CStride>>> for Matrix<N, R, C, ArrayStorage<N, R, C>> where     N: Scalar,     R: DimName,     C: DimName,     RStride: Dim,     CStride: Dim,     R::Value: Mul<C::Value>,     Prod<R::Value, C::Value>: ArrayLength<N>,

impl<'a, N, C, RStride, CStride> From<Matrix<N, Dynamic, C, SliceStorageMut<'a, N, Dynamic, C, RStride, CStride>>> for Matrix<N, Dynamic, C, VecStorage<N, Dynamic, C>> where     N: Scalar,     C: Dim,     RStride: Dim,     CStride: Dim,

impl<'a, N, R, RStride, CStride> From<Matrix<N, R, Dynamic, SliceStorageMut<'a, N, R, Dynamic, RStride, CStride>>> for Matrix<N, R, Dynamic, VecStorage<N, R, Dynamic>> where     N: Scalar,     R: DimName,     RStride: Dim,     CStride: Dim,

impl<'a, N, R, C, RSlice, CSlice, RStride, CStride, S> From<&'a Matrix<N, R, C, S>> for MatrixSlice<'a, N, RSlice, CSlice, RStride, CStride> where     N: Scalar,     R: Dim,     C: Dim,     RSlice: Dim,     CSlice: Dim,     RStride: Dim,     CStride: Dim,     S: Storage<N, R, C>,     ShapeConstraint: DimEq<R, RSlice> + DimEq<C, CSlice> + DimEq<RStride, S::RStride> + DimEq<CStride, S::CStride>,

impl<'a, N, R, C, RSlice, CSlice, RStride, CStride, S> From<&'a mut Matrix<N, R, C, S>> for MatrixSlice<'a, N, RSlice, CSlice, RStride, CStride> where     N: Scalar,     R: Dim,     C: Dim,     RSlice: Dim,     CSlice: Dim,     RStride: Dim,     CStride: Dim,     S: Storage<N, R, C>,     ShapeConstraint: DimEq<R, RSlice> + DimEq<C, CSlice> + DimEq<RStride, S::RStride> + DimEq<CStride, S::CStride>,

impl<'a, N, R, C, RSlice, CSlice, RStride, CStride, S> From<&'a mut Matrix<N, R, C, S>> for MatrixSliceMut<'a, N, RSlice, CSlice, RStride, CStride> where     N: Scalar,     R: Dim,     C: Dim,     RSlice: Dim,     CSlice: Dim,     RStride: Dim,     CStride: Dim,     S: StorageMut<N, R, C>,     ShapeConstraint: DimEq<R, RSlice> + DimEq<C, CSlice> + DimEq<RStride, S::RStride> + DimEq<CStride, S::CStride>,

impl<'a, N: Scalar> From<Vec<N, Global>> for DVector<N>

impl<'a, N: Scalar + Copy> From<&'a [N]> for DVectorSlice<'a, N>

impl<'a, N: Scalar + Copy> From<&'a mut [N]> for DVectorSliceMut<'a, N>

impl<N: Scalar + PrimitiveSimdValue, R: Dim, C: Dim> From<[Matrix<<N as SimdValue>::Element, R, C, <DefaultAllocator as Allocator<<N as SimdValue>::Element, R, C>>::Buffer>; 2]> for MatrixMN<N, R, C> where     N: From<[<N as SimdValue>::Element; 2]>,     N::Element: Scalar + SimdValue,     DefaultAllocator: Allocator<N, R, C> + Allocator<N::Element, R, C>,

impl<N: Scalar + PrimitiveSimdValue, R: Dim, C: Dim> From<[Matrix<<N as SimdValue>::Element, R, C, <DefaultAllocator as Allocator<<N as SimdValue>::Element, R, C>>::Buffer>; 4]> for MatrixMN<N, R, C> where     N: From<[<N as SimdValue>::Element; 4]>,     N::Element: Scalar + SimdValue,     DefaultAllocator: Allocator<N, R, C> + Allocator<N::Element, R, C>,

impl<N: Scalar + PrimitiveSimdValue, R: Dim, C: Dim> From<[Matrix<<N as SimdValue>::Element, R, C, <DefaultAllocator as Allocator<<N as SimdValue>::Element, R, C>>::Buffer>; 8]> for MatrixMN<N, R, C> where     N: From<[<N as SimdValue>::Element; 8]>,     N::Element: Scalar + SimdValue,     DefaultAllocator: Allocator<N, R, C> + Allocator<N::Element, R, C>,

impl<N: Scalar + PrimitiveSimdValue, R: Dim, C: Dim> From<[Matrix<<N as SimdValue>::Element, R, C, <DefaultAllocator as Allocator<<N as SimdValue>::Element, R, C>>::Buffer>; 16]> for MatrixMN<N, R, C> where     N: From<[<N as SimdValue>::Element; 16]>,     N::Element: Scalar + SimdValue,     DefaultAllocator: Allocator<N, R, C> + Allocator<N::Element, R, C>,

impl<'a, N, R, C, RStride, CStride> From<Matrix<N, R, C, SliceStorageMut<'a, N, R, C, RStride, CStride>>> for MatrixSlice<'a, N, R, C, RStride, CStride> where     N: Scalar,     R: Dim,     C: Dim,     RStride: Dim,     CStride: Dim,

impl<N: Scalar + PrimitiveSimdValue, R: Dim, C: Dim> From<[Unit<Matrix<<N as SimdValue>::Element, R, C, <DefaultAllocator as Allocator<<N as SimdValue>::Element, R, C>>::Buffer>>; 2]> for Unit<MatrixMN<N, R, C>> where     N: From<[<N as SimdValue>::Element; 2]>,     N::Element: Scalar,     DefaultAllocator: Allocator<N, R, C> + Allocator<N::Element, R, C>,

impl<N: Scalar + PrimitiveSimdValue, R: Dim, C: Dim> From<[Unit<Matrix<<N as SimdValue>::Element, R, C, <DefaultAllocator as Allocator<<N as SimdValue>::Element, R, C>>::Buffer>>; 4]> for Unit<MatrixMN<N, R, C>> where     N: From<[<N as SimdValue>::Element; 4]>,     N::Element: Scalar,     DefaultAllocator: Allocator<N, R, C> + Allocator<N::Element, R, C>,

impl<N: Scalar + PrimitiveSimdValue, R: Dim, C: Dim> From<[Unit<Matrix<<N as SimdValue>::Element, R, C, <DefaultAllocator as Allocator<<N as SimdValue>::Element, R, C>>::Buffer>>; 8]> for Unit<MatrixMN<N, R, C>> where     N: From<[<N as SimdValue>::Element; 8]>,     N::Element: Scalar,     DefaultAllocator: Allocator<N, R, C> + Allocator<N::Element, R, C>,

impl<N: Scalar + PrimitiveSimdValue, R: Dim, C: Dim> From<[Unit<Matrix<<N as SimdValue>::Element, R, C, <DefaultAllocator as Allocator<<N as SimdValue>::Element, R, C>>::Buffer>>; 16]> for Unit<MatrixMN<N, R, C>> where     N: From<[<N as SimdValue>::Element; 16]>,     N::Element: Scalar,     DefaultAllocator: Allocator<N, R, C> + Allocator<N::Element, R, C>,

impl<N: Scalar> From<[N; 1]> for Point1<N>

impl<N: Scalar> From<[N; 2]> for Point2<N>

impl<N: Scalar> From<[N; 3]> for Point3<N>

impl<N: Scalar> From<[N; 4]> for Point4<N>

impl<N: Scalar> From<[N; 5]> for Point5<N>

impl<N: Scalar> From<[N; 6]> for Point6<N>

impl<N: Scalar + Zero + One, D: DimName> From<Point<N, D>> for VectorN<N, DimNameSum<D, U1>> where     D: DimNameAdd<U1>,     DefaultAllocator: Allocator<N, D> + Allocator<N, DimNameSum<D, U1>>,

impl<N: Scalar, D: DimName> From<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for Point<N, D> where     DefaultAllocator: Allocator<N, D>,

impl<N: Scalar + Copy + PrimitiveSimdValue, D: DimName> From<[Point<<N as SimdValue>::Element, D>; 2]> for Point<N, D> where     N: From<[<N as SimdValue>::Element; 2]>,     N::Element: Scalar + Copy,     DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,     <DefaultAllocator as Allocator<N::Element, D>>::Buffer: Copy,

impl<N: Scalar + Copy + PrimitiveSimdValue, D: DimName> From<[Point<<N as SimdValue>::Element, D>; 4]> for Point<N, D> where     N: From<[<N as SimdValue>::Element; 4]>,     N::Element: Scalar + Copy,     DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,     <DefaultAllocator as Allocator<N::Element, D>>::Buffer: Copy,

impl<N: Scalar + Copy + PrimitiveSimdValue, D: DimName> From<[Point<<N as SimdValue>::Element, D>; 8]> for Point<N, D> where     N: From<[<N as SimdValue>::Element; 8]>,     N::Element: Scalar + Copy,     DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,     <DefaultAllocator as Allocator<N::Element, D>>::Buffer: Copy,

impl<N: Scalar + Copy + PrimitiveSimdValue, D: DimName> From<[Point<<N as SimdValue>::Element, D>; 16]> for Point<N, D> where     N: From<[<N as SimdValue>::Element; 16]>,     N::Element: Scalar + Copy,     DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,     <DefaultAllocator as Allocator<N::Element, D>>::Buffer: Copy,

impl<N: RealField> From<Rotation<N, U2>> for Matrix3<N>

impl<N: RealField> From<Rotation<N, U2>> for Matrix2<N>

impl<N: RealField> From<Rotation<N, U3>> for Matrix4<N>

impl<N: RealField> From<Rotation<N, U3>> for Matrix3<N>

impl<N: Scalar + PrimitiveSimdValue, D: DimName> From<[Rotation<<N as SimdValue>::Element, D>; 2]> for Rotation<N, D> where     N: From<[<N as SimdValue>::Element; 2]>,     N::Element: Scalar + Copy,     DefaultAllocator: Allocator<N, D, D> + Allocator<N::Element, D, D>,

impl<N: Scalar + PrimitiveSimdValue, D: DimName> From<[Rotation<<N as SimdValue>::Element, D>; 4]> for Rotation<N, D> where     N: From<[<N as SimdValue>::Element; 4]>,     N::Element: Scalar + Copy,     DefaultAllocator: Allocator<N, D, D> + Allocator<N::Element, D, D>,

impl<N: Scalar + PrimitiveSimdValue, D: DimName> From<[Rotation<<N as SimdValue>::Element, D>; 8]> for Rotation<N, D> where     N: From<[<N as SimdValue>::Element; 8]>,     N::Element: Scalar + Copy,     DefaultAllocator: Allocator<N, D, D> + Allocator<N::Element, D, D>,

impl<N: Scalar + PrimitiveSimdValue, D: DimName> From<[Rotation<<N as SimdValue>::Element, D>; 16]> for Rotation<N, D> where     N: From<[<N as SimdValue>::Element; 16]>,     N::Element: Scalar + Copy,     DefaultAllocator: Allocator<N, D, D> + Allocator<N::Element, D, D>,

impl<N: SimdRealField> From<Unit<Quaternion<N>>> for Matrix4<N> where     N::Element: SimdRealField,

impl<N: SimdRealField> From<Unit<Quaternion<N>>> for Rotation3<N> where     N::Element: SimdRealField,

impl<N: SimdRealField> From<Rotation<N, U3>> for UnitQuaternion<N> where     N::Element: SimdRealField,

impl<N: SimdRealField> From<Unit<Quaternion<N>>> for Matrix3<N> where     N::Element: SimdRealField,

impl<N: Scalar> From<Matrix<N, U4, U1, <DefaultAllocator as Allocator<N, U4, U1>>::Buffer>> for Quaternion<N>

impl<N: Scalar> From<[N; 4]> for Quaternion<N>

impl<N: Scalar + PrimitiveSimdValue> From<[Quaternion<<N as SimdValue>::Element>; 2]> for Quaternion<N> where     N: From<[<N as SimdValue>::Element; 2]>,     N::Element: Scalar + Copy,

impl<N: Scalar + PrimitiveSimdValue> From<[Quaternion<<N as SimdValue>::Element>; 4]> for Quaternion<N> where     N: From<[<N as SimdValue>::Element; 4]>,     N::Element: Scalar + Copy,

impl<N: Scalar + PrimitiveSimdValue> From<[Quaternion<<N as SimdValue>::Element>; 8]> for Quaternion<N> where     N: From<[<N as SimdValue>::Element; 8]>,     N::Element: Scalar + Copy,

impl<N: Scalar + PrimitiveSimdValue> From<[Quaternion<<N as SimdValue>::Element>; 16]> for Quaternion<N> where     N: From<[<N as SimdValue>::Element; 16]>,     N::Element: Scalar + Copy,

impl<N: Scalar + Copy + PrimitiveSimdValue> From<[Unit<Quaternion<<N as SimdValue>::Element>>; 2]> for UnitQuaternion<N> where     N: From<[<N as SimdValue>::Element; 2]>,     N::Element: Scalar + Copy,

impl<N: Scalar + Copy + PrimitiveSimdValue> From<[Unit<Quaternion<<N as SimdValue>::Element>>; 4]> for UnitQuaternion<N> where     N: From<[<N as SimdValue>::Element; 4]>,     N::Element: Scalar + Copy,

impl<N: Scalar + Copy + PrimitiveSimdValue> From<[Unit<Quaternion<<N as SimdValue>::Element>>; 8]> for UnitQuaternion<N> where     N: From<[<N as SimdValue>::Element; 8]>,     N::Element: Scalar + Copy,

impl<N: Scalar + Copy + PrimitiveSimdValue> From<[Unit<Quaternion<<N as SimdValue>::Element>>; 16]> for UnitQuaternion<N> where     N: From<[<N as SimdValue>::Element; 16]>,     N::Element: Scalar + Copy,

impl<N: SimdRealField> From<Unit<Complex<N>>> for Rotation2<N> where     N::Element: SimdRealField,

impl<N: SimdRealField> From<Rotation<N, U2>> for UnitComplex<N> where     N::Element: SimdRealField,

impl<N: SimdRealField> From<Unit<Complex<N>>> for Matrix3<N> where     N::Element: SimdRealField,

impl<N: SimdRealField> From<Unit<Complex<N>>> for Matrix2<N> where     N::Element: SimdRealField,

impl<N: Scalar + Copy + PrimitiveSimdValue> From<[Unit<Complex<<N as SimdValue>::Element>>; 2]> for UnitComplex<N> where     N: From<[<N as SimdValue>::Element; 2]>,     N::Element: Scalar + Copy,

impl<N: Scalar + Copy + PrimitiveSimdValue> From<[Unit<Complex<<N as SimdValue>::Element>>; 4]> for UnitComplex<N> where     N: From<[<N as SimdValue>::Element; 4]>,     N::Element: Scalar + Copy,

impl<N: Scalar + Copy + PrimitiveSimdValue> From<[Unit<Complex<<N as SimdValue>::Element>>; 8]> for UnitComplex<N> where     N: From<[<N as SimdValue>::Element; 8]>,     N::Element: Scalar + Copy,

impl<N: Scalar + Copy + PrimitiveSimdValue> From<[Unit<Complex<<N as SimdValue>::Element>>; 16]> for UnitComplex<N> where     N: From<[<N as SimdValue>::Element; 16]>,     N::Element: Scalar + Copy,

impl<N: Scalar + Zero + One, D: DimName> From<Translation<N, D>> for MatrixN<N, DimNameSum<D, U1>> where     D: DimNameAdd<U1>,     DefaultAllocator: Allocator<N, D> + Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,

impl<N: Scalar, D: DimName> From<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for Translation<N, D> where     DefaultAllocator: Allocator<N, D>,

impl<N: Scalar + PrimitiveSimdValue, D: DimName> From<[Translation<<N as SimdValue>::Element, D>; 2]> for Translation<N, D> where     N: From<[<N as SimdValue>::Element; 2]>,     N::Element: Scalar,     DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,

impl<N: Scalar + PrimitiveSimdValue, D: DimName> From<[Translation<<N as SimdValue>::Element, D>; 4]> for Translation<N, D> where     N: From<[<N as SimdValue>::Element; 4]>,     N::Element: Scalar,     DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,

impl<N: Scalar + PrimitiveSimdValue, D: DimName> From<[Translation<<N as SimdValue>::Element, D>; 8]> for Translation<N, D> where     N: From<[<N as SimdValue>::Element; 8]>,     N::Element: Scalar,     DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,

impl<N: Scalar + PrimitiveSimdValue, D: DimName> From<[Translation<<N as SimdValue>::Element, D>; 16]> for Translation<N, D> where     N: From<[<N as SimdValue>::Element; 16]>,     N::Element: Scalar,     DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,

impl<N: SimdRealField, D: DimName, R: AbstractRotation<N, D>> From<Translation<N, D>> for Isometry<N, D, R> where     DefaultAllocator: Allocator<N, D>,

impl<N: SimdRealField, D: DimName, R> From<Isometry<N, D, R>> for MatrixN<N, DimNameSum<D, U1>> where     D: DimNameAdd<U1>,     R: SubsetOf<MatrixN<N, DimNameSum<D, U1>>>,     DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D>,

impl<N: Scalar + PrimitiveSimdValue, D: DimName, R> From<[Isometry<<N as SimdValue>::Element, D, <R as SimdValue>::Element>; 2]> for Isometry<N, D, R> where     N: From<[<N as SimdValue>::Element; 2]>,     R: SimdValue + AbstractRotation<N, D> + From<[<R as SimdValue>::Element; 2]>,     R::Element: AbstractRotation<N::Element, D>,     N::Element: Scalar + Copy,     R::Element: Scalar + Copy,     DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,

impl<N: Scalar + PrimitiveSimdValue, D: DimName, R> From<[Isometry<<N as SimdValue>::Element, D, <R as SimdValue>::Element>; 4]> for Isometry<N, D, R> where     N: From<[<N as SimdValue>::Element; 4]>,     R: SimdValue + AbstractRotation<N, D> + From<[<R as SimdValue>::Element; 4]>,     R::Element: AbstractRotation<N::Element, D>,     N::Element: Scalar + Copy,     R::Element: Scalar + Copy,     DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,

impl<N: Scalar + PrimitiveSimdValue, D: DimName, R> From<[Isometry<<N as SimdValue>::Element, D, <R as SimdValue>::Element>; 8]> for Isometry<N, D, R> where     N: From<[<N as SimdValue>::Element; 8]>,     R: SimdValue + AbstractRotation<N, D> + From<[<R as SimdValue>::Element; 8]>,     R::Element: AbstractRotation<N::Element, D>,     N::Element: Scalar + Copy,     R::Element: Scalar + Copy,     DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,

impl<N: Scalar + PrimitiveSimdValue, D: DimName, R> From<[Isometry<<N as SimdValue>::Element, D, <R as SimdValue>::Element>; 16]> for Isometry<N, D, R> where     N: From<[<N as SimdValue>::Element; 16]>,     R: SimdValue + AbstractRotation<N, D> + From<[<R as SimdValue>::Element; 16]>,     R::Element: AbstractRotation<N::Element, D>,     N::Element: Scalar + Copy,     R::Element: Scalar + Copy,     DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,

impl<N: SimdRealField, D: DimName, R> From<Similarity<N, D, R>> for MatrixN<N, DimNameSum<D, U1>> where     D: DimNameAdd<U1>,     R: SubsetOf<MatrixN<N, DimNameSum<D, U1>>>,     DefaultAllocator: Allocator<N, D> + Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,

impl<N: Scalar + Zero + PrimitiveSimdValue, D: DimName, R> From<[Similarity<<N as SimdValue>::Element, D, <R as SimdValue>::Element>; 2]> for Similarity<N, D, R> where     N: From<[<N as SimdValue>::Element; 2]>,     R: SimdValue + AbstractRotation<N, D> + From<[<R as SimdValue>::Element; 2]>,     R::Element: AbstractRotation<N::Element, D>,     N::Element: Scalar + Zero + Copy,     R::Element: Scalar + Zero + Copy,     DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,

impl<N: Scalar + Zero + PrimitiveSimdValue, D: DimName, R> From<[Similarity<<N as SimdValue>::Element, D, <R as SimdValue>::Element>; 4]> for Similarity<N, D, R> where     N: From<[<N as SimdValue>::Element; 4]>,     R: SimdValue + AbstractRotation<N, D> + From<[<R as SimdValue>::Element; 4]>,     R::Element: AbstractRotation<N::Element, D>,     N::Element: Scalar + Zero + Copy,     R::Element: Scalar + Zero + Copy,     DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,

impl<N: Scalar + Zero + PrimitiveSimdValue, D: DimName, R> From<[Similarity<<N as SimdValue>::Element, D, <R as SimdValue>::Element>; 8]> for Similarity<N, D, R> where     N: From<[<N as SimdValue>::Element; 8]>,     R: SimdValue + AbstractRotation<N, D> + From<[<R as SimdValue>::Element; 8]>,     R::Element: AbstractRotation<N::Element, D>,     N::Element: Scalar + Zero + Copy,     R::Element: Scalar + Zero + Copy,     DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,

impl<N: Scalar + Zero + PrimitiveSimdValue, D: DimName, R> From<[Similarity<<N as SimdValue>::Element, D, <R as SimdValue>::Element>; 16]> for Similarity<N, D, R> where     N: From<[<N as SimdValue>::Element; 16]>,     R: SimdValue + AbstractRotation<N, D> + From<[<R as SimdValue>::Element; 16]>,     R::Element: AbstractRotation<N::Element, D>,     N::Element: Scalar + Zero + Copy,     R::Element: Scalar + Zero + Copy,     DefaultAllocator: Allocator<N, D> + Allocator<N::Element, D>,

impl<N: RealField, D: DimName, C> From<Transform<N, D, C>> for MatrixN<N, DimNameSum<D, U1>> where     D: DimNameAdd<U1>,     C: TCategory,     DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,

impl<N: RealField> From<Orthographic3<N>> for Matrix4<N>

impl<N: RealField> From<Perspective3<N>> for Matrix4<N>

impl From<KeyData> for ContactId

impl From<ContactId> for KeyData

impl<N: RealField> From<TriMesh<N>> for TriMesh<N>

impl<T: Clone + Num> From<T> for Complex<T>

impl<'a, T: Clone + Num> From<&'a T> for Complex<T>

impl<T> From<T> for Ratio<T> where     T: Clone + Integer,

impl<T> From<(T, T)> for Ratio<T> where     T: Clone + Integer,

impl From<FromSliceError> for FixedUintError

impl From<IntoSliceError> for FixedUintError

impl From<FromStrError> for FixedUintError

impl From<bool> for U128

impl From<u8> for U128

impl<'a> From<&'a u8> for U128

impl From<u16> for U128

impl<'a> From<&'a u16> for U128

impl From<u32> for U128

impl<'a> From<&'a u32> for U128

impl From<u64> for U128

impl<'a> From<&'a u64> for U128

impl From<u128> for U128

impl<'a> From<&'a u128> for U128

impl From<bool> for U160

impl From<u8> for U160

impl<'a> From<&'a u8> for U160

impl From<u16> for U160

impl<'a> From<&'a u16> for U160

impl From<u32> for U160

impl<'a> From<&'a u32> for U160

impl From<u64> for U160

impl<'a> From<&'a u64> for U160

impl From<u128> for U160

impl<'a> From<&'a u128> for U160

impl From<bool> for U224

impl From<u8> for U224

impl<'a> From<&'a u8> for U224

impl From<u16> for U224

impl<'a> From<&'a u16> for U224

impl From<u32> for U224

impl<'a> From<&'a u32> for U224

impl From<u64> for U224

impl<'a> From<&'a u64> for U224

impl From<u128> for U224

impl<'a> From<&'a u128> for U224

impl From<bool> for U256

impl From<u8> for U256

impl<'a> From<&'a u8> for U256

impl From<u16> for U256

impl<'a> From<&'a u16> for U256

impl From<u32> for U256

impl<'a> From<&'a u32> for U256

impl From<u64> for U256

impl<'a> From<&'a u64> for U256

impl From<u128> for U256

impl<'a> From<&'a u128> for U256

impl From<bool> for U384

impl From<u8> for U384

impl<'a> From<&'a u8> for U384

impl From<u16> for U384

impl<'a> From<&'a u16> for U384

impl From<u32> for U384

impl<'a> From<&'a u32> for U384

impl From<u64> for U384

impl<'a> From<&'a u64> for U384

impl From<u128> for U384

impl<'a> From<&'a u128> for U384

impl From<bool> for U512

impl From<u8> for U512

impl<'a> From<&'a u8> for U512

impl From<u16> for U512

impl<'a> From<&'a u16> for U512

impl From<u32> for U512

impl<'a> From<&'a u32> for U512

impl From<u64> for U512

impl<'a> From<&'a u64> for U512

impl From<u128> for U512

impl<'a> From<&'a u128> for U512

impl From<bool> for U520

impl From<u8> for U520

impl<'a> From<&'a u8> for U520

impl From<u16> for U520

impl<'a> From<&'a u16> for U520

impl From<u32> for U520

impl<'a> From<&'a u32> for U520

impl From<u64> for U520

impl<'a> From<&'a u64> for U520

impl From<u128> for U520

impl<'a> From<&'a u128> for U520

impl From<bool> for U1024

impl From<u8> for U1024

impl<'a> From<&'a u8> for U1024

impl From<u16> for U1024

impl<'a> From<&'a u16> for U1024

impl From<u32> for U1024

impl<'a> From<&'a u32> for U1024

impl From<u64> for U1024

impl<'a> From<&'a u64> for U1024

impl From<u128> for U1024

impl<'a> From<&'a u128> for U1024

impl From<bool> for U2048

impl From<u8> for U2048

impl<'a> From<&'a u8> for U2048

impl From<u16> for U2048

impl<'a> From<&'a u16> for U2048

impl From<u32> for U2048

impl<'a> From<&'a u32> for U2048

impl From<u64> for U2048

impl<'a> From<&'a u64> for U2048

impl From<u128> for U2048

impl<'a> From<&'a u128> for U2048

impl From<bool> for U4096

impl From<u8> for U4096

impl<'a> From<&'a u8> for U4096

impl From<u16> for U4096

impl<'a> From<&'a u16> for U4096

impl From<u32> for U4096

impl<'a> From<&'a u32> for U4096

impl From<u64> for U4096

impl<'a> From<&'a u64> for U4096

impl From<u128> for U4096

impl<'a> From<&'a u128> for U4096

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

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

impl<T> From<T> for OnceCell<T>

impl<T> From<T> for OnceCell<T>

impl<Ix: IndexType> From<Ix> for NodeIndex<Ix>

impl<Ix: IndexType> From<Ix> for EdgeIndex<Ix>

impl<N, E, Ty, Ix> From<Graph<N, E, Ty, Ix>> for StableGraph<N, E, Ty, Ix> where     Ty: EdgeType,     Ix: IndexType,

impl<N, E, Ty, Ix> From<StableGraph<N, E, Ty, Ix>> for Graph<N, E, Ty, Ix> where     Ty: EdgeType,     Ix: IndexType,

impl From<Compression> for Compression

impl From<Compression> for CompressionOptions

impl From<Error> for DecodingError

impl From<String> for DecodingError

impl From<DecodingError> for Error

impl From<Error> for EncodingError

impl From<EncodingError> for Error

impl<'slice, T> From<&'slice [[T; 2]]> for Polygon<T> where     T: Clone + Zero + Signed + PartialEq + PartialOrd,     &'a T: Div<&'b T, Output = T> + Sub<&'b T, Output = T> + Add<&'b T, Output = T> + Mul<&'b T, Output = T>,

impl<T> From<(usize, T, [T; 2], [T; 2])> for Intersection<T>

impl From<Span> for Span

impl From<TokenStream> for TokenStream

impl From<TokenStream> for TokenStream

impl From<TokenTree> for TokenStream

impl From<Group> for TokenTree

impl From<Ident> for TokenTree

impl From<Punct> for TokenTree

impl From<Literal> for TokenTree

impl<X: SampleUniform> From<Range<X>> for Uniform<X>

impl<X: SampleUniform> From<RangeInclusive<X>> for Uniform<X>

impl From<Vec<u32, Global>> for IndexVec

impl From<Vec<usize, Global>> for IndexVec

impl From<ChaCha20Core> for ChaCha20Rng

impl From<ChaCha12Core> for ChaCha12Rng

impl From<ChaCha8Core> for ChaCha8Rng

impl From<NonZeroU32> for Error

impl From<Error> for Error

impl From<Error> for Error

impl<'t> From<Match<'t>> for Range<usize>

impl<'t> From<Match<'t>> for &'t str

impl<'t> From<Match<'t>> for Range<usize>

impl From<Error> for Error

impl From<Error> for Error

impl<'a> From<(&'a Vertex, f32)> for Vertex

impl From<Rotation> for Rotation

impl From<Point<f32, U3>> for Node

impl From<Translation<f32, U3>> for Node

impl From<Rotation<f32, U3>> for Node

impl From<Isometry<f32, U3, Unit<Quaternion<f32>>>> for Node

impl From<Unit<Quaternion<f32>>> for Node

impl<'a> From<&'a Projection> for Mvp

impl From<CameraMatrices> for Mvp

impl From<Matrix<f32, U4, U4, <DefaultAllocator as Allocator<f32, U4, U4>>::Buffer>> for Model

impl From<Node> for Model

impl<'a> From<&'a Matrix<f32, U4, U4, <DefaultAllocator as Allocator<f32, U4, U4>>::Buffer>> for Model

impl<'a, N: NodeRef> From<&'a N> for Model

impl<'a> From<&'a Point<f32, U3>> for Model

impl<'a> From<&'a Point<f32, U2>> for Model

impl<'a> From<&'a Translation<f32, U3>> for Model

impl<'a> From<&'a Rotation<f32, U3>> for Model

impl<'a> From<&'a Isometry<f32, U3, Unit<Quaternion<f32>>>> for Model

impl<'a> From<&'a Unit<Quaternion<f32>>> for Model

impl<'a> From<&'a Translation<f32, U2>> for Model

impl<'a> From<&'a Rotation<f32, U2>> for Model

impl<'a> From<&'a Isometry<f32, U2, Unit<Complex<f32>>>> for Model

impl<'a, C: CameraExt + ?Sized> From<(&'a C, &'a Rect<i32>)> for CameraMatrices

impl<'a> From<&'a Projection> for CameraMatrices

impl<T: PartialEq + Clone> From<T> for Parameter<T>

impl From<TextureRef> for TextureSampler

impl From<TextureRef> for Option<TextureSampler>

impl From<CubemapRef> for CubemapSampler

impl From<CubemapRef> for Option<CubemapSampler>

impl From<Rect> for Rect<u32>

impl From<Viewport> for Rect<i32>

impl From<Rect> for Rect<i32>

impl<T> From<T> for LazyUpdate<T>

impl<T> From<T> for Lazy<T>

impl<'a> From<&'a str> for Error

impl From<char> for Key

impl<'a> From<IdProperty<'a>> for Property

impl From<&'_ str> for LibraryId

impl From<PathBuf> for LibraryId

impl<T> From<Node<T>> for NodeId

impl<'a, T> From<NodeIdMut<'a, T>> for NodeId

impl<'a, T> From<NodeIdRef<'a, T>> for NodeId

impl<'a, T: Clone + 'a> From<Stream<'a, T>> for StreamRc<'a, T>

impl<'a, T: 'a> From<StreamRc<'a, T>> for Stream<'a, T>

impl<'a, T: Clone> From<T> for Property<'a, T>

impl<'a, T: Clone> From<T> for PropertyLastValue<'a, T>

impl From<Identifier> for Identifier

impl From<Version> for Version

impl From<(u64, u64, u64)> for Version

impl From<VersionReq> for VersionReq

impl From<String> for ReqParseError

impl From<Error> for Error

impl From<i8> for Value

impl From<i16> for Value

impl From<i32> for Value

impl From<i64> for Value

impl From<isize> for Value

impl From<u8> for Value

impl From<u16> for Value

impl From<u32> for Value

impl From<u64> for Value

impl From<usize> for Value

impl From<f32> for Value

impl From<f64> for Value

impl From<bool> for Value

impl From<String> for Value

impl<'a> From<&'a str> for Value

impl<'a> From<Cow<'a, str>> for Value

impl From<Number> for Value

impl From<Map<String, Value>> for Value

impl<T: Into<Value>> From<Vec<T, Global>> for Value

impl<'a, T: Clone + Into<Value>> From<&'a [T]> for Value

impl From<()> for Value

impl From<u8> for Number

impl From<u16> for Number

impl From<u32> for Number

impl From<u64> for Number

impl From<usize> for Number

impl From<i8> for Number

impl From<i16> for Number

impl From<i32> for Number

impl From<i64> for Number

impl From<isize> for Number

impl From<[f32; 2]> for AutoSimd<[f32; 2]>

impl From<AutoSimd<[f32; 2]>> for [f32; 2]

impl From<[f32; 4]> for AutoSimd<[f32; 4]>

impl From<AutoSimd<[f32; 4]>> for [f32; 4]

impl From<[f32; 8]> for AutoSimd<[f32; 8]>

impl From<AutoSimd<[f32; 8]>> for [f32; 8]

impl From<[f32; 16]> for AutoSimd<[f32; 16]>

impl From<AutoSimd<[f32; 16]>> for [f32; 16]

impl From<[f64; 2]> for AutoSimd<[f64; 2]>

impl From<AutoSimd<[f64; 2]>> for [f64; 2]

impl From<[f64; 4]> for AutoSimd<[f64; 4]>

impl From<AutoSimd<[f64; 4]>> for [f64; 4]

impl From<[f64; 8]> for AutoSimd<[f64; 8]>

impl From<AutoSimd<[f64; 8]>> for [f64; 8]

impl From<[i128; 1]> for AutoSimd<[i128; 1]>

impl From<AutoSimd<[i128; 1]>> for [i128; 1]

impl From<[i128; 2]> for AutoSimd<[i128; 2]>

impl From<AutoSimd<[i128; 2]>> for [i128; 2]

impl From<[i128; 4]> for AutoSimd<[i128; 4]>

impl From<AutoSimd<[i128; 4]>> for [i128; 4]

impl From<[i16; 2]> for AutoSimd<[i16; 2]>

impl From<AutoSimd<[i16; 2]>> for [i16; 2]

impl From<[i16; 4]> for AutoSimd<[i16; 4]>

impl From<AutoSimd<[i16; 4]>> for [i16; 4]

impl From<[i16; 8]> for AutoSimd<[i16; 8]>

impl From<AutoSimd<[i16; 8]>> for [i16; 8]

impl From<[i16; 16]> for AutoSimd<[i16; 16]>

impl From<AutoSimd<[i16; 16]>> for [i16; 16]

impl From<[i16; 32]> for AutoSimd<[i16; 32]>

impl From<AutoSimd<[i16; 32]>> for [i16; 32]

impl From<[i32; 2]> for AutoSimd<[i32; 2]>

impl From<AutoSimd<[i32; 2]>> for [i32; 2]

impl From<[i32; 4]> for AutoSimd<[i32; 4]>

impl From<AutoSimd<[i32; 4]>> for [i32; 4]

impl From<[i32; 8]> for AutoSimd<[i32; 8]>

impl From<AutoSimd<[i32; 8]>> for [i32; 8]

impl From<[i32; 16]> for AutoSimd<[i32; 16]>

impl From<AutoSimd<[i32; 16]>> for [i32; 16]

impl From<[i64; 2]> for AutoSimd<[i64; 2]>

impl From<AutoSimd<[i64; 2]>> for [i64; 2]

impl From<[i64; 4]> for AutoSimd<[i64; 4]>

impl From<AutoSimd<[i64; 4]>> for [i64; 4]

impl From<[i64; 8]> for AutoSimd<[i64; 8]>

impl From<AutoSimd<[i64; 8]>> for [i64; 8]

impl From<[i8; 2]> for AutoSimd<[i8; 2]>

impl From<AutoSimd<[i8; 2]>> for [i8; 2]

impl From<[i8; 4]> for AutoSimd<[i8; 4]>

impl From<AutoSimd<[i8; 4]>> for [i8; 4]

impl From<[i8; 8]> for AutoSimd<[i8; 8]>

impl From<AutoSimd<[i8; 8]>> for [i8; 8]

impl From<[i8; 16]> for AutoSimd<[i8; 16]>

impl From<AutoSimd<[i8; 16]>> for [i8; 16]

impl From<[i8; 32]> for AutoSimd<[i8; 32]>

impl From<AutoSimd<[i8; 32]>> for [i8; 32]

impl From<[isize; 2]> for AutoSimd<[isize; 2]>

impl From<AutoSimd<[isize; 2]>> for [isize; 2]

impl From<[isize; 4]> for AutoSimd<[isize; 4]>

impl From<AutoSimd<[isize; 4]>> for [isize; 4]

impl From<[isize; 8]> for AutoSimd<[isize; 8]>

impl From<AutoSimd<[isize; 8]>> for [isize; 8]

impl From<[u128; 1]> for AutoSimd<[u128; 1]>

impl From<AutoSimd<[u128; 1]>> for [u128; 1]

impl From<[u128; 2]> for AutoSimd<[u128; 2]>

impl From<AutoSimd<[u128; 2]>> for [u128; 2]

impl From<[u128; 4]> for AutoSimd<[u128; 4]>

impl From<AutoSimd<[u128; 4]>> for [u128; 4]

impl From<[u16; 2]> for AutoSimd<[u16; 2]>

impl From<AutoSimd<[u16; 2]>> for [u16; 2]

impl From<[u16; 4]> for AutoSimd<[u16; 4]>

impl From<AutoSimd<[u16; 4]>> for [u16; 4]

impl From<[u16; 8]> for AutoSimd<[u16; 8]>

impl From<AutoSimd<[u16; 8]>> for [u16; 8]

impl From<[u16; 16]> for AutoSimd<[u16; 16]>

impl From<AutoSimd<[u16; 16]>> for [u16; 16]

impl From<[u16; 32]> for AutoSimd<[u16; 32]>

impl From<AutoSimd<[u16; 32]>> for [u16; 32]

impl From<[u32; 2]> for AutoSimd<[u32; 2]>

impl From<AutoSimd<[u32; 2]>> for [u32; 2]

impl From<[u32; 4]> for AutoSimd<[u32; 4]>

impl From<AutoSimd<[u32; 4]>> for [u32; 4]

impl From<[u32; 8]> for AutoSimd<[u32; 8]>

impl From<AutoSimd<[u32; 8]>> for [u32; 8]

impl From<[u32; 16]> for AutoSimd<[u32; 16]>

impl From<AutoSimd<[u32; 16]>> for [u32; 16]

impl From<[u64; 2]> for AutoSimd<[u64; 2]>

impl From<AutoSimd<[u64; 2]>> for [u64; 2]

impl From<[u64; 4]> for AutoSimd<[u64; 4]>

impl From<AutoSimd<[u64; 4]>> for [u64; 4]

impl From<[u64; 8]> for AutoSimd<[u64; 8]>

impl From<AutoSimd<[u64; 8]>> for [u64; 8]

impl From<[u8; 2]> for AutoSimd<[u8; 2]>

impl From<AutoSimd<[u8; 2]>> for [u8; 2]

impl From<[u8; 4]> for AutoSimd<[u8; 4]>

impl From<AutoSimd<[u8; 4]>> for [u8; 4]

impl From<[u8; 8]> for AutoSimd<[u8; 8]>

impl From<AutoSimd<[u8; 8]>> for [u8; 8]

impl From<[u8; 16]> for AutoSimd<[u8; 16]>

impl From<AutoSimd<[u8; 16]>> for [u8; 16]

impl From<[u8; 32]> for AutoSimd<[u8; 32]>

impl From<AutoSimd<[u8; 32]>> for [u8; 32]

impl From<[usize; 2]> for AutoSimd<[usize; 2]>

impl From<AutoSimd<[usize; 2]>> for [usize; 2]

impl From<[usize; 4]> for AutoSimd<[usize; 4]>

impl From<AutoSimd<[usize; 4]>> for [usize; 4]

impl From<[usize; 8]> for AutoSimd<[usize; 8]>

impl From<AutoSimd<[usize; 8]>> for [usize; 8]

impl From<[bool; 1]> for AutoSimd<[bool; 1]>

impl From<[bool; 2]> for AutoSimd<[bool; 2]>

impl From<[bool; 4]> for AutoSimd<[bool; 4]>

impl From<[bool; 8]> for AutoSimd<[bool; 8]>

impl From<[bool; 16]> for AutoSimd<[bool; 16]>

impl From<[bool; 32]> for AutoSimd<[bool; 32]>

impl From<KeyData> for DefaultKey

impl From<DefaultKey> for KeyData

impl From<LayoutError> for CollectionAllocErr

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

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

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

impl From<SelfValue> for Ident

impl From<SelfType> for Ident

impl From<Super> for Ident

impl From<Crate> for Ident

impl From<Extern> for Ident

impl From<Underscore> for Ident

impl From<Path> for Meta

impl From<MetaList> for Meta

impl From<MetaNameValue> for Meta

impl From<Meta> for NestedMeta

impl From<Lit> for NestedMeta

impl From<FieldsNamed> for Fields

impl From<FieldsUnnamed> for Fields

impl From<VisPublic> for Visibility

impl From<VisCrate> for Visibility

impl From<VisRestricted> for Visibility

impl From<ExprArray> for Expr

impl From<ExprAssign> for Expr

impl From<ExprAssignOp> for Expr

impl From<ExprAsync> for Expr

impl From<ExprAwait> for Expr

impl From<ExprBinary> for Expr

impl From<ExprBlock> for Expr

impl From<ExprBox> for Expr

impl From<ExprBreak> for Expr

impl From<ExprCall> for Expr

impl From<ExprCast> for Expr

impl From<ExprClosure> for Expr

impl From<ExprContinue> for Expr

impl From<ExprField> for Expr

impl From<ExprForLoop> for Expr

impl From<ExprGroup> for Expr

impl From<ExprIf> for Expr

impl From<ExprIndex> for Expr

impl From<ExprLet> for Expr

impl From<ExprLit> for Expr

impl From<ExprLoop> for Expr

impl From<ExprMacro> for Expr

impl From<ExprMatch> for Expr

impl From<ExprMethodCall> for Expr

impl From<ExprParen> for Expr

impl From<ExprPath> for Expr

impl From<ExprRange> for Expr

impl From<ExprReference> for Expr

impl From<ExprRepeat> for Expr

impl From<ExprReturn> for Expr

impl From<ExprStruct> for Expr

impl From<ExprTry> for Expr

impl From<ExprTryBlock> for Expr

impl From<ExprTuple> for Expr

impl From<ExprType> for Expr

impl From<ExprUnary> for Expr

impl From<ExprUnsafe> for Expr

impl From<ExprWhile> for Expr

impl From<ExprYield> for Expr

impl From<usize> for Index

impl From<TypeParam> for GenericParam

impl From<LifetimeDef> for GenericParam

impl From<ConstParam> for GenericParam

impl From<Ident> for TypeParam

impl From<TraitBound> for TypeParamBound

impl From<Lifetime> for TypeParamBound

impl From<PredicateType> for WherePredicate

impl From<PredicateLifetime> for WherePredicate

impl From<PredicateEq> for WherePredicate

impl From<ItemConst> for Item

impl From<ItemEnum> for Item

impl From<ItemExternCrate> for Item

impl From<ItemFn> for Item

impl From<ItemForeignMod> for Item

impl From<ItemImpl> for Item

impl From<ItemMacro> for Item

impl From<ItemMacro2> for Item

impl From<ItemMod> for Item

impl From<ItemStatic> for Item

impl From<ItemStruct> for Item

impl From<ItemTrait> for Item

impl From<ItemTraitAlias> for Item

impl From<ItemType> for Item

impl From<ItemUnion> for Item

impl From<ItemUse> for Item

impl From<DeriveInput> for Item

impl From<ItemStruct> for DeriveInput

impl From<ItemEnum> for DeriveInput

impl From<ItemUnion> for DeriveInput

impl From<UsePath> for UseTree

impl From<UseName> for UseTree

impl From<UseRename> for UseTree

impl From<UseGlob> for UseTree

impl From<UseGroup> for UseTree

impl From<ForeignItemFn> for ForeignItem

impl From<ForeignItemStatic> for ForeignItem

impl From<ForeignItemType> for ForeignItem

impl From<ForeignItemMacro> for ForeignItem

impl From<TraitItemConst> for TraitItem

impl From<TraitItemMethod> for TraitItem

impl From<TraitItemType> for TraitItem

impl From<TraitItemMacro> for TraitItem

impl From<ImplItemConst> for ImplItem

impl From<ImplItemMethod> for ImplItem

impl From<ImplItemType> for ImplItem

impl From<ImplItemMacro> for ImplItem

impl From<Receiver> for FnArg

impl From<PatType> for FnArg

impl From<LitStr> for Lit

impl From<LitByteStr> for Lit

impl From<LitByte> for Lit

impl From<LitChar> for Lit

impl From<LitInt> for Lit

impl From<LitFloat> for Lit

impl From<LitBool> for Lit

impl From<Literal> for LitInt

impl From<Literal> for LitFloat

impl From<DataStruct> for Data

impl From<DataEnum> for Data

impl From<DataUnion> for Data

impl From<TypeArray> for Type

impl From<TypeBareFn> for Type

impl From<TypeGroup> for Type

impl From<TypeImplTrait> for Type

impl From<TypeInfer> for Type

impl From<TypeMacro> for Type

impl From<TypeNever> for Type

impl From<TypeParen> for Type

impl From<TypePath> for Type

impl From<TypePtr> for Type

impl From<TypeReference> for Type

impl From<TypeSlice> for Type

impl From<TypeTraitObject> for Type

impl From<TypeTuple> for Type

impl From<PatBox> for Pat

impl From<PatIdent> for Pat

impl From<PatLit> for Pat

impl From<PatMacro> for Pat

impl From<PatOr> for Pat

impl From<PatPath> for Pat

impl From<PatRange> for Pat

impl From<PatReference> for Pat

impl From<PatRest> for Pat

impl From<PatSlice> for Pat

impl From<PatStruct> for Pat

impl From<PatTuple> for Pat

impl From<PatTupleStruct> for Pat

impl From<PatType> for Pat

impl From<PatWild> for Pat

impl<T> From<T> for Path where     T: Into<PathSegment>,

impl<T> From<T> for PathSegment where     T: Into<Ident>,

impl From<LexError> for Error

impl From<Error> for TiffError

impl From<FromUtf8Error> for TiffError

impl From<TiffFormatError> for TiffError

impl From<TiffUnsupportedError> for TiffError

impl From<TryFromIntError> for TiffError

impl<'a> From<&'a str> for Value

impl<V: Into<Value>> From<Vec<V, Global>> for Value

impl<S: Into<String>, V: Into<Value>> From<BTreeMap<S, V>> for Value

impl<S: Into<String> + Hash + Eq, V: Into<Value>> From<HashMap<S, V, RandomState>> for Value

impl From<String> for Value

impl From<i64> for Value

impl From<i32> for Value

impl From<i8> for Value

impl From<u8> for Value

impl From<u32> for Value

impl From<f64> for Value

impl From<f32> for Value

impl From<bool> for Value

impl From<Datetime> for Value

impl From<Map<String, Value>> for Value

impl From<Error> for Error

impl From<XAnyEvent> for XEvent

impl<'a> From<&'a XAnyEvent> for XEvent

impl From<XEvent> for XAnyEvent

impl<'a> From<&'a XEvent> for XAnyEvent

impl From<XButtonEvent> for XEvent

impl<'a> From<&'a XButtonEvent> for XEvent

impl From<XEvent> for XButtonEvent

impl<'a> From<&'a XEvent> for XButtonEvent

impl From<XCirculateEvent> for XEvent

impl<'a> From<&'a XCirculateEvent> for XEvent

impl From<XEvent> for XCirculateEvent

impl<'a> From<&'a XEvent> for XCirculateEvent

impl From<XCirculateRequestEvent> for XEvent

impl<'a> From<&'a XCirculateRequestEvent> for XEvent

impl From<XEvent> for XCirculateRequestEvent

impl<'a> From<&'a XEvent> for XCirculateRequestEvent

impl From<XClientMessageEvent> for XEvent

impl<'a> From<&'a XClientMessageEvent> for XEvent

impl From<XEvent> for XClientMessageEvent

impl<'a> From<&'a XEvent> for XClientMessageEvent

impl From<XColormapEvent> for XEvent

impl<'a> From<&'a XColormapEvent> for XEvent

impl From<XEvent> for XColormapEvent

impl<'a> From<&'a XEvent> for XColormapEvent

impl From<XConfigureEvent> for XEvent

impl<'a> From<&'a XConfigureEvent> for XEvent

impl From<XEvent> for XConfigureEvent

impl<'a> From<&'a XEvent> for XConfigureEvent

impl From<XConfigureRequestEvent> for XEvent

impl<'a> From<&'a XConfigureRequestEvent> for XEvent

impl From<XEvent> for XConfigureRequestEvent

impl<'a> From<&'a XEvent> for XConfigureRequestEvent

impl From<XCreateWindowEvent> for XEvent

impl<'a> From<&'a XCreateWindowEvent> for XEvent

impl From<XEvent> for XCreateWindowEvent

impl<'a> From<&'a XEvent> for XCreateWindowEvent

impl From<XCrossingEvent> for XEvent

impl<'a> From<&'a XCrossingEvent> for XEvent

impl From<XEvent> for XCrossingEvent

impl<'a> From<&'a XEvent> for XCrossingEvent

impl From<XDestroyWindowEvent> for XEvent

impl<'a> From<&'a XDestroyWindowEvent> for XEvent

impl From<XEvent> for XDestroyWindowEvent

impl<'a> From<&'a XEvent> for XDestroyWindowEvent

impl From<XErrorEvent> for XEvent

impl<'a> From<&'a XErrorEvent> for XEvent

impl From<XEvent> for XErrorEvent

impl<'a> From<&'a XEvent> for XErrorEvent

impl From<XExposeEvent> for XEvent

impl<'a> From<&'a XExposeEvent> for XEvent

impl From<XEvent> for XExposeEvent

impl<'a> From<&'a XEvent> for XExposeEvent

impl From<XFocusChangeEvent> for XEvent

impl<'a> From<&'a XFocusChangeEvent> for XEvent

impl From<XEvent> for XFocusChangeEvent

impl<'a> From<&'a XEvent> for XFocusChangeEvent

impl From<XGenericEventCookie> for XEvent

impl<'a> From<&'a XGenericEventCookie> for XEvent

impl From<XEvent> for XGenericEventCookie

impl<'a> From<&'a XEvent> for XGenericEventCookie

impl From<XGraphicsExposeEvent> for XEvent

impl<'a> From<&'a XGraphicsExposeEvent> for XEvent

impl From<XEvent> for XGraphicsExposeEvent

impl<'a> From<&'a XEvent> for XGraphicsExposeEvent

impl From<XGravityEvent> for XEvent

impl<'a> From<&'a XGravityEvent> for XEvent

impl From<XEvent> for XGravityEvent

impl<'a> From<&'a XEvent> for XGravityEvent

impl From<XKeyEvent> for XEvent

impl<'a> From<&'a XKeyEvent> for XEvent

impl From<XEvent> for XKeyEvent

impl<'a> From<&'a XEvent> for XKeyEvent

impl From<XKeymapEvent> for XEvent

impl<'a> From<&'a XKeymapEvent> for XEvent

impl From<XEvent> for XKeymapEvent

impl<'a> From<&'a XEvent> for XKeymapEvent

impl From<XMapEvent> for XEvent

impl<'a> From<&'a XMapEvent> for XEvent

impl From<XEvent> for XMapEvent

impl<'a> From<&'a XEvent> for XMapEvent

impl From<XMappingEvent> for XEvent

impl<'a> From<&'a XMappingEvent> for XEvent

impl From<XEvent> for XMappingEvent

impl<'a> From<&'a XEvent> for XMappingEvent

impl From<XMapRequestEvent> for XEvent

impl<'a> From<&'a XMapRequestEvent> for XEvent

impl From<XEvent> for XMapRequestEvent

impl<'a> From<&'a XEvent> for XMapRequestEvent

impl From<XMotionEvent> for XEvent

impl<'a> From<&'a XMotionEvent> for XEvent

impl From<XEvent> for XMotionEvent

impl<'a> From<&'a XEvent> for XMotionEvent

impl From<XNoExposeEvent> for XEvent

impl<'a> From<&'a XNoExposeEvent> for XEvent

impl From<XEvent> for XNoExposeEvent

impl<'a> From<&'a XEvent> for XNoExposeEvent

impl From<XPropertyEvent> for XEvent

impl<'a> From<&'a XPropertyEvent> for XEvent

impl From<XEvent> for XPropertyEvent

impl<'a> From<&'a XEvent> for XPropertyEvent

impl From<XReparentEvent> for XEvent

impl<'a> From<&'a XReparentEvent> for XEvent

impl From<XEvent> for XReparentEvent

impl<'a> From<&'a XEvent> for XReparentEvent

impl From<XResizeRequestEvent> for XEvent

impl<'a> From<&'a XResizeRequestEvent> for XEvent

impl From<XEvent> for XResizeRequestEvent

impl<'a> From<&'a XEvent> for XResizeRequestEvent

impl From<XSelectionClearEvent> for XEvent

impl<'a> From<&'a XSelectionClearEvent> for XEvent

impl From<XEvent> for XSelectionClearEvent

impl<'a> From<&'a XEvent> for XSelectionClearEvent

impl From<XSelectionEvent> for XEvent

impl<'a> From<&'a XSelectionEvent> for XEvent

impl From<XEvent> for XSelectionEvent

impl<'a> From<&'a XEvent> for XSelectionEvent

impl From<XSelectionRequestEvent> for XEvent

impl<'a> From<&'a XSelectionRequestEvent> for XEvent

impl From<XEvent> for XSelectionRequestEvent

impl<'a> From<&'a XEvent> for XSelectionRequestEvent

impl From<XUnmapEvent> for XEvent

impl<'a> From<&'a XUnmapEvent> for XEvent

impl From<XEvent> for XUnmapEvent

impl<'a> From<&'a XEvent> for XUnmapEvent

impl From<XVisibilityEvent> for XEvent

impl<'a> From<&'a XVisibilityEvent> for XEvent

impl From<XEvent> for XVisibilityEvent

impl<'a> From<&'a XEvent> for XVisibilityEvent

impl From<[i8; 20]> for ClientMessageData

impl From<[u8; 20]> for ClientMessageData

impl From<[i16; 10]> for ClientMessageData

impl From<[u16; 10]> for ClientMessageData

impl From<[i64; 5]> for ClientMessageData

impl From<[u64; 5]> for ClientMessageData

impl From<XF86VidModeNotifyEvent> for XEvent

impl<'a> From<&'a XF86VidModeNotifyEvent> for XEvent

impl From<XEvent> for XF86VidModeNotifyEvent

impl<'a> From<&'a XEvent> for XF86VidModeNotifyEvent

impl From<XRRScreenChangeNotifyEvent> for XEvent

impl<'a> From<&'a XRRScreenChangeNotifyEvent> for XEvent

impl From<XEvent> for XRRScreenChangeNotifyEvent

impl<'a> From<&'a XEvent> for XRRScreenChangeNotifyEvent

impl From<XRRNotifyEvent> for XEvent

impl<'a> From<&'a XRRNotifyEvent> for XEvent

impl From<XEvent> for XRRNotifyEvent

impl<'a> From<&'a XEvent> for XRRNotifyEvent

impl From<XRROutputChangeNotifyEvent> for XEvent

impl<'a> From<&'a XRROutputChangeNotifyEvent> for XEvent

impl From<XEvent> for XRROutputChangeNotifyEvent

impl<'a> From<&'a XEvent> for XRROutputChangeNotifyEvent

impl From<XRRCrtcChangeNotifyEvent> for XEvent

impl<'a> From<&'a XRRCrtcChangeNotifyEvent> for XEvent

impl From<XEvent> for XRRCrtcChangeNotifyEvent

impl<'a> From<&'a XEvent> for XRRCrtcChangeNotifyEvent

impl From<XRROutputPropertyNotifyEvent> for XEvent

impl<'a> From<&'a XRROutputPropertyNotifyEvent> for XEvent

impl From<XEvent> for XRROutputPropertyNotifyEvent

impl<'a> From<&'a XEvent> for XRROutputPropertyNotifyEvent

impl From<XRRProviderChangeNotifyEvent> for XEvent

impl<'a> From<&'a XRRProviderChangeNotifyEvent> for XEvent

impl From<XEvent> for XRRProviderChangeNotifyEvent

impl<'a> From<&'a XEvent> for XRRProviderChangeNotifyEvent

impl From<XRRProviderPropertyNotifyEvent> for XEvent

impl<'a> From<&'a XRRProviderPropertyNotifyEvent> for XEvent

impl From<XEvent> for XRRProviderPropertyNotifyEvent

impl<'a> From<&'a XEvent> for XRRProviderPropertyNotifyEvent

impl From<XRRResourceChangeNotifyEvent> for XEvent

impl<'a> From<&'a XRRResourceChangeNotifyEvent> for XEvent

impl From<XEvent> for XRRResourceChangeNotifyEvent

impl<'a> From<&'a XEvent> for XRRResourceChangeNotifyEvent

impl From<XScreenSaverNotifyEvent> for XEvent

impl<'a> From<&'a XScreenSaverNotifyEvent> for XEvent

impl From<XEvent> for XScreenSaverNotifyEvent

impl<'a> From<&'a XEvent> for XScreenSaverNotifyEvent