Trait sp_std::convert::From

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

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

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

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

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

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

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

Generic Implementations

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

Examples

String implements From<&str>:

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

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

assert_eq!(string, other_string);

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

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

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

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

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

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

Required methods

fn from(T) -> Self

Performs the conversion.

Implementations on Foreign Types

impl From<OwnedFd> for UnixListener

pub fn from(fd: OwnedFd) -> UnixListener

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

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

Copies any value implementing AsRef<OsStr> into a newly allocated OsString.

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<UnixStream> for OwnedFd

pub fn from(unix_stream: UnixStream) -> OwnedFd

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

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

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<OwnedFd> for TcpListener

pub fn from(owned_fd: OwnedFd) -> TcpListener

impl From<NulError> for Error

pub fn from(NulError) -> Error

Converts a NulError into a io::Error.

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<OwnedFd> for UdpSocket

pub fn from(owned_fd: OwnedFd) -> UdpSocket

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<[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<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<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(0x12345678);
assert_eq!(Ipv4Addr::new(0x12, 0x34, 0x56, 0x78), addr);

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

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

Converts a Cow<'a, OsStr> into an OsString, by copying the contents if they are borrowed.

impl From<String> for OsString

pub fn from(s: String) -> OsString

Converts a String into an OsString.

This conversion does not allocate or copy memory.

impl From<TcpStream> for OwnedFd

pub fn from(tcp_stream: TcpStream) -> OwnedFd

impl From<OwnedFd> for PidFd

pub fn from(fd: OwnedFd) -> PidFd

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

pub fn from(code: u8) -> ExitCode

Construct an exit code from an arbitrary u8 value.

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<PidFd> for OwnedFd

pub fn from(pid_fd: PidFd) -> OwnedFd

impl From<File> for OwnedFd

pub fn from(file: File) -> OwnedFd

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 an IpAddr::V4 and creates a SocketAddr::V6 for an IpAddr::V6.

u16 is treated as port of the newly created SocketAddr.

impl<'_> From<&'_ CStr> for CString

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

Copies the contents of the &CStr into a newly allocated CString.

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

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

Create a new cell with its contents set to value.

Example

#![feature(once_cell)]

use std::lazy::SyncOnceCell;

let a = SyncOnceCell::from(3);
let b = SyncOnceCell::new();
b.set(3)?;
assert_eq!(a, b);
Ok(())

impl From<OwnedFd> for UnixStream

pub fn from(owned: OwnedFd) -> UnixStream

impl From<TcpListener> for OwnedFd

pub fn from(tcp_listener: TcpListener) -> OwnedFd

impl<T, const N: usize> From<[T; N]> for HashSet<T, RandomState> where
    T: Eq + Hash, 

pub fn from(arr: [T; N]) -> HashSet<T, RandomState>

Examples

use std::collections::HashSet;

let set1 = HashSet::from([1, 2, 3, 4]);
let set2: HashSet<_> = [1, 2, 3, 4].into();
assert_eq!(set1, set2);

impl From<UnixDatagram> for OwnedFd

pub fn from(unix_datagram: UnixDatagram) -> OwnedFd

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<OwnedFd> for UnixDatagram

pub fn from(owned: OwnedFd) -> UnixDatagram

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<'_, T> From<&'_ T> for PathBuf where
    T: AsRef<OsStr> + ?Sized, 

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

Converts a borrowed OsStr to a PathBuf.

Allocates a PathBuf and copies the data into it.

impl From<SocketAddrV6> for SocketAddr

pub fn from(sock6: SocketAddrV6) -> SocketAddr

Converts a SocketAddrV6 into a SocketAddr::V6.

impl From<OwnedFd> for TcpStream

pub fn from(owned_fd: OwnedFd) -> TcpStream

impl<K, V, const N: usize> From<[(K, V); N]> for HashMap<K, V, RandomState> where
    K: Eq + Hash, 

pub fn from(arr: [(K, V); N]) -> HashMap<K, V, RandomState>

Examples

use std::collections::HashMap;

let map1 = HashMap::from([(1, 2), (3, 4)]);
let map2: HashMap<_, _> = [(1, 2), (3, 4)].into();
assert_eq!(map1, map2);

impl From<SocketAddrV4> for SocketAddr

pub fn from(sock4: SocketAddrV4) -> SocketAddr

Converts a SocketAddrV4 into a SocketAddr::V4.

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

pub fn from(error: E) -> Report<Box<dyn Error + 'a, Global>>

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<UdpSocket> for OwnedFd

pub fn from(udp_socket: UdpSocket) -> OwnedFd

impl From<ChildStdin> for OwnedFd

pub fn from(child_stdin: ChildStdin) -> OwnedFd

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<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<[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<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<ChildStdout> for OwnedFd

pub fn from(child_stdout: ChildStdout) -> OwnedFd

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<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 creates 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<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<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(0x12, 0x34, 0x56, 0x78);
assert_eq!(0x12345678, u32::from(addr));

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<'a> From<Cow<'a, Path>> for PathBuf

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

Converts a clone-on-write pointer to an owned path.

Converting from a Cow::Owned does not clone or allocate.

impl From<OwnedFd> for Stdio

pub fn from(fd: OwnedFd) -> Stdio

impl<E> From<E> for Report<E> where
    E: Error, 

pub fn from(error: E) -> Report<E>

impl From<OwnedFd> for File

pub fn from(owned_fd: OwnedFd) -> File

impl From<ChildStderr> for OwnedFd

pub fn from(child_stderr: ChildStderr) -> OwnedFd

impl From<UnixListener> for OwnedFd

pub fn from(listener: UnixListener) -> OwnedFd

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

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

Converts a Cow<'a, CStr> into a CString, by copying the contents if they are borrowed.

impl<const LANES: usize> From<Mask<i16, LANES>> for Mask<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn from(value: Mask<i16, LANES>) -> Mask<i32, LANES>

impl From<Simd<usize, 2_usize>> for __m128i

pub fn from(value: Simd<usize, 2_usize>) -> __m128i

impl From<i32> for i128

pub fn from(small: i32) -> i128

Converts i32 to i128 losslessly.

impl From<Simd<f32, 4_usize>> for __m128

pub fn from(value: Simd<f32, 4_usize>) -> __m128

impl<const LANES: usize> From<Mask<i32, LANES>> for Mask<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn from(value: Mask<i32, LANES>) -> Mask<i64, LANES>

impl<const LANES: usize> From<Mask<isize, LANES>> for Mask<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn from(value: Mask<isize, LANES>) -> Mask<i16, LANES>

impl<const LANES: usize> From<Mask<i64, LANES>> for Mask<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn from(value: Mask<i64, LANES>) -> Mask<isize, LANES>

impl From<Simd<i32, 4_usize>> for __m128i

pub fn from(value: Simd<i32, 4_usize>) -> __m128i

impl From<u8> for i32

pub fn from(small: u8) -> i32

Converts u8 to i32 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<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 f64

pub fn from(small: i16) -> f64

Converts i16 to f64 losslessly.

impl From<Simd<isize, 2_usize>> for __m128i

pub fn from(value: Simd<isize, 2_usize>) -> __m128i

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

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

Moves the value into a Poll::Ready to make a Poll<T>.

Example

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

impl From<__m512i> for Simd<u32, 16_usize>

pub fn from(value: __m512i) -> Simd<u32, 16_usize>

impl From<i16> for f32

pub fn from(small: i16) -> f32

Converts i16 to f32 losslessly.

impl From<NonZeroUsize> for usize

pub fn from(nonzero: NonZeroUsize) -> usize

Converts a NonZeroUsize into an usize

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<Infallible> for TryFromSliceError

pub fn from(x: Infallible) -> TryFromSliceError

impl From<Simd<u8, 64_usize>> for __m512i

pub fn from(value: Simd<u8, 64_usize>) -> __m512i

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

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

Moves val into a new Some.

Examples

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

assert_eq!(Some(67), o);

impl From<Simd<i8, 16_usize>> for __m128i

pub fn from(value: Simd<i8, 16_usize>) -> __m128i

impl From<__m512i> for Simd<i32, 16_usize>

pub fn from(value: __m512i) -> Simd<i32, 16_usize>

impl From<Simd<usize, 8_usize>> for __m512i

pub fn from(value: Simd<usize, 8_usize>) -> __m512i

impl<const LANES: usize> From<Mask<i8, LANES>> for Mask<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn from(value: Mask<i8, LANES>) -> Mask<i32, LANES>

impl From<NonZeroU64> for u64

pub fn from(nonzero: NonZeroU64) -> u64

Converts a NonZeroU64 into an u64

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<const LANES: usize> From<Mask<isize, LANES>> for Mask<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn from(value: Mask<isize, LANES>) -> Mask<i32, LANES>

impl From<Simd<f64, 2_usize>> for __m128d

pub fn from(value: Simd<f64, 2_usize>) -> __m128d

impl From<i16> for isize

pub fn from(small: i16) -> isize

Converts i16 to isize losslessly.

impl From<Simd<u8, 16_usize>> for __m128i

pub fn from(value: Simd<u8, 16_usize>) -> __m128i

impl From<u8> for u32

pub fn from(small: u8) -> u32

Converts u8 to u32 losslessly.

impl From<u64> for i128

pub fn from(small: u64) -> i128

Converts u64 to i128 losslessly.

impl From<u8> for f32

pub fn from(small: u8) -> f32

Converts u8 to f32 losslessly.

impl<T, const LANES: usize> From<[T; LANES]> for Simd<T, LANES> where
    T: SimdElement,
    LaneCount<LANES>: SupportedLaneCount, 

pub fn from(array: [T; LANES]) -> Simd<T, LANES>

impl From<__m512i> for Simd<u8, 64_usize>

pub fn from(value: __m512i) -> Simd<u8, 64_usize>

impl From<u32> for u64

pub fn from(small: u32) -> u64

Converts u32 to u64 losslessly.

impl<const LANES: usize> From<Mask<i32, LANES>> for Mask<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn from(value: Mask<i32, LANES>) -> Mask<i16, LANES>

impl From<__m256i> for Simd<isize, 4_usize>

pub fn from(value: __m256i) -> Simd<isize, 4_usize>

impl From<Simd<f32, 16_usize>> for __m512

pub fn from(value: Simd<f32, 16_usize>) -> __m512

impl From<__m128i> for Simd<u64, 2_usize>

pub fn from(value: __m128i) -> Simd<u64, 2_usize>

impl From<__m128i> for Simd<u32, 4_usize>

pub fn from(value: __m128i) -> Simd<u32, 4_usize>

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

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

Creates a new OnceCell<T> which already contains the given value.

impl<T, const LANES: usize> From<Simd<T, LANES>> for [T; LANES] where
    T: SimdElement,
    LaneCount<LANES>: SupportedLaneCount, 

pub fn from(vector: Simd<T, LANES>) -> [T; LANES]

impl From<__m256i> for Simd<usize, 4_usize>

pub fn from(value: __m256i) -> Simd<usize, 4_usize>

impl From<Simd<f64, 4_usize>> for __m256d

pub fn from(value: Simd<f64, 4_usize>) -> __m256d

impl From<Simd<i32, 16_usize>> for __m512i

pub fn from(value: Simd<i32, 16_usize>) -> __m512i

impl From<i8> for isize

pub fn from(small: i8) -> isize

Converts i8 to isize losslessly.

impl From<Simd<u8, 32_usize>> for __m256i

pub fn from(value: Simd<u8, 32_usize>) -> __m256i

impl From<u16> for i64

pub fn from(small: u16) -> i64

Converts u16 to i64 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 From<NonZeroI8> for i8

pub fn from(nonzero: NonZeroI8) -> i8

Converts a NonZeroI8 into an i8

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 from 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 From<NonZeroU32> for u32

pub fn from(nonzero: NonZeroU32) -> u32

Converts a NonZeroU32 into an u32

impl From<i8> for i32

pub fn from(small: i8) -> i32

Converts i8 to i32 losslessly.

impl From<u8> for usize

pub fn from(small: u8) -> usize

Converts u8 to usize losslessly.

impl From<__m512i> for Simd<u16, 32_usize>

pub fn from(value: __m512i) -> Simd<u16, 32_usize>

impl From<__m512i> for Simd<i8, 64_usize>

pub fn from(value: __m512i) -> Simd<i8, 64_usize>

impl From<__m128i> for Simd<u16, 8_usize>

pub fn from(value: __m128i) -> Simd<u16, 8_usize>

impl<const LANES: usize> From<Mask<i16, LANES>> for Mask<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn from(value: Mask<i16, LANES>) -> Mask<i8, LANES>

impl From<u8> for i64

pub fn from(small: u8) -> i64

Converts u8 to i64 losslessly.

impl From<u32> for u128

pub fn from(small: u32) -> u128

Converts u32 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<Simd<u64, 2_usize>> for __m128i

pub fn from(value: Simd<u64, 2_usize>) -> __m128i

impl From<u16> for u32

pub fn from(small: u16) -> u32

Converts u16 to u32 losslessly.

impl From<u16> for u128

pub fn from(small: u16) -> u128

Converts u16 to u128 losslessly.

impl From<__m128i> for Simd<i32, 4_usize>

pub fn from(value: __m128i) -> Simd<i32, 4_usize>

impl From<__m512i> for Simd<usize, 8_usize>

pub fn from(value: __m512i) -> Simd<usize, 8_usize>

impl From<__m128i> for Simd<i16, 8_usize>

pub fn from(value: __m128i) -> Simd<i16, 8_usize>

impl From<__m512i> for Simd<i64, 8_usize>

pub fn from(value: __m512i) -> Simd<i64, 8_usize>

impl From<u32> for i128

pub fn from(small: u32) -> i128

Converts u32 to i128 losslessly.

impl From<__m256i> for Simd<u32, 8_usize>

pub fn from(value: __m256i) -> Simd<u32, 8_usize>

impl<const LANES: usize> From<Mask<i16, LANES>> for Mask<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn from(value: Mask<i16, LANES>) -> Mask<i64, LANES>

impl From<i64> for i128

pub fn from(small: i64) -> i128

Converts i64 to i128 losslessly.

impl From<__m256i> for Simd<u16, 16_usize>

pub fn from(value: __m256i) -> Simd<u16, 16_usize>

impl From<u8> for i128

pub fn from(small: u8) -> i128

Converts u8 to i128 losslessly.

impl From<__m256> for Simd<f32, 8_usize>

pub fn from(value: __m256) -> Simd<f32, 8_usize>

impl From<__m256i> for Simd<u8, 32_usize>

pub fn from(value: __m256i) -> Simd<u8, 32_usize>

impl<const LANES: usize> From<Mask<isize, LANES>> for Mask<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn from(value: Mask<isize, LANES>) -> Mask<i8, LANES>

impl<const LANES: usize> From<Mask<isize, LANES>> for Mask<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn from(value: Mask<isize, LANES>) -> Mask<i64, LANES>

impl From<__m128d> for Simd<f64, 2_usize>

pub fn from(value: __m128d) -> Simd<f64, 2_usize>

impl From<u32> for i64

pub fn from(small: u32) -> i64

Converts u32 to i64 losslessly.

impl From<u8> for f64

pub fn from(small: u8) -> f64

Converts u8 to f64 losslessly.

impl From<__m512i> for Simd<i16, 32_usize>

pub fn from(value: __m512i) -> Simd<i16, 32_usize>

impl From<__m256i> for Simd<u64, 4_usize>

pub fn from(value: __m256i) -> Simd<u64, 4_usize>

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

pub fn from(small: u16) -> i32

Converts u16 to i32 losslessly.

impl From<__m256i> for Simd<i16, 16_usize>

pub fn from(value: __m256i) -> Simd<i16, 16_usize>

impl From<NonZeroI16> for i16

pub fn from(nonzero: NonZeroI16) -> i16

Converts a NonZeroI16 into an i16

impl<T, const LANES: usize> From<Mask<T, LANES>> for Simd<T, LANES> where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 

pub fn from(value: Mask<T, LANES>) -> Simd<T, LANES>

impl From<__m128i> for Simd<usize, 2_usize>

pub fn from(value: __m128i) -> Simd<usize, 2_usize>

impl From<u8> for i16

pub fn from(small: u8) -> i16

Converts u8 to i16 losslessly.

impl From<Simd<u16, 8_usize>> for __m128i

pub fn from(value: Simd<u16, 8_usize>) -> __m128i

impl From<NonZeroI32> for i32

pub fn from(nonzero: NonZeroI32) -> i32

Converts a NonZeroI32 into an i32

impl From<Simd<i16, 32_usize>> for __m512i

pub fn from(value: Simd<i16, 32_usize>) -> __m512i

impl<const LANES: usize> From<Mask<i64, LANES>> for Mask<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn from(value: Mask<i64, LANES>) -> Mask<i16, LANES>

impl From<Simd<i32, 8_usize>> for __m256i

pub fn from(value: Simd<i32, 8_usize>) -> __m256i

impl From<__m512i> for Simd<isize, 8_usize>

pub fn from(value: __m512i) -> Simd<isize, 8_usize>

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

pub fn from(nonzero: NonZeroU8) -> u8

Converts a NonZeroU8 into an u8

impl From<Simd<isize, 8_usize>> for __m512i

pub fn from(value: Simd<isize, 8_usize>) -> __m512i

impl<T, const LANES: usize> From<[bool; LANES]> for Mask<T, LANES> where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 

pub fn from(array: [bool; LANES]) -> Mask<T, LANES>

impl From<u16> for f64

pub fn from(small: u16) -> f64

Converts u16 to f64 losslessly.

impl From<Simd<i64, 4_usize>> for __m256i

pub fn from(value: Simd<i64, 4_usize>) -> __m256i

impl From<u8> for u128

pub fn from(small: u8) -> u128

Converts u8 to u128 losslessly.

impl From<u16> for i128

pub fn from(small: u16) -> i128

Converts u16 to i128 losslessly.

impl From<__m512d> for Simd<f64, 8_usize>

pub fn from(value: __m512d) -> Simd<f64, 8_usize>

impl From<__m128i> for Simd<u8, 16_usize>

pub fn from(value: __m128i) -> Simd<u8, 16_usize>

impl From<NonZeroU16> for u16

pub fn from(nonzero: NonZeroU16) -> u16

Converts a NonZeroU16 into an u16

impl From<i8> for f64

pub fn from(small: i8) -> f64

Converts i8 to f64 losslessly.

impl From<Simd<u16, 16_usize>> for __m256i

pub fn from(value: Simd<u16, 16_usize>) -> __m256i

impl From<u8> for u64

pub fn from(small: u8) -> u64

Converts u8 to u64 losslessly.

impl From<Simd<i16, 8_usize>> for __m128i

pub fn from(value: Simd<i16, 8_usize>) -> __m128i

impl<const LANES: usize> From<Mask<i8, LANES>> for Mask<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn from(value: Mask<i8, LANES>) -> Mask<isize, LANES>

impl From<Simd<u32, 16_usize>> for __m512i

pub fn from(value: Simd<u32, 16_usize>) -> __m512i

impl From<i8> for i16

pub fn from(small: i8) -> i16

Converts i8 to i16 losslessly.

impl From<NonZeroI128> for i128

pub fn from(nonzero: NonZeroI128) -> i128

Converts a NonZeroI128 into an i128

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 From<i8> for i128

pub fn from(small: i8) -> i128

Converts i8 to i128 losslessly.

impl From<u16> for f32

pub fn from(small: u16) -> f32

Converts u16 to f32 losslessly.

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<__m128> for Simd<f32, 4_usize>

pub fn from(value: __m128) -> Simd<f32, 4_usize>

impl<T, const LANES: usize> From<Mask<T, LANES>> for [bool; LANES] where
    T: MaskElement,
    LaneCount<LANES>: SupportedLaneCount, 

pub fn from(vector: Mask<T, LANES>) -> [bool; LANES]

impl From<u32> for f64

pub fn from(small: u32) -> f64

Converts u32 to f64 losslessly.

impl From<__m128i> for Simd<isize, 2_usize>

pub fn from(value: __m128i) -> Simd<isize, 2_usize>

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<__m256d> for Simd<f64, 4_usize>

pub fn from(value: __m256d) -> Simd<f64, 4_usize>

impl From<__m128i> for Simd<i8, 16_usize>

pub fn from(value: __m128i) -> Simd<i8, 16_usize>

impl From<i8> for i64

pub fn from(small: i8) -> i64

Converts i8 to i64 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<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<const LANES: usize> From<Mask<i32, LANES>> for Mask<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn from(value: Mask<i32, LANES>) -> Mask<isize, LANES>

impl From<NonZeroI64> for i64

pub fn from(nonzero: NonZeroI64) -> i64

Converts a NonZeroI64 into an i64

impl From<i16> for i32

pub fn from(small: i16) -> i32

Converts i16 to i32 losslessly.

impl From<Simd<f64, 8_usize>> for __m512d

pub fn from(value: Simd<f64, 8_usize>) -> __m512d

impl<const LANES: usize> From<Mask<i64, LANES>> for Mask<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn from(value: Mask<i64, LANES>) -> Mask<i32, LANES>

impl From<Simd<i8, 64_usize>> for __m512i

pub fn from(value: Simd<i8, 64_usize>) -> __m512i

impl From<__m256i> for Simd<i8, 32_usize>

pub fn from(value: __m256i) -> Simd<i8, 32_usize>

impl From<i32> for f64

pub fn from(small: i32) -> f64

Converts i32 to f64 losslessly.

impl From<u8> for u16

pub fn from(small: u8) -> u16

Converts u8 to u16 losslessly.

impl From<f32> for f64

pub fn from(small: f32) -> f64

Converts f32 to f64 losslessly.

impl From<__m256i> for Simd<i32, 8_usize>

pub fn from(value: __m256i) -> Simd<i32, 8_usize>

impl From<Simd<i64, 2_usize>> for __m128i

pub fn from(value: Simd<i64, 2_usize>) -> __m128i

impl From<NonZeroU128> for u128

pub fn from(nonzero: NonZeroU128) -> u128

Converts a NonZeroU128 into an u128

impl<const LANES: usize> From<Mask<i16, LANES>> for Mask<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn from(value: Mask<i16, LANES>) -> Mask<isize, LANES>

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<const LANES: usize> From<Mask<i64, LANES>> for Mask<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn from(value: Mask<i64, LANES>) -> Mask<i8, LANES>

impl From<__m128i> for Simd<i64, 2_usize>

pub fn from(value: __m128i) -> Simd<i64, 2_usize>

impl From<i8> for f32

pub fn from(small: i8) -> f32

Converts i8 to f32 losslessly.

impl<const LANES: usize> From<Mask<i32, LANES>> for Mask<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn from(value: Mask<i32, LANES>) -> Mask<i8, LANES>

impl From<Simd<i8, 32_usize>> for __m256i

pub fn from(value: Simd<i8, 32_usize>) -> __m256i

impl From<Simd<f32, 8_usize>> for __m256

pub fn from(value: Simd<f32, 8_usize>) -> __m256

impl From<u64> for u128

pub fn from(small: u64) -> u128

Converts u64 to u128 losslessly.

impl From<u16> for usize

pub fn from(small: u16) -> usize

Converts u16 to usize losslessly.

impl From<Simd<u32, 4_usize>> for __m128i

pub fn from(value: Simd<u32, 4_usize>) -> __m128i

impl From<__m512> for Simd<f32, 16_usize>

pub fn from(value: __m512) -> Simd<f32, 16_usize>

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<const LANES: usize> From<Mask<i8, LANES>> for Mask<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn from(value: Mask<i8, LANES>) -> Mask<i16, LANES>

impl From<NonZeroIsize> for isize

pub fn from(nonzero: NonZeroIsize) -> isize

Converts a NonZeroIsize into an isize

impl From<u16> for u64

pub fn from(small: u16) -> u64

Converts u16 to u64 losslessly.

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<Simd<u32, 8_usize>> for __m256i

pub fn from(value: Simd<u32, 8_usize>) -> __m256i

impl From<Simd<u64, 4_usize>> for __m256i

pub fn from(value: Simd<u64, 4_usize>) -> __m256i

impl From<Simd<isize, 4_usize>> for __m256i

pub fn from(value: Simd<isize, 4_usize>) -> __m256i

impl From<i16> for i64

pub fn from(small: i16) -> i64

Converts i16 to i64 losslessly.

impl From<Simd<u64, 8_usize>> for __m512i

pub fn from(value: Simd<u64, 8_usize>) -> __m512i

impl From<Simd<usize, 4_usize>> for __m256i

pub fn from(value: Simd<usize, 4_usize>) -> __m256i

impl From<u8> for isize

pub fn from(small: u8) -> isize

Converts u8 to isize losslessly.

impl From<Simd<i16, 16_usize>> for __m256i

pub fn from(value: Simd<i16, 16_usize>) -> __m256i

impl From<Simd<i64, 8_usize>> for __m512i

pub fn from(value: Simd<i64, 8_usize>) -> __m512i

impl From<i16> for i128

pub fn from(small: i16) -> i128

Converts i16 to i128 losslessly.

impl From<__m512i> for Simd<u64, 8_usize>

pub fn from(value: __m512i) -> Simd<u64, 8_usize>

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

pub fn from(small: i32) -> i64

Converts i32 to i64 losslessly.

impl From<__m256i> for Simd<i64, 4_usize>

pub fn from(value: __m256i) -> Simd<i64, 4_usize>

impl<const LANES: usize> From<Mask<i8, LANES>> for Mask<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn from(value: Mask<i8, LANES>) -> Mask<i64, LANES>

impl From<Simd<u16, 32_usize>> for __m512i

pub fn from(value: Simd<u16, 32_usize>) -> __m512i

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

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

Converts a &String into a String.

This clones s and returns the clone.

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

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

Converts a &str into a String.

The result is allocated on the heap.

impl From<LayoutError> for TryReserveErrorKind

pub fn from(LayoutError) -> TryReserveErrorKind

Always evaluates to TryReserveErrorKind::CapacityOverflow.

impl From<TryReserveErrorKind> for TryReserveError

pub fn from(kind: TryReserveErrorKind) -> TryReserveError

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

pub fn from(arr: [T; N]) -> LinkedList<T>

Converts a [T; N] into a LinkedList<T>.

use std::collections::LinkedList;

let list1 = LinkedList::from([1, 2, 3, 4]);
let list2: LinkedList<_> = [1, 2, 3, 4].into();
assert_eq!(list1, list2);

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, A> From<Box<T, A>> for Pin<Box<T, A>> where
    A: Allocator + 'static,
    T: ?Sized, 

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<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 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<&'_ 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<'a> From<Cow<'a, str>> for String

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

Converts a clone-on-write string to an owned instance of String.

This extracts the owned string, clones the string if it is not already owned.

Example

// If the string is not owned...
let cow: Cow<str> = Cow::Borrowed("eggplant");
// It will allocate on the heap and copy the string.
let owned: String = String::from(cow);
assert_eq!(&owned[..], "eggplant");

impl<T, const N: usize> From<[T; N]> for BinaryHeap<T> where
    T: Ord, 

pub fn from(arr: [T; N]) -> BinaryHeap<T>

use std::collections::BinaryHeap;

let mut h1 = BinaryHeap::from([1, 4, 2, 3]);
let mut h2: BinaryHeap<_> = [1, 4, 2, 3].into();
while let Some((a, b)) = h1.pop().zip(h2.pop()) {
    assert_eq!(a, b);
}

impl From<char> for String

pub fn from(c: char) -> String

Allocates an owned String from a single character.

Example

let c: char = 'a';
let s: String = String::from(c);
assert_eq!("a", &s[..]);

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.

Implementors

impl From<Infallible> for TryFromIntError

impl From<bool> for AtomicBool

impl From<i8> for AtomicI8

impl From<i16> for AtomicI16

impl From<i32> for AtomicI32

impl From<i64> for AtomicI64

impl From<isize> for AtomicIsize

impl From<!> for Infallible

impl From<!> for TryFromIntError

impl From<u8> for AtomicU8

impl From<u16> for AtomicU16

impl From<u32> for AtomicU32

impl From<u64> for AtomicU64

impl From<usize> for AtomicUsize

impl From<NonZeroI8> for NonZeroI16

impl From<NonZeroI8> for NonZeroI32

impl From<NonZeroI8> for NonZeroI64

impl From<NonZeroI8> for NonZeroI128

impl From<NonZeroI8> for NonZeroIsize

impl From<NonZeroI16> for NonZeroI32

impl From<NonZeroI16> for NonZeroI64

impl From<NonZeroI16> for NonZeroI128

impl From<NonZeroI16> for NonZeroIsize

impl From<NonZeroI32> for NonZeroI64

impl From<NonZeroI32> for NonZeroI128

impl From<NonZeroI64> for NonZeroI128

impl From<NonZeroU8> for NonZeroI16

impl From<NonZeroU8> for NonZeroI32

impl From<NonZeroU8> for NonZeroI64

impl From<NonZeroU8> for NonZeroI128

impl From<NonZeroU8> for NonZeroIsize

impl From<NonZeroU8> for NonZeroU16

impl From<NonZeroU8> for NonZeroU32

impl From<NonZeroU8> for NonZeroU64

impl From<NonZeroU8> for NonZeroU128

impl From<NonZeroU8> for NonZeroUsize

impl From<NonZeroU16> for NonZeroI32

impl From<NonZeroU16> for NonZeroI64

impl From<NonZeroU16> for NonZeroI128

impl From<NonZeroU16> for NonZeroU32

impl From<NonZeroU16> for NonZeroU64

impl From<NonZeroU16> for NonZeroU128

impl From<NonZeroU16> for NonZeroUsize

impl From<NonZeroU32> for NonZeroI64

impl From<NonZeroU32> for NonZeroI128

impl From<NonZeroU32> for NonZeroU64

impl From<NonZeroU32> for NonZeroU128

impl From<NonZeroU64> for NonZeroI128

impl From<NonZeroU64> for NonZeroU128

impl From<RecvError> for RecvTimeoutError

impl From<RecvError> for TryRecvError

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

impl From<String> for Box<dyn Error + 'static, Global>

impl From<String> for Box<dyn Error + Send + Sync + 'static, Global>

impl From<String> for Rc<str>

impl From<String> for Arc<str>

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

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

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

impl From<CString> for Rc<CStr>

impl From<CString> for Arc<CStr>

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

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

impl From<OsString> for Rc<OsStr>

impl From<OsString> for Arc<OsStr>

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

impl From<PathBuf> for Rc<Path>

impl From<PathBuf> for Arc<Path>

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

impl<'_> From<&'_ str> for Box<dyn Error + 'static, Global>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a, E> From<E> for Box<dyn Error + 'a, Global> where
    E: 'a + Error, 

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

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

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

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

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

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

impl<K, V, const N: usize> From<[(K, V); N]> for BTreeMap<K, V> where
    K: Ord, 

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.

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

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

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

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

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

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

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

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

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

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

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

impl<T> From<T> for UnsafeCell<T>

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

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

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

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

impl<T> From<T> for T

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

impl<T, A> From<VecDeque<T, A>> for Vec<T, A> where
    A: Allocator, 

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

impl<T, A> From<Vec<T, A>> for VecDeque<T, A> where
    A: Allocator, 

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

impl<T, const N: usize> From<[T; N]> for BTreeSet<T> where
    T: Ord, 

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

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

impl<'msg, 'aad> From<&'msg [u8]> for Payload<'msg, 'aad>

impl<Aes, NonceSize> From<Aes> for AesGcm<Aes, NonceSize> where
    Aes: BlockCipher<BlockSize = U16>,
    Aes::ParBlocks: ArrayLength<Block<Aes>>,
    NonceSize: ArrayLength<u8>, 

impl From<Event<Runtime>> for Event

impl From<Event> for Event

impl From<Event<Runtime, ()>> for Event

impl From<RawEvent<<Runtime as Config>::AccountId>> for Event

impl From<Event> for Event

impl From<Event<Runtime>> for Event

impl From<Event<Runtime>> for Event

impl From<RawOrigin<<Runtime as Config>::AccountId>> for OriginCaller

impl From<RawOrigin<<Runtime as Config>::AccountId>> for Origin

impl From<OriginCaller> for Origin

impl From<Option<<Runtime as Config>::AccountId>> for Origin

impl From<<Pallet<Runtime> as Callable<Runtime>>::Call> for Call

impl From<<Module<Runtime> as Callable<Runtime>>::Call> for Call

impl From<<Pallet<Runtime> as Callable<Runtime>>::Call> for Call

impl From<<Module<Runtime> as Callable<Runtime>>::Call> for Call

impl From<<Pallet<Runtime, ()> as Callable<Runtime>>::Call> for Call

impl From<<Module<Runtime> as Callable<Runtime>>::Call> for Call

impl From<<Module<Runtime> as Callable<Runtime>>::Call> for Call

impl From<<Pallet<Runtime> as Callable<Runtime>>::Call> for Call

impl From<<Pallet<Runtime> as Callable<Runtime>>::Call> for Call

impl From<&'_ str> for Characters

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

impl<T: Config> From<Error<T>> for &'static str

impl<T: Config> From<Error<T>> for DispatchError

impl From<Colour> for Style

impl<'a, I, S: 'a + ToOwned + ?Sized> From<I> for ANSIGenericString<'a, S> where
    I: Into<Cow<'a, S>>,
    <S as ToOwned>::Owned: Debug, 

impl<E> From<E> for Error where
    E: StdError + Send + Sync + 'static, 

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

impl From<Error> for Box<dyn StdError + Send + 'static>

impl From<Error> for Box<dyn StdError + 'static>

impl<T, const CAP: usize> From<[T; CAP]> for ArrayVec<T, CAP>

impl From<u8> for DerTag

impl From<DerTag> for u8

impl From<usize> for DerLength

impl From<DerLength> for usize

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

impl From<DerValue> for Vec<u8>

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

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

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

impl From<UnixDatagram> for UnixDatagram

impl From<UnixListener> for UnixListener

impl From<UnixStream> for UnixStream

impl From<File> for File

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

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

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

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

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

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

impl From<PathBuf> for Box<Path>

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

impl From<OsString> for PathBuf

impl From<PathBuf> for OsString

impl From<String> for PathBuf

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

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

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

impl From<PathBuf> for Arc<Path>

impl From<PathBuf> for Rc<Path>

impl From<PathBuf> for PathBuf

impl From<TcpListener> for TcpListener

impl From<TcpStream> for TcpStream

impl From<UdpSocket> for UdpSocket

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

impl From<Frame> for BacktraceFrame

impl From<Error> for Error

impl From<Mnemonic> for String

impl<O, V> From<V> for BitArray<O, V> where
    O: BitOrder,
    V: BitView, 

impl<T> From<&'_ T> for Address<Const, T> where
    T: BitStore, 

impl<T> From<&'_ mut T> for Address<Mut, T> where
    T: BitStore, 

impl<T> From<Infallible> for AddressError<T> where
    T: BitStore, 

impl<M, O, T> From<Range<BitPtr<M, O, T>>> for BitPtrRange<M, O, T> where
    M: Mutability,
    O: BitOrder,
    T: BitStore, 

impl<O, T> From<&'_ T> for BitPtr<Const, O, T> where
    O: BitOrder,
    T: BitStore, 

impl<O, T> From<&'_ mut T> for BitPtr<Mut, O, T> where
    O: BitOrder,
    T: BitStore, 

impl<T> From<AddressError<T>> for BitPtrError<T> where
    T: BitStore, 

impl<T> From<BitIdxError<<T as BitStore>::Mem>> for BitPtrError<T> where
    T: BitStore, 

impl<T> From<Infallible> for BitPtrError<T> where
    T: BitStore, 

impl<T> From<BitPtrError<T>> for BitSpanError<T> where
    T: BitStore, 

impl<T> From<Infallible> for BitSpanError<T> where
    T: BitStore, 

impl<'a, O, T> From<&'a BitSlice<O, T>> for BitBox<O, T> where
    O: BitOrder,
    T: BitStore, 

impl<O, T> From<BitVec<O, T>> for BitBox<O, T> where
    O: BitOrder,
    T: BitStore, 

impl<'a, O, T> From<&'a BitSlice<O, T>> for BitVec<O, T> where
    O: BitOrder,
    T: BitStore, 

impl<'a, O, T> From<&'a mut BitSlice<O, T>> for BitVec<O, T> where
    O: BitOrder,
    T: BitStore, 

impl<O, T> From<BitBox<O, T>> for BitVec<O, T> where
    O: BitOrder,
    T: BitStore, 

impl<'a> From<&'a [u8]> for BString

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

impl From<BString> for Vec<u8>

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

impl From<String> for BString

impl<'a> From<&'a BStr> for BString

impl<'a> From<BString> for Cow<'a, BStr>

impl<'a> From<&'a [u8]> for &'a BStr

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

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

impl From<Box<[u8], Global>> for Box<BStr>

impl From<Box<BStr, Global>> for Box<[u8]>

impl From<&'static [u8]> for Bytes

impl From<&'static str> for Bytes

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

impl From<String> for Bytes

impl<'a> From<&'a [u8]> for BytesMut

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

impl From<BytesMut> for Bytes

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

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<const S: usize> From<&'_ Cid<S>> for Cid<S>

impl<const S: usize> From<Cid<S>> for Vec<u8>

impl<const S: usize> From<Cid<S>> for String

impl<'a, const S: usize> From<Cid<S>> for Cow<'a, Cid<S>>

impl<'a, const S: usize> From<&'a Cid<S>> for Cow<'a, Cid<S>>

impl From<Error> for Error

impl From<Error> for Error

impl From<Error> for Error

impl From<Error> for Error

impl From<Version> for u64

impl From<OverflowError> for LoopError

impl<'a, 'b, 'z> From<&'z Arg<'a, 'b>> for Arg<'a, 'b>

impl<'a, 'z> From<&'z ArgGroup<'a>> for ArgGroup<'a>

impl From<Error> for Error

impl From<Error> for Error

impl<'a, E: Error + 'a> From<E> for Box<dyn Error + 'a>

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

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

impl From<String> for Box<dyn Error>

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

impl From<&'_ str> for Box<dyn Error>

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

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

impl From<ErrorKind> for Error

impl From<bool> for DataValue

impl From<i8> for DataValue

impl From<i16> for DataValue

impl From<i32> for DataValue

impl From<i64> for DataValue

impl From<u8> for DataValue

impl From<u16> for DataValue

impl From<u32> for DataValue

impl From<u64> for DataValue

impl From<Ieee32> for DataValue

impl From<Ieee64> for DataValue

impl From<[u8; 16]> for DataValue

impl From<Offset32> for DataValue

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

impl From<&'_ [u8]> for ConstantData

impl From<V128Imm> for ConstantData

impl From<Block> for AnyEntity

impl From<Inst> for AnyEntity

impl From<Value> for AnyEntity

impl From<StackSlot> for AnyEntity

impl From<GlobalValue> for AnyEntity

impl From<JumpTable> for AnyEntity

impl From<Constant> for AnyEntity

impl From<FuncRef> for AnyEntity

impl From<SigRef> for AnyEntity

impl From<Heap> for AnyEntity

impl From<Table> for AnyEntity

impl<'a> From<Option<&'a (dyn TargetIsa + 'a)>> for DisplayFunctionAnnotations<'a>

impl From<i64> for Imm64

impl From<u64> for Uimm64

impl From<u32> for Uimm32

impl From<&'_ [u8]> for V128Imm

impl From<i32> for Offset32

impl From<f32> for Ieee32

impl From<f64> for Ieee64

impl From<u64> for Ieee64

impl<'a> From<&'a InstructionData> for InstructionFormat

impl From<Opcode> for NonZeroU32

impl From<Inst> for ProgramPoint

impl From<Block> for ProgramPoint

impl From<ValueDef> for ProgramPoint

impl From<Inst> for ExpandedProgramPoint

impl From<Block> for ExpandedProgramPoint

impl From<ValueDef> for ExpandedProgramPoint

impl From<ProgramPoint> for ExpandedProgramPoint

impl From<&'static RegClassData> for RegClassIndex

impl<'a> From<&'a Flags> for FlagsOrIsa<'a>

impl<'a> From<&'a (dyn TargetIsa + 'a)> for FlagsOrIsa<'a>

impl<L, C, M> From<(L, C, M)> for VerifierError where
    L: Into<AnyEntity>,
    C: Into<String>,
    M: Into<String>, 

impl<L, M> From<(L, M)> for VerifierError where
    L: Into<AnyEntity>,
    M: Into<String>, 

impl From<Vec<VerifierError, Global>> for VerifierErrors

impl From<VerifierErrors> for CodegenError

impl From<u16> for EncodingBits

impl From<u8> for OpcodePrefix

impl<T: ReservedValue> From<T> for PackedOption<T>

impl<T: ReservedValue> From<Option<T>> for PackedOption<T>

impl From<WasmType> for Type

impl From<BinaryReaderError> for WasmError

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<H> From<ExportedCuckooFilter> for CuckooFilter<H>

impl<H> From<&'_ CuckooFilter<H>> for ExportedCuckooFilter where
    H: Hasher + Default, 

impl From<u8> for Scalar

impl From<u16> for Scalar

impl From<u32> for Scalar

impl From<u64> for Scalar

impl From<u128> for Scalar

impl<'a> From<&'a EdwardsBasepointTableRadix16> for EdwardsBasepointTableRadix32

impl<'a> From<&'a EdwardsBasepointTableRadix32> for EdwardsBasepointTableRadix16

impl<'a> From<&'a EdwardsBasepointTableRadix16> for EdwardsBasepointTableRadix64

impl<'a> From<&'a EdwardsBasepointTableRadix64> for EdwardsBasepointTableRadix16

impl<'a> From<&'a EdwardsBasepointTableRadix16> for EdwardsBasepointTableRadix128

impl<'a> From<&'a EdwardsBasepointTableRadix128> for EdwardsBasepointTableRadix16

impl<'a> From<&'a EdwardsBasepointTableRadix16> for EdwardsBasepointTableRadix256

impl<'a> From<&'a EdwardsBasepointTableRadix256> for EdwardsBasepointTableRadix16

impl<'a> From<&'a EdwardsBasepointTableRadix32> for EdwardsBasepointTableRadix64

impl<'a> From<&'a EdwardsBasepointTableRadix64> for EdwardsBasepointTableRadix32

impl<'a> From<&'a EdwardsBasepointTableRadix32> for EdwardsBasepointTableRadix128

impl<'a> From<&'a EdwardsBasepointTableRadix128> for EdwardsBasepointTableRadix32

impl<'a> From<&'a EdwardsBasepointTableRadix32> for EdwardsBasepointTableRadix256

impl<'a> From<&'a EdwardsBasepointTableRadix256> for EdwardsBasepointTableRadix32

impl<'a> From<&'a EdwardsBasepointTableRadix64> for EdwardsBasepointTableRadix128

impl<'a> From<&'a EdwardsBasepointTableRadix128> for EdwardsBasepointTableRadix64

impl<'a> From<&'a EdwardsBasepointTableRadix64> for EdwardsBasepointTableRadix256

impl<'a> From<&'a EdwardsBasepointTableRadix256> for EdwardsBasepointTableRadix64

impl<'a> From<&'a EdwardsBasepointTableRadix128> for EdwardsBasepointTableRadix256

impl<'a> From<&'a EdwardsBasepointTableRadix256> for EdwardsBasepointTableRadix128

impl From<u16> for Opcode

impl From<u8> for ResponseCode

impl From<[u8; 64]> for Signature

impl<'a> From<&'a SecretKey> for PublicKey

impl<'a> From<&'a ExpandedSecretKey> for PublicKey

impl<'a> From<&'a SecretKey> for ExpandedSecretKey

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

impl<'a, T> From<T> for Env<'a> where
    T: Into<Cow<'a, str>>, 

impl From<Errno> for Error

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<H, N> From<CommitValidationResult<H, N>> for BadCommit

impl<H, N, S, Id> From<CompactCommit<H, N, S, Id>> for Commit<H, N, S, Id>

impl<H: Clone, N: Clone, S, Id> From<Commit<H, N, S, Id>> for CompactCommit<H, N, S, Id>

impl From<DecompressError> for Error

impl From<CompressError> for Error

impl<E: Error> From<E> for Error<E>

impl From<FrameTransactionPriority> for u64

impl From<(Option<u64>, Pays)> for PostDispatchInfo

impl From<Pays> for PostDispatchInfo

impl From<Option<u64>> for PostDispatchInfo

impl From<()> for PostDispatchInfo

impl<T: Config> From<Error<T>> for &'static str

impl<T: Config> From<Error<T>> for DispatchError

impl<T: Config> From<Event<T>> for ()

impl<AccountId> From<Option<AccountId>> for RawOrigin<AccountId>

impl From<RuntimeVersion> for LastRuntimeUpgradeInfo

impl From<Arc<ClientConfig>> for TlsConnector

impl From<Arc<ServerConfig>> for TlsAcceptor

impl<T> From<TlsStream<T>> for TlsStream<T>

impl<T> From<TlsStream<T>> for TlsStream<T>

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 = ()> + Send + 'a, 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 = ()> + Send + 'a, 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<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> 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<Reason> for Error

impl From<u32> for Reason

impl From<Reason> for u32

impl From<Error> for RenderError

impl From<Error> for RenderError

impl From<FromUtf8Error> for RenderError

impl From<ParseIntError> for RenderError

impl From<TemplateError> for TemplateFileError

impl From<TemplateError> for TemplateRenderError

impl From<RenderError> for TemplateRenderError

impl<'reg: 'rc, 'rc> From<Value> for ScopedJson<'reg, 'rc>

impl<T, S, A> From<HashMap<T, (), S, A>> for HashSet<T, S, A> where
    A: Allocator + Clone, 

impl<'a> From<&'a HeaderName> for HeaderName

impl From<HeaderName> for HeaderValue

impl From<u16> for HeaderValue

impl From<i16> for HeaderValue

impl From<u32> for HeaderValue

impl From<i32> for HeaderValue

impl From<u64> for HeaderValue

impl From<i64> for HeaderValue

impl From<usize> for HeaderValue

impl From<isize> for HeaderValue

impl<'a> From<&'a HeaderValue> for HeaderValue

impl<'a> From<&'a Method> for Method

impl From<StatusCode> for u16

impl<'a> From<&'a StatusCode> for StatusCode

impl<T> From<Port<T>> for u16

impl From<Uri> for Parts

impl From<InvalidStatusCode> for Error

impl From<InvalidMethod> for Error

impl From<InvalidUri> for Error

impl From<InvalidUriParts> for Error

impl From<InvalidHeaderName> for Error

impl From<InvalidHeaderValue> for Error

impl From<Infallible> for Error

impl From<SystemTime> for HttpDate

impl From<HttpDate> for SystemTime

impl From<ParseIntError> for Error

impl From<Error> for Error

impl From<Duration> for Duration

impl From<SystemTime> for Timestamp

impl From<Box<dyn Stream<Item = Result<Bytes, Box<dyn Error + Send + Sync + 'static, Global>>> + Send + 'static, Global>> for Body

impl From<Bytes> for Body

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

impl From<&'static [u8]> for Body

impl From<Cow<'static, [u8]>> for Body

impl From<String> for Body

impl From<&'static str> for Body

impl From<Cow<'static, str>> for Body

impl<H, C> From<(H, C)> for HttpsConnector<H> where
    C: Into<Arc<ClientConfig>>, 

impl<T> From<T> for MaybeHttpsStream<T>

impl<T> From<TlsStream<T>> for MaybeHttpsStream<T>

impl From<Errors> for Result<(), Errors>

impl From<Ipv4Addr> for IpNetwork

impl From<Ipv6Addr> for IpNetwork

impl From<IpAddr> for IpNetwork

impl From<Ipv4Network> for IpNetwork

impl From<Ipv6Network> for IpNetwork

impl From<Ipv4Addr> for Ipv4Network

impl From<Ipv6Addr> for Ipv6Network

impl From<Ipv4AddrRange> for IpAddrRange

impl From<Ipv6AddrRange> for IpAddrRange

impl From<Ipv4Net> for IpNet

impl From<Ipv6Net> for IpNet

impl From<IpAddr> for IpNet

impl From<Ipv4Addr> for Ipv4Net

impl From<Ipv6Addr> for Ipv6Net

impl From<Ipv4Subnets> for IpSubnets

impl From<Ipv6Subnets> for IpSubnets

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<JsValue> for Array

impl From<Array> for JsValue

impl From<Array> for Object

impl From<JsValue> for ArrayBuffer

impl From<ArrayBuffer> for JsValue

impl From<ArrayBuffer> for Object

impl From<JsValue> for SharedArrayBuffer

impl From<SharedArrayBuffer> for JsValue

impl From<SharedArrayBuffer> for Object

impl From<JsValue> for Boolean

impl From<Boolean> for JsValue

impl From<Boolean> for Object

impl From<bool> for Boolean

impl From<Boolean> for bool

impl From<JsValue> for DataView

impl From<DataView> for JsValue

impl From<DataView> for Object

impl From<JsValue> for Error

impl From<Error> for JsValue

impl From<Error> for Object

impl From<JsValue> for EvalError

impl From<EvalError> for JsValue

impl From<EvalError> for Object

impl From<EvalError> for Error

impl From<JsValue> for Function

impl From<Function> for JsValue

impl From<Function> for Object

impl From<JsValue> for Generator

impl From<Generator> for JsValue

impl From<Generator> for Object

impl From<JsValue> for Map

impl From<Map> for JsValue

impl From<Map> for Object

impl From<JsValue> for Iterator

impl From<Iterator> for JsValue

impl From<JsValue> for AsyncIterator

impl From<AsyncIterator> for JsValue

impl From<JsValue> for IteratorNext

impl From<IteratorNext> for JsValue

impl From<IteratorNext> for Object

impl From<JsValue> for Number

impl From<Number> for JsValue

impl From<Number> for Object

impl From<i8> for Number

impl From<u8> for Number

impl From<i16> for Number

impl From<u16> for Number

impl From<i32> for Number

impl From<u32> for Number

impl From<f32> for Number

impl From<f64> for Number

impl From<Number> for f64

impl From<JsValue> for Date

impl From<Date> for JsValue

impl From<Date> for Object

impl From<JsValue> for Object

impl From<Object> for JsValue

impl From<JsValue> for Proxy

impl From<Proxy> for JsValue

impl From<JsValue> for RangeError

impl From<RangeError> for JsValue

impl From<RangeError> for Error

impl From<RangeError> for Object

impl From<JsValue> for ReferenceError

impl From<ReferenceError> for JsValue

impl From<ReferenceError> for Error

impl From<ReferenceError> for Object

impl From<JsValue> for RegExp

impl From<RegExp> for JsValue

impl From<RegExp> for Object

impl From<JsValue> for Set

impl From<Set> for JsValue

impl From<Set> for Object

impl From<JsValue> for SyntaxError

impl From<SyntaxError> for JsValue

impl From<SyntaxError> for Error

impl From<SyntaxError> for Object

impl From<JsValue> for TypeError

impl From<TypeError> for JsValue

impl From<TypeError> for Error

impl From<TypeError> for Object

impl From<JsValue> for UriError

impl From<UriError> for JsValue

impl From<UriError> for Error

impl From<UriError> for Object

impl From<JsValue> for WeakMap

impl From<WeakMap> for JsValue

impl From<WeakMap> for Object

impl From<JsValue> for WeakSet

impl From<WeakSet> for JsValue

impl From<WeakSet> for Object

impl From<JsValue> for CompileError

impl From<CompileError> for JsValue

impl From<CompileError> for Error

impl From<JsValue> for Instance

impl From<Instance> for JsValue

impl From<Instance> for Object

impl From<JsValue> for LinkError

impl From<LinkError> for JsValue

impl From<LinkError> for Error

impl From<JsValue> for RuntimeError

impl From<RuntimeError> for JsValue

impl From<RuntimeError> for Error

impl From<JsValue> for Module

impl From<Module> for JsValue

impl From<Module> for Object

impl From<JsValue> for Table

impl From<Table> for JsValue

impl From<Table> for Object

impl From<JsValue> for Global

impl From<Global> for JsValue

impl From<Global> for Object

impl From<JsValue> for Memory

impl From<Memory> for JsValue

impl From<Memory> for Object

impl From<JsValue> for JsString

impl From<JsString> for JsValue

impl From<JsString> for Object

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

impl From<String> for JsString

impl From<char> for JsString

impl<'a> From<&'a JsString> for String

impl From<JsString> for String

impl From<JsValue> for Symbol

impl From<Symbol> for JsValue

impl From<JsValue> for Collator

impl From<Collator> for JsValue

impl From<Collator> for Object

impl From<JsValue> for DateTimeFormat

impl From<DateTimeFormat> for JsValue

impl From<DateTimeFormat> for Object

impl From<JsValue> for NumberFormat

impl From<NumberFormat> for JsValue

impl From<NumberFormat> for Object

impl From<JsValue> for PluralRules

impl From<PluralRules> for JsValue

impl From<PluralRules> for Object

impl From<JsValue> for Promise

impl From<Promise> for JsValue

impl From<Promise> for Object

impl From<JsValue> for Int8Array

impl From<Int8Array> for JsValue

impl From<Int8Array> for Object

impl<'a> From<&'a [i8]> for Int8Array

impl From<JsValue> for Int16Array

impl From<Int16Array> for JsValue

impl From<Int16Array> for Object

impl<'a> From<&'a [i16]> for Int16Array

impl From<JsValue> for Int32Array

impl From<Int32Array> for JsValue

impl From<Int32Array> for Object

impl<'a> From<&'a [i32]> for Int32Array

impl From<JsValue> for Uint8Array

impl From<Uint8Array> for JsValue

impl From<Uint8Array> for Object

impl<'a> From<&'a [u8]> for Uint8Array

impl From<JsValue> for Uint8ClampedArray

impl From<Uint8ClampedArray> for JsValue

impl From<Uint8ClampedArray> for Object

impl<'a> From<&'a [u8]> for Uint8ClampedArray

impl From<JsValue> for Uint16Array

impl From<Uint16Array> for JsValue

impl From<Uint16Array> for Object

impl<'a> From<&'a [u16]> for Uint16Array

impl From<JsValue> for Uint32Array

impl From<Uint32Array> for JsValue

impl From<Uint32Array> for Object

impl<'a> From<&'a [u32]> for Uint32Array

impl From<JsValue> for Float32Array

impl From<Float32Array> for JsValue

impl From<Float32Array> for Object

impl<'a> From<&'a [f32]> for Float32Array

impl From<JsValue> for Float64Array

impl From<Float64Array> for JsValue

impl From<Float64Array> for Object

impl<'a> From<&'a [f64]> for Float64Array

impl From<ClientResponse> for Result<Value, Error>

impl From<Error> for RpcError

impl From<Sender<RpcMessage>> for RpcChannel

impl From<RpcChannel> for RawClient

impl From<RpcChannel> for TypedClient

impl From<IoHandler<()>> for MetaIoHandler<()>

impl From<i64> for ErrorCode

impl From<Params> for Value

impl From<MethodCall> for Call

impl From<Notification> for Call

impl From<Output> for CoreResult<Value>

impl From<Failure> for Response

impl From<Success> for Response

impl From<Response> for Response<Body>

impl From<Response> for RequestMiddlewareAction

impl From<Response<Body>> for RequestMiddlewareAction

impl From<Request<Body>> for RequestMiddlewareAction

impl From<String> for SubscriptionId

impl From<SubscriptionId> for Value

impl From<u8> for SubscriptionId

impl From<u16> for SubscriptionId

impl From<u32> for SubscriptionId

impl From<u64> for SubscriptionId

impl<T: AsRef<str>> From<T> for Origin

impl<T: Into<String>> From<T> for AccessControlAllowOrigin

impl From<Option<u16>> for Port

impl From<u16> for Port

impl<T: AsRef<str>> From<T> for Host

impl<T> From<Option<Vec<T, Global>>> for DomainsValidation<T>

impl From<Error> for Error

impl From<Error> for Error

impl From<Option<Response>> for MiddlewareAction

impl From<Error> for Error

impl From<PublicKey> for PeerId

impl From<PeerId> for Multihash

impl From<PeerId> for Vec<u8>

impl From<&'_ ConnectedPoint> for Endpoint

impl From<ConnectedPoint> for Endpoint

impl From<Keypair> for SecretKey

impl From<SecretKey> for Keypair

impl From<SecretKey> for Keypair

impl From<Keypair> for SecretKey

impl<T> From<T> for OptionalTransport<T>

impl<E> From<NegotiationError> for UpgradeError<E>

impl From<Error> for ReadOneError

impl From<ReadOneError> for FloodsubDecodeError

impl From<DecodeError> for FloodsubDecodeError

impl From<Topic> for String

impl From<SigningError> for PublishError

impl From<Error> for GossipsubHandlerError

impl From<Error> for PublishError

impl From<GossipsubConfig> for GossipsubConfigBuilder

impl<H: Hasher> From<Topic<H>> for TopicHash

impl<T: Into<Vec<u8>>> From<T> for MessageId

impl<T: Into<Vec<u8>>> From<T> for FastMessageId

impl From<ProtocolsHandlerUpgrErr<Error>> for KademliaHandlerQueryErr

impl From<Multihash<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>>> for Key<Multihash>

impl From<PeerId> for Key<PeerId>

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

impl From<Key> for Key<Key>

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

impl From<Multihash<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>>> for Key

impl From<EntryView<Key<PeerId>, Addresses>> for KadPeer

impl From<Error> for NoiseError

impl From<Error> for NoiseError

impl From<DecodeError> for NoiseError

impl From<SigningError> for NoiseError

impl From<SecretKey<X25519>> for Keypair<X25519>

impl From<SecretKey<X25519Spec>> for Keypair<X25519Spec>

impl From<Error> for PnetError

impl<TErr> From<TErr> for NodeHandlerWrapperError<TErr>

impl<TBehaviour> From<Option<TBehaviour>> for Toggle<TBehaviour>

impl From<JsValue> for Transport

impl From<Transport> for JsValue

impl From<JsValue> for Connection

impl From<Connection> for JsValue

impl From<JsValue> for ListenEvent

impl From<ListenEvent> for JsValue

impl From<JsValue> for ConnectionEvent

impl From<ConnectionEvent> for JsValue

impl From<JsValue> for JsErr

impl From<Error> for JsErr

impl From<JsErr> for Error

impl<E> From<Error> for Error<E>

impl From<Error> for Error

impl<T> From<WsConfig<T>> for WsConfig<T>

impl From<ConnectionError> for YamuxError

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

impl From<Error> for Error

impl<'k> From<&'k str> for Key<'k>

impl<'v> From<&'v str> for Value<'v>

impl<'v> From<usize> for Value<'v>

impl<'v> From<u8> for Value<'v>

impl<'v> From<u16> for Value<'v>

impl<'v> From<u32> for Value<'v>

impl<'v> From<u64> for Value<'v>

impl<'v> From<u128> for Value<'v>

impl<'v> From<isize> for Value<'v>

impl<'v> From<i8> for Value<'v>

impl<'v> From<i16> for Value<'v>

impl<'v> From<i32> for Value<'v>

impl<'v> From<i64> for Value<'v>

impl<'v> From<i128> for Value<'v>

impl<'v> From<f32> for Value<'v>

impl<'v> From<f64> for Value<'v>

impl<'v> From<char> for Value<'v>

impl<'v> From<bool> for Value<'v>

impl From<Words> for Bytes

impl From<Pages> for Bytes

impl From<Words> for Bytes

impl From<Pages> for Bytes

impl<'a> From<&'a [u8]> for &'a ByteSlice

impl<'a> From<&'a mut [u8]> for &'a mut ByteSlice

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

impl From<Utf8Error> for Error

impl From<MZFlush> for TDEFLFlush

impl From<StreamResult> for MZResult

impl From<&'_ StreamResult> for MZResult

impl From<Ready> for UnixReady

impl From<UnixReady> for Ready

impl From<usize> for Token

impl From<Token> for usize

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

impl<T> From<Error> for SendError<T>

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

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

impl<T> From<Error> for TrySendError<T>

impl From<DecodeError> for Error

impl From<DecodeError> for Error

impl From<Error> for Error

impl<const S: usize> From<Multihash<S>> for Vec<u8>

impl From<ProtocolError> for NegotiationError

impl From<Error> for NegotiationError

impl From<NegotiationError> for Error

impl From<Error> for ProtocolError

impl From<Error> for ProtocolError

impl<T: Scalar, const D: usize> From<[T; D]> for SVector<T, D>

impl<T: Scalar, const D: usize> From<[T; D]> for RowSVector<T, D> where
    Const<D>: IsNotStaticOne, 

impl<T: Scalar, const R: usize, const C: usize> From<[[T; R]; C]> for SMatrix<T, R, C>

impl<'a, T, RStride, CStride, const R: usize, const C: usize> From<Matrix<T, Const<R>, Const<C>, SliceStorage<'a, T, Const<R>, Const<C>, RStride, CStride>>> for Matrix<T, Const<R>, Const<C>, ArrayStorage<T, R, C>> where
    T: Scalar,
    RStride: Dim,
    CStride: Dim, 

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

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

impl<'a, T, RStride, CStride, const R: usize, const C: usize> From<Matrix<T, Const<R>, Const<C>, SliceStorageMut<'a, T, Const<R>, Const<C>, RStride, CStride>>> for Matrix<T, Const<R>, Const<C>, ArrayStorage<T, R, C>> where
    T: Scalar,
    RStride: Dim,
    CStride: Dim, 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<T: Scalar + Zero + One, const D: usize> From<Point<T, D>> for OVector<T, DimNameSum<Const<D>, U1>> where
    Const<D>: DimNameAdd<U1>,
    DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>>, 

impl<T: Scalar, const D: usize> From<[T; D]> for Point<T, D>

impl<T: Scalar, const D: usize> From<Matrix<T, Const<D>, Const<1_usize>, <DefaultAllocator as Allocator<T, Const<D>, Const<1_usize>>>::Buffer>> for Point<T, D>

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

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

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

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

impl<T: RealField> From<Rotation<T, 2_usize>> for Matrix3<T>

impl<T: RealField> From<Rotation<T, 2_usize>> for Matrix2<T>

impl<T: RealField> From<Rotation<T, 3_usize>> for Matrix4<T>

impl<T: RealField> From<Rotation<T, 3_usize>> for Matrix3<T>

impl<T: Scalar + PrimitiveSimdValue, const D: usize> From<[Rotation<<T as SimdValue>::Element, D>; 2]> for Rotation<T, D> where
    T: From<[<T as SimdValue>::Element; 2]>,
    T::Element: Scalar + Copy, 

impl<T: Scalar + PrimitiveSimdValue, const D: usize> From<[Rotation<<T as SimdValue>::Element, D>; 4]> for Rotation<T, D> where
    T: From<[<T as SimdValue>::Element; 4]>,
    T::Element: Scalar + Copy, 

impl<T: Scalar + PrimitiveSimdValue, const D: usize> From<[Rotation<<T as SimdValue>::Element, D>; 8]> for Rotation<T, D> where
    T: From<[<T as SimdValue>::Element; 8]>,
    T::Element: Scalar + Copy, 

impl<T: Scalar + PrimitiveSimdValue, const D: usize> From<[Rotation<<T as SimdValue>::Element, D>; 16]> for Rotation<T, D> where
    T: From<[<T as SimdValue>::Element; 16]>,
    T::Element: Scalar + Copy, 

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

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

impl<T: SimdRealField> From<Rotation<T, 3_usize>> for UnitQuaternion<T> where
    T::Element: SimdRealField, 

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

impl<T: Scalar> From<Matrix<T, Const<{ typenum::$D::USIZE }>, Const<1_usize>, ArrayStorage<T, 4_usize, 1_usize>>> for Quaternion<T>

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

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

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

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

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

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

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

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

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

impl<T: SimdRealField + RealField> From<Unit<DualQuaternion<T>>> for Matrix4<T> where
    T::Element: SimdRealField, 

impl<T: SimdRealField> From<Unit<DualQuaternion<T>>> for Isometry3<T> where
    T::Element: SimdRealField, 

impl<T: SimdRealField> From<Isometry<T, Unit<Quaternion<T>>, 3_usize>> for UnitDualQuaternion<T> where
    T::Element: SimdRealField, 

impl<T: SimdRealField> From<Unit<Complex<T>>> for Rotation2<T> where
    T::Element: SimdRealField, 

impl<T: SimdRealField> From<Rotation<T, 2_usize>> for UnitComplex<T> where
    T::Element: SimdRealField, 

impl<T: SimdRealField> From<Unit<Complex<T>>> for Matrix3<T> where
    T::Element: SimdRealField, 

impl<T: SimdRealField> From<Unit<Complex<T>>> for Matrix2<T> where
    T::Element: SimdRealField, 

impl<T: Scalar + Copy + PrimitiveSimdValue> From<[Unit<Complex<<T as SimdValue>::Element>>; 2]> for UnitComplex<T> where
    T: From<[<T as SimdValue>::Element; 2]>,
    T::Element: Scalar + Copy, 

impl<T: Scalar + Copy + PrimitiveSimdValue> From<[Unit<Complex<<T as SimdValue>::Element>>; 4]> for UnitComplex<T> where
    T: From<[<T as SimdValue>::Element; 4]>,
    T::Element: Scalar + Copy, 

impl<T: Scalar + Copy + PrimitiveSimdValue> From<[Unit<Complex<<T as SimdValue>::Element>>; 8]> for UnitComplex<T> where
    T: From<[<T as SimdValue>::Element; 8]>,
    T::Element: Scalar + Copy, 

impl<T: Scalar + Copy + PrimitiveSimdValue> From<[Unit<Complex<<T as SimdValue>::Element>>; 16]> for UnitComplex<T> where
    T: From<[<T as SimdValue>::Element; 16]>,
    T::Element: Scalar + Copy, 

impl<T: Scalar + Zero + One, const D: usize> From<Translation<T, D>> for OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> where
    Const<D>: DimNameAdd<U1>,
    DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> + Allocator<T, Const<D>>, 

impl<T: Scalar, const D: usize> From<Matrix<T, Const<D>, Const<1_usize>, <DefaultAllocator as Allocator<T, Const<D>, Const<1_usize>>>::Buffer>> for Translation<T, D>

impl<T: Scalar, const D: usize> From<[T; D]> for Translation<T, D>

impl<T: Scalar, const D: usize> From<Point<T, D>> for Translation<T, D>

impl<T: Scalar + PrimitiveSimdValue, const D: usize> From<[Translation<<T as SimdValue>::Element, D>; 2]> for Translation<T, D> where
    T: From<[<T as SimdValue>::Element; 2]>,
    T::Element: Scalar, 

impl<T: Scalar + PrimitiveSimdValue, const D: usize> From<[Translation<<T as SimdValue>::Element, D>; 4]> for Translation<T, D> where
    T: From<[<T as SimdValue>::Element; 4]>,
    T::Element: Scalar, 

impl<T: Scalar + PrimitiveSimdValue, const D: usize> From<[Translation<<T as SimdValue>::Element, D>; 8]> for Translation<T, D> where
    T: From<[<T as SimdValue>::Element; 8]>,
    T::Element: Scalar, 

impl<T: Scalar + PrimitiveSimdValue, const D: usize> From<[Translation<<T as SimdValue>::Element, D>; 16]> for Translation<T, D> where
    T: From<[<T as SimdValue>::Element; 16]>,
    T::Element: Scalar, 

impl<T: SimdRealField, R: AbstractRotation<T, D>, const D: usize> From<Translation<T, D>> for Isometry<T, R, D>

impl<T: SimdRealField, R, const D: usize> From<Isometry<T, R, D>> for OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> where
    Const<D>: DimNameAdd<U1>,
    R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>,
    DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>, 

impl<T: SimdRealField, R, const D: usize> From<[T; D]> for Isometry<T, R, D> where
    R: AbstractRotation<T, D>, 

impl<T: SimdRealField, R, const D: usize> From<Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>> for Isometry<T, R, D> where
    R: AbstractRotation<T, D>, 

impl<T: SimdRealField, R, const D: usize> From<Point<T, D>> for Isometry<T, R, D> where
    R: AbstractRotation<T, D>, 

impl<T: Scalar + PrimitiveSimdValue, R, const D: usize> From<[Isometry<<T as SimdValue>::Element, <R as SimdValue>::Element, D>; 2]> for Isometry<T, R, D> where
    T: From<[<T as SimdValue>::Element; 2]>,
    R: SimdValue + AbstractRotation<T, D> + From<[<R as SimdValue>::Element; 2]>,
    R::Element: AbstractRotation<T::Element, D>,
    T::Element: Scalar + Copy,
    R::Element: Scalar + Copy, 

impl<T: Scalar + PrimitiveSimdValue, R, const D: usize> From<[Isometry<<T as SimdValue>::Element, <R as SimdValue>::Element, D>; 4]> for Isometry<T, R, D> where
    T: From<[<T as SimdValue>::Element; 4]>,
    R: SimdValue + AbstractRotation<T, D> + From<[<R as SimdValue>::Element; 4]>,
    R::Element: AbstractRotation<T::Element, D>,
    T::Element: Scalar + Copy,
    R::Element: Scalar + Copy, 

impl<T: Scalar + PrimitiveSimdValue, R, const D: usize> From<[Isometry<<T as SimdValue>::Element, <R as SimdValue>::Element, D>; 8]> for Isometry<T, R, D> where
    T: From<[<T as SimdValue>::Element; 8]>,
    R: SimdValue + AbstractRotation<T, D> + From<[<R as SimdValue>::Element; 8]>,
    R::Element: AbstractRotation<T::Element, D>,
    T::Element: Scalar + Copy,
    R::Element: Scalar + Copy, 

impl<T: Scalar + PrimitiveSimdValue, R, const D: usize> From<[Isometry<<T as SimdValue>::Element, <R as SimdValue>::Element, D>; 16]> for Isometry<T, R, D> where
    T: From<[<T as SimdValue>::Element; 16]>,
    R: SimdValue + AbstractRotation<T, D> + From<[<R as SimdValue>::Element; 16]>,
    R::Element: AbstractRotation<T::Element, D>,
    T::Element: Scalar + Copy,
    R::Element: Scalar + Copy, 

impl<T: SimdRealField, R, const D: usize> From<Similarity<T, R, D>> for OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> where
    Const<D>: DimNameAdd<U1>,
    R: SubsetOf<OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>,
    DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>, 

impl<T: Scalar + Zero + PrimitiveSimdValue, R, const D: usize> From<[Similarity<<T as SimdValue>::Element, <R as SimdValue>::Element, D>; 2]> for Similarity<T, R, D> where
    T: From<[<T as SimdValue>::Element; 2]>,
    R: SimdValue + AbstractRotation<T, D> + From<[<R as SimdValue>::Element; 2]>,
    R::Element: AbstractRotation<T::Element, D>,
    T::Element: Scalar + Zero + Copy,
    R::Element: Scalar + Zero + Copy, 

impl<T: Scalar + Zero + PrimitiveSimdValue, R, const D: usize> From<[Similarity<<T as SimdValue>::Element, <R as SimdValue>::Element, D>; 4]> for Similarity<T, R, D> where
    T: From<[<T as SimdValue>::Element; 4]>,
    R: SimdValue + AbstractRotation<T, D> + From<[<R as SimdValue>::Element; 4]>,
    R::Element: AbstractRotation<T::Element, D>,
    T::Element: Scalar + Zero + Copy,
    R::Element: Scalar + Zero + Copy, 

impl<T: Scalar + Zero + PrimitiveSimdValue, R, const D: usize> From<[Similarity<<T as SimdValue>::Element, <R as SimdValue>::Element, D>; 8]> for Similarity<T, R, D> where
    T: From<[<T as SimdValue>::Element; 8]>,
    R: SimdValue + AbstractRotation<T, D> + From<[<R as SimdValue>::Element; 8]>,
    R::Element: AbstractRotation<T::Element, D>,
    T::Element: Scalar + Zero + Copy,
    R::Element: Scalar + Zero + Copy, 

impl<T: Scalar + Zero + PrimitiveSimdValue, R, const D: usize> From<[Similarity<<T as SimdValue>::Element, <R as SimdValue>::Element, D>; 16]> for Similarity<T, R, D> where
    T: From<[<T as SimdValue>::Element; 16]>,
    R: SimdValue + AbstractRotation<T, D> + From<[<R as SimdValue>::Element; 16]>,
    R::Element: AbstractRotation<T::Element, D>,
    T::Element: Scalar + Zero + Copy,
    R::Element: Scalar + Zero + Copy, 

impl<T: RealField, C, const D: usize> From<Transform<T, C, D>> for OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> where
    Const<D>: DimNameAdd<U1>,
    C: TCategory,
    DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>, 

impl<T: RealField> From<Orthographic3<T>> for Matrix4<T>

impl<T: RealField> From<Perspective3<T>> for Matrix4<T>

impl From<i64> for BigInt

impl From<i128> for BigInt

impl From<i8> for BigInt

impl From<i16> for BigInt

impl From<i32> for BigInt

impl From<isize> for BigInt

impl From<u64> for BigInt

impl From<u128> for BigInt

impl From<u8> for BigInt

impl From<u16> for BigInt

impl From<u32> for BigInt

impl From<usize> for BigInt

impl From<BigUint> for BigInt

impl From<u64> for BigUint

impl From<u128> for BigUint

impl From<u8> for BigUint

impl From<u16> for BigUint

impl From<u32> for BigUint

impl From<usize> for BigUint

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<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<T: Config> From<Error<T>> for &'static str

impl<T: Config> From<Error<T>> for DispatchError

impl<T: Config> From<Event<T>> for ()

impl<O, T: ?Sized> From<O> for OwningRef<O, T> where
    O: StableAddress,
    O: Deref<Target = T>, 

impl<O, T: ?Sized> From<O> for OwningRefMut<O, T> where
    O: StableAddress,
    O: DerefMut<Target = T>, 

impl<O, T: ?Sized> From<OwningRefMut<O, T>> for OwningRef<O, T> where
    O: StableAddress,
    O: DerefMut<Target = T>, 

impl<T: Config> From<Error<T>> for &'static str

impl<T: Config> From<Error<T>> for DispatchError

impl<T: Config<I>, I: 'static> From<Error<T, I>> for &'static str

impl<T: Config<I>, I: 'static> From<Error<T, I>> for DispatchError

impl<T: Config<I>, I: 'static> From<Event<T, I>> for ()

impl From<WithdrawReasons> for Reasons

impl From<Event> for ()

impl<T: Config> From<Error<T>> for &'static str

impl<T: Config> From<Error<T>> for DispatchError

impl From<Event> for ()

impl<T: Config> From<Error<T>> for &'static str

impl<T: Config> From<Error<T>> for DispatchError

impl<AccountId> From<RawEvent<AccountId>> for ()

impl<T: Config> From<Error<T>> for &'static str

impl<T: Config> From<Error<T>> for DispatchError

impl<BlockHash, ResponseType> From<RpcChannel> for Client<BlockHash, ResponseType> where
    BlockHash: Send + Sync + 'static + Serialize,
    ResponseType: Send + Sync + 'static + DeserializeOwned, 

impl From<Error> for i64

impl From<Event> for ()

impl From<Error> for Error

impl<'a> From<IpAddr> for Protocol<'a>

impl<'a> From<Ipv4Addr> for Protocol<'a>

impl<'a> From<Ipv6Addr> for Protocol<'a>

impl From<([u8; 35], u16)> for Onion3Addr<'_>

impl<'a> From<(&'a [u8; 35], u16)> for Onion3Addr<'a>

impl From<Error> for Error

impl From<Error> for Error

impl From<Error> for Error

impl From<AddrParseError> for Error

impl From<ParseIntError> for Error

impl From<FromUtf8Error> for Error

impl From<Utf8Error> for Error

impl From<Error> for Error

impl<'a> From<Protocol<'a>> for Multiaddr

impl From<IpAddr> for Multiaddr

impl From<Ipv4Addr> for Multiaddr

impl From<Ipv6Addr> for Multiaddr

impl From<Error> for Error

impl<T> From<T> for Compact<T>

impl<'a, T: Copy> From<&'a T> for Compact<T>

impl From<Compact<()>> for ()

impl From<Compact<u8>> for u8

impl From<Compact<u16>> for u16

impl From<Compact<u32>> for u32

impl From<Compact<u64>> for u64

impl From<Compact<u128>> for u128

impl<'a, T: EncodeLike<U>, U: Encode> From<&'a T> for Ref<'a, T, U>

impl From<&'static str> for Error

impl From<VarUint32> for usize

impl From<VarUint32> for u32

impl From<u32> for VarUint32

impl From<usize> for VarUint32

impl From<VarUint64> for u64

impl From<u64> for VarUint64

impl From<VarUint7> for u8

impl From<u8> for VarUint7

impl From<VarInt7> for i8

impl From<i8> for VarInt7

impl From<Uint8> for u8

impl From<u8> for Uint8

impl From<VarInt32> for i32

impl From<i32> for VarInt32

impl From<VarInt64> for i64

impl From<i64> for VarInt64

impl From<Uint32> for u32

impl From<u32> for Uint32

impl From<u64> for Uint64

impl From<Uint64> for u64

impl From<VarUint1> for bool

impl From<bool> for VarUint1

impl From<(Vec<(usize, Error), Global>, Module)> for Error

impl From<Unparsed> for Vec<u8>

impl From<String> for Message

impl<'s> From<&'s str> for Message

impl<'b> From<&'b [u8]> for Message

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

impl From<u8> for OpCode

impl From<u16> for CloseCode

impl From<Error> for Error

impl From<Error> for Error

impl From<SendError<Command>> for Error

impl From<Utf8Error> for Error

impl<B> From<Box<B, Global>> for Error where
    B: StdError + Send + Sync + 'static, 

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

impl<'a> From<PercentDecode<'a>> for Cow<'a, [u8]>

impl<'a> From<&'a U128> for U128

impl From<U128> for [u8; 16]

impl From<[u8; 16]> for U128

impl<'a> From<&'a [u8; 16]> for U128

impl From<u64> for U128

impl From<u8> for U128

impl From<u16> for U128

impl From<u32> for U128

impl From<usize> for U128

impl From<i64> for U128

impl From<i8> for U128

impl From<i16> for U128

impl From<i32> for U128

impl From<isize> for U128

impl<'a> From<&'a [u8]> for U128

impl From<&'static str> for U128

impl From<u128> for U128

impl From<i128> for U128

impl<'a> From<&'a U256> for U256

impl From<U256> for [u8; 32]

impl From<[u8; 32]> for U256

impl<'a> From<&'a [u8; 32]> for U256

impl From<u64> for U256

impl From<u8> for U256

impl From<u16> for U256

impl From<u32> for U256

impl From<usize> for U256

impl From<i64> for U256

impl From<i8> for U256

impl From<i16> for U256

impl From<i32> for U256

impl From<isize> for U256

impl<'a> From<&'a [u8]> for U256

impl From<&'static str> for U256

impl From<u128> for U256

impl From<i128> for U256

impl<'a> From<&'a U512> for U512

impl From<U512> for [u8; 64]

impl From<[u8; 64]> for U512

impl<'a> From<&'a [u8; 64]> for U512

impl From<u64> for U512

impl From<u8> for U512

impl From<u16> for U512

impl From<u32> for U512

impl From<usize> for U512

impl From<i64> for U512

impl From<i8> for U512

impl From<i16> for U512

impl From<i32> for U512

impl From<isize> for U512

impl<'a> From<&'a [u8]> for U512

impl From<&'static str> for U512

impl From<u128> for U512

impl From<i128> for U512

impl From<[u8; 16]> for H128

impl<'a> From<&'a [u8; 16]> for H128

impl<'a> From<&'a mut [u8; 16]> for H128

impl From<H128> for [u8; 16]

impl From<[u8; 20]> for H160

impl<'a> From<&'a [u8; 20]> for H160

impl<'a> From<&'a mut [u8; 20]> for H160

impl From<H160> for [u8; 20]

impl From<[u8; 32]> for H256

impl<'a> From<&'a [u8; 32]> for H256

impl<'a> From<&'a mut [u8; 32]> for H256

impl From<H256> for [u8; 32]

impl From<[u8; 64]> for H512

impl<'a> From<&'a [u8; 64]> for H512

impl<'a> From<&'a mut [u8; 64]> for H512

impl From<H512> for [u8; 64]

impl From<H160> for H256

impl From<H256> for H160

impl From<U256> for U512

impl From<U128> for U512

impl From<U128> for U256

impl<'a> From<&'a U256> for U512

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 From<Error> for Diagnostic

impl From<Error> for Error

impl From<Opts> for HistogramOpts

impl From<DecodeError> for Error

impl From<EncodeError> for Error

impl From<Error> for Error

impl From<Error> for Error

impl<T> From<Entry<T>> for EntryRef<T>

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 From<Okm<'_, &'static Algorithm>> for UnboundKey

impl From<Okm<'_, &'static Algorithm>> for HeaderProtectionKey

impl From<EndOfInput> for Unspecified

impl From<TryFromSliceError> for Unspecified

impl From<KeyRejected> for Unspecified

impl From<Okm<'_, Algorithm>> for Salt

impl From<Okm<'_, Algorithm>> for Prk

impl From<Okm<'_, Algorithm>> for Key

impl From<Error> for String

impl From<TrustAnchor<'_>> for OwnedTrustAnchor

impl From<Okm<'_, PayloadU8Len>> for PayloadU8

impl From<Error> for Error

impl From<Error> for Error

impl From<Error> for Error

impl From<Error> for Error

impl From<Error> for Error

impl From<Error> for Error

impl From<FromHexError> for Error

impl From<Box<dyn Error + Send + Sync + 'static, Global>> for Error

impl From<Error> for Error

impl From<&'_ str> for Error

impl From<String> for Error

impl From<PublicError> for Error

impl<B: BlockT> From<FinalityNotification<B>> for ChainEvent<B>

impl<B: BlockT> From<Error<B>> for String

impl<'a, E: Epoch> From<&'a E> for EpochHeader<E>

impl<'a, E: Epoch> From<&'a PersistedEpoch<E>> for PersistedEpochHeader<E>

impl From<Error> for Error

impl From<Trap> for Error

impl From<Error> for Error

impl From<Error> for Error

impl From<WasmError> for Error

impl From<&'static str> for Error

impl From<String> for Error

impl From<SupervisorFuncIndex> for usize

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

impl<H, N> From<AuthoritySet<H, N>> for SharedAuthoritySet<H, N>

impl From<Error> for FinalityProofError

impl From<Error> for Error

impl From<Error> for Error

impl From<KeyTypeId> for Error

impl From<String> for Error

impl From<Error> for Error

impl From<Error> for Error

impl From<Error> for TraitError

impl From<()> for HandlerEvent

impl From<Error> for BitswapError

impl From<DecodeError> for BitswapError

impl From<EncodeError> for BitswapError

impl From<Error> for BitswapError

impl From<ReadOneError> for BitswapError

impl From<()> for BitswapError

impl From<()> for SendRequestError

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

impl From<MultiaddrWithPeerId> for String

impl From<Error> for ParseErr

impl From<Error> for Error

impl From<(Multiaddr, PeerId, PeerId)> for Error

impl From<Error> for Error

impl From<Cow<'static, str>> for Error

impl From<(TransportConfig, Vec<Multiaddr, Global>)> for Error

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

impl From<ConnectedPoint> for PeerEndpoint

impl From<usize> for SetId

impl From<SetId> for usize

impl From<u64> for IncomingIndex

impl From<Sender<String>> for Metadata

impl From<Error> for Error

impl From<Error> for Error

impl From<Error> for Error

impl<Hash, BlockHash> From<RpcChannel> for Client<Hash, BlockHash> where
    Hash: Send + Sync + 'static + DeserializeOwned + Serialize,
    BlockHash: Send + Sync + 'static + DeserializeOwned, 

impl From<Box<dyn Error + Send + 'static, Global>> for Error

impl From<String> for Error

impl From<Error> for Error

impl<Number, Hash, Header, SignedBlock> From<RpcChannel> for Client<Number, Hash, Header, SignedBlock> where
    Number: Send + Sync + 'static,
    Hash: Send + Sync + 'static + DeserializeOwned + Serialize,
    Header: Send + Sync + 'static + DeserializeOwned,
    SignedBlock: Send + Sync + 'static + DeserializeOwned, 

impl From<()> for Error

impl From<Error> for Error

impl From<RpcChannel> for Client

impl From<(String, String, String)> for Error

impl From<Box<dyn Error + Send + 'static, Global>> for Error

impl From<(u32, u32)> for Error

impl From<Error> for Error

impl<Hash> From<RpcChannel> for Client<Hash> where
    Hash: Send + Sync + 'static + DeserializeOwned + Serialize, 

impl<Hash> From<RpcChannel> for Client<Hash> where
    Hash: Send + Sync + 'static + DeserializeOwned + Serialize, 

impl From<String> for Error

impl From<Health> for Error

impl From<Error> for Error

impl<Hash, Number> From<RpcChannel> for Client<Hash, Number> where
    Hash: Send + Sync + 'static + DeserializeOwned,
    Number: Send + Sync + 'static + DeserializeOwned, 

impl From<PathBuf> for BasePath

impl<F, FUT> From<F> for TaskExecutor where
    F: Fn(Pin<Box<dyn Future<Output = ()> + Send>>, TaskType) -> FUT + Send + Sync + 'static,
    FUT: Future<Output = ()> + Send + 'static, 

impl From<Error> for Error

impl From<Error> for Error

impl From<Error> for Error

impl From<Error> for Error

impl From<Error> for Error

impl From<Error> for Error

impl From<Box<dyn Error + Send + Sync + 'static, Global>> for Error

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

impl<'a> From<String> for Error

impl<R> From<R> for NoopRpcExtensionBuilder<R> where
    R: RpcExtension<Metadata>, 

impl<E: Debug> From<Error> for Error<E>

impl From<Error> for Error

impl From<SetGlobalDefaultError> for Error

impl From<ParseError> for Error

impl From<SetLoggerError> for Error

impl From<bool> for IsValidator

impl From<Box<dyn Fn() + Send + Sync + 'static, Global>> for IsValidator

impl From<Error> for Error

impl From<Error> for Error

impl From<SecretKey> for PublicKey

impl From<SecretKey> for Keypair

impl<H> From<H> for XoFTranscript<H> where
    H: Input + ExtendableOutput + Clone, 

impl From<ECQVCertSecret> for ECQVCertPublic

impl From<Error> for Error

impl From<bool> for Endian

impl From<Uleb128> for u64

impl From<Sleb128> for i64

impl From<AffineStorage> for Affine

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<Box<dyn Error + Send + Sync + 'static, Global>> for Error

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

impl From<InitStage> for Error

impl From<Prerequisite> for Error

impl From<StateProblem> for Error

impl From<SocketAddr> for SockAddr

impl From<SocketAddrV4> for SockAddr

impl From<SocketAddrV6> for SockAddr

impl From<TcpStream> for Socket

impl From<TcpListener> for Socket

impl From<UdpSocket> for Socket

impl From<Socket> for TcpStream

impl From<Socket> for TcpListener

impl From<Socket> for UdpSocket

impl<'s, S> From<&'s S> for SockRef<'s> where
    S: AsRawFd, 

impl From<UnixStream> for Socket

impl From<UnixListener> for Socket

impl From<UnixDatagram> for Socket

impl From<Socket> for UnixStream

impl From<Socket> for UnixListener

impl From<Socket> for UnixDatagram

impl From<i32> for Domain

impl From<Domain> for c_int

impl From<i32> for Type

impl From<Type> for c_int

impl From<i32> for Protocol

impl From<Protocol> for c_int

impl From<OpCode> for u8

impl From<Error> for Error

impl From<UnknownOpCode> for Error

impl From<Error> for Error

impl From<Utf8Error> for Error

impl From<Error> for Error

impl From<Utf8Error> for Error

impl From<Error> for Error

impl From<(&'static str, Error)> for ApiError

impl<'a, T> From<T> for ApiRef<'a, T>

impl From<OldRuntimeVersion> for RuntimeVersion

impl From<RuntimeVersion> for OldRuntimeVersion

impl From<Public> for Public

impl From<Public> for Public

impl From<Public> for CryptoTypePublicPair

impl From<&'_ Public> for CryptoTypePublicPair

impl From<Signature> for Signature

impl From<Signature> for Signature

impl From<Pair> for Pair

impl From<Pair> for Pair

impl From<Public> for Public

impl From<Public> for Public

impl From<Public> for CryptoTypePublicPair

impl From<&'_ Public> for CryptoTypePublicPair

impl From<Signature> for Signature

impl From<Signature> for Signature

impl From<Pair> for Pair

impl From<Pair> for Pair

impl From<Public> for Public

impl From<Public> for Public

impl From<Public> for CryptoTypePublicPair

impl From<&'_ Public> for CryptoTypePublicPair

impl From<Signature> for Signature

impl From<Signature> for Signature

impl From<Pair> for Pair

impl From<Pair> for Pair

impl From<u8> for BigUint

impl From<u16> for BigUint

impl From<u32> for BigUint

impl From<u64> for BigUint

impl From<u128> for BigUint

impl From<Compact<Percent>> for Percent

impl From<Compact<PerU16>> for PerU16

impl From<Compact<Permill>> for Permill

impl From<Compact<Perbill>> for Perbill

impl From<Compact<Perquintill>> for Perquintill

impl From<Compact<FixedI64>> for FixedI64

impl From<i64> for FixedI64

impl<N: FixedPointOperand, D: FixedPointOperand> From<(N, D)> for FixedI64

impl<P: PerThing> From<P> for FixedI64 where
    P::Inner: FixedPointOperand, 

impl From<Compact<FixedI128>> for FixedI128

impl From<i128> for FixedI128

impl<N: FixedPointOperand, D: FixedPointOperand> From<(N, D)> for FixedI128

impl<P: PerThing> From<P> for FixedI128 where
    P::Inner: FixedPointOperand, 

impl From<Compact<FixedU128>> for FixedU128

impl From<u128> for FixedU128

impl<N: FixedPointOperand, D: FixedPointOperand> From<(N, D)> for FixedU128

impl<P: PerThing> From<P> for FixedU128 where
    P::Inner: FixedPointOperand, 

impl From<Rational128> for RationalInfinite

impl<T: Into<u128>> From<T> for Rational128

impl<Block: BlockT> From<&'_ <Block as Block>::Header> for CachedHeaderMetadata<Block>

impl From<TransactionValidityError> for ApplyExtrinsicFailed

impl From<Canceled> for Error

impl From<Error> for Error

impl From<ApplyExtrinsicFailed> for Error

impl From<ApiError> for Error

impl From<DatabaseError> for Error

impl From<Box<dyn Error + Send + Sync + 'static, Global>> for Error

impl From<Box<dyn Error + Send + Sync + 'static, Global>> for Error

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

impl From<Error> for Error

impl From<Error> for Error

impl From<Box<dyn Error + Send + Sync + 'static, Global>> for Error

impl From<Public> for Error

impl From<String> for Error

impl From<Error> for Error

impl From<bool> for RecordProof

impl From<NextConfigDescriptor> for BabeEpochConfiguration

impl From<BabeGenesisConfigurationV1> for BabeGenesisConfiguration

impl From<u64> for Slot

impl From<Slot> for u64

impl<T: AsRef<str>> From<T> for DeriveJunction

impl From<Ss58AddressFormat> for u16

impl From<Ss58AddressFormat> for String

impl From<[u8; 32]> for AccountId32

impl From<AccountId32> for [u8; 32]

impl From<Public> for AccountId32

impl From<Public> for AccountId32

impl From<u32> for KeyTypeId

impl From<KeyTypeId> for u32

impl From<Public> for [u8; 32]

impl From<Pair> for Public

impl From<Public> for H256

impl From<Signature> for H512

impl From<Signature> for [u8; 64]

impl From<Public> for CryptoTypePublicPair

impl From<&'_ Public> for CryptoTypePublicPair

impl From<Public> for [u8; 32]

impl From<Public> for H256

impl From<Signature> for [u8; 64]

impl From<Signature> for H512

impl From<Signature> for Signature

impl From<Public> for CryptoTypePublicPair

impl From<&'_ Public> for CryptoTypePublicPair

impl From<MiniSecretKey> for Pair

impl From<SecretKey> for Pair

impl From<Keypair> for Pair

impl From<Pair> for Keypair

impl From<Public> for CryptoTypePublicPair

impl From<&'_ Public> for CryptoTypePublicPair

impl From<Pair> for Public

impl From<Signature> for [u8; 65]

impl From<(Signature, RecoveryId)> for Signature

impl From<StorageKind> for u8

impl From<StorageKind> for u32

impl From<HttpRequestId> for u32

impl From<HttpError> for u8

impl From<HttpError> for u32

impl From<HttpRequestStatus> for u32

impl<'a> From<&'a [Capability]> for Capabilities

impl From<Box<dyn Externalities + 'static, Global>> for OffchainExt

impl From<Box<dyn TransactionPool + Send + 'static, Global>> for TransactionPoolExt

impl From<Box<dyn CallInWasm + 'static, Global>> for CallInWasmExt

impl From<Box<dyn SpawnNamed + 'static, Global>> for TaskExecutorExt

impl From<Box<dyn RuntimeSpawn + 'static, Global>> for RuntimeSpawnExt

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

impl From<OpaqueMetadata> for Bytes

impl<R> From<R> for NativeOrEncoded<R>

impl From<LogLevel> for u8

impl From<u32> for LogLevel

impl From<Level> for LogLevel

impl From<LogLevel> for Level

impl<H, N> From<Equivocation<Public, Prevote<H, N>, Signature>> for Equivocation<H, N>

impl<H, N> From<Equivocation<Public, Precommit<H, N>, Signature>> for Equivocation<H, N>

impl<'a> From<Vec<(Public, u64), Global>> for VersionedAuthorityList<'a>

impl<'a> From<&'a Vec<(Public, u64), Global>> for VersionedAuthorityList<'a>

impl<T: Into<String>> From<T> for Error

impl<E: Encode> From<E> for MakeFatalError<E>

impl From<Keyring> for &'static str

impl From<Keyring> for MultiSigner

impl From<Keyring> for AccountId32

impl From<Keyring> for Public

impl From<Keyring> for Pair

impl From<Keyring> for [u8; 32]

impl From<Keyring> for H256

impl From<Keyring> for &'static [u8; 32]

impl From<Keyring> for &'static str

impl From<Keyring> for MultiSigner

impl From<Keyring> for Public

impl From<Keyring> for AccountId32

impl From<Keyring> for Pair

impl From<Keyring> for [u8; 32]

impl From<Keyring> for H256

impl From<Keyring> for &'static [u8; 32]

impl From<Arc<dyn SyncCryptoStore + 'static>> for KeystoreExt

impl From<u32> for NumberOrHex

impl From<u64> for NumberOrHex

impl From<u128> for NumberOrHex

impl From<U256> for NumberOrHex

impl From<NumberOrHex> for U256

impl<T> From<T> for ListOrValue<T>

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

impl<Address, Call, Signature, Extra> From<UncheckedExtrinsic<Address, Call, Signature, Extra>> for OpaqueExtrinsic where
    Address: Encode,
    Signature: Encode,
    Call: Encode,
    Extra: SignedExtension, 

impl From<u64> for UintAuthorityId

impl From<UintAuthorityId> for u64

impl<Xt> From<Xt> for ExtrinsicWrapper<Xt>

impl From<BadOrigin> for &'static str

impl From<StoredMapError> for &'static str

impl From<LookupError> for &'static str

impl From<LookupError> for TransactionValidityError

impl From<InvalidTransaction> for &'static str

impl From<UnknownTransaction> for &'static str

impl From<TransactionValidityError> for &'static str

impl From<InvalidTransaction> for TransactionValidityError

impl From<UnknownTransaction> for TransactionValidityError

impl From<ValidTransactionBuilder> for TransactionValidity

impl From<ValidTransactionBuilder> for ValidTransaction

impl From<&'static str> for RuntimeString

impl From<RuntimeString> for String

impl<AccountId, AccountIndex> From<AccountId> for MultiAddress<AccountId, AccountIndex>

impl From<Signature> for MultiSignature

impl From<Signature> for MultiSignature

impl From<Signature> for MultiSignature

impl From<Public> for MultiSigner

impl From<Public> for MultiSigner

impl From<Public> for MultiSigner

impl From<Signature> for AnySignature

impl From<Signature> for AnySignature

impl From<DispatchError> for DispatchOutcome

impl<T, E> From<E> for DispatchErrorWithPostInfo<T> where
    T: Eq + PartialEq + Clone + Copy + Encode + Decode + Printable + Default,
    E: Into<DispatchError>, 

impl From<LookupError> for DispatchError

impl From<BadOrigin> for DispatchError

impl From<StoredMapError> for DispatchError

impl From<&'static str> for DispatchError

impl From<DispatchError> for &'static str

impl<T> From<DispatchErrorWithPostInfo<T>> for &'static str where
    T: Eq + PartialEq + Clone + Copy + Encode + Decode + Printable, 

impl<T, O> From<T> for WrappedFFIValue<T, O>

impl<T, O> From<(T, O)> for WrappedFFIValue<T, O>

impl<H: Hasher> From<HashMap<Option<ChildInfo>, BTreeMap<Vec<u8, Global>, Vec<u8, Global>>, RandomState>> for TrieBackend<MemoryDB<H>, H> where
    H::Out: Codec + Ord, 

impl<H: Hasher> From<Storage> for TrieBackend<MemoryDB<H>, H> where
    H::Out: Codec + Ord, 

impl<H: Hasher> From<BTreeMap<Vec<u8, Global>, Vec<u8, Global>>> for TrieBackend<MemoryDB<H>, H> where
    H::Out: Codec + Ord, 

impl<H: Hasher> From<Vec<(Option<ChildInfo>, Vec<(Vec<u8, Global>, Option<Vec<u8, Global>>), Global>), Global>> for TrieBackend<MemoryDB<H>, H> where
    H::Out: Codec + Ord, 

impl<H: Hasher, N: ChangesTrieBlockNumber> From<Storage> for TestExternalities<H, N> where
    H::Out: Ord + 'static + Codec, 

impl From<BTreeMap<Vec<u8, Global>, Vec<u8, Global>>> for BasicExternalities

impl<'a, H: Hasher, B: 'a + Backend<H>> From<&'a B> for ReadOnlyExternalities<'a, H, B>

impl<'a, F> From<&'a ExecutionManager<F>> for ExecutionStrategy

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

impl From<&'_ Level> for WasmLevel

impl From<u8> for WasmValue

impl From<&'_ i8> for WasmValue

impl From<&'_ str> for WasmValue

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

impl From<bool> for WasmValue

impl From<Arguments<'_>> for WasmValue

impl From<i8> for WasmValue

impl From<i32> for WasmValue

impl From<&'_ i32> for WasmValue

impl From<u32> for WasmValue

impl From<&'_ u32> for WasmValue

impl From<u64> for WasmValue

impl From<i64> for WasmValue

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

impl From<&'_ str> for WasmFieldName

impl From<Vec<WasmFieldName, Global>> for WasmFields

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

impl From<&'_ FieldSet> for WasmFields

impl From<Vec<(WasmFieldName, Option<WasmValue>), Global>> for WasmValuesSet

impl From<Vec<(&'_ &'_ WasmFieldName, Option<WasmValue>), Global>> for WasmValuesSet

impl From<Vec<(&'_ &'_ str, Option<WasmValue>), Global>> for WasmValuesSet

impl From<&'_ Metadata<'_>> for WasmMetadata

impl From<&'_ Event<'_>> for WasmEntryAttributes

impl From<&'_ Attributes<'_>> for WasmEntryAttributes

impl From<&'_ WasmMetadata> for &'static Metadata<'static>

impl From<WasmEntryAttributes> for Span

impl From<(u64, u64)> for Error

impl From<Box<dyn Any + Send + 'static, Global>> for Error

impl From<UnknownTransaction> for Error

impl From<InvalidTransaction> for Error

impl From<Error> for Error

impl<H: Hasher> From<StorageProof> for MemoryDB<H>

impl From<Value> for RuntimeValue

impl From<RuntimeValue> for Value

impl From<ValueType> for ValueType

impl From<ValueType> for ValueType

impl From<Signature> for Signature

impl From<&'_ Signature> for Signature

impl From<ValueType> for u8

impl<T: PointerType> From<u32> for Pointer<T>

impl<T: PointerType> From<Pointer<T>> for u32

impl<T: PointerType> From<Pointer<T>> for u64

impl<T: PointerType> From<Pointer<T>> for usize

impl From<Value> for ReturnValue

impl From<OverflowError> for LoopError

impl<BlockHash, AccountId, Index> From<RpcChannel> for Client<BlockHash, AccountId, Index> where
    BlockHash: Send + Sync + 'static + Serialize,
    AccountId: Send + Sync + 'static + Serialize,
    Index: Send + Sync + 'static + DeserializeOwned, 

impl From<Error> for i64

impl From<Choice> for bool

impl From<u8> for Choice

impl<T> From<CtOption<T>> for Option<T>

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<Ident> for Member

impl From<Index> for Member

impl From<usize> for Member

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

impl From<PathPersistError> for TempPath

impl From<PersistError> for Error

impl From<PersistError> for NamedTempFile

impl<A: Array> From<A> for ArrayVec<A>

impl<'s, T> From<&'s mut [T]> for SliceVec<'s, T>

impl<'s, T, A> From<&'s mut A> for SliceVec<'s, T> where
    A: AsMut<[T]>, 

impl<A: Array> From<ArrayVec<A>> for TinyVec<A>

impl<A: Array> From<A> for TinyVec<A>

impl<T, A> From<&'_ [T]> for TinyVec<A> where
    T: Clone + Default,
    A: Array<Item = T>, 

impl<T, A> From<&'_ mut [T]> for TinyVec<A> where
    T: Clone + Default,
    A: Array<Item = T>, 

impl<RW> From<BufReader<BufWriter<RW>>> for BufStream<RW>

impl<RW> From<BufWriter<BufReader<RW>>> for BufStream<RW>

impl From<JoinError> for Error

impl<T> From<(T, TrySendError)> for SendError<T>

impl<T> From<(T, TrySendError)> for TrySendError<T>

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

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

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

impl From<Instant> for Instant

impl From<Instant> for Instant

impl From<Elapsed> for Error

impl From<Arc<ClientConfig>> for TlsConnector

impl From<Arc<ServerConfig>> for TlsAcceptor

impl<T> From<TlsStream<T>> for TlsStream<T>

impl<T> From<TlsStream<T>> for TlsStream<T>

impl<T> From<T> for Lock<T>

impl<T> From<(T, TrySendError)> for TrySendError<T>

impl<T> From<(T, TrySendError)> for UnboundedTrySendError<T>

impl From<Error> for LinesCodecError

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<'a> From<&'a Span> for Option<&'a Id>

impl<'a> From<&'a Span> for Option<Id>

impl From<Span> for Option<Id>

impl<'a> From<&'a EnteredSpan> for Option<&'a Id>

impl<'a> From<&'a EnteredSpan> for Option<Id>

impl<S> From<S> for Dispatch where
    S: Subscriber + Send + Sync + 'static, 

impl From<Level> for LevelFilter

impl From<Option<Level>> for LevelFilter

impl From<LevelFilter> for Option<Level>

impl<'a> From<&'a Id> for Option<Id>

impl<'a> From<&'a Current> for Option<&'a Id>

impl<'a> From<&'a Current> for Option<Id>

impl From<Current> for Option<Id>

impl<'a> From<&'a Current> for Option<&'static Metadata<'static>>

impl From<LevelFilter> for Directive

impl From<Level> for Directive

impl From<Box<dyn Error + Send + Sync + 'static, Global>> for ParseError

impl From<ParseLevelFilterError> for ParseError

impl<S> From<S> for EnvFilter where
    S: AsRef<str>, 

impl From<ParseError> for FromEnvError

impl From<VarError> for FromEnvError

impl From<Instant> for Uptime

impl<T> From<Option<T>> for OptionalWriter<T>

impl<N, E, F, W> From<SubscriberBuilder<N, E, F, W>> for Dispatch where
    N: for<'writer> FormatFields<'writer> + 'static,
    E: FormatEvent<Registry, N> + 'static,
    W: MakeWriter + 'static,
    F: Layer<Formatter<N, E, W>> + Send + Sync + 'static,
    Layer<Registry, N, E, W>: Layer<Registry> + Send + Sync + 'static, 

impl<'a> From<NibbleSlice<'a>> for NibbleVec

impl From<Error> for Error

impl From<FromDecStrErr> for FromStrRadixErr

impl From<FromHexError> for FromStrRadixErr

impl<S> From<Ascii<S>> for UniCase<S>

impl<S: AsRef<str>> From<S> for UniCase<S>

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

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

impl<'a> From<&'a str> for UniCase<String>

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

impl<'a> From<&'a String> for UniCase<&'a str>

impl From<u8> for Level

impl<U> From<GenericArray<u8, <U as UniversalHash>::BlockSize>> for Output<U> where
    U: UniversalHash, 

impl<'a, U> From<&'a GenericArray<u8, <U as UniversalHash>::BlockSize>> for Output<U> where
    U: UniversalHash, 

impl From<Error> for ReadError

impl From<Error> for ReadError

impl<'a> From<&'a [u8]> for Input<'a>

impl From<Errors> for ParseError

impl From<Url> for String

impl From<Error> for Error

impl<'v> From<&'v str> for ValueBag<'v>

impl<'v> From<()> for ValueBag<'v>

impl<'v> From<usize> for ValueBag<'v>

impl<'v> From<u8> for ValueBag<'v>

impl<'v> From<u16> for ValueBag<'v>

impl<'v> From<u32> for ValueBag<'v>

impl<'v> From<u64> for ValueBag<'v>

impl<'v> From<u128> for ValueBag<'v>

impl<'v> From<isize> for ValueBag<'v>

impl<'v> From<i8> for ValueBag<'v>

impl<'v> From<i16> for ValueBag<'v>

impl<'v> From<i32> for ValueBag<'v>

impl<'v> From<i64> for ValueBag<'v>

impl<'v> From<i128> for ValueBag<'v>

impl<'v> From<f32> for ValueBag<'v>

impl<'v> From<f64> for ValueBag<'v>

impl<'v> From<char> for ValueBag<'v>

impl<'v> From<bool> for ValueBag<'v>

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

impl<'a> From<&'a String> for JsValue

impl From<String> for JsValue

impl From<bool> for JsValue

impl<'a, T> From<&'a T> for JsValue where
    T: JsCast, 

impl<T> From<Option<T>> for JsValue where
    JsValue: From<T>, 

impl From<i8> for JsValue

impl From<u8> for JsValue

impl From<i16> for JsValue

impl From<u16> for JsValue

impl From<i32> for JsValue

impl From<u32> for JsValue

impl From<f32> for JsValue

impl From<f64> for JsValue

impl From<Error> for Diagnostic

impl From<Promise> for JsFuture

impl<U> From<U> for Error where
    U: HostError + Sized, 

impl<U> From<U> for Trap where
    U: HostError + Sized, 

impl From<Trap> for Error

impl From<TrapKind> for Trap

impl From<Error> for Error

impl From<Trap> for ResumableError

impl<'a> From<&'a [RuntimeValue]> for RuntimeArgs<'a>

impl From<f32> for F32

impl From<F32> for f32

impl From<f64> for F64

impl From<F64> for f64

impl From<u32> for F32

impl From<F32> for u32

impl From<u64> for F64

impl From<F64> for u64

impl From<i8> for RuntimeValue

impl From<i16> for RuntimeValue

impl From<i32> for RuntimeValue

impl From<i64> for RuntimeValue

impl From<u8> for RuntimeValue

impl From<u16> for RuntimeValue

impl From<u32> for RuntimeValue

impl From<u64> for RuntimeValue

impl From<F32> for RuntimeValue

impl From<F64> for RuntimeValue

impl From<ValueType> for StackValueType

impl From<Error> for Error

impl From<Func> for Extern

impl From<Global> for Extern

impl From<Memory> for Extern

impl From<Table> for Extern

impl From<Instance> for Extern

impl From<Module> for Extern

impl From<Error> for Trap

impl From<Box<dyn Error + Send + Sync + 'static, Global>> for Trap

impl From<FuncType> for ExternType

impl From<GlobalType> for ExternType

impl From<MemoryType> for ExternType

impl From<TableType> for ExternType

impl From<ModuleType> for ExternType

impl From<InstanceType> for ExternType

impl From<i32> for Val

impl From<i64> for Val

impl From<f32> for Val

impl From<f64> for Val

impl From<ExternRef> for Val

impl From<Option<ExternRef>> for Val

impl From<Option<Func>> for Val

impl From<Func> for Val

impl From<WasmError> for CompileError

impl From<CompileError> for SetupError

impl From<InstantiationError> for SetupError

impl From<Error> for SetupError

impl<'a> From<ExportFunction> for Export<'a>

impl<'a> From<ExportTable> for Export<'a>

impl<'a> From<ExportMemory> for Export<'a>

impl<'a> From<ExportGlobal> for Export<'a>

impl From<LinkError> for InstantiationError

impl From<*mut VMCallerCheckedAnyfunc> for TableElement

impl From<Option<VMExternRef>> for TableElement

impl From<VMExternRef> for TableElement

impl<'a> From<Id<'a>> for Index<'a>

impl From<instance> for ExportKind

impl From<module> for ExportKind

impl From<func> for ExportKind

impl From<table> for ExportKind

impl From<global> for ExportKind

impl From<tag> for ExportKind

impl From<memory> for ExportKind

impl From<type> for ExportKind

impl<'a> From<FunctionTypeNoNames<'a>> for FunctionType<'a>

impl<'a> From<TypeUse<'a, FunctionTypeNoNames<'a>>> for TypeUse<'a, FunctionType<'a>>

impl From<DNSNameRef<'_>> for DNSName

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

impl<T: Config> From<Error<T>> for &'static str

impl<T: Config> From<Error<T>> for DispatchError

impl<T: Config> From<Event<T>> for ()

impl From<[u8; 32]> for PublicKey

impl<'a> From<&'a EphemeralSecret> for PublicKey

impl From<[u8; 32]> for StaticSecret

impl<'a> From<&'a StaticSecret> for PublicKey

impl From<Error> for ConnectionError

impl From<FrameDecodeError> for ConnectionError

impl From<SendError> for ConnectionError

impl From<Canceled> for ConnectionError

impl From<Error> for FrameDecodeError

impl From<HeaderDecodeError> for FrameDecodeError

impl<Z> From<Z> for Zeroizing<Z> where
    Z: Zeroize,