chore: reorganized some code

Author: WhaleKit

crates/tinywasm/src/coro.rs

@@ -12,6 +12,7 @@ pub trait CoroState<Ret, ResumeContext>: Debug {
 
 /// explains why did execution suspend, and carries payload if needed
 #[derive(Debug)]
+#[non_exhaustive] // some variants are feature-gated
 pub enum SuspendReason {
     /// host function yielded
     /// potentially some host functions might expect resume argument when calling resume
@@ -59,7 +60,6 @@ pub enum CoroStateResumeResult<R> {
 }
 
 impl<R, State> PotentialCoroCallResult<R, State> {
-
     /// in case you expect function only to return
     /// you can make Suspend into [crate::Error::UnexpectedSuspend] error
     pub fn suspend_to_err(self) -> Result<R> {
@@ -95,24 +95,24 @@ impl<R, State> PotentialCoroCallResult<R, State> {
             Self::Suspended(suspend, state) => PotentialCoroCallResult::Suspended(suspend, mapper(state)),
         }
     }
-    /// transform result with mapper if there is none - calls "otherwise" arg. user_val
-    pub fn map_result_or_else<OutR, Usr>(
+    /// transform result with mapper if there is none - calls "otherwise".
+    /// user_val passed to whichever is called and is guaranteed to be used
+    pub fn map<OutR, Usr, OutS>(
         self,
         user_val: Usr,
-        mapper: impl FnOnce(R, Usr) -> OutR,
-        otherwise: impl FnOnce(Usr),
-    ) -> PotentialCoroCallResult<OutR, State> {
+        res_mapper: impl FnOnce(R, Usr) -> OutR,
+        state_mapper: impl FnOnce(State, Usr) -> OutS,
+    ) -> PotentialCoroCallResult<OutR, OutS> {
         match self {
-            Self::Return(res) => PotentialCoroCallResult::Return(mapper(res, user_val)),
+            Self::Return(res) => PotentialCoroCallResult::Return(res_mapper(res, user_val)),
             Self::Suspended(suspend, state) => {
-                otherwise(user_val);
-                PotentialCoroCallResult::Suspended(suspend, state)
+                PotentialCoroCallResult::Suspended(suspend, state_mapper(state, user_val))
             }
         }
     }
     /// transforms result
     pub fn map_result<OutR>(self, mapper: impl FnOnce(R) -> OutR) -> PotentialCoroCallResult<OutR, State> {
-        self.map_result_or_else((), |val, _| mapper(val), |_| {})
+        self.map((), |val, _| mapper(val), |s,_| {s})
     }
 }
 
@@ -130,14 +130,15 @@ impl<R> CoroStateResumeResult<R> {
     pub fn map_result<OutR>(self, mapper: impl FnOnce(R) -> OutR) -> CoroStateResumeResult<OutR> {
         PotentialCoroCallResult::<R, ()>::from(self).map_result(mapper).into()
     }
-    /// transform result with mapper if there is none - calls "otherwise" arg. user_val called
-    pub fn map_result_or_else<OutR, Usr>(
+    /// transform result with mapper. If there is none - calls "otherwise"
+    /// user_val passed to whichever is called and is guaranteed to be used
+    pub fn map<OutR, Usr>(
         self,
         user_val: Usr,
         mapper: impl FnOnce(R, Usr) -> OutR,
         otherwise: impl FnOnce(Usr),
     ) -> CoroStateResumeResult<OutR> {
-        PotentialCoroCallResult::<R, ()>::from(self).map_result_or_else(user_val, mapper, otherwise).into()
+        PotentialCoroCallResult::<R, ()>::from(self).map(user_val, mapper, |(), usr|{otherwise(usr)}).into()
     }
 }
 

crates/tinywasm/src/store/mod.rs

@@ -1,6 +1,5 @@
 use alloc::{boxed::Box, format, string::ToString, vec::Vec};
 use core::fmt::Debug;
-use core::ops::ControlFlow;
 use core::sync::atomic::{AtomicUsize, Ordering};
 use tinywasm_types::*;
 
@@ -12,8 +11,10 @@ mod element;
 mod function;
 mod global;
 mod memory;
+mod suspend_conditions;
 mod table;
 
+pub use suspend_conditions::*;
 pub(crate) use {data::*, element::*, function::*, global::*, memory::*, table::*};
 
 // global store id counter
@@ -34,7 +35,11 @@ pub struct Store {
 
     pub(crate) data: StoreData,
     pub(crate) runtime: Runtime,
-    // idk where to put it, but here it's accessible to host functions without modifying their signature
+
+    // idk where really to put it, but it should be accessible to host environment (obviously)
+    // and (less obviously) to host functions called from store - for calling wasm callbacks and propagating this config to them
+    // (or just complying with suspend conditions themselves)
+    // alternatively it could be passed to function handles and passend into function context
     pub(crate) suspend_cond: SuspendConditions,
 }
 
@@ -486,53 +491,7 @@ fn get_pair_mut<T>(slice: &mut [T], i: usize, j: usize) -> Option<(&mut T, &mut
     Some(pair)
 }
 
-/// user callback for use in [SuspendConditions::suspend_cb]
-pub type ShouldSuspendCb = Box<dyn FnMut(&Store) -> ControlFlow<(), ()>>;
-
-// idk where really to put it, but it should be accessible to host environment (obviously)
-// and (less obviously) to host functions called from it - for calling wasm callbacks and propagating this config to them
-// (or just complying with suspend conditions themselves)
-/// used to limit execution time wasm code takes
-#[derive(Default)]
-pub struct SuspendConditions {
-    /// atomic flag. when set to true it means execution should suspend
-    /// can be used to tell executor to stop from another thread
-    pub suspend_flag: Option<alloc::sync::Arc<core::sync::atomic::AtomicBool>>,
-
-    /// instant at which execution should suspend
-    /// can be used to control how much time will be spent in wasm without requiring other threads
-    /// such as for time-slice multitasking
-    /// uses rust standard library for checking time - so not available in no-std
-    #[cfg(feature = "std")]
-    pub timeout_instant: Option<crate::std::time::Instant>,
-
-    /// callback that returns [`ControlFlow::Break`]` when execution should suspend
-    /// can be used when above methods are insufficient or
-    /// instead of [`timeout_instant`] in no-std builds, if you have your own clock function
-    pub suspend_cb: Option<ShouldSuspendCb>,
-}
-
-impl Debug for SuspendConditions {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        let stop_cb_text = if self.suspend_cb.is_some() { "<present>" } else { "<not present>" };
-        let mut f = f.debug_struct("SuspendConditions");
-        f.field("stop_flag", &self.suspend_flag);
-        #[cfg(feature = "std")]
-        {
-            f.field("timeout_instant", &self.timeout_instant);
-        }
-        f.field("stop_cb", &stop_cb_text).finish()
-    }
-}
-
-impl SuspendConditions {
-    /// sets timeout_instant to `how_long` from now
-    #[cfg(feature = "std")]
-    pub fn set_timeout_in(&mut self, how_long: crate::std::time::Duration) {
-        self.timeout_instant = Some(crate::std::time::Instant::now() + how_long);
-    }
-}
-
+// suspend_conditions-related functions
 impl Store {
     /// sets suspend conditions for store
     pub fn set_suspend_conditions(&mut self, val: SuspendConditions) {
@@ -543,8 +502,8 @@ impl Store {
         &self.suspend_cond
     }
     /// transforms suspend conditions for store using user-provided function
-    pub fn update_suspend_conditions(&mut self, replacer: impl FnOnce(SuspendConditions) -> SuspendConditions) {
+    pub fn update_suspend_conditions(&mut self, mapper: impl FnOnce(SuspendConditions) -> SuspendConditions) {
         let temp = core::mem::take(&mut self.suspend_cond);
-        self.suspend_cond = replacer(temp);
+        self.suspend_cond = mapper(temp);
     }
 }

crates/tinywasm/src/store/suspend_conditions.rs

@@ -0,0 +1,94 @@
+use crate::store::Store;
+use alloc::boxed::Box;
+use core::fmt::Debug;
+use core::ops::ControlFlow;
+
+/// user callback for use in [SuspendConditions::suspend_cb]
+pub type ShouldSuspendCb = Box<dyn FnMut(&Store) -> ControlFlow<(), ()>>;
+
+/// used to limit execution time wasm code takes
+#[derive(Default)]
+#[non_exhaustive] // some fields are feature-gated, use with*-methods to construct
+pub struct SuspendConditions {
+    /// atomic flag. when set to true it means execution should suspend
+    /// can be used to tell executor to stop from another thread
+    pub suspend_flag: Option<alloc::sync::Arc<core::sync::atomic::AtomicBool>>,
+
+    /// instant at which execution should suspend
+    /// can be used to control how much time will be spent in wasm without requiring other threads
+    /// such as for time-slice multitasking
+    /// uses rust standard library for checking time - so not available in no-std
+    #[cfg(feature = "std")]
+    pub timeout_instant: Option<crate::std::time::Instant>,
+
+    /// callback that returns [`ControlFlow::Break`]` when execution should suspend
+    /// can be used when above ways are insufficient or
+    /// instead of [`timeout_instant`] in no-std builds, with your own clock function
+    pub suspend_cb: Option<ShouldSuspendCb>,
+}
+
+impl Debug for SuspendConditions {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        let stop_cb_text = if self.suspend_cb.is_some() { "<present>" } else { "<not present>" };
+        let mut f = f.debug_struct("SuspendConditions");
+        f.field("stop_flag", &self.suspend_flag);
+        #[cfg(feature = "std")]
+        {
+            f.field("timeout_instant", &self.timeout_instant);
+        }
+        f.field("stop_cb", &stop_cb_text).finish()
+    }
+}
+
+impl SuspendConditions {
+    /// creates suspend_conditions with every condition unset
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    /// sets timeout_instant to `how_long` from now
+    #[cfg(feature = "std")]
+    pub fn set_timeout_in(&mut self, how_long: crate::std::time::Duration) -> &mut Self {
+        self.timeout_instant = Some(crate::std::time::Instant::now() + how_long);
+        self
+    }
+    /// adds timeout at specified instant
+    #[cfg(feature = "std")]
+    pub fn with_timeout_at(self, when: crate::std::time::Instant) -> Self {
+        Self { timeout_instant: Some(when), ..self }
+    }
+    /// adds timeout in specified duration
+    #[cfg(feature = "std")]
+    pub fn with_timeout_in(self, how_long: crate::std::time::Duration) -> Self {
+        Self { timeout_instant: Some(crate::std::time::Instant::now() + how_long), ..self }
+    }
+    /// removes timeout
+    pub fn without_timeout(self) -> Self {
+        #[cfg(feature = "std")]
+        {
+            Self { timeout_instant: None, ..self }
+        }
+        #[cfg(not(feature = "std"))]
+        {
+            self
+        }
+    }
+
+    /// adds susped flag
+    pub fn with_suspend_flag(self, should_suspend: alloc::sync::Arc<core::sync::atomic::AtomicBool>) -> Self {
+        Self { suspend_flag: Some(should_suspend), ..self }
+    }
+    /// removes susped flag
+    pub fn without_suspend_flag(self) -> Self {
+        Self { suspend_flag: None, ..self }
+    }
+
+    /// adds suspend callback
+    pub fn with_suspend_callback(self, cb: ShouldSuspendCb) -> Self {
+        Self { suspend_cb: Some(cb), ..self }
+    }
+    /// removes suspend callback
+    pub fn without_suspend_callback(self) -> Self {
+        Self { suspend_cb: None, ..self }
+    }
+}

tests/wasm_resume.rs

@@ -1,10 +1,7 @@
 use core::panic;
 use eyre;
 use std::sync;
-use std::{
-    ops::ControlFlow,
-    time::{Duration, Instant},
-};
+use std::{ops::ControlFlow, time::Duration};
 use tinywasm::{
     CoroState, CoroStateResumeResult, Module, ModuleInstance, PotentialCoroCallResult, Store, SuspendConditions,
     SuspendReason,
@@ -17,18 +14,15 @@ fn main() -> std::result::Result<(), eyre::Report> {
     println!("\n# testing with callback");
     let mut cb_cond = |store: &mut Store| {
         let callback = make_suspend_in_time_cb(30);
-        store.set_suspend_conditions(SuspendConditions { suspend_cb: Some(Box::new(callback)), ..Default::default() });
+        store.set_suspend_conditions(SuspendConditions::new().with_suspend_callback(Box::new(callback)));
     };
     suspend_with_pure_loop(&mut cb_cond, SuspendReason::SuspendedCallback)?;
     suspend_with_wasm_fn(&mut cb_cond, SuspendReason::SuspendedCallback)?;
     suspend_with_host_fn(&mut cb_cond, SuspendReason::SuspendedCallback)?;
 
     println!("\n# testing with epoch");
     let mut time_cond = |store: &mut Store| {
-        store.set_suspend_conditions(SuspendConditions {
-            timeout_instant: Some(Instant::now() + Duration::from_millis(10)),
-            ..Default::default()
-        })
+        store.set_suspend_conditions(SuspendConditions::new().with_timeout_in(Duration::from_millis(10)))
     };
     suspend_with_pure_loop(&mut time_cond, SuspendReason::SuspendedEpoch)?;
     suspend_with_wasm_fn(&mut time_cond, SuspendReason::SuspendedEpoch)?;
@@ -37,7 +31,7 @@ fn main() -> std::result::Result<(), eyre::Report> {
     println!("\n# testing atomic bool");
     let mut cb_thead = |store: &mut Store| {
         let arc = sync::Arc::<sync::atomic::AtomicBool>::new(sync::atomic::AtomicBool::new(false));
-        store.set_suspend_conditions(SuspendConditions { suspend_flag: Some(arc.clone()), ..Default::default() });
+        store.set_suspend_conditions(SuspendConditions::new().with_suspend_flag(arc.clone()));
         let handle = std::thread::spawn(move || {
             std::thread::sleep(Duration::from_millis(10));
             arc.store(true, sync::atomic::Ordering::Release);
@@ -70,6 +64,7 @@ fn try_compare(lhs: &SuspendReason, rhs: &SuspendReason) -> eyre::Result<bool> {
         SuspendReason::SuspendedEpoch => matches!(rhs, SuspendReason::SuspendedEpoch),
         SuspendReason::SuspendedCallback => matches!(rhs, SuspendReason::SuspendedCallback),
         SuspendReason::SuspendedFlag => matches!(rhs, SuspendReason::SuspendedFlag),
+        _ =>eyre::bail!("unimplemented new variant"),
     })
 }