feat: use afit and rpitit to optimize Service trait

README.md

@@ -18,7 +18,7 @@ Motore is greatly inspired by [`Tower`][tower].
 
 ## Overview
 
-Motore uses GAT and TAIT to reduce the mental burden of writing asynchronous code, especially to avoid the overhead of `Box` to make people less anxious.
+Motore uses AFIT and RPITIT to reduce the mental burden of writing asynchronous code, especially to avoid the overhead of `Box` to make people less anxious.
 
 The core abstraciton of Motore is the `Service` trait:
 
@@ -29,22 +29,14 @@ pub trait Service<Cx, Request> {
     /// Errors produced by the service.
     type Error;
 
-    /// The future response value.
-    type Future<'cx>: Future<Output = Result<Self::Response, Self::Error>> + Send + 'cx
-    where
-        Cx: 'cx,
-        Self: 'cx;
-
     /// Process the request and return the response asynchronously.
-    fn call<'cx, 's>(&'s self, cx: &'cx mut Cx, req: Request) -> Self::Future<'cx>
-    where
-        's: 'cx;
+    async fn call<'s, 'cx>(&'s self, cx: &'cx mut Cx, req: Request) -> Result<Self::Response, Self::Error>;
 }
 ```
 
 ## Getting Started
 
-Combing GAT and `impl_trait_in_assoc_type` together, we can write asynchronous code in a very concise and readable way.
+Combing AFIT and RPITIT together, we can write asynchronous code in a very concise and readable way.
 
 ```rust
 pub struct Timeout<S> {
@@ -63,20 +55,13 @@ where
 
     type Error = BoxError;
 
-    type Future<'cx> = impl Future<Output = Result<S::Response, Self::Error>> + Send + 'cx;
-
-    fn call<'cx, 's>(&'s self, cx: &'cx mut Cx, req: Req) -> Self::Future<'cx>
-    where
-        's: 'cx,
-    {
-        async move {
-            let sleep = tokio::time::sleep(self.duration);
-            tokio::select! {
-                r = self.inner.call(cx, req) => {
-                    r.map_err(Into::into)
-                },
-                _ = sleep => Err(std::io::Error::new(std::io::ErrorKind::TimedOut, "service time out").into()),
-            }
+    async fn call<'s, 'cx>(&'s self, cx: &'cx mut Cx, req: Req) -> Result<Self::Response, Self::Error> {
+        let sleep = tokio::time::sleep(self.duration);
+        tokio::select! {
+            r = self.inner.call(cx, req) => {
+                r.map_err(Into::into)
+            },
+            _ = sleep => Err(std::io::Error::new(std::io::ErrorKind::TimedOut, "service time out").into()),
         }
     }
 }
@@ -106,10 +91,6 @@ where
 
 ## FAQ
 
-### Why do we need GAT?
-
-https://www.cloudwego.io/zh/docs/motore/faq/q1_gat/
-
 ### Where's the `poll_ready`(a.k.a. backpressure)?
 
 https://www.cloudwego.io/zh/docs/motore/faq/q2_pull_ready/

motore-macros/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "motore-macros"
-version = "0.3.1"
+version = "0.4.0"
 edition = "2021"
 description = """
 Motore's proc macros.
@@ -27,6 +27,9 @@ proc-macro2 = "1"
 quote = "1"
 syn = { version = "1", features = ["full"] }
 
-
 [dev-dependencies]
 motore = { path = "../motore" }
+
+[features]
+default = []
+service_send = []

motore-macros/src/lib.rs

@@ -42,7 +42,8 @@ pub fn service(_args: TokenStream, input: TokenStream) -> TokenStream {
 }
 
 fn expand(item: &mut ItemImpl) -> Result<(), syn::Error> {
-    let generic_params = &item.generics.params;
+    let generic_params: &syn::punctuated::Punctuated<syn::GenericParam, syn::token::Comma> =
+        &item.generics.params;
     let call_method = item
         .items
         .iter_mut()
@@ -89,7 +90,7 @@ fn expand(item: &mut ItemImpl) -> Result<(), syn::Error> {
         }
     };
 
-    let cx_is_generic = generic_params
+    let _cx_is_generic = generic_params
         .iter()
         .filter_map(|p| match p {
             syn::GenericParam::Type(t) => Some(t),
@@ -128,9 +129,16 @@ fn expand(item: &mut ItemImpl) -> Result<(), syn::Error> {
         }
     };
     sig.asyncness = None;
-    sig.generics = parse_quote!(<'cx, 's>);
-    sig.generics.where_clause = Some(parse_quote!(where 's: 'cx));
-    sig.output = parse_quote!(-> Self::Future<'cx>);
+    sig.generics = parse_quote!(<'s, 'cx>);
+    // sig.generics.where_clause = Some(parse_quote!(where 's: 'cx));
+    #[cfg(feature = "service_send")]
+    {
+        sig.output = parse_quote!(-> impl ::std::future::Future<Output = Result<Self::Response, Self::Error>> + Send);
+    }
+    #[cfg(not(feature = "service_send"))]
+    {
+        sig.output = parse_quote!(-> impl ::std::future::Future<Output = Result<Self::Response, Self::Error>>);
+    }
     sig.inputs[0] = parse_quote!(&'s self);
     let old_stmts = &call_method.block.stmts;
     call_method.block.stmts = vec![parse_quote!(async move { #(#old_stmts)* })];
@@ -143,14 +151,14 @@ fn expand(item: &mut ItemImpl) -> Result<(), syn::Error> {
         type Error = #err_ty;
     ));
 
-    let cx_bound = cx_is_generic.then(|| Some(quote!(Cx: 'cx,))).into_iter();
+    // let cx_bound = cx_is_generic.then(|| Some(quote!(Cx: 'cx,))).into_iter();
 
-    item.items.push(parse_quote!(
-       type Future<'cx> = impl ::std::future::Future<Output = Result<Self::Response, Self::Error>> + 'cx
-        where
-            #(#cx_bound)*
-            Self:'cx;
-    ));
+    // item.items.push(parse_quote!(
+    //    type Future<'cx> = impl ::std::future::Future<Output = Result<Self::Response,
+    // Self::Error>> + 'cx     where
+    //         #(#cx_bound)*
+    //         Self:'cx;
+    // ));
 
     Ok(())
 }

motore/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "motore"
-version = "0.3.3"
+version = "0.4.0"
 edition = "2021"
 description = """
 Motore is a library of modular and reusable components for building robust
@@ -21,7 +21,7 @@ keywords = ["io", "async", "non-blocking", "futures", "service"]
 maintenance = { status = "actively-developed" }
 
 [dependencies]
-motore-macros = { path = "../motore-macros", version = "0.3" }
+motore-macros = { path = "../motore-macros", version = "0.4" }
 
 futures = "0.3"
 tokio = { version = "1", features = ["time", "macros"] }
@@ -32,7 +32,11 @@ tower = { version = "0.4", optional = true }
 http = "0.2"
 
 [features]
+default = []
+# enable the tower adapter
 tower = ["dep:tower"]
+# indicates the Service should be Send
+service_send = ["motore-macros/service_send"]
 
 [package.metadata.docs.rs]
 all-features = true

motore/src/layer/layer_fn.rs

@@ -14,9 +14,7 @@ use super::Layer;
 /// # Example
 ///
 /// ```rust
-/// # #![feature(type_alias_impl_trait)]
 /// #
-/// # use futures::Future;
 /// # use motore::layer::{Layer, layer_fn};
 /// # use motore::service::{service_fn, Service, ServiceFn};
 /// # use std::convert::Infallible;
@@ -30,24 +28,22 @@ use super::Layer;
 ///
 /// impl<S, Cx, Request> Service<Cx, Request> for LogService<S>
 /// where
-///     S: Service<Cx, Request>,
-///     Request: fmt::Debug,
+///     S: Service<Cx, Request> + Send + Sync,
+///     Request: fmt::Debug + Send,
+///     Cx: Send,
 /// {
 ///     type Response = S::Response;
 ///     type Error = S::Error;
-///     type Future<'cx> = S::Future<'cx>
-/// where
-///     Cx: 'cx,
-///     S: 'cx;
 ///
-///     fn call<'cx, 's>(&'s self, cx: &'cx mut Cx, req: Request) -> Self::Future<'cx>
-///     where
-///         's: 'cx,
-///     {
+///     async fn call<'s, 'cx>(
+///         &'s self,
+///         cx: &'cx mut Cx,
+///         req: Request,
+///     ) -> Result<Self::Response, Self::Error> {
 ///         // Log the request
 ///         println!("req = {:?}, target = {:?}", req, self.target);
 ///
-///         self.service.call(cx, req)
+///         self.service.call(cx, req).await
 ///     }
 /// }
 ///

motore/src/lib.rs

@@ -1,5 +1,4 @@
 #![cfg_attr(docsrs, feature(doc_cfg))]
-#![feature(impl_trait_in_assoc_type)]
 #![doc(
     html_logo_url = "https://github.com/cloudwego/motore/raw/main/.github/assets/logo.png?sanitize=true"
 )]

