impl<'a, T: ?Sized> MutexGuard<'a, T>

fn map<U: ?Sized, F>(this: Self, f: F) -> MappedMutexGuard<'a, T, U>
where
    F: FnOnce(&mut T) -> &mut U

Returns a locked view over a portion of the locked data.

Example

# futures::executor::block_on(async {
use futures::lock::{Mutex, MutexGuard};

let data = Mutex::new(Some("value".to_string()));
{
    let locked_str = MutexGuard::map(data.lock().await, |opt| opt.as_mut().unwrap());
    assert_eq!(&*locked_str, "value");
}
# });

impl<'a, T> Freeze for MutexGuard<'a, T>

impl<'a, T> RefUnwindSafe for MutexGuard<'a, T>

impl<'a, T> Unpin for MutexGuard<'a, T>

impl<'a, T> UnsafeUnpin for MutexGuard<'a, T>

impl<'a, T> UnwindSafe for MutexGuard<'a, T>

impl<P, T> Receiver for MutexGuard<'a, T>

impl<T> Any for MutexGuard<'a, T>

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for MutexGuard<'a, T>

fn borrow(self: &Self) -> &T

impl<T> BorrowMut for MutexGuard<'a, T>

fn borrow_mut(self: &mut Self) -> &mut T

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

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into for MutexGuard<'a, T>

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom for MutexGuard<'a, T>

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto for MutexGuard<'a, T>

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>

impl<T: ?Sized + Send> Send for MutexGuard<'_, T>

impl<T: ?Sized + Sync> Sync for MutexGuard<'_, T>

impl<T: ?Sized + fmt::Debug> Debug for MutexGuard<'_, T>

fn fmt(self: &Self, f: &mut Formatter<'_>) -> Result

impl<T: ?Sized> Deref for MutexGuard<'_, T>

fn deref(self: &Self) -> &T

impl<T: ?Sized> DerefMut for MutexGuard<'_, T>

fn deref_mut(self: &mut Self) -> &mut T

impl<T: ?Sized> Drop for MutexGuard<'_, T>

fn drop(self: &mut Self)