Merge queue and queue_fallible

Author: cart

crates/bevy_ecs/src/system/commands/command.rs

@@ -65,7 +65,7 @@ where
 
 /// Takes a [`Command`] that returns a Result and uses a given error handler function to convert it into
 /// a [`Command`] that internally handles an error if it occurs and returns `()`.
-pub trait HandleError {
+pub trait HandleError<T = ()> {
     /// Takes a [`Command`] that returns a Result and uses a given error handler function to convert it into
     /// a [`Command`] that internally handles an error if it occurs and returns `()`.
     fn handle_error_with(self, error_handler: fn(&mut World, Error)) -> impl Command;
@@ -79,23 +79,26 @@ pub trait HandleError {
     }
 }
 
-impl<C: Command<Result>> HandleError for C {
+impl<C: Command<Result<T, E>>, T, E: Into<Error>> HandleError<Result<T, E>> for C {
     fn handle_error_with(self, error_handler: fn(&mut World, Error)) -> impl Command {
         move |world: &mut World| match self.apply(world) {
             Ok(_) => {}
-            Err(err) => (error_handler)(world, err),
+            Err(err) => (error_handler)(world, err.into()),
         }
     }
 }
 
-/// Takes a [`Command`] that returns a [`Result`] with an error that can be converted into the [`Error`] type
-/// and returns a [`Command`] that internally converts that error to [`Error`] (if it occurs).
-pub fn map_command_err<T, E: Into<Error>>(
-    command: impl Command<Result<T, E>>,
-) -> impl Command<Result<T, Error>> {
-    move |world: &mut World| match command.apply(world) {
-        Ok(result) => Ok(result),
-        Err(err) => Err(err.into()),
+impl<C: Command> HandleError for C {
+    #[inline]
+    fn handle_error_with(self, _error_handler: fn(&mut World, Error)) -> impl Command {
+        self
+    }
+    #[inline]
+    fn handle_error(self) -> impl Command
+    where
+        Self: Sized,
+    {
+        self
     }
 }
 

crates/bevy_ecs/src/system/commands/entity_command.rs

@@ -15,7 +15,7 @@ use crate::{
     component::{Component, ComponentId, ComponentInfo},
     entity::{Entity, EntityCloneBuilder},
     event::Event,
-    system::{error_handler, Command, IntoObserverSystem},
+    system::{error_handler, Command, HandleError, IntoObserverSystem},
     world::{error::EntityFetchError, EntityWorldMut, FromWorld, World},
 };
 use bevy_ptr::OwningPtr;
@@ -86,23 +86,34 @@ pub trait EntityCommand<T = ()>: Send + 'static {
 pub trait CommandWithEntity<T> {
     /// Passes in a specific entity to an [`EntityCommand`], resulting in a [`Command`] that
     /// internally runs the [`EntityCommand`] on that entity.
-    fn with_entity(self, entity: Entity) -> impl Command<T>;
+    fn with_entity(self, entity: Entity) -> impl Command<T> + HandleError<T>;
 }
 
-impl<C: EntityCommand<()>> CommandWithEntity<Result<(), EntityFetchError>> for C {
-    fn with_entity(self, entity: Entity) -> impl Command<Result<(), EntityFetchError>> {
-        move |world: &mut World| {
+impl<C: EntityCommand> CommandWithEntity<Result<(), EntityFetchError>> for C {
+    fn with_entity(
+        self,
+        entity: Entity,
+    ) -> impl Command<Result<(), EntityFetchError>> + HandleError<Result<(), EntityFetchError>>
+    {
+        move |world: &mut World| -> Result<(), EntityFetchError> {
             let entity = world.get_entity_mut(entity)?;
             self.apply(entity);
             Ok(())
         }
     }
 }
 
-impl<C: EntityCommand<Result<T, Err>>, T, Err> CommandWithEntity<Result<T, EntityCommandError<Err>>>
-    for C
+impl<
+        C: EntityCommand<Result<T, Err>>,
+        T,
+        Err: core::fmt::Debug + core::fmt::Display + Send + Sync + 'static,
+    > CommandWithEntity<Result<T, EntityCommandError<Err>>> for C
 {
-    fn with_entity(self, entity: Entity) -> impl Command<Result<T, EntityCommandError<Err>>> {
+    fn with_entity(
+        self,
+        entity: Entity,
+    ) -> impl Command<Result<T, EntityCommandError<Err>>> + HandleError<Result<T, EntityCommandError<Err>>>
+    {
         move |world: &mut World| {
             let entity = world.get_entity_mut(entity)?;
             match self.apply(entity) {
@@ -115,7 +126,7 @@ impl<C: EntityCommand<Result<T, Err>>, T, Err> CommandWithEntity<Result<T, Entit
 
 /// Takes a [`EntityCommand`] that returns a Result and uses a given error handler function to convert it into
 /// a [`EntityCommand`] that internally handles an error if it occurs and returns `()`.
-pub trait HandleEntityError {
+pub trait HandleEntityError<T = ()> {
     /// Takes a [`EntityCommand`] that returns a Result and uses a given error handler function to convert it into
     /// a [`EntityCommand`] that internally handles an error if it occurs and returns `()`.
     fn handle_error_with(
@@ -132,7 +143,9 @@ pub trait HandleEntityError {
     }
 }
 
-impl<C: EntityCommand<crate::result::Result>> HandleEntityError for C {
+impl<C: EntityCommand<crate::result::Result<T, E>>, T, E: Into<crate::result::Error>>
+    HandleEntityError<crate::result::Result<T, E>> for C
+{
     fn handle_error_with(
         self,
         error_handler: fn(&mut World, crate::result::Error),
@@ -146,20 +159,27 @@ impl<C: EntityCommand<crate::result::Result>> HandleEntityError for C {
             // SAFETY: location has not changed and entity is valid
             match self.apply(unsafe { EntityWorldMut::new(world, id, location) }) {
                 Ok(_) => {}
-                Err(err) => (error_handler)(world, err),
+                Err(err) => (error_handler)(world, err.into()),
             }
         }
     }
 }
 
-/// Takes a [`EntityCommand`] that returns a [`Result`] with an error that can be converted into the [`Error`] type
-/// and returns a [`EntityCommand`] that internally converts that error to [`Error`] (if it occurs).
-pub fn map_entity_command_err<T, E: Into<crate::result::Error>>(
-    command: impl EntityCommand<Result<T, E>>,
-) -> impl EntityCommand<Result<T, crate::result::Error>> {
-    move |entity: EntityWorldMut| match command.apply(entity) {
-        Ok(result) => Ok(result),
-        Err(err) => Err(err.into()),
+impl<C: EntityCommand> HandleEntityError for C {
+    #[inline]
+    fn handle_error_with(
+        self,
+        _error_handler: fn(&mut World, crate::result::Error),
+    ) -> impl EntityCommand {
+        self
+    }
+
+    #[inline]
+    fn handle_error(self) -> impl EntityCommand
+    where
+        Self: Sized,
+    {
+        self
     }
 }
 

crates/bevy_ecs/src/system/commands/mod.rs

@@ -26,11 +26,10 @@ use crate::{
     entity::{Entities, Entity, EntityCloneBuilder},
     event::Event,
     observer::{Observer, TriggerTargets},
-    result::{Error, Result},
     schedule::ScheduleLabel,
     system::{
-        command::map_command_err, entity_command::map_entity_command_err, input::SystemInput,
-        Deferred, IntoObserverSystem, IntoSystem, RegisteredSystem, Resource, SystemId,
+        input::SystemInput, Deferred, IntoObserverSystem, IntoSystem, RegisteredSystem, Resource,
+        SystemId,
     },
     world::{
         command_queue::RawCommandQueue, unsafe_world_cell::UnsafeWorldCell, CommandQueue,
@@ -589,7 +588,8 @@ impl<'w, 's> Commands<'w, 's> {
     /// # bevy_ecs::system::assert_is_system(add_three_to_counter_system);
     /// # bevy_ecs::system::assert_is_system(add_twenty_five_to_counter_system);
     /// ```
-    pub fn queue<C: Command>(&mut self, command: C) {
+    pub fn queue<C: Command<T> + HandleError<T>, T>(&mut self, command: C) {
+        let command = command.handle_error();
         match &mut self.queue {
             InternalQueue::CommandQueue(queue) => {
                 queue.push(command);
@@ -604,18 +604,6 @@ impl<'w, 's> Commands<'w, 's> {
         }
     }
 
-    /// Pushes a generic [`Command`] to the command queue with error handling.
-    ///
-    /// The command can be:
-    /// - A custom struct that implements [`Command`].
-    /// - A closure or function that has the signature [`(&mut World)`](World)`->`[`Result`](crate::result::Result).
-    /// - A built-in command from the [`command`] module.
-    ///
-    /// This will use the default error handler. See [`Command`] for details on error handling.
-    pub fn queue_fallible<E: Into<Error>>(&mut self, command: impl Command<Result<(), E>>) {
-        self.queue(map_command_err(command).handle_error());
-    }
-
     /// Pushes a [`Command`] to the queue for creating entities, if needed,
     /// and for adding a bundle to each entity.
     ///
@@ -1666,25 +1654,11 @@ impl<'a> EntityCommands<'a> {
     /// # }
     /// # bevy_ecs::system::assert_is_system(my_system);
     /// ```
-    pub fn queue(&mut self, command: impl EntityCommand) -> &mut Self {
-        self.commands
-            .queue_fallible(command.with_entity(self.entity));
-        self
-    }
-
-    /// Pushes a fallible [`EntityCommand`] to the queue, which will get executed for the current [`Entity`].
-    ///
-    /// The command can be:
-    /// - A custom struct that implements [`EntityCommand`].
-    /// - A closure or function that matches the following signature:
-    ///   - [`(EntityWorldMut)`](EntityWorldMut)`->` [`Result<(), E>`]
-    /// - A built-in command from the [`entity_command`] module.
-    pub fn queue_fallible<E: Into<Error>>(
+    pub fn queue<C: EntityCommand<T> + CommandWithEntity<M>, T, M>(
         &mut self,
-        command: impl EntityCommand<Result<(), E>>,
+        command: C,
     ) -> &mut Self {
-        self.commands
-            .queue_fallible(map_entity_command_err(command).with_entity(self.entity));
+        self.commands.queue(command.with_entity(self.entity));
         self
     }