Use option-like operator for OptionalArg

Author: youknowone

stdlib/src/bisect.rs

@@ -22,10 +22,9 @@ mod _bisect {
         arg: OptionalArg<PyObjectRef>,
         vm: &VirtualMachine,
     ) -> PyResult<Option<isize>> {
-        Ok(match arg {
-            OptionalArg::Present(v) => Some(vm.to_index(&v)?.try_to_primitive(vm)?),
-            OptionalArg::Missing => None,
-        })
+        arg.into_option()
+            .map(|v| vm.to_index(&v)?.try_to_primitive(vm))
+            .transpose()
     }
 
     // Handles defaults for lo, hi.

stdlib/src/re.rs

@@ -296,10 +296,7 @@ mod re {
     }
 
     fn extract_flags(flags: OptionalArg<usize>) -> PyRegexFlags {
-        match flags {
-            OptionalArg::Present(flags) => PyRegexFlags::from_int(flags),
-            OptionalArg::Missing => Default::default(),
-        }
+        flags.map_or_else(Default::default, PyRegexFlags::from_int)
     }
 
     #[pyfunction]

stdlib/src/unicodedata.rs

@@ -101,12 +101,7 @@ mod unicodedata {
                     }
                 }
             }
-            match default {
-                OptionalArg::Present(obj) => Ok(obj),
-                OptionalArg::Missing => {
-                    Err(vm.new_value_error("character name not found!".to_owned()))
-                }
-            }
+            default.ok_or_else(|| vm.new_value_error("character name not found!".to_owned()))
         }
 
         #[pymethod]

stdlib/src/zlib.rs

@@ -366,15 +366,10 @@ mod zlib {
         #[pymethod]
         fn flush(&self, length: OptionalArg<isize>, vm: &VirtualMachine) -> PyResult<Vec<u8>> {
             let length = match length {
-                OptionalArg::Present(l) => {
-                    if l <= 0 {
-                        return Err(
-                            vm.new_value_error("length must be greater than zero".to_owned())
-                        );
-                    } else {
-                        l as usize
-                    }
+                OptionalArg::Present(l) if l <= 0 => {
+                    return Err(vm.new_value_error("length must be greater than zero".to_owned()));
                 }
+                OptionalArg::Present(l) => l as usize,
                 OptionalArg::Missing => DEF_BUF_SIZE,
             };
 

vm/src/builtins/int.rs

@@ -607,12 +607,7 @@ impl PyInt {
         args: IntFromByteArgs,
         vm: &VirtualMachine,
     ) -> PyResult<PyRef<Self>> {
-        let signed = if let OptionalArg::Present(signed) = args.signed {
-            signed.to_bool()
-        } else {
-            false
-        };
-
+        let signed = args.signed.map_or(false, |s| s.to_bool());
         let value = match (args.byteorder.as_str(), signed) {
             ("big", true) => BigInt::from_signed_bytes_be(&args.bytes.elements),
             ("big", false) => BigInt::from_bytes_be(Sign::Plus, &args.bytes.elements),

vm/src/function/argument.rs

@@ -469,10 +469,7 @@ pub type OptionalOption<T = PyObjectRef> = OptionalArg<Option<T>>;
 impl<T> OptionalOption<T> {
     #[inline]
     pub fn flatten(self) -> Option<T> {
-        match self {
-            OptionalArg::Present(Some(value)) => Some(value),
-            _ => None,
-        }
+        self.into_option().flatten()
     }
 }
 

vm/src/stdlib/os.rs

@@ -933,11 +933,7 @@ pub(super) mod _os {
 
     #[pyfunction]
     fn scandir(path: OptionalArg<PyPathLike>, vm: &VirtualMachine) -> PyResult {
-        let path = match path {
-            OptionalArg::Present(path) => path,
-            OptionalArg::Missing => PyPathLike::new_str("."),
-        };
-
+        let path = path.unwrap_or_else(|| PyPathLike::new_str("."));
         let entries = fs::read_dir(path.path).map_err(|err| err.to_pyexception(vm))?;
         Ok(ScandirIterator {
             entries: PyRwLock::new(entries),