Eliminate unwraps

Author: chrisrink10

src/singledispatch/core.rs

@@ -14,13 +14,10 @@ use pyo3::{
 use std::collections::HashMap;
 use std::sync::Mutex;
 
-fn get_abc_cache_token(py: Python) -> Bound<'_, PyAny> {
-    py.import(intern!(py, "abc"))
-        .unwrap()
-        .getattr(intern!(py, "get_cache_token"))
-        .unwrap()
+fn get_abc_cache_token(py: Python) -> PyResult<Bound<'_, PyAny>> {
+    py.import(intern!(py, "abc"))?
+        .getattr(intern!(py, "get_cache_token"))?
         .call0()
-        .unwrap()
 }
 
 fn valid_dispatch_types(py: Python, cls: &Bound<'_, PyAny>) -> PyResult<Vec<Py<PyType>>> {
@@ -83,26 +80,29 @@ impl SingleDispatchState {
                 mro_match = Some(typ.clone_ref(py));
             }
 
-            if mro_match.is_some() {
-                let m = &mro_match.unwrap().clone_ref(py);
-                if self.registry.contains_key(typ)
-                    && !cls_mro.contains(typ)
-                    && !cls_mro.contains(m)
-                    && Builtins::cached(py)
+            match mro_match {
+                Some(m) => {
+                    let m = &m.clone_ref(py);
+                    if self.registry.contains_key(typ)
+                        && !cls_mro.contains(typ)
+                        && !cls_mro.contains(m)
+                        && Builtins::cached(py)
                         .issubclass(py, m.wrapped().bind(py), typ.wrapped().bind(py))
                         .is_ok_and(|res| res)
-                {
-                    return Err(PyRuntimeError::new_err(format!(
-                        "Ambiguous dispatch: {m} or {typ}"
-                    )));
+                    {
+                        return Err(PyRuntimeError::new_err(format!(
+                            "Ambiguous dispatch: {m} or {typ}"
+                        )));
+                    }
+                    mro_match = Some(m.clone_ref(py));
+                    eprintln!("MRO match: {m}");
+                    break;
                 }
-                mro_match = Some(m.clone_ref(py));
-                eprintln!("MRO match: {m}");
-                break;
+                _ => {},
             }
         }
         let impl_fn = match mro_match {
-            Some(_) => match self.registry.get(&mro_match.unwrap()) {
+            Some(v) => match self.registry.get(&v) {
                 Some(&ref it) => Some(it.clone_ref(py)),
                 None => None,
             },
@@ -180,7 +180,7 @@ impl SingleDispatch {
                 }
                 if state.cache_token.is_none() {
                     if let Ok(_) = unbound_func.getattr(py, intern!(py, "__abstractmethods__")) {
-                        state.cache_token = Some(get_abc_cache_token(py).unbind());
+                        state.cache_token = Some(get_abc_cache_token(py)?.unbind());
                     }
                 }
                 state.cache.clear();
@@ -253,7 +253,7 @@ impl SingleDispatch {
             Ok(mut state) => {
                 match &state.cache_token {
                     Some(cache_token) => {
-                        let current_token = get_abc_cache_token(py);
+                        let current_token = get_abc_cache_token(py)?;
                         match current_token.rich_compare(cache_token.bind(py), CompareOp::Eq) {
                             Ok(_) => {
                                 state.cache.clear();