What #[derive(DerefMut)] generates

Deriving Deref only works for a single field of a struct. 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.

1 Example usage

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

#[derive(Deref, DerefMut)]
#[deref(forward)]
#[deref_mut(forward)]
struct MyBoxedInt(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>,
}


fn main() {
    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);
}

2 Structs

When deriving a non-forwarded Deref for a struct:

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

Code like this will be generated:

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

3 Enums

Deriving DerefMut is not supported for enums.