motore/src/make/make_connection.rs

@@ -11,12 +11,17 @@ use crate::{sealed::Sealed, UnaryService};
 pub trait MakeConnection<Address>: Sealed<(Address,)> {
     type Connection: AsyncRead + AsyncWrite + Unpin + Send;
     type Error;
-    type Future<'s>: Future<Output = Result<Self::Connection, Self::Error>> + Send + 's
-    where
-        Self: 's,
-        Address: 's;
 
-    fn make_connection(&self, req: Address) -> Self::Future<'_>;
+    #[cfg(feature = "service_send")]
+    fn make_connection(
+        &self,
+        req: Address,
+    ) -> impl Future<Output = Result<Self::Connection, Self::Error>> + Send;
+    #[cfg(not(feature = "service_send"))]
+    fn make_connection(
+        &self,
+        req: Address,
+    ) -> impl Future<Output = Result<Self::Connection, Self::Error>>;
 }
 
 impl<S, Address> Sealed<(Address,)> for S where S: UnaryService<Address> {}
@@ -28,9 +33,19 @@ where
 {
     type Connection = S::Response;
     type Error = S::Error;
-    type Future<'s> = impl Future<Output = Result<Self::Connection, Self::Error>> + Send + 's where Self: 's, Address:'s;
 
-    fn make_connection(&self, addr: Address) -> Self::Future<'_> {
+    #[cfg(feature = "service_send")]
+    fn make_connection(
+        &self,
+        addr: Address,
+    ) -> impl Future<Output = Result<Self::Connection, Self::Error>> + Send {
+        self.call(addr)
+    }
+    #[cfg(not(feature = "service_send"))]
+    fn make_connection(
+        &self,
+        addr: Address,
+    ) -> impl Future<Output = Result<Self::Connection, Self::Error>> {
         self.call(addr)
     }
 }

