[Merged by Bors] - Use consistent names for marker generics

crates/bevy_app/src/app.rs

@@ -378,7 +378,7 @@ impl App {
     /// #
     /// app.add_system(my_system);
     /// ```
-    pub fn add_system<P>(&mut self, system: impl IntoSystemConfig<P>) -> &mut Self {
+    pub fn add_system<M>(&mut self, system: impl IntoSystemConfig<M>) -> &mut Self {
         let mut schedules = self.world.resource_mut::<Schedules>();
 
         if let Some(default_schedule) = schedules.get_mut(&*self.default_schedule_label) {
@@ -406,7 +406,7 @@ impl App {
     /// #
     /// app.add_systems((system_a, system_b, system_c));
     /// ```
-    pub fn add_systems<P>(&mut self, systems: impl IntoSystemConfigs<P>) -> &mut Self {
+    pub fn add_systems<M>(&mut self, systems: impl IntoSystemConfigs<M>) -> &mut Self {
         let mut schedules = self.world.resource_mut::<Schedules>();
 
         if let Some(default_schedule) = schedules.get_mut(&*self.default_schedule_label) {
@@ -420,10 +420,10 @@ impl App {
     }
 
     /// Adds a system to the provided [`Schedule`].
-    pub fn add_system_to_schedule<P>(
+    pub fn add_system_to_schedule<M>(
         &mut self,
         schedule_label: impl ScheduleLabel,
-        system: impl IntoSystemConfig<P>,
+        system: impl IntoSystemConfig<M>,
     ) -> &mut Self {
         let mut schedules = self.world.resource_mut::<Schedules>();
 
@@ -437,10 +437,10 @@ impl App {
     }
 
     /// Adds a collection of system to the provided [`Schedule`].
-    pub fn add_systems_to_schedule<P>(
+    pub fn add_systems_to_schedule<M>(
         &mut self,
         schedule_label: impl ScheduleLabel,
-        systems: impl IntoSystemConfigs<P>,
+        systems: impl IntoSystemConfigs<M>,
     ) -> &mut Self {
         let mut schedules = self.world.resource_mut::<Schedules>();
 
@@ -471,7 +471,7 @@ impl App {
     /// App::new()
     ///     .add_startup_system(my_startup_system);
     /// ```
-    pub fn add_startup_system<P>(&mut self, system: impl IntoSystemConfig<P>) -> &mut Self {
+    pub fn add_startup_system<M>(&mut self, system: impl IntoSystemConfig<M>) -> &mut Self {
         self.add_system_to_schedule(CoreSchedule::Startup, system)
     }
 
@@ -496,7 +496,7 @@ impl App {
     ///     )
     /// );
     /// ```
-    pub fn add_startup_systems<P>(&mut self, systems: impl IntoSystemConfigs<P>) -> &mut Self {
+    pub fn add_startup_systems<M>(&mut self, systems: impl IntoSystemConfigs<M>) -> &mut Self {
         self.add_systems_to_schedule(CoreSchedule::Startup, systems)
     }
 

crates/bevy_ecs/src/schedule/condition.rs

@@ -8,7 +8,7 @@ pub type BoxedCondition = Box<dyn ReadOnlySystem<In = (), Out = bool>>;
 ///
 /// Implemented for functions and closures that convert into [`System<In=(), Out=bool>`](crate::system::System)
 /// with [read-only](crate::system::ReadOnlySystemParam) parameters.
-pub trait Condition<Params>: sealed::Condition<Params> {
+pub trait Condition<Marker>: sealed::Condition<Marker> {
     /// Returns a new run condition that only returns `true`
     /// if both this one and the passed `and_then` return `true`.
     ///
@@ -53,7 +53,7 @@ pub trait Condition<Params>: sealed::Condition<Params> {
     /// Note that in this case, it's better to just use the run condition [`resource_exists_and_equals`].
     ///
     /// [`resource_exists_and_equals`]: common_conditions::resource_exists_and_equals
-    fn and_then<P, C: Condition<P>>(self, and_then: C) -> AndThen<Self::System, C::System> {
+    fn and_then<M, C: Condition<M>>(self, and_then: C) -> AndThen<Self::System, C::System> {
         let a = IntoSystem::into_system(self);
         let b = IntoSystem::into_system(and_then);
         let name = format!("{} && {}", a.name(), b.name());
@@ -100,30 +100,30 @@ pub trait Condition<Params>: sealed::Condition<Params> {
     /// # app.run(&mut world);
     /// # assert!(world.resource::<C>().0);
     /// ```
-    fn or_else<P, C: Condition<P>>(self, or_else: C) -> OrElse<Self::System, C::System> {
+    fn or_else<M, C: Condition<M>>(self, or_else: C) -> OrElse<Self::System, C::System> {
         let a = IntoSystem::into_system(self);
         let b = IntoSystem::into_system(or_else);
         let name = format!("{} || {}", a.name(), b.name());
         CombinatorSystem::new(a, b, Cow::Owned(name))
     }
 }
 
-impl<Params, F> Condition<Params> for F where F: sealed::Condition<Params> {}
+impl<Marker, F> Condition<Marker> for F where F: sealed::Condition<Marker> {}
 
 mod sealed {
     use crate::system::{IntoSystem, ReadOnlySystem};
 
-    pub trait Condition<Params>:
-        IntoSystem<(), bool, Params, System = Self::ReadOnlySystem>
+    pub trait Condition<Marker>:
+        IntoSystem<(), bool, Marker, System = Self::ReadOnlySystem>
     {
         // This associated type is necessary to let the compiler
         // know that `Self::System` is `ReadOnlySystem`.
         type ReadOnlySystem: ReadOnlySystem<In = (), Out = bool>;
     }
 
-    impl<Params, F> Condition<Params> for F
+    impl<Marker, F> Condition<Marker> for F
     where
-        F: IntoSystem<(), bool, Params>,
+        F: IntoSystem<(), bool, Marker>,
         F::System: ReadOnlySystem,
     {
         type ReadOnlySystem = F::System;
@@ -373,8 +373,8 @@ pub mod common_conditions {
     /// #
     /// # fn my_system() { unreachable!() }
     /// ```
-    pub fn not<Params>(
-        condition: impl Condition<Params>,
+    pub fn not<Marker>(
+        condition: impl Condition<Marker>,
     ) -> impl ReadOnlySystem<In = (), Out = bool> {
         condition.pipe(|In(val): In<bool>| !val)
     }

crates/bevy_ecs/src/schedule/config.rs

@@ -54,7 +54,7 @@ impl SystemConfig {
     }
 }
 
-fn new_condition<P>(condition: impl Condition<P>) -> BoxedCondition {
+fn new_condition<M>(condition: impl Condition<M>) -> BoxedCondition {
     let condition_system = IntoSystem::into_system(condition);
     assert!(
         condition_system.is_send(),
@@ -100,7 +100,7 @@ pub trait IntoSystemSetConfig: sealed::IntoSystemSetConfig {
     ///
     /// The `Condition` will be evaluated at most once (per schedule run),
     /// the first time a system in this set prepares to run.
-    fn run_if<P>(self, condition: impl Condition<P>) -> SystemSetConfig;
+    fn run_if<M>(self, condition: impl Condition<M>) -> SystemSetConfig;
     /// Suppress warnings and errors that would result from systems in this set having ambiguities
     /// (conflicting access but indeterminate order) with systems in `set`.
     fn ambiguous_with<M>(self, set: impl IntoSystemSet<M>) -> SystemSetConfig;
@@ -139,7 +139,7 @@ where
         self.into_config().after(set)
     }
 
-    fn run_if<P>(self, condition: impl Condition<P>) -> SystemSetConfig {
+    fn run_if<M>(self, condition: impl Condition<M>) -> SystemSetConfig {
         self.into_config().run_if(condition)
     }
 
@@ -179,7 +179,7 @@ impl IntoSystemSetConfig for BoxedSystemSet {
         self.into_config().after(set)
     }
 
-    fn run_if<P>(self, condition: impl Condition<P>) -> SystemSetConfig {
+    fn run_if<M>(self, condition: impl Condition<M>) -> SystemSetConfig {
         self.into_config().run_if(condition)
     }
 
@@ -254,7 +254,7 @@ impl IntoSystemSetConfig for SystemSetConfig {
         self
     }
 
-    fn run_if<P>(mut self, condition: impl Condition<P>) -> Self {
+    fn run_if<M>(mut self, condition: impl Condition<M>) -> Self {
         self.conditions.push(new_condition(condition));
         self
     }
@@ -274,7 +274,7 @@ impl IntoSystemSetConfig for SystemSetConfig {
 ///
 /// This has been implemented for boxed [`System<In=(), Out=()>`](crate::system::System)
 /// trait objects and all functions that turn into such.
-pub trait IntoSystemConfig<Params>: sealed::IntoSystemConfig<Params> {
+pub trait IntoSystemConfig<Marker>: sealed::IntoSystemConfig<Marker> {
     /// Convert into a [`SystemConfig`].
     #[doc(hidden)]
     fn into_config(self) -> SystemConfig;
@@ -294,7 +294,7 @@ pub trait IntoSystemConfig<Params>: sealed::IntoSystemConfig<Params> {
     ///
     /// The `Condition` will be evaluated at most once (per schedule run),
     /// when the system prepares to run.
-    fn run_if<P>(self, condition: impl Condition<P>) -> SystemConfig;
+    fn run_if<M>(self, condition: impl Condition<M>) -> SystemConfig;
     /// Suppress warnings and errors that would result from this system having ambiguities
     /// (conflicting access but indeterminate order) with systems in `set`.
     fn ambiguous_with<M>(self, set: impl IntoSystemSet<M>) -> SystemConfig;
@@ -303,9 +303,9 @@ pub trait IntoSystemConfig<Params>: sealed::IntoSystemConfig<Params> {
     fn ambiguous_with_all(self) -> SystemConfig;
 }
 
-impl<Params, F> IntoSystemConfig<Params> for F
+impl<Marker, F> IntoSystemConfig<Marker> for F
 where
-    F: IntoSystem<(), (), Params> + sealed::IntoSystemConfig<Params>,
+    F: IntoSystem<(), (), Marker> + sealed::IntoSystemConfig<Marker>,
 {
     fn into_config(self) -> SystemConfig {
         SystemConfig::new(Box::new(IntoSystem::into_system(self)))
@@ -333,7 +333,7 @@ where
         self.into_config().after(set)
     }
 
-    fn run_if<P>(self, condition: impl Condition<P>) -> SystemConfig {
+    fn run_if<M>(self, condition: impl Condition<M>) -> SystemConfig {
         self.into_config().run_if(condition)
     }
 
@@ -373,7 +373,7 @@ impl IntoSystemConfig<()> for BoxedSystem<(), ()> {
         self.into_config().after(set)
     }
 
-    fn run_if<P>(self, condition: impl Condition<P>) -> SystemConfig {
+    fn run_if<M>(self, condition: impl Condition<M>) -> SystemConfig {
         self.into_config().run_if(condition)
     }
 
@@ -440,7 +440,7 @@ impl IntoSystemConfig<()> for SystemConfig {
         self
     }
 
-    fn run_if<P>(mut self, condition: impl Condition<P>) -> Self {
+    fn run_if<M>(mut self, condition: impl Condition<M>) -> Self {
         self.conditions.push(new_condition(condition));
         self
     }
@@ -465,9 +465,9 @@ mod sealed {
 
     use super::{SystemConfig, SystemSetConfig};
 
-    pub trait IntoSystemConfig<Params> {}
+    pub trait IntoSystemConfig<Marker> {}
 
-    impl<Params, F: IntoSystem<(), (), Params>> IntoSystemConfig<Params> for F {}
+    impl<Marker, F: IntoSystem<(), (), Marker>> IntoSystemConfig<Marker> for F {}
 
     impl IntoSystemConfig<()> for BoxedSystem<(), ()> {}
 
@@ -490,7 +490,7 @@ pub struct SystemConfigs {
 }
 
 /// Types that can convert into a [`SystemConfigs`].
-pub trait IntoSystemConfigs<Params>
+pub trait IntoSystemConfigs<Marker>
 where
     Self: Sized,
 {
@@ -550,7 +550,7 @@ where
     /// Use [`run_if`](IntoSystemSetConfig::run_if) on a [`SystemSet`] if you want to make sure
     /// that either all or none of the systems are run, or you don't want to evaluate the run
     /// condition for each contained system separately.
-    fn distributive_run_if<P>(self, condition: impl Condition<P> + Clone) -> SystemConfigs {
+    fn distributive_run_if<M>(self, condition: impl Condition<M> + Clone) -> SystemConfigs {
         self.into_configs().distributive_run_if(condition)
     }
 
@@ -637,7 +637,7 @@ impl IntoSystemConfigs<()> for SystemConfigs {
         self
     }
 
-    fn distributive_run_if<P>(mut self, condition: impl Condition<P> + Clone) -> SystemConfigs {
+    fn distributive_run_if<M>(mut self, condition: impl Condition<M> + Clone) -> SystemConfigs {
         for config in &mut self.systems {
             config.conditions.push(new_condition(condition.clone()));
         }

crates/bevy_ecs/src/schedule/schedule.rs

@@ -190,13 +190,13 @@ impl Schedule {
     }
 
     /// Add a system to the schedule.
-    pub fn add_system<P>(&mut self, system: impl IntoSystemConfig<P>) -> &mut Self {
+    pub fn add_system<M>(&mut self, system: impl IntoSystemConfig<M>) -> &mut Self {
         self.graph.add_system(system);
         self
     }
 
     /// Add a collection of systems to the schedule.
-    pub fn add_systems<P>(&mut self, systems: impl IntoSystemConfigs<P>) -> &mut Self {
+    pub fn add_systems<M>(&mut self, systems: impl IntoSystemConfigs<M>) -> &mut Self {
         self.graph.add_systems(systems);
         self
     }
@@ -556,7 +556,7 @@ impl ScheduleGraph {
         &self.conflicting_systems
     }
 
-    fn add_systems<P>(&mut self, systems: impl IntoSystemConfigs<P>) {
+    fn add_systems<M>(&mut self, systems: impl IntoSystemConfigs<M>) {
         let SystemConfigs { systems, chained } = systems.into_configs();
         let mut system_iter = systems.into_iter();
         if chained {
@@ -574,13 +574,13 @@ impl ScheduleGraph {
         }
     }
 
-    fn add_system<P>(&mut self, system: impl IntoSystemConfig<P>) {
+    fn add_system<M>(&mut self, system: impl IntoSystemConfig<M>) {
         self.add_system_inner(system).unwrap();
     }
 
-    fn add_system_inner<P>(
+    fn add_system_inner<M>(
         &mut self,
-        system: impl IntoSystemConfig<P>,
+        system: impl IntoSystemConfig<M>,
     ) -> Result<NodeId, ScheduleBuildError> {
         let SystemConfig {
             system,

crates/bevy_ecs/src/system/function_system.rs

@@ -319,7 +319,7 @@ impl<Param: SystemParam> FromWorld for SystemState<Param> {
 // This trait has to be generic because we have potentially overlapping impls, in particular
 // because Rust thinks a type could impl multiple different `FnMut` combinations
 // even though none can currently
-pub trait IntoSystem<In, Out, Params>: Sized {
+pub trait IntoSystem<In, Out, Marker>: Sized {
     type System: System<In = In, Out = Out>;
     /// Turns this value into its corresponding [`System`].
     fn into_system(this: Self) -> Self::System;

crates/bevy_ecs/src/system/mod.rs

@@ -124,7 +124,7 @@ pub use system_piping::*;
 /// This should be used when writing doc examples,
 /// to confirm that systems used in an example are
 /// valid systems.
-pub fn assert_is_system<In, Out, Params, S: IntoSystem<In, Out, Params>>(sys: S) {
+pub fn assert_is_system<In, Out, Marker, S: IntoSystem<In, Out, Marker>>(sys: S) {
     if false {
         // Check it can be converted into a system
         // TODO: This should ensure that the system has no conflicting system params
@@ -137,7 +137,7 @@ pub fn assert_is_system<In, Out, Params, S: IntoSystem<In, Out, Params>>(sys: S)
 /// This should be used when writing doc examples,
 /// to confirm that systems used in an example are
 /// valid systems.
-pub fn assert_is_read_only_system<In, Out, Params, S: IntoSystem<In, Out, Params>>(sys: S)
+pub fn assert_is_read_only_system<In, Out, Marker, S: IntoSystem<In, Out, Marker>>(sys: S)
 where
     S::System: ReadOnlySystem,
 {