feat: add ResWith effect for transforming a resource with a function

Cargo.toml

@@ -9,3 +9,4 @@ bevy = "0.15.2"
 [dev-dependencies]
 proptest = "1.6.0"
 proptest-derive = "0.5.1"
+blake2 = "0.10.2"

mvp-effects.md

@@ -1,6 +1,6 @@
 # Resource Effects
 - [x] `ResPut`
-- [ ] `ResWith`
+- [x] `ResWith`
 
 # Local?
 - [ ] `LocalPut`?

src/effects/mod.rs

@@ -3,4 +3,4 @@
 //! [`Effect`]: crate::Effect
 
 mod resource;
-pub use resource::ResPut;
+pub use resource::{ResPut, ResWith};

src/effects/resource.rs

@@ -1,3 +1,5 @@
+use std::marker::PhantomData;
+
 use bevy::ecs::system::SystemParam;
 use bevy::prelude::*;
 
@@ -19,8 +21,47 @@ where
     }
 }
 
+/// [`Effect`] that transforms a `Resource` with the provided function.
+#[derive(Copy, Clone, Debug, Default, PartialEq, Eq)]
+pub struct ResWith<F, R>
+where
+    F: FnOnce(R) -> R,
+    R: Resource + Clone,
+{
+    f: F,
+    phantom: PhantomData<R>,
+}
+
+impl<F, R> ResWith<F, R>
+where
+    F: FnOnce(R) -> R,
+    R: Resource + Clone,
+{
+    /// Construct a new [`ResWith`].
+    pub fn new(f: F) -> Self {
+        ResWith {
+            f,
+            phantom: PhantomData,
+        }
+    }
+}
+
+impl<F, R> Effect for ResWith<F, R>
+where
+    F: FnOnce(R) -> R,
+    R: Resource + Clone,
+{
+    type MutParam = ResMut<'static, R>;
+
+    fn affect(self, param: &mut <Self::MutParam as SystemParam>::Item<'_, '_>) {
+        **param = (self.f)(param.clone());
+    }
+}
+
 #[cfg(test)]
 mod tests {
+    use blake2::digest::consts::U4;
+    use blake2::{Blake2b, Digest};
     use proptest::prelude::*;
     use proptest_derive::Arbitrary;
 
@@ -30,21 +71,56 @@ mod tests {
     #[derive(Copy, Clone, Debug, PartialEq, Eq, Resource, Arbitrary)]
     struct NumberResource(i32);
 
+    fn number_resource_one_way_fn_fn(
+        salt: Vec<u8>,
+    ) -> impl FnOnce(NumberResource) -> NumberResource + Clone {
+        move |NumberResource(input)| {
+            let data = salt
+                .into_iter()
+                .chain(input.to_be_bytes())
+                .collect::<Vec<_>>();
+
+            let mut hasher = Blake2b::<U4>::new();
+            hasher.update(data);
+            let res = hasher.finalize();
+
+            NumberResource(i32::from_be_bytes(res.into()))
+        }
+    }
+
     proptest! {
         #[test]
         fn res_put_overwrites_initial_state(initial: NumberResource, put: NumberResource) {
             let mut app = App::new();
 
             prop_assume!(initial != put);
 
-            app.insert_resource(initial).add_systems(Update, (move || ResPut(put)).pipe(affect));
+            app.insert_resource(initial)
+                .add_systems(Update, (move || ResPut(put)).pipe(affect));
 
             prop_assert_eq!(app.world().resource::<NumberResource>(), &initial);
 
             app.update();
 
             prop_assert_eq!(app.world().resource::<NumberResource>(), &put);
+        }
+
+        #[test]
+        fn res_with_correctly_executes_one_way_function(initial: NumberResource, salt: Vec<u8>) {
+            let f = number_resource_one_way_fn_fn(salt);
+
+            let expected = f.clone()(initial);
+
+            let mut app = App::new();
+
+            app.insert_resource(initial.clone())
+                .add_systems(Update, (move || ResWith::new(f.clone())).pipe(affect));
+
+            prop_assert_eq!(app.world().resource::<NumberResource>(), &initial);
+
+            app.update();
 
+            prop_assert_eq!(app.world().resource::<NumberResource>(), &expected);
         }
     }
 }

src/prelude.rs

@@ -1,5 +1,5 @@
 //! `use bevy_pipe_affect::prelude::*;` to import common items.
 
-pub use crate::effects::ResPut;
+pub use crate::effects::{ResPut, ResWith};
 pub use crate::system_combinators::{affect, and_compose};
 pub use crate::{Effect, EffectOut};