Enum IsMut 

pub enum IsMut<'a, T>
where
    T: ?Sized + ToOwned,
{
    Owned(T::Owned),
    MutBorrowed(&'a mut T),
}

Represents an owned or a mutably borrowed data.

Variants

Owned(T::Owned)

Owned data.

MutBorrowed(&'a mut T)

Mutably borrowed data.

Trait Implementations

impl<T, U, O> Add<U> for &IsMut<'_, T>

where T: ?Sized + ToOwned + RefAdd<Owned<U>, Output = O> + for<'a> RefAdd<&'a U::Is, Output = O> + for<'a> RefAdd<&'a mut U::Is, Output = O>, U: AsIs,

type Output = O

The resulting type after applying the + operator.

fn add(self, rhs: U) -> Self::Output

Performs the + operation.

impl<T, U, O> Add<U> for &mut IsMut<'_, T>

where T: ?Sized + ToOwnedMut + RefMutAdd<Owned<U>, Output = O> + for<'a> RefMutAdd<&'a U::Is, Output = O> + for<'a> RefMutAdd<&'a mut U::Is, Output = O>, U: AsIs,

type Output = O

The resulting type after applying the + operator.

fn add(self, rhs: U) -> Self::Output

Performs the + operation.

impl<T, U, O> Add<U> for IsMut<'_, T>

where T: ?Sized + ToOwned + RefMutAdd<Owned<U>, Output = O> + for<'a> RefMutAdd<&'a U::Is, Output = O> + for<'a> RefMutAdd<&'a mut U::Is, Output = O>, U: AsIs, T::Owned: Add<Owned<U>, Output = O> + for<'a> Add<&'a U::Is, Output = O> + for<'a> Add<&'a mut U::Is, Output = O>,

type Output = O

The resulting type after applying the + operator.

fn add(self, rhs: U) -> Self::Output

Performs the + operation.

impl<T, U> AddAssign<U> for IsMut<'_, T>

where T: ?Sized + ToOwned + AddAssign<Owned<U>> + for<'a> AddAssign<&'a U::Is> + for<'a> AddAssign<&'a mut U::Is>, U: AsIs, T::Owned: AddAssign<Owned<U>> + for<'a> AddAssign<&'a U::Is> + for<'a> AddAssign<&'a mut U::Is>,

fn add_assign(&mut self, rhs: U)

Performs the += operation.

impl<T> AsIs for IsMut<'_, T>

where T: ?Sized + BorrowAsIs<Is = T> + ToOwned,

fn as_is<'a>(self) -> Is<'a, T>

where Self: 'a,

Converts self into an Is<'a, Self::Is>.

fn into_is<'a, B>(self) -> Is<'a, B>

where Self: 'a, Self::Is: BorrowMut<B>, B: ?Sized + ToOwned<Owned = Owned<Self>>,

Converts self into an Is<'a, B>.

fn into_is_cow<'a, B>(self) -> IsCow<'a, B>

where Self: 'a, Self::Is: Borrow<B>, B: ?Sized + ToOwned<Owned = Owned<Self>>,

Converts self into an IsCow<'a, B>.

fn try_into_is_mut<'a, B>(self) -> Result<IsMut<'a, B>, Is<'a, Self::Is>>

where Self: 'a, Self::Is: BorrowMut<B>, B: ?Sized + ToOwned<Owned = Owned<Self>>,

Converts self into an IsMut<'a, B> without cloning if possible.

fn try_into_owned<'a>(self) -> Result<Owned<Self>, Is<'a, Self::Is>>

where Self: 'a,

Converts self into an owned data without cloning if possible.

fn into_cow<'a, B>(self) -> Cow<'a, B>

where Self: 'a, Self::Is: Borrow<B>, B: ?Sized + ToOwned<Owned = Owned<Self>>,

Converts self into a Cow<'a, B>. Only available if the alloc feature is enabled.

impl<T, U, O> BitAnd<U> for &IsMut<'_, T>

where T: ?Sized + ToOwned + RefBitAnd<Owned<U>, Output = O> + for<'a> RefBitAnd<&'a U::Is, Output = O> + for<'a> RefBitAnd<&'a mut U::Is, Output = O>, U: AsIs,

type Output = O

The resulting type after applying the & operator.

fn bitand(self, rhs: U) -> Self::Output

Performs the & operation.

impl<T, U, O> BitAnd<U> for &mut IsMut<'_, T>

where T: ?Sized + ToOwnedMut + RefMutBitAnd<Owned<U>, Output = O> + for<'a> RefMutBitAnd<&'a U::Is, Output = O> + for<'a> RefMutBitAnd<&'a mut U::Is, Output = O>, U: AsIs,

type Output = O

The resulting type after applying the & operator.

fn bitand(self, rhs: U) -> Self::Output

Performs the & operation.

impl<T, U, O> BitAnd<U> for IsMut<'_, T>

where T: ?Sized + ToOwned + RefMutBitAnd<Owned<U>, Output = O> + for<'a> RefMutBitAnd<&'a U::Is, Output = O> + for<'a> RefMutBitAnd<&'a mut U::Is, Output = O>, U: AsIs, T::Owned: BitAnd<Owned<U>, Output = O> + for<'a> BitAnd<&'a U::Is, Output = O> + for<'a> BitAnd<&'a mut U::Is, Output = O>,

type Output = O

The resulting type after applying the & operator.

fn bitand(self, rhs: U) -> Self::Output

Performs the & operation.

impl<T, U> BitAndAssign<U> for IsMut<'_, T>

where T: ?Sized + ToOwned + BitAndAssign<Owned<U>> + for<'a> BitAndAssign<&'a U::Is> + for<'a> BitAndAssign<&'a mut U::Is>, U: AsIs, T::Owned: BitAndAssign<Owned<U>> + for<'a> BitAndAssign<&'a U::Is> + for<'a> BitAndAssign<&'a mut U::Is>,

fn bitand_assign(&mut self, rhs: U)

Performs the &= operation.

impl<T, U, O> BitOr<U> for &IsMut<'_, T>

where T: ?Sized + ToOwned + RefBitOr<Owned<U>, Output = O> + for<'a> RefBitOr<&'a U::Is, Output = O> + for<'a> RefBitOr<&'a mut U::Is, Output = O>, U: AsIs,

type Output = O

The resulting type after applying the | operator.

fn bitor(self, rhs: U) -> Self::Output

Performs the | operation.

impl<T, U, O> BitOr<U> for &mut IsMut<'_, T>

where T: ?Sized + ToOwnedMut + RefMutBitOr<Owned<U>, Output = O> + for<'a> RefMutBitOr<&'a U::Is, Output = O> + for<'a> RefMutBitOr<&'a mut U::Is, Output = O>, U: AsIs,

type Output = O

The resulting type after applying the | operator.

fn bitor(self, rhs: U) -> Self::Output

Performs the | operation.

impl<T, U, O> BitOr<U> for IsMut<'_, T>

where T: ?Sized + ToOwned + RefMutBitOr<Owned<U>, Output = O> + for<'a> RefMutBitOr<&'a U::Is, Output = O> + for<'a> RefMutBitOr<&'a mut U::Is, Output = O>, U: AsIs, T::Owned: BitOr<Owned<U>, Output = O> + for<'a> BitOr<&'a U::Is, Output = O> + for<'a> BitOr<&'a mut U::Is, Output = O>,

type Output = O

The resulting type after applying the | operator.

fn bitor(self, rhs: U) -> Self::Output

Performs the | operation.

impl<T, U> BitOrAssign<U> for IsMut<'_, T>

where T: ?Sized + ToOwned + BitOrAssign<Owned<U>> + for<'a> BitOrAssign<&'a U::Is> + for<'a> BitOrAssign<&'a mut U::Is>, U: AsIs, T::Owned: BitOrAssign<Owned<U>> + for<'a> BitOrAssign<&'a U::Is> + for<'a> BitOrAssign<&'a mut U::Is>,

fn bitor_assign(&mut self, rhs: U)

Performs the |= operation.

impl<T, U, O> BitXor<U> for &IsMut<'_, T>

where T: ?Sized + ToOwned + RefBitXor<Owned<U>, Output = O> + for<'a> RefBitXor<&'a U::Is, Output = O> + for<'a> RefBitXor<&'a mut U::Is, Output = O>, U: AsIs,

type Output = O

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: U) -> Self::Output

Performs the ^ operation.

impl<T, U, O> BitXor<U> for &mut IsMut<'_, T>

where T: ?Sized + ToOwnedMut + RefMutBitXor<Owned<U>, Output = O> + for<'a> RefMutBitXor<&'a U::Is, Output = O> + for<'a> RefMutBitXor<&'a mut U::Is, Output = O>, U: AsIs,

type Output = O

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: U) -> Self::Output

