Merge pull request #247 from Fishrock123/client-send-no-boxedfuture

Client, RB: remove BoxFuture from .send()

Author: Fishrock123

src/client.rs

@@ -6,7 +6,6 @@ use crate::middleware::{Middleware, Next};
 use crate::{HttpClient, Request, RequestBuilder, Response, Result};
 
 use cfg_if::cfg_if;
-use futures_util::future::BoxFuture;
 
 cfg_if! {
     if #[cfg(feature = "curl-client")] {
@@ -182,23 +181,22 @@ impl Client {
     /// let res = client.send(req).await?;
     /// # Ok(()) }
     /// ```
-    pub fn send(&self, req: impl Into<Request>) -> BoxFuture<'static, Result<Response>> {
+    pub async fn send(&self, req: impl Into<Request>) -> Result<Response> {
         let req: Request = req.into();
         let http_client = self.http_client.clone();
         let middleware = self.middleware.clone();
-        Box::pin(async move {
-            let next = Next::new(&middleware, &|req, client| {
-                Box::pin(async move {
-                    let req: http_types::Request = req.into();
-                    client.http_client.send(req).await.map(Into::into)
-                })
-            });
-
-            let res = next
-                .run(req, Self::with_http_client_internal(http_client))
-                .await?;
-            Ok(Response::new(res.into()))
-        })
+
+        let next = Next::new(&middleware, &|req, client| {
+            Box::pin(async move {
+                let req: http_types::Request = req.into();
+                client.http_client.send(req).await.map(Into::into)
+            })
+        });
+
+        let res = next
+            .run(req, Self::with_http_client_internal(http_client))
+            .await?;
+        Ok(Response::new(res.into()))
     }
 
     /// Submit a `Request` and get the response body as bytes.

src/request_builder.rs

@@ -258,11 +258,12 @@ impl RequestBuilder {
     }
 
     /// Create a `Client` and send the constructed `Request` from it.
-    pub fn send(mut self) -> BoxFuture<'static, Result<Response>> {
+    pub async fn send(mut self) -> Result<Response> {
         self.client
             .take()
             .unwrap_or_else(Client::new_shared_or_panic)
             .send(self.build())
+            .await
     }
 }
 
@@ -278,12 +279,13 @@ impl Future for RequestBuilder {
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         if self.fut.is_none() {
             let req = self.req.take().unwrap();
-            if let Some(client) = &self.client {
-                self.fut = Some(client.send(req))
-            } else {
-                let client = Client::new_shared_or_panic();
-                self.fut = Some(client.send(req))
-            }
+
+            let client = self
+                .client
+                .take()
+                .unwrap_or_else(Client::new_shared_or_panic);
+
+            self.fut = Some(Box::pin(async move { client.send(req).await }))
         }
 
         // We can safely unwrap here because this is the only time we take ownership of the request.