doc: update volo and motore doc to adapt new version (#837)

Author: PureWhiteWu

content/en/docs/motore/overview/_index.md

@@ -6,15 +6,15 @@ description: >
 
 ---
 
-Motore is an async middleware abstraction powered by GAT and TAIT.
+Motore is an async middleware abstraction powered by AFIT and RPITIT.
 
 Around Motore, we build modular and reusable components for building robust networking clients and servers.
 
 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:
 
@@ -24,20 +24,14 @@ pub trait Service<Cx, Request> {
     type Response;
     /// 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 mut self, cx: &'cx mut Cx, req: Request) -> Self::Future<'cx>
-    where
-        's: 'cx;
+    async fn call<'s, 'cx>(&'s mut 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.
+Using AFIT, we can write asynchronous code in a very concise and readable way.
 
 ```rust
 pub struct Timeout<S> {
@@ -53,19 +47,14 @@ where
 {
     type Response = S::Response;
     type Error = BoxError;
-    type Future<'cx> = impl Future<Output = Result<S::Response, Self::Error>> + 'cx;
-    fn call<'cx, 's>(&'s mut 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 mut 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()),
         }
     }
 }

content/en/docs/volo/overview/_index.md

@@ -10,19 +10,19 @@ description: >
 
 Volo is a **high-performance** and **strong-extensibility** Rust RPC framework that helps developers build microservices.
 
-Volo uses [Motore](https://github.com/cloudwego/motore) as its middleware abstraction, which is powered by GAT.
+Volo uses [Motore](https://github.com/cloudwego/motore) as its middleware abstraction, which is powered by AFIT and RPITIT.
 
 ## Architecture
 
 ![Volo](/img/docs/volo.png)
 
 ## Features
 
-### Powered by GAT
+### Powered by AFIT and RPITIT
 
-Volo uses Motore as its middleware abstraction, which is powered by GAT.
+Volo uses Motore as its middleware abstraction, which is powered by AFIT and RPITIT.
 
-Through GAT, we can avoid many unnecessary Box memory allocations, improve ease of use,
+Through AFIT and RPITIT, we can avoid many unnecessary Box memory allocations, improve ease of use,
 and provide users with a more friendly programming interface and a more ergonomic programming paradigm.
 
 ### High Performance
@@ -55,5 +55,5 @@ We have also created an organization [Volo-rs](http://github.com/volo-rs), any c
 
 1. [Volo-rs](http://github.com/volo-rs)：The volo ecosystem which contains a lot of useful components.
 2. [Pilota](https://github.com/cloudwego/pilota)：A thrift and protobuf implementation in pure rust with high performance and extensibility.
-3. [Motore](https://github.com/cloudwego/motore)：Middleware abstraction layer powered by GAT.
+3. [Motore](https://github.com/cloudwego/motore)：Middleware abstraction layer powered by AFIT and RPITIT.
 4. [Metainfo](https://github.com/cloudwego/metainfo)：Transmissing metainfo across components.

content/en/docs/volo/volo-grpc/getting-started/part_2.md

@@ -104,11 +104,8 @@ At this point, our entire directory structure looks like this:
 Then we open `src/lib.rs` and add the method implementation to the `impl` block. The resulting code should look like this:
 
 ```rust
-#![feature(impl_trait_in_assoc_type)]
-
 pub struct S;
 
-#[volo::async_trait]
 impl volo_gen::volo::example::ItemService for S {
     // This is the part of the code we need to add
     async fn get_item(

content/en/docs/volo/volo-thrift/getting-started/part_2.md

@@ -103,11 +103,8 @@ At this point, our entire directory structure looks like this:
 Then we open `src/lib.rs` and add the method implementation to the `impl` block. The resulting code should look like this:
 
 ```rust
-#![feature(impl_trait_in_assoc_type)]
-
 pub struct S;
 
-#[volo::async_trait]
 impl volo_gen::volo::example::ItemService for S {
     // This is the part of the code we need to add
     async fn get_item(

content/zh/docs/motore/faq/q1_gat.md

@@ -6,13 +6,13 @@ description: >
 
 ---
 
-Motore 是一个使用了 GAT 和 TAIT 特性的中间件抽象层。
+Motore 是一个使用了 AFIT 和 RPITIT 特性的中间件抽象层。
 
 基于 Motore，我们编写了一些模块化并且可复用的，用来编写 client 和 server 的组件。
 
 Motore 深受[`Tower`][Tower] 启发。
 
-Motore 使用 GAT 和 TAIT 来减轻编写异步代码的精神负担，尤其是为了避免 `Box` 的开销而导致的负担，以减少使用者的焦虑。
+Motore 使用 AFIT 和 RPITIT 来减轻编写异步代码的精神负担，尤其是为了避免 `Box` 的开销而导致的负担，以减少使用者的焦虑。
 
 Motore 最核心的抽象是 `Service` trait：
 
@@ -22,20 +22,14 @@ pub trait Service<Cx, Request> {
     type Response;
     /// 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 mut self, cx: &'cx mut Cx, req: Request) -> Self::Future<'cx>
-    where
-        's: 'cx;
+    async fn call<'s, 'cx>(&'s mut self, cx: &'cx mut Cx, req: Request) -> Result<Self::Response, Self::Error>;
 }
 ```
 ## 快速上手
 
-通过将 GAT 和 TAIT 组合在一起，我们可以以非常简洁易读的方式编写异步代码：
+使用 AFIT，我们可以以非常简洁易读的方式编写异步代码：
 
 ```rust
 pub struct Timeout<S> {
@@ -51,19 +45,14 @@ where
 {
     type Response = S::Response;
     type Error = BoxError;
-    type Future<'cx> = impl Future<Output = Result<S::Response, Self::Error>> + 'cx;
-    fn call<'cx, 's>(&'s mut 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 mut 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()),
         }
     }
 }