motore/src/service/ext/map_err.rs

@@ -1,4 +1,6 @@
-use futures::{Future, TryFutureExt};
+use std::future::Future;
+
+use futures::TryFutureExt;
 
 use crate::Service;
 
@@ -20,15 +22,20 @@ where
 
     type Error = E;
 
-    type Future<'cx> = impl Future<Output = Result<Self::Response, Self::Error>> + 'cx
-    where
-        Cx: 'cx,
-        Self: 'cx;
-
-    fn call<'cx, 's>(&'s self, cx: &'cx mut Cx, req: Req) -> Self::Future<'cx>
-    where
-        's: 'cx,
-    {
+    #[cfg(feature = "service_send")]
+    fn call<'s, 'cx>(
+        &'s self,
+        cx: &'cx mut Cx,
+        req: Req,
+    ) -> impl Future<Output = Result<Self::Response, Self::Error>> + Send {
+        self.inner.call(cx, req).map_err(self.f.clone())
+    }
+    #[cfg(not(feature = "service_send"))]
+    fn call<'s, 'cx>(
+        &'s self,
+        cx: &'cx mut Cx,
+        req: Req,
+    ) -> impl Future<Output = Result<Self::Response, Self::Error>> {
         self.inner.call(cx, req).map_err(self.f.clone())
     }
 }

motore/src/service/ext/map_response.rs

@@ -1,6 +1,6 @@
-use std::fmt;
+use std::{fmt, future::Future};
 
-use futures::{Future, TryFutureExt};
+use futures::TryFutureExt;
 
 use crate::Service;
 /// Service returned by the [`map_response`] combinator.
@@ -19,15 +19,21 @@ where
 {
     type Response = Response;
     type Error = S::Error;
-    type Future<'cx> = impl Future<Output = Result<Self::Response, Self::Error>> + 'cx
-    where
-        Cx: 'cx,
-        Self: 'cx;
 
-    fn call<'cx, 's>(&'s self, cx: &'cx mut Cx, req: Req) -> Self::Future<'cx>
-    where
-        's: 'cx,
-    {
+    #[cfg(feature = "service_send")]
+    fn call<'s, 'cx>(
+        &'s self,
+        cx: &'cx mut Cx,
+        req: Req,
+    ) -> impl Future<Output = Result<Self::Response, Self::Error>> + Send {
+        self.inner.call(cx, req).map_ok(self.f.clone())
+    }
+    #[cfg(not(feature = "service_send"))]
+    fn call<'s, 'cx>(
+        &'s self,
+        cx: &'cx mut Cx,
+        req: Req,
+    ) -> impl Future<Output = Result<Self::Response, Self::Error>> {
         self.inner.call(cx, req).map_ok(self.f.clone())
     }
 }