Add generic systems example (#2636)

# Objective
My attempt at fixing #2142. My very first attempt at contributing to Bevy so more than open to any feedback.
I borrowed heavily from the [Bevy Cheatbook page](https://bevy-cheatbook.github.io/patterns/generic-systems.html?highlight=generic#generic-systems).

## Solution
Fairly straightforward example using a clean up system to delete entities that are coupled with app state after exiting that state.


Co-authored-by: B-Janson <brandon@canva.com>

Cargo.toml

@@ -323,6 +323,10 @@ path = "examples/ecs/event.rs"
 name = "fixed_timestep"
 path = "examples/ecs/fixed_timestep.rs"
 
+[[example]]
+name = "generic_system"
+path = "examples/ecs/generic_system.rs"
+
 [[example]]
 name = "hierarchy"
 path = "examples/ecs/hierarchy.rs"

examples/README.md

@@ -168,6 +168,7 @@ Example | File | Description
 `component_change_detection` | [`ecs/component_change_detection.rs`](./ecs/component_change_detection.rs) | Change detection on components
 `event` | [`ecs/event.rs`](./ecs/event.rs) | Illustrates event creation, activation, and reception
 `fixed_timestep` | [`ecs/fixed_timestep.rs`](./ecs/fixed_timestep.rs) | Shows how to create systems that run every fixed timestep, rather than every tick
+`generic_system` | [`ecs/generic_system.rs`](./ecs/generic_system.rs) | Shows how to create systems that can be reused with different types
 `hierarchy` | [`ecs/hierarchy.rs`](./ecs/hierarchy.rs) | Creates a hierarchy of parents and children entities
 `iter_combinations` | [`ecs/iter_combinations.rs`](./ecs/iter_combinations.rs) | Shows how to iterate over combinations of query results.
 `parallel_query` | [`ecs/parallel_query.rs`](./ecs/parallel_query.rs) | Illustrates parallel queries with `ParallelIterator`

examples/ecs/generic_system.rs

@@ -0,0 +1,91 @@
+use bevy::{ecs::component::Component, prelude::*};
+
+/// Generic types allow us to reuse logic across many related systems,
+/// allowing us to specialize our function's behavior based on which type (or types) are passed in.
+///
+/// This is commonly useful for working on related components or resources,
+/// where we want to have unique types for querying purposes but want them all to work the same way.
+/// This is particularly powerful when combined with user-defined traits to add more functionality to these related types.
+/// Remember to insert a specialized copy of the system into the schedule for each type that you want to operate on!
+///
+/// For more advice on working with generic types in Rust, check out <https://doc.rust-lang.org/book/ch10-01-syntax.html>
+/// or <https://doc.rust-lang.org/rust-by-example/generics.html>
+
+#[derive(Debug, Clone, Eq, PartialEq, Hash)]
+enum AppState {
+    MainMenu,
+    InGame,
+}
+
+#[derive(Component)]
+struct TextToPrint(String);
+
+#[derive(Component)]
+struct PrinterTick(bevy::prelude::Timer);
+
+#[derive(Component)]
+struct MenuClose;
+
+#[derive(Component)]
+struct LevelUnload;
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .add_state(AppState::MainMenu)
+        .add_startup_system(setup_system)
+        .add_system(print_text_system)
+        .add_system_set(
+            SystemSet::on_update(AppState::MainMenu).with_system(transition_to_in_game_system),
+        )
+        // add the cleanup systems
+        .add_system_set(
+            // Pass in the types your system should operate on using the ::<T> (turbofish) syntax
+            SystemSet::on_exit(AppState::MainMenu).with_system(cleanup_system::<MenuClose>),
+        )
+        .add_system_set(
+            SystemSet::on_exit(AppState::InGame).with_system(cleanup_system::<LevelUnload>),
+        )
+        .run();
+}
+
+fn setup_system(mut commands: Commands) {
+    commands
+        .spawn()
+        .insert(PrinterTick(bevy::prelude::Timer::from_seconds(1.0, true)))
+        .insert(TextToPrint(
+            "I will print until you press space.".to_string(),
+        ))
+        .insert(MenuClose);
+
+    commands
+        .spawn()
+        .insert(PrinterTick(bevy::prelude::Timer::from_seconds(1.0, true)))
+        .insert(TextToPrint("I will always print".to_string()))
+        .insert(LevelUnload);
+}
+
+fn print_text_system(time: Res<Time>, mut query: Query<(&mut PrinterTick, &TextToPrint)>) {
+    for (mut timer, text) in query.iter_mut() {
+        if timer.0.tick(time.delta()).just_finished() {
+            info!("{}", text.0);
+        }
+    }
+}
+
+fn transition_to_in_game_system(
+    mut state: ResMut<State<AppState>>,
+    keyboard_input: Res<Input<KeyCode>>,
+) {
+    if keyboard_input.pressed(KeyCode::Space) {
+        state.set(AppState::InGame).unwrap();
+    }
+}
+
+// Type arguments on functions come after the function name, but before ordinary arguments.
+// Here, the `Component` trait is a trait bound on T, our generic type
+fn cleanup_system<T: Component>(mut commands: Commands, query: Query<Entity, With<T>>) {
+    for e in query.iter() {
+        commands.entity(e).despawn_recursive();
+    }
+}