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),
  }
  }