Performs the ^ operation.

impl<T, U, O> BitXor<U> for IsMut<'_, T>

where T: ?Sized + ToOwned + RefMutBitXor<Owned<U>, Output = O> + for<'a> RefMutBitXor<&'a U::Is, Output = O> + for<'a> RefMutBitXor<&'a mut U::Is, Output = O>, U: AsIs, T::Owned: BitXor<Owned<U>, Output = O> + for<'a> BitXor<&'a U::Is, Output = O> + for<'a> BitXor<&'a mut U::Is, Output = O>,

type Output = O

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: U) -> Self::Output

Performs the ^ operation.

impl<T, U> BitXorAssign<U> for IsMut<'_, T>

where T: ?Sized + ToOwned + BitXorAssign<Owned<U>> + for<'a> BitXorAssign<&'a U::Is> + for<'a> BitXorAssign<&'a mut U::Is>, U: AsIs, T::Owned: BitXorAssign<Owned<U>> + for<'a> BitXorAssign<&'a U::Is> + for<'a> BitXorAssign<&'a mut U::Is>,

fn bitxor_assign(&mut self, rhs: U)

Performs the ^= operation.

impl<T> Borrow<T> for &IsMut<'_, T>

where T: ?Sized + ToOwned,

fn borrow(&self) -> &T

