codestyle, relax bounds on YieldedValue/ResumeArgument

Author: WhaleKit

crates/tinywasm/src/coro.rs

@@ -15,15 +15,15 @@ pub trait CoroState<Ret, ResumeContext>: 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
+    /// some host functions might expect resume argument when calling resume
     Yield(YieldedValue),
 
     /// time to suspend has come,
     /// host shouldn't provide resume argument when calling resume
     #[cfg(feature = "std")]
     SuspendedEpoch,
 
-    /// user's should-suspend-callback,
+    /// user's should-suspend-callback returned Break,
     /// host shouldn't provide resume argument when calling resume
     SuspendedCallback,
 
@@ -65,7 +65,7 @@ impl<R, State> PotentialCoroCallResult<R, State> {
     pub fn suspend_to_err(self) -> Result<R> {
         match self {
             PotentialCoroCallResult::Return(r) => Ok(r),
-            PotentialCoroCallResult::Suspended(r, _) => Err(crate::Error::UnexpectedSuspend(r)),
+            PotentialCoroCallResult::Suspended(r, _) => Err(crate::Error::UnexpectedSuspend(r.into())),
         }
     }
 
@@ -112,7 +112,7 @@ impl<R, State> PotentialCoroCallResult<R, State> {
     }
     /// transforms result
     pub fn map_result<OutR>(self, mapper: impl FnOnce(R) -> OutR) -> PotentialCoroCallResult<OutR, State> {
-        self.map((), |val, _| mapper(val), |s,_| {s})
+        self.map((), |val, _| mapper(val), |s, _| s)
     }
 }
 
@@ -138,7 +138,7 @@ impl<R> CoroStateResumeResult<R> {
         mapper: impl FnOnce(R, Usr) -> OutR,
         otherwise: impl FnOnce(Usr),
     ) -> CoroStateResumeResult<OutR> {
-        PotentialCoroCallResult::<R, ()>::from(self).map(user_val, mapper, |(), usr|{otherwise(usr)}).into()
+        PotentialCoroCallResult::<R, ()>::from(self).map(user_val, mapper, |(), usr| otherwise(usr)).into()
     }
 }
 
@@ -161,3 +161,39 @@ impl<SrcR> From<CoroStateResumeResult<SrcR>> for PotentialCoroCallResult<SrcR, (
         }
     }
 }
+
+impl SuspendReason {
+    /// shotrhand to package val into a Box<any> in a [SuspendReason::Yield] variant
+    /// you'll need to specify type explicitly, because you'll need to use exact same type when downcasting
+    pub fn make_yield<T>(val: impl Into<T> + core::any::Any) -> Self {
+        Self::Yield(Some(alloc::boxed::Box::new(val) as alloc::boxed::Box<dyn core::any::Any>))
+    }
+}
+
+// same as SuspendReason, but without [tinywasm_types::YieldedValue]
+// it's opaque anyway, and error has Send and Sync which aren't typically needed for yielded value
+#[derive(Debug)]
+pub enum UnexpectedSuspendError {
+    /// host function yielded
+    Yield,
+
+    /// timeout,
+    #[cfg(feature = "std")]
+    SuspendedEpoch,
+
+    /// user's should-suspend-callback returned Break,
+    SuspendedCallback,
+
+    /// async should_suspend flag was set
+    SuspendedFlag,
+}
+impl From<SuspendReason> for UnexpectedSuspendError {
+    fn from(value: SuspendReason) -> Self {
+        match value {
+            SuspendReason::Yield(_) => Self::Yield,
+            SuspendReason::SuspendedEpoch => Self::SuspendedEpoch,
+            SuspendReason::SuspendedCallback => Self::SuspendedCallback,
+            SuspendReason::SuspendedFlag => Self::SuspendedFlag,
+        }
+    }
+}

crates/tinywasm/src/error.rs

@@ -6,7 +6,7 @@ use tinywasm_types::FuncType;
 #[cfg(feature = "parser")]
 pub use tinywasm_parser::ParseError;
 
-use crate::{coro::SuspendReason, interpreter};
+use crate::{coro::UnexpectedSuspendError, interpreter};
 
 /// Errors that can occur for `TinyWasm` operations
 #[derive(Debug)]
@@ -45,7 +45,7 @@ pub enum Error {
 
     /// Function unexpectedly yielded instead of returning
     /// (for backwards compatibility with old api)
-    UnexpectedSuspend(SuspendReason),
+    UnexpectedSuspend(UnexpectedSuspendError),
 
     #[cfg(feature = "std")]
     /// An I/O error occurred

crates/types/src/lib.rs

@@ -10,7 +10,7 @@
 
 extern crate alloc;
 use alloc::boxed::Box;
-use core::{fmt::Debug, ops::Range, any::Any};
+use core::{any::Any, fmt::Debug, ops::Range};
 
 // Memory defaults
 const MEM_PAGE_SIZE: u64 = 65536;
@@ -409,9 +409,5 @@ pub enum ElementItem {
     Expr(ConstInstruction),
 }
 
-// concider adding lifetime
-// yielded value might benefit from referencing something in 
-// suspended host coro, and resume argument - from down the callstack
-// however, that would make executor structure more difficult
-pub type YieldedValue = Option<Box<dyn Any + Send + Sync>>;
-pub type ResumeArgument = Option<Box<dyn Any + Send + Sync>>;
+pub type YieldedValue = Option<Box<dyn Any>>;
+pub type ResumeArgument = Option<Box<dyn Any>>;

examples/host_coro.rs

@@ -56,9 +56,11 @@ fn main() -> eyre::Result<()> {
                            vals: &[WasmValue]|
      -> tinywasm::Result<PotentialCoroCallResult<Vec<WasmValue>, Box<dyn HostCoroState>>> {
         let base = if let WasmValue::I32(v) = vals.first().expect("wrong args") { v } else { panic!("wrong arg") };
-        let val_to_yield = Box::new(MyUserData { magic: 42 });
         let coro = Box::new(MySuspendedState { base: *base });
-        return Ok(PotentialCoroCallResult::Suspended(SuspendReason::Yield(Some(val_to_yield)), coro));
+        return Ok(PotentialCoroCallResult::Suspended(
+            SuspendReason::make_yield::<MyUserData>(MyUserData { magic: 42 }),
+            coro,
+        ));
     };
     imports.define(
         "host",