Return AsyncCallFuture<R> instead of opaque impl Future from ObjectLike trait.

Author: khvzak

src/function.rs

@@ -657,6 +657,13 @@ impl LuaType for Function {
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 pub struct AsyncCallFuture<R: FromLuaMulti>(Result<AsyncThread<R>>);
 
+#[cfg(feature = "async")]
+impl<R: FromLuaMulti> AsyncCallFuture<R> {
+    pub(crate) fn error(err: Error) -> Self {
+        AsyncCallFuture(Err(err))
+    }
+}
+
 #[cfg(feature = "async")]
 impl<R: FromLuaMulti> Future for AsyncCallFuture<R> {
     type Output = Result<R>;

src/table.rs

@@ -13,10 +13,7 @@ use crate::util::{assert_stack, check_stack, get_metatable_ptr, StackGuard};
 use crate::value::{Nil, Value};
 
 #[cfg(feature = "async")]
-use {
-    crate::types::MaybeSend,
-    futures_util::future::{self, Either, Future},
-};
+use crate::function::AsyncCallFuture;
 
 #[cfg(feature = "serde")]
 use {
@@ -892,9 +889,9 @@ impl ObjectLike for Table {
 
     #[cfg(feature = "async")]
     #[inline]
-    fn call_async<R>(&self, args: impl IntoLuaMulti) -> impl Future<Output = Result<R>> + MaybeSend
+    fn call_async<R>(&self, args: impl IntoLuaMulti) -> AsyncCallFuture<R>
     where
-        R: FromLuaMulti + MaybeSend,
+        R: FromLuaMulti,
     {
         Function(self.0.copy()).call_async(args)
     }
@@ -908,13 +905,9 @@ impl ObjectLike for Table {
     }
 
     #[cfg(feature = "async")]
-    fn call_async_method<R>(
-        &self,
-        name: &str,
-        args: impl IntoLuaMulti,
-    ) -> impl Future<Output = Result<R>> + MaybeSend
+    fn call_async_method<R>(&self, name: &str, args: impl IntoLuaMulti) -> AsyncCallFuture<R>
     where
-        R: FromLuaMulti + MaybeSend,
+        R: FromLuaMulti,
     {
         self.call_async_function(name, (self, args))
     }
@@ -932,21 +925,17 @@ impl ObjectLike for Table {
 
     #[cfg(feature = "async")]
     #[inline]
-    fn call_async_function<R>(
-        &self,
-        name: &str,
-        args: impl IntoLuaMulti,
-    ) -> impl Future<Output = Result<R>> + MaybeSend
+    fn call_async_function<R>(&self, name: &str, args: impl IntoLuaMulti) -> AsyncCallFuture<R>
     where
-        R: FromLuaMulti + MaybeSend,
+        R: FromLuaMulti,
     {
         match self.get(name) {
-            Ok(Value::Function(func)) => Either::Left(func.call_async(args)),
+            Ok(Value::Function(func)) => func.call_async(args),
             Ok(val) => {
                 let msg = format!("attempt to call a {} value (function '{name}')", val.type_name());
-                Either::Right(future::ready(Err(Error::RuntimeError(msg))))
+                AsyncCallFuture::error(Error::RuntimeError(msg))
             }
-            Err(err) => Either::Right(future::ready(Err(err))),
+            Err(err) => AsyncCallFuture::error(err),
         }
     }
 

src/traits.rs

@@ -11,7 +11,7 @@ use crate::util::{check_stack, short_type_name};
 use crate::value::Value;
 
 #[cfg(feature = "async")]
-use std::future::Future;
+use {crate::function::AsyncCallFuture, std::future::Future};
 
 /// Trait for types convertible to [`Value`].
 pub trait IntoLua: Sized {
@@ -162,9 +162,9 @@ pub trait ObjectLike: Sealed {
     /// arguments.
     #[cfg(feature = "async")]
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    fn call_async<R>(&self, args: impl IntoLuaMulti) -> impl Future<Output = Result<R>> + MaybeSend
+    fn call_async<R>(&self, args: impl IntoLuaMulti) -> AsyncCallFuture<R>
     where
-        R: FromLuaMulti + MaybeSend;
+        R: FromLuaMulti;
 
     /// Gets the function associated to key `name` from the object and calls it,
     /// passing the object itself along with `args` as function arguments.
@@ -178,13 +178,9 @@ pub trait ObjectLike: Sealed {
     /// This might invoke the `__index` metamethod.
     #[cfg(feature = "async")]
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    fn call_async_method<R>(
-        &self,
-        name: &str,
-        args: impl IntoLuaMulti,
-    ) -> impl Future<Output = Result<R>> + MaybeSend
+    fn call_async_method<R>(&self, name: &str, args: impl IntoLuaMulti) -> AsyncCallFuture<R>
     where
-        R: FromLuaMulti + MaybeSend;
+        R: FromLuaMulti;
 
     /// Gets the function associated to key `name` from the object and calls it,
     /// passing `args` as function arguments.
@@ -200,13 +196,9 @@ pub trait ObjectLike: Sealed {
     /// This might invoke the `__index` metamethod.
     #[cfg(feature = "async")]
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    fn call_async_function<R>(
-        &self,
-        name: &str,
-        args: impl IntoLuaMulti,
-    ) -> impl Future<Output = Result<R>> + MaybeSend
+    fn call_async_function<R>(&self, name: &str, args: impl IntoLuaMulti) -> AsyncCallFuture<R>
     where
-        R: FromLuaMulti + MaybeSend;
+        R: FromLuaMulti;
 
     /// Converts the object to a string in a human-readable format.
     ///

src/userdata/object.rs

@@ -8,10 +8,7 @@ use crate::value::Value;
 use crate::Function;
 
 #[cfg(feature = "async")]
-use {
-    crate::types::MaybeSend,
-    futures_util::future::{self, Either, Future},
-};
+use crate::function::AsyncCallFuture;
 
 impl ObjectLike for AnyUserData {
     #[inline]
@@ -38,9 +35,9 @@ impl ObjectLike for AnyUserData {
 
     #[cfg(feature = "async")]
     #[inline]
-    fn call_async<R>(&self, args: impl IntoLuaMulti) -> impl Future<Output = Result<R>> + MaybeSend
+    fn call_async<R>(&self, args: impl IntoLuaMulti) -> AsyncCallFuture<R>
     where
-        R: FromLuaMulti + MaybeSend,
+        R: FromLuaMulti,
     {
         Function(self.0.copy()).call_async(args)
     }
@@ -54,13 +51,9 @@ impl ObjectLike for AnyUserData {
     }
 
     #[cfg(feature = "async")]
-    fn call_async_method<R>(
-        &self,
-        name: &str,
-        args: impl IntoLuaMulti,
-    ) -> impl Future<Output = Result<R>> + MaybeSend
+    fn call_async_method<R>(&self, name: &str, args: impl IntoLuaMulti) -> AsyncCallFuture<R>
     where
-        R: FromLuaMulti + MaybeSend,
+        R: FromLuaMulti,
     {
         self.call_async_function(name, (self, args))
     }
@@ -79,21 +72,17 @@ impl ObjectLike for AnyUserData {
     }
 
     #[cfg(feature = "async")]
-    fn call_async_function<R>(
-        &self,
-        name: &str,
-        args: impl IntoLuaMulti,
-    ) -> impl Future<Output = Result<R>> + MaybeSend
+    fn call_async_function<R>(&self, name: &str, args: impl IntoLuaMulti) -> AsyncCallFuture<R>
     where
-        R: FromLuaMulti + MaybeSend,
+        R: FromLuaMulti,
     {
         match self.get(name) {
-            Ok(Value::Function(func)) => Either::Left(func.call_async(args)),
+            Ok(Value::Function(func)) => func.call_async(args),
             Ok(val) => {
                 let msg = format!("attempt to call a {} value (function '{name}')", val.type_name());
-                Either::Right(future::ready(Err(Error::RuntimeError(msg))))
+                AsyncCallFuture::error(Error::RuntimeError(msg))
             }
-            Err(err) => Either::Right(future::ready(Err(err))),
+            Err(err) => AsyncCallFuture::error(err),
         }
     }