Rename Command's "write" method to "apply" (#8814)

neithanmo · alice-i-cecile · web-flow · commit f135535cd604 · 2023-06-12T17:53:47.000Z
# Objective - Fixes #8811 . ## Solution - Rename "write" method to "apply" in Command trait definition. - Rename other implementations of command trait throughout bevy's code base. --- ## Changelog - Changed: `Command::write` has been changed to `Command::apply` - Changed: `EntityCommand::write` has been changed to `EntityCommand::apply` ## Migration Guide - `Command::write` implementations need to be changed to implement `Command::apply` instead. This is a mere name change, with no further actions needed. - `EntityCommand::write` implementations need to be changed to implement `EntityCommand::apply` instead. This is a mere name change, with no further actions needed. --------- Co-authored-by: Alice Cecile <alice.i.cecile@gmail.com>
diff --git a/benches/benches/bevy_ecs/world/commands.rs b/benches/benches/bevy_ecs/world/commands.rs
@@ -125,14 +125,14 @@ struct FakeCommandA;
 struct FakeCommandB(u64);
 
 impl Command for FakeCommandA {
-    fn write(self, world: &mut World) {
+    fn apply(self, world: &mut World) {
         black_box(self);
         black_box(world);
     }
 }
 
 impl Command for FakeCommandB {
-    fn write(self, world: &mut World) {
+    fn apply(self, world: &mut World) {
         black_box(self);
         black_box(world);
     }
@@ -169,7 +169,7 @@ pub fn fake_commands(criterion: &mut Criterion) {
 struct SizedCommand<T: Default + Send + Sync + 'static>(T);
 
 impl<T: Default + Send + Sync + 'static> Command for SizedCommand<T> {
-    fn write(self, world: &mut World) {
+    fn apply(self, world: &mut World) {
         black_box(self);
         black_box(world);
     }
diff --git a/crates/bevy_ecs/src/system/commands/command_queue.rs b/crates/bevy_ecs/src/system/commands/command_queue.rs
@@ -57,7 +57,7 @@ impl CommandQueue {
                 // SAFETY: According to the invariants of `CommandMeta.apply_command_and_get_size`,
                 // `command` must point to a value of type `C`.
                 let command: C = unsafe { command.read_unaligned() };
-                command.write(world);
+                command.apply(world);
                 std::mem::size_of::<C>()
             },
         };
@@ -165,7 +165,7 @@ mod test {
     }
 
     impl Command for DropCheck {
-        fn write(self, _: &mut World) {}
+        fn apply(self, _: &mut World) {}
     }
 
     #[test]
@@ -191,7 +191,7 @@ mod test {
     struct SpawnCommand;
 
     impl Command for SpawnCommand {
-        fn write(self, world: &mut World) {
+        fn apply(self, world: &mut World) {
             world.spawn_empty();
         }
     }
@@ -219,7 +219,7 @@ mod test {
     // some data added to it.
     struct PanicCommand(String);
     impl Command for PanicCommand {
-        fn write(self, _: &mut World) {
+        fn apply(self, _: &mut World) {
             panic!("command is panicking");
         }
     }
@@ -267,7 +267,7 @@ mod test {
 
     struct CommandWithPadding(u8, u16);
     impl Command for CommandWithPadding {
-        fn write(self, _: &mut World) {}
+        fn apply(self, _: &mut World) {}
     }
 
     #[cfg(miri)]
diff --git a/crates/bevy_ecs/src/system/commands/mod.rs b/crates/bevy_ecs/src/system/commands/mod.rs
@@ -32,7 +32,7 @@ use super::{Deferred, Resource, SystemBuffer, SystemMeta};
 /// struct AddToCounter(u64);
 ///
 /// impl Command for AddToCounter {
-///     fn write(self, world: &mut World) {
+///     fn apply(self, world: &mut World) {
 ///         let mut counter = world.get_resource_or_insert_with(Counter::default);
 ///         counter.0 += self.0;
 ///     }
@@ -43,8 +43,12 @@ use super::{Deferred, Resource, SystemBuffer, SystemMeta};
 /// }
 /// ```
 pub trait Command: Send + 'static {
-    /// Executes this command.
-    fn write(self, world: &mut World);
+    /// Applies this command, causing it to mutate the provided `world`.
+    ///
+    /// This method is used to define what a command "does" when it is ultimately applied.
+    /// Because this method takes `self`, you can store data or settings on the type that implements this trait.
+    /// This data is set by the system or other source of the command, and then ultimately read in this method.
+    fn apply(self, world: &mut World);
 }
 
 /// A [`Command`] queue to perform impactful changes to the [`World`].
@@ -522,7 +526,7 @@ impl<'w, 's> Commands<'w, 's> {
     /// struct AddToCounter(u64);
     ///
     /// impl Command for AddToCounter {
-    ///     fn write(self, world: &mut World) {
+    ///     fn apply(self, world: &mut World) {
     ///         let mut counter = world.get_resource_or_insert_with(Counter::default);
     ///         counter.0 += self.0;
     ///     }
@@ -569,7 +573,7 @@ impl<'w, 's> Commands<'w, 's> {
 /// struct CountName;
 ///
 /// impl EntityCommand for CountName {
-///     fn write(self, id: Entity, world: &mut World) {
+///     fn apply(self, id: Entity, world: &mut World) {
 ///         // Get the current value of the counter, and increment it for next time.
 ///         let mut counter = world.resource_mut::<Counter>();
 ///         let i = counter.0;
@@ -605,7 +609,7 @@ impl<'w, 's> Commands<'w, 's> {
 /// ```
 pub trait EntityCommand: Send + 'static {
     /// Executes this command for the given [`Entity`].
-    fn write(self, id: Entity, world: &mut World);
+    fn apply(self, id: Entity, world: &mut World);
     /// Returns a [`Command`] which executes this [`EntityCommand`] for the given [`Entity`].
     fn with_entity(self, id: Entity) -> WithEntity<Self>
     where
@@ -623,8 +627,8 @@ pub struct WithEntity<C: EntityCommand> {
 
 impl<C: EntityCommand> Command for WithEntity<C> {
     #[inline]
-    fn write(self, world: &mut World) {
-        self.cmd.write(self.id, world);
+    fn apply(self, world: &mut World) {
+        self.cmd.apply(self.id, world);
     }
 }
 
@@ -829,7 +833,7 @@ impl<F> Command for F
 where
     F: FnOnce(&mut World) + Send + 'static,
 {
-    fn write(self, world: &mut World) {
+    fn apply(self, world: &mut World) {
         self(world);
     }
 }
@@ -838,7 +842,7 @@ impl<F> EntityCommand for F
 where
     F: FnOnce(Entity, &mut World) + Send + 'static,
 {
-    fn write(self, id: Entity, world: &mut World) {
+    fn apply(self, id: Entity, world: &mut World) {
         self(id, world);
     }
 }
@@ -854,7 +858,7 @@ impl<T> Command for Spawn<T>
 where
     T: Bundle,
 {
-    fn write(self, world: &mut World) {
+    fn apply(self, world: &mut World) {
         world.spawn(self.bundle);
     }
 }
@@ -876,7 +880,7 @@ where
     I: IntoIterator + Send + Sync + 'static,
     I::Item: Bundle,
 {
-    fn write(self, world: &mut World) {
+    fn apply(self, world: &mut World) {
         world.spawn_batch(self.bundles_iter);
     }
 }
@@ -901,7 +905,7 @@ where
     B: Bundle,
     I::IntoIter: Iterator<Item = (Entity, B)>,
 {
-    fn write(self, world: &mut World) {
+    fn apply(self, world: &mut World) {
         if let Err(invalid_entities) = world.insert_or_spawn_batch(self.bundles_iter) {
             error!(
                 "Failed to 'insert or spawn' bundle of type {} into the following invalid entities: {:?}",
@@ -921,7 +925,7 @@ pub struct Despawn {
 }
 
 impl Command for Despawn {
-    fn write(self, world: &mut World) {
+    fn apply(self, world: &mut World) {
         world.despawn(self.entity);
     }
 }
@@ -938,7 +942,7 @@ impl<T> Command for Insert<T>
 where
     T: Bundle + 'static,
 {
-    fn write(self, world: &mut World) {
+    fn apply(self, world: &mut World) {
         if let Some(mut entity) = world.get_entity_mut(self.entity) {
             entity.insert(self.bundle);
         } else {
@@ -961,7 +965,7 @@ impl<T> Command for Remove<T>
 where
     T: Bundle,
 {
-    fn write(self, world: &mut World) {
+    fn apply(self, world: &mut World) {
         if let Some(mut entity_mut) = world.get_entity_mut(self.entity) {
             entity_mut.remove::<T>();
         }
@@ -985,7 +989,7 @@ pub struct InitResource<R: Resource + FromWorld> {
 }
 
 impl<R: Resource + FromWorld> Command for InitResource<R> {
-    fn write(self, world: &mut World) {
+    fn apply(self, world: &mut World) {
         world.init_resource::<R>();
     }
 }
@@ -1006,7 +1010,7 @@ pub struct InsertResource<R: Resource> {
 }
 
 impl<R: Resource> Command for InsertResource<R> {
-    fn write(self, world: &mut World) {
+    fn apply(self, world: &mut World) {
         world.insert_resource(self.resource);
     }
 }
@@ -1017,7 +1021,7 @@ pub struct RemoveResource<R: Resource> {
 }
 
 impl<R: Resource> Command for RemoveResource<R> {
-    fn write(self, world: &mut World) {
+    fn apply(self, world: &mut World) {
         world.remove_resource::<R>();
     }
 }
@@ -1037,7 +1041,7 @@ pub struct LogComponents {
 }
 
 impl Command for LogComponents {
-    fn write(self, world: &mut World) {
+    fn apply(self, world: &mut World) {
         let debug_infos: Vec<_> = world
             .inspect_entity(self.entity)
             .into_iter()
diff --git a/crates/bevy_hierarchy/src/child_builder.rs b/crates/bevy_hierarchy/src/child_builder.rs
@@ -169,7 +169,7 @@ pub struct AddChild {
 }
 
 impl Command for AddChild {
-    fn write(self, world: &mut World) {
+    fn apply(self, world: &mut World) {
         world.entity_mut(self.parent).add_child(self.child);
     }
 }
@@ -183,7 +183,7 @@ pub struct InsertChildren {
 }
 
 impl Command for InsertChildren {
-    fn write(self, world: &mut World) {
+    fn apply(self, world: &mut World) {
         world
             .entity_mut(self.parent)
             .insert_children(self.index, &self.children);
@@ -198,7 +198,7 @@ pub struct PushChildren {
 }
 
 impl Command for PushChildren {
-    fn write(self, world: &mut World) {
+    fn apply(self, world: &mut World) {
         world.entity_mut(self.parent).push_children(&self.children);
     }
 }
@@ -210,7 +210,7 @@ pub struct RemoveChildren {
 }
 
 impl Command for RemoveChildren {
-    fn write(self, world: &mut World) {
+    fn apply(self, world: &mut World) {
         remove_children(self.parent, &self.children, world);
     }
 }
@@ -222,7 +222,7 @@ pub struct ClearChildren {
 }
 
 impl Command for ClearChildren {
-    fn write(self, world: &mut World) {
+    fn apply(self, world: &mut World) {
         clear_children(self.parent, world);
     }
 }
@@ -234,7 +234,7 @@ pub struct ReplaceChildren {
 }
 
 impl Command for ReplaceChildren {
-    fn write(self, world: &mut World) {
+    fn apply(self, world: &mut World) {
         clear_children(self.parent, world);
         world.entity_mut(self.parent).push_children(&self.children);
     }
@@ -247,7 +247,7 @@ pub struct RemoveParent {
 }
 
 impl Command for RemoveParent {
-    fn write(self, world: &mut World) {
+    fn apply(self, world: &mut World) {
         world.entity_mut(self.child).remove_parent();
     }
 }
diff --git a/crates/bevy_hierarchy/src/hierarchy.rs b/crates/bevy_hierarchy/src/hierarchy.rs
@@ -55,7 +55,7 @@ fn despawn_children_recursive(world: &mut World, entity: Entity) {
 }
 
 impl Command for DespawnRecursive {
-    fn write(self, world: &mut World) {
+    fn apply(self, world: &mut World) {
         #[cfg(feature = "trace")]
         let _span = bevy_utils::tracing::info_span!(
             "command",
@@ -68,7 +68,7 @@ impl Command for DespawnRecursive {
 }
 
 impl Command for DespawnChildrenRecursive {
-    fn write(self, world: &mut World) {
+    fn apply(self, world: &mut World) {
         #[cfg(feature = "trace")]
         let _span = bevy_utils::tracing::info_span!(
             "command",
diff --git a/crates/bevy_scene/src/dynamic_scene.rs b/crates/bevy_scene/src/dynamic_scene.rs
@@ -208,7 +208,7 @@ mod tests {
             parent: original_parent_entity,
             child: original_child_entity,
         }
-        .write(&mut world);
+        .apply(&mut world);
 
         // We then write this relationship to a new scene, and then write that scene back to the
         // world to create another parent and child relationship
@@ -229,7 +229,7 @@ mod tests {
             parent: original_child_entity,
             child: from_scene_parent_entity,
         }
-        .write(&mut world);
+        .apply(&mut world);
 
         // We then reload the scene to make sure that from_scene_parent_entity's parent component
         // isn't updated with the entity map, since this component isn't defined in the scene.
diff --git a/crates/bevy_scene/src/scene_spawner.rs b/crates/bevy_scene/src/scene_spawner.rs
@@ -284,7 +284,7 @@ impl SceneSpawner {
                             parent,
                             child: entity,
                         }
-                        .write(world);
+                        .apply(world);
                     }
                 }
             } else {
diff --git a/crates/bevy_transform/src/commands.rs b/crates/bevy_transform/src/commands.rs
@@ -21,12 +21,12 @@ pub struct AddChildInPlace {
     pub child: Entity,
 }
 impl Command for AddChildInPlace {
-    fn write(self, world: &mut World) {
+    fn apply(self, world: &mut World) {
         let hierarchy_command = AddChild {
             child: self.child,
             parent: self.parent,
         };
-        hierarchy_command.write(world);
+        hierarchy_command.apply(world);
         // FIXME: Replace this closure with a `try` block. See: https://github.com/rust-lang/rust/issues/31436.
         let mut update_transform = || {
             let parent = *world.get_entity(self.parent)?.get::<GlobalTransform>()?;
@@ -49,9 +49,9 @@ pub struct RemoveParentInPlace {
     pub child: Entity,
 }
 impl Command for RemoveParentInPlace {
-    fn write(self, world: &mut World) {
+    fn apply(self, world: &mut World) {
         let hierarchy_command = RemoveParent { child: self.child };
-        hierarchy_command.write(world);
+        hierarchy_command.apply(world);
         // FIXME: Replace this closure with a `try` block. See: https://github.com/rust-lang/rust/issues/31436.
         let mut update_transform = || {
             let child_global = *world.get_entity(self.child)?.get::<GlobalTransform>()?;

Original file line number	Diff line number	Diff line change
`@@ -125,14 +125,14 @@ struct FakeCommandA;`
`125`	`125`	`struct FakeCommandB(u64);`
`126`	`126`
`127`	`127`	`impl Command for FakeCommandA {`
`128`		`- fn write(self, world: &mut World) {`
	`128`	`+ fn apply(self, world: &mut World) {`
`129`	`129`	`black_box(self);`
`130`	`130`	`black_box(world);`
`131`	`131`	`}`
`132`	`132`	`}`
`133`	`133`
`134`	`134`	`impl Command for FakeCommandB {`
`135`		`- fn write(self, world: &mut World) {`
	`135`	`+ fn apply(self, world: &mut World) {`
`136`	`136`	`black_box(self);`
`137`	`137`	`black_box(world);`
`138`	`138`	`}`
`@@ -169,7 +169,7 @@ pub fn fake_commands(criterion: &mut Criterion) {`
`169`	`169`	`struct SizedCommand<T: Default + Send + Sync + 'static>(T);`
`170`	`170`
`171`	`171`	`impl<T: Default + Send + Sync + 'static> Command for SizedCommand<T> {`
`172`		`- fn write(self, world: &mut World) {`
	`172`	`+ fn apply(self, world: &mut World) {`
`173`	`173`	`black_box(self);`
`174`	`174`	`black_box(world);`
`175`	`175`	`}`
Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ impl CommandQueue {`
`57`	`57`	// SAFETY: According to the invariants of `CommandMeta.apply_command_and_get_size`,
`58`	`58`	// `command` must point to a value of type `C`.
`59`	`59`	`let command: C = unsafe { command.read_unaligned() };`
`60`		`- command.write(world);`
	`60`	`+ command.apply(world);`
`61`	`61`	`std::mem::size_of::<C>()`
`62`	`62`	`},`
`63`	`63`	`};`
`@@ -165,7 +165,7 @@ mod test {`
`165`	`165`	`}`
`166`	`166`
`167`	`167`	`impl Command for DropCheck {`
`168`		`- fn write(self, _: &mut World) {}`
	`168`	`+ fn apply(self, _: &mut World) {}`
`169`	`169`	`}`
`170`	`170`
`171`	`171`	`#[test]`
`@@ -191,7 +191,7 @@ mod test {`
`191`	`191`	`struct SpawnCommand;`
`192`	`192`
`193`	`193`	`impl Command for SpawnCommand {`
`194`		`- fn write(self, world: &mut World) {`
	`194`	`+ fn apply(self, world: &mut World) {`
`195`	`195`	`world.spawn_empty();`
`196`	`196`	`}`
`197`	`197`	`}`
`@@ -219,7 +219,7 @@ mod test {`
`219`	`219`	`// some data added to it.`
`220`	`220`	`struct PanicCommand(String);`
`221`	`221`	`impl Command for PanicCommand {`
`222`		`- fn write(self, _: &mut World) {`
	`222`	`+ fn apply(self, _: &mut World) {`
`223`	`223`	`panic!("command is panicking");`
`224`	`224`	`}`
`225`	`225`	`}`
`@@ -267,7 +267,7 @@ mod test {`
`267`	`267`
`268`	`268`	`struct CommandWithPadding(u8, u16);`
`269`	`269`	`impl Command for CommandWithPadding {`
`270`		`- fn write(self, _: &mut World) {}`
	`270`	`+ fn apply(self, _: &mut World) {}`
`271`	`271`	`}`
`272`	`272`
`273`	`273`	`#[cfg(miri)]`
Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,7 @@ use super::{Deferred, Resource, SystemBuffer, SystemMeta};`
`32`	`32`	`/// struct AddToCounter(u64);`
`33`	`33`	`///`
`34`	`34`	`/// impl Command for AddToCounter {`
`35`		`-/// fn write(self, world: &mut World) {`
	`35`	`+/// fn apply(self, world: &mut World) {`
`36`	`36`	`/// let mut counter = world.get_resource_or_insert_with(Counter::default);`
`37`	`37`	`/// counter.0 += self.0;`
`38`	`38`	`/// }`
`@@ -43,8 +43,12 @@ use super::{Deferred, Resource, SystemBuffer, SystemMeta};`
`43`	`43`	`/// }`
`44`	`44`	/// ```
`45`	`45`	`pub trait Command: Send + 'static {`
`46`		`- /// Executes this command.`
`47`		`- fn write(self, world: &mut World);`
	`46`	+ /// Applies this command, causing it to mutate the provided `world`.
	`47`	`+ ///`
	`48`	`+ /// This method is used to define what a command "does" when it is ultimately applied.`
	`49`	+ /// Because this method takes `self`, you can store data or settings on the type that implements this trait.
	`50`	`+ /// This data is set by the system or other source of the command, and then ultimately read in this method.`
	`51`	`+ fn apply(self, world: &mut World);`
`48`	`52`	`}`
`49`	`53`
`50`	`54`	/// A [`Command`] queue to perform impactful changes to the [`World`].
`@@ -522,7 +526,7 @@ impl<'w, 's> Commands<'w, 's> {`
`522`	`526`	`/// struct AddToCounter(u64);`
`523`	`527`	`///`
`524`	`528`	`/// impl Command for AddToCounter {`
`525`		`- /// fn write(self, world: &mut World) {`
	`529`	`+ /// fn apply(self, world: &mut World) {`
`526`	`530`	`/// let mut counter = world.get_resource_or_insert_with(Counter::default);`
`527`	`531`	`/// counter.0 += self.0;`
`528`	`532`	`/// }`
`@@ -569,7 +573,7 @@ impl<'w, 's> Commands<'w, 's> {`
`569`	`573`	`/// struct CountName;`
`570`	`574`	`///`
`571`	`575`	`/// impl EntityCommand for CountName {`
`572`		`-/// fn write(self, id: Entity, world: &mut World) {`
	`576`	`+/// fn apply(self, id: Entity, world: &mut World) {`
`573`	`577`	`/// // Get the current value of the counter, and increment it for next time.`
`574`	`578`	`/// let mut counter = world.resource_mut::<Counter>();`
`575`	`579`	`/// let i = counter.0;`
`@@ -605,7 +609,7 @@ impl<'w, 's> Commands<'w, 's> {`
`605`	`609`	/// ```
`606`	`610`	`pub trait EntityCommand: Send + 'static {`
`607`	`611`	/// Executes this command for the given [`Entity`].
`608`		`- fn write(self, id: Entity, world: &mut World);`
	`612`	`+ fn apply(self, id: Entity, world: &mut World);`
`609`	`613`	/// Returns a [`Command`] which executes this [`EntityCommand`] for the given [`Entity`].
`610`	`614`	`fn with_entity(self, id: Entity) -> WithEntity<Self>`
`611`	`615`	`where`
`@@ -623,8 +627,8 @@ pub struct WithEntity<C: EntityCommand> {`
`623`	`627`
`624`	`628`	`impl<C: EntityCommand> Command for WithEntity<C> {`
`625`	`629`	`#[inline]`
`626`		`- fn write(self, world: &mut World) {`
`627`		`- self.cmd.write(self.id, world);`
	`630`	`+ fn apply(self, world: &mut World) {`
	`631`	`+ self.cmd.apply(self.id, world);`
`628`	`632`	`}`
`629`	`633`	`}`
`630`	`634`
`@@ -829,7 +833,7 @@ impl<F> Command for F`
`829`	`833`	`where`
`830`	`834`	`F: FnOnce(&mut World) + Send + 'static,`
`831`	`835`	`{`
`832`		`- fn write(self, world: &mut World) {`
	`836`	`+ fn apply(self, world: &mut World) {`
`833`	`837`	`self(world);`
`834`	`838`	`}`
`835`	`839`	`}`
`@@ -838,7 +842,7 @@ impl<F> EntityCommand for F`
`838`	`842`	`where`
`839`	`843`	`F: FnOnce(Entity, &mut World) + Send + 'static,`
`840`	`844`	`{`
`841`		`- fn write(self, id: Entity, world: &mut World) {`
	`845`	`+ fn apply(self, id: Entity, world: &mut World) {`
`842`	`846`	`self(id, world);`
`843`	`847`	`}`
`844`	`848`	`}`
`@@ -854,7 +858,7 @@ impl<T> Command for Spawn<T>`
`854`	`858`	`where`
`855`	`859`	`T: Bundle,`
`856`	`860`	`{`
`857`		`- fn write(self, world: &mut World) {`
	`861`	`+ fn apply(self, world: &mut World) {`
`858`	`862`	`world.spawn(self.bundle);`
`859`	`863`	`}`
`860`	`864`	`}`
`@@ -876,7 +880,7 @@ where`
`876`	`880`	`I: IntoIterator + Send + Sync + 'static,`
`877`	`881`	`I::Item: Bundle,`
`878`	`882`	`{`
`879`		`- fn write(self, world: &mut World) {`
	`883`	`+ fn apply(self, world: &mut World) {`
`880`	`884`	`world.spawn_batch(self.bundles_iter);`
`881`	`885`	`}`
`882`	`886`	`}`
`@@ -901,7 +905,7 @@ where`
`901`	`905`	`B: Bundle,`
`902`	`906`	`I::IntoIter: Iterator<Item = (Entity, B)>,`
`903`	`907`	`{`
`904`		`- fn write(self, world: &mut World) {`
	`908`	`+ fn apply(self, world: &mut World) {`
`905`	`909`	`if let Err(invalid_entities) = world.insert_or_spawn_batch(self.bundles_iter) {`
`906`	`910`	`error!(`
`907`	`911`	`"Failed to 'insert or spawn' bundle of type {} into the following invalid entities: {:?}",`
`@@ -921,7 +925,7 @@ pub struct Despawn {`
`921`	`925`	`}`
`922`	`926`
`923`	`927`	`impl Command for Despawn {`
`924`		`- fn write(self, world: &mut World) {`
	`928`	`+ fn apply(self, world: &mut World) {`
`925`	`929`	`world.despawn(self.entity);`
`926`	`930`	`}`
`927`	`931`	`}`
`@@ -938,7 +942,7 @@ impl<T> Command for Insert<T>`
`938`	`942`	`where`
`939`	`943`	`T: Bundle + 'static,`
`940`	`944`	`{`
`941`		`- fn write(self, world: &mut World) {`
	`945`	`+ fn apply(self, world: &mut World) {`
`942`	`946`	`if let Some(mut entity) = world.get_entity_mut(self.entity) {`
`943`	`947`	`entity.insert(self.bundle);`
`944`	`948`	`} else {`
`@@ -961,7 +965,7 @@ impl<T> Command for Remove<T>`
`961`	`965`	`where`
`962`	`966`	`T: Bundle,`
`963`	`967`	`{`
`964`		`- fn write(self, world: &mut World) {`
	`968`	`+ fn apply(self, world: &mut World) {`
`965`	`969`	`if let Some(mut entity_mut) = world.get_entity_mut(self.entity) {`
`966`	`970`	`entity_mut.remove::<T>();`
`967`	`971`	`}`
`@@ -985,7 +989,7 @@ pub struct InitResource<R: Resource + FromWorld> {`
`985`	`989`	`}`
`986`	`990`
`987`	`991`	`impl<R: Resource + FromWorld> Command for InitResource<R> {`
`988`		`- fn write(self, world: &mut World) {`
	`992`	`+ fn apply(self, world: &mut World) {`
`989`	`993`	`world.init_resource::<R>();`
`990`	`994`	`}`
`991`	`995`	`}`
`@@ -1006,7 +1010,7 @@ pub struct InsertResource<R: Resource> {`
`1006`	`1010`	`}`
`1007`	`1011`
`1008`	`1012`	`impl<R: Resource> Command for InsertResource<R> {`
`1009`		`- fn write(self, world: &mut World) {`
	`1013`	`+ fn apply(self, world: &mut World) {`
`1010`	`1014`	`world.insert_resource(self.resource);`
`1011`	`1015`	`}`
`1012`	`1016`	`}`
`@@ -1017,7 +1021,7 @@ pub struct RemoveResource<R: Resource> {`
`1017`	`1021`	`}`
`1018`	`1022`
`1019`	`1023`	`impl<R: Resource> Command for RemoveResource<R> {`
`1020`		`- fn write(self, world: &mut World) {`
	`1024`	`+ fn apply(self, world: &mut World) {`
`1021`	`1025`	`world.remove_resource::<R>();`
`1022`	`1026`	`}`
`1023`	`1027`	`}`
`@@ -1037,7 +1041,7 @@ pub struct LogComponents {`
`1037`	`1041`	`}`
`1038`	`1042`
`1039`	`1043`	`impl Command for LogComponents {`
`1040`		`- fn write(self, world: &mut World) {`
	`1044`	`+ fn apply(self, world: &mut World) {`
`1041`	`1045`	`let debug_infos: Vec<_> = world`
`1042`	`1046`	`.inspect_entity(self.entity)`
`1043`	`1047`	`.into_iter()`
Original file line number	Diff line number	Diff line change
`@@ -169,7 +169,7 @@ pub struct AddChild {`
`169`	`169`	`}`
`170`	`170`
`171`	`171`	`impl Command for AddChild {`
`172`		`- fn write(self, world: &mut World) {`
	`172`	`+ fn apply(self, world: &mut World) {`
`173`	`173`	`world.entity_mut(self.parent).add_child(self.child);`
`174`	`174`	`}`
`175`	`175`	`}`
`@@ -183,7 +183,7 @@ pub struct InsertChildren {`
`183`	`183`	`}`
`184`	`184`
`185`	`185`	`impl Command for InsertChildren {`
`186`		`- fn write(self, world: &mut World) {`
	`186`	`+ fn apply(self, world: &mut World) {`
`187`	`187`	`world`
`188`	`188`	`.entity_mut(self.parent)`
`189`	`189`	`.insert_children(self.index, &self.children);`
`@@ -198,7 +198,7 @@ pub struct PushChildren {`
`198`	`198`	`}`
`199`	`199`
`200`	`200`	`impl Command for PushChildren {`
`201`		`- fn write(self, world: &mut World) {`
	`201`	`+ fn apply(self, world: &mut World) {`
`202`	`202`	`world.entity_mut(self.parent).push_children(&self.children);`
`203`	`203`	`}`
`204`	`204`	`}`
`@@ -210,7 +210,7 @@ pub struct RemoveChildren {`
`210`	`210`	`}`
`211`	`211`
`212`	`212`	`impl Command for RemoveChildren {`
`213`		`- fn write(self, world: &mut World) {`
	`213`	`+ fn apply(self, world: &mut World) {`
`214`	`214`	`remove_children(self.parent, &self.children, world);`
`215`	`215`	`}`
`216`	`216`	`}`
`@@ -222,7 +222,7 @@ pub struct ClearChildren {`
`222`	`222`	`}`
`223`	`223`
`224`	`224`	`impl Command for ClearChildren {`
`225`		`- fn write(self, world: &mut World) {`
	`225`	`+ fn apply(self, world: &mut World) {`
`226`	`226`	`clear_children(self.parent, world);`
`227`	`227`	`}`
`228`	`228`	`}`
`@@ -234,7 +234,7 @@ pub struct ReplaceChildren {`
`234`	`234`	`}`
`235`	`235`
`236`	`236`	`impl Command for ReplaceChildren {`
`237`		`- fn write(self, world: &mut World) {`
	`237`	`+ fn apply(self, world: &mut World) {`
`238`	`238`	`clear_children(self.parent, world);`
`239`	`239`	`world.entity_mut(self.parent).push_children(&self.children);`
`240`	`240`	`}`
`@@ -247,7 +247,7 @@ pub struct RemoveParent {`
`247`	`247`	`}`
`248`	`248`
`249`	`249`	`impl Command for RemoveParent {`
`250`		`- fn write(self, world: &mut World) {`
	`250`	`+ fn apply(self, world: &mut World) {`
`251`	`251`	`world.entity_mut(self.child).remove_parent();`
`252`	`252`	`}`
`253`	`253`	`}`
Original file line number	Diff line number	Diff line change
`@@ -284,7 +284,7 @@ impl SceneSpawner {`
`284`	`284`	`parent,`
`285`	`285`	`child: entity,`
`286`	`286`	`}`
`287`		`- .write(world);`
	`287`	`+ .apply(world);`
`288`	`288`	`}`
`289`	`289`	`}`
`290`	`290`	`} else {`