Refactor Python discovery iterators to use filter_ok and map_ok

Because now I know those exist
astral-sh · Jan 31, 2025 · a90e880 · a90e880
1 parent 479580d
commit a90e880
Showing 1 changed file with 37 additions and 57 deletions.
diff --git a/crates/uv-python/src/discovery.rs b/crates/uv-python/src/discovery.rs
@@ -434,11 +434,8 @@ fn python_executables<'a>(
         .chain(from_virtual_environments)
         .chain(from_base_conda_environment)
         .chain(from_installed)
-        .filter(move |result| {
-            result.is_err()
-                || result.as_ref().is_ok_and(|(source, path)| {
-                    source_satisfies_environment_preference(*source, path, environments)
-                })
+        .filter_ok(move |(source, path)| {
+            source_satisfies_environment_preference(*source, path, environments)
         })
 }
 
@@ -600,8 +597,21 @@ fn python_interpreters<'a>(
         python_executables(version, implementation, environments, preference),
         cache,
     )
-    .filter(move |result| result_satisfies_environment_preference(result, environments))
-    .filter(move |result| result_satisfies_version_request(result, version))
+    .filter_ok(move |(source, interpreter)| {
+        interpreter_satisfies_environment_preference(*source, interpreter, environments)
+    })
+    .filter_ok(move |(source, interpreter)| {
+        let request = version.clone().into_request_for_source(*source);
+        if request.matches_interpreter(interpreter) {
+            true
+        } else {
+            debug!(
+                "Skipping interpreter at `{}` from {source}: does not satisfy request `{request}`",
+                interpreter.sys_executable().user_display()
+            );
+            false
+        }
+    })
 }
 
 /// Lazily convert Python executables into interpreters.
@@ -729,35 +739,6 @@ fn source_satisfies_environment_preference(
     }
 }
 
-/// Utility for applying [`VersionRequest::matches_interpreter`] to a result type.
-fn result_satisfies_version_request(
-    result: &Result<(PythonSource, Interpreter), Error>,
-    request: &VersionRequest,
-) -> bool {
-    result.as_ref().ok().map_or(true, |(source, interpreter)| {
-        let request = request.clone().into_request_for_source(*source);
-        if request.matches_interpreter(interpreter) {
-            true
-        } else {
-            debug!(
-                "Skipping interpreter at `{}` from {source}: does not satisfy request `{request}`",
-                interpreter.sys_executable().user_display()
-            );
-            false
-        }
-    })
-}
-
-/// Utility for applying [`satisfies_environment_preference`] to a result type.
-fn result_satisfies_environment_preference(
-    result: &Result<(PythonSource, Interpreter), Error>,
-    preference: EnvironmentPreference,
-) -> bool {
-    result.as_ref().ok().map_or(true, |(source, interpreter)| {
-        interpreter_satisfies_environment_preference(*source, interpreter, preference)
-    })
-}
-
 /// Check if an encountered error is critical and should stop discovery.
 ///
 /// Returns false when an error could be due to a faulty Python installation and we should continue searching for a working one.
@@ -912,10 +893,14 @@ pub fn find_python_installations<'a>(
                 debug!("Searching for Python interpreter with {request}");
                 Box::new(
                     python_interpreters_with_executable_name(name, cache)
-                        .filter(move |result| {
-                            result_satisfies_environment_preference(result, environments)
+                        .filter_ok(move |(source, interpreter)| {
+                            interpreter_satisfies_environment_preference(
+                                *source,
+                                interpreter,
+                                environments,
+                            )
                         })
-                        .map(|result| result.map(PythonInstallation::from_tuple).map(Ok)),
+                        .map_ok(|tuple| Ok(PythonInstallation::from_tuple(tuple))),
                 )
             } else {
                 Box::new(iter::once(Err(Error::SourceNotAllowed(
@@ -928,7 +913,7 @@ pub fn find_python_installations<'a>(
         PythonRequest::Any => Box::new({
             debug!("Searching for any Python interpreter in {sources}");
             python_interpreters(&VersionRequest::Any, None, environments, preference, cache)
-                .map(|result| result.map(PythonInstallation::from_tuple).map(Ok))
+                .map_ok(|tuple| Ok(PythonInstallation::from_tuple(tuple)))
         }),
         PythonRequest::Default => Box::new({
             debug!("Searching for default Python interpreter in {sources}");
@@ -939,7 +924,7 @@ pub fn find_python_installations<'a>(
                 preference,
                 cache,
             )
-            .map(|result| result.map(PythonInstallation::from_tuple).map(Ok))
+            .map_ok(|tuple| Ok(PythonInstallation::from_tuple(tuple)))
         }),
         PythonRequest::Version(version) => {
             if let Err(err) = version.check_supported() {
@@ -948,7 +933,7 @@ pub fn find_python_installations<'a>(
             Box::new({
                 debug!("Searching for {request} in {sources}");
                 python_interpreters(version, None, environments, preference, cache)
-                    .map(|result| result.map(PythonInstallation::from_tuple).map(Ok))
+                    .map_ok(|tuple| Ok(PythonInstallation::from_tuple(tuple)))
             })
         }
         PythonRequest::Implementation(implementation) => Box::new({
@@ -960,13 +945,12 @@ pub fn find_python_installations<'a>(
                 preference,
                 cache,
             )
-            .filter(|result| match result {
-                Err(_) => true,
-                Ok((_source, interpreter)) => interpreter
+            .filter_ok(|(_source, interpreter)| {
+                interpreter
                     .implementation_name()
-                    .eq_ignore_ascii_case(implementation.into()),
+                    .eq_ignore_ascii_case(implementation.into())
             })
-            .map(|result| result.map(PythonInstallation::from_tuple).map(Ok))
+            .map_ok(|tuple| Ok(PythonInstallation::from_tuple(tuple)))
         }),
         PythonRequest::ImplementationVersion(implementation, version) => {
             if let Err(err) = version.check_supported() {
@@ -981,13 +965,12 @@ pub fn find_python_installations<'a>(
                     preference,
                     cache,
                 )
-                .filter(|result| match result {
-                    Err(_) => true,
-                    Ok((_source, interpreter)) => interpreter
+                .filter_ok(|(_source, interpreter)| {
+                    interpreter
                         .implementation_name()
-                        .eq_ignore_ascii_case(implementation.into()),
+                        .eq_ignore_ascii_case(implementation.into())
                 })
-                .map(|result| result.map(PythonInstallation::from_tuple).map(Ok))
+                .map_ok(|tuple| Ok(PythonInstallation::from_tuple(tuple)))
             })
         }
         PythonRequest::Key(request) => {
@@ -1005,11 +988,8 @@ pub fn find_python_installations<'a>(
                     preference,
                     cache,
                 )
-                .filter(|result| match result {
-                    Err(_) => true,
-                    Ok((_source, interpreter)) => request.satisfied_by_interpreter(interpreter),
-                })
-                .map(|result| result.map(PythonInstallation::from_tuple).map(Ok))
+                .filter_ok(|(_source, interpreter)| request.satisfied_by_interpreter(interpreter))
+                .map_ok(|tuple| Ok(PythonInstallation::from_tuple(tuple)))
             })
         }
     }