ComputeParamsRequest

rslib/src/deckconfig/update.rs

@@ -22,6 +22,7 @@ use crate::prelude::*;
 use crate::scheduler::fsrs::memory_state::UpdateMemoryStateEntry;
 use crate::scheduler::fsrs::memory_state::UpdateMemoryStateRequest;
 use crate::scheduler::fsrs::params::ignore_revlogs_before_ms_from_config;
+use crate::scheduler::fsrs::params::ComputeParamsRequest;
 use crate::search::JoinSearches;
 use crate::search::Negated;
 use crate::search::SearchNode;
@@ -368,15 +369,15 @@ impl Collection {
             };
             let ignore_revlogs_before_ms = ignore_revlogs_before_ms_from_config(config)?;
             let num_of_relearning_steps = config.inner.relearn_steps.len();
-            match self.compute_params(
-                &search,
+            match self.compute_params(ComputeParamsRequest {
+                search: &search,
                 ignore_revlogs_before_ms,
-                idx as u32 + 1,
-                config_len,
-                config.fsrs_params(),
+                current_preset: idx as u32 + 1,
+                total_presets: config_len,
+                current_params: config.fsrs_params(),
                 num_of_relearning_steps,
-                false,
-            ) {
+                health_check: false,
+            }) {
                 Ok(params) => {
                     println!("{}: {:?}", config.name, params.params);
                     config.inner.fsrs_params_6 = params.params;

rslib/src/scheduler/fsrs/params.rs

@@ -51,6 +51,16 @@ pub(crate) fn ignore_revlogs_before_ms_from_config(config: &DeckConfig) -> Resul
     ignore_revlogs_before_date_to_ms(&config.inner.ignore_revlogs_before_date)
 }
 
+pub struct ComputeParamsRequest<'t> {
+    pub search: &'t str,
+    pub ignore_revlogs_before_ms: TimestampMillis,
+    pub current_preset: u32,
+    pub total_presets: u32,
+    pub current_params: &'t Params,
+    pub num_of_relearning_steps: usize,
+    pub health_check: bool,
+}
+
 /// r: retention
 fn log_loss_adjustment(r: f32) -> f32 {
     0.621 * (4. * r * (1. - r)).powf(0.739)
@@ -67,17 +77,20 @@ impl Collection {
     /// Note this does not return an error if there are less than 400 items -
     /// the caller should instead check the fsrs_items count in the return
     /// value.
-    #[allow(clippy::too_many_arguments)]
     pub fn compute_params(
         &mut self,
-        search: &str,
-        ignore_revlogs_before: TimestampMillis,
-        current_preset: u32,
-        total_presets: u32,
-        current_params: &Params,
-        num_of_relearning_steps: usize,
-        health_check: bool,
+        request: ComputeParamsRequest,
     ) -> Result<ComputeFsrsParamsResponse> {
+        let ComputeParamsRequest {
+            search,
+            ignore_revlogs_before_ms: ignore_revlogs_before,
+            current_preset,
+            total_presets,
+            current_params,
+            num_of_relearning_steps,
+            health_check,
+        } = request;
+
         self.clear_progress();
         let timing = self.timing_today()?;
         let revlogs = self.revlog_for_srs(search)?;

rslib/src/scheduler/service/mod.rs

@@ -23,6 +23,7 @@ use fsrs::FSRS;
 
 use crate::backend::Backend;
 use crate::prelude::*;
+use crate::scheduler::fsrs::params::ComputeParamsRequest;
 use crate::scheduler::new::NewCardDueOrder;
 use crate::scheduler::states::CardState;
 use crate::scheduler::states::SchedulingStates;
@@ -264,15 +265,15 @@ impl crate::services::SchedulerService for Collection {
         &mut self,
         input: scheduler::ComputeFsrsParamsRequest,
     ) -> Result<scheduler::ComputeFsrsParamsResponse> {
-        self.compute_params(
-            &input.search,
-            input.ignore_revlogs_before_ms.into(),
-            1,
-            1,
-            &input.current_params,
-            input.num_of_relearning_steps as usize,
-            input.health_check,
-        )
+        self.compute_params(ComputeParamsRequest {
+            search: &input.search,
+            ignore_revlogs_before_ms: input.ignore_revlogs_before_ms.into(),
+            current_preset: 1,
+            total_presets: 1,
+            current_params: &input.current_params,
+            num_of_relearning_steps: input.num_of_relearning_steps as usize,
+            health_check: input.health_check,
+        })
     }
 
     fn simulate_fsrs_review(