lib: replace `map`+`unwrap_or` with `Option::map_or` in impls

Refactor trait implementations to use Option::map_or instead of chaining
map+unwrap_or. This pattern appears consistently across multiple methods
(write, read, write_byte, set_timer, etc.) that handle Option<&T> receiver types.

The change improves code density while preserving semantics:
- Eliminates temporary Option values created by map()
- Reduces visual noise from multi-line chain calls
- Maintains identical error handling behavior
- Better expresses the "default-or-transform" intent through standard  library APIs

Signed-off-by: Zhouqi Jiang <luojia@hust.edu.cn>

CHANGELOG.md

@@ -19,6 +19,7 @@ to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 ### Modified
 
 - susp: amend documentation on `system_suspend` function.
+- lib: replace map+unwrap_or with Option::map_or in impls
 
 ### Removed
 

src/console.rs

@@ -111,20 +111,17 @@ impl<T: Console> Console for Option<T> {
     #[inline]
     fn write(&self, bytes: Physical<&[u8]>) -> SbiRet {
         self.as_ref()
-            .map(|inner| T::write(inner, bytes))
-            .unwrap_or(SbiRet::not_supported())
+            .map_or(SbiRet::not_supported(), |inner| T::write(inner, bytes))
     }
     #[inline]
     fn read(&self, bytes: Physical<&mut [u8]>) -> SbiRet {
         self.as_ref()
-            .map(|inner| T::read(inner, bytes))
-            .unwrap_or(SbiRet::not_supported())
+            .map_or(SbiRet::not_supported(), |inner| T::read(inner, bytes))
     }
     #[inline]
     fn write_byte(&self, byte: u8) -> SbiRet {
         self.as_ref()
-            .map(|inner| T::write_byte(inner, byte))
-            .unwrap_or(SbiRet::not_supported())
+            .map_or(SbiRet::not_supported(), |inner| T::write_byte(inner, byte))
     }
     #[inline]
     fn _rustsbi_probe(&self) -> usize {

src/cppc.rs

@@ -144,26 +144,23 @@ impl<T: Cppc> Cppc for Option<T> {
     #[inline]
     fn probe(&self, reg_id: u32) -> SbiRet {
         self.as_ref()
-            .map(|inner| T::probe(inner, reg_id))
-            .unwrap_or(SbiRet::not_supported())
+            .map_or(SbiRet::not_supported(), |inner| T::probe(inner, reg_id))
     }
     #[inline]
     fn read(&self, reg_id: u32) -> SbiRet {
         self.as_ref()
-            .map(|inner| T::read(inner, reg_id))
-            .unwrap_or(SbiRet::not_supported())
+            .map_or(SbiRet::not_supported(), |inner| T::read(inner, reg_id))
     }
     #[inline]
     fn read_hi(&self, reg_id: u32) -> SbiRet {
         self.as_ref()
-            .map(|inner| T::read_hi(inner, reg_id))
-            .unwrap_or(SbiRet::not_supported())
+            .map_or(SbiRet::not_supported(), |inner| T::read_hi(inner, reg_id))
     }
     #[inline]
     fn write(&self, reg_id: u32, val: u64) -> SbiRet {
-        self.as_ref()
-            .map(|inner| T::write(inner, reg_id, val))
-            .unwrap_or(SbiRet::not_supported())
+        self.as_ref().map_or(SbiRet::not_supported(), |inner| {
+            T::write(inner, reg_id, val)
+        })
     }
     #[inline]
     fn _rustsbi_probe(&self) -> usize {

src/hsm.rs

@@ -231,27 +231,26 @@ impl<T: Hsm> Hsm for &T {
 impl<T: Hsm> Hsm for Option<T> {
     #[inline]
     fn hart_start(&self, hartid: usize, start_addr: usize, opaque: usize) -> SbiRet {
-        self.as_ref()
-            .map(|inner| T::hart_start(inner, hartid, start_addr, opaque))
-            .unwrap_or(SbiRet::not_supported())
+        self.as_ref().map_or(SbiRet::not_supported(), |inner| {
+            T::hart_start(inner, hartid, start_addr, opaque)
+        })
     }
     #[inline]
     fn hart_stop(&self) -> SbiRet {
         self.as_ref()
-            .map(|inner| T::hart_stop(inner))
-            .unwrap_or(SbiRet::not_supported())
+            .map_or(SbiRet::not_supported(), |inner| T::hart_stop(inner))
     }
     #[inline]
     fn hart_get_status(&self, hartid: usize) -> SbiRet {
-        self.as_ref()
-            .map(|inner| T::hart_get_status(inner, hartid))
-            .unwrap_or(SbiRet::not_supported())
+        self.as_ref().map_or(SbiRet::not_supported(), |inner| {
+            T::hart_get_status(inner, hartid)
+        })
     }
     #[inline]
     fn hart_suspend(&self, suspend_type: u32, resume_addr: usize, opaque: usize) -> SbiRet {
-        self.as_ref()
-            .map(|inner| T::hart_suspend(inner, suspend_type, resume_addr, opaque))
-            .unwrap_or(SbiRet::not_supported())
+        self.as_ref().map_or(SbiRet::not_supported(), |inner| {
+            T::hart_suspend(inner, suspend_type, resume_addr, opaque)
+        })
     }
     #[inline]
     fn _rustsbi_probe(&self) -> usize {

src/ipi.rs

@@ -28,9 +28,9 @@ impl<T: Ipi> Ipi for &T {
 impl<T: Ipi> Ipi for Option<T> {
     #[inline]
     fn send_ipi(&self, hart_mask: HartMask) -> SbiRet {
-        self.as_ref()
-            .map(|inner| T::send_ipi(inner, hart_mask))
-            .unwrap_or(SbiRet::not_supported())
+        self.as_ref().map_or(SbiRet::not_supported(), |inner| {
+            T::send_ipi(inner, hart_mask)
+        })
     }
     #[inline]
     fn _rustsbi_probe(&self) -> usize {

src/nacl.rs

@@ -174,33 +174,31 @@ impl<T: Nacl> Nacl for &T {
 impl<T: Nacl> Nacl for Option<T> {
     #[inline]
     fn probe_feature(&self, feature_id: u32) -> SbiRet {
-        self.as_ref()
-            .map(|inner| T::probe_feature(inner, feature_id))
-            .unwrap_or(SbiRet::not_supported())
+        self.as_ref().map_or(SbiRet::not_supported(), |inner| {
+            T::probe_feature(inner, feature_id)
+        })
     }
     #[inline]
     fn set_shmem(&self, shmem: SharedPtr<[u8; NATIVE]>, flags: usize) -> SbiRet {
-        self.as_ref()
-            .map(|inner| T::set_shmem(inner, shmem, flags))
-            .unwrap_or(SbiRet::not_supported())
+        self.as_ref().map_or(SbiRet::not_supported(), |inner| {
+            T::set_shmem(inner, shmem, flags)
+        })
     }
     #[inline]
     fn sync_csr(&self, csr_num: usize) -> SbiRet {
         self.as_ref()
-            .map(|inner| T::sync_csr(inner, csr_num))
-            .unwrap_or(SbiRet::not_supported())
+            .map_or(SbiRet::not_supported(), |inner| T::sync_csr(inner, csr_num))
     }
     #[inline]
     fn sync_hfence(&self, entry_index: usize) -> SbiRet {
-        self.as_ref()
-            .map(|inner| T::sync_hfence(inner, entry_index))
-            .unwrap_or(SbiRet::not_supported())
+        self.as_ref().map_or(SbiRet::not_supported(), |inner| {
+            T::sync_hfence(inner, entry_index)
+        })
     }
     #[inline]
     fn sync_sret(&self) -> SbiRet {
         self.as_ref()
-            .map(|inner| T::sync_sret(inner))
-            .unwrap_or(SbiRet::not_supported())
+            .map_or(SbiRet::not_supported(), |inner| T::sync_sret(inner))
     }
     #[inline]
     fn _rustsbi_probe(&self) -> usize {

src/pmu.rs

@@ -359,15 +359,13 @@ impl<T: Pmu> Pmu for &T {
 impl<T: Pmu> Pmu for Option<T> {
     #[inline]
     fn num_counters(&self) -> usize {
-        self.as_ref()
-            .map(|inner| T::num_counters(inner))
-            .unwrap_or(0)
+        self.as_ref().map_or(0, |inner| T::num_counters(inner))
     }
     #[inline]
     fn counter_get_info(&self, counter_idx: usize) -> SbiRet {
-        self.as_ref()
-            .map(|inner| T::counter_get_info(inner, counter_idx))
-            .unwrap_or(SbiRet::not_supported())
+        self.as_ref().map_or(SbiRet::not_supported(), |inner| {
+            T::counter_get_info(inner, counter_idx)
+        })
     }
     #[inline]
     fn counter_config_matching(
@@ -397,17 +395,15 @@ impl<T: Pmu> Pmu for Option<T> {
         start_flags: usize,
         initial_value: u64,
     ) -> SbiRet {
-        self.as_ref()
-            .map(|inner| {
-                T::counter_start(
-                    inner,
-                    counter_idx_base,
-                    counter_idx_mask,
-                    start_flags,
-                    initial_value,
-                )
-            })
-            .unwrap_or(SbiRet::not_supported())
+        self.as_ref().map_or(SbiRet::not_supported(), |inner| {
+            T::counter_start(
+                inner,
+                counter_idx_base,
+                counter_idx_mask,
+                start_flags,
+                initial_value,
+            )
+        })
     }
     #[inline]
     fn counter_stop(
@@ -416,27 +412,27 @@ impl<T: Pmu> Pmu for Option<T> {
         counter_idx_mask: usize,
         stop_flags: usize,
     ) -> SbiRet {
-        self.as_ref()
-            .map(|inner| T::counter_stop(inner, counter_idx_base, counter_idx_mask, stop_flags))
-            .unwrap_or(SbiRet::not_supported())
+        self.as_ref().map_or(SbiRet::not_supported(), |inner| {
+            T::counter_stop(inner, counter_idx_base, counter_idx_mask, stop_flags)
+        })
     }
     #[inline]
     fn counter_fw_read(&self, counter_idx: usize) -> SbiRet {
-        self.as_ref()
-            .map(|inner| T::counter_fw_read(inner, counter_idx))
-            .unwrap_or(SbiRet::not_supported())
+        self.as_ref().map_or(SbiRet::not_supported(), |inner| {
+            T::counter_fw_read(inner, counter_idx)
+        })
     }
     #[inline]
     fn counter_fw_read_hi(&self, counter_idx: usize) -> SbiRet {
-        self.as_ref()
-            .map(|inner| T::counter_fw_read_hi(inner, counter_idx))
-            .unwrap_or(SbiRet::not_supported())
+        self.as_ref().map_or(SbiRet::not_supported(), |inner| {
+            T::counter_fw_read_hi(inner, counter_idx)
+        })
     }
     #[inline]
     fn snapshot_set_shmem(&self, shmem: SharedPtr<[u8; SIZE]>, flags: usize) -> SbiRet {
-        self.as_ref()
-            .map(|inner| T::snapshot_set_shmem(inner, shmem, flags))
-            .unwrap_or(SbiRet::not_supported())
+        self.as_ref().map_or(SbiRet::not_supported(), |inner| {
+            T::snapshot_set_shmem(inner, shmem, flags)
+        })
     }
     #[inline]
     fn _rustsbi_probe(&self) -> usize {

src/reset.rs

@@ -59,9 +59,9 @@ impl<T: Reset> Reset for &T {
 impl<T: Reset> Reset for Option<T> {
     #[inline]
     fn system_reset(&self, reset_type: u32, reset_reason: u32) -> SbiRet {
-        self.as_ref()
-            .map(|inner| T::system_reset(inner, reset_type, reset_reason))
-            .unwrap_or(SbiRet::not_supported())
+        self.as_ref().map_or(SbiRet::not_supported(), |inner| {
+            T::system_reset(inner, reset_type, reset_reason)
+        })
     }
     #[inline]
     fn _rustsbi_probe(&self) -> usize {

src/rfence.rs

@@ -196,15 +196,15 @@ impl<T: Rfence> Rfence for &T {
 impl<T: Rfence> Rfence for Option<T> {
     #[inline]
     fn remote_fence_i(&self, hart_mask: HartMask) -> SbiRet {
-        self.as_ref()
-            .map(|inner| T::remote_fence_i(inner, hart_mask))
-            .unwrap_or(SbiRet::not_supported())
+        self.as_ref().map_or(SbiRet::not_supported(), |inner| {
+            T::remote_fence_i(inner, hart_mask)
+        })
     }
     #[inline]
     fn remote_sfence_vma(&self, hart_mask: HartMask, start_addr: usize, size: usize) -> SbiRet {
-        self.as_ref()
-            .map(|inner| T::remote_sfence_vma(inner, hart_mask, start_addr, size))
-            .unwrap_or(SbiRet::not_supported())
+        self.as_ref().map_or(SbiRet::not_supported(), |inner| {
+            T::remote_sfence_vma(inner, hart_mask, start_addr, size)
+        })
     }
     #[inline]
     fn remote_sfence_vma_asid(
@@ -214,9 +214,9 @@ impl<T: Rfence> Rfence for Option<T> {
         size: usize,
         asid: usize,
     ) -> SbiRet {
-        self.as_ref()
-            .map(|inner| T::remote_sfence_vma_asid(inner, hart_mask, start_addr, size, asid))
-            .unwrap_or(SbiRet::not_supported())
+        self.as_ref().map_or(SbiRet::not_supported(), |inner| {
+            T::remote_sfence_vma_asid(inner, hart_mask, start_addr, size, asid)
+        })
     }
     #[inline]
     fn remote_hfence_gvma_vmid(
@@ -226,15 +226,15 @@ impl<T: Rfence> Rfence for Option<T> {
         size: usize,
         vmid: usize,
     ) -> SbiRet {
-        self.as_ref()
-            .map(|inner| T::remote_hfence_gvma_vmid(inner, hart_mask, start_addr, size, vmid))
-            .unwrap_or(SbiRet::not_supported())
+        self.as_ref().map_or(SbiRet::not_supported(), |inner| {
+            T::remote_hfence_gvma_vmid(inner, hart_mask, start_addr, size, vmid)
+        })
     }
     #[inline]
     fn remote_hfence_gvma(&self, hart_mask: HartMask, start_addr: usize, size: usize) -> SbiRet {
-        self.as_ref()
-            .map(|inner| T::remote_hfence_gvma(inner, hart_mask, start_addr, size))
-            .unwrap_or(SbiRet::not_supported())
+        self.as_ref().map_or(SbiRet::not_supported(), |inner| {
+            T::remote_hfence_gvma(inner, hart_mask, start_addr, size)
+        })
     }
     #[inline]
     fn remote_hfence_vvma_asid(
@@ -244,15 +244,15 @@ impl<T: Rfence> Rfence for Option<T> {
         size: usize,
         asid: usize,
     ) -> SbiRet {
-        self.as_ref()
-            .map(|inner| T::remote_hfence_vvma_asid(inner, hart_mask, start_addr, size, asid))
-            .unwrap_or(SbiRet::not_supported())
+        self.as_ref().map_or(SbiRet::not_supported(), |inner| {
+            T::remote_hfence_vvma_asid(inner, hart_mask, start_addr, size, asid)
+        })
     }
     #[inline]
     fn remote_hfence_vvma(&self, hart_mask: HartMask, start_addr: usize, size: usize) -> SbiRet {
-        self.as_ref()
-            .map(|inner| T::remote_hfence_vvma(inner, hart_mask, start_addr, size))
-            .unwrap_or(SbiRet::not_supported())
+        self.as_ref().map_or(SbiRet::not_supported(), |inner| {
+            T::remote_hfence_vvma(inner, hart_mask, start_addr, size)
+        })
     }
     #[inline]
     fn _rustsbi_probe(&self) -> usize {

src/sta.rs

@@ -74,9 +74,9 @@ impl<T: Sta> Sta for &T {
 impl<T: Sta> Sta for Option<T> {
     #[inline]
     fn set_shmem(&self, shmem: SharedPtr<[u8; 64]>, flags: usize) -> SbiRet {
-        self.as_ref()
-            .map(|inner| T::set_shmem(inner, shmem, flags))
-            .unwrap_or(SbiRet::not_supported())
+        self.as_ref().map_or(SbiRet::not_supported(), |inner| {
+            T::set_shmem(inner, shmem, flags)
+        })
     }
     #[inline]
     fn _rustsbi_probe(&self) -> usize {

src/susp.rs

@@ -99,9 +99,9 @@ impl<T: Susp> Susp for &T {
 impl<T: Susp> Susp for Option<T> {
     #[inline]
     fn system_suspend(&self, sleep_type: u32, resume_addr: usize, opaque: usize) -> SbiRet {
-        self.as_ref()
-            .map(|inner| T::system_suspend(inner, sleep_type, resume_addr, opaque))
-            .unwrap_or(SbiRet::not_supported())
+        self.as_ref().map_or(SbiRet::not_supported(), |inner| {
+            T::system_suspend(inner, sleep_type, resume_addr, opaque)
+        })
     }
     #[inline]
     fn _rustsbi_probe(&self) -> usize {

src/timer.rs

@@ -27,8 +27,7 @@ impl<T: Timer> Timer for Option<T> {
     #[inline]
     fn set_timer(&self, stime_value: u64) {
         self.as_ref()
-            .map(|inner| T::set_timer(inner, stime_value))
-            .unwrap_or(())
+            .map_or((), |inner| T::set_timer(inner, stime_value))
     }
     #[inline]
     fn _rustsbi_probe(&self) -> usize {