pub trait From<T> {
fn from(T) -> Self;
}
Expand description
Used to do value-to-value conversions while consuming the input value. It is the reciprocal of
Into
.
One should always prefer implementing From
over Into
because implementing From
automatically provides one with an implementation of Into
thanks to the blanket implementation in the standard library.
Only implement Into
when targeting a version prior to Rust 1.41 and converting to a type
outside the current crate.
From
was not able to do these types of conversions in earlier versions because of Rust’s
orphaning rules.
See Into
for more details.
Prefer using Into
over using From
when specifying trait bounds on a generic function.
This way, types that directly implement Into
can be used as arguments as well.
The From
is also very useful when performing error handling. When constructing a function
that is capable of failing, the return type will generally be of the form Result<T, E>
.
The From
trait simplifies error handling by allowing a function to return a single error type
that encapsulate multiple error types. See the “Examples” section and the book for more
details.
Note: This trait must not fail. The From
trait is intended for perfect conversions.
If the conversion can fail or is not perfect, use TryFrom
.
Generic Implementations
From<T> for U
impliesInto
<U> for T
From
is reflexive, which means thatFrom<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
Implementations on Foreign Types
1.45.0 · sourceimpl<'_> From<Cow<'_, OsStr>> for Box<OsStr, Global>
impl<'_> From<Cow<'_, OsStr>> for Box<OsStr, Global>
sourcefn from(cow: Cow<'_, OsStr>) -> Box<OsStr, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
fn from(cow: Cow<'_, OsStr>) -> Box<OsStr, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
1.17.0 · sourceimpl<'_> From<&'_ OsStr> for Box<OsStr, Global>
impl<'_> From<&'_ OsStr> for Box<OsStr, Global>
sourcefn from(s: &OsStr) -> Box<OsStr, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
fn from(s: &OsStr) -> Box<OsStr, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
1.6.0 · sourceimpl From<String> for Box<dyn Error + 'static, Global>
impl From<String> for Box<dyn Error + 'static, Global>
sourcefn from(str_err: String) -> Box<dyn Error + 'static, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
fn from(str_err: String) -> Box<dyn Error + 'static, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
1.45.0 · sourceimpl<'_> From<Cow<'_, CStr>> for Box<CStr, Global>
impl<'_> From<Cow<'_, CStr>> for Box<CStr, Global>
sourcefn from(cow: Cow<'_, CStr>) -> Box<CStr, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
fn from(cow: Cow<'_, CStr>) -> Box<CStr, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
Converts a Cow<'a, CStr>
into a Box<CStr>
,
by copying the contents if they are borrowed.
1.17.0 · sourceimpl<'_> From<&'_ Path> for Box<Path, Global>
impl<'_> From<&'_ Path> for Box<Path, Global>
sourcefn from(path: &Path) -> Box<Path, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
fn from(path: &Path) -> Box<Path, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
Creates a boxed Path
from a reference.
This will allocate and clone path
to it.
1.20.0 · sourceimpl From<PathBuf> for Box<Path, Global>
impl From<PathBuf> for Box<Path, Global>
sourcefn from(p: PathBuf) -> Box<Path, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
fn from(p: PathBuf) -> Box<Path, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
1.24.0 · sourceimpl<T> From<T> for Mutex<T>
impl<T> From<T> for Mutex<T>
sourcefn from(t: T) -> Mutex<T>
fn from(t: T) -> Mutex<T>
Creates a new mutex in an unlocked state ready for use.
This is equivalent to Mutex::new
.
1.22.0 · sourceimpl<'a> From<Cow<'a, str>> for Box<dyn Error + 'static, Global>
impl<'a> From<Cow<'a, str>> for Box<dyn Error + 'static, Global>
sourcefn from(err: Cow<'a, str>) -> Box<dyn Error + 'static, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
fn from(err: Cow<'a, str>) -> Box<dyn Error + 'static, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
sourceimpl<'a, '_> From<&'_ str> for Box<dyn Error + Send + Sync + 'a, Global>
impl<'a, '_> From<&'_ str> for Box<dyn Error + Send + Sync + 'a, Global>
sourcefn from(err: &str) -> Box<dyn Error + Send + Sync + 'a, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
fn from(err: &str) -> Box<dyn Error + Send + Sync + 'a, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
sourceimpl<T> From<T> for SyncOnceCell<T>
impl<T> From<T> for SyncOnceCell<T>
sourcefn from(value: T) -> SyncOnceCell<T>
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(())
sourceimpl From<OwnedFd> for TcpListener
impl From<OwnedFd> for TcpListener
fn from(owned_fd: OwnedFd) -> TcpListener
sourceimpl<T> From<PoisonError<T>> for TryLockError<T>
impl<T> From<PoisonError<T>> for TryLockError<T>
fn from(err: PoisonError<T>) -> TryLockError<T>
sourceimpl From<String> for Box<dyn Error + Send + Sync + 'static, Global>
impl From<String> for Box<dyn Error + Send + Sync + 'static, Global>
sourcefn from(err: String) -> Box<dyn Error + Send + Sync + 'static, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
fn from(err: String) -> Box<dyn Error + Send + Sync + 'static, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
Converts a String
into a box of dyn Error
+ Send
+ Sync
.
Examples
use std::error::Error;
use std::mem;
let a_string_error = "a string error".to_string();
let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_string_error);
assert!(
mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))
1.22.0 · sourceimpl<'a, 'b> From<Cow<'b, str>> for Box<dyn Error + Send + Sync + 'a, Global>
impl<'a, 'b> From<Cow<'b, str>> for Box<dyn Error + Send + Sync + 'a, Global>
sourcefn from(err: Cow<'b, str>) -> Box<dyn Error + Send + Sync + 'a, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
fn from(err: Cow<'b, str>) -> Box<dyn Error + Send + Sync + 'a, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
Converts a Cow
into a box of dyn Error
+ Send
+ Sync
.
Examples
use std::error::Error;
use std::mem;
use std::borrow::Cow;
let a_cow_str_error = Cow::from("a str error");
let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_cow_str_error);
assert!(
mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))
sourceimpl<'a, E> From<E> for Box<dyn Error + 'a, Global> where
E: 'a + Error,
impl<'a, E> From<E> for Box<dyn Error + 'a, Global> where
E: 'a + Error,
sourcefn from(err: E) -> Box<dyn Error + 'a, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
fn from(err: E) -> Box<dyn Error + 'a, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
Converts a type of Error
into a box of dyn Error
.
Examples
use std::error::Error;
use std::fmt;
use std::mem;
#[derive(Debug)]
struct AnError;
impl fmt::Display for AnError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "An error")
}
}
impl Error for AnError {}
let an_error = AnError;
assert!(0 == mem::size_of_val(&an_error));
let a_boxed_error = Box::<dyn Error>::from(an_error);
assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))
1.17.0 · sourceimpl<'_> From<&'_ CStr> for Box<CStr, Global>
impl<'_> From<&'_ CStr> for Box<CStr, Global>
sourcefn from(s: &CStr) -> Box<CStr, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
fn from(s: &CStr) -> Box<CStr, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
Converts a &CStr
into a Box<CStr>
,
by copying the contents into a newly allocated Box
.
1.6.0 · sourceimpl<'_> From<&'_ str> for Box<dyn Error + 'static, Global>
impl<'_> From<&'_ str> for Box<dyn Error + 'static, Global>
sourcefn from(err: &str) -> Box<dyn Error + 'static, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
fn from(err: &str) -> Box<dyn Error + 'static, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
1.20.0 · sourceimpl From<OsString> for Box<OsStr, Global>
impl From<OsString> for Box<OsStr, Global>
sourcefn from(s: OsString) -> Box<OsStr, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
fn from(s: OsString) -> Box<OsStr, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
1.20.0 · sourceimpl From<CString> for Box<CStr, Global>
impl From<CString> for Box<CStr, Global>
sourcefn from(s: CString) -> Box<CStr, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
fn from(s: CString) -> Box<CStr, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
1.24.0 · sourceimpl<T> From<T> for RwLock<T>
impl<T> From<T> for RwLock<T>
sourcefn from(t: T) -> RwLock<T>
fn from(t: T) -> RwLock<T>
Creates a new instance of an RwLock<T>
which is unlocked.
This is equivalent to RwLock::new
.
1.45.0 · sourceimpl<'_> From<Cow<'_, Path>> for Box<Path, Global>
impl<'_> From<Cow<'_, Path>> for Box<Path, Global>
sourcefn from(cow: Cow<'_, Path>) -> Box<Path, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
fn from(cow: Cow<'_, Path>) -> Box<Path, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
Creates a boxed Path
from a clone-on-write pointer.
Converting from a Cow::Owned
does not clone or allocate.
sourceimpl<'a, E> From<E> for Box<dyn Error + Send + Sync + 'a, Global> where
E: 'a + Error + Send + Sync,
impl<'a, E> From<E> for Box<dyn Error + Send + Sync + 'a, Global> where
E: 'a + Error + Send + Sync,
sourcefn from(err: E) -> Box<dyn Error + Send + Sync + 'a, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
fn from(err: E) -> Box<dyn Error + Send + Sync + 'a, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
Converts a type of Error
+ Send
+ Sync
into a box of
dyn Error
+ Send
+ Sync
.
Examples
use std::error::Error;
use std::fmt;
use std::mem;
#[derive(Debug)]
struct AnError;
impl fmt::Display for AnError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "An error")
}
}
impl Error for AnError {}
unsafe impl Send for AnError {}
unsafe impl Sync for AnError {}
let an_error = AnError;
assert!(0 == mem::size_of_val(&an_error));
let a_boxed_error = Box::<dyn Error + Send + Sync>::from(an_error);
assert!(
mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))
1.31.0 (const: unstable) · sourceimpl From<NonZeroUsize> for usize
impl From<NonZeroUsize> for usize
const: unstable · sourcefn from(nonzero: NonZeroUsize) -> usize
fn from(nonzero: NonZeroUsize) -> usize
Converts a NonZeroUsize
into an usize
1.31.0 (const: unstable) · sourceimpl From<NonZeroU128> for u128
impl From<NonZeroU128> for u128
const: unstable · sourcefn from(nonzero: NonZeroU128) -> u128
fn from(nonzero: NonZeroU128) -> u128
Converts a NonZeroU128
into an u128
1.31.0 (const: unstable) · sourceimpl From<NonZeroI128> for i128
impl From<NonZeroI128> for i128
const: unstable · sourcefn from(nonzero: NonZeroI128) -> i128
fn from(nonzero: NonZeroI128) -> i128
Converts a NonZeroI128
into an i128
1.31.0 (const: unstable) · sourceimpl From<NonZeroI64> for i64
impl From<NonZeroI64> for i64
const: unstable · sourcefn from(nonzero: NonZeroI64) -> i64
fn from(nonzero: NonZeroI64) -> i64
Converts a NonZeroI64
into an i64
1.13.0 (const: unstable) · sourceimpl From<u8> for char
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.
1.31.0 (const: unstable) · sourceimpl From<NonZeroIsize> for isize
impl From<NonZeroIsize> for isize
const: unstable · sourcefn from(nonzero: NonZeroIsize) -> isize
fn from(nonzero: NonZeroIsize) -> isize
Converts a NonZeroIsize
into an isize
sourceimpl<T, const LANES: usize> From<Mask<T, LANES>> for [bool; LANES] where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> From<Mask<T, LANES>> for [bool; LANES] where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<T, const LANES: usize> From<Simd<T, LANES>> for [T; LANES] where
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> From<Simd<T, LANES>> for [T; LANES] where
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
1.31.0 (const: unstable) · sourceimpl From<NonZeroU64> for u64
impl From<NonZeroU64> for u64
const: unstable · sourcefn from(nonzero: NonZeroU64) -> u64
fn from(nonzero: NonZeroU64) -> u64
Converts a NonZeroU64
into an u64
1.31.0 (const: unstable) · sourceimpl From<NonZeroU16> for u16
impl From<NonZeroU16> for u16
const: unstable · sourcefn from(nonzero: NonZeroU16) -> u16
fn from(nonzero: NonZeroU16) -> u16
Converts a NonZeroU16
into an u16
1.31.0 (const: unstable) · sourceimpl From<NonZeroI32> for i32
impl From<NonZeroI32> for i32
const: unstable · sourcefn from(nonzero: NonZeroI32) -> i32
fn from(nonzero: NonZeroI32) -> i32
Converts a NonZeroI32
into an i32
1.31.0 (const: unstable) · sourceimpl From<NonZeroU32> for u32
impl From<NonZeroU32> for u32
const: unstable · sourcefn from(nonzero: NonZeroU32) -> u32
fn from(nonzero: NonZeroU32) -> u32
Converts a NonZeroU32
into an u32
1.31.0 (const: unstable) · sourceimpl From<NonZeroI16> for i16
impl From<NonZeroI16> for i16
const: unstable · sourcefn from(nonzero: NonZeroI16) -> i16
fn from(nonzero: NonZeroI16) -> i16
Converts a NonZeroI16
into an i16
1.14.0 · sourceimpl<'a, T> From<Cow<'a, [T]>> for Vec<T, Global> where
[T]: ToOwned,
<[T] as ToOwned>::Owned == Vec<T, Global>,
impl<'a, T> From<Cow<'a, [T]>> for Vec<T, Global> where
[T]: ToOwned,
<[T] as ToOwned>::Owned == Vec<T, Global>,
sourcefn from(s: Cow<'a, [T]>) -> Vec<T, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
fn from(s: Cow<'a, [T]>) -> Vec<T, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
A: Allocator,
Convert a clone-on-write slice into a vector.
If s
already owns a Vec<T>
, it will be returned directly.
If s
is borrowing a slice, a new Vec<T>
will be allocated and
filled by cloning s
’s items into it.
Examples
let o: Cow<[i32]> = Cow::Owned(vec![1, 2, 3]);
let b: Cow<[i32]> = Cow::Borrowed(&[1, 2, 3]);
assert_eq!(Vec::from(o), Vec::from(b));
1.17.0 · sourceimpl<'_> From<&'_ str> for Box<str, Global>
impl<'_> From<&'_ str> for Box<str, Global>
sourcefn from(s: &str) -> Box<str, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
fn from(s: &str) -> Box<str, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
Converts a &str
into a Box<str>
This conversion allocates on the heap
and performs a copy of s
.
Examples
let boxed: Box<str> = Box::from("hello");
println!("{boxed}");
1.6.0 · sourceimpl<T> From<T> for Box<T, Global>
impl<T> From<T> for Box<T, Global>
sourcefn from(t: T) -> Box<T, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
fn from(t: T) -> Box<T, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
Converts a T
into a Box<T>
The conversion allocates on the heap and moves t
from the stack into it.
Examples
let x = 5;
let boxed = Box::new(5);
assert_eq!(Box::from(x), boxed);
1.14.0 · sourceimpl From<String> for Vec<u8, Global>
impl From<String> for Vec<u8, Global>
1.20.0 · sourceimpl<T, A> From<Vec<T, A>> for Box<[T], A> where
A: Allocator,
impl<T, A> From<Vec<T, A>> for Box<[T], A> where
A: Allocator,
sourcefn from(v: Vec<T, A>) -> Box<[T], A>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
fn from(v: Vec<T, A>) -> Box<[T], A>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
Convert a vector into a boxed slice.
If v
has excess capacity, its items will be moved into a
newly-allocated buffer with exactly the right capacity.
Examples
assert_eq!(Box::from(vec![1, 2, 3]), vec![1, 2, 3].into_boxed_slice());
1.45.0 · sourceimpl<'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 Rc<B> where
B: ToOwned + ?Sized,
Rc<B>: From<&'a B>,
Rc<B>: From<<B as ToOwned>::Owned>,
1.14.0 · sourceimpl<'a> From<Cow<'a, str>> for String
impl<'a> From<Cow<'a, str>> for String
sourcefn from(s: Cow<'a, str>) -> String
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");
1.18.0 · sourceimpl<T, A> From<Box<[T], A>> for Vec<T, A> where
A: Allocator,
impl<T, A> From<Box<[T], A>> for Vec<T, A> where
A: Allocator,
sourcefn from(s: Box<[T], A>) -> Vec<T, A>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
fn from(s: Box<[T], A>) -> Vec<T, A>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
A: Allocator,
Convert a boxed slice into a vector by transferring ownership of the existing heap allocation.
Examples
let b: Box<[i32]> = vec![1, 2, 3].into_boxed_slice();
assert_eq!(Vec::from(b), vec![1, 2, 3]);
1.17.0 · sourceimpl<'_, T> From<&'_ [T]> for Box<[T], Global> where
T: Copy,
impl<'_, T> From<&'_ [T]> for Box<[T], Global> where
T: Copy,
sourcefn from(slice: &[T]) -> Box<[T], Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
fn from(slice: &[T]) -> Box<[T], Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
Converts a &[T]
into a Box<[T]>
This conversion allocates on the heap
and performs a copy of slice
.
Examples
// create a &[u8] which will be used to create a Box<[u8]>
let slice: &[u8] = &[104, 101, 108, 108, 111];
let boxed_slice: Box<[u8]> = Box::from(slice);
println!("{boxed_slice:?}");
1.20.0 · sourceimpl From<String> for Box<str, Global>
impl From<String> for Box<str, Global>
sourcefn from(s: String) -> Box<str, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
fn from(s: String) -> Box<str, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
1.5.0 · sourceimpl<T> From<Vec<T, Global>> for BinaryHeap<T> where
T: Ord,
impl<T> From<Vec<T, Global>> for BinaryHeap<T> where
T: Ord,
sourcefn from(vec: Vec<T, Global>) -> BinaryHeap<T>
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.
sourceimpl From<LayoutError> for TryReserveErrorKind
impl From<LayoutError> for TryReserveErrorKind
sourcefn from(LayoutError) -> TryReserveErrorKind
fn from(LayoutError) -> TryReserveErrorKind
Always evaluates to TryReserveErrorKind::CapacityOverflow
.
1.45.0 · sourceimpl<'_, T> From<Cow<'_, [T]>> for Box<[T], Global> where
T: Copy,
impl<'_, T> From<Cow<'_, [T]>> for Box<[T], Global> where
T: Copy,
sourcefn from(cow: Cow<'_, [T]>) -> Box<[T], Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
fn from(cow: Cow<'_, [T]>) -> Box<[T], Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
Converts a Cow<'_, [T]>
into a Box<[T]>
When cow
is the Cow::Borrowed
variant, this
conversion allocates on the heap and copies the
underlying slice. Otherwise, it will try to reuse the owned
Vec
’s allocation.
1.45.0 · sourceimpl<T, const N: usize> From<[T; N]> for Box<[T], Global>
impl<T, const N: usize> From<[T; N]> for Box<[T], Global>
sourcefn from(array: [T; N]) -> Box<[T], Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
fn from(array: [T; N]) -> Box<[T], Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
Converts a [T; N]
into a Box<[T]>
This conversion moves the array to newly heap-allocated memory.
Examples
let boxed: Box<[u8]> = Box::from([4, 2]);
println!("{boxed:?}");
1.10.0 · sourceimpl<T, A> From<VecDeque<T, A>> for Vec<T, A> where
A: Allocator,
impl<T, A> From<VecDeque<T, A>> for Vec<T, A> where
A: Allocator,
sourcefn from(other: VecDeque<T, A>) -> Vec<T, A>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
fn from(other: VecDeque<T, A>) -> Vec<T, A>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
A: Allocator,
Turn a VecDeque<T>
into a Vec<T>
.
This never needs to re-allocate, but does need to do O(n) data movement if the circular buffer doesn’t happen to be at the beginning of the allocation.
Examples
use std::collections::VecDeque;
// This one is *O*(1).
let deque: VecDeque<_> = (1..5).collect();
let ptr = deque.as_slices().0.as_ptr();
let vec = Vec::from(deque);
assert_eq!(vec, [1, 2, 3, 4]);
assert_eq!(vec.as_ptr(), ptr);
// This one needs data rearranging.
let mut deque: VecDeque<_> = (1..5).collect();
deque.push_front(9);
deque.push_front(8);
let ptr = deque.as_slices().1.as_ptr();
let vec = Vec::from(deque);
assert_eq!(vec, [8, 9, 1, 2, 3, 4]);
assert_eq!(vec.as_ptr(), ptr);
1.56.0 · sourceimpl<T, const N: usize> From<[T; N]> for BinaryHeap<T> where
T: Ord,
impl<T, const N: usize> From<[T; N]> for BinaryHeap<T> where
T: Ord,
sourcefn from(arr: [T; N]) -> BinaryHeap<T>
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);
}
1.56.0 · sourceimpl<T, const N: usize> From<[T; N]> for LinkedList<T>
impl<T, const N: usize> From<[T; N]> for LinkedList<T>
sourcefn from(arr: [T; N]) -> LinkedList<T>
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);
1.19.0 · sourceimpl<A> From<Box<str, A>> for Box<[u8], A> where
A: Allocator,
impl<A> From<Box<str, A>> for Box<[u8], A> where
A: Allocator,
sourcefn from(s: Box<str, A>) -> Box<[u8], A>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
fn from(s: Box<str, A>) -> Box<[u8], A>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
Converts a Box<str>
into a Box<[u8]>
This conversion does not allocate on the heap and happens in place.
Examples
// create a Box<str> which will be used to create a Box<[u8]>
let boxed: Box<str> = Box::from("hello");
let boxed_str: Box<[u8]> = Box::from(boxed);
// create a &[u8] which will be used to create a Box<[u8]>
let slice: &[u8] = &[104, 101, 108, 108, 111];
let boxed_slice = Box::from(slice);
assert_eq!(boxed_slice, boxed_str);
1.45.0 · sourceimpl<'_> From<Cow<'_, str>> for Box<str, Global>
impl<'_> From<Cow<'_, str>> for Box<str, Global>
sourcefn from(cow: Cow<'_, str>) -> Box<str, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
fn from(cow: Cow<'_, str>) -> Box<str, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
Converts a Cow<'_, str>
into a Box<str>
When cow
is the Cow::Borrowed
variant, this
conversion allocates on the heap and copies the
underlying str
. Otherwise, it will try to reuse the owned
String
’s allocation.
Examples
use std::borrow::Cow;
let unboxed = Cow::Borrowed("hello");
let boxed: Box<str> = Box::from(unboxed);
println!("{boxed}");
let unboxed = Cow::Owned("hello".to_string());
let boxed: Box<str> = Box::from(unboxed);
println!("{boxed}");
1.5.0 · sourceimpl<T> From<BinaryHeap<T>> for Vec<T, Global>
impl<T> From<BinaryHeap<T>> for Vec<T, Global>
sourceimpl From<TryReserveErrorKind> for TryReserveError
impl From<TryReserveErrorKind> for TryReserveError
fn from(kind: TryReserveErrorKind) -> TryReserveError
sourceimpl From<CompassAngle> for u8
impl From<CompassAngle> for u8
fn from(a: CompassAngle) -> u8
sourceimpl From<VisiblePieceId> for String
impl From<VisiblePieceId> for String
fn from(p: VisiblePieceId) -> String
sourceimpl From<GoodItemName> for String
impl From<GoodItemName> for String
fn from(i: GoodItemName) -> String
sourceimpl From<LibInBundleI> for usize
impl From<LibInBundleI> for usize
fn from(v: LibInBundleI) -> usize
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B0>>> for [T; 44]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B0>>> for [T; 44]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B1>>> for [T; 41]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B1>>> for [T; 41]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B0>>> for [T; 500]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B0>>> for [T; 500]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B1>, B0>>> for [T; 90]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B1>, B0>>> for [T; 90]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0>>> for [T; 48]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0>>> for [T; 48]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B1>, B0>>> for [T; 70]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B1>, B0>>> for [T; 70]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B1>>> for [T; 57]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B1>>> for [T; 57]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>, B1>>> for [T; 55]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>, B1>>> for [T; 55]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B1>>> for [T; 51]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B1>>> for [T; 51]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>, B1>>> for [T; 61]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>, B1>>> for [T; 61]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B1>>> for [T; 33]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B1>>> for [T; 33]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>, B0>>> for [T; 38]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>, B0>>> for [T; 38]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>, B1>>> for [T; 43]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>, B1>>> for [T; 43]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B1>>> for [T; 37]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B1>>> for [T; 37]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B0>>> for [T; 36]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B0>>> for [T; 36]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B1>>> for [T; 45]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B1>>> for [T; 45]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B0>, B0>>> for [T; 80]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B0>, B0>>> for [T; 80]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>> for [T; 256]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>> for [T; 256]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>, B1>>> for [T; 53]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>, B1>>> for [T; 53]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>, B0>>> for [T; 60]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>, B0>>> for [T; 60]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>> for [T; 1024]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>> for [T; 1024]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>, B0>>> for [T; 46]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>, B0>>> for [T; 46]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B0>>> for [T; 56]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B0>>> for [T; 56]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>, B0>>> for [T; 100]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>, B0>>> for [T; 100]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>, B0>>> for [T; 52]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>, B0>>> for [T; 52]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>, B0>>> for [T; 54]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>, B0>>> for [T; 54]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>>> for [T; 64]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>>> for [T; 64]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>, B1>>> for [T; 39]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>, B1>>> for [T; 39]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B1>>> for [T; 35]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B1>>> for [T; 35]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B1>>> for [T; 63]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B1>>> for [T; 63]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>, B0>>> for [T; 58]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>, B0>>> for [T; 58]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B0>, B0>>> for [T; 400]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B0>, B0>>> for [T; 400]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>, B1>>> for [T; 47]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>, B1>>> for [T; 47]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>, B0>>> for [T; 42]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>, B0>>> for [T; 42]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>, B1>>> for [T; 59]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>, B1>>> for [T; 59]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>> for [T; 512]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>> for [T; 512]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B0>, B0>>> for [T; 1000]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B0>, B0>>> for [T; 1000]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B0>>> for [T; 34]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B0>>> for [T; 34]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B0>>> for [T; 62]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B0>>> for [T; 62]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B0>>> for [T; 40]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B0>>> for [T; 40]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B1>>> for [T; 49]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B1>>> for [T; 49]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>>> for [T; 32]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>>> for [T; 32]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>>> for [T; 50]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>>> for [T; 50]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B1>, B1>, B0>, B0>>> for [T; 300]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B1>, B1>, B0>, B0>>> for [T; 300]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>> for [T; 128]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>> for [T; 128]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B0>>> for [T; 200]
impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B0>>> for [T; 200]
sourceimpl<'a, T, U> From<&'a T> for SerializeAsWrap<'a, T, U> where
U: SerializeAs<T> + ?Sized,
T: ?Sized,
impl<'a, T, U> From<&'a T> for SerializeAsWrap<'a, T, U> where
U: SerializeAs<T> + ?Sized,
T: ?Sized,
fn from(value: &'a T) -> SerializeAsWrap<'a, T, U>
sourceimpl From<Error> for Box<dyn Error + Send + Sync + 'static, Global>
impl From<Error> for Box<dyn Error + Send + Sync + 'static, Global>
fn from(error: Error) -> Box<dyn Error + Send + Sync + 'static, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
sourceimpl From<Error> for Box<dyn Error + 'static, Global>
impl From<Error> for Box<dyn Error + 'static, Global>
fn from(error: Error) -> Box<dyn Error + 'static, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
sourceimpl From<Error> for Box<dyn Error + Send + 'static, Global>
impl From<Error> for Box<dyn Error + Send + 'static, Global>
fn from(error: Error) -> Box<dyn Error + Send + 'static, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
impl From<LayoutError> for CollectionAllocErr
impl From<LayoutError> for CollectionAllocErr
fn from(LayoutError) -> CollectionAllocErr
impl<'a, A> From<&'a [<A as Array>::Item]> for SmallVec<A> where
A: Array,
<A as Array>::Item: Clone,
impl<'a, A> From<&'a [<A as Array>::Item]> for SmallVec<A> where
A: Array,
<A as Array>::Item: Clone,
sourceimpl From<Choice> for bool
impl From<Choice> for bool
sourcefn from(source: Choice) -> bool
fn from(source: Choice) -> bool
Convert the Choice
wrapper into a bool
, depending on whether
the underlying u8
was a 0
or a 1
.
Note
This function exists to avoid having higher-level cryptographic protocol implementations duplicating this pattern.
The intended use case for this conversion is at the end of a
higher-level primitive implementation: for example, in checking a keyed
MAC, where the verification should happen in constant-time (and thus use
a Choice
) but it is safe to return a bool
at the end of the
verification.
sourceimpl From<SystemTime> for Timestamp
impl From<SystemTime> for Timestamp
fn from(dur: SystemTime) -> Timestamp
impl From<SystemTime> for OffsetDateTime
impl From<SystemTime> for OffsetDateTime
fn from(system_time: SystemTime) -> OffsetDateTime
impl From<Colour> for Style
impl From<Colour> for Style
fn from(colour: Colour) -> Style
fn from(colour: Colour) -> Style
You can turn a Colour
into a Style
with the foreground colour set
with the From
trait.
use ansi_term::{Style, Colour};
let green_foreground = Style::default().fg(Colour::Green);
assert_eq!(green_foreground, Colour::Green.normal());
assert_eq!(green_foreground, Colour::Green.into());
assert_eq!(green_foreground, Style::from(Colour::Green));
impl<'a, I, S> From<I> for ANSIGenericString<'a, S> where
S: 'a + ToOwned + ?Sized,
I: Into<Cow<'a, S>>,
<S as ToOwned>::Owned: Debug,
impl<'a, I, S> From<I> for ANSIGenericString<'a, S> where
S: 'a + ToOwned + ?Sized,
I: Into<Cow<'a, S>>,
<S as ToOwned>::Owned: Debug,
fn from(input: I) -> ANSIGenericString<'a, S>
impl From<SystemTime> for FileTime
impl From<SystemTime> for FileTime
fn from(time: SystemTime) -> FileTime
impl<T> From<TrySendError<T>> for TrySendError<T>
impl<T> From<TrySendError<T>> for TrySendError<T>
fn from(src: TrySendError<T>) -> TrySendError<T>
impl<I, T> From<IndexVec<I, T>> for Box<IndexSlice<I, [T]>, Global> where
I: Idx,
impl<I, T> From<IndexVec<I, T>> for Box<IndexSlice<I, [T]>, Global> where
I: Idx,
fn from(src: IndexVec<I, T>) -> Box<IndexSlice<I, [T]>, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
impl<I, T> From<Box<[T], Global>> for Box<IndexSlice<I, [T]>, Global> where
I: Idx,
impl<I, T> From<Box<[T], Global>> for Box<IndexSlice<I, [T]>, Global> where
I: Idx,
fn from(b: Box<[T], Global>) -> Box<IndexSlice<I, [T]>, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
impl From<OrderedFloat<f64>> for f64
impl From<OrderedFloat<f64>> for f64
fn from(f: OrderedFloat<f64>) -> f64
impl From<OrderedFloat<f32>> for f32
impl From<OrderedFloat<f32>> for f32
fn from(f: OrderedFloat<f32>) -> f32
impl From<Error> for Box<dyn Error + 'static, Global>
impl From<Error> for Box<dyn Error + 'static, Global>
fn from(error: Error) -> Box<dyn Error + 'static, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
impl<D> From<D> for Context<D> where
D: 'static + Display + Send + Sync,
impl<D> From<D> for Context<D> where
D: 'static + Display + Send + Sync,
fn from(display: D) -> Context<D>
impl From<Error> for Box<dyn Error + Send + Sync + 'static, Global>
impl From<Error> for Box<dyn Error + Send + Sync + 'static, Global>
fn from(error: Error) -> Box<dyn Error + Send + Sync + 'static, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
sourceimpl From<Frame> for BacktraceFrame
impl From<Frame> for BacktraceFrame
fn from(frame: Frame) -> BacktraceFrame
impl<R> From<R> for DebugPubNames<R> where
R: Reader,
impl<R> From<R> for DebugPubNames<R> where
R: Reader,
fn from(debug_pubnames_section: R) -> DebugPubNames<R>
impl<T> From<DebugInfoOffset<T>> for UnitSectionOffset<T>
impl<T> From<DebugInfoOffset<T>> for UnitSectionOffset<T>
fn from(offset: DebugInfoOffset<T>) -> UnitSectionOffset<T>
impl<R> From<R> for DebugPubTypes<R> where
R: Reader,
impl<R> From<R> for DebugPubTypes<R> where
R: Reader,
fn from(debug_pubtypes_section: R) -> DebugPubTypes<R>
impl<T> From<DebugTypesOffset<T>> for UnitSectionOffset<T>
impl<T> From<DebugTypesOffset<T>> for UnitSectionOffset<T>
fn from(offset: DebugTypesOffset<T>) -> UnitSectionOffset<T>
impl<'a> From<ValueReadError> for DecodeStringError<'a>
impl<'a> From<ValueReadError> for DecodeStringError<'a>
fn from(err: ValueReadError) -> DecodeStringError<'a>
impl From<CharRange> for CharIter
impl From<CharRange> for CharIter
sourceimpl<X> From<Range<X>> for Uniform<X> where
X: SampleUniform,
impl<X> From<Range<X>> for Uniform<X> where
X: SampleUniform,
sourceimpl<X> From<RangeInclusive<X>> for Uniform<X> where
X: SampleUniform,
impl<X> From<RangeInclusive<X>> for Uniform<X> where
X: SampleUniform,
fn from(r: RangeInclusive<X>) -> Uniform<X>
sourceimpl From<NonZeroU32> for Error
impl From<NonZeroU32> for Error
fn from(code: NonZeroU32) -> Error
sourceimpl From<NonZeroU32> for Error
impl From<NonZeroU32> for Error
fn from(code: NonZeroU32) -> Error
sourceimpl From<ChaCha8Core> for ChaCha8Rng
impl From<ChaCha8Core> for ChaCha8Rng
fn from(core: ChaCha8Core) -> ChaCha8Rng
sourceimpl From<ChaCha20Core> for ChaCha20Rng
impl From<ChaCha20Core> for ChaCha20Rng
fn from(core: ChaCha20Core) -> ChaCha20Rng
sourceimpl<'_> From<&'_ ChaCha20Rng> for ChaCha20Rng
impl<'_> From<&'_ ChaCha20Rng> for ChaCha20Rng
fn from(a: &ChaCha20Rng) -> ChaCha20Rng
sourceimpl From<ChaCha12Core> for ChaCha12Rng
impl From<ChaCha12Core> for ChaCha12Rng
fn from(core: ChaCha12Core) -> ChaCha12Rng
sourceimpl<'_> From<&'_ ChaCha8Rng> for ChaCha8Rng
impl<'_> From<&'_ ChaCha8Rng> for ChaCha8Rng
fn from(a: &ChaCha8Rng) -> ChaCha8Rng
sourceimpl<'_> From<&'_ ChaCha12Rng> for ChaCha12Rng
impl<'_> From<&'_ ChaCha12Rng> for ChaCha12Rng
fn from(a: &ChaCha12Rng) -> ChaCha12Rng
impl<S3, S4, NI> From<u128x1_sse2<S3, S4, NI>> for vec128_storage
impl<S3, S4, NI> From<u128x1_sse2<S3, S4, NI>> for vec128_storage
fn from(x: u128x1_sse2<S3, S4, NI>) -> vec128_storage
impl<W, G> From<x2<W, G>> for vec256_storage where
W: Copy,
vec128_storage: From<W>,
impl<W, G> From<x2<W, G>> for vec256_storage where
W: Copy,
vec128_storage: From<W>,
fn from(x: x2<W, G>) -> vec256_storage
impl<NI> From<x2<u32x4x2_avx2<NI>, G0>> for vec512_storage where
NI: Copy,
impl<NI> From<x2<u32x4x2_avx2<NI>, G0>> for vec512_storage where
NI: Copy,
fn from(x: x2<u32x4x2_avx2<NI>, G0>) -> vec512_storage
impl<S3, S4, NI> From<u32x4_sse2<S3, S4, NI>> for vec128_storage
impl<S3, S4, NI> From<u32x4_sse2<S3, S4, NI>> for vec128_storage
fn from(x: u32x4_sse2<S3, S4, NI>) -> vec128_storage
impl<W> From<x4<W>> for vec512_storage where
W: Copy,
vec128_storage: From<W>,
impl<W> From<x4<W>> for vec512_storage where
W: Copy,
vec128_storage: From<W>,
fn from(x: x4<W>) -> vec512_storage
impl<S3, S4, NI> From<u64x2_sse2<S3, S4, NI>> for vec128_storage
impl<S3, S4, NI> From<u64x2_sse2<S3, S4, NI>> for vec128_storage
fn from(x: u64x2_sse2<S3, S4, NI>) -> vec128_storage
impl From<Box<[u8], Global>> for Box<BStr, Global>
impl From<Box<[u8], Global>> for Box<BStr, Global>
fn from(s: Box<[u8], Global>) -> Box<BStr, Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
impl From<Box<BStr, Global>> for Box<[u8], Global>
impl From<Box<BStr, Global>> for Box<[u8], Global>
fn from(s: Box<BStr, Global>) -> Box<[u8], Global>ⓘNotable traits for Box<R, Global>impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
sourceimpl<'a> From<&'a SaltString> for Salt<'a>
impl<'a> From<&'a SaltString> for Salt<'a>
fn from(salt_string: &'a SaltString) -> Salt<'a>
sourceimpl From<InvalidLengthError> for Error
impl From<InvalidLengthError> for Error
fn from(InvalidLengthError) -> Error
sourceimpl From<InvalidEncodingError> for Error
impl From<InvalidEncodingError> for Error
fn from(InvalidEncodingError) -> Error
sourceimpl From<InvalidLengthError> for Error
impl From<InvalidLengthError> for Error
fn from(InvalidLengthError) -> Error
sourceimpl From<Errors> for ParseError
impl From<Errors> for ParseError
fn from(Errors) -> ParseError
impl<'_, T, A> From<&'_ mut [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<A> From<A> for ArrayVec<A> where
A: Array,
impl<A> From<A> for ArrayVec<A> where
A: Array,
fn from(data: A) -> ArrayVec<A>
fn from(data: A) -> ArrayVec<A>
The output has a length equal to the full array.
If you want to select a length, use
from_array_len
impl<'s, T> From<&'s mut [T]> for SliceVec<'s, T>
impl<'s, T> From<&'s mut [T]> for SliceVec<'s, T>
fn from(data: &'s mut [T]) -> SliceVec<'s, T>
fn from(data: &'s mut [T]) -> SliceVec<'s, T>
Uses the full slice as the initial length.
Example
let mut arr = [0_i32; 2];
let mut sv = SliceVec::from(&mut arr[..]);
impl From<ChildStdin> for Sender
impl From<ChildStdin> for Sender
Notes
The underlying pipe is not set to non-blocking.
fn from(stdin: ChildStdin) -> SenderⓘNotable traits for &'_ Senderimpl<'_> Write for &'_ Senderimpl Write for Sender
impl From<ChildStdout> for Receiver
impl From<ChildStdout> for Receiver
Notes
The underlying pipe is not set to non-blocking.
fn from(stdout: ChildStdout) -> ReceiverⓘNotable traits for Receiverimpl Read for Receiverimpl<'_> Read for &'_ Receiver
impl From<ChildStderr> for Receiver
impl From<ChildStderr> for Receiver
Notes
The underlying pipe is not set to non-blocking.
fn from(stderr: ChildStderr) -> ReceiverⓘNotable traits for Receiverimpl Read for Receiverimpl<'_> Read for &'_ Receiver
impl From<ParameterErrorKind> for ParameterError
impl From<ParameterErrorKind> for ParameterError
fn from(inner: ParameterErrorKind) -> ParameterError
impl From<Compression> for CompressionOptions
impl From<Compression> for CompressionOptions
fn from(compression: Compression) -> CompressionOptions
sourceimpl From<ClientBuilder> for ClientBuilder
impl From<ClientBuilder> for ClientBuilder
fn from(builder: ClientBuilder) -> ClientBuilder
sourceimpl From<InvalidMethod> for Error
impl From<InvalidMethod> for Error
fn from(err: InvalidMethod) -> Error
sourceimpl From<isize> for HeaderValue
impl From<isize> for HeaderValue
fn from(num: isize) -> HeaderValue
sourceimpl From<InvalidUriParts> for Error
impl From<InvalidUriParts> for Error
fn from(err: InvalidUriParts) -> Error
sourceimpl From<u16> for HeaderValue
impl From<u16> for HeaderValue
fn from(num: u16) -> HeaderValue
sourceimpl From<HeaderName> for HeaderValue
impl From<HeaderName> for HeaderValue
fn from(h: HeaderName) -> HeaderValue
sourceimpl<'a> From<&'a StatusCode> for StatusCode
impl<'a> From<&'a StatusCode> for StatusCode
fn from(t: &'a StatusCode) -> StatusCode
sourceimpl From<InvalidHeaderValue> for Error
impl From<InvalidHeaderValue> for Error
fn from(err: InvalidHeaderValue) -> Error
sourceimpl From<Uri> for Parts
impl From<Uri> for Parts
Convert a Uri
from parts
Examples
Relative URI
let mut parts = Parts::default();
parts.path_and_query = Some("/foo".parse().unwrap());
let uri = Uri::from_parts(parts).unwrap();
assert_eq!(uri.path(), "/foo");
assert!(uri.scheme().is_none());
assert!(uri.authority().is_none());
Absolute URI
let mut parts = Parts::default();
parts.scheme = Some("http".parse().unwrap());
parts.authority = Some("foo.com".parse().unwrap());
parts.path_and_query = Some("/foo".parse().unwrap());
let uri = Uri::from_parts(parts).unwrap();
assert_eq!(uri.scheme().unwrap().as_str(), "http");
assert_eq!(uri.authority().unwrap(), "foo.com");
assert_eq!(uri.path(), "/foo");
sourceimpl From<u64> for HeaderValue
impl From<u64> for HeaderValue
fn from(num: u64) -> HeaderValue
sourceimpl From<i64> for HeaderValue
impl From<i64> for HeaderValue
fn from(num: i64) -> HeaderValue
sourceimpl From<InvalidUri> for Error
impl From<InvalidUri> for Error
fn from(err: InvalidUri) -> Error
sourceimpl From<i32> for HeaderValue
impl From<i32> for HeaderValue
fn from(num: i32) -> HeaderValue
sourceimpl From<Infallible> for Error
impl From<Infallible> for Error
fn from(err: Infallible) -> Error
sourceimpl From<i16> for HeaderValue
impl From<i16> for HeaderValue
fn from(num: i16) -> HeaderValue
sourceimpl From<u32> for HeaderValue
impl From<u32> for HeaderValue
fn from(num: u32) -> HeaderValue
sourceimpl From<StatusCode> for u16
impl From<StatusCode> for u16
fn from(status: StatusCode) -> u16
sourceimpl<'a> From<&'a HeaderValue> for HeaderValue
impl<'a> From<&'a HeaderValue> for HeaderValue
fn from(t: &'a HeaderValue) -> HeaderValue
sourceimpl<'a> From<&'a HeaderName> for HeaderName
impl<'a> From<&'a HeaderName> for HeaderName
fn from(src: &'a HeaderName) -> HeaderName
sourceimpl From<usize> for HeaderValue
impl From<usize> for HeaderValue
fn from(num: usize) -> HeaderValue
sourceimpl From<InvalidHeaderName> for Error
impl From<InvalidHeaderName> for Error
fn from(err: InvalidHeaderName) -> Error
sourceimpl From<InvalidStatusCode> for Error
impl From<InvalidStatusCode> for Error
fn from(err: InvalidStatusCode) -> Error
sourceimpl From<ErrorKind> for InvalidUri
impl From<ErrorKind> for InvalidUri
fn from(src: ErrorKind) -> InvalidUri
sourceimpl From<ErrorKind> for InvalidUriParts
impl From<ErrorKind> for InvalidUriParts
fn from(src: ErrorKind) -> InvalidUriParts
impl From<&'static [u8]> for Bytes
impl From<&'static [u8]> for Bytes
fn from(slice: &'static [u8]) -> Bytes
impl<'a, F> From<Pin<Box<F, Global>>> for FutureObj<'a, ()> where
F: 'a + Future<Output = ()> + Send,
impl<'a, F> From<Pin<Box<F, Global>>> for FutureObj<'a, ()> where
F: 'a + Future<Output = ()> + Send,
impl<'a, T> From<FutureObj<'a, T>> for LocalFutureObj<'a, T>
impl<'a, T> From<FutureObj<'a, T>> for LocalFutureObj<'a, T>
sourceimpl<D> From<&'static [u8]> for Full<D> where
D: Buf + From<&'static [u8]>,
impl<D> From<&'static [u8]> for Full<D> where
D: Buf + From<&'static [u8]>,
sourceimpl<D, B> From<Cow<'static, B>> for Full<D> where
D: Buf + From<&'static B> + From<<B as ToOwned>::Owned>,
B: ToOwned + ?Sized,
impl<D, B> From<Cow<'static, B>> for Full<D> where
D: Buf + From<&'static B> + From<<B as ToOwned>::Owned>,
B: ToOwned + ?Sized,
impl<RW> From<BufWriter<BufReader<RW>>> for BufStream<RW>
impl<RW> From<BufWriter<BufReader<RW>>> for BufStream<RW>
fn from(b: BufWriter<BufReader<RW>>) -> BufStream<RW>
impl From<OpenOptions> for OpenOptions
impl From<OpenOptions> for OpenOptions
fn from(options: OpenOptions) -> OpenOptions
impl<RW> From<BufReader<BufWriter<RW>>> for BufStream<RW>
impl<RW> From<BufReader<BufWriter<RW>>> for BufStream<RW>
fn from(b: BufReader<BufWriter<RW>>) -> BufStream<RW>
sourceimpl From<SocketAddrV4> for SockAddr
impl From<SocketAddrV4> for SockAddr
fn from(addr: SocketAddrV4) -> SockAddr
sourceimpl From<UnixListener> for Socket
impl From<UnixListener> for Socket
sourceimpl From<SocketAddrV6> for SockAddr
impl From<SocketAddrV6> for SockAddr
fn from(addr: SocketAddrV6) -> SockAddr
sourceimpl From<UnixStream> for Socket
impl From<UnixStream> for Socket
sourceimpl<'s, S> From<&'s S> for SockRef<'s> where
S: AsRawFd,
impl<'s, S> From<&'s S> for SockRef<'s> where
S: AsRawFd,
On Windows, a corresponding From<&impl AsRawSocket>
implementation exists.
sourceimpl From<SocketAddr> for SockAddr
impl From<SocketAddr> for SockAddr
fn from(addr: SocketAddr) -> SockAddr
sourceimpl From<TcpListener> for Socket
impl From<TcpListener> for Socket
sourceimpl From<UnixDatagram> for Socket
impl From<UnixDatagram> for Socket
sourceimpl From<Socket> for TcpListener
impl From<Socket> for TcpListener
fn from(socket: Socket) -> TcpListener
impl From<&'static [u8]> for Body
impl From<&'static [u8]> for Body
fn from(slice: &'static [u8]) -> Body
sourceimpl From<Level> for LevelFilter
impl From<Level> for LevelFilter
fn from(level: Level) -> LevelFilter
sourceimpl From<Option<Level>> for LevelFilter
impl From<Option<Level>> for LevelFilter
fn from(level: Option<Level>) -> LevelFilter
sourceimpl<K, V, const N: usize> From<[(K, V); N]> for IndexMap<K, V, RandomState> where
K: Hash + Eq,
impl<K, V, const N: usize> From<[(K, V); N]> for IndexMap<K, V, RandomState> where
K: Hash + Eq,
sourceimpl<S> From<HandshakeError<S>> for HandshakeError<S>
impl<S> From<HandshakeError<S>> for HandshakeError<S>
fn from(e: HandshakeError<S>) -> HandshakeError<S>
sourceimpl From<ErrorStack> for Error
impl From<ErrorStack> for Error
fn from(e: ErrorStack) -> Error
sourceimpl<S> From<ErrorStack> for HandshakeError<S>
impl<S> From<ErrorStack> for HandshakeError<S>
fn from(e: ErrorStack) -> HandshakeError<S>
sourceimpl From<TlsConnector> for TlsConnector
impl From<TlsConnector> for TlsConnector
fn from(inner: TlsConnector) -> TlsConnector
sourceimpl From<TlsAcceptor> for TlsAcceptor
impl From<TlsAcceptor> for TlsAcceptor
fn from(inner: TlsAcceptor) -> TlsAcceptor
sourceimpl From<Ipv4AddrRange> for IpAddrRange
impl From<Ipv4AddrRange> for IpAddrRange
fn from(i: Ipv4AddrRange) -> IpAddrRangeⓘNotable traits for IpAddrRangeimpl Iterator for IpAddrRange type Item = IpAddr;
sourceimpl From<Ipv6AddrRange> for IpAddrRange
impl From<Ipv6AddrRange> for IpAddrRange
fn from(i: Ipv6AddrRange) -> IpAddrRangeⓘNotable traits for IpAddrRangeimpl Iterator for IpAddrRange type Item = IpAddr;
sourceimpl From<Ipv6Subnets> for IpSubnets
impl From<Ipv6Subnets> for IpSubnets
sourceimpl From<Ipv4Subnets> for IpSubnets
impl From<Ipv4Subnets> for IpSubnets
sourceimpl<T> From<(T, TlsConnector)> for HttpsConnector<T>
impl<T> From<(T, TlsConnector)> for HttpsConnector<T>
fn from(args: (T, TlsConnector)) -> HttpsConnector<T>
sourceimpl<T> From<T> for MaybeHttpsStream<T>
impl<T> From<T> for MaybeHttpsStream<T>
fn from(inner: T) -> MaybeHttpsStream<T>
sourceimpl<T> From<TlsStream<T>> for MaybeHttpsStream<T>
impl<T> From<TlsStream<T>> for MaybeHttpsStream<T>
fn from(inner: TlsStream<T>) -> MaybeHttpsStream<T>
sourceimpl From<StaticUser> for &'static str
impl From<StaticUser> for &'static str
fn from(x: StaticUser) -> &'static str
sourceimpl<'_derivative_strum> From<&'_derivative_strum StaticUser> for &'static str
impl<'_derivative_strum> From<&'_derivative_strum StaticUser> for &'static str
fn from(x: &'_derivative_strum StaticUser) -> &'static str
sourceimpl From<OtterOutput> for String
impl From<OtterOutput> for String
fn from(oo: OtterOutput) -> String
sourceimpl From<&'_ mut OtterOutput> for String
impl From<&'_ mut OtterOutput> for String
fn from(oo: &mut OtterOutput) -> String
Implementors
impl From<&'static str> for NotBundle
impl From<LoadError> for MgmtError
impl From<AccountsSaveError> for InternalError
impl From<AccountsSaveError> for MgmtError
impl From<Explode> for otter_api_tests::imports::anyhow::Error
impl From<Fatal> for ApiPieceOpError
impl From<Inapplicable> for ApiPieceOpError
impl From<InternalError> for LoadError
impl From<InternalError> for ApiPieceOpError
impl From<InternalError> for Fatal
impl From<InternalError> for LibraryLoadError
impl From<InternalError> for SpecError
impl From<InternalError> for MgmtError
impl From<OccultationKindAlwaysOk> for OccultationKindGeneral<(OccDisplacement, ZCoord)>
impl From<PieceUpdateOp<(), ()>> for PieceUpdateOps
impl From<SVGProcessingError> for InternalError
impl From<SVGProcessingError> for SpecError
impl From<SVGProcessingError> for MgmtError
impl From<SpecError> for MgmtError
impl From<ErrorKind> for otter_api_tests::io::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.
impl From<Infallible> for FlexiLoggerError
impl From<Infallible> for TryFromIntError
impl From<Infallible> for TryFromSliceError
impl From<ZipError> for LoadError
impl From<ZipError> for otter_api_tests::io::Error
impl From<KeyError> for MgmtError
impl From<RangeImpossible> for LogicError
impl From<Errno> for otter_api_tests::io::Error
impl From<Error> for InternalError
impl From<Error> for AccountsSaveError
impl From<Error> for InternalError
impl From<Error> for MgmtChannelWriteError
impl From<Error> for otter_api_tests::io::Error
impl From<[u8; 4]> for IpAddr
impl From<[u8; 4]> for Ipv4Addr
impl From<[u8; 16]> for IpAddr
impl From<[u8; 16]> for Ipv6Addr
impl From<[u16; 8]> for IpAddr
impl From<[u16; 8]> for Ipv6Addr
impl From<bool> for otter_api_tests::serde_json::Value
impl From<bool> for otter_api_tests::imports::toml::Value
impl From<bool> for AtomicBool
impl From<f32> for otter_api_tests::serde_json::Value
impl From<f32> for otter_api_tests::imports::toml::Value
impl From<f64> for otter_api_tests::serde_json::Value
impl From<f64> for otter_api_tests::imports::toml::Value
impl From<i8> for otter_api_tests::serde_json::Value
impl From<i8> for otter_api_tests::imports::toml::Value
impl From<i8> for Number
impl From<i8> for NotNan<f32>
impl From<i8> for NotNan<f64>
impl From<i8> for AtomicI8
impl From<i16> for otter_api_tests::serde_json::Value
impl From<i16> for Number
impl From<i16> for NotNan<f32>
impl From<i16> for NotNan<f64>
impl From<i16> for AtomicI16
impl From<i32> for otter_api_tests::serde_json::Value
impl From<i32> for otter_api_tests::imports::toml::Value
impl From<i32> for Number
impl From<i32> for ClockId
impl From<i32> for NotNan<f64>
impl From<i32> for AtomicI32
impl From<i64> for otter_api_tests::serde_json::Value
impl From<i64> for otter_api_tests::imports::toml::Value
impl From<i64> for Number
impl From<i64> for AtomicI64
impl From<isize> for otter_api_tests::serde_json::Value
impl From<isize> for Number
impl From<isize> for AtomicIsize
impl From<!> for Infallible
impl From<!> for TryFromIntError
impl From<(WhatResponseToClientOp, PieceUpdateOp<(), ()>, Vec<LogEntry, Global>)> for PieceUpdate
impl From<(Box<Item, Global>, Option<(OccultIlkName, Arc<dyn OccultedPieceTrait + 'static>)>)> for PieceSpecLoaded
impl From<u8> for otter_api_tests::serde_json::Value
impl From<u8> for otter_api_tests::imports::toml::Value
impl From<u8> for Number
impl From<u8> for FaceId
impl From<u8> for NotNan<f32>
impl From<u8> for NotNan<f64>
impl From<u8> for AtomicU8
impl From<u16> for otter_api_tests::serde_json::Value
impl From<u16> for Number
impl From<u16> for NotNan<f32>
impl From<u16> for NotNan<f64>
impl From<u16> for AtomicU16
impl From<u32> for otter_api_tests::serde_json::Value
impl From<u32> for otter_api_tests::imports::toml::Value
impl From<u32> for Number
impl From<u32> for Ipv4Addr
impl From<u32> for NotNan<f64>
impl From<u32> for AtomicU32
impl From<u64> for otter_api_tests::serde_json::Value
impl From<u64> for Number
impl From<u64> for LimbVal
impl From<u64> for AtomicU64
impl From<u128> for Ipv6Addr
impl From<()> for otter_api_tests::serde_json::Value
impl From<usize> for otter_api_tests::serde_json::Value
impl From<usize> for LibInBundleI
impl From<usize> for Number
impl From<usize> for DescId
impl From<usize> for SvgId
impl From<usize> for FaceId
impl From<usize> for Notch
impl From<usize> for AtomicUsize
impl From<Error> for InternalError
impl From<Error> for SVGProcessingError
impl From<Error> for AccountsSaveError
impl From<Error> for MgmtChannelReadError
impl From<Error> for MgmtChannelWriteError
impl From<Error> for FlexiLoggerError
impl From<Error> for ZipError
impl From<Error> for otter_api_tests::imports::tera::Error
impl From<RecvError> for RecvTimeoutError
impl From<RecvError> for TryRecvError
impl From<Error> for otter_api_tests::io::Error
impl From<Error> for otter_api_tests::imports::tera::Error
impl From<Map<String, Value>> for otter_api_tests::serde_json::Value
impl From<Number> for otter_api_tests::serde_json::Value
impl From<AuthKeysManipError> for InternalError
impl From<AuthKeysManipError> for MgmtError
impl From<Id> for KeyData
impl From<CoordinateOverflow> for InternalError
impl From<CoordinateOverflow> for MgmtError
impl From<Duration> for TimeSpec
impl From<File> for Stdio
impl From<File> for OwnedFd
impl From<Ipv4Addr> for IpAddr
impl From<Ipv6Addr> for IpAddr
impl From<PathBuf> for Arc<Path>
impl From<SubstError> for LibraryLoadError
impl From<TimeSpec> for otter_api_tests::shapelib::Duration
impl From<TryFromIntError> for Overflow
impl From<UnixStream> for OwnedFd
impl From<Utf8Error> for otter_api_tests::imports::rmp_serde::decode::Error
impl From<AccountNotFound> for MgmtError
impl From<CircleShape> for Outline
impl From<ClientId> for KeyData
impl From<GameBeingDestroyed> for Fatal
impl From<GameBeingDestroyed> for MgmtError
impl From<HtmlLit> for &'static HtmlStr
impl From<HtmlLit> for Html
impl From<OccId> for KeyData
impl From<PUOs_Simple_Modify> for PieceUpdateOps
impl From<PlayerId> for KeyData
impl From<PlayerNotFound> for ApiPieceOpError
impl From<PlayerNotFound> for Fatal
impl From<PlayerNotFound> for MgmtError
impl From<RectShape> for Outline
impl From<TokenDeliveryError> for MgmtError
impl From<UnsupportedColourSpec> for LibraryLoadError
impl From<UnsupportedColourSpec> for SpecError
impl From<VisiblePieceId> for KeyData
impl From<PathPersistError> for otter_api_tests::io::Error
impl From<PathPersistError> for TempPath
impl From<PersistError> for otter_api_tests::io::Error
impl From<PersistError> for NamedTempFile
impl From<SystemTime> for DateTime<Local>
impl From<SystemTime> for DateTime<Utc>
impl From<User> for passwd
impl From<UnixDatagram> for OwnedFd
impl From<UnixListener> for OwnedFd
impl From<OwnedFd> for otter_api_tests::shapelib::File
impl From<OwnedFd> for Stdio
impl From<OwnedFd> for UnixStream
impl From<OwnedFd> for UnixDatagram
impl From<OwnedFd> for UnixListener
impl From<Overflow> for InternalError
impl From<Overflow> for MgmtError
impl From<TotallyUnboundedRange> for LogicError
impl From<Error> for InternalError
impl From<Error> for AuthorisationError
impl From<Error> for AuthKeysManipError
impl From<Error> for TokenDeliveryError
impl From<DateTime<FixedOffset>> for DateTime<Local>
Convert a DateTime<FixedOffset>
instance into a DateTime<Local>
instance.
impl From<DateTime<FixedOffset>> for DateTime<Utc>
Convert a DateTime<FixedOffset>
instance into a DateTime<Utc>
instance.
impl From<DateTime<Local>> for DateTime<FixedOffset>
Convert a DateTime<Local>
instance into a DateTime<FixedOffset>
instance.
impl From<DateTime<Local>> for DateTime<Utc>
Convert a DateTime<Local>
instance into a DateTime<Utc>
instance.
impl From<DateTime<Utc>> for DateTime<FixedOffset>
Convert a DateTime<Utc>
instance into a DateTime<FixedOffset>
instance.
impl From<DateTime<Utc>> for DateTime<Local>
Convert a DateTime<Utc>
instance into a DateTime<Local>
instance.
impl From<GlobError> for LibraryLoadError
impl From<termios> for Termios
impl From<timespec> for TimeSpec
impl From<timeval> for TimeVal
impl From<ucred> for UnixCredentials
impl From<SetLoggerError> for FlexiLoggerError
impl From<UnixCredentials> for ucred
impl From<Termios> for termios
impl From<FloatIsNan> for otter_api_tests::io::Error
impl From<NotNan<f32>> for NotNan<f64>
impl From<KeyData> for Id
impl From<KeyData> for AccountId
impl From<KeyData> for ClientId
impl From<KeyData> for OccId
impl From<KeyData> for OccultIlkId
impl From<KeyData> for PieceId
impl From<KeyData> for PlayerId
impl From<KeyData> for VisiblePieceId
impl From<KeyData> for DefaultKey
impl From<Error> for InternalError
impl From<Error> for LibraryLoadError
impl From<Error> for FlexiLoggerError
impl From<Error> for otter_api_tests::io::Error
impl From<Datetime> for otter_api_tests::imports::toml::Value
impl From<Map<String, Value>> for otter_api_tests::imports::toml::Value
impl From<__m128> for Simd<f32, 4_usize>
impl From<__m128d> for Simd<f64, 2_usize>
impl From<__m128i> for Simd<i8, 16_usize>
impl From<__m128i> for Simd<i16, 8_usize>
impl From<__m128i> for Simd<i32, 4_usize>
impl From<__m128i> for Simd<i64, 2_usize>
impl From<__m128i> for Simd<isize, 2_usize>
impl From<__m128i> for Simd<u8, 16_usize>
impl From<__m128i> for Simd<u16, 8_usize>
impl From<__m128i> for Simd<u32, 4_usize>
impl From<__m128i> for Simd<u64, 2_usize>
impl From<__m128i> for Simd<usize, 2_usize>
impl From<__m256> for Simd<f32, 8_usize>
impl From<__m256d> for Simd<f64, 4_usize>
impl From<__m256i> for Simd<i8, 32_usize>
impl From<__m256i> for Simd<i16, 16_usize>
impl From<__m256i> for Simd<i32, 8_usize>
impl From<__m256i> for Simd<i64, 4_usize>
impl From<__m256i> for Simd<isize, 4_usize>
impl From<__m256i> for Simd<u8, 32_usize>
impl From<__m256i> for Simd<u16, 16_usize>
impl From<__m256i> for Simd<u32, 8_usize>
impl From<__m256i> for Simd<u64, 4_usize>
impl From<__m256i> for Simd<usize, 4_usize>
impl From<__m512> for Simd<f32, 16_usize>
impl From<__m512d> for Simd<f64, 8_usize>
impl From<__m512i> for Simd<i8, 64_usize>
impl From<__m512i> for Simd<i16, 32_usize>
impl From<__m512i> for Simd<i32, 16_usize>
impl From<__m512i> for Simd<i64, 8_usize>
impl From<__m512i> for Simd<isize, 8_usize>
impl From<__m512i> for Simd<u8, 64_usize>
impl From<__m512i> for Simd<u16, 32_usize>
impl From<__m512i> for Simd<u32, 16_usize>
impl From<__m512i> for Simd<u64, 8_usize>
impl From<__m512i> for Simd<usize, 8_usize>
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 NonZeroUsize
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<NonZeroU16> 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<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<ParseFloatError> for SVGProcessingError
impl From<ParseIntError> for FlexiLoggerError
impl From<Simd<f32, 4_usize>> for __m128
impl From<Simd<f32, 8_usize>> for __m256
impl From<Simd<f32, 16_usize>> for __m512
impl From<Simd<f64, 2_usize>> for __m128d
impl From<Simd<f64, 4_usize>> for __m256d
impl From<Simd<f64, 8_usize>> for __m512d
impl From<Simd<i8, 16_usize>> for __m128i
impl From<Simd<i8, 32_usize>> for __m256i
impl From<Simd<i8, 64_usize>> for __m512i
impl From<Simd<i16, 8_usize>> for __m128i
impl From<Simd<i16, 16_usize>> for __m256i
impl From<Simd<i16, 32_usize>> for __m512i
impl From<Simd<i32, 4_usize>> for __m128i
impl From<Simd<i32, 8_usize>> for __m256i
impl From<Simd<i32, 16_usize>> for __m512i
impl From<Simd<i64, 2_usize>> for __m128i
impl From<Simd<i64, 4_usize>> for __m256i
impl From<Simd<i64, 8_usize>> for __m512i
impl From<Simd<isize, 2_usize>> for __m128i
impl From<Simd<isize, 4_usize>> for __m256i
impl From<Simd<isize, 8_usize>> for __m512i
impl From<Simd<u8, 16_usize>> for __m128i
impl From<Simd<u8, 32_usize>> for __m256i
impl From<Simd<u8, 64_usize>> for __m512i
impl From<Simd<u16, 8_usize>> for __m128i
impl From<Simd<u16, 16_usize>> for __m256i
impl From<Simd<u16, 32_usize>> for __m512i
impl From<Simd<u32, 4_usize>> for __m128i
impl From<Simd<u32, 8_usize>> for __m256i
impl From<Simd<u32, 16_usize>> for __m512i
impl From<Simd<u64, 2_usize>> for __m128i
impl From<Simd<u64, 4_usize>> for __m256i
impl From<Simd<u64, 8_usize>> for __m512i
impl From<Simd<usize, 2_usize>> for __m128i
impl From<Simd<usize, 4_usize>> for __m256i
impl From<Simd<usize, 8_usize>> for __m512i
impl From<Box<Path, Global>> for PathBuf
impl From<String> for otter_api_tests::serde_json::Value
impl From<String> for otter_api_tests::imports::toml::Value
impl From<String> for Count<'static>
impl From<String> for Arc<str>
impl From<String> for PathBuf
impl From<String> for otter_api_tests::imports::tera::Error
impl From<StreamResult> for Result<MZStatus, MZError>
impl From<CString> for Arc<CStr>
impl From<NulError> for otter_api_tests::io::Error
impl From<OsString> for Arc<OsStr>
impl From<OsString> for PathBuf
impl From<SocketAddrV4> for SocketAddr
impl From<SocketAddrV6> for SocketAddr
impl From<TcpListener> for OwnedFd
impl From<TcpStream> for OwnedFd
impl From<UdpSocket> for OwnedFd
impl From<PidFd> for OwnedFd
impl From<ChildStderr> for Stdio
impl From<ChildStderr> for OwnedFd
impl From<ChildStdin> for Stdio
impl From<ChildStdin> for OwnedFd
impl From<ChildStdout> for Stdio
impl From<ChildStdout> for OwnedFd
impl From<CompressError> for otter_api_tests::io::Error
impl From<DecompressError> for otter_api_tests::io::Error
impl From<Error> for otter_api_tests::io::Error
impl From<ErrorStack> for otter_api_tests::fmt::Error
impl From<ErrorStack> for otter_api_tests::io::Error
impl From<Broken> for otter_api_tests::io::Error
impl From<SenderError> for otter_api_tests::io::Error
impl From<Socket> for UnixStream
impl From<Socket> for UnixDatagram
impl From<Socket> for UnixListener
impl From<LevelFilter> for Option<Level>
impl From<Current> for Option<Id>
impl From<Span> for Option<Id>
impl From<Error> for otter_api_tests::io::Error
impl From<DataWriteError> for otter_api_tests::io::Error
impl From<DecodingError> for otter_api_tests::io::Error
impl From<Delay> for otter_api_tests::shapelib::Duration
impl From<Elapsed> for otter_api_tests::io::Error
impl From<EncodingError> for otter_api_tests::io::Error
impl From<Error> for FlexiLoggerError
impl From<Error> for otter_api_tests::io::Error
impl From<Error> for otter_api_tests::io::Error
impl From<Errors> for Result<(), Errors>
impl From<GlobError> for otter_api_tests::io::Error
impl From<Instant> for otter_api_tests::shapelib::Instant
impl From<Instant> for otter_api_tests::shapelib::Instant
impl From<JoinError> for otter_api_tests::io::Error
impl From<MarkerReadError> for otter_api_tests::imports::rmp_serde::decode::Error
impl From<MarkerWriteError> for otter_api_tests::io::Error
impl From<NumValueReadError> for otter_api_tests::imports::rmp_serde::decode::Error
impl From<OffsetDateTime> for SystemTime
impl From<OpenSSHKeyError> for KeyError
impl From<ParserNumber> for Number
impl From<StreamResult> for Result<MZStatus, MZError>
impl From<StreamResult> for Result<MZStatus, MZError>
impl From<TimerSpec> for Expiration
impl From<ValueReadError> for otter_api_tests::imports::rmp_serde::decode::Error
impl From<ValueWriteError> for otter_api_tests::imports::rmp_serde::encode::Error
impl From<ValueWriteError> for otter_api_tests::io::Error
impl<'_> From<&'_ str> for Arc<str>
impl<'_> From<&'_ str> for otter_api_tests::imports::tera::Error
impl<'_> From<&'_ OsStr> for Arc<OsStr>
impl<'_> From<&'_ HtmlStr> for Html
impl<'_> From<&'_ ItemEnquiryData> for ItemSpec
impl<'_> From<&'_ LinksTable> for Html
impl<'_> From<&'_ group> for Group
impl<'_> From<&'_ passwd> for User
impl<'_> From<&'_ StreamResult> for Result<MZStatus, MZError>
impl<'_> From<&'_ CStr> for Arc<CStr>
impl<'_> From<&'_ Path> for Arc<Path>
impl<'_> From<&'_ StreamResult> for Result<MZStatus, MZError>
impl<'_> From<&'_ StreamResult> for Result<MZStatus, MZError>
impl<'_, T> From<&'_ T> for PathBuf where
T: AsRef<OsStr> + ?Sized,
impl<'_, T> From<&'_ [T]> for Arc<[T]> where
T: Clone,
impl<'a> From<&'a str> for otter_api_tests::serde_json::Value
impl<'a> From<&'a str> for Cow<'a, str>
impl<'a> From<&'a str> for otter_api_tests::imports::toml::Value
impl<'a> From<&'a str> for UniCase<Cow<'a, str>>
impl<'a> From<&'a str> for UniCase<String>
impl<'a> From<&'a OsStr> for Cow<'a, OsStr>
impl<'a> From<&'a PathBuf> for Cow<'a, Path>
impl<'a> From<&'a sigevent> for SigEvent
impl<'a> From<&'a UnixSocketAddr> for AddrName<'a>
impl<'a> From<&'a String> for Cow<'a, str>
impl<'a> From<&'a String> for UniCase<&'a str>
impl<'a> From<&'a CStr> for Cow<'a, CStr>
impl<'a> From<&'a CString> for Cow<'a, CStr>
impl<'a> From<&'a OsString> for Cow<'a, OsStr>
impl<'a> From<&'a Path> for Cow<'a, Path>
impl<'a> From<&'a Current> for Option<&'a Id>
impl<'a> From<&'a Current> for Option<&'static Metadata<'static>>
impl<'a> From<&'a Current> for Option<Id>
impl<'a> From<&'a Id> for Option<Id>
impl<'a> From<&'a EnteredSpan> for Option<&'a Id>
impl<'a> From<&'a EnteredSpan> for Option<Id>
impl<'a> From<&'a Span> for Option<&'a Id>
impl<'a> From<&'a Span> for Option<Id>
impl<'a> From<&'a BStr> for Cow<'a, BStr>
impl<'a> From<Cow<'a, str>> for otter_api_tests::serde_json::Value
impl<'a> From<Cow<'a, str>> for UniCase<String>
impl<'a> From<Cow<'a, Path>> for PathBuf
impl<'a> From<PathBuf> for Cow<'a, Path>
impl<'a> From<String> for Cow<'a, str>
impl<'a> From<String> for UniCase<Cow<'a, str>>
impl<'a> From<CString> for Cow<'a, CStr>
impl<'a> From<OsString> for Cow<'a, OsStr>
impl<'a> From<BString> for Cow<'a, BStr>
impl<'a> From<DecodeStringError<'a>> for otter_api_tests::imports::rmp_serde::decode::Error
impl<'a> From<PercentDecode<'a>> for Cow<'a, [u8]>
impl<'a> From<PercentEncode<'a>> for Cow<'a, str>
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, I, T> From<&'a IndexSlice<I, [T]>> for otter_api_tests::shapelib::IndexVec<I, T> where
I: Idx,
T: Clone,
impl<'a, I, T> From<&'a mut IndexSlice<I, [T]>> for otter_api_tests::shapelib::IndexVec<I, T> where
I: Idx,
T: Clone,
impl<'a, I, T> From<Cow<'a, IndexSlice<I, [T]>>> for otter_api_tests::shapelib::IndexVec<I, T> where
I: Idx,
IndexSlice<I, [T]>: ToOwned,
<IndexSlice<I, [T]> as ToOwned>::Owned == IndexVec<I, T>,
impl<'a, I, T> From<&'a [T]> for &'a IndexSlice<I, [T]> where
I: Idx,
impl<'a, I, T> From<&'a mut [T]> for &'a mut IndexSlice<I, [T]> where
I: Idx,
impl<'a, T> From<&'a Option<T>> for Option<&'a T>
impl<'a, T> From<&'a [T; 1]> for &'a GenericArray<T, UInt<UTerm, B1>>
impl<'a, T> From<&'a [T; 2]> for &'a GenericArray<T, UInt<UInt<UTerm, B1>, B0>>
impl<'a, T> From<&'a [T; 3]> for &'a GenericArray<T, UInt<UInt<UTerm, B1>, B1>>
impl<'a, T> From<&'a [T; 4]> for &'a GenericArray<T, UInt<UInt<UInt<UTerm, B1>, B0>, B0>>
impl<'a, T> From<&'a [T; 5]> for &'a GenericArray<T, UInt<UInt<UInt<UTerm, B1>, B0>, B1>>
impl<'a, T> From<&'a [T; 6]> for &'a GenericArray<T, UInt<UInt<UInt<UTerm, B1>, B1>, B0>>
impl<'a, T> From<&'a [T; 7]> for &'a GenericArray<T, UInt<UInt<UInt<UTerm, B1>, B1>, B1>>
impl<'a, T> From<&'a [T; 8]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>
impl<'a, T> From<&'a [T; 9]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>>
impl<'a, T> From<&'a [T; 10]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>>
impl<'a, T> From<&'a [T; 11]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>>
impl<'a, T> From<&'a [T; 12]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>>
impl<'a, T> From<&'a [T; 13]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>>
impl<'a, T> From<&'a [T; 14]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>>
impl<'a, T> From<&'a [T; 15]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>>
impl<'a, T> From<&'a [T; 16]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>>
impl<'a, T> From<&'a [T; 17]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>>
impl<'a, T> From<&'a [T; 18]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>>
impl<'a, T> From<&'a [T; 19]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>>
impl<'a, T> From<&'a [T; 20]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>>
impl<'a, T> From<&'a [T; 21]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>>
impl<'a, T> From<&'a [T; 22]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>>
impl<'a, T> From<&'a [T; 23]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>>
impl<'a, T> From<&'a [T; 24]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>>
impl<'a, T> From<&'a [T; 25]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>>
impl<'a, T> From<&'a [T; 26]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>>
impl<'a, T> From<&'a [T; 27]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>>
impl<'a, T> From<&'a [T; 28]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>>
impl<'a, T> From<&'a [T; 29]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>>
impl<'a, T> From<&'a [T; 30]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>>
impl<'a, T> From<&'a [T; 31]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>>
impl<'a, T> From<&'a [T; 32]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>>
impl<'a, T> From<&'a [T; 33]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B1>>
impl<'a, T> From<&'a [T; 34]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B0>>
impl<'a, T> From<&'a [T; 35]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B1>>
impl<'a, T> From<&'a [T; 36]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B0>>
impl<'a, T> From<&'a [T; 37]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B1>>
impl<'a, T> From<&'a [T; 38]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>, B0>>
impl<'a, T> From<&'a [T; 39]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>, B1>>
impl<'a, T> From<&'a [T; 40]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B0>>
impl<'a, T> From<&'a [T; 41]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B1>>
impl<'a, T> From<&'a [T; 42]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>, B0>>
impl<'a, T> From<&'a [T; 43]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>, B1>>
impl<'a, T> From<&'a [T; 44]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B0>>
impl<'a, T> From<&'a [T; 45]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B1>>
impl<'a, T> From<&'a [T; 46]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>, B0>>
impl<'a, T> From<&'a [T; 47]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>, B1>>
impl<'a, T> From<&'a [T; 48]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0>>
impl<'a, T> From<&'a [T; 49]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B1>>
impl<'a, T> From<&'a [T; 50]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>>
impl<'a, T> From<&'a [T; 51]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B1>>
impl<'a, T> From<&'a [T; 52]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>, B0>>
impl<'a, T> From<&'a [T; 53]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>, B1>>
impl<'a, T> From<&'a [T; 54]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>, B0>>
impl<'a, T> From<&'a [T; 55]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>, B1>>
impl<'a, T> From<&'a [T; 56]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B0>>
impl<'a, T> From<&'a [T; 57]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B1>>
impl<'a, T> From<&'a [T; 58]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>, B0>>
impl<'a, T> From<&'a [T; 59]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>, B1>>
impl<'a, T> From<&'a [T; 60]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>, B0>>
impl<'a, T> From<&'a [T; 61]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>, B1>>
impl<'a, T> From<&'a [T; 62]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B0>>
impl<'a, T> From<&'a [T; 63]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B1>>
impl<'a, T> From<&'a [T; 64]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>>
impl<'a, T> From<&'a [T; 70]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B1>, B0>>
impl<'a, T> From<&'a [T; 80]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B0>, B0>>
impl<'a, T> From<&'a [T; 90]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B1>, B0>>
impl<'a, T> From<&'a [T; 100]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>, B0>>
impl<'a, T> From<&'a [T; 128]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>
impl<'a, T> From<&'a [T; 200]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B0>>
impl<'a, T> From<&'a [T; 256]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>
impl<'a, T> From<&'a [T; 300]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B1>, B1>, B0>, B0>>
impl<'a, T> From<&'a [T; 400]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B0>, B0>>
impl<'a, T> From<&'a [T; 500]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B0>>
impl<'a, T> From<&'a [T; 512]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>
impl<'a, T> From<&'a [T; 1000]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B0>, B0>>
impl<'a, T> From<&'a [T; 1024]> for &'a GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>
impl<'a, T> From<&'a GenericArray<u8, <T as OutputSizeUser>::OutputSize>> for CtOutput<T> where
T: OutputSizeUser,
impl<'a, T> From<&'a Vec<T, Global>> for Cow<'a, [T]> where
T: Clone,
impl<'a, T> From<&'a mut Option<T>> for Option<&'a mut T>
impl<'a, T> From<&'a mut [T; 1]> for &'a mut GenericArray<T, UInt<UTerm, B1>>
impl<'a, T> From<&'a mut [T; 2]> for &'a mut GenericArray<T, UInt<UInt<UTerm, B1>, B0>>
impl<'a, T> From<&'a mut [T; 3]> for &'a mut GenericArray<T, UInt<UInt<UTerm, B1>, B1>>
impl<'a, T> From<&'a mut [T; 4]> for &'a mut GenericArray<T, UInt<UInt<UInt<UTerm, B1>, B0>, B0>>
impl<'a, T> From<&'a mut [T; 5]> for &'a mut GenericArray<T, UInt<UInt<UInt<UTerm, B1>, B0>, B1>>
impl<'a, T> From<&'a mut [T; 6]> for &'a mut GenericArray<T, UInt<UInt<UInt<UTerm, B1>, B1>, B0>>
impl<'a, T> From<&'a mut [T; 7]> for &'a mut GenericArray<T, UInt<UInt<UInt<UTerm, B1>, B1>, B1>>
impl<'a, T> From<&'a mut [T; 8]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>
impl<'a, T> From<&'a mut [T; 9]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>>
impl<'a, T> From<&'a mut [T; 10]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>>
impl<'a, T> From<&'a mut [T; 11]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>>
impl<'a, T> From<&'a mut [T; 12]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>>
impl<'a, T> From<&'a mut [T; 13]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>>
impl<'a, T> From<&'a mut [T; 14]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>>
impl<'a, T> From<&'a mut [T; 15]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>>
impl<'a, T> From<&'a mut [T; 16]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>>
impl<'a, T> From<&'a mut [T; 17]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>>
impl<'a, T> From<&'a mut [T; 18]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>>
impl<'a, T> From<&'a mut [T; 19]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>>
impl<'a, T> From<&'a mut [T; 20]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>>
impl<'a, T> From<&'a mut [T; 21]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>>
impl<'a, T> From<&'a mut [T; 22]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>>
impl<'a, T> From<&'a mut [T; 23]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>>
impl<'a, T> From<&'a mut [T; 24]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>>
impl<'a, T> From<&'a mut [T; 25]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>>
impl<'a, T> From<&'a mut [T; 26]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>>
impl<'a, T> From<&'a mut [T; 27]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>>
impl<'a, T> From<&'a mut [T; 28]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>>
impl<'a, T> From<&'a mut [T; 29]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>>
impl<'a, T> From<&'a mut [T; 30]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>>
impl<'a, T> From<&'a mut [T; 31]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>>
impl<'a, T> From<&'a mut [T; 32]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>>
impl<'a, T> From<&'a mut [T; 33]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B1>>
impl<'a, T> From<&'a mut [T; 34]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B0>>
impl<'a, T> From<&'a mut [T; 35]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B1>>
impl<'a, T> From<&'a mut [T; 36]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B0>>
impl<'a, T> From<&'a mut [T; 37]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B1>>
impl<'a, T> From<&'a mut [T; 38]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>, B0>>
impl<'a, T> From<&'a mut [T; 39]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>, B1>>
impl<'a, T> From<&'a mut [T; 40]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B0>>
impl<'a, T> From<&'a mut [T; 41]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B1>>
impl<'a, T> From<&'a mut [T; 42]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>, B0>>
impl<'a, T> From<&'a mut [T; 43]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>, B1>>
impl<'a, T> From<&'a mut [T; 44]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B0>>
impl<'a, T> From<&'a mut [T; 45]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B1>>
impl<'a, T> From<&'a mut [T; 46]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>, B0>>
impl<'a, T> From<&'a mut [T; 47]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>, B1>>
impl<'a, T> From<&'a mut [T; 48]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0>>
impl<'a, T> From<&'a mut [T; 49]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B1>>
impl<'a, T> From<&'a mut [T; 50]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>>
impl<'a, T> From<&'a mut [T; 51]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B1>>
impl<'a, T> From<&'a mut [T; 52]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>, B0>>
impl<'a, T> From<&'a mut [T; 53]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>, B1>>
impl<'a, T> From<&'a mut [T; 54]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>, B0>>
impl<'a, T> From<&'a mut [T; 55]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>, B1>>
impl<'a, T> From<&'a mut [T; 56]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B0>>
impl<'a, T> From<&'a mut [T; 57]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B1>>
impl<'a, T> From<&'a mut [T; 58]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>, B0>>
impl<'a, T> From<&'a mut [T; 59]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>, B1>>
impl<'a, T> From<&'a mut [T; 60]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>, B0>>
impl<'a, T> From<&'a mut [T; 61]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>, B1>>
impl<'a, T> From<&'a mut [T; 62]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B0>>
impl<'a, T> From<&'a mut [T; 63]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B1>>
impl<'a, T> From<&'a mut [T; 64]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>>
impl<'a, T> From<&'a mut [T; 70]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B1>, B0>>
impl<'a, T> From<&'a mut [T; 80]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B0>, B0>>
impl<'a, T> From<&'a mut [T; 90]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B1>, B0>>
impl<'a, T> From<&'a mut [T; 100]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>, B0>>
impl<'a, T> From<&'a mut [T; 128]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>
impl<'a, T> From<&'a mut [T; 200]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B0>>
impl<'a, T> From<&'a mut [T; 256]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>
impl<'a, T> From<&'a mut [T; 300]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B1>, B1>, B0>, B0>>
impl<'a, T> From<&'a mut [T; 400]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B0>, B0>>
impl<'a, T> From<&'a mut [T; 500]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B0>>
impl<'a, T> From<&'a mut [T; 512]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>
impl<'a, T> From<&'a mut [T; 1000]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B0>, B0>>
impl<'a, T> From<&'a mut [T; 1024]> for &'a mut GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>
impl<'a, T> From<&'a T> for &'a OrderedFloat<T> where
T: Float,
impl<'a, T> From<&'a mut T> for &'a mut OrderedFloat<T> where
T: Float,
impl<'a, T> From<&'a [T]> for otter_api_tests::serde_json::Value where
T: Clone + Into<Value>,
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, T> From<T> for Env<'a> where
T: Into<Cow<'a, str>>,
impl<'a, T, N> From<&'a [T]> for &'a GenericArray<T, N> where
N: ArrayLength<T>,
impl<'a, T, N> From<&'a mut [T]> for &'a mut GenericArray<T, N> where
N: ArrayLength<T>,
impl<'e, E: Into<Box<dyn Error + 'e>>> From<E> for Explode
impl<'i, P, II, I> From<I> for PermSet<P> where
P: Perm,
II: Borrow<P>,
I: IntoIterator<Item = II>,
impl<'i, T: AsRef<str> + 'i, U: AsRef<str> + 'i, L: IntoIterator<Item = &'i (T, U)>> From<L> for Subst
impl<'key> From<Key<'key>> for Cow<'static, str>
impl<'s> From<&'s str> for &'s RawTokenVal
impl<'t> From<&'t str> for Count<'t>
impl<'t> From<()> for Count<'t>
impl<'t> From<Match<'t>> for Range<usize>
impl<'t> From<Match<'t>> for Range<usize>
impl<A> From<(A,)> for Zip<(<A as IntoIterator>::IntoIter,)> where
A: IntoIterator,
impl<A, B> From<(A, B)> for Zip<(<A as IntoIterator>::IntoIter, <B as IntoIterator>::IntoIter)> where
A: IntoIterator,
B: IntoIterator,
impl<A, B, C> From<(A, B, C)> for Zip<(<A as IntoIterator>::IntoIter, <B as IntoIterator>::IntoIter, <C as IntoIterator>::IntoIter)> where
A: IntoIterator,
B: IntoIterator,
C: IntoIterator,
impl<A, B, C, D> From<(A, B, C, D)> for Zip<(<A as IntoIterator>::IntoIter, <B as IntoIterator>::IntoIter, <C as IntoIterator>::IntoIter, <D as IntoIterator>::IntoIter)> where
A: IntoIterator,
B: IntoIterator,
C: IntoIterator,
D: IntoIterator,
impl<A, B, C, D, E> From<(A, B, C, D, E)> for Zip<(<A as IntoIterator>::IntoIter, <B as IntoIterator>::IntoIter, <C as IntoIterator>::IntoIter, <D as IntoIterator>::IntoIter, <E as IntoIterator>::IntoIter)> where
A: IntoIterator,
B: IntoIterator,
C: IntoIterator,
D: IntoIterator,
E: IntoIterator,
impl<A, B, C, D, E, F> From<(A, B, C, D, E, F)> for Zip<(<A as IntoIterator>::IntoIter, <B as IntoIterator>::IntoIter, <C as IntoIterator>::IntoIter, <D as IntoIterator>::IntoIter, <E as IntoIterator>::IntoIter, <F as IntoIterator>::IntoIter)> where
A: IntoIterator,
B: IntoIterator,
C: IntoIterator,
D: IntoIterator,
E: IntoIterator,
F: IntoIterator,
impl<A, B, C, D, E, F, G> From<(A, B, C, D, E, F, G)> for Zip<(<A as IntoIterator>::IntoIter, <B as IntoIterator>::IntoIter, <C as IntoIterator>::IntoIter, <D as IntoIterator>::IntoIter, <E as IntoIterator>::IntoIter, <F as IntoIterator>::IntoIter, <G as IntoIterator>::IntoIter)> where
A: IntoIterator,
B: IntoIterator,
C: IntoIterator,
D: IntoIterator,
E: IntoIterator,
F: IntoIterator,
G: IntoIterator,
impl<A, B, C, D, E, F, G, H> From<(A, B, C, D, E, F, G, H)> for Zip<(<A as IntoIterator>::IntoIter, <B as IntoIterator>::IntoIter, <C as IntoIterator>::IntoIter, <D as IntoIterator>::IntoIter, <E as IntoIterator>::IntoIter, <F as IntoIterator>::IntoIter, <G as IntoIterator>::IntoIter, <H as IntoIterator>::IntoIter)> where
A: IntoIterator,
B: IntoIterator,
C: IntoIterator,
D: IntoIterator,
E: IntoIterator,
F: IntoIterator,
G: IntoIterator,
H: IntoIterator,
impl<A, B, C, D, E, F, G, H, I> From<(A, B, C, D, E, F, G, H, I)> for Zip<(<A as IntoIterator>::IntoIter, <B as IntoIterator>::IntoIter, <C as IntoIterator>::IntoIter, <D as IntoIterator>::IntoIter, <E as IntoIterator>::IntoIter, <F as IntoIterator>::IntoIter, <G as IntoIterator>::IntoIter, <H as IntoIterator>::IntoIter, <I as IntoIterator>::IntoIter)> where
A: IntoIterator,
B: IntoIterator,
C: IntoIterator,
D: IntoIterator,
E: IntoIterator,
F: IntoIterator,
G: IntoIterator,
H: IntoIterator,
I: IntoIterator,
impl<A, B, C, D, E, F, G, H, I, J> From<(A, B, C, D, E, F, G, H, I, J)> for Zip<(<A as IntoIterator>::IntoIter, <B as IntoIterator>::IntoIter, <C as IntoIterator>::IntoIter, <D as IntoIterator>::IntoIter, <E as IntoIterator>::IntoIter, <F as IntoIterator>::IntoIter, <G as IntoIterator>::IntoIter, <H as IntoIterator>::IntoIter, <I as IntoIterator>::IntoIter, <J as IntoIterator>::IntoIter)> where
A: IntoIterator,
B: IntoIterator,
C: IntoIterator,
D: IntoIterator,
E: IntoIterator,
F: IntoIterator,
G: IntoIterator,
H: IntoIterator,
I: IntoIterator,
J: IntoIterator,
impl<A, B, C, D, E, F, G, H, I, J, K> From<(A, B, C, D, E, F, G, H, I, J, K)> for Zip<(<A as IntoIterator>::IntoIter, <B as IntoIterator>::IntoIter, <C as IntoIterator>::IntoIter, <D as IntoIterator>::IntoIter, <E as IntoIterator>::IntoIter, <F as IntoIterator>::IntoIter, <G as IntoIterator>::IntoIter, <H as IntoIterator>::IntoIter, <I as IntoIterator>::IntoIter, <J as IntoIterator>::IntoIter, <K as IntoIterator>::IntoIter)> where
A: IntoIterator,
B: IntoIterator,
C: IntoIterator,
D: IntoIterator,
E: IntoIterator,
F: IntoIterator,
G: IntoIterator,
H: IntoIterator,
I: IntoIterator,
J: IntoIterator,
K: IntoIterator,
impl<A, B, C, D, E, F, G, H, I, J, K, L> From<(A, B, C, D, E, F, G, H, I, J, K, L)> for Zip<(<A as IntoIterator>::IntoIter, <B as IntoIterator>::IntoIter, <C as IntoIterator>::IntoIter, <D as IntoIterator>::IntoIter, <E as IntoIterator>::IntoIter, <F as IntoIterator>::IntoIter, <G as IntoIterator>::IntoIter, <H as IntoIterator>::IntoIter, <I as IntoIterator>::IntoIter, <J as IntoIterator>::IntoIter, <K as IntoIterator>::IntoIter, <L as IntoIterator>::IntoIter)> where
A: IntoIterator,
B: IntoIterator,
C: IntoIterator,
D: IntoIterator,
E: IntoIterator,
F: IntoIterator,
G: IntoIterator,
H: IntoIterator,
I: IntoIterator,
J: IntoIterator,
K: IntoIterator,
L: IntoIterator,
impl<E> From<E> for otter_api_tests::imports::anyhow::Error where
E: 'static + Error + Send + Sync,
impl<I> From<(I, u16)> for SocketAddr where
I: Into<IpAddr>,
impl<I, T> From<Box<IndexSlice<I, [T]>, Global>> for otter_api_tests::shapelib::IndexVec<I, T> where
I: Idx,
impl<I, T> From<Vec<T, Global>> for otter_api_tests::shapelib::IndexVec<I, T> where
I: Idx,
impl<K, V, const N: usize> From<[(K, V); N]> for BTreeMap<K, V> where
K: Ord,
impl<K, V, const N: usize> From<[(K, V); N]> for HashMap<K, V, RandomState> where
K: Eq + Hash,
impl<L, R> From<Result<R, L>> for Either<L, R>
Convert from Result
to Either
with Ok => Right
and Err => Left
.
impl<P> From<LoadedAcl<P>> for Acl<P> where
P: Perm,
impl<P> From<Acl<P>> for LoadedAcl<P> where
P: Perm,
impl<R, G, T> From<T> for ReentrantMutex<R, G, T> where
R: RawMutex,
G: GetThreadId,
impl<R, T> From<T> for otter_api_tests::imports::parking_lot::lock_api::Mutex<R, T> where
R: RawMutex,
impl<R, T> From<T> for otter_api_tests::imports::parking_lot::lock_api::RwLock<R, T> where
R: RawRwLock,
impl<S> From<Ascii<S>> for UniCase<S>
impl<S> From<S> for UniCase<S> where
S: AsRef<str>,
impl<S, V> From<BTreeMap<S, V>> for otter_api_tests::imports::toml::Value where
S: Into<String>,
V: Into<Value>,
impl<S, V> From<HashMap<S, V, RandomState>> for otter_api_tests::imports::toml::Value where
S: Into<String> + Hash + Eq,
V: Into<Value>,
impl<T> From<[T; 1]> for GenericArray<T, UInt<UTerm, B1>>
impl<T> From<[T; 2]> for OldNew<T>
impl<T> From<[T; 2]> for GenericArray<T, UInt<UInt<UTerm, B1>, B0>>
impl<T> From<[T; 3]> for GenericArray<T, UInt<UInt<UTerm, B1>, B1>>
impl<T> From<[T; 4]> for GenericArray<T, UInt<UInt<UInt<UTerm, B1>, B0>, B0>>
impl<T> From<[T; 5]> for GenericArray<T, UInt<UInt<UInt<UTerm, B1>, B0>, B1>>
impl<T> From<[T; 6]> for GenericArray<T, UInt<UInt<UInt<UTerm, B1>, B1>, B0>>
impl<T> From<[T; 7]> for GenericArray<T, UInt<UInt<UInt<UTerm, B1>, B1>, B1>>
impl<T> From<[T; 8]> for GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>
impl<T> From<[T; 9]> for GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>>
impl<T> From<[T; 10]> for GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>>
impl<T> From<[T; 11]> for GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>>
impl<T> From<[T; 12]> for GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>>
impl<T> From<[T; 13]> for GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>>
impl<T> From<[T; 14]> for GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>>
impl<T> From<[T; 15]> for GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>>
impl<T> From<[T; 16]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>>
impl<T> From<[T; 17]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>>
impl<T> From<[T; 18]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>>
impl<T> From<[T; 19]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>>
impl<T> From<[T; 20]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>>
impl<T> From<[T; 21]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>>
impl<T> From<[T; 22]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>>
impl<T> From<[T; 23]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>>
impl<T> From<[T; 24]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>>
impl<T> From<[T; 25]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>>
impl<T> From<[T; 26]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>>
impl<T> From<[T; 27]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>>
impl<T> From<[T; 28]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>>
impl<T> From<[T; 29]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>>
impl<T> From<[T; 30]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>>
impl<T> From<[T; 31]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>>
impl<T> From<[T; 32]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>>
impl<T> From<[T; 33]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B1>>
impl<T> From<[T; 34]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B0>>
impl<T> From<[T; 35]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B1>>
impl<T> From<[T; 36]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B0>>
impl<T> From<[T; 37]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B1>>
impl<T> From<[T; 38]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>, B0>>
impl<T> From<[T; 39]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>, B1>>
impl<T> From<[T; 40]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B0>>
impl<T> From<[T; 41]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B1>>
impl<T> From<[T; 42]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>, B0>>
impl<T> From<[T; 43]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>, B1>>
impl<T> From<[T; 44]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B0>>
impl<T> From<[T; 45]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B1>>
impl<T> From<[T; 46]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>, B0>>
impl<T> From<[T; 47]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>, B1>>
impl<T> From<[T; 48]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0>>
impl<T> From<[T; 49]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B1>>
impl<T> From<[T; 50]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>>
impl<T> From<[T; 51]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B1>>
impl<T> From<[T; 52]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>, B0>>
impl<T> From<[T; 53]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>, B1>>
impl<T> From<[T; 54]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>, B0>>
impl<T> From<[T; 55]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>, B1>>
impl<T> From<[T; 56]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B0>>
impl<T> From<[T; 57]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B1>>
impl<T> From<[T; 58]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>, B0>>
impl<T> From<[T; 59]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>, B1>>
impl<T> From<[T; 60]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>, B0>>
impl<T> From<[T; 61]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>, B1>>
impl<T> From<[T; 62]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B0>>
impl<T> From<[T; 63]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B1>>
impl<T> From<[T; 64]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>>
impl<T> From<[T; 70]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B1>, B0>>
impl<T> From<[T; 80]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B0>, B0>>
impl<T> From<[T; 90]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B1>, B0>>
impl<T> From<[T; 100]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>, B0>>
impl<T> From<[T; 128]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>
impl<T> From<[T; 200]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B0>>
impl<T> From<[T; 256]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>
impl<T> From<[T; 300]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B1>, B1>, B0>, B0>>
impl<T> From<[T; 400]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B0>, B0>>
impl<T> From<[T; 500]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B0>>
impl<T> From<[T; 512]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>
impl<T> From<[T; 1000]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B0>, B0>>
impl<T> From<[T; 1024]> for GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>
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<SendError<T>> for otter_api_tests::mpsc::TrySendError<T>
impl<T> From<Authorisation<Global>> for Authorisation<T> where
T: Serialize,
impl<T> From<PosOffTableError<T>> for SpecError where
T: Debug,
impl<T> From<PosOffTableError<T>> for MgmtError where
T: Debug,
impl<T> From<GenericArray<u8, <T as OutputSizeUser>::OutputSize>> for CtOutput<T> where
T: OutputSizeUser,
impl<T> From<Box<T, Global>> for Arc<T> where
T: ?Sized,
impl<T> From<Vec<T, Global>> for otter_api_tests::serde_json::Value where
T: Into<Value>,
impl<T> From<Vec<T, Global>> for Arc<[T]>
impl<T> From<CtOption<T>> for Option<T>
impl<T> From<T> for Option<T>
impl<T> From<T> for Poll<T>
impl<T> From<T> for Count<'static> where
T: Enum,
impl<T> From<T> for Arc<T>
impl<T> From<T> for OrderedFloat<T> where
T: Float,
impl<T> From<T> for RefCell<T>
impl<T> From<T> for otter_api_tests::imports::once_cell::sync::OnceCell<T>
impl<T> From<T> for otter_api_tests::imports::once_cell::unsync::OnceCell<T>
impl<T> From<T> for Cell<T>
impl<T> From<T> for UnsafeCell<T>
impl<T> From<T> for otter_api_tests::imports::inventory::core::lazy::OnceCell<T>
impl<T> From<T> for T
impl<T, A> From<Box<T, A>> for Pin<Box<T, A>> where
A: Allocator + 'static,
T: ?Sized,
impl<T, A> From<Vec<T, A>> for VecDeque<T, A> where
A: Allocator,
impl<T, A> From<T> for Unauthorised<T, A>
impl<T, const CAP: usize> From<[T; CAP]> for otter_api_tests::shapelib::ArrayVec<T, CAP>
Create an ArrayVec
from an array.
use arrayvec::ArrayVec;
let mut array = ArrayVec::from([1, 2, 3]);
assert_eq!(array.len(), 3);
assert_eq!(array.capacity(), 3);