Immutably borrows from an owned value.

impl<T> Borrow<T> for &mut IsMut<'_, T>

where T: ?Sized + ToOwned,

fn borrow(&self) -> &T

Immutably borrows from an owned value.

impl<T> Borrow<T> for IsMut<'_, T>

where T: ?Sized + ToOwned,

fn borrow(&self) -> &T

Immutably borrows from an owned value.

impl<T> BorrowAsIs for IsMut<'_, T>

where T: ?Sized + BorrowAsIs<Is = T> + ToOwned,

type Is = T

The primary borrow target.

fn borrow_or_clone<B>(&self) -> IsCow<'_, B>

where T: Borrow<B>, B: ?Sized + ToOwned<Owned = T::Owned>,

Immutably borrows from self by default, but can be overridden to clone self if appropriate.

fn borrow_as_is(&self) -> &Self::Is

Immutably borrows from self as Is.

impl<T> BorrowMut<T> for &mut IsMut<'_, T>

where T: ?Sized + ToOwnedMut,

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

Mutably borrows from an owned value.

impl<T> BorrowMut<T> for IsMut<'_, T>

where T: ?Sized + ToOwnedMut,

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

Mutably borrows from an owned value.

impl<'a, T> Debug for IsMut<'a, T>

where T: ?Sized + ToOwned + Debug, T::Owned: Debug,

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

Formats the value using the given formatter.

impl<T> Default for IsMut<'_, T>

where T: ?Sized + ToOwned, T::Owned: Default,

fn default() -> Self

Creates an owned IsMut<'_, T> with the default value for T::Owned.

impl<T> Deref for IsMut<'_, T>

where T: ?Sized + ToOwned,

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T> DerefMut for IsMut<'_, T>

