SystemParam lifetime more general.

[mendelsshop]

I have code like this (adapted from https://www.reddit.com/r/bevy/comments/18xgcm8/comment/kg5jmwp/):

use std::{marker::PhantomData, ops::DerefMut};

use bevy::{
    ecs::{
        schedule::ScheduleConfigs,
        system::{ScheduleSystem, StaticSystemParam, SystemParam, SystemParamItem},
    },
    prelude::*,
};

use crate::colors::{HOVERED_BUTTON, NORMAL_BUTTON, PRESSED_BUTTON};

// https://www.reddit.com/r/bevy/comments/18xgcm8/comment/kg5jmwp/
pub trait ButtonInteraction<C: Component>: SystemParam {
    fn interact(&mut self, _: &C);
    fn verify(&mut self, _: &C) -> bool {
        true
    }
}
pub trait SpinnerButtonInteraction<C: Component>: SystemParam {
    fn increment(&mut self, _: &C);
    fn can_increment(&mut self, _: &C) -> bool {
        true
    }

    fn decrement(&mut self, _: &C);
    fn can_decrement(&mut self, _: &C) -> bool {
        true
    }
}
#[derive(SystemParam)]
pub struct SpinnerParmeter<
    'w,
    's,
    C: Component,
    T: SystemParam + SpinnerButtonInteraction<C> + 'static,
>(Query<'w, 's, &'static C>, StaticSystemParam<'w, 's, T>);

#[derive(Debug, Component, Clone, Copy)]
pub struct Up<C>(Entity, PhantomData<C>);
impl<C, T> ButtonInteraction<Up<C>> for SpinnerParmeter<'_, '_, C, T>
where
    C: Component,
    T: SpinnerButtonInteraction<C>
        + for<'w, 's> SystemParam<Item<'w, 's> = T>
        + SpinnerButtonInteraction<C>,
{
    fn interact(&mut self, c: &Up<C>) {
        if let Ok(c) = self.0.get(c.0) {
            self.1.increment(c)
        }
    }

    fn verify(&mut self, c: &Up<C>) -> bool {
        if let Ok(c) = self.0.get(c.0) {
            self.1.deref_mut().can_increment(c)
        } else {
            false
        }
    }
}

#[derive(Debug, Component, Clone, Copy)]
pub struct Down<C>(Entity, PhantomData<C>);
impl<C, T> ButtonInteraction<Down<C>> for SpinnerParmeter<'_, '_, C, T>
where
    C: Component,
    T: SpinnerButtonInteraction<C>
        + for<'w, 's> SystemParam<Item<'w, 's> = T>
        + SpinnerButtonInteraction<C>,
{
    fn interact(&mut self, c: &Down<C>) {
        if let Ok(c) = self.0.get(c.0) {
            self.1.deref_mut().increment(c)
        }
    }

    fn verify(&mut self, c: &Down<C>) -> bool {
        if let Ok(c) = self.0.get(c.0) {
            self.1.deref_mut().can_increment(c)
        } else {
            false
        }
    }
}

#[derive(Debug, Component, Clone, Copy)]
pub struct Value<C>(pub Entity, PhantomData<C>);
pub fn button_system_with_generic<C: Component, T: SystemParam>(
    button_query: Query<'_, '_, (&Interaction, &mut BackgroundColor, &C), (Changed<Interaction>,)>,
    mut param: SystemParamItem<T>,
) where
    for<'w, 's> T::Item<'w, 's>: ButtonInteraction<C>,
{
    for (interaction, mut background_color, c) in button_query {
        if param.verify(c) {
            match *interaction {
                Interaction::Pressed => {
                    param.interact(c);

                    *background_color = PRESSED_BUTTON.into()
                }
                Interaction::Hovered => *background_color = HOVERED_BUTTON.into(),
                Interaction::None => *background_color = NORMAL_BUTTON.into(),
            }
        } else {
            // TODO: have disable button color
            *background_color = NORMAL_BUTTON.into()
        }
    }
}

When the ButtonInteraction interface is implemented, the button_system_with_generic can be used as a system to manage the interactions with the buttons.

The SpinnerButtonInteraction builds on top of the ButtonInteraction, so it should be able to use the button_system_with_generic machinery for the up and down button.
It wraps the SystemParam in a new SystemParam which also contains a query for the spinner's actual component, so that the up and down button don't need to store duplicate information and instead just store a reference (Entity) to the same entity.

An example implementation of SpinnerButtonInteraction:

#[derive(Debug, Component, Resource, Clone, Copy)]
pub enum GameResource {
     // stuff
}

#[derive(Resource)]
pub struct TradingResources {
     // stuff
}
impl TradingResources {
    pub const fn get_mut(&mut self, selector: GameResource) -> &mut i8 {
          todo!(),
    }
}
#[derive(Debug, Component, Clone, Copy)]
pub struct TradingResourcesSpinner(GameResource);
impl SliderButtonInteraction<TradingResourcesSpinner> for ResMut<'_, TradingResources> {
    fn increment(&mut self, resource: &TradingResourcesSpinner) {
        *self.get_mut(resource.0) += 1;
    }
    fn decrement(&mut self, resource: &TradingResourcesSpinner) {
        *self.get_mut(resource.0) -= 1;
    }
}

The problem is when I try to use the button_system_with_generic with spinner like:

fn main() {
    let mut app = App::new();
   app.add_systems(
         Update,
         (common_ui::button_system_with_generic::<
             Down<TradingResourcesSpinner>,
             SpinnerParmeter<'_, '_, TradingResourcesSpinner, ResMut<TradingResources>>,
         >,),
     );
}

I get an error:

error[E0308]: mismatched types
   --> src/main.rs:260:5
    |
260 | /     app.add_systems(
261 | |         Update,
262 | |         (common_ui::button_system_with_generic::<
263 | |             Down<TradingResourcesSlider>,
264 | |             SliderParmeter<'_, '_, TradingResourcesSlider, ResMut<TradingResources>>,
265 | |         >,),
266 | |     );
    | |_____^ one type is more general than the other
    |
    = note: expected struct `bevy::prelude::ResMut<'w, _>`
               found struct `bevy::prelude::ResMut<'_, _>`
note: the lifetime requirement is introduced here
   --> src/common_ui.rs:94:34
    |
94  |     for<'w, 's> T::Item<'w, 's>: ButtonInteraction<C>,
    |                                  ^^^^^^^^^^^^^^^^^^^^

error[E0308]: mismatched types
   --> src/main.rs:262:10
    |
262 |           (common_ui::button_system_with_generic::<
    |  __________^
263 | |             Down<TradingResourcesSlider>,
264 | |             SliderParmeter<'_, '_, TradingResourcesSlider, ResMut<TradingResources>>,
265 | |         >,),
    | |_________^ one type is more general than the other
    |
    = note: expected struct `bevy::prelude::ResMut<'w, _>`
               found struct `bevy::prelude::ResMut<'_, _>`

It works fine when I do it with something that implements ButtonInteraction by itself, but when I do it with something that implements SliderButtonInteraction, I get this error.

Sorry this was pretty long.
If you want, it's also in a git repo: https://github.com/mendelsshop/katan, in common_ui.rs, resource_management.rs, and main.rs.

[mendelsshop]

I got it to work by changing generics impls of ButtonInteraction<Up/Down> to mirror the trait bounds button_system_with_generic.
So putting the SpinnerInteraction constraint on T::Item and then dealing with the lifetimes with a for<'w1, s1>.

:

#[derive(Debug, Component, Clone, Copy)]
pub struct Up<C>(Entity, PhantomData<C>);
impl<'w, 's, C, T> ButtonInteraction<Up<C>> for SpinnerParmeter<'w, 's, C, T>
where
    C: Component,
    T: SystemParam,
    for<'w1, 's1> T::Item<'w1, 's1>: SpinnerButtonInteraction<C>,
{
    fn interact(&mut self, c: &Up<C>) {
        if let Ok(c) = self.0.get(c.0) {
            self.1.increment(c)
        }
    }

    fn verify(&mut self, c: &Up<C>) -> bool {
        if let Ok(c) = self.0.get(c.0) {
            self.1.deref_mut().can_increment(c)
        } else {
            false
        }
    }
}

#[derive(Debug, Component, Clone, Copy)]
pub struct Down<C>(Entity, PhantomData<C>);
impl<'w, 's, C, T> ButtonInteraction<Down<C>> for SpinnerParmeter<'w, 's, C, T>
where
    C: Component,
    T: SystemParam,
    for<'w1, 's1> T::Item<'w1, 's1>: SpinnerButtonInteraction<C>,
{
    fn interact(&mut self, c: &Down<C>) {
        if let Ok(c) = self.0.get(c.0) {
            self.1.deref_mut().decrement(c)
        }
    }

    fn verify(&mut self, c: &Down<C>) -> bool {
        if let Ok(c) = self.0.get(c.0) {
            self.1.deref_mut().can_decrement(c)
        } else {
            false
        }
    }
}