[Issue-1961]: Handle clippy::ignored_unit_patterns (tensorzero#2820)

* [Issue-1961]: Handle clippy::ignored_unit_patterns

* Fix linter error

* Fix merge from main

Author: michaldorsett

Cargo.toml

@@ -75,6 +75,7 @@ allow_attributes = "deny"
 dbg_macro = "deny"
 expect_used = "deny"
 if_not_else = "deny"
+ignored_unit_patterns = "deny"
 manual_string_new = "deny"
 match_bool = "deny"
 needless_raw_string_hashes = "deny"

clients/python/src/lib.rs

@@ -1573,7 +1573,7 @@ impl AsyncTensorZeroGateway {
         pyo3_async_runtimes::tokio::future_into_py(this.py(), async move {
             let res = client.delete_datapoint(dataset_name, datapoint_id).await;
             Python::with_gil(|py| match res {
-                Ok(_) => Ok(()),
+                Ok(()) => Ok(()),
                 Err(e) => Err(convert_error(py, e)),
             })
         })

evaluations/src/evaluators/mod.rs

@@ -135,6 +135,7 @@ pub(crate) async fn evaluate_inference(
                                 })
                                 .await
                             {
+                                #[expect(clippy::ignored_unit_patterns)]
                                 Ok(_) => {
                                     debug!(evaluator_name = %evaluator_name, "Feedback sent successfully");
                                 },

evaluations/src/main.rs

@@ -25,7 +25,9 @@ async fn main() -> Result<()> {
     let result = run_evaluation(args, evaluation_run_id, &mut writer).await;
 
     match &result {
-        Ok(_) => info!(evaluation_run_id = %evaluation_run_id, "Evaluation completed successfully"),
+        Ok(()) => {
+            info!(evaluation_run_id = %evaluation_run_id, "Evaluation completed successfully");
+        }
         Err(e) => {
             tracing::error!(evaluation_run_id = %evaluation_run_id, error = %e, "Evaluation failed");
         }

gateway/src/main.rs

@@ -393,13 +393,13 @@ pub async fn shutdown_signal() {
     let hangup = std::future::pending::<()>();
 
     tokio::select! {
-        _ = ctrl_c => {
+        () = ctrl_c => {
             tracing::info!("Received Ctrl+C signal");
         }
-        _ = terminate => {
+        () = terminate => {
             tracing::info!("Received SIGTERM signal");
         }
-        _ = hangup => {
+        () = hangup => {
             tokio::time::sleep(std::time::Duration::from_secs(1)).await;
             tracing::info!("Received SIGHUP signal");
         }

tensorzero-core/src/config_parser/mod.rs

@@ -57,7 +57,7 @@ tokio::task_local! {
 pub fn skip_credential_validation() -> bool {
     // tokio::task_local doesn't have an 'is_set' method, so we call 'try_with'
     // (which returns an `Err` if the task-local is not set)
-    SKIP_CREDENTIAL_VALIDATION.try_with(|_| ()).is_ok()
+    SKIP_CREDENTIAL_VALIDATION.try_with(|()| ()).is_ok()
 }
 
 #[derive(Debug, Default, Serialize)]

tensorzero-core/src/endpoints/stored_inference.rs

@@ -48,7 +48,7 @@ pub async fn render_samples<T: StoredSample>(
             // Filter out examples where reresolve_input_for_fine_tuning failed.
             // If resolution_result is Ok, map Some(()) to Some(example).
             // If resolution_result is Err, .ok() yields None, so filter_map drops it.
-            resolution_result.ok().map(|_| example)
+            resolution_result.ok().map(|()| example)
         })
         .filter_map(|resolved_example| {
             // resolved_example is a StoredInference that was successfully processed by reresolve.

tensorzero-core/src/function.rs

@@ -387,7 +387,7 @@ impl FunctionConfig {
                 // If the parsed output fails validation, we log the error and set `parsed_output` to None
                 let parsed_output = match parsed_output {
                     Some(parsed_output) => match output_schema.validate(&parsed_output).await {
-                        Ok(_) => Some(parsed_output),
+                        Ok(()) => Some(parsed_output),
                         Err(_) => None,
                     },
                     None => None,

tensorzero-core/src/howdy.rs

@@ -57,7 +57,7 @@ pub async fn howdy_loop(clickhouse: ClickHouseConnectionInfo) {
     let client = Client::new();
     let deployment_id = match get_deployment_id(&clickhouse).await {
         Ok(deployment_id) => deployment_id,
-        Err(_) => {
+        Err(()) => {
             return;
         }
     };

tensorzero-core/src/providers/openai/mod.rs

@@ -497,7 +497,7 @@ impl InferenceProvider for OpenAIProvider {
             get_batch_url(self.api_base.as_ref().unwrap_or(&OPENAI_DEFAULT_BASE_URL))?;
         request_url
             .path_segments_mut()
-            .map_err(|_| {
+            .map_err(|()| {
                 Error::new(ErrorDetails::Inference {
                     message: "Failed to get mutable path segments".to_string(),
                 })