where T: ?Sized + ToOwnedMut,

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

Mutably dereferences the value.

impl<T, U, O> Div<U> for &IsMut<'_, T>

where T: ?Sized + ToOwned + RefDiv<Owned<U>, Output = O> + for<'a> RefDiv<&'a U::Is, Output = O> + for<'a> RefDiv<&'a mut U::Is, Output = O>, U: AsIs,

type Output = O

The resulting type after applying the / operator.

fn div(self, rhs: U) -> Self::Output

Performs the / operation.

impl<T, U, O> Div<U> for &mut IsMut<'_, T>

where T: ?Sized + ToOwnedMut + RefMutDiv<Owned<U>, Output = O> + for<'a> RefMutDiv<&'a U::Is, Output = O> + for<'a> RefMutDiv<&'a mut U::Is, Output = O>, U: AsIs,

type Output = O

The resulting type after applying the / operator.

fn div(self, rhs: U) -> Self::Output

Performs the / operation.

impl<T, U, O> Div<U> for IsMut<'_, T>

where T: ?Sized + ToOwned + RefMutDiv<Owned<U>, Output = O> + for<'a> RefMutDiv<&'a U::Is, Output = O> + for<'a> RefMutDiv<&'a mut U::Is, Output = O>, U: AsIs, T::Owned: Div<Owned<U>, Output = O> + for<'a> Div<&'a U::Is, Output = O> + for<'a> Div<&'a mut U::Is, Output = O>,

type Output = O

The resulting type after applying the / operator.

fn div(self, rhs: U) -> Self::Output

Performs the / operation.

impl<T, U> DivAssign<U> for IsMut<'_, T>

where T: ?Sized + ToOwned + DivAssign<Owned<U>> + for<'a> DivAssign<&'a U::Is> + for<'a> DivAssign<&'a mut U::Is>, U: AsIs, T::Owned: DivAssign<Owned<U>> + for<'a> DivAssign<&'a U::Is> + for<'a> DivAssign<&'a mut U::Is>,

fn div_assign(&mut self, rhs: U)

Performs the /= operation.

impl<T> Hash for IsMut<'_, T>

where T: ?Sized + ToOwned + Hash,

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T, U, O> Mul<U> for &IsMut<'_, T>

where T: ?Sized + ToOwned + RefMul<Owned<U>, Output = O> + for<'a> RefMul<&'a U::Is, Output = O> + for<'a> RefMul<&'a mut U::Is, Output = O>, U: AsIs,

type Output = O

The resulting type after applying the * operator.

fn mul(self, rhs: U) -> Self::Output

Performs the * operation.

impl<T, U, O> Mul<U> for &mut IsMut<'_, T>

where T: ?Sized + ToOwnedMut + RefMutMul<Owned<U>, Output = O> + for<'a> RefMutMul<&'a U::Is, Output = O> + for<'a> RefMutMul<&'a mut U::Is, Output = O>, U: AsIs,

type Output = O

The resulting type after applying the * operator.

fn mul(self, rhs: U) -> Self::Output

Performs the * operation.

impl<T, U, O> Mul<U> for IsMut<'_, T>

where T: ?Sized + ToOwned + RefMutMul<Owned<U>, Output = O> + for<'a> RefMutMul<&'a U::Is, Output = O> + for<'a> RefMutMul<&'a mut U::Is, Output = O>, U: AsIs, T::Owned: Mul<Owned<U>, Output = O> + for<'a> Mul<&'a U::Is, Output = O> + for<'a> Mul<&'a mut U::Is, Output = O>,

type Output = O

The resulting type after applying the * operator.

fn mul(self, rhs: U) -> Self::Output

Performs the * operation.

impl<T, U> MulAssign<U> for IsMut<'_, T>

where T: ?Sized + ToOwned + MulAssign<Owned<U>> + for<'a> MulAssign<&'a U::Is> + for<'a> MulAssign<&'a mut U::Is>, U: AsIs, T::Owned: MulAssign<Owned<U>> + for<'a> MulAssign<&'a U::Is> + for<'a> MulAssign<&'a mut U::Is>,

