Missing EntityWorldMut::into_mut(self)

[jkb0o]

What problem does this solve or what need does it fill?

For my plugin I'd like to have closures that takes Entity and &' mut World and returns Mut<'w, T>:

fn translation<'w>(id: Entity, world: &'w mut World) -> Mut<'w, Vec3> {
    world
        .entity_mut(id)
        .get_mut::<Transform>()
        .unwrap()
        .map_unchanged(|t| &mut t.translation)
}

This code won't compile:

cannot return value referencing temporary value
returns a value referencing data owned by the current function

It happens because EntityWorldMut<'w>::get_mut(&mut self) returns Mut with lifetime of &mut self instead of 'w.

What solution would you like?

It would be nice to have some method on EntityWorldMut like get_mut but that consumes self and returns Mut<'w, T>:

// bevy_ecs/world/entity_ref.rs
impl<'w> EntityWorldMut<'w> {
  pub fn into_mut<T: Component>(self) -> Option<Mut<'w, T>> {
    unsafe { self.into_unsafe_entity_cell().get_mut() }
  }
}

It is possible to implement the translation function for now:

fn translation<'w>(id: Entity, world: &'w mut World) -> Mut<'w, Vec3> {
  world
    .entity_mut(id)
    .into_mut::<Transform>()
    .unwrap()
    .map_unchanged(|t| &mut t.translation)
}

What alternative(s) have you considered?

I didn't find a way to bypass proper lifetime within my transform function without making changes to engine.

[james7132]

Might be good to add an equivalent functions for EntityMut and EntityRef:

• EntityRef::into_borrow
• EntityRef::into_ref
• EntityRef::into_borrow
• EntityMut::into_ref
• EntityMut::into_mut
• EntityWorldMut::into_borrow
• EntityWorldMut::into_ref
• EntityWorldMut::into_mut

The docs will likely need to clarify what the difference between these and get/get_mut is.

[jkb0o]

@james7132 I'm not sure we need EntityRef::into_ methods. I have no problems with read-only lifetimes. This one compiles well:

fn translation_ref<'w>(id: Entity, world: &'w mut World) -> Ref<'w, Vec3> {
    world
        .entity(id)
        .get_ref::<Transform>()
        .unwrap()
        .map(|r| &r.translation)
}

The problem only with mutable access.

[jkb0o]

And I'm not sure what into_borrow means. If it is an alternative to reborrow then it doesn't look practical for me: reborrow is about to convert &'a mut EntityMut<'w> into EntityMut<'a>, there is no place for consuming self here.

[james7132]

Ah right, Entity*::get returns &'w T. Makes sense as it's Copy. The mutable variants are the only ones that need it.

into_borrow would return &'w T instead of Ref<'w, T>.