#[lang = "owned_box"]pub struct Box<T>(_) where T: ?Sized;
A pointer type for heap allocation.
See the module-level documentation for more.
impl<T> Box<T>[src]
pub fn new(x: T) -> Box<T>ⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
Allocates memory on the heap and then places x into it.
This doesn't actually allocate if T is zero-sized.
let five = Box::new(5);
pub fn new_uninit() -> Box<MaybeUninit<T>>ⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
Constructs a new box with uninitialized contents.
#![feature(new_uninit)]
let mut five = Box::<u32>::new_uninit();
let five = unsafe {
// Deferred initialization:
five.as_mut_ptr().write(5);
five.assume_init()
};
assert_eq!(*five, 5)pub fn new_zeroed() -> Box<MaybeUninit<T>>ⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
Constructs a new Box with uninitialized contents, with the memory being filled with 0 bytes.
See MaybeUninit::zeroed for examples of correct and incorrect usage of this method.
#![feature(new_uninit)]
let zero = Box::<u32>::new_zeroed();
let zero = unsafe { zero.assume_init() };
assert_eq!(*zero, 0)pub fn pin(x: T) -> Pin<Box<T>>ⓘNotable traits for Pin<P>
impl<P> Future for Pin<P> where
P: Unpin + DerefMut,
<P as Deref>::Target: Future,
type Output = <<P as Deref>::Target as Future>::Output;
[src]1.33.0
Constructs a new Pin<Box<T>>. If T does not implement Unpin, then x will be pinned in memory and unable to be moved.
pub fn into_boxed_slice(boxed: Box<T>) -> Box<[T]>ⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
Converts a Box<T> into a Box<[T]>
This conversion does not allocate on the heap and happens in place.
impl<T> Box<[T]>[src]
pub fn new_uninit_slice(len: usize) -> Box<[MaybeUninit<T>]>ⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
Constructs a new boxed slice with uninitialized contents.
#![feature(new_uninit)]
let mut values = Box::<[u32]>::new_uninit_slice(3);
let values = unsafe {
// Deferred initialization:
values[0].as_mut_ptr().write(1);
values[1].as_mut_ptr().write(2);
values[2].as_mut_ptr().write(3);
values.assume_init()
};
assert_eq!(*values, [1, 2, 3])pub fn new_zeroed_slice(len: usize) -> Box<[MaybeUninit<T>]>ⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
Constructs a new boxed slice with uninitialized contents, with the memory being filled with 0 bytes.
See MaybeUninit::zeroed for examples of correct and incorrect usage of this method.
#![feature(new_uninit)]
let values = Box::<[u32]>::new_zeroed_slice(3);
let values = unsafe { values.assume_init() };
assert_eq!(*values, [0, 0, 0])impl<T> Box<MaybeUninit<T>>[src]
pub unsafe fn assume_init(self) -> Box<T>ⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
Converts to Box<T>.
As with MaybeUninit::assume_init, it is up to the caller to guarantee that the value really is in an initialized state. Calling this when the content is not yet fully initialized causes immediate undefined behavior.
#![feature(new_uninit)]
let mut five = Box::<u32>::new_uninit();
let five: Box<u32> = unsafe {
// Deferred initialization:
five.as_mut_ptr().write(5);
five.assume_init()
};
assert_eq!(*five, 5)impl<T> Box<[MaybeUninit<T>]>[src]
pub unsafe fn assume_init(self) -> Box<[T]>ⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
Converts to Box<[T]>.
As with MaybeUninit::assume_init, it is up to the caller to guarantee that the values really are in an initialized state. Calling this when the content is not yet fully initialized causes immediate undefined behavior.
#![feature(new_uninit)]
let mut values = Box::<[u32]>::new_uninit_slice(3);
let values = unsafe {
// Deferred initialization:
values[0].as_mut_ptr().write(1);
values[1].as_mut_ptr().write(2);
values[2].as_mut_ptr().write(3);
values.assume_init()
};
assert_eq!(*values, [1, 2, 3])impl<T> Box<T> where
T: ?Sized, [src]
pub unsafe fn from_raw(raw: *mut T) -> Box<T>ⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]1.4.0
Constructs a box from a raw pointer.
After calling this function, the raw pointer is owned by the resulting Box. Specifically, the Box destructor will call the destructor of T and free the allocated memory. For this to be safe, the memory must have been allocated in accordance with the memory layout used by Box .
This function is unsafe because improper use may lead to memory problems. For example, a double-free may occur if the function is called twice on the same raw pointer.
Recreate a Box which was previously converted to a raw pointer using Box::into_raw:
let x = Box::new(5);
let ptr = Box::into_raw(x);
let x = unsafe { Box::from_raw(ptr) };Manually create a Box from scratch by using the global allocator:
use std::alloc::{alloc, Layout};
unsafe {
let ptr = alloc(Layout::new::<i32>()) as *mut i32;
// In general .write is required to avoid attempting to destruct
// the (uninitialized) previous contents of `ptr`, though for this
// simple example `*ptr = 5` would have worked as well.
ptr.write(5);
let x = Box::from_raw(ptr);
}pub fn into_raw(b: Box<T>) -> *mut T[src]1.4.0
Consumes the Box, returning a wrapped raw pointer.
The pointer will be properly aligned and non-null.
After calling this function, the caller is responsible for the memory previously managed by the Box. In particular, the caller should properly destroy T and release the memory, taking into account the memory layout used by Box. The easiest way to do this is to convert the raw pointer back into a Box with the Box::from_raw function, allowing the Box destructor to perform the cleanup.
Note: this is an associated function, which means that you have to call it as Box::into_raw(b) instead of b.into_raw(). This is so that there is no conflict with a method on the inner type.
Converting the raw pointer back into a Box with Box::from_raw for automatic cleanup:
let x = Box::new(String::from("Hello"));
let ptr = Box::into_raw(x);
let x = unsafe { Box::from_raw(ptr) };Manual cleanup by explicitly running the destructor and deallocating the memory:
use std::alloc::{dealloc, Layout};
use std::ptr;
let x = Box::new(String::from("Hello"));
let p = Box::into_raw(x);
unsafe {
ptr::drop_in_place(p);
dealloc(p as *mut u8, Layout::new::<String>());
}pub fn leak<'a>(b: Box<T>) -> &'a mut TⓘNotable traits for &'_ mut F
impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized, '_> Read for &'_ mut R
impl<W: Write + ?Sized, '_> Write for &'_ mut W
where
T: 'a, [src]1.26.0
Consumes and leaks the Box, returning a mutable reference, &'a mut T. Note that the type T must outlive the chosen lifetime 'a. If the type has only static references, or none at all, then this may be chosen to be 'static.
This function is mainly useful for data that lives for the remainder of the program's life. Dropping the returned reference will cause a memory leak. If this is not acceptable, the reference should first be wrapped with the Box::from_raw function producing a Box. This Box can then be dropped which will properly destroy T and release the allocated memory.
Note: this is an associated function, which means that you have to call it as Box::leak(b) instead of b.leak(). This is so that there is no conflict with a method on the inner type.
Simple usage:
let x = Box::new(41); let static_ref: &'static mut usize = Box::leak(x); *static_ref += 1; assert_eq!(*static_ref, 42);
Unsized data:
let x = vec![1, 2, 3].into_boxed_slice(); let static_ref = Box::leak(x); static_ref[0] = 4; assert_eq!(*static_ref, [4, 2, 3]);
pub fn into_pin(boxed: Box<T>) -> Pin<Box<T>>ⓘNotable traits for Pin<P>
impl<P> Future for Pin<P> where
P: Unpin + DerefMut,
<P as Deref>::Target: Future,
type Output = <<P as Deref>::Target as Future>::Output;
[src]
Converts a Box<T> into a Pin<Box<T>>
This conversion does not allocate on the heap and happens in place.
This is also available via From.
impl Box<dyn Any + 'static>[src]
pub fn downcast<T>(self) -> Result<Box<T>, Box<dyn Any + 'static>> where
T: Any, [src]
Attempt to downcast the box to a concrete type.
use std::any::Any;
fn print_if_string(value: Box<dyn Any>) {
if let Ok(string) = value.downcast::<String>() {
println!("String ({}): {}", string.len(), string);
}
}
let my_string = "Hello World".to_string();
print_if_string(Box::new(my_string));
print_if_string(Box::new(0i8));impl Box<dyn Any + 'static + Send>[src]
pub fn downcast<T>(self) -> Result<Box<T>, Box<dyn Any + 'static + Send>> where
T: Any, [src]
Attempt to downcast the box to a concrete type.
use std::any::Any;
fn print_if_string(value: Box<dyn Any + Send>) {
if let Ok(string) = value.downcast::<String>() {
println!("String ({}): {}", string.len(), string);
}
}
let my_string = "Hello World".to_string();
print_if_string(Box::new(my_string));
print_if_string(Box::new(0i8));impl<T> AsMut<T> for Box<T> where
T: ?Sized, [src]1.5.0
fn as_mut(&mut self) -> &mut TⓘNotable traits for &'_ mut F
impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized, '_> Read for &'_ mut R
impl<W: Write + ?Sized, '_> Write for &'_ mut W
[src]
impl<T> AsRef<T> for Box<T> where
T: ?Sized, [src]1.5.0
fn as_ref(&self) -> &TⓘNotable traits for &'_ mut F
impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized, '_> Read for &'_ mut R
impl<W: Write + ?Sized, '_> Write for &'_ mut W
[src]
impl<T> Borrow<T> for Box<T> where
T: ?Sized, [src]1.1.0
fn borrow(&self) -> &TⓘNotable traits for &'_ mut F
impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized, '_> Read for &'_ mut R
impl<W: Write + ?Sized, '_> Write for &'_ mut W
[src]
impl<T> BorrowMut<T> for Box<T> where
T: ?Sized, [src]1.1.0
fn borrow_mut(&mut self) -> &mut TⓘNotable traits for &'_ mut F
impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized, '_> Read for &'_ mut R
impl<W: Write + ?Sized, '_> Write for &'_ mut W
[src]
impl<B: BufRead + ?Sized> BufRead for Box<B>[src]
fn fill_buf(&mut self) -> Result<&[u8]>[src]
fn consume(&mut self, amt: usize)[src]
fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> Result<usize>[src]
fn read_line(&mut self, buf: &mut String) -> Result<usize>[src]
fn split(self, byte: u8) -> Split<Self>ⓘNotable traits for Split<B>
impl<B: BufRead> Iterator for Split<B>
type Item = Result<Vec<u8>>;
where
Self: Sized, [src]
fn lines(self) -> Lines<Self>ⓘNotable traits for Lines<B>
impl<B: BufRead> Iterator for Lines<B>
type Item = Result<String>;
where
Self: Sized, [src]
impl<T> Clone for Box<[T]> where
T: Clone, [src]1.3.0
fn clone(&self) -> Box<[T]>ⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
fn clone_from(&mut self, other: &Box<[T]>)[src]
impl Clone for Box<str>[src]1.3.0
fn clone(&self) -> Box<str>ⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
fn clone_from(&mut self, source: &Self)[src]
impl<T> Clone for Box<T> where
T: Clone, [src]
fn clone(&self) -> Box<T>ⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
Returns a new box with a clone() of this box's contents.
let x = Box::new(5); let y = x.clone(); // The value is the same assert_eq!(x, y); // But they are unique objects assert_ne!(&*x as *const i32, &*y as *const i32);
fn clone_from(&mut self, source: &Box<T>)[src]
Copies source's contents into self without creating a new allocation.
let x = Box::new(5); let mut y = Box::new(10); let yp: *const i32 = &*y; y.clone_from(&x); // The value is the same assert_eq!(x, y); // And no allocation occurred assert_eq!(yp, &*y);
impl Clone for Box<CStr>[src]1.29.0
fn clone(&self) -> Self[src]
fn clone_from(&mut self, source: &Self)[src]
impl Clone for Box<OsStr>[src]1.29.0
fn clone(&self) -> Self[src]
fn clone_from(&mut self, source: &Self)[src]
impl Clone for Box<Path>[src]1.29.0
fn clone(&self) -> Self[src]
fn clone_from(&mut self, source: &Self)[src]
impl<T, U> CoerceUnsized<Box<U>> for Box<T> where
T: Unsize<U> + ?Sized,
U: ?Sized, [src]
impl<T> Debug for Box<T> where
T: Debug + ?Sized, [src]
impl<T> Default for Box<T> where
T: Default, [src]
fn default() -> Box<T>ⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
Creates a Box<T>, with the Default value for T.
impl<T> Default for Box<[T]>[src]
fn default() -> Box<[T]>ⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
impl Default for Box<str>[src]1.17.0
fn default() -> Box<str>ⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
impl Default for Box<CStr>[src]1.17.0
fn default() -> Box<CStr>ⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
impl Default for Box<OsStr>[src]1.17.0
fn default() -> Box<OsStr>ⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
impl<T> Deref for Box<T> where
T: ?Sized, [src]
type Target = TThe resulting type after dereferencing.
fn deref(&self) -> &TⓘNotable traits for &'_ mut F
impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized, '_> Read for &'_ mut R
impl<W: Write + ?Sized, '_> Write for &'_ mut W
[src]
impl<T> DerefMut for Box<T> where
T: ?Sized, [src]
fn deref_mut(&mut self) -> &mut TⓘNotable traits for &'_ mut F
impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized, '_> Read for &'_ mut R
impl<W: Write + ?Sized, '_> Write for &'_ mut W
[src]
impl<T, U> DispatchFromDyn<Box<U>> for Box<T> where
T: Unsize<U> + ?Sized,
U: ?Sized, [src]
impl<T> Display for Box<T> where
T: Display + ?Sized, [src]
impl<I> DoubleEndedIterator for Box<I> where
I: DoubleEndedIterator + ?Sized, [src]
fn next_back(&mut self) -> Option<<I as Iterator>::Item>[src]
fn nth_back(&mut self, n: usize) -> Option<<I as Iterator>::Item>[src]
fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>, [src]1.27.0
fn rfold<B, F>(self, init: B, f: F) -> B where
F: FnMut(B, Self::Item) -> B, [src]1.27.0
fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
P: FnMut(&Self::Item) -> bool, [src]1.27.0
impl<T> Drop for Box<T> where
T: ?Sized, [src]
impl<T> Eq for Box<T> where
T: Eq + ?Sized, [src]
impl<T: Error> Error for Box<T>[src]1.8.0
fn description(&self) -> &str[src]
fn cause(&self) -> Option<&dyn Error>[src]
fn source(&self) -> Option<&(dyn Error + 'static)>[src]
fn backtrace(&self) -> Option<&Backtrace>[src]
impl<I> ExactSizeIterator for Box<I> where
I: ExactSizeIterator + ?Sized, [src]
impl Extend<Box<str>> for String[src]1.45.0
fn extend<I>(&mut self, iter: I) where
I: IntoIterator<Item = Box<str>>, [src]
fn extend_one(&mut self, item: A)[src]
fn extend_reserve(&mut self, additional: usize)[src]
impl<A, F> Fn<A> for Box<F> where
F: Fn<A> + ?Sized, [src]1.35.0
extern "rust-call" fn call(&self, args: A) -> <Box<F> as FnOnce<A>>::OutputⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
impl<A, F> FnMut<A> for Box<F> where
F: FnMut<A> + ?Sized, [src]1.35.0
extern "rust-call" fn call_mut(
&mut self,
args: A
) -> <Box<F> as FnOnce<A>>::OutputⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
impl<A, F> FnOnce<A> for Box<F> where
F: FnOnce<A> + ?Sized, [src]1.35.0
type Output = <F as FnOnce<A>>::OutputThe returned type after the call operator is used.
extern "rust-call" fn call_once(self, args: A) -> <Box<F> as FnOnce<A>>::OutputⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
impl<'_, T> From<&'_ [T]> for Box<[T]> where
T: Copy, [src]1.17.0
fn from(slice: &[T]) -> Box<[T]>ⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
Converts a &[T] into a Box<[T]>
This conversion allocates on the heap and performs a copy of slice.
// create a &[u8] which will be used to create a Box<[u8]>
let slice: &[u8] = &[104, 101, 108, 108, 111];
let boxed_slice: Box<[u8]> = Box::from(slice);
println!("{:?}", boxed_slice);impl<'_> From<&'_ CStr> for Box<CStr>[src]1.17.0
fn from(s: &CStr) -> Box<CStr>ⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
impl<'_> From<&'_ OsStr> for Box<OsStr>[src]1.17.0
fn from(s: &OsStr) -> Box<OsStr>ⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
impl<'_> From<&'_ Path> for Box<Path>[src]1.17.0
fn from(path: &Path) -> Box<Path>ⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
impl<'_> From<&'_ str> for Box<str>[src]1.17.0
fn from(s: &str) -> Box<str>ⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
Converts a &str into a Box<str>
This conversion allocates on the heap and performs a copy of s.
let boxed: Box<str> = Box::from("hello");
println!("{}", boxed);impl<'a, '_> From<&'_ str> for Box<dyn Error + Send + Sync + 'a>[src]
fn from(err: &str) -> Box<dyn Error + Send + Sync + 'a>ⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
impl<'_> From<&'_ str> for Box<dyn Error>[src]1.6.0
fn from(err: &str) -> Box<dyn Error>ⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
impl<T, const N: usize> From<[T; N]> for Box<[T]>[src]1.45.0
fn from(array: [T; N]) -> Box<[T]>ⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
Converts a [T; N] into a Box<[T]>
This conversion moves the array to newly heap-allocated memory.
let boxed: Box<[u8]> = Box::from([4, 2]);
println!("{:?}", boxed);impl<T> From<Box<[T]>> for Vec<T>[src]1.18.0
impl From<Box<CStr>> for CString[src]1.18.0
impl From<Box<OsStr>> for OsString[src]1.18.0
impl From<Box<Path>> for PathBuf[src]1.18.0
fn from(boxed: Box<Path>) -> PathBuf[src]
Converts a Box<Path> into a PathBuf
This conversion does not allocate or copy memory.
impl<T> From<Box<T>> for Arc<T> where
T: ?Sized, [src]1.21.0
impl<T> From<Box<T>> for Pin<Box<T>> where
T: ?Sized, [src]1.33.0
fn from(boxed: Box<T>) -> Pin<Box<T>>ⓘNotable traits for Pin<P>
impl<P> Future for Pin<P> where
P: Unpin + DerefMut,
<P as Deref>::Target: Future,
type Output = <<P as Deref>::Target as Future>::Output;
[src]
Converts a Box<T> into a Pin<Box<T>>
This conversion does not allocate on the heap and happens in place.
impl<T> From<Box<T>> for Rc<T> where
T: ?Sized, [src]1.21.0
impl From<Box<str>> for Box<[u8]>[src]1.19.0
fn from(s: Box<str>) -> Box<[u8]>ⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
Converts a Box<str>> into a Box<[u8]>
This conversion does not allocate on the heap and happens in place.
// create a Box<str> which will be used to create a Box<[u8]>
let boxed: Box<str> = Box::from("hello");
let boxed_str: Box<[u8]> = Box::from(boxed);
// create a &[u8] which will be used to create a Box<[u8]>
let slice: &[u8] = &[104, 101, 108, 108, 111];
let boxed_slice = Box::from(slice);
assert_eq!(boxed_slice, boxed_str);impl From<Box<str>> for String[src]1.18.0
fn from(s: Box<str>) -> String[src]
Converts the given boxed str slice to a String. It is notable that the str slice is owned.
Basic usage:
let s1: String = String::from("hello world");
let s2: Box<str> = s1.into_boxed_str();
let s3: String = String::from(s2);
assert_eq!("hello world", s3)impl From<CString> for Box<CStr>[src]1.20.0
fn from(s: CString) -> Box<CStr>ⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
impl<'_, T> From<Cow<'_, [T]>> for Box<[T]> where
T: Copy, [src]1.45.0
fn from(cow: Cow<'_, [T]>) -> Box<[T]>ⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
impl<'_> From<Cow<'_, CStr>> for Box<CStr>[src]1.45.0
fn from(cow: Cow<'_, CStr>) -> Box<CStr>ⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
impl<'_> From<Cow<'_, OsStr>> for Box<OsStr>[src]1.45.0
fn from(cow: Cow<'_, OsStr>) -> Box<OsStr>ⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
impl<'_> From<Cow<'_, Path>> for Box<Path>[src]1.45.0
fn from(cow: Cow<'_, Path>) -> Box<Path>ⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
impl<'_> From<Cow<'_, str>> for Box<str>[src]1.45.0
fn from(cow: Cow<'_, str>) -> Box<str>ⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
impl<'a> From<Cow<'a, str>> for Box<dyn Error>[src]1.22.0
fn from(err: Cow<'a, str>) -> Box<dyn Error>ⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
impl<'a, 'b> From<Cow<'b, str>> for Box<dyn Error + Send + Sync + 'a>[src]1.22.0
fn from(err: Cow<'b, str>) -> Box<dyn Error + Send + Sync + 'a>ⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
Converts a Cow into a box of dyn Error + Send + Sync.
use std::error::Error;
use std::mem;
use std::borrow::Cow;
let a_cow_str_error = Cow::from("a str error");
let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_cow_str_error);
assert!(
mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))impl<'a, E: Error + 'a> From<E> for Box<dyn Error + 'a>[src]
fn from(err: E) -> Box<dyn Error + 'a>ⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
Converts a type of Error into a box of dyn Error.
use std::error::Error;
use std::fmt;
use std::mem;
#[derive(Debug)]
struct AnError;
impl fmt::Display for AnError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f , "An error")
}
}
impl Error for AnError {}
let an_error = AnError;
assert!(0 == mem::size_of_val(&an_error));
let a_boxed_error = Box::<dyn Error>::from(an_error);
assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))impl<'a, E: Error + Send + Sync + 'a> From<E> for Box<dyn Error + Send + Sync + 'a>[src]
fn from(err: E) -> Box<dyn Error + Send + Sync + 'a>ⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
Converts a type of Error + Send + Sync into a box of dyn Error + Send + Sync.
use std::error::Error;
use std::fmt;
use std::mem;
#[derive(Debug)]
struct AnError;
impl fmt::Display for AnError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f , "An error")
}
}
impl Error for AnError {}
unsafe impl Send for AnError {}
unsafe impl Sync for AnError {}
let an_error = AnError;
assert!(0 == mem::size_of_val(&an_error));
let a_boxed_error = Box::<dyn Error + Send + Sync>::from(an_error);
assert!(
mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))impl From<OsString> for Box<OsStr>[src]1.20.0
fn from(s: OsString) -> Box<OsStr>ⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
impl From<PathBuf> for Box<Path>[src]1.20.0
fn from(p: PathBuf) -> Box<Path>ⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
Converts a PathBuf into a Box<Path>
This conversion currently should not allocate memory, but this behavior is not guaranteed on all platforms or in all future versions.
impl From<String> for Box<str>[src]1.20.0
fn from(s: String) -> Box<str>ⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
Converts the given String to a boxed str slice that is owned.
Basic usage:
let s1: String = String::from("hello world");
let s2: Box<str> = Box::from(s1);
let s3: String = String::from(s2);
assert_eq!("hello world", s3)impl From<String> for Box<dyn Error + Send + Sync>[src]
fn from(err: String) -> Box<dyn Error + Send + Sync>ⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
Converts a String into a box of dyn Error + Send + Sync.
use std::error::Error;
use std::mem;
let a_string_error = "a string error".to_string();
let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_string_error);
assert!(
mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))impl From<String> for Box<dyn Error>[src]1.6.0
fn from(str_err: String) -> Box<dyn Error>ⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
impl<T> From<T> for Box<T>[src]1.6.0
fn from(t: T) -> Box<T>ⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
Converts a generic type T into a Box<T>
The conversion allocates on the heap and moves t from the stack into it.
let x = 5; let boxed = Box::new(5); assert_eq!(Box::from(x), boxed);
impl<T> From<Vec<T>> for Box<[T]>[src]1.20.0
fn from(v: Vec<T>) -> Box<[T]>ⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
[src]
impl<A> FromIterator<A> for Box<[A]>[src]1.32.0
fn from_iter<T>(iter: T) -> Box<[A]>ⓘNotable traits for Box<F>
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized> Read for Box<R>
impl<W: Write + ?Sized> Write for Box<W>
where
T: IntoIterator<Item = A>, [src]
impl FromIterator<Box<str>> for String[src]1.45.0
impl<I> FusedIterator for Box<I> where
I: FusedIterator + ?Sized, [src]1.26.0
impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized, [src]1.36.0
type Output = <F as Future>::OutputThe type of value produced on completion.
fn poll(
self: Pin<&mut Box<F>>,
cx: &mut Context<'_>
) -> Poll<<Box<F> as Future>::Output>[src]
impl<G, R> Generator<R> for Box<G> where
G: Unpin + Generator<R> + ?Sized, [src]
type Yield = <G as Generator<R>>::YieldThe type of value this generator yields. Read more
type Return = <G as Generator<R>>::ReturnThe type of value this generator returns. Read more
fn resume(
self: Pin<&mut Box<G>>,
arg: R
) -> GeneratorState<<Box<G> as Generator<R>>::Yield, <Box<G> as Generator<R>>::Return>[src]
impl<T> Hash for Box<T> where
T: Hash + ?Sized, [src]
fn hash<H>(&self, state: &mut H) where
H: Hasher, [src]
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, [src]1.3.0
impl<T> Hasher for Box<T> where
T: Hasher + ?Sized, [src]1.22.0
fn finish(&self) -> u64[src]
fn write(&mut self, bytes: &[u8])[src]
fn write_u8(&mut self, i: u8)[src]
fn write_u16(&mut self, i: u16)[src]
fn write_u32(&mut self, i: u32)[src]
fn write_u64(&mut self, i: u64)[src]
fn write_u128(&mut self, i: u128)[src]
fn write_usize(&mut self, i: usize)[src]
fn write_i8(&mut self, i: i8)[src]
fn write_i16(&mut self, i: i16)[src]
fn write_i32(&mut self, i: i32)[src]
fn write_i64(&mut self, i: i64)[src]
fn write_i128(&mut self, i: i128)[src]
fn write_isize(&mut self, i: isize)[src]
impl<I> Iterator for Box<I> where
I: Iterator + ?Sized, [src]
type Item = <I as Iterator>::ItemThe type of the elements being iterated over.
fn next(&mut self) -> Option<<I as Iterator>::Item>[src]
fn size_hint(&self) -> (usize, Option<usize>)[src]
fn nth(&mut self, n: usize) -> Option<<I as Iterator>::Item>[src]
fn last(self) -> Option<<I as Iterator>::Item>[src]
fn count(self) -> usize[src]
fn step_by(self, step: usize) -> StepBy<Self>ⓘNotable traits for StepBy<I>
impl<I> Iterator for StepBy<I> where
I: Iterator,
type Item = <I as Iterator>::Item;
[src]1.28.0
fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>ⓘNotable traits for Chain<A, B>
impl<A, B> Iterator for Chain<A, B> where
A: Iterator,
B: Iterator<Item = <A as Iterator>::Item>,
type Item = <A as Iterator>::Item;
where
U: IntoIterator<Item = Self::Item>, [src]
fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>ⓘNotable traits for Zip<A, B>
impl<A, B> Iterator for Zip<A, B> where
A: Iterator,
B: Iterator,
type Item = (<A as Iterator>::Item, <B as Iterator>::Item);
where
U: IntoIterator, [src]
fn map<B, F>(self, f: F) -> Map<Self, F>ⓘNotable traits for Map<I, F>
impl<B, I, F> Iterator for Map<I, F> where
F: FnMut(<I as Iterator>::Item) -> B,
I: Iterator,
type Item = B;
where
F: FnMut(Self::Item) -> B, [src]
fn for_each<F>(self, f: F) where
F: FnMut(Self::Item), [src]1.21.0
fn filter<P>(self, predicate: P) -> Filter<Self, P>ⓘNotable traits for Filter<I, P>
impl<I, P> Iterator for Filter<I, P> where
I: Iterator,
P: FnMut(&<I as Iterator>::Item) -> bool,
type Item = <I as Iterator>::Item;
where
P: FnMut(&Self::Item) -> bool, [src]
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>ⓘNotable traits for FilterMap<I, F>
impl<B, I, F> Iterator for FilterMap<I, F> where
F: FnMut(<I as Iterator>::Item) -> Option<B>,
I: Iterator,
type Item = B;
where
F: FnMut(Self::Item) -> Option<B>, [src]
fn enumerate(self) -> Enumerate<Self>ⓘNotable traits for Enumerate<I>
impl<I> Iterator for Enumerate<I> where
I: Iterator,
type Item = (usize, <I as Iterator>::Item);
[src]
fn peekable(self) -> Peekable<Self>ⓘNotable traits for Peekable<I>
impl<I> Iterator for Peekable<I> where
I: Iterator,
type Item = <I as Iterator>::Item;
[src]
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>ⓘNotable traits for SkipWhile<I, P>
impl<I, P> Iterator for SkipWhile<I, P> where
I: Iterator,
P: FnMut(&<I as Iterator>::Item) -> bool,
type Item = <I as Iterator>::Item;
where
P: FnMut(&Self::Item) -> bool, [src]
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>ⓘNotable traits for TakeWhile<I, P>
impl<I, P> Iterator for TakeWhile<I, P> where
I: Iterator,
P: FnMut(&<I as Iterator>::Item) -> bool,
type Item = <I as Iterator>::Item;
where
P: FnMut(&Self::Item) -> bool, [src]
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>ⓘNotable traits for MapWhile<I, P>
impl<B, I, P> Iterator for MapWhile<I, P> where
I: Iterator,
P: FnMut(<I as Iterator>::Item) -> Option<B>,
type Item = B;
where
P: FnMut(Self::Item) -> Option<B>, [src]
fn skip(self, n: usize) -> Skip<Self>ⓘNotable traits for Skip<I>
impl<I> Iterator for Skip<I> where
I: Iterator,
type Item = <I as Iterator>::Item;
[src]
fn take(self, n: usize) -> Take<Self>ⓘNotable traits for Take<I>
impl<I> Iterator for Take<I> where
I: Iterator,
type Item = <I as Iterator>::Item;
[src]
fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>ⓘNotable traits for Scan<I, St, F>
impl<B, I, St, F> Iterator for Scan<I, St, F> where
F: FnMut(&mut St, <I as Iterator>::Item) -> Option<B>,
I: Iterator,
type Item = B;
where
F: FnMut(&mut St, Self::Item) -> Option<B>, [src]
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>ⓘNotable traits for FlatMap<I, U, F>
impl<I, U, F> Iterator for FlatMap<I, U, F> where
F: FnMut(<I as Iterator>::Item) -> U,
I: Iterator,
U: IntoIterator,
type Item = <U as IntoIterator>::Item;
where
F: FnMut(Self::Item) -> U,
U: IntoIterator, [src]
fn flatten(self) -> Flatten<Self>ⓘNotable traits for Flatten<I>
impl<I, U> Iterator for Flatten<I> where
I: Iterator,
U: Iterator,
<I as Iterator>::Item: IntoIterator,
<<I as Iterator>::Item as IntoIterator>::IntoIter == U,
<<I as Iterator>::Item as IntoIterator>::Item == <U as Iterator>::Item,
type Item = <U as Iterator>::Item;
where
Self::Item: IntoIterator, [src]1.29.0
fn fuse(self) -> Fuse<Self>ⓘNotable traits for Fuse<I>
impl<I> Iterator for Fuse<I> where
I: Iterator,
type Item = <I as Iterator>::Item;
[src]
fn inspect<F>(self, f: F) -> Inspect<Self, F>ⓘNotable traits for Inspect<I, F>
impl<I, F> Iterator for Inspect<I, F> where
F: FnMut(&<I as Iterator>::Item),
I: Iterator,
type Item = <I as Iterator>::Item;
where
F: FnMut(&Self::Item), [src]
fn by_ref(&mut self) -> &mut SelfⓘNotable traits for &'_ mut F
impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized, '_> Read for &'_ mut R
impl<W: Write + ?Sized, '_> Write for &'_ mut W
[src]
#[must_use =
"if you really need to exhaust the iterator, consider `.for_each(drop)` instead"]fn collect<B>(self) -> B where
B: FromIterator<Self::Item>, [src]
fn partition<B, F>(self, f: F) -> (B, B) where
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool, [src]
fn partition_in_place<'a, T, P>(self, predicate: P) -> usize where
P: FnMut(&T) -> bool,
Self: DoubleEndedIterator<Item = &'a mut T>,
T: 'a, [src]
fn is_partitioned<P>(self, predicate: P) -> bool where
P: FnMut(Self::Item) -> bool, [src]
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>, [src]1.27.0
fn try_for_each<F, R>(&mut self, f: F) -> R where
F: FnMut(Self::Item) -> R,
R: Try<Ok = ()>, [src]1.27.0
fn fold<B, F>(self, init: B, f: F) -> B where
F: FnMut(B, Self::Item) -> B, [src]
fn fold_first<F>(self, f: F) -> Option<Self::Item> where
F: FnMut(Self::Item, Self::Item) -> Self::Item, [src]
fn all<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool, [src]
fn any<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool, [src]
fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where
P: FnMut(&Self::Item) -> bool, [src]
fn find_map<B, F>(&mut self, f: F) -> Option<B> where
F: FnMut(Self::Item) -> Option<B>, [src]1.30.0
fn try_find<F, R>(
&mut self,
f: F
) -> Result<Option<Self::Item>, <R as Try>::Error> where
F: FnMut(&Self::Item) -> R,
R: Try<Ok = bool>, [src]
fn position<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool, [src]
fn rposition<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool,
Self: ExactSizeIterator + DoubleEndedIterator, [src]
fn max(self) -> Option<Self::Item> where
Self::Item: Ord, [src]
fn min(self) -> Option<Self::Item> where
Self::Item: Ord, [src]
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where
B: Ord,
F: FnMut(&Self::Item) -> B, [src]1.6.0
fn max_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering, [src]1.15.0
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where
B: Ord,
F: FnMut(&Self::Item) -> B, [src]1.6.0
fn min_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering, [src]1.15.0
fn rev(self) -> Rev<Self>ⓘNotable traits for Rev<I>
impl<I> Iterator for Rev<I> where
I: DoubleEndedIterator,
type Item = <I as Iterator>::Item;
where
Self: DoubleEndedIterator, [src]
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Iterator<Item = (A, B)>, [src]
fn copied<'a, T>(self) -> Copied<Self>ⓘNotable traits for Copied<I>
impl<'a, I, T> Iterator for Copied<I> where
I: Iterator<Item = &'a T>,
T: 'a + Copy,
type Item = T;
where
Self: Iterator<Item = &'a T>,
T: 'a + Copy, [src]1.36.0
fn cloned<'a, T>(self) -> Cloned<Self>ⓘNotable traits for Cloned<I>
impl<'a, I, T> Iterator for Cloned<I> where
I: Iterator<Item = &'a T>,
T: 'a + Clone,
type Item = T;
where
Self: Iterator<Item = &'a T>,
T: 'a + Clone, [src]
fn cycle(self) -> Cycle<Self>ⓘNotable traits for Cycle<I>
impl<I> Iterator for Cycle<I> where
I: Clone + Iterator,
type Item = <I as Iterator>::Item;
where
Self: Clone, [src]
fn sum<S>(self) -> S where
S: Sum<Self::Item>, [src]1.11.0
fn product<P>(self) -> P where
P: Product<Self::Item>, [src]1.11.0
fn cmp<I>(self, other: I) -> Ordering where
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord, [src]1.5.0
fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
I: IntoIterator, [src]
fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>, [src]1.5.0
fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering> where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
I: IntoIterator, [src]
fn eq<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>, [src]1.5.0
fn eq_by<I, F>(self, other: I, eq: F) -> bool where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
I: IntoIterator, [src]
fn ne<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>, [src]1.5.0
fn lt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>, [src]1.5.0
fn le<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>, [src]1.5.0
fn gt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>, [src]1.5.0
fn ge<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>, [src]1.5.0
fn is_sorted(self) -> bool where
Self::Item: PartialOrd<Self::Item>, [src]
fn is_sorted_by<F>(self, compare: F) -> bool where
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>, [src]
fn is_sorted_by_key<F, K>(self, f: F) -> bool where
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>, [src]
impl<T> Ord for Box<T> where
T: Ord + ?Sized, [src]
fn cmp(&self, other: &Box<T>) -> Ordering[src]
fn max(self, other: Self) -> Self[src]1.21.0
fn min(self, other: Self) -> Self[src]1.21.0
fn clamp(self, min: Self, max: Self) -> Self[src]
impl<T> PartialEq<Box<T>> for Box<T> where
T: PartialEq<T> + ?Sized, [src]
impl<T> PartialOrd<Box<T>> for Box<T> where
T: PartialOrd<T> + ?Sized, [src]
fn partial_cmp(&self, other: &Box<T>) -> Option<Ordering>[src]
fn lt(&self, other: &Box<T>) -> bool[src]
fn le(&self, other: &Box<T>) -> bool[src]
fn ge(&self, other: &Box<T>) -> bool[src]
fn gt(&self, other: &Box<T>) -> bool[src]
impl<T> Pointer for Box<T> where
T: ?Sized, [src]
impl<R: Read + ?Sized> Read for Box<R>[src]
fn read(&mut self, buf: &mut [u8]) -> Result<usize>[src]
fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize>[src]
fn is_read_vectored(&self) -> bool[src]
unsafe fn initializer(&self) -> Initializer[src]
fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize>[src]
fn read_to_string(&mut self, buf: &mut String) -> Result<usize>[src]
fn read_exact(&mut self, buf: &mut [u8]) -> Result<()>[src]
fn by_ref(&mut self) -> &mut SelfⓘNotable traits for &'_ mut F
impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized, '_> Read for &'_ mut R
impl<W: Write + ?Sized, '_> Write for &'_ mut W
where
Self: Sized, [src]
fn bytes(self) -> Bytes<Self>ⓘNotable traits for Bytes<R>
impl<R: Read> Iterator for Bytes<R>
type Item = Result<u8>;
where
Self: Sized, [src]
fn chain<R: Read>(self, next: R) -> Chain<Self, R>ⓘNotable traits for Chain<T, U>
impl<T: Read, U: Read> Read for Chain<T, U>
where
Self: Sized, [src]
fn take(self, limit: u64) -> Take<Self>ⓘNotable traits for Take<T>
impl<T: Read> Read for Take<T>
where
Self: Sized, [src]
impl<S: Seek + ?Sized> Seek for Box<S>[src]
fn seek(&mut self, pos: SeekFrom) -> Result<u64>[src]
fn stream_len(&mut self) -> Result<u64>[src]
fn stream_position(&mut self) -> Result<u64>[src]
impl<T, const N: usize> TryFrom<Box<[T]>> for Box<[T; N]>[src]1.43.0
type Error = Box<[T]>The type returned in the event of a conversion error.
fn try_from(
boxed_slice: Box<[T]>
) -> Result<Box<[T; N]>, <Box<[T; N]> as TryFrom<Box<[T]>>>::Error>[src]
impl<T> Unpin for Box<T> where
T: ?Sized, [src]1.33.0
impl<W: Write + ?Sized> Write for Box<W>[src]
fn write(&mut self, buf: &[u8]) -> Result<usize>[src]
fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize>[src]
fn is_write_vectored(&self) -> bool[src]
fn flush(&mut self) -> Result<()>[src]
fn write_all(&mut self, buf: &[u8]) -> Result<()>[src]
fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<()>[src]
fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<()>[src]
fn by_ref(&mut self) -> &mut SelfⓘNotable traits for &'_ mut F
impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized, '_> Read for &'_ mut R
impl<W: Write + ?Sized, '_> Write for &'_ mut W
where
Self: Sized, [src]
impl<T: ?Sized> RefUnwindSafe for Box<T> where
T: RefUnwindSafe, impl<T: ?Sized> Send for Box<T> where
T: Send, impl<T: ?Sized> Sync for Box<T> where
T: Sync, impl<T: ?Sized> UnwindSafe for Box<T> where
T: UnwindSafe, impl<T> Any for T where
T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
T: ?Sized, [src]
fn borrow(&self) -> &TⓘNotable traits for &'_ mut F
impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized, '_> Read for &'_ mut R
impl<W: Write + ?Sized, '_> Write for &'_ mut W
[src]
impl<T> BorrowMut<T> for T where
T: ?Sized, [src]
fn borrow_mut(&mut self) -> &mut TⓘNotable traits for &'_ mut F
impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized, '_> Read for &'_ mut R
impl<W: Write + ?Sized, '_> Write for &'_ mut W
[src]
impl<T> From<!> for T[src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
U: From<T>, [src]
impl<F> IntoFuture for F where
F: Future, [src]
type Output = <F as Future>::OutputThe output that the future will produce on completion.
type Future = FWhich kind of future are we turning this into?
fn into_future(self) -> <F as IntoFuture>::Future[src]
impl<I> IntoIterator for I where
I: Iterator, [src]
type Item = <I as Iterator>::ItemThe type of the elements being iterated over.
type IntoIter = IWhich kind of iterator are we turning this into?
fn into_iter(self) -> I[src]
impl<'a, F> Pattern<'a> for F where
F: FnMut(char) -> bool, [src]
type Searcher = CharPredicateSearcher<'a, F>Associated searcher for this pattern
fn into_searcher(self, haystack: &'a str) -> CharPredicateSearcher<'a, F>[src]
fn is_contained_in(self, haystack: &'a str) -> bool[src]
fn is_prefix_of(self, haystack: &'a str) -> bool[src]
fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>[src]
fn is_suffix_of(self, haystack: &'a str) -> bool where
CharPredicateSearcher<'a, F>: ReverseSearcher<'a>, [src]
fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str> where
CharPredicateSearcher<'a, F>: ReverseSearcher<'a>, [src]
impl<T> ToOwned for T where
T: Clone, [src]
type Owned = TThe resulting type after obtaining ownership.
fn to_owned(&self) -> T[src]
fn clone_into(&self, target: &mut T)[src]
impl<T> ToString for T where
T: Display + ?Sized, [src]
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]
type Error = InfallibleThe type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]
© 2010 The Rust Project Developers
Licensed under the Apache License, Version 2.0 or the MIT license, at your option.
https://doc.rust-lang.org/std/boxed/struct.Box.html