fn mul_assign(&mut self, rhs: U)

Performs the *= operation.

impl<T> Neg for &IsMut<'_, T>

where T: ?Sized + ToOwned + RefNeg,

type Output = <T as RefNeg>::Output

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T> Neg for &mut IsMut<'_, T>

where T: ?Sized + ToOwnedMut + RefMutNeg,

type Output = <T as RefMutNeg>::Output

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T> Neg for IsMut<'_, T>

where T: ?Sized + ToOwned + RefMutNeg, T::Owned: Neg<Output = T::Output>,

type Output = <T as RefMutNeg>::Output

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T> Not for &IsMut<'_, T>

where T: ?Sized + ToOwned + RefNot,

type Output = <T as RefNot>::Output

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T> Not for &mut IsMut<'_, T>

where T: ?Sized + ToOwnedMut + RefMutNot,

type Output = <T as RefMutNot>::Output

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T> Not for IsMut<'_, T>

where T: ?Sized + ToOwned + RefMutNot, T::Owned: Not<Output = T::Output>,

type Output = <T as RefMutNot>::Output

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T> Ord for IsMut<'_, T>

where T: ?Sized + ToOwned + Ord,

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T, U> PartialEq<Is<'_, U>> for IsMut<'_, T>

where T: ?Sized + ToOwned + PartialEq<U>, U: ?Sized + ToOwned,

fn eq(&self, other: &Is<'_, U>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T, U> PartialEq<IsCow<'_, U>> for IsMut<'_, T>

where T: ?Sized + ToOwned + PartialEq<U>, U: ?Sized + ToOwned,

fn eq(&self, other: &IsCow<'_, U>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T, U> PartialEq<IsMut<'_, U>> for Is<'_, T>

where T: ?Sized + ToOwned + PartialEq<U>, U: ?Sized + ToOwned,

fn eq(&self, other: &IsMut<'_, U>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T, U> PartialEq<IsMut<'_, U>> for IsCow<'_, T>

where T: ?Sized + ToOwned + PartialEq<U>, U: ?Sized + ToOwned,

fn eq(&self, other: &IsMut<'_, U>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T, U> PartialEq<IsMut<'_, U>> for IsMut<'_, T>

where T: ?Sized + ToOwned + PartialEq<U>, U: ?Sized + ToOwned,

fn eq(&self, other: &IsMut<'_, U>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T, U> PartialOrd<Is<'_, U>> for IsMut<'_, T>

where T: ?Sized + ToOwned + PartialOrd<U>, U: ?Sized + ToOwned,

fn partial_cmp(&self, other: &Is<'_, U>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, U> PartialOrd<IsCow<'_, U>> for IsMut<'_, T>

where T: ?Sized + ToOwned + PartialOrd<U>, U: ?Sized + ToOwned,

fn partial_cmp(&self, other: &IsCow<'_, U>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, U> PartialOrd<IsMut<'_, U>> for Is<'_, T>

where T: ?Sized + ToOwned + PartialOrd<U>, U: ?Sized + ToOwned,

fn partial_cmp(&self, other: &IsMut<'_, U>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, U> PartialOrd<IsMut<'_, U>> for IsCow<'_, T>

where T: ?Sized + ToOwned + PartialOrd<U>, U: ?Sized + ToOwned,

fn partial_cmp(&self, other: &IsMut<'_, U>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, U> PartialOrd<IsMut<'_, U>> for IsMut<'_, T>

where T: ?Sized + ToOwned + PartialOrd<U>, U: ?Sized + ToOwned,

fn partial_cmp(&self, other: &IsMut<'_, U>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, U, O> Rem<U> for &IsMut<'_, T>

where T: ?Sized + ToOwned + RefRem<Owned<U>, Output = O> + for<'a> RefRem<&'a U::Is, Output = O> + for<'a> RefRem<&'a mut U::Is, Output = O>, U: AsIs,

type Output = O

The resulting type after applying the % operator.

fn rem(self, rhs: U) -> Self::Output

Performs the % operation.

impl<T, U, O> Rem<U> for &mut IsMut<'_, T>

where T: ?Sized + ToOwnedMut + RefMutRem<Owned<U>, Output = O> + for<'a> RefMutRem<&'a U::Is, Output = O> + for<'a> RefMutRem<&'a mut U::Is, Output = O>, U: AsIs,

type Output = O

The resulting type after applying the % operator.

fn rem(self, rhs: U) -> Self::Output

Performs the % operation.

impl<T, U, O> Rem<U> for IsMut<'_, T>

where T: ?Sized + ToOwned + RefMutRem<Owned<U>, Output = O> + for<'a> RefMutRem<&'a U::Is, Output = O> + for<'a> RefMutRem<&'a mut U::Is, Output = O>, U: AsIs, T::Owned: Rem<Owned<U>, Output = O> + for<'a> Rem<&'a U::Is, Output = O> + for<'a> Rem<&'a mut U::Is, Output = O>,

type Output = O

The resulting type after applying the % operator.

fn rem(self, rhs: U) -> Self::Output

Performs the % operation.

impl<T, U> RemAssign<U> for IsMut<'_, T>

where T: ?Sized + ToOwned + RemAssign<Owned<U>> + for<'a> RemAssign<&'a U::Is> + for<'a> RemAssign<&'a mut U::Is>, U: AsIs, T::Owned: RemAssign<Owned<U>> + for<'a> RemAssign<&'a U::Is> + for<'a> RemAssign<&'a mut U::Is>,

fn rem_assign(&mut self, rhs: U)

Performs the %= operation.

impl<T, U, O> Shl<U> for &IsMut<'_, T>

where T: ?Sized + ToOwned + RefShl<Owned<U>, Output = O> + for<'a> RefShl<&'a U::Is, Output = O> + for<'a> RefShl<&'a mut U::Is, Output = O>, U: AsIs,

type Output = O

The resulting type after applying the << operator.

fn shl(self, rhs: U) -> Self::Output

Performs the << operation.

impl<T, U, O> Shl<U> for &mut IsMut<'_, T>

where T: ?Sized + ToOwnedMut + RefMutShl<Owned<U>, Output = O> + for<'a> RefMutShl<&'a U::Is, Output = O> + for<'a> RefMutShl<&'a mut U::Is, Output = O>, U: AsIs,

type Output = O

The resulting type after applying the << operator.

fn shl(self, rhs: U) -> Self::Output

Performs the << operation.

impl<T, U, O> Shl<U> for IsMut<'_, T>

where T: ?Sized + ToOwned + RefMutShl<Owned<U>, Output = O> + for<'a> RefMutShl<&'a U::Is, Output = O> + for<'a> RefMutShl<&'a mut U::Is, Output = O>, U: AsIs, T::Owned: Shl<Owned<U>, Output = O> + for<'a> Shl<&'a U::Is, Output = O> + for<'a> Shl<&'a mut U::Is, Output = O>,

type Output = O

The resulting type after applying the << operator.

fn shl(self, rhs: U) -> Self::Output

Performs the << operation.

impl<T, U> ShlAssign<U> for IsMut<'_, T>

where T: ?Sized + ToOwned + ShlAssign<Owned<U>> + for<'a> ShlAssign<&'a U::Is> + for<'a> ShlAssign<&'a mut U::Is>, U: AsIs, T::Owned: ShlAssign<Owned<U>> + for<'a> ShlAssign<&'a U::Is> + for<'a> ShlAssign<&'a mut U::Is>,

fn shl_assign(&mut self, rhs: U)

Performs the <<= operation.

impl<T, U, O> Shr<U> for &IsMut<'_, T>

where T: ?Sized + ToOwned + RefShr<Owned<U>, Output = O> + for<'a> RefShr<&'a U::Is, Output = O> + for<'a> RefShr<&'a mut U::Is, Output = O>, U: AsIs,

type Output = O

The resulting type after applying the >> operator.

fn shr(self, rhs: U) -> Self::Output

Performs the >> operation.

impl<T, U, O> Shr<U> for &mut IsMut<'_, T>

where T: ?Sized + ToOwnedMut + RefMutShr<Owned<U>, Output = O> + for<'a> RefMutShr<&'a U::Is, Output = O> + for<'a> RefMutShr<&'a mut U::Is, Output = O>, U: AsIs,

type Output = O

The resulting type after applying the >> operator.

fn shr(self, rhs: U) -> Self::Output

Performs the >> operation.

impl<T, U, O> Shr<U> for IsMut<'_, T>

where T: ?Sized + ToOwned + RefMutShr<Owned<U>, Output = O> + for<'a> RefMutShr<&'a U::Is, Output = O> + for<'a> RefMutShr<&'a mut U::Is, Output = O>, U: AsIs, T::Owned: Shr<Owned<U>, Output = O> + for<'a> Shr<&'a U::Is, Output = O> + for<'a> Shr<&'a mut U::Is, Output = O>,

type Output = O

The resulting type after applying the >> operator.

fn shr(self, rhs: U) -> Self::Output

Performs the >> operation.

impl<T, U> ShrAssign<U> for IsMut<'_, T>

where T: ?Sized + ToOwned + ShrAssign<Owned<U>> + for<'a> ShrAssign<&'a U::Is> + for<'a> ShrAssign<&'a mut U::Is>, U: AsIs, T::Owned: ShrAssign<Owned<U>> + for<'a> ShrAssign<&'a U::Is> + for<'a> ShrAssign<&'a mut U::Is>,

fn shr_assign(&mut self, rhs: U)

Performs the >>= operation.

impl<T, U, O> Sub<U> for &IsMut<'_, T>

where T: ?Sized + ToOwned + RefSub<Owned<U>, Output = O> + for<'a> RefSub<&'a U::Is, Output = O> + for<'a> RefSub<&'a mut U::Is, Output = O>, U: AsIs,

type Output = O

The resulting type after applying the - operator.

fn sub(self, rhs: U) -> Self::Output

Performs the - operation.

impl<T, U, O> Sub<U> for &mut IsMut<'_, T>

where T: ?Sized + ToOwnedMut + RefMutSub<Owned<U>, Output = O> + for<'a> RefMutSub<&'a U::Is, Output = O> + for<'a> RefMutSub<&'a mut U::Is, Output = O>, U: AsIs,

type Output = O

The resulting type after applying the - operator.

fn sub(self, rhs: U) -> Self::Output

Performs the - operation.

impl<T, U, O> Sub<U> for IsMut<'_, T>

where T: ?Sized + ToOwned + RefMutSub<Owned<U>, Output = O> + for<'a> RefMutSub<&'a U::Is, Output = O> + for<'a> RefMutSub<&'a mut U::Is, Output = O>, U: AsIs, T::Owned: Sub<Owned<U>, Output = O> + for<'a> Sub<&'a U::Is, Output = O> + for<'a> Sub<&'a mut U::Is, Output = O>,

type Output = O

The resulting type after applying the - operator.

fn sub(self, rhs: U) -> Self::Output

Performs the - operation.

impl<T, U> SubAssign<U> for IsMut<'_, T>

where T: ?Sized + ToOwned + SubAssign<Owned<U>> + for<'a> SubAssign<&'a U::Is> + for<'a> SubAssign<&'a mut U::Is>, U: AsIs, T::Owned: SubAssign<Owned<U>> + for<'a> SubAssign<&'a U::Is> + for<'a> SubAssign<&'a mut U::Is>,

fn sub_assign(&mut self, rhs: U)

Performs the -= operation.

impl<T> Eq for IsMut<'_, T>

where T: ?Sized + ToOwned + Eq,