Simplify world schedule methods

crates/bevy_app/src/app.rs

@@ -162,9 +162,7 @@ impl SubApp {
 
  /// Runs the `SubApp`'s default schedule.
  pub fn run(&mut self) {
- self.app
- .world
- .run_schedule_ref(&*self.app.main_schedule_label);
+ self.app.world.run_schedule(&*self.app.main_schedule_label);
  self.app.world.clear_trackers();
  }
 
@@ -241,7 +239,7 @@ impl App {
  {
  #[cfg(feature = "trace")]
  let _bevy_frame_update_span = info_span!("main app").entered();
- self.world.run_schedule_ref(&*self.main_schedule_label);
+ self.world.run_schedule(&*self.main_schedule_label);
  }
  for (_label, sub_app) in self.sub_apps.iter_mut() {
  #[cfg(feature = "trace")]
@@ -1025,7 +1023,7 @@ mod tests {
  app.add_state::<AppState>()
  .add_systems(OnEnter(AppState::MainMenu), (foo, bar));
 
- app.world.run_schedule(OnEnter(AppState::MainMenu));
+ app.world.run_schedule(&OnEnter(AppState::MainMenu));
  assert_eq!(app.world.entities().len(), 2);
  }
 
@@ -1035,7 +1033,7 @@ mod tests {
  app.add_systems(OnEnter(AppState::MainMenu), (foo, bar))
  .add_state::<AppState>();
 
- app.world.run_schedule(OnEnter(AppState::MainMenu));
+ app.world.run_schedule(&OnEnter(AppState::MainMenu));
  assert_eq!(app.world.entities().len(), 2);
  }
 }

crates/bevy_app/src/main_schedule.rs

@@ -135,15 +135,15 @@ impl Main {
  /// A system that runs the "main schedule"
  pub fn run_main(world: &mut World, mut run_at_least_once: Local<bool>) {
  if !*run_at_least_once {
- let _ = world.try_run_schedule(PreStartup);
- let _ = world.try_run_schedule(Startup);
- let _ = world.try_run_schedule(PostStartup);
+ let _ = world.try_run_schedule(&PreStartup);
+ let _ = world.try_run_schedule(&Startup);
+ let _ = world.try_run_schedule(&PostStartup);
  *run_at_least_once = true;
  }
 
  world.resource_scope(|world, order: Mut<MainScheduleOrder>| {
  for label in &order.labels {
- let _ = world.try_run_schedule_ref(&**label);
+ let _ = world.try_run_schedule(&**label);
  }
  });
  }

crates/bevy_ecs/src/schedule/state.rs

@@ -113,7 +113,7 @@ impl<S: States> NextState<S> {
 /// Run the enter schedule (if it exists) for the current state.
 pub fn run_enter_schedule<S: States>(world: &mut World) {
  world
- .try_run_schedule(OnEnter(world.resource::<State<S>>().0.clone()))
+ .try_run_schedule(&OnEnter(world.resource::<State<S>>().0.clone()))
  .ok();
 }
 
@@ -133,14 +133,14 @@ pub fn apply_state_transition<S: States>(world: &mut World) {
  if *state_resource != entered {
  let exited = mem::replace(&mut state_resource.0, entered.clone());
  // Try to run the schedules if they exist.
- world.try_run_schedule(OnExit(exited.clone())).ok();
+ world.try_run_schedule(&OnExit(exited.clone())).ok();
  world
- .try_run_schedule(OnTransition {
+ .try_run_schedule(&OnTransition {
  from: exited,
  to: entered.clone(),
  })
  .ok();
- world.try_run_schedule(OnEnter(entered)).ok();
+ world.try_run_schedule(&OnEnter(entered)).ok();
  }
  }
 }

crates/bevy_ecs/src/world/mod.rs

@@ -1733,27 +1733,6 @@ impl World {
  /// consider using [`World::try_run_schedule`] instead.
  /// For other use cases, see the example on [`World::schedule_scope`].
  pub fn try_schedule_scope<R>(
- &mut self,
- label: impl ScheduleLabel,
- f: impl FnOnce(&mut World, &mut Schedule) -> R,
- ) -> Result<R, TryRunScheduleError> {
- self.try_schedule_scope_ref(&label, f)
- }
-
- /// Temporarily removes the schedule associated with `label` from the world,
- /// runs user code, and finally re-adds the schedule.
- /// This returns a [`TryRunScheduleError`] if there is no schedule
- /// associated with `label`.
- ///
- /// Unlike the `try_run_schedule` method, this method takes the label by reference, which can save a clone.
- ///
- /// The [`Schedule`] is fetched from the [`Schedules`] resource of the world by its label,
- /// and system state is cached.
- ///
- /// For simple cases where you just need to call the schedule once,
- /// consider using [`World::try_run_schedule_ref`] instead.
- /// For other use cases, see the example on [`World::schedule_scope`].
- pub fn try_schedule_scope_ref<R>(
  &mut self,
  label: &dyn ScheduleLabel,
  f: impl FnOnce(&mut World, &mut Schedule) -> R,
@@ -1802,7 +1781,7 @@ impl World {
  /// # world.add_schedule(schedule, MySchedule);
  /// # fn tick_counter(mut counter: ResMut<Counter>) { counter.0 += 1; }
  /// // Run the schedule five times.
- /// world.schedule_scope(MySchedule, |world, schedule| {
+ /// world.schedule_scope(&MySchedule, |world, schedule| {
  /// for _ in 0..5 {
  /// schedule.run(world);
  /// }
@@ -1817,34 +1796,11 @@ impl World {
  ///
  /// If the requested schedule does not exist.
  pub fn schedule_scope<R>(
- &mut self,
- label: impl ScheduleLabel,
- f: impl FnOnce(&mut World, &mut Schedule) -> R,
- ) -> R {
- self.schedule_scope_ref(&label, f)
- }
-
- /// Temporarily removes the schedule associated with `label` from the world,
- /// runs user code, and finally re-adds the schedule.
- ///
- /// Unlike the `run_schedule` method, this method takes the label by reference, which can save a clone.
- ///
- /// The [`Schedule`] is fetched from the [`Schedules`] resource of the world by its label,
- /// and system state is cached.
- ///
- /// For simple cases where you just need to call the schedule,
- /// consider using [`World::run_schedule_ref`] instead.
- /// For other use cases, see the example on [`World::schedule_scope`].
- ///
- /// # Panics
- ///
- /// If the requested schedule does not exist.
- pub fn schedule_scope_ref<R>(
  &mut self,
  label: &dyn ScheduleLabel,
  f: impl FnOnce(&mut World, &mut Schedule) -> R,
  ) -> R {
- self.try_schedule_scope_ref(label, f)
+ self.try_schedule_scope(label, f)
  .unwrap_or_else(|e| panic!("{e}"))
  }
 
@@ -1856,46 +1812,14 @@ impl World {
  ///
  /// For simple testing use cases, call [`Schedule::run(&mut world)`](Schedule::run) instead.
  pub fn try_run_schedule(
- &mut self,
- label: impl ScheduleLabel,
- ) -> Result<(), TryRunScheduleError> {
- self.try_run_schedule_ref(&label)
- }
-
- /// Attempts to run the [`Schedule`] associated with the `label` a single time,
- /// and returns a [`TryRunScheduleError`] if the schedule does not exist.
- ///
- /// Unlike the `try_run_schedule` method, this method takes the label by reference, which can save a clone.
- ///
- /// The [`Schedule`] is fetched from the [`Schedules`] resource of the world by its label,
- /// and system state is cached.
- ///
- /// For simple testing use cases, call [`Schedule::run(&mut world)`](Schedule::run) instead.
- pub fn try_run_schedule_ref(
  &mut self,
  label: &dyn ScheduleLabel,
  ) -> Result<(), TryRunScheduleError> {
- self.try_schedule_scope_ref(label, |world, sched| sched.run(world))
- }
-
- /// Runs the [`Schedule`] associated with the `label` a single time.
- ///
- /// The [`Schedule`] is fetched from the [`Schedules`] resource of the world by its label,
- /// and system state is cached.
- ///
- /// For simple testing use cases, call [`Schedule::run(&mut world)`](Schedule::run) instead.
- ///
- /// # Panics
- ///
- /// If the requested schedule does not exist.
- pub fn run_schedule(&mut self, label: impl ScheduleLabel) {
- self.run_schedule_ref(&label);
+ self.try_schedule_scope(label, |world, sched| sched.run(world))
  }
 
  /// Runs the [`Schedule`] associated with the `label` a single time.
  ///
- /// Unlike the `run_schedule` method, this method takes the label by reference, which can save a clone.
- ///
  /// The [`Schedule`] is fetched from the [`Schedules`] resource of the world by its label,
  /// and system state is cached.
  ///
@@ -1904,8 +1828,8 @@ impl World {
  /// # Panics
  ///
  /// If the requested schedule does not exist.
- pub fn run_schedule_ref(&mut self, label: &dyn ScheduleLabel) {
- self.schedule_scope_ref(label, |world, sched| sched.run(world));
+ pub fn run_schedule(&mut self, label: &dyn ScheduleLabel) {
+ self.schedule_scope(label, |world, sched| sched.run(world));
  }
 }
 

crates/bevy_render/src/lib.rs

@@ -330,7 +330,7 @@ fn extract(main_world: &mut World, render_app: &mut App) {
  let inserted_world = std::mem::replace(main_world, scratch_world.0);
  render_app.world.insert_resource(MainWorld(inserted_world));
 
- render_app.world.run_schedule(ExtractSchedule);
+ render_app.world.run_schedule(&ExtractSchedule);
 
  // move the app world back, as if nothing happened.
  let inserted_world = render_app.world.remove_resource::<MainWorld>().unwrap();

crates/bevy_time/src/fixed_timestep.rs

@@ -107,7 +107,7 @@ pub fn run_fixed_update_schedule(world: &mut World) {
  fixed_time.tick(delta_time);
 
  // Run the schedule until we run out of accumulated time
- let _ = world.try_schedule_scope(FixedUpdate, |world, schedule| {
+ let _ = world.try_schedule_scope(&FixedUpdate, |world, schedule| {
  while world.resource_mut::<FixedTime>().expend().is_ok() {
  schedule.run(world);
  }