Trait otter_api_tests::imports::failure::_core::convert::From 1.0.0[−][src]
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. If the conversion can fail, 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
pub 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]
pub 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]Converts a SocketAddrV6
into a SocketAddr::V6
.
pub 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]
pub 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]Creates a boxed Path
from a reference.
This will allocate and clone path
to it.
Creates a new instance of an RwLock<T>
which is unlocked.
This is equivalent to RwLock::new
.
pub 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]pub fn from(err: &str) -> Box<dyn Error + 'a + Sync + Send, 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]
pub fn from(err: &str) -> Box<dyn Error + 'a + Sync + Send, 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]pub 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]
pub 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]pub 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]
pub 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]Creates a boxed Path
from a clone-on-write pointer.
Converting from a Cow::Owned
does not clone or allocate.
pub 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]
pub 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]Converts a type of Error
into a box of dyn Error
.
Examples
use std::error::Error; use std::fmt; use std::mem; #[derive(Debug)] struct AnError; impl fmt::Display for AnError { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f , "An error") } } impl Error for AnError {} let an_error = AnError; assert!(0 == mem::size_of_val(&an_error)); let a_boxed_error = Box::<dyn Error>::from(an_error); assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))
Creates an Ipv6Addr
from an eight element 16-bit array.
Examples
use std::net::Ipv6Addr; let addr = Ipv6Addr::from([ 525u16, 524u16, 523u16, 522u16, 521u16, 520u16, 519u16, 518u16, ]); assert_eq!( Ipv6Addr::new( 0x20d, 0x20c, 0x20b, 0x20a, 0x209, 0x208, 0x207, 0x206 ), addr );
Creates an IpAddr::V6
from a sixteen element byte array.
Examples
use std::net::{IpAddr, Ipv6Addr}; let addr = IpAddr::from([ 25u8, 24u8, 23u8, 22u8, 21u8, 20u8, 19u8, 18u8, 17u8, 16u8, 15u8, 14u8, 13u8, 12u8, 11u8, 10u8, ]); assert_eq!( IpAddr::V6(Ipv6Addr::new( 0x1918, 0x1716, 0x1514, 0x1312, 0x1110, 0x0f0e, 0x0d0c, 0x0b0a )), addr );
pub 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]
pub 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]Creates an IpAddr::V6
from an eight element 16-bit array.
Examples
use std::net::{IpAddr, Ipv6Addr}; let addr = IpAddr::from([ 525u16, 524u16, 523u16, 522u16, 521u16, 520u16, 519u16, 518u16, ]); assert_eq!( IpAddr::V6(Ipv6Addr::new( 0x20d, 0x20c, 0x20b, 0x20a, 0x209, 0x208, 0x207, 0x206 )), addr );
pub fn from(err: E) -> Box<dyn Error + 'a + Sync + Send, 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]
pub fn from(err: E) -> Box<dyn Error + 'a + Sync + Send, 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]Converts a type of Error
+ Send
+ Sync
into a box of
dyn Error
+ Send
+ Sync
.
Examples
use std::error::Error; use std::fmt; use std::mem; #[derive(Debug)] struct AnError; impl fmt::Display for AnError { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f , "An error") } } impl Error for AnError {} unsafe impl Send for AnError {} unsafe impl Sync for AnError {} let an_error = AnError; assert!(0 == mem::size_of_val(&an_error)); let a_boxed_error = Box::<dyn Error + Send + Sync>::from(an_error); assert!( mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))
pub 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]Converts a SocketAddrV4
into a SocketAddr::V4
.
Creates an Ipv6Addr
from a sixteen element byte array.
Examples
use std::net::Ipv6Addr; let addr = Ipv6Addr::from([ 25u8, 24u8, 23u8, 22u8, 21u8, 20u8, 19u8, 18u8, 17u8, 16u8, 15u8, 14u8, 13u8, 12u8, 11u8, 10u8, ]); assert_eq!( Ipv6Addr::new( 0x1918, 0x1716, 0x1514, 0x1312, 0x1110, 0x0f0e, 0x0d0c, 0x0b0a ), addr );
pub fn from(err: Cow<'b, str>) -> Box<dyn Error + 'a + Sync + Send, 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]
pub fn from(err: Cow<'b, str>) -> Box<dyn Error + 'a + Sync + Send, 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]Converts a Cow
into a box of dyn Error
+ Send
+ Sync
.
Examples
use std::error::Error; use std::mem; use std::borrow::Cow; let a_cow_str_error = Cow::from("a str error"); let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_cow_str_error); assert!( mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))
Converts a tuple struct (Into<IpAddr
>, u16
) into a SocketAddr
.
This conversion creates a SocketAddr::V4
for a IpAddr::V4
and creates a SocketAddr::V6
for a IpAddr::V6
.
u16
is treated as port of the newly created SocketAddr
.
pub 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]pub 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]
pub 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]Converts a PathBuf
into a Box<Path>
This conversion currently should not allocate memory, but this behavior is not guaranteed on all platforms or in all future versions.
Creates a new mutex in an unlocked state ready for use.
This is equivalent to Mutex::new
.
pub 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]
pub 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]pub 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]
pub 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]pub fn from(err: String) -> Box<dyn Error + 'static + Sync + Send, 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]
pub fn from(err: String) -> Box<dyn Error + 'static + Sync + Send, 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]Converts a String
into a box of dyn Error
+ Send
+ Sync
.
Examples
use std::error::Error; use std::mem; let a_string_error = "a string error".to_string(); let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_string_error); assert!( mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))
pub 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]Converts a NonZeroU32
into an u32
Converts a NonZeroU16
into an u16
Converts a NonZeroU128
into an u128
Converts a NonZeroI64
into an i64
Converts a NonZeroI16
into an i16
Converts a NonZeroUsize
into an usize
Converts a NonZeroI32
into an i32
Converts a NonZeroIsize
into an isize
Converts a NonZeroU64
into an u64
Converts a NonZeroI128
into an i128
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.
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));
pub 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]
pub 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]Converts a &[T]
into a Box<[T]>
This conversion allocates on the heap
and performs a copy of slice
.
Examples
// create a &[u8] which will be used to create a Box<[u8]> let slice: &[u8] = &[104, 101, 108, 108, 111]; let boxed_slice: Box<[u8]> = Box::from(slice); println!("{:?}", boxed_slice);
Converts a Vec<T>
into a BinaryHeap<T>
.
This conversion happens in-place, and has O(n) time complexity.
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]);
pub 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]pub 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]
pub 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]Converts a generic type T
into a Box<T>
The conversion allocates on the heap and moves t
from the stack into it.
Examples
let x = 5; let boxed = Box::new(5); assert_eq!(Box::from(x), boxed);
pub 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]
pub 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]pub 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]
pub 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]Converts a Box<str>
into a Box<[u8]>
This conversion does not allocate on the heap and happens in place.
Examples
// create a Box<str> which will be used to create a Box<[u8]> let boxed: Box<str> = Box::from("hello"); let boxed_str: Box<[u8]> = Box::from(boxed); // create a &[u8] which will be used to create a Box<[u8]> let slice: &[u8] = &[104, 101, 108, 108, 111]; let boxed_slice = Box::from(slice); assert_eq!(boxed_slice, boxed_str);
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");
pub 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]
pub 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]Converts a &str
into a Box<str>
This conversion allocates on the heap
and performs a copy of s
.
Examples
let boxed: Box<str> = Box::from("hello"); println!("{}", boxed);
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);
pub 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]
pub 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]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());
pub 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]pub 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]
pub 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]Converts a [T; N]
into a Box<[T]>
This conversion moves the array to newly heap-allocated memory.
Examples
let boxed: Box<[u8]> = Box::from([4, 2]); println!("{:?}", boxed);
impl<'a, T, U> From<&'a T> for SerializeAsWrap<'a, T, U> where
T: ?Sized,
U: SerializeAs<T> + ?Sized,
[src]
impl<'a, T, U> From<&'a T> for SerializeAsWrap<'a, T, U> where
T: ?Sized,
U: SerializeAs<T> + ?Sized,
[src]pub fn from(error: Error) -> Box<dyn Error + 'static + Send, 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]pub 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]pub fn from(error: Error) -> Box<dyn Error + 'static + Sync + Send, 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
[src]pub fn from(error: Error) -> Box<dyn Error + 'static + Sync + Send, 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
pub 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
impl<T> From<DebugTypesOffset<T>> for UnitSectionOffset<T>
impl<T> From<DebugTypesOffset<T>> for UnitSectionOffset<T>
pub fn from(offset: DebugTypesOffset<T>) -> UnitSectionOffset<T>
impl<R> From<R> for DebugPubNames<R> where
R: Reader,
impl<R> From<R> for DebugPubNames<R> where
R: Reader,
pub fn from(debug_pubnames_section: R) -> DebugPubNames<R>
impl<R> From<R> for DebugPubTypes<R> where
R: Reader,
impl<R> From<R> for DebugPubTypes<R> where
R: Reader,
pub fn from(debug_pubtypes_section: R) -> DebugPubTypes<R>
impl<T> From<DebugInfoOffset<T>> for UnitSectionOffset<T>
impl<T> From<DebugInfoOffset<T>> for UnitSectionOffset<T>
pub fn from(offset: DebugInfoOffset<T>) -> UnitSectionOffset<T>
impl From<SystemTime> for FileTime
impl From<SystemTime> for FileTime
pub fn from(time: SystemTime) -> FileTime
impl<T> From<TrySendError<T>> for TrySendError<T>
impl<T> From<TrySendError<T>> for TrySendError<T>
pub fn from(src: TrySendError<T>) -> TrySendError<T>
pub 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
pub 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
impl From<OrderedFloat<f32>> for f32
impl From<OrderedFloat<f32>> for f32
pub fn from(f: OrderedFloat<f32>) -> f32
impl From<OrderedFloat<f64>> for f64
impl From<OrderedFloat<f64>> for f64
pub fn from(f: OrderedFloat<f64>) -> f64
impl From<LayoutError> for CollectionAllocErr
impl From<LayoutError> for CollectionAllocErr
pub fn from(LayoutError) -> CollectionAllocErr
impl From<MarkerReadError> for NumValueReadError
impl From<MarkerReadError> for NumValueReadError
pub fn from(err: MarkerReadError) -> NumValueReadError
impl From<MarkerWriteError> for ValueWriteError
impl From<MarkerWriteError> for ValueWriteError
pub fn from(err: MarkerWriteError) -> ValueWriteError
impl From<ValueReadError> for NumValueReadError
impl From<ValueReadError> for NumValueReadError
pub fn from(err: ValueReadError) -> NumValueReadError
impl<'a> From<ValueReadError> for DecodeStringError<'a>
impl<'a> From<ValueReadError> for DecodeStringError<'a>
pub fn from(err: ValueReadError) -> DecodeStringError<'a>
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
pub fn from(x: u64x2_sse2<S3, S4, NI>) -> vec128_storage
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
pub fn from(x: u128x1_sse2<S3, S4, NI>) -> vec128_storage
impl<NI> From<u32x4x4_avx2<NI>> for vec512_storage
impl<NI> From<u32x4x4_avx2<NI>> for vec512_storage
pub fn from(x: u32x4x4_avx2<NI>) -> vec512_storage
pub fn from(x: x4<W>) -> 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
pub fn from(x: u32x4_sse2<S3, S4, NI>) -> vec128_storage
pub fn from(x: x2<W, G>) -> vec256_storage
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.
impl<A> From<ArrayVec<A>> for TinyVec<A> where
A: Array,
impl<A> From<ArrayVec<A>> for TinyVec<A> where
A: Array,
#[must_use]pub fn from(arr: ArrayVec<A>) -> TinyVec<A>
impl<'s, T> From<&'s mut [T]> for SliceVec<'s, T>
impl<'s, T> From<&'s mut [T]> for SliceVec<'s, T>
pub fn from(data: &'s mut [T]) -> SliceVec<'s, T>
pub 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<A> From<A> for ArrayVec<A> where
A: Array,
impl<A> From<A> for ArrayVec<A> where
A: Array,
#[must_use]pub fn from(data: A) -> ArrayVec<A>
#[must_use]pub 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<'_, 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>,
Notes
The underlying pipe is not set to non-blocking.
Notes
The underlying pipe is not set to non-blocking.
Notes
The underlying pipe is not set to non-blocking.
impl From<ImageFormatHint> for UnsupportedError
impl From<ImageFormatHint> for UnsupportedError
pub fn from(hint: ImageFormatHint) -> UnsupportedError
impl From<Compression> for CompressionOptions
impl From<Compression> for CompressionOptions
pub fn from(compression: Compression) -> CompressionOptions
impl From<CharRange> for CharIter
impl From<CharRange> for CharIter
pub 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
pub 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<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
An error happened while serializing JSON
Link to another ErrorChain
.
impl From<CharRange> for CharIter
impl From<CharRange> for CharIter
impl From<Colour> for Style
impl From<Colour> for Style
pub fn from(colour: Colour) -> Style
pub 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));
pub fn from(input: I) -> ANSIGenericString<'a, S>
A Response
can be piped as the Body
of another request.
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");
impl<'a, T> From<FutureObj<'a, T>> for LocalFutureObj<'a, T>
impl<'a, T> From<FutureObj<'a, T>> for LocalFutureObj<'a, T>
impl<RW> From<BufReader<BufWriter<RW>>> for BufStream<RW>
impl<RW> From<BufReader<BufWriter<RW>>> for BufStream<RW>
pub fn from(b: BufReader<BufWriter<RW>>) -> BufStream<RW>
impl<RW> From<BufWriter<BufReader<RW>>> for BufStream<RW>
impl<RW> From<BufWriter<BufReader<RW>>> for BufStream<RW>
pub fn from(b: BufWriter<BufReader<RW>>) -> BufStream<RW>
impl From<&'static [u8]> for Body
impl From<&'static [u8]> for Body
pub fn from(slice: &'static [u8]) -> Body
pub fn from(i: Ipv4AddrRange) -> IpAddrRangeⓘNotable traits for IpAddrRange
impl Iterator for IpAddrRange type Item = IpAddr;
[src]pub fn from(i: Ipv6AddrRange) -> IpAddrRangeⓘNotable traits for IpAddrRange
impl Iterator for IpAddrRange type Item = IpAddr;
[src]Implementors
Intended for use for errors not exposed to the user, where allocating onto the heap (for normal construction via Error::new) is too costly.
Converts a bool
into an AtomicBool
.
Examples
use std::sync::atomic::AtomicBool; let atomic_bool = AtomicBool::from(true); assert_eq!(format!("{:?}", atomic_bool), "true")
Converts an isize
into an AtomicIsize
.
impl From<(WhatResponseToClientOp, PieceUpdateOp<(), ()>, Vec<LogEntry, Global>)> for PieceUpdate
[src]
impl From<(WhatResponseToClientOp, PieceUpdateOp<(), ()>, Vec<LogEntry, Global>)> for PieceUpdate
[src]pub fn from(
(WhatResponseToClientOp, PieceUpdateOp<(), ()>, Vec<LogEntry, Global>)
) -> PieceUpdate
[src]impl From<(Box<Item, Global>, Option<(OccultIlkName, Arc<dyn OccultedPieceTrait + 'static>)>)> for PieceSpecLoaded
[src]
impl From<(Box<Item, Global>, Option<(OccultIlkName, Arc<dyn OccultedPieceTrait + 'static>)>)> for PieceSpecLoaded
[src]pub fn from(
(Box<Item, Global>, Option<(OccultIlkName, Arc<dyn OccultedPieceTrait + 'static>)>)
) -> PieceSpecLoaded
[src]Converts an usize
into an AtomicUsize
.
impl From<Error> for FlexiLoggerError
impl From<Error> for FlexiLoggerError
pub fn from(source: Error) -> FlexiLoggerError
Converts a RecvError
into a RecvTimeoutError
.
This conversion always returns RecvTimeoutError::Disconnected
.
No data is allocated on the heap.
Converts a RecvError
into a TryRecvError
.
This conversion always returns TryRecvError::Disconnected
.
No data is allocated on the heap.
Convert a serde_json::Error
into an io::Error
.
JSON syntax and data errors are turned into InvalidData
IO errors.
EOF errors are turned into UnexpectedEof
IO errors.
use std::io; enum MyError { Io(io::Error), Json(serde_json::Error), } impl From<serde_json::Error> for MyError { fn from(err: serde_json::Error) -> MyError { use serde_json::error::Category; match err.classify() { Category::Io => { MyError::Io(err.into()) } Category::Syntax | Category::Data | Category::Eof => { MyError::Json(err) } } } }
Converts a File
into a Stdio
Examples
File
will be converted to Stdio
using Stdio::from
under the hood.
use std::fs::File; use std::process::Command; // With the `foo.txt` file containing `Hello, world!" let file = File::open("foo.txt").unwrap(); let reverse = Command::new("rev") .stdin(file) // Implicit File conversion into a Stdio .output() .expect("failed reverse command"); assert_eq!(reverse.stdout, b"!dlrow ,olleH");
impl From<TryFromIntError> for Overflow
impl From<TryFromIntError> for Overflow
pub fn from(TryFromIntError) -> Overflow
pub fn from(error: PersistError) -> NamedTempFileⓘNotable traits for NamedTempFile
impl Write for NamedTempFileimpl<'a> Write for &'a NamedTempFileimpl Read for NamedTempFileimpl<'a> Read for &'a NamedTempFile
[src]impl From<RangeBackwards> for LogicError
impl From<RangeBackwards> for LogicError
pub fn from(source: RangeBackwards) -> LogicError
impl From<TotallyUnboundedRange> for LogicError
impl From<TotallyUnboundedRange> for LogicError
pub fn from(source: TotallyUnboundedRange) -> LogicError
Convert a DateTime<FixedOffset>
instance into a DateTime<Local>
instance.
Convert this DateTime<FixedOffset>
instance into a DateTime<Local>
instance.
Conversion is performed via DateTime::with_timezone
. Returns the equivalent value in local
time.
Convert a DateTime<FixedOffset>
instance into a DateTime<Utc>
instance.
Convert this DateTime<FixedOffset>
instance into a DateTime<Utc>
instance.
Conversion is performed via DateTime::with_timezone
, accounting for the timezone
difference.
Convert a DateTime<Local>
instance into a DateTime<FixedOffset>
instance.
Convert this DateTime<Local>
instance into a DateTime<FixedOffset>
instance.
Conversion is performed via DateTime::with_timezone
. Note that the converted value returned
by this will be created with a fixed timezone offset of 0.
Convert a DateTime<Local>
instance into a DateTime<Utc>
instance.
Convert a DateTime<Utc>
instance into a DateTime<FixedOffset>
instance.
Convert this DateTime<Utc>
instance into a DateTime<FixedOffset>
instance.
Conversion is done via DateTime::with_timezone
. Note that the converted value returned by
this will be created with a fixed timezone offset of 0.
Convert a DateTime<Utc>
instance into a DateTime<Local>
instance.
impl From<ucred> for UnixCredentials
impl From<ucred> for UnixCredentials
pub fn from(cred: ucred) -> UnixCredentials
impl From<SetLoggerError> for FlexiLoggerError
impl From<SetLoggerError> for FlexiLoggerError
pub fn from(source: SetLoggerError) -> FlexiLoggerError
impl From<FloatIsNan> for otter_api_tests::io::Error
impl From<FloatIsNan> for otter_api_tests::io::Error
pub fn from(e: FloatIsNan) -> Error
impl From<Error> for FlexiLoggerError
impl From<Error> for FlexiLoggerError
pub fn from(source: Error) -> FlexiLoggerError
Converts NonZeroI8
to NonZeroI16
losslessly.
Converts NonZeroI8
to NonZeroI32
losslessly.
Converts NonZeroI8
to NonZeroI64
losslessly.
Converts NonZeroI8
to NonZeroI128
losslessly.
Converts NonZeroI8
to NonZeroIsize
losslessly.
Converts NonZeroI16
to NonZeroI32
losslessly.
Converts NonZeroI16
to NonZeroI64
losslessly.
Converts NonZeroI16
to NonZeroI128
losslessly.
Converts NonZeroI16
to NonZeroIsize
losslessly.
Converts NonZeroI32
to NonZeroI64
losslessly.
Converts NonZeroI32
to NonZeroI128
losslessly.
Converts NonZeroI64
to NonZeroI128
losslessly.
Converts NonZeroU8
to NonZeroUsize
losslessly.
Converts NonZeroU8
to NonZeroI16
losslessly.
Converts NonZeroU8
to NonZeroI32
losslessly.
Converts NonZeroU8
to NonZeroI64
losslessly.
Converts NonZeroU8
to NonZeroI128
losslessly.
Converts NonZeroU8
to NonZeroIsize
losslessly.
Converts NonZeroU8
to NonZeroU16
losslessly.
Converts NonZeroU8
to NonZeroU32
losslessly.
Converts NonZeroU8
to NonZeroU64
losslessly.
Converts NonZeroU8
to NonZeroU128
losslessly.
Converts NonZeroU16
to NonZeroUsize
losslessly.
Converts NonZeroU16
to NonZeroI32
losslessly.
Converts NonZeroU16
to NonZeroI64
losslessly.
Converts NonZeroU16
to NonZeroI128
losslessly.
Converts NonZeroU16
to NonZeroU32
losslessly.
Converts NonZeroU16
to NonZeroU64
losslessly.
Converts NonZeroU16
to NonZeroU128
losslessly.
Converts NonZeroU32
to NonZeroI64
losslessly.
Converts NonZeroU32
to NonZeroI128
losslessly.
Converts NonZeroU32
to NonZeroU64
losslessly.
Converts NonZeroU32
to NonZeroU128
losslessly.
Converts NonZeroU64
to NonZeroI128
losslessly.
Converts NonZeroU64
to NonZeroU128
losslessly.
impl From<ParseIntError> for FlexiLoggerError
impl From<ParseIntError> for FlexiLoggerError
pub fn from(source: ParseIntError) -> FlexiLoggerError
impl From<FromUtf8Error> for otter_api_tests::imports::nix::Error
impl From<FromUtf8Error> for otter_api_tests::imports::nix::Error
pub fn from(FromUtf8Error) -> Error
Converts a ChildStderr
into a Stdio
Examples
use std::process::{Command, Stdio}; let reverse = Command::new("rev") .arg("non_existing_file.txt") .stderr(Stdio::piped()) .spawn() .expect("failed reverse command"); let cat = Command::new("cat") .arg("-") .stdin(reverse.stderr.unwrap()) // Converted into a Stdio here .output() .expect("failed echo command"); assert_eq!( String::from_utf8_lossy(&cat.stdout), "rev: cannot open non_existing_file.txt: No such file or directory\n" );
Converts a ChildStdin
into a Stdio
Examples
ChildStdin
will be converted to Stdio
using Stdio::from
under the hood.
use std::process::{Command, Stdio}; let reverse = Command::new("rev") .stdin(Stdio::piped()) .spawn() .expect("failed reverse command"); let _echo = Command::new("echo") .arg("Hello, world!") .stdout(reverse.stdin.unwrap()) // Converted into a Stdio here .output() .expect("failed echo command"); // "!dlrow ,olleH" echoed to console
Converts a ChildStdout
into a Stdio
Examples
ChildStdout
will be converted to Stdio
using Stdio::from
under the hood.
use std::process::{Command, Stdio}; let hello = Command::new("echo") .arg("Hello, world!") .stdout(Stdio::piped()) .spawn() .expect("failed echo command"); let reverse = Command::new("rev") .stdin(hello.stdout.unwrap()) // Converted into a Stdio here .output() .expect("failed reverse command"); assert_eq!(reverse.stdout, b"!dlrow ,olleH\n");
impl From<Error> for FlexiLoggerError
impl From<Error> for FlexiLoggerError
pub fn from(source: Error) -> FlexiLoggerError
Convert the Error
to an io::Error
, preserving the original
Error
as the “inner error”. Note that this also makes the display
of the error include the context.
This is different from into_io_error
which returns the original
io::Error
.
impl From<TimerSpec> for Expiration
impl From<TimerSpec> for Expiration
pub fn from(timerspec: TimerSpec) -> Expiration
impl<'a> From<&'a UnixSocketAddr> for AddrName<'a>
impl<'a> From<&'a UnixSocketAddr> for AddrName<'a>
pub fn from(addr: &'a UnixSocketAddr) -> AddrName<'a>
Convert copy-on-write string to Value
Examples
use serde_json::Value; use std::borrow::Cow; let s: Cow<str> = Cow::Borrowed("lorem"); let x: Value = s.into();
use serde_json::Value; use std::borrow::Cow; let s: Cow<str> = Cow::Owned("lorem".to_string()); let x: Value = s.into();
pub fn from(src: &'a IndexSlice<I, [T]>) -> IndexVec<I, T>
pub fn from(src: &'a mut IndexSlice<I, [T]>) -> IndexVec<I, T>
pub fn from(a: &'a [T]) -> &'a IndexSlice<I, [T]>
impl<'a, I, T> From<&'a mut [T]> for &'a mut IndexSlice<I, [T]> where
I: Idx,
impl<'a, I, T> From<&'a mut [T]> for &'a mut IndexSlice<I, [T]> where
I: Idx,
pub fn from(a: &'a mut [T]) -> &'a mut IndexSlice<I, [T]>
Converts from &Option<T>
to Option<&T>
.
Examples
Converts an Option<
String
>
into an Option<
usize
>
, preserving the original.
The map
method takes the self
argument by value, consuming the original,
so this technique uses as_ref
to first take an Option
to a reference
to the value inside the original.
let s: Option<String> = Some(String::from("Hello, Rustaceans!")); let o: Option<usize> = Option::from(&s).map(|ss: &String| ss.len()); println!("Can still print s: {:?}", s); assert_eq!(o, Some(18));
Converts from &mut Option<T>
to Option<&mut T>
Examples
let mut s = Some(String::from("Hello")); let o: Option<&mut String> = Option::from(&mut s); match o { Some(t) => *t = String::from("Hello, Rustaceans!"), None => (), } assert_eq!(s, Some(String::from("Hello, Rustaceans!")));
impl<'a, T> From<&'a T> for &'a OrderedFloat<T> where
T: Float,
impl<'a, T> From<&'a T> for &'a OrderedFloat<T> where
T: Float,
pub fn from(t: &'a T) -> &'a OrderedFloat<T>
impl<'a, T> From<&'a mut T> for &'a mut OrderedFloat<T> where
T: Float,
impl<'a, T> From<&'a mut T> for &'a mut OrderedFloat<T> where
T: Float,
pub fn from(t: &'a mut T) -> &'a mut OrderedFloat<T>
impl<'a, T, N> From<&'a [T]> for &'a GenericArray<T, N> where
N: ArrayLength<T>,
impl<'a, T, N> From<&'a [T]> for &'a GenericArray<T, N> where
N: ArrayLength<T>,
pub fn from(slice: &[T]) -> &GenericArray<T, N>
pub fn from(slice: &[T]) -> &GenericArray<T, N>
Converts slice to a generic array reference with inferred length;
Length of the slice must be equal to the length of the array.
impl<'a, T, N> From<&'a mut [T]> for &'a mut 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>,
pub fn from(slice: &mut [T]) -> &mut GenericArray<T, N>
pub fn from(slice: &mut [T]) -> &mut GenericArray<T, N>
Converts mutable slice to a mutable generic array reference
Length of the slice must be equal to the length of the array.
pub fn from(t: (A,)) -> Zip<(<A as IntoIterator>::IntoIter,)>ⓘNotable traits for Zip<(A, B, C, D)>
impl<A, B, C, D> Iterator for Zip<(A, B, C, D)> where
C: Iterator,
B: Iterator,
A: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item);impl<A, B, C, D, E> Iterator for Zip<(A, B, C, D, E)> where
C: Iterator,
E: Iterator,
B: Iterator,
A: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item);impl<A, B, C> Iterator for Zip<(A, B, C)> where
C: Iterator,
B: Iterator,
A: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I, J, K, L> Iterator for Zip<(A, B, C, D, E, F, G, H, I, J, K, L)> where
C: Iterator,
E: Iterator,
L: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
K: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator,
J: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item, <J as Iterator>::Item, <K as Iterator>::Item, <L as Iterator>::Item);impl<A> Iterator for Zip<(A,)> where
A: Iterator, type Item = (<A as Iterator>::Item,);impl<A, B, C, D, E, F, G> Iterator for Zip<(A, B, C, D, E, F, G)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item);impl<A, B, C, D, E, F, G, H> Iterator for Zip<(A, B, C, D, E, F, G, H)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
D: Iterator,
H: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item);impl<A, B> Iterator for Zip<(A, B)> where
B: Iterator,
A: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I, J, K> Iterator for Zip<(A, B, C, D, E, F, G, H, I, J, K)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
K: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator,
J: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item, <J as Iterator>::Item, <K as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I> Iterator for Zip<(A, B, C, D, E, F, G, H, I)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item);impl<A, B, C, D, E, F> Iterator for Zip<(A, B, C, D, E, F)> where
C: Iterator,
E: Iterator,
B: Iterator,
A: Iterator,
F: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I, J> Iterator for Zip<(A, B, C, D, E, F, G, H, I, J)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator,
J: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item, <J as Iterator>::Item);
[src]impl<A, B> From<(A, B)> for Zip<(<A as IntoIterator>::IntoIter, <B as IntoIterator>::IntoIter)> where
B: IntoIterator,
A: IntoIterator,
[src]
impl<A, B> From<(A, B)> for Zip<(<A as IntoIterator>::IntoIter, <B as IntoIterator>::IntoIter)> where
B: IntoIterator,
A: IntoIterator,
[src]pub fn from(
t: (A, B)
) -> Zip<(<A as IntoIterator>::IntoIter, <B as IntoIterator>::IntoIter)>ⓘNotable traits for Zip<(A, B, C, D)>
impl<A, B, C, D> Iterator for Zip<(A, B, C, D)> where
C: Iterator,
B: Iterator,
A: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item);impl<A, B, C, D, E> Iterator for Zip<(A, B, C, D, E)> where
C: Iterator,
E: Iterator,
B: Iterator,
A: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item);impl<A, B, C> Iterator for Zip<(A, B, C)> where
C: Iterator,
B: Iterator,
A: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I, J, K, L> Iterator for Zip<(A, B, C, D, E, F, G, H, I, J, K, L)> where
C: Iterator,
E: Iterator,
L: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
K: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator,
J: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item, <J as Iterator>::Item, <K as Iterator>::Item, <L as Iterator>::Item);impl<A> Iterator for Zip<(A,)> where
A: Iterator, type Item = (<A as Iterator>::Item,);impl<A, B, C, D, E, F, G> Iterator for Zip<(A, B, C, D, E, F, G)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item);impl<A, B, C, D, E, F, G, H> Iterator for Zip<(A, B, C, D, E, F, G, H)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
D: Iterator,
H: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item);impl<A, B> Iterator for Zip<(A, B)> where
B: Iterator,
A: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I, J, K> Iterator for Zip<(A, B, C, D, E, F, G, H, I, J, K)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
K: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator,
J: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item, <J as Iterator>::Item, <K as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I> Iterator for Zip<(A, B, C, D, E, F, G, H, I)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item);impl<A, B, C, D, E, F> Iterator for Zip<(A, B, C, D, E, F)> where
C: Iterator,
E: Iterator,
B: Iterator,
A: Iterator,
F: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I, J> Iterator for Zip<(A, B, C, D, E, F, G, H, I, J)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator,
J: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item, <J as Iterator>::Item);
[src]impl<A, B, C> From<(A, B, C)> for Zip<(<A as IntoIterator>::IntoIter, <B as IntoIterator>::IntoIter, <C as IntoIterator>::IntoIter)> where
C: IntoIterator,
B: IntoIterator,
A: IntoIterator,
[src]
impl<A, B, C> From<(A, B, C)> for Zip<(<A as IntoIterator>::IntoIter, <B as IntoIterator>::IntoIter, <C as IntoIterator>::IntoIter)> where
C: IntoIterator,
B: IntoIterator,
A: IntoIterator,
[src]pub fn from(
t: (A, B, C)
) -> Zip<(<A as IntoIterator>::IntoIter, <B as IntoIterator>::IntoIter, <C as IntoIterator>::IntoIter)>ⓘNotable traits for Zip<(A, B, C, D)>
impl<A, B, C, D> Iterator for Zip<(A, B, C, D)> where
C: Iterator,
B: Iterator,
A: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item);impl<A, B, C, D, E> Iterator for Zip<(A, B, C, D, E)> where
C: Iterator,
E: Iterator,
B: Iterator,
A: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item);impl<A, B, C> Iterator for Zip<(A, B, C)> where
C: Iterator,
B: Iterator,
A: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I, J, K, L> Iterator for Zip<(A, B, C, D, E, F, G, H, I, J, K, L)> where
C: Iterator,
E: Iterator,
L: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
K: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator,
J: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item, <J as Iterator>::Item, <K as Iterator>::Item, <L as Iterator>::Item);impl<A> Iterator for Zip<(A,)> where
A: Iterator, type Item = (<A as Iterator>::Item,);impl<A, B, C, D, E, F, G> Iterator for Zip<(A, B, C, D, E, F, G)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item);impl<A, B, C, D, E, F, G, H> Iterator for Zip<(A, B, C, D, E, F, G, H)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
D: Iterator,
H: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item);impl<A, B> Iterator for Zip<(A, B)> where
B: Iterator,
A: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I, J, K> Iterator for Zip<(A, B, C, D, E, F, G, H, I, J, K)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
K: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator,
J: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item, <J as Iterator>::Item, <K as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I> Iterator for Zip<(A, B, C, D, E, F, G, H, I)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item);impl<A, B, C, D, E, F> Iterator for Zip<(A, B, C, D, E, F)> where
C: Iterator,
E: Iterator,
B: Iterator,
A: Iterator,
F: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I, J> Iterator for Zip<(A, B, C, D, E, F, G, H, I, J)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator,
J: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item, <J as Iterator>::Item);
[src]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
C: IntoIterator,
B: IntoIterator,
A: IntoIterator,
D: IntoIterator,
[src]
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
C: IntoIterator,
B: IntoIterator,
A: IntoIterator,
D: IntoIterator,
[src]pub fn from(
t: (A, B, C, D)
) -> Zip<(<A as IntoIterator>::IntoIter, <B as IntoIterator>::IntoIter, <C as IntoIterator>::IntoIter, <D as IntoIterator>::IntoIter)>ⓘNotable traits for Zip<(A, B, C, D)>
impl<A, B, C, D> Iterator for Zip<(A, B, C, D)> where
C: Iterator,
B: Iterator,
A: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item);impl<A, B, C, D, E> Iterator for Zip<(A, B, C, D, E)> where
C: Iterator,
E: Iterator,
B: Iterator,
A: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item);impl<A, B, C> Iterator for Zip<(A, B, C)> where
C: Iterator,
B: Iterator,
A: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I, J, K, L> Iterator for Zip<(A, B, C, D, E, F, G, H, I, J, K, L)> where
C: Iterator,
E: Iterator,
L: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
K: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator,
J: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item, <J as Iterator>::Item, <K as Iterator>::Item, <L as Iterator>::Item);impl<A> Iterator for Zip<(A,)> where
A: Iterator, type Item = (<A as Iterator>::Item,);impl<A, B, C, D, E, F, G> Iterator for Zip<(A, B, C, D, E, F, G)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item);impl<A, B, C, D, E, F, G, H> Iterator for Zip<(A, B, C, D, E, F, G, H)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
D: Iterator,
H: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item);impl<A, B> Iterator for Zip<(A, B)> where
B: Iterator,
A: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I, J, K> Iterator for Zip<(A, B, C, D, E, F, G, H, I, J, K)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
K: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator,
J: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item, <J as Iterator>::Item, <K as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I> Iterator for Zip<(A, B, C, D, E, F, G, H, I)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item);impl<A, B, C, D, E, F> Iterator for Zip<(A, B, C, D, E, F)> where
C: Iterator,
E: Iterator,
B: Iterator,
A: Iterator,
F: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I, J> Iterator for Zip<(A, B, C, D, E, F, G, H, I, J)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator,
J: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item, <J as Iterator>::Item);
[src]impl<A, B, C, D, E> From<(A, B, C, D, E)> for Zip<(<A as IntoIterator>::IntoIter, <B as IntoIterator>::IntoIter, <C as IntoIterator>::IntoIter, <D as IntoIterator>::IntoIter, <E as IntoIterator>::IntoIter)> where
C: IntoIterator,
E: IntoIterator,
B: IntoIterator,
A: IntoIterator,
D: IntoIterator,
[src]
impl<A, B, C, D, E> From<(A, B, C, D, E)> for Zip<(<A as IntoIterator>::IntoIter, <B as IntoIterator>::IntoIter, <C as IntoIterator>::IntoIter, <D as IntoIterator>::IntoIter, <E as IntoIterator>::IntoIter)> where
C: IntoIterator,
E: IntoIterator,
B: IntoIterator,
A: IntoIterator,
D: IntoIterator,
[src]pub fn from(
t: (A, B, C, D, E)
) -> Zip<(<A as IntoIterator>::IntoIter, <B as IntoIterator>::IntoIter, <C as IntoIterator>::IntoIter, <D as IntoIterator>::IntoIter, <E as IntoIterator>::IntoIter)>ⓘNotable traits for Zip<(A, B, C, D)>
impl<A, B, C, D> Iterator for Zip<(A, B, C, D)> where
C: Iterator,
B: Iterator,
A: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item);impl<A, B, C, D, E> Iterator for Zip<(A, B, C, D, E)> where
C: Iterator,
E: Iterator,
B: Iterator,
A: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item);impl<A, B, C> Iterator for Zip<(A, B, C)> where
C: Iterator,
B: Iterator,
A: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I, J, K, L> Iterator for Zip<(A, B, C, D, E, F, G, H, I, J, K, L)> where
C: Iterator,
E: Iterator,
L: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
K: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator,
J: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item, <J as Iterator>::Item, <K as Iterator>::Item, <L as Iterator>::Item);impl<A> Iterator for Zip<(A,)> where
A: Iterator, type Item = (<A as Iterator>::Item,);impl<A, B, C, D, E, F, G> Iterator for Zip<(A, B, C, D, E, F, G)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item);impl<A, B, C, D, E, F, G, H> Iterator for Zip<(A, B, C, D, E, F, G, H)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
D: Iterator,
H: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item);impl<A, B> Iterator for Zip<(A, B)> where
B: Iterator,
A: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I, J, K> Iterator for Zip<(A, B, C, D, E, F, G, H, I, J, K)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
K: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator,
J: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item, <J as Iterator>::Item, <K as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I> Iterator for Zip<(A, B, C, D, E, F, G, H, I)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item);impl<A, B, C, D, E, F> Iterator for Zip<(A, B, C, D, E, F)> where
C: Iterator,
E: Iterator,
B: Iterator,
A: Iterator,
F: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I, J> Iterator for Zip<(A, B, C, D, E, F, G, H, I, J)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator,
J: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item, <J as Iterator>::Item);
[src]impl<A, B, C, D, E, F> From<(A, B, C, D, E, F)> for Zip<(<A as IntoIterator>::IntoIter, <B as IntoIterator>::IntoIter, <C as IntoIterator>::IntoIter, <D as IntoIterator>::IntoIter, <E as IntoIterator>::IntoIter, <F as IntoIterator>::IntoIter)> where
C: IntoIterator,
E: IntoIterator,
B: IntoIterator,
A: IntoIterator,
F: IntoIterator,
D: IntoIterator,
[src]
impl<A, B, C, D, E, F> From<(A, B, C, D, E, F)> for Zip<(<A as IntoIterator>::IntoIter, <B as IntoIterator>::IntoIter, <C as IntoIterator>::IntoIter, <D as IntoIterator>::IntoIter, <E as IntoIterator>::IntoIter, <F as IntoIterator>::IntoIter)> where
C: IntoIterator,
E: IntoIterator,
B: IntoIterator,
A: IntoIterator,
F: IntoIterator,
D: IntoIterator,
[src]pub fn from(
t: (A, B, C, D, E, F)
) -> 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)>ⓘNotable traits for Zip<(A, B, C, D)>
impl<A, B, C, D> Iterator for Zip<(A, B, C, D)> where
C: Iterator,
B: Iterator,
A: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item);impl<A, B, C, D, E> Iterator for Zip<(A, B, C, D, E)> where
C: Iterator,
E: Iterator,
B: Iterator,
A: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item);impl<A, B, C> Iterator for Zip<(A, B, C)> where
C: Iterator,
B: Iterator,
A: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I, J, K, L> Iterator for Zip<(A, B, C, D, E, F, G, H, I, J, K, L)> where
C: Iterator,
E: Iterator,
L: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
K: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator,
J: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item, <J as Iterator>::Item, <K as Iterator>::Item, <L as Iterator>::Item);impl<A> Iterator for Zip<(A,)> where
A: Iterator, type Item = (<A as Iterator>::Item,);impl<A, B, C, D, E, F, G> Iterator for Zip<(A, B, C, D, E, F, G)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item);impl<A, B, C, D, E, F, G, H> Iterator for Zip<(A, B, C, D, E, F, G, H)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
D: Iterator,
H: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item);impl<A, B> Iterator for Zip<(A, B)> where
B: Iterator,
A: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I, J, K> Iterator for Zip<(A, B, C, D, E, F, G, H, I, J, K)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
K: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator,
J: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item, <J as Iterator>::Item, <K as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I> Iterator for Zip<(A, B, C, D, E, F, G, H, I)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item);impl<A, B, C, D, E, F> Iterator for Zip<(A, B, C, D, E, F)> where
C: Iterator,
E: Iterator,
B: Iterator,
A: Iterator,
F: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I, J> Iterator for Zip<(A, B, C, D, E, F, G, H, I, J)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator,
J: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item, <J as Iterator>::Item);
[src]impl<A, B, C, D, E, F, G> From<(A, B, C, D, E, F, G)> for Zip<(<A as IntoIterator>::IntoIter, <B as IntoIterator>::IntoIter, <C as IntoIterator>::IntoIter, <D as IntoIterator>::IntoIter, <E as IntoIterator>::IntoIter, <F as IntoIterator>::IntoIter, <G as IntoIterator>::IntoIter)> where
C: IntoIterator,
E: IntoIterator,
B: IntoIterator,
G: IntoIterator,
A: IntoIterator,
F: IntoIterator,
D: IntoIterator,
[src]
impl<A, B, C, D, E, F, G> From<(A, B, C, D, E, F, G)> for Zip<(<A as IntoIterator>::IntoIter, <B as IntoIterator>::IntoIter, <C as IntoIterator>::IntoIter, <D as IntoIterator>::IntoIter, <E as IntoIterator>::IntoIter, <F as IntoIterator>::IntoIter, <G as IntoIterator>::IntoIter)> where
C: IntoIterator,
E: IntoIterator,
B: IntoIterator,
G: IntoIterator,
A: IntoIterator,
F: IntoIterator,
D: IntoIterator,
[src]pub fn from(
t: (A, B, C, D, E, F, G)
) -> 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)>ⓘNotable traits for Zip<(A, B, C, D)>
impl<A, B, C, D> Iterator for Zip<(A, B, C, D)> where
C: Iterator,
B: Iterator,
A: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item);impl<A, B, C, D, E> Iterator for Zip<(A, B, C, D, E)> where
C: Iterator,
E: Iterator,
B: Iterator,
A: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item);impl<A, B, C> Iterator for Zip<(A, B, C)> where
C: Iterator,
B: Iterator,
A: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I, J, K, L> Iterator for Zip<(A, B, C, D, E, F, G, H, I, J, K, L)> where
C: Iterator,
E: Iterator,
L: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
K: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator,
J: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item, <J as Iterator>::Item, <K as Iterator>::Item, <L as Iterator>::Item);impl<A> Iterator for Zip<(A,)> where
A: Iterator, type Item = (<A as Iterator>::Item,);impl<A, B, C, D, E, F, G> Iterator for Zip<(A, B, C, D, E, F, G)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item);impl<A, B, C, D, E, F, G, H> Iterator for Zip<(A, B, C, D, E, F, G, H)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
D: Iterator,
H: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item);impl<A, B> Iterator for Zip<(A, B)> where
B: Iterator,
A: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I, J, K> Iterator for Zip<(A, B, C, D, E, F, G, H, I, J, K)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
K: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator,
J: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item, <J as Iterator>::Item, <K as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I> Iterator for Zip<(A, B, C, D, E, F, G, H, I)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item);impl<A, B, C, D, E, F> Iterator for Zip<(A, B, C, D, E, F)> where
C: Iterator,
E: Iterator,
B: Iterator,
A: Iterator,
F: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I, J> Iterator for Zip<(A, B, C, D, E, F, G, H, I, J)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator,
J: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item, <J as Iterator>::Item);
[src]impl<A, B, C, D, E, F, G, H> From<(A, B, C, D, E, F, G, H)> for Zip<(<A as IntoIterator>::IntoIter, <B as IntoIterator>::IntoIter, <C as IntoIterator>::IntoIter, <D as IntoIterator>::IntoIter, <E as IntoIterator>::IntoIter, <F as IntoIterator>::IntoIter, <G as IntoIterator>::IntoIter, <H as IntoIterator>::IntoIter)> where
C: IntoIterator,
E: IntoIterator,
B: IntoIterator,
G: IntoIterator,
A: IntoIterator,
F: IntoIterator,
D: IntoIterator,
H: IntoIterator,
[src]
impl<A, B, C, D, E, F, G, H> From<(A, B, C, D, E, F, G, H)> for Zip<(<A as IntoIterator>::IntoIter, <B as IntoIterator>::IntoIter, <C as IntoIterator>::IntoIter, <D as IntoIterator>::IntoIter, <E as IntoIterator>::IntoIter, <F as IntoIterator>::IntoIter, <G as IntoIterator>::IntoIter, <H as IntoIterator>::IntoIter)> where
C: IntoIterator,
E: IntoIterator,
B: IntoIterator,
G: IntoIterator,
A: IntoIterator,
F: IntoIterator,
D: IntoIterator,
H: IntoIterator,
[src]pub fn from(
t: (A, B, C, D, E, F, G, H)
) -> 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)>ⓘNotable traits for Zip<(A, B, C, D)>
impl<A, B, C, D> Iterator for Zip<(A, B, C, D)> where
C: Iterator,
B: Iterator,
A: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item);impl<A, B, C, D, E> Iterator for Zip<(A, B, C, D, E)> where
C: Iterator,
E: Iterator,
B: Iterator,
A: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item);impl<A, B, C> Iterator for Zip<(A, B, C)> where
C: Iterator,
B: Iterator,
A: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I, J, K, L> Iterator for Zip<(A, B, C, D, E, F, G, H, I, J, K, L)> where
C: Iterator,
E: Iterator,
L: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
K: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator,
J: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item, <J as Iterator>::Item, <K as Iterator>::Item, <L as Iterator>::Item);impl<A> Iterator for Zip<(A,)> where
A: Iterator, type Item = (<A as Iterator>::Item,);impl<A, B, C, D, E, F, G> Iterator for Zip<(A, B, C, D, E, F, G)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item);impl<A, B, C, D, E, F, G, H> Iterator for Zip<(A, B, C, D, E, F, G, H)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
D: Iterator,
H: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item);impl<A, B> Iterator for Zip<(A, B)> where
B: Iterator,
A: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I, J, K> Iterator for Zip<(A, B, C, D, E, F, G, H, I, J, K)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
K: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator,
J: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item, <J as Iterator>::Item, <K as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I> Iterator for Zip<(A, B, C, D, E, F, G, H, I)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item);impl<A, B, C, D, E, F> Iterator for Zip<(A, B, C, D, E, F)> where
C: Iterator,
E: Iterator,
B: Iterator,
A: Iterator,
F: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I, J> Iterator for Zip<(A, B, C, D, E, F, G, H, I, J)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator,
J: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item, <J as Iterator>::Item);
[src]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
C: IntoIterator,
E: IntoIterator,
B: IntoIterator,
G: IntoIterator,
A: IntoIterator,
F: IntoIterator,
I: IntoIterator,
D: IntoIterator,
H: IntoIterator,
[src]
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
C: IntoIterator,
E: IntoIterator,
B: IntoIterator,
G: IntoIterator,
A: IntoIterator,
F: IntoIterator,
I: IntoIterator,
D: IntoIterator,
H: IntoIterator,
[src]pub fn from(
t: (A, B, C, D, E, F, G, H, I)
) -> 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)>ⓘNotable traits for Zip<(A, B, C, D)>
impl<A, B, C, D> Iterator for Zip<(A, B, C, D)> where
C: Iterator,
B: Iterator,
A: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item);impl<A, B, C, D, E> Iterator for Zip<(A, B, C, D, E)> where
C: Iterator,
E: Iterator,
B: Iterator,
A: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item);impl<A, B, C> Iterator for Zip<(A, B, C)> where
C: Iterator,
B: Iterator,
A: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I, J, K, L> Iterator for Zip<(A, B, C, D, E, F, G, H, I, J, K, L)> where
C: Iterator,
E: Iterator,
L: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
K: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator,
J: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item, <J as Iterator>::Item, <K as Iterator>::Item, <L as Iterator>::Item);impl<A> Iterator for Zip<(A,)> where
A: Iterator, type Item = (<A as Iterator>::Item,);impl<A, B, C, D, E, F, G> Iterator for Zip<(A, B, C, D, E, F, G)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item);impl<A, B, C, D, E, F, G, H> Iterator for Zip<(A, B, C, D, E, F, G, H)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
D: Iterator,
H: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item);impl<A, B> Iterator for Zip<(A, B)> where
B: Iterator,
A: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I, J, K> Iterator for Zip<(A, B, C, D, E, F, G, H, I, J, K)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
K: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator,
J: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item, <J as Iterator>::Item, <K as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I> Iterator for Zip<(A, B, C, D, E, F, G, H, I)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item);impl<A, B, C, D, E, F> Iterator for Zip<(A, B, C, D, E, F)> where
C: Iterator,
E: Iterator,
B: Iterator,
A: Iterator,
F: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I, J> Iterator for Zip<(A, B, C, D, E, F, G, H, I, J)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator,
J: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item, <J as Iterator>::Item);
[src]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
C: IntoIterator,
E: IntoIterator,
B: IntoIterator,
G: IntoIterator,
A: IntoIterator,
F: IntoIterator,
I: IntoIterator,
D: IntoIterator,
H: IntoIterator,
J: IntoIterator,
[src]
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
C: IntoIterator,
E: IntoIterator,
B: IntoIterator,
G: IntoIterator,
A: IntoIterator,
F: IntoIterator,
I: IntoIterator,
D: IntoIterator,
H: IntoIterator,
J: IntoIterator,
[src]pub fn from(
t: (A, B, C, D, E, F, G, H, I, J)
) -> 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)>ⓘNotable traits for Zip<(A, B, C, D)>
impl<A, B, C, D> Iterator for Zip<(A, B, C, D)> where
C: Iterator,
B: Iterator,
A: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item);impl<A, B, C, D, E> Iterator for Zip<(A, B, C, D, E)> where
C: Iterator,
E: Iterator,
B: Iterator,
A: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item);impl<A, B, C> Iterator for Zip<(A, B, C)> where
C: Iterator,
B: Iterator,
A: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I, J, K, L> Iterator for Zip<(A, B, C, D, E, F, G, H, I, J, K, L)> where
C: Iterator,
E: Iterator,
L: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
K: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator,
J: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item, <J as Iterator>::Item, <K as Iterator>::Item, <L as Iterator>::Item);impl<A> Iterator for Zip<(A,)> where
A: Iterator, type Item = (<A as Iterator>::Item,);impl<A, B, C, D, E, F, G> Iterator for Zip<(A, B, C, D, E, F, G)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item);impl<A, B, C, D, E, F, G, H> Iterator for Zip<(A, B, C, D, E, F, G, H)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
D: Iterator,
H: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item);impl<A, B> Iterator for Zip<(A, B)> where
B: Iterator,
A: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I, J, K> Iterator for Zip<(A, B, C, D, E, F, G, H, I, J, K)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
K: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator,
J: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item, <J as Iterator>::Item, <K as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I> Iterator for Zip<(A, B, C, D, E, F, G, H, I)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item);impl<A, B, C, D, E, F> Iterator for Zip<(A, B, C, D, E, F)> where
C: Iterator,
E: Iterator,
B: Iterator,
A: Iterator,
F: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I, J> Iterator for Zip<(A, B, C, D, E, F, G, H, I, J)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator,
J: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item, <J as Iterator>::Item);
[src]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
C: IntoIterator,
E: IntoIterator,
B: IntoIterator,
G: IntoIterator,
A: IntoIterator,
K: IntoIterator,
F: IntoIterator,
I: IntoIterator,
D: IntoIterator,
H: IntoIterator,
J: IntoIterator,
[src]
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
C: IntoIterator,
E: IntoIterator,
B: IntoIterator,
G: IntoIterator,
A: IntoIterator,
K: IntoIterator,
F: IntoIterator,
I: IntoIterator,
D: IntoIterator,
H: IntoIterator,
J: IntoIterator,
[src]pub fn from(
t: (A, B, C, D, E, F, G, H, I, J, K)
) -> 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)>ⓘNotable traits for Zip<(A, B, C, D)>
impl<A, B, C, D> Iterator for Zip<(A, B, C, D)> where
C: Iterator,
B: Iterator,
A: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item);impl<A, B, C, D, E> Iterator for Zip<(A, B, C, D, E)> where
C: Iterator,
E: Iterator,
B: Iterator,
A: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item);impl<A, B, C> Iterator for Zip<(A, B, C)> where
C: Iterator,
B: Iterator,
A: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I, J, K, L> Iterator for Zip<(A, B, C, D, E, F, G, H, I, J, K, L)> where
C: Iterator,
E: Iterator,
L: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
K: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator,
J: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item, <J as Iterator>::Item, <K as Iterator>::Item, <L as Iterator>::Item);impl<A> Iterator for Zip<(A,)> where
A: Iterator, type Item = (<A as Iterator>::Item,);impl<A, B, C, D, E, F, G> Iterator for Zip<(A, B, C, D, E, F, G)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item);impl<A, B, C, D, E, F, G, H> Iterator for Zip<(A, B, C, D, E, F, G, H)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
D: Iterator,
H: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item);impl<A, B> Iterator for Zip<(A, B)> where
B: Iterator,
A: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I, J, K> Iterator for Zip<(A, B, C, D, E, F, G, H, I, J, K)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
K: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator,
J: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item, <J as Iterator>::Item, <K as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I> Iterator for Zip<(A, B, C, D, E, F, G, H, I)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item);impl<A, B, C, D, E, F> Iterator for Zip<(A, B, C, D, E, F)> where
C: Iterator,
E: Iterator,
B: Iterator,
A: Iterator,
F: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I, J> Iterator for Zip<(A, B, C, D, E, F, G, H, I, J)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator,
J: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item, <J as Iterator>::Item);
[src]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
C: IntoIterator,
E: IntoIterator,
L: IntoIterator,
B: IntoIterator,
G: IntoIterator,
A: IntoIterator,
K: IntoIterator,
F: IntoIterator,
I: IntoIterator,
D: IntoIterator,
H: IntoIterator,
J: IntoIterator,
[src]
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
C: IntoIterator,
E: IntoIterator,
L: IntoIterator,
B: IntoIterator,
G: IntoIterator,
A: IntoIterator,
K: IntoIterator,
F: IntoIterator,
I: IntoIterator,
D: IntoIterator,
H: IntoIterator,
J: IntoIterator,
[src]pub fn from(
t: (A, B, C, D, E, F, G, H, I, J, K, L)
) -> 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)>ⓘNotable traits for Zip<(A, B, C, D)>
impl<A, B, C, D> Iterator for Zip<(A, B, C, D)> where
C: Iterator,
B: Iterator,
A: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item);impl<A, B, C, D, E> Iterator for Zip<(A, B, C, D, E)> where
C: Iterator,
E: Iterator,
B: Iterator,
A: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item);impl<A, B, C> Iterator for Zip<(A, B, C)> where
C: Iterator,
B: Iterator,
A: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I, J, K, L> Iterator for Zip<(A, B, C, D, E, F, G, H, I, J, K, L)> where
C: Iterator,
E: Iterator,
L: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
K: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator,
J: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item, <J as Iterator>::Item, <K as Iterator>::Item, <L as Iterator>::Item);impl<A> Iterator for Zip<(A,)> where
A: Iterator, type Item = (<A as Iterator>::Item,);impl<A, B, C, D, E, F, G> Iterator for Zip<(A, B, C, D, E, F, G)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item);impl<A, B, C, D, E, F, G, H> Iterator for Zip<(A, B, C, D, E, F, G, H)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
D: Iterator,
H: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item);impl<A, B> Iterator for Zip<(A, B)> where
B: Iterator,
A: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I, J, K> Iterator for Zip<(A, B, C, D, E, F, G, H, I, J, K)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
K: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator,
J: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item, <J as Iterator>::Item, <K as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I> Iterator for Zip<(A, B, C, D, E, F, G, H, I)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item);impl<A, B, C, D, E, F> Iterator for Zip<(A, B, C, D, E, F)> where
C: Iterator,
E: Iterator,
B: Iterator,
A: Iterator,
F: Iterator,
D: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item);impl<A, B, C, D, E, F, G, H, I, J> Iterator for Zip<(A, B, C, D, E, F, G, H, I, J)> where
C: Iterator,
E: Iterator,
B: Iterator,
G: Iterator,
A: Iterator,
F: Iterator,
I: Iterator,
D: Iterator,
H: Iterator,
J: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item, <J as Iterator>::Item);
[src]Convert from Result
to Either
with Ok => Right
and Err => Left
.
impl<R, G, T> From<T> for ReentrantMutex<R, G, T> where
G: GetThreadId,
R: RawMutex,
impl<R, G, T> From<T> for ReentrantMutex<R, G, T> where
G: GetThreadId,
R: RawMutex,
pub fn from(t: T) -> ReentrantMutex<R, G, 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.
Converts a SendError<T>
into a TrySendError<T>
.
This conversion always returns a TrySendError::Disconnected
containing the data in the SendError<T>
.
No data is allocated on the heap.
Convert the CtOption<T>
wrapper into an Option<T>
, depending on whether
the underlying is_some
Choice
was a 0
or a 1
once unwrapped.
Note
This function exists to avoid ending up with ugly, verbose and/or bad handled
conversions from the CtOption<T>
wraps to an Option<T>
or Result<T, E>
.
This implementation doesn’t intend to be constant-time nor try to protect the
leakage of the T
since the Option<T>
will do it anyways.
impl<T> From<T> for OrderedFloat<T> where
T: Float,
impl<T> From<T> for OrderedFloat<T> where
T: Float,
pub fn from(val: T) -> OrderedFloat<T>
Converts a Box<T>
into a Pin<Box<T>>
This conversion does not allocate on the heap and happens in place.
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);