Remove InfallibleCommand trait

Author: NathanSWard

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

@@ -9,6 +9,12 @@ pub trait AddCommand {
     fn add_command(&mut self, command: impl Command);
 }
 
+/// Provides configuration mechanisms in case a command errors.
+/// You can specify a custom handler via [`FallibleCommandConfig::on_failure`] or
+/// use one of the provided implementations.
+///
+/// ## Note
+/// The default error handler logs the error (via [`error!`]), but does not panic.
 pub struct FallibleCommandConfig<'a, C, T>
 where
     C: FallibleCommand,
@@ -59,7 +65,7 @@ where
 }
 
 macro_rules! impl_fallible_commands {
-    ($name:ident, $returnty:ty, $func:ident) => {
+    ($name:ident, $returnty:ty, $returnfunc:ident) => {
         impl<'a, C, T> $name<'a, C, T>
         where
             C: FallibleCommand,
@@ -82,7 +88,7 @@ macro_rules! impl_fallible_commands {
 
             #[inline]
             #[allow(dead_code)]
-            fn return_unit(&mut self) {}
+            fn return_unit(&self) {}
         }
 
         impl<'a, C, T> $name<'a, C, T>
@@ -91,6 +97,7 @@ macro_rules! impl_fallible_commands {
             C::Error: Debug,
             T: AddCommand,
         {
+            /// If the command failed, run the provided `error_handler`.
             pub fn on_failure<'this, H>(&'this mut self, error_handler: H) -> $returnty
             where
                 H: FnOnce(CommandError<'_, C>) + Send + Sync + 'static,
@@ -100,29 +107,34 @@ macro_rules! impl_fallible_commands {
                     command,
                     error_handler,
                 });
-                self.$func()
+                self.$returnfunc()
             }
 
+            /// If the command failed, ignore the error and silently succeed.
             pub fn ignore<'this>(&'this mut self) -> $returnty {
                 let command = self.command.take().unwrap();
                 self.inner
                     .add_command(IgnoreFallibleCommandWrapper(command));
-                self.$func()
+                self.$returnfunc()
             }
 
-            // this is the default
+            /// If the command failed, log the error.
+            ///
+            /// ## Note
+            /// This is the default behavior if no error handler is specified.
             pub fn log_on_failure<'this>(&'this mut self) -> $returnty {
                 let command = self.command.take().unwrap();
                 self.inner
                     .add_command(LoggingFallibleCommandWrapper(command));
-                self.$func()
+                self.$returnfunc()
             }
 
+            /// If the command failed, [`panic!`] with the error.
             pub fn panic_on_failure<'this>(&'this mut self) -> $returnty {
                 let command = self.command.take().unwrap();
                 self.inner
                     .add_command(PanickingFallibleCommandWrapper(command));
-                self.$func()
+                self.$returnfunc()
             }
         }
 

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

@@ -3,21 +3,19 @@ use crate::world::World;
 use bevy_utils::tracing::error;
 use std::fmt::Debug;
 
+/// TODO:
 pub struct CommandError<'a, C: FallibleCommand> {
     pub error: C::Error,
     pub world: &'a mut World,
 }
 
+/// Used for specifying and error for a command.
 pub trait FallibleCommand: Send + Sync + 'static {
     type Error;
 
     fn try_write(self, world: &mut World) -> Result<(), Self::Error>;
 }
 
-pub trait InfallibleCommand: Send + Sync + 'static {
-    fn write(self, world: &mut World);
-}
-
 pub(crate) struct IgnoreFallibleCommandWrapper<C: FallibleCommand>(pub(crate) C);
 
 impl<C> Command for IgnoreFallibleCommandWrapper<C>
@@ -82,19 +80,3 @@ where
         }
     }
 }
-
-pub(crate) struct InfallibleCommandWrapper<C>
-where
-    C: InfallibleCommand,
-{
-    pub(crate) command: C,
-}
-
-impl<C> Command for InfallibleCommandWrapper<C>
-where
-    C: InfallibleCommand,
-{
-    fn write(self: Box<Self>, world: &mut World) {
-        self.command.write(world);
-    }
-}

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

@@ -7,13 +7,13 @@ use crate::{
     entity::{Entities, Entity},
     world::World,
 };
-use fallible::*;
 use std::{fmt::Debug, marker::PhantomData};
 
-pub use config::*;
-pub use fallible::{FallibleCommand, InfallibleCommand};
+pub use config::{FallibleCommandConfig, FinalFallibleCommandConfig};
+pub use fallible::{CommandError, FallibleCommand};
 
 /// A [`World`] mutation.
+/// If this could potentially fail, use [`FallibleCommand`].
 pub trait Command: Send + Sync + 'static {
     fn write(self: Box<Self>, world: &mut World);
 }
@@ -169,16 +169,12 @@ impl<'a> Commands<'a> {
         I: IntoIterator + Send + Sync + 'static,
         I::Item: Bundle,
     {
-        self.queue.push(InfallibleCommandWrapper {
-            command: SpawnBatch { bundles_iter },
-        });
+        self.queue.push(SpawnBatch { bundles_iter });
     }
 
     /// See [`World::insert_resource`].
     pub fn insert_resource<T: Component>(&mut self, resource: T) {
-        self.queue.push(InfallibleCommandWrapper {
-            command: InsertResource { resource },
-        })
+        self.queue.push(InsertResource { resource })
     }
 
     /// Queue a resource removal.
@@ -197,6 +193,15 @@ impl<'a> Commands<'a> {
     pub fn add<C: Command>(&mut self, command: C) {
         self.queue.push(command);
     }
+
+    /// Adds a fallible command to the command list.
+    pub fn add_fallible<C>(&mut self, command: C) -> FinalFallibleCommandConfig<'_, C, Self>
+    where
+        C: FallibleCommand,
+        C::Error: Debug,
+    {
+        FinalFallibleCommandConfig::new(command, self)
+    }
 }
 
 impl<'a> config::AddCommand for Commands<'a> {
@@ -332,11 +337,11 @@ pub struct Spawn<T> {
     pub bundle: T,
 }
 
-impl<T> InfallibleCommand for Spawn<T>
+impl<T> Command for Spawn<T>
 where
     T: Bundle,
 {
-    fn write(self, world: &mut World) {
+    fn write(self: Box<Self>, world: &mut World) {
         world.spawn().insert_bundle(self.bundle);
     }
 }
@@ -349,12 +354,12 @@ where
     pub bundles_iter: I,
 }
 
-impl<I> InfallibleCommand for SpawnBatch<I>
+impl<I> Command for SpawnBatch<I>
 where
     I: IntoIterator + Send + Sync + 'static,
     I::Item: Bundle,
 {
-    fn write(self, world: &mut World) {
+    fn write(self: Box<Self>, world: &mut World) {
         world.spawn_batch(self.bundles_iter);
     }
 }
@@ -545,8 +550,8 @@ pub struct InsertResource<T: Component> {
     pub resource: T,
 }
 
-impl<T: Component> InfallibleCommand for InsertResource<T> {
-    fn write(self, world: &mut World) {
+impl<T: Component> Command for InsertResource<T> {
+    fn write(self: Box<Self>, world: &mut World) {
         world.insert_resource(self.resource);
     }
 }