feat!: upgrade to bevy 0.19

Cargo.toml

@@ -14,7 +14,7 @@ exclude = ["assets/", "ci/", ".github/"]
 members = ["effect_derive"]
 
 [dependencies]
-bevy = { version = "0.18.0", default-features = false }
+bevy = { version = "0.19.0", default-features = false }
 bevy_pipe_affect_derive = { version = "0.3.0", path = "effect_derive", optional = true }
 
 # bevy with no default features actually depends on all of these, no need to hide them behind flags
@@ -23,7 +23,7 @@ variadics_please = "1.1.0"
 either = "1.15.0"
 
 [dev-dependencies]
-bevy = { version = "0.18.0" }
+bevy = { version = "0.19.0" }
 proptest = "1.8.0"
 proptest-derive = "0.6.0"
 blake2 = "0.10.6"

README.md

@@ -79,6 +79,7 @@ $ cargo run --release --all-features --example example-name
 ## Compatibility
 | bevy | bevy_pipe_affect |
 | --- | --- |
+| 0.19 | main |
 | 0.18 | 0.3 |
 | 0.18 | 0.2 |
 | 0.17 | 0.1 |

src/effects/command.rs

@@ -34,6 +34,8 @@ use crate::Effect;
 /// struct InitScores(Vec<Entity>);
 ///
 /// impl Command for InitScores {
+///     type Out = ();
+///
 ///     fn apply(self, world: &mut World) {
 ///         world.insert_batch_if_new(self.0.into_iter().map(|entity| (entity, Score(0))));
 ///     }

src/effects/entity_command.rs

@@ -1,7 +1,6 @@
 //! [`Effect`]s that queue entity-specific `Commands`.
 use std::marker::PhantomData;
 
-use bevy::ecs::error::CommandWithEntity;
 use bevy::prelude::*;
 
 use crate::Effect;
@@ -20,7 +19,6 @@ use crate::Effect;
 /// In this example, a system is written that removes all components from the `Player` entity
 /// except for the `Player` component.
 /// ```rust
-/// use bevy::ecs::error::CommandWithEntity;
 /// use bevy::ecs::system::entity_command::retain;
 /// use bevy::ecs::world::error::EntityMutableFetchError;
 /// use bevy::prelude::*;
@@ -32,11 +30,7 @@ use crate::Effect;
 /// /// Pure system using effects.
 /// fn reset_player_pure(
 ///     player: Single<Entity, With<Player>>,
-/// ) -> EntityCommandQueue<
-///     impl EntityCommand<()> + CommandWithEntity<Result<(), EntityMutableFetchError>> + use<>,
-///     (),
-///     Result<(), EntityMutableFetchError>,
-/// > {
+/// ) -> EntityCommandQueue<impl EntityCommand + use<>> {
 ///     entity_command_queue(*player, retain::<Player>())
 /// }
 ///
@@ -105,42 +99,35 @@ use crate::Effect;
 /// ```
 #[doc = include_str!("defer_command_note.md")]
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
-pub struct EntityCommandQueue<C, T, M>
+pub struct EntityCommandQueue<C>
 where
-    C: EntityCommand<T> + CommandWithEntity<M>,
+    C: EntityCommand,
 {
     entity: Entity,
     command: C,
-    entity_command_out: PhantomData<T>,
-    command_with_entity_out: PhantomData<M>,
 }
 
-impl<C, T, M> EntityCommandQueue<C, T, M>
+impl<C> EntityCommandQueue<C>
 where
-    C: EntityCommand<T> + CommandWithEntity<M>,
+    C: EntityCommand,
 {
     /// Construct a new [`EntityCommandQueue`]
     pub fn new(entity: Entity, command: C) -> Self {
-        EntityCommandQueue {
-            entity,
-            command,
-            entity_command_out: PhantomData,
-            command_with_entity_out: PhantomData,
-        }
+        EntityCommandQueue { entity, command }
     }
 }
 
 /// Construct a new [`EntityCommandQueue`] [`Effect`].
-pub fn entity_command_queue<C, T, M>(entity: Entity, command: C) -> EntityCommandQueue<C, T, M>
+pub fn entity_command_queue<C>(entity: Entity, command: C) -> EntityCommandQueue<C>
 where
-    C: EntityCommand<T> + CommandWithEntity<M>,
+    C: EntityCommand,
 {
     EntityCommandQueue::new(entity, command)
 }
 
-impl<C, T, M> Effect for EntityCommandQueue<C, T, M>
+impl<C> Effect for EntityCommandQueue<C>
 where
-    C: EntityCommand<T> + CommandWithEntity<M>,
+    C: EntityCommand,
 {
     type MutParam = Commands<'static, 'static>;
 

src/effects/error.rs

@@ -2,7 +2,7 @@
 //!
 //! On top of the types shown here, this implements [`Effect`] for...
 //! - `Result<T, E>` where `T: Effect` and `E: Into<BevyError>`
-use bevy::ecs::error::{DefaultErrorHandler, ErrorContext};
+use bevy::ecs::error::{ErrorContext, FallbackErrorHandler};
 use bevy::ecs::system::{SystemChangeTick, SystemName};
 use bevy::prelude::*;
 
@@ -33,7 +33,7 @@ use crate::Effect;
 /// bevy::ecs::system::assert_is_system(zero_red_clear_color_srgba.pipe(affect))
 /// ```
 ///
-/// Using a plain `Result` as an effect works too, but uses `bevy`'s `DefaultErrorHandler`.
+/// Using a plain `Result` as an effect works too, but uses `bevy`'s `FallbackErrorHandler`.
 ///
 /// Can be constructed with [`affect_or_handle`].
 #[derive(derive_more::Debug)]
@@ -123,7 +123,7 @@ where
     Er: Into<BevyError>,
 {
     type MutParam = (
-        Option<Res<'static, DefaultErrorHandler>>,
+        Option<Res<'static, FallbackErrorHandler>>,
         (Ef::MutParam, SystemName, SystemChangeTick),
     );
 

src/effects/message.rs

@@ -138,7 +138,7 @@ where
 ///     });
 /// }
 /// #
-/// # use bevy::ecs::error::{ignore, DefaultErrorHandler};
+/// # use bevy::ecs::error::{ignore, FallbackErrorHandler};
 /// # use proptest::prelude::*;
 /// #
 /// # fn app_setup(
@@ -147,7 +147,7 @@ where
 /// # ) -> App {
 /// #     let mut app = App::new();
 /// #     app.add_message::<Winner>()
-/// #         .insert_resource(DefaultErrorHandler(ignore));
+/// #         .insert_resource(FallbackErrorHandler(ignore));
 /// #
 /// #     let entities = component_table
 /// #         .into_iter()

src/effects/query.rs

@@ -136,9 +136,10 @@ where
     type MutParam = Query<'static, 'static, QueryDataE::MutQueryData, Filter>;
 
     fn affect(self, param: &mut <Self::MutParam as bevy::ecs::system::SystemParam>::Item<'_, '_>) {
-        param
-            .iter_mut()
-            .for_each(|mut query_data| self.query_data_effect.clone().affect(&mut query_data));
+        let mut iter = param.iter_mut();
+        while let Some(mut query_data) = iter.fetch_next() {
+            self.query_data_effect.clone().affect(&mut query_data);
+        }
     }
 }
 

src/effects/query_entity.rs

@@ -10,7 +10,7 @@ use crate::{Effect, EffectOut};
 
 /// [`Effect`] that applies the given [`QueryDataEffect`] to the given entity.
 ///
-/// Produces an error (handled by `bevy`'s `DefaultErrorHandler`) if the entity does not exist in
+/// Produces an error (handled by `bevy`'s `FallbackErrorHandler`) if the entity does not exist in
 /// the [`QueryDataEffect::Filter`] (and the optional `Filter` generic).
 ///
 /// Can be constructed by [`query_entity_affect`].
@@ -43,13 +43,13 @@ use crate::{Effect, EffectOut};
 ///     query.get_mut(top_player.0)?.0 = 0.5;
 ///     Ok(())
 /// }
-/// # use bevy::ecs::error::{ignore, DefaultErrorHandler};
+/// # use bevy::ecs::error::{ignore, FallbackErrorHandler};
 /// # use proptest::prelude::*;
 /// #
 /// # fn app_setup(entity_table: Vec<Option<Defense>>, top_player_index: usize) -> App {
 /// #     let mut app = App::new();
 /// #
-/// #     app.insert_resource(DefaultErrorHandler(ignore));
+/// #     app.insert_resource(FallbackErrorHandler(ignore));
 /// #
 /// #     let entities = entity_table.into_iter().fold(
 /// #         vec![app.world_mut().spawn_empty().id()],
@@ -162,7 +162,7 @@ where
 /// [`Effect`] that applies the given mapping of `QueryData` to [`QueryDataEffect`] to the given
 /// entity, and applies the [`QueryDataEffect`].
 ///
-/// Produces an error (handled by `bevy`'s `DefaultErrorHandler`) if the entity isn't selected by
+/// Produces an error (handled by `bevy`'s `FallbackErrorHandler`) if the entity isn't selected by
 /// `QueryDataIn`'s or `QueryDataE`'s filters or the optional `Filter` generic.
 ///
 /// Can be constructed by [`query_entity_map`].
@@ -203,13 +203,13 @@ where
 ///     attack_multiplier.0 = 1.0 + ((100.0 - health.0) / 100.0);
 ///     Ok(())
 /// }
-/// # use bevy::ecs::error::{ignore, DefaultErrorHandler};
+/// # use bevy::ecs::error::{ignore, FallbackErrorHandler};
 /// # use proptest::prelude::*;
 /// #
 /// # fn app_setup(entity_table: Vec<(Option<Health>, Option<AttackMultiplier>)>, bottom_player_index: usize) -> App {
 /// #     let mut app = App::new();
 /// #
-/// #     app.insert_resource(DefaultErrorHandler(ignore));
+/// #     app.insert_resource(FallbackErrorHandler(ignore));
 /// #
 /// #     let entities = entity_table.into_iter().fold(
 /// #         vec![app.world_mut().spawn_empty().id()],
@@ -345,7 +345,7 @@ where
 /// (as an `EffectOut<Effect, QueryDataEffect>` to the given entity, and applies the
 /// [`QueryDataEffect`] + [`Effect`].
 ///
-/// Produces an error (handled by `bevy`'s `DefaultErrorHandler`) if the entity isn't selected by
+/// Produces an error (handled by `bevy`'s `FallbackErrorHandler`) if the entity isn't selected by
 /// `QueryDataIn`'s or `QueryDataE`'s filters or the optional `Filter` generic.
 ///
 /// Can be constructed by [`query_entity_map_and`].
@@ -395,13 +395,13 @@ where
 ///     }
 ///     Ok(())
 /// }
-/// # use bevy::ecs::error::{ignore, DefaultErrorHandler};
+/// # use bevy::ecs::error::{ignore, FallbackErrorHandler};
 /// # use proptest::prelude::*;
 /// #
 /// # fn app_setup(entity_table: Vec<Option<Health>>, cursed_player_index: usize) -> App {
 /// #     let mut app = App::new();
 /// #
-/// #     app.insert_resource(DefaultErrorHandler(ignore));
+/// #     app.insert_resource(FallbackErrorHandler(ignore));
 /// #
 /// #     let entities = entity_table.into_iter().fold(
 /// #         vec![app.world_mut().spawn_empty().id()],

src/effects/resource.rs

@@ -1,6 +1,7 @@
 //! [`Effect`]s that modify resources.
 use std::any::type_name;
 
+use bevy::ecs::component::Mutable;
 use bevy::ecs::system::SystemParam;
 use bevy::prelude::*;
 
@@ -61,7 +62,7 @@ use crate::effect::Effect;
 #[derive(Copy, Clone, Debug, Default, PartialEq, Eq)]
 pub struct ResSet<R>
 where
-    R: Resource,
+    R: Resource + Component<Mutability = Mutable>,
 {
     /// The value that the resource will be set to.
     pub value: R,
@@ -70,14 +71,14 @@ where
 /// Construct a new [`ResSet`] [`Effect`].
 pub fn res_set<R>(value: R) -> ResSet<R>
 where
-    R: Resource,
+    R: Resource + Component<Mutability = Mutable>,
 {
     ResSet { value }
 }
 
 impl<R> Effect for ResSet<R>
 where
-    R: Resource,
+    R: Resource + Component<Mutability = Mutable>,
 {
     type MutParam = ResMut<'static, R>;
 
@@ -141,7 +142,7 @@ where
 #[derive(derive_more::Debug)]
 pub struct ResSetWith<R>
 where
-    R: Resource,
+    R: Resource + Component<Mutability = Mutable>,
 {
     /// The function that maps the resource to its new value.
     #[debug("{} -> {}", type_name::<&R>(), type_name::<R>())]
@@ -152,14 +153,14 @@ where
 pub fn res_set_with<F, R>(f: F) -> ResSetWith<R>
 where
     F: FnOnce(&R) -> R + 'static,
-    R: Resource,
+    R: Resource + Component<Mutability = Mutable>,
 {
     ResSetWith { f: Box::new(f) }
 }
 
 impl<R> Default for ResSetWith<R>
 where
-    R: Resource + Clone,
+    R: Resource + Component<Mutability = Mutable> + Clone,
 {
     fn default() -> Self {
         res_set_with(|r: &R| r.clone())
@@ -168,7 +169,7 @@ where
 
 impl<R> Effect for ResSetWith<R>
 where
-    R: Resource,
+    R: Resource + Component<Mutability = Mutable>,
 {
     type MutParam = ResMut<'static, R>;
 

tests/derive_compilation.rs

@@ -110,7 +110,7 @@ fn effect_with_effect_parameter_implements_effect() {
     >());
 }
 
-#[derive(Clone, Component, Resource)]
+#[derive(Clone, Resource)]
 struct MyComponentResource;
 
 #[derive(Effect)]