References, both shared and mutable.
A reference represents a borrow of some owned value. You can get one by using the & or &mut operators on a value, or by using a ref or ref mut pattern.
For those familiar with pointers, a reference is just a pointer that is assumed to be aligned, not null, and pointing to memory containing a valid value of T - for example, &bool can only point to an allocation containing the integer values 1 (true) or 0 (false), but creating a &bool that points to an allocation containing the value 3 causes undefined behaviour. In fact, Option<&T> has the same memory representation as a nullable but aligned pointer, and can be passed across FFI boundaries as such.
In most cases, references can be used much like the original value. Field access, method calling, and indexing work the same (save for mutability rules, of course). In addition, the comparison operators transparently defer to the referent's implementation, allowing references to be compared the same as owned values.
References have a lifetime attached to them, which represents the scope for which the borrow is valid. A lifetime is said to "outlive" another one if its representative scope is as long or longer than the other. The 'static lifetime is the longest lifetime, which represents the total life of the program. For example, string literals have a 'static lifetime because the text data is embedded into the binary of the program, rather than in an allocation that needs to be dynamically managed.
&mut T references can be freely coerced into &T references with the same referent type, and references with longer lifetimes can be freely coerced into references with shorter ones.
Reference equality by address, instead of comparing the values pointed to, is accomplished via implicit reference-pointer coercion and raw pointer equality via ptr::eq, while PartialEq compares values.
use std::ptr; let five = 5; let other_five = 5; let five_ref = &five; let same_five_ref = &five; let other_five_ref = &other_five; assert!(five_ref == same_five_ref); assert!(five_ref == other_five_ref); assert!(ptr::eq(five_ref, same_five_ref)); assert!(!ptr::eq(five_ref, other_five_ref));
For more information on how to use references, see the book's section on "References and Borrowing".
The following traits are implemented for all &T, regardless of the type of its referent:
CopyClone (Note that this will not defer to T's Clone implementation if it exists!)DerefBorrowPointer&mut T references get all of the above except Copy and Clone (to prevent creating multiple simultaneous mutable borrows), plus the following, regardless of the type of its referent:
The following traits are implemented on &T references if the underlying T also implements that trait:
std::fmt except Pointer and fmt::Write
PartialOrdOrdPartialEqEqAsRefFn (in addition, &T references get FnMut and FnOnce if T: Fn)HashToSocketAddrs&mut T references get all of the above except ToSocketAddrs, plus the following, if T implements that trait:
AsMutFnMut (in addition, &mut T references get FnOnce if T: FnMut)fmt::WriteIteratorDoubleEndedIteratorExactSizeIteratorFusedIteratorTrustedLenSend (note that &T references only get Send if T: Sync)io::WriteReadSeekBufReadNote that due to method call deref coercion, simply calling a trait method will act like they work on references as well as they do on owned values! The implementations described here are meant for generic contexts, where the final type T is a type parameter or otherwise not locally known.
impl<'_, A> AllocRef for &'_ mut A where
A: AllocRef + ?Sized, [src]
fn alloc(&mut self, layout: Layout) -> Result<NonNull<[u8]>, AllocErr>[src]
fn alloc_zeroed(&mut self, layout: Layout) -> Result<NonNull<[u8]>, AllocErr>[src]
unsafe fn dealloc(&mut self, ptr: NonNull<u8>, layout: Layout)[src]
unsafe fn grow(
&mut self,
ptr: NonNull<u8>,
layout: Layout,
new_size: usize
) -> Result<NonNull<[u8]>, AllocErr>[src]
unsafe fn grow_zeroed(
&mut self,
ptr: NonNull<u8>,
layout: Layout,
new_size: usize
) -> Result<NonNull<[u8]>, AllocErr>[src]
unsafe fn shrink(
&mut self,
ptr: NonNull<u8>,
layout: Layout,
new_size: usize
) -> Result<NonNull<[u8]>, AllocErr>[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]
impl<'_, T, U> AsMut<U> for &'_ mut T where
T: AsMut<U> + ?Sized,
U: ?Sized, [src]
fn as_mut(&mut self) -> &mut Uⓘ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> AsRef<U> for &'_ T where
T: AsRef<U> + ?Sized,
U: ?Sized, [src]
fn as_ref(&self) -> &Uⓘ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> AsRef<U> for &'_ mut T where
T: AsRef<U> + ?Sized,
U: ?Sized, [src]
fn as_ref(&self) -> &Uⓘ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> Binary for &'_ mut T where
T: Binary + ?Sized, [src]
impl<'_, T> Binary for &'_ T where
T: Binary + ?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> Borrow<T> for &'_ mut 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 &'_ mut 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<B: BufRead + ?Sized, '_> BufRead for &'_ mut 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 &'_ T where
T: ?Sized, [src]
Shared references can be cloned, but mutable references cannot!
fn clone(&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]
fn clone_from(&mut self, source: &Self)[src]
impl<'_, T> !Clone for &'_ mut T where
T: ?Sized, [src]
Shared references can be cloned, but mutable references cannot!
#[must_use =
"cloning is often expensive and is not expected to have side effects"]fn clone(&self) -> Self[src]
fn clone_from(&mut self, source: &Self)[src]
impl<'a, 'b, T, U> CoerceUnsized<&'a U> for &'b mut T where
'b: 'a,
T: Unsize<U> + ?Sized,
U: ?Sized, [src]
impl<'a, 'b, T, U> CoerceUnsized<&'a U> for &'b T where
'b: 'a,
T: Unsize<U> + ?Sized,
U: ?Sized, [src]
impl<'a, T, U> CoerceUnsized<&'a mut U> for &'a mut T where
T: Unsize<U> + ?Sized,
U: ?Sized, [src]
impl<'a, T, U> CoerceUnsized<*const U> for &'a T where
T: Unsize<U> + ?Sized,
U: ?Sized, [src]
impl<'a, T, U> CoerceUnsized<*const U> for &'a mut T where
T: Unsize<U> + ?Sized,
U: ?Sized, [src]
impl<'a, T, U> CoerceUnsized<*mut U> for &'a mut T where
T: Unsize<U> + ?Sized,
U: ?Sized, [src]
impl<'_, T> Copy for &'_ T where
T: ?Sized, [src]
Shared references can be copied, but mutable references cannot!
impl<'_, T> Debug for &'_ mut T where
T: Debug + ?Sized, [src]
impl<'_, T> Debug for &'_ T where
T: Debug + ?Sized, [src]
impl<'_, T> Deref for &'_ mut 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> Deref for &'_ 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 &'_ mut 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> !DerefMut for &'_ T where
T: ?Sized, [src]
impl<'a, T, U> DispatchFromDyn<&'a U> for &'a T where
T: Unsize<U> + ?Sized,
U: ?Sized, [src]
impl<'a, T, U> DispatchFromDyn<&'a mut U> for &'a mut T where
T: Unsize<U> + ?Sized,
U: ?Sized, [src]
impl<'_, T> Display for &'_ mut T where
T: Display + ?Sized, [src]
impl<'_, T> Display for &'_ T where
T: Display + ?Sized, [src]
impl<'a, I> DoubleEndedIterator for &'a mut 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<'_, A> Eq for &'_ A where
A: Eq + ?Sized, [src]
impl<'_, A> Eq for &'_ mut A where
A: Eq + ?Sized, [src]
impl<'_, I> ExactSizeIterator for &'_ mut I where
I: ExactSizeIterator + ?Sized, [src]
impl<'_, A, F> Fn<A> for &'_ F where
F: Fn<A> + ?Sized, [src]
impl<'_, A, F> FnMut<A> for &'_ mut F where
F: FnMut<A> + ?Sized, [src]
impl<'_, A, F> FnMut<A> for &'_ F where
F: Fn<A> + ?Sized, [src]
impl<'_, A, F> FnOnce<A> for &'_ F where
F: Fn<A> + ?Sized, [src]
type Output = <F as FnOnce<A>>::OutputThe returned type after the call operator is used.
extern "rust-call" fn call_once(self, args: A) -> <F as FnOnce<A>>::Output[src]
impl<'_, A, F> FnOnce<A> for &'_ mut F where
F: FnMut<A> + ?Sized, [src]
type Output = <F as FnOnce<A>>::OutputThe returned type after the call operator is used.
extern "rust-call" fn call_once(self, args: A) -> <F as FnOnce<A>>::Output[src]
impl<'_, I> FusedIterator for &'_ mut I where
I: FusedIterator + ?Sized, [src]1.26.0
impl<'_, F> Future for &'_ mut 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 &'_ mut F>,
cx: &mut Context<'_>
) -> Poll<<&'_ mut F as Future>::Output>[src]
impl<'_, G, R> Generator<R> for &'_ mut 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 &'_ mut G>,
arg: R
) -> GeneratorState<<&'_ mut G as Generator<R>>::Yield, <&'_ mut G as Generator<R>>::Return>[src]
impl<'_, T> Hash for &'_ mut 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> Hash for &'_ 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<'_, H> Hasher for &'_ mut H where
H: 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 &'_ mut 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<<&'_ mut I as Iterator>::Item>[src]
fn count(self) -> usize[src]
fn last(self) -> Option<Self::Item>[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> LowerExp for &'_ mut T where
T: LowerExp + ?Sized, [src]
impl<'_, T> LowerExp for &'_ T where
T: LowerExp + ?Sized, [src]
impl<'_, T> LowerHex for &'_ mut T where
T: LowerHex + ?Sized, [src]
impl<'_, T> LowerHex for &'_ T where
T: LowerHex + ?Sized, [src]
impl<'_, T> Octal for &'_ T where
T: Octal + ?Sized, [src]
impl<'_, T> Octal for &'_ mut T where
T: Octal + ?Sized, [src]
impl<'_, A> Ord for &'_ A where
A: Ord + ?Sized, [src]
fn cmp(&self, other: &&'_ A) -> 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<'_, A> Ord for &'_ mut A where
A: Ord + ?Sized, [src]
fn cmp(&self, other: &&'_ mut A) -> 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<'_, '_, A, B> PartialEq<&'_ B> for &'_ A where
A: PartialEq<B> + ?Sized,
B: ?Sized, [src]
impl<'_, '_, A, B> PartialEq<&'_ B> for &'_ mut A where
A: PartialEq<B> + ?Sized,
B: ?Sized, [src]
impl<'_, '_, A, B> PartialEq<&'_ mut B> for &'_ mut A where
A: PartialEq<B> + ?Sized,
B: ?Sized, [src]
impl<'_, '_, A, B> PartialEq<&'_ mut B> for &'_ A where
A: PartialEq<B> + ?Sized,
B: ?Sized, [src]
impl<'_, '_, A, B> PartialOrd<&'_ B> for &'_ A where
A: PartialOrd<B> + ?Sized,
B: ?Sized, [src]
fn partial_cmp(&self, other: &&B) -> Option<Ordering>[src]
fn lt(&self, other: &&B) -> bool[src]
fn le(&self, other: &&B) -> bool[src]
fn gt(&self, other: &&B) -> bool[src]
fn ge(&self, other: &&B) -> bool[src]
impl<'_, '_, A, B> PartialOrd<&'_ mut B> for &'_ mut A where
A: PartialOrd<B> + ?Sized,
B: ?Sized, [src]
fn partial_cmp(&self, other: &&mut B) -> Option<Ordering>[src]
fn lt(&self, other: &&mut B) -> bool[src]
fn le(&self, other: &&mut B) -> bool[src]
fn gt(&self, other: &&mut B) -> bool[src]
fn ge(&self, other: &&mut B) -> bool[src]
impl<'_, T> Pointer for &'_ mut T where
T: ?Sized, [src]
impl<'_, T> Pointer for &'_ T where
T: ?Sized, [src]
impl<R: Read + ?Sized, '_> Read for &'_ mut 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 &'_ mut 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> Send for &'_ T where
T: Sync + ?Sized, [src]
impl<'_, T> Send for &'_ mut T where
T: Send + ?Sized, [src]
impl<T: ToSocketAddrs + ?Sized, '_> ToSocketAddrs for &'_ T[src]
type Iter = T::IterReturned iterator over socket addresses which this type may correspond to. Read more
fn to_socket_addrs(&self) -> Result<T::Iter>[src]
impl<'_, I> TrustedLen for &'_ mut I where
I: TrustedLen + ?Sized, [src]
impl<'a, T> Unpin for &'a T where
T: 'a + ?Sized, [src]1.33.0
impl<'a, T> Unpin for &'a mut T where
T: 'a + ?Sized, [src]1.33.0
impl<T: ?Sized, '_> !UnwindSafe for &'_ mut T[src]1.9.0
impl<T: RefUnwindSafe + ?Sized, '_> UnwindSafe for &'_ T[src]1.9.0
impl<'_, T> UpperExp for &'_ mut T where
T: UpperExp + ?Sized, [src]
impl<'_, T> UpperExp for &'_ T where
T: UpperExp + ?Sized, [src]
impl<'_, T> UpperHex for &'_ mut T where
T: UpperHex + ?Sized, [src]
impl<'_, T> UpperHex for &'_ T where
T: UpperHex + ?Sized, [src]
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, [src]1.4.0
fn write_str(&mut self, s: &str) -> Result<(), Error>[src]
fn write_char(&mut self, c: char) -> Result<(), Error>[src]
fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>[src]
impl<W: Write + ?Sized, '_> Write for &'_ mut 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]
© 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/primitive.reference.html