async_std::sync::channel -> async_channel

Author: akhilles

Cargo.toml

@@ -28,6 +28,7 @@ cookie-secure = ["cookie/secure"]
 # features: async_std
 async-std = { version = "1.6.0", features = ["unstable"] }
 futures-lite = "1.7.0"
+async-channel = "1.4.2"
 
 # features: hyperium/http
 http = { version = "0.2.0", optional = true }

src/request.rs

@@ -1,4 +1,3 @@
-use async_std::sync;
 use futures_lite::*;
 
 use std::convert::{Into, TryInto};
@@ -38,8 +37,8 @@ pin_project_lite::pin_project! {
         local_addr: Option<String>,
         peer_addr: Option<String>,
         ext: Extensions,
-        trailers_sender: Option<sync::Sender<Trailers>>,
-        trailers_receiver: Option<sync::Receiver<Trailers>>,
+        trailers_sender: Option<async_channel::Sender<Trailers>>,
+        trailers_receiver: Option<async_channel::Receiver<Trailers>>,
         has_trailers: bool,
     }
 }
@@ -52,7 +51,7 @@ impl Request {
         U::Error: std::fmt::Debug,
     {
         let url = url.try_into().expect("Could not convert into a valid url");
-        let (trailers_sender, trailers_receiver) = sync::channel(1);
+        let (trailers_sender, trailers_receiver) = async_channel::bounded(1);
         Self {
             method,
             url,

src/response.rs

@@ -1,4 +1,3 @@
-use async_std::sync;
 use futures_lite::*;
 
 use std::convert::{Into, TryInto};
@@ -43,8 +42,8 @@ pin_project_lite::pin_project! {
         headers: Headers,
         version: Option<Version>,
         has_trailers: bool,
-        trailers_sender: Option<sync::Sender<Trailers>>,
-        trailers_receiver: Option<sync::Receiver<Trailers>>,
+        trailers_sender: Option<async_channel::Sender<Trailers>>,
+        trailers_receiver: Option<async_channel::Receiver<Trailers>>,
         #[pin]
         body: Body,
         ext: Extensions,
@@ -74,11 +73,11 @@ pin_project_lite::pin_project! {
         status: StatusCode,
         headers: Headers,
         version: Option<Version>,
-        trailers_sender: Option<sync::Sender<Trailers>>,
-        trailers_receiver: Option<sync::Receiver<Trailers>>,
+        trailers_sender: Option<async_channel::Sender<Trailers>>,
+        trailers_receiver: Option<async_channel::Receiver<Trailers>>,
         has_trailers: bool,
-        upgrade_sender: Option<sync::Sender<upgrade::Connection>>,
-        upgrade_receiver: Option<sync::Receiver<upgrade::Connection>>,
+        upgrade_sender: Option<async_channel::Sender<upgrade::Connection>>,
+        upgrade_receiver: Option<async_channel::Receiver<upgrade::Connection>>,
         has_upgrade: bool,
         #[pin]
         body: Body,
@@ -99,7 +98,7 @@ impl Response {
         let status = status
             .try_into()
             .expect("Could not convert into a valid `StatusCode`");
-        let (trailers_sender, trailers_receiver) = sync::channel(1);
+        let (trailers_sender, trailers_receiver) = async_channel::bounded(1);
         Self {
             status,
             headers: Headers::new(),
@@ -124,8 +123,8 @@ impl Response {
         let status = status
             .try_into()
             .expect("Could not convert into a valid `StatusCode`");
-        let (trailers_sender, trailers_receiver) = sync::channel(1);
-        let (upgrade_sender, upgrade_receiver) = sync::channel(1);
+        let (trailers_sender, trailers_receiver) = async_channel::bounded(1);
+        let (upgrade_sender, upgrade_receiver) = async_channel::bounded(1);
         Self {
             status,
             headers: Headers::new(),

src/trailers.rs

@@ -50,7 +50,6 @@
 use crate::headers::{
     HeaderName, HeaderValues, Headers, Iter, IterMut, Names, ToHeaderValues, Values,
 };
-use async_std::sync;
 use futures_lite::*;
 
 use std::convert::Into;
@@ -207,43 +206,43 @@ impl Index<&str> for Trailers {
 
 /// The sending half of a channel to send trailers.
 ///
-/// Unlike `async_std::sync::channel` the `send` method on this type can only be
+/// Unlike `async_channel::Sender` the `send` method on this type can only be
 /// called once, and cannot be cloned. That's because only a single instance of
 /// `Trailers` should be created.
 #[derive(Debug)]
 pub struct Sender {
-    sender: sync::Sender<Trailers>,
+    sender: async_channel::Sender<Trailers>,
 }
 
 impl Sender {
     /// Create a new instance of `Sender`.
     #[doc(hidden)]
-    pub fn new(sender: sync::Sender<Trailers>) -> Self {
+    pub fn new(sender: async_channel::Sender<Trailers>) -> Self {
         Self { sender }
     }
 
     /// Send a `Trailer`.
     ///
     /// The channel will be consumed after having sent trailers.
     pub async fn send(self, trailers: Trailers) {
-        self.sender.send(trailers).await
+        let _ = self.sender.send(trailers).await;
     }
 }
 
 /// The receiving half of a channel to send trailers.
 ///
-/// Unlike `async_std::sync::channel` the `send` method on this type can only be
+/// Unlike `async_channel::Sender` the `send` method on this type can only be
 /// called once, and cannot be cloned. That's because only a single instance of
 /// `Trailers` should be created.
 #[must_use = "Futures do nothing unless polled or .awaited"]
 #[derive(Debug)]
 pub struct Receiver {
-    receiver: sync::Receiver<Trailers>,
+    receiver: async_channel::Receiver<Trailers>,
 }
 
 impl Receiver {
     /// Create a new instance of `Receiver`.
-    pub(crate) fn new(receiver: sync::Receiver<Trailers>) -> Self {
+    pub(crate) fn new(receiver: async_channel::Receiver<Trailers>) -> Self {
         Self { receiver }
     }
 }

src/upgrade/receiver.rs

@@ -1,4 +1,3 @@
-use async_std::sync;
 use futures_lite::*;
 
 use std::future::Future;
@@ -8,20 +7,16 @@ use std::task::{Context, Poll};
 use crate::upgrade::Connection;
 
 /// The receiving half of a channel to send an upgraded connection.
-///
-/// Unlike `async_std::sync::channel` the `send` method on this type can only be
-/// called once, and cannot be cloned. That's because only a single instance of
-/// `Connection` should be created.
 #[must_use = "Futures do nothing unless polled or .awaited"]
 #[derive(Debug)]
 pub struct Receiver {
-    receiver: sync::Receiver<Connection>,
+    receiver: async_channel::Receiver<Connection>,
 }
 
 impl Receiver {
     /// Create a new instance of `Receiver`.
     #[allow(unused)]
-    pub(crate) fn new(receiver: sync::Receiver<Connection>) -> Self {
+    pub(crate) fn new(receiver: async_channel::Receiver<Connection>) -> Self {
         Self { receiver }
     }
 }

src/upgrade/sender.rs

@@ -1,28 +1,26 @@
-use async_std::sync;
-
 use crate::upgrade::Connection;
 
 /// The sending half of a channel to send an upgraded connection.
 ///
-/// Unlike `async_std::sync::channel` the `send` method on this type can only be
+/// Unlike `async_channel::Sender` the `send` method on this type can only be
 /// called once, and cannot be cloned. That's because only a single instance of
 /// `Connection` should be created.
 #[derive(Debug)]
 pub struct Sender {
-    sender: sync::Sender<Connection>,
+    sender: async_channel::Sender<Connection>,
 }
 
 impl Sender {
     /// Create a new instance of `Sender`.
     #[doc(hidden)]
-    pub fn new(sender: sync::Sender<Connection>) -> Self {
+    pub fn new(sender: async_channel::Sender<Connection>) -> Self {
         Self { sender }
     }
 
     /// Send a `Trailer`.
     ///
     /// The channel will be consumed after having sent trailers.
     pub async fn send(self, trailers: Connection) {
-        self.sender.send(trailers).await
+        let _ = self.sender.send(trailers).await;
     }
 }