Derive Macro DerefMut 

#[derive(DerefMut)]
{
    // Attributes available to this derive:
    #[deref_mut]
}

What #[derive(DerefMut)] generates

Deriving Deref only works for a single field of a struct, or a single field of each variant of an enum. Furthermore it requires that the type also implements Deref, so usually Deref should also be derived. The resulting implementation of Deref will allow you to mutably dereference the struct its member directly.

1. Dereferencing to the field, i.e. like if your type was a reference type.
2. Doing a dereference on the field, for when the field itself is a reference type like &mut and Box.

With #[deref_mut] or #[deref_mut(ignore)] it’s possible to indicate the field that you want to derive DerefMut for.

Example usage

#[derive(Deref, DerefMut)]
struct Num {
    num: i32,
}

#[derive(Deref, DerefMut)]
enum Enum {
    V1(i32),
    V2 { num: i32 },
}

#[derive(Deref, DerefMut)]
#[deref(forward)]
#[deref_mut(forward)]
struct MyBoxedInt(Box<i32>);

#[derive(Deref, DerefMut)]
#[deref(forward)]
#[deref_mut(forward)]
enum MyBoxedIntEnum {
    V1(Box<i32>),
    V2 { num: Box<i32> },
}

// You can specify the field you want to derive DerefMut for
#[derive(Deref, DerefMut)]
struct CoolVec {
    cool: bool,
    #[deref]
    #[deref_mut]
    vec: Vec<i32>,
}

#[derive(Deref, DerefMut)]
enum CoolVecEnum {
    V1(Vec<i32>),
    V2 {
        cool: bool,
        #[deref]
        #[deref_mut]
        vec: Vec<i32>,
    },
}

let mut num = Num{num: 123};
let mut boxed = MyBoxedInt(Box::new(123));
let mut cool_vec = CoolVec{cool: true, vec: vec![123]};
*num += 123;
assert_eq!(246, *num);
*boxed += 1000;
assert_eq!(1123, *boxed);
cool_vec.push(456);
assert_eq!(vec![123, 456], *cool_vec);

Structs

When deriving a non-forwarded DerefMut for a struct:

#[derive(Deref, DerefMut)]
struct CoolVec {
    cool: bool,
    #[deref]
    #[deref_mut]
    vec: Vec<i32>,
}

Code like this will be generated:

impl derive_more::core::ops::DerefMut for CoolVec {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.vec
    }
}

When deriving DerefMut for a tuple struct with one field:

#[derive(Deref, DerefMut)]
#[deref(forward)]
#[deref_mut(forward)]
struct MyBoxedInt(Box<i32>);

When deriving a forwarded DerefMut for a struct:

impl derive_more::core::ops::DerefMut for MyBoxedInt {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        <Box<i32> as derive_more::core::ops::DerefMut>::deref_mut(&mut self.0)
    }
}

Enums

When deriving a non-forwarded DerefMut for an enum:

#[derive(Deref, DerefMut)]
enum CoolVecEnum {
    V1(Vec<i32>),
    V2 {
        cool: bool,
        #[deref]
        #[deref_mut]
        vec: Vec<i32>,
    },
}

Code like this will be generated:

impl derive_more::with_trait::DerefMut for CoolVecEnum {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        match self {
            CoolVecEnum::V1(__0) => __0,
            CoolVecEnum::V2 { cool: _, vec: __0 } => __0,
        }
    }
}

When deriving a forwarded DerefMut for an enum:

#[derive(Deref, DerefMut)]
#[deref(forward)]
#[deref_mut(forward)]
enum MyBoxedIntEnum {
    V1(Box<i32>),
    V2 { num: Box<i32> },
}

Code like this will be generated:

impl derive_more::with_trait::DerefMut for MyBoxedIntEnum {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        match self {
            MyBoxedIntEnum::V1(__0) => {
                <Box<i32> as derive_more::with_trait::DerefMut>::deref_mut(__0)
            }
            MyBoxedIntEnum::V2 { num: __0 } => {
                <Box<i32> as derive_more::with_trait::DerefMut>::deref_mut(__0)
            }
        }
    }
}