From 58f4642eae6aa4f3e0be5f2f26fd72f23761a73b Mon Sep 17 00:00:00 2001
From: Yoshua Wuyts <yoshuawuyts@gmail.com>
Date: Fri, 10 Jan 2020 17:13:09 +0100
Subject: [PATCH 1/4] attempt to fix Send guards on collect

Signed-off-by: Yoshua Wuyts <yoshuawuyts@gmail.com>
---
 src/collections/binary_heap/from_stream.rs |  2 +-
 src/collections/btree_map/from_stream.rs   |  2 +-
 src/collections/btree_set/from_stream.rs   |  2 +-
 src/collections/hash_map/from_stream.rs    |  3 ++-
 src/collections/hash_set/from_stream.rs    |  2 +-
 src/collections/linked_list/from_stream.rs |  2 +-
 src/collections/vec_deque/from_stream.rs   |  2 +-
 src/option/from_stream.rs                  |  2 +-
 src/path/pathbuf.rs                        |  2 +-
 src/result/from_stream.rs                  |  2 ++
 src/stream/from_stream.rs                  |  4 ++--
 src/stream/stream/mod.rs                   |  1 +
 src/vec/from_stream.rs                     | 10 +++++-----
 tests/collect.rs                           | 18 ++++++++++++++++++
 14 files changed, 38 insertions(+), 16 deletions(-)
 create mode 100644 tests/collect.rs

diff --git a/src/collections/binary_heap/from_stream.rs b/src/collections/binary_heap/from_stream.rs
index 6851948e6..80022d28a 100644
--- a/src/collections/binary_heap/from_stream.rs
+++ b/src/collections/binary_heap/from_stream.rs
@@ -4,7 +4,7 @@ use std::pin::Pin;
 use crate::prelude::*;
 use crate::stream::{self, FromStream, IntoStream};
 
-impl<T: Ord> FromStream<T> for BinaryHeap<T> {
+impl<T: Ord + Send> FromStream<T> for BinaryHeap<T> {
     #[inline]
     fn from_stream<'a, S: IntoStream<Item = T> + 'a>(
         stream: S,
diff --git a/src/collections/btree_map/from_stream.rs b/src/collections/btree_map/from_stream.rs
index 853122361..d1b6ca20a 100644
--- a/src/collections/btree_map/from_stream.rs
+++ b/src/collections/btree_map/from_stream.rs
@@ -4,7 +4,7 @@ use std::pin::Pin;
 use crate::prelude::*;
 use crate::stream::{self, FromStream, IntoStream};
 
-impl<K: Ord, V> FromStream<(K, V)> for BTreeMap<K, V> {
+impl<K: Ord + Send, V: Send> FromStream<(K, V)> for BTreeMap<K, V> {
     #[inline]
     fn from_stream<'a, S: IntoStream<Item = (K, V)> + 'a>(
         stream: S,
diff --git a/src/collections/btree_set/from_stream.rs b/src/collections/btree_set/from_stream.rs
index 318af9e65..e943c2731 100644
--- a/src/collections/btree_set/from_stream.rs
+++ b/src/collections/btree_set/from_stream.rs
@@ -4,7 +4,7 @@ use std::pin::Pin;
 use crate::prelude::*;
 use crate::stream::{self, FromStream, IntoStream};
 
-impl<T: Ord> FromStream<T> for BTreeSet<T> {
+impl<T: Ord + Send> FromStream<T> for BTreeSet<T> {
     #[inline]
     fn from_stream<'a, S: IntoStream<Item = T> + 'a>(
         stream: S,
diff --git a/src/collections/hash_map/from_stream.rs b/src/collections/hash_map/from_stream.rs
index d74a7ccfa..40b86f0fe 100644
--- a/src/collections/hash_map/from_stream.rs
+++ b/src/collections/hash_map/from_stream.rs
@@ -7,8 +7,9 @@ use crate::stream::{self, FromStream, IntoStream};
 
 impl<K, V, H> FromStream<(K, V)> for HashMap<K, V, H>
 where
-    K: Eq + Hash,
+    K: Eq + Hash + Send,
     H: BuildHasher + Default,
+    V: Send,
 {
     #[inline]
     fn from_stream<'a, S: IntoStream<Item = (K, V)> + 'a>(
diff --git a/src/collections/hash_set/from_stream.rs b/src/collections/hash_set/from_stream.rs
index dc5e61e39..e0ca39206 100644
--- a/src/collections/hash_set/from_stream.rs
+++ b/src/collections/hash_set/from_stream.rs
@@ -7,7 +7,7 @@ use crate::stream::{self, FromStream, IntoStream};
 
 impl<T, H> FromStream<T> for HashSet<T, H>
 where
-    T: Eq + Hash,
+    T: Eq + Hash + Send,
     H: BuildHasher + Default,
 {
     #[inline]
diff --git a/src/collections/linked_list/from_stream.rs b/src/collections/linked_list/from_stream.rs
index d93bbb7be..972b39d6f 100644
--- a/src/collections/linked_list/from_stream.rs
+++ b/src/collections/linked_list/from_stream.rs
@@ -4,7 +4,7 @@ use std::pin::Pin;
 use crate::prelude::*;
 use crate::stream::{self, FromStream, IntoStream};
 
-impl<T> FromStream<T> for LinkedList<T> {
+impl<T: Send> FromStream<T> for LinkedList<T> {
     #[inline]
     fn from_stream<'a, S: IntoStream<Item = T> + 'a>(
         stream: S,
diff --git a/src/collections/vec_deque/from_stream.rs b/src/collections/vec_deque/from_stream.rs
index 241bd74e9..540665705 100644
--- a/src/collections/vec_deque/from_stream.rs
+++ b/src/collections/vec_deque/from_stream.rs
@@ -4,7 +4,7 @@ use std::pin::Pin;
 use crate::prelude::*;
 use crate::stream::{self, FromStream, IntoStream};
 
-impl<T> FromStream<T> for VecDeque<T> {
+impl<T: Send> FromStream<T> for VecDeque<T> {
     #[inline]
     fn from_stream<'a, S: IntoStream<Item = T> + 'a>(
         stream: S,
diff --git a/src/option/from_stream.rs b/src/option/from_stream.rs
index de929ca94..90be98b7a 100644
--- a/src/option/from_stream.rs
+++ b/src/option/from_stream.rs
@@ -4,7 +4,7 @@ use crate::prelude::*;
 use crate::stream::{FromStream, IntoStream};
 use std::convert::identity;
 
-impl<T, V> FromStream<Option<T>> for Option<V>
+impl<T: Send, V> FromStream<Option<T>> for Option<V>
 where
     V: FromStream<T>,
 {
diff --git a/src/path/pathbuf.rs b/src/path/pathbuf.rs
index e684df89f..1e42693c8 100644
--- a/src/path/pathbuf.rs
+++ b/src/path/pathbuf.rs
@@ -337,7 +337,7 @@ impl<P: AsRef<Path>> stream::Extend<P> for PathBuf {
 }
 
 #[cfg(feature = "unstable")]
-impl<'b, P: AsRef<Path> + 'b> FromStream<P> for PathBuf {
+impl<'b, P: AsRef<Path> + 'b + Send> FromStream<P> for PathBuf {
     #[inline]
     fn from_stream<'a, S: IntoStream<Item = P> + 'a>(
         stream: S,
diff --git a/src/result/from_stream.rs b/src/result/from_stream.rs
index 8a8e0eaf3..50d8bedbd 100644
--- a/src/result/from_stream.rs
+++ b/src/result/from_stream.rs
@@ -5,6 +5,8 @@ use crate::stream::{FromStream, IntoStream};
 
 impl<T, E, V> FromStream<Result<T, E>> for Result<V, E>
 where
+    T: Send,
+    E: Send,
     V: FromStream<T>,
 {
     /// Takes each element in the stream: if it is an `Err`, no further
diff --git a/src/stream/from_stream.rs b/src/stream/from_stream.rs
index 12d89e813..9507309e6 100644
--- a/src/stream/from_stream.rs
+++ b/src/stream/from_stream.rs
@@ -107,12 +107,12 @@ use crate::stream::IntoStream;
 /// assert_eq!(c.0, vec![5, 5, 5, 5, 5]);
 /// #
 /// # Ok(()) }) }
-///```
+/// ```
 ///
 /// [`IntoStream`]: trait.IntoStream.html
 #[cfg(feature = "unstable")]
 #[cfg_attr(feature = "docs", doc(cfg(unstable)))]
-pub trait FromStream<T> {
+pub trait FromStream<T: Send> {
     /// Creates a value from a stream.
     ///
     /// # Examples
diff --git a/src/stream/stream/mod.rs b/src/stream/stream/mod.rs
index 4be0eb5f9..42afe9e45 100644
--- a/src/stream/stream/mod.rs
+++ b/src/stream/stream/mod.rs
@@ -1892,6 +1892,7 @@ extension_trait! {
         where
             Self: Sized + 'a,
             B: FromStream<Self::Item>,
+            Self::Item: Send,
         {
             FromStream::from_stream(self)
         }
diff --git a/src/vec/from_stream.rs b/src/vec/from_stream.rs
index e88e8202e..2b1c31e03 100644
--- a/src/vec/from_stream.rs
+++ b/src/vec/from_stream.rs
@@ -6,7 +6,7 @@ use std::sync::Arc;
 use crate::prelude::*;
 use crate::stream::{self, FromStream, IntoStream};
 
-impl<T> FromStream<T> for Vec<T> {
+impl<T: Send> FromStream<T> for Vec<T> {
     #[inline]
     fn from_stream<'a, S: IntoStream<Item = T>>(
         stream: S,
@@ -24,7 +24,7 @@ impl<T> FromStream<T> for Vec<T> {
     }
 }
 
-impl<'b, T: Clone> FromStream<T> for Cow<'b, [T]> {
+impl<'b, T: Clone + Send> FromStream<T> for Cow<'b, [T]> {
     #[inline]
     fn from_stream<'a, S: IntoStream<Item = T> + 'a>(
         stream: S,
@@ -37,7 +37,7 @@ impl<'b, T: Clone> FromStream<T> for Cow<'b, [T]> {
     }
 }
 
-impl<T> FromStream<T> for Box<[T]> {
+impl<T: Send> FromStream<T> for Box<[T]> {
     #[inline]
     fn from_stream<'a, S: IntoStream<Item = T> + 'a>(
         stream: S,
@@ -50,7 +50,7 @@ impl<T> FromStream<T> for Box<[T]> {
     }
 }
 
-impl<T> FromStream<T> for Rc<[T]> {
+impl<T: Send> FromStream<T> for Rc<[T]> {
     #[inline]
     fn from_stream<'a, S: IntoStream<Item = T> + 'a>(
         stream: S,
@@ -63,7 +63,7 @@ impl<T> FromStream<T> for Rc<[T]> {
     }
 }
 
-impl<T> FromStream<T> for Arc<[T]> {
+impl<T: Send> FromStream<T> for Arc<[T]> {
     #[inline]
     fn from_stream<'a, S: IntoStream<Item = T> + 'a>(
         stream: S,
diff --git a/tests/collect.rs b/tests/collect.rs
new file mode 100644
index 000000000..82d2f8083
--- /dev/null
+++ b/tests/collect.rs
@@ -0,0 +1,18 @@
+use async_std::prelude::*;
+use async_std::io;
+use async_std::task;
+
+#[test]
+fn test_send() -> io::Result<()> {
+    task::block_on(async {
+        fn test_send_trait<T: Send>(_: &T) {}
+
+        let stream = futures::stream::pending::<()>();
+        test_send_trait(&stream);
+
+        let fut = stream.collect::<Vec<_>>();
+
+        // This line triggers a compilation error
+        test_send_trait(&fut);
+    })
+}

From c6836ec4750a1679d4d5c23f8ae178fc5ca2e78e Mon Sep 17 00:00:00 2001
From: dignifiedquire <me@dignifiedquire.com>
Date: Sat, 27 Jun 2020 14:45:59 +0200
Subject: [PATCH 2/4] fixup test

---
 tests/collect.rs | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/tests/collect.rs b/tests/collect.rs
index 82d2f8083..d24484f4e 100644
--- a/tests/collect.rs
+++ b/tests/collect.rs
@@ -1,18 +1,20 @@
-use async_std::prelude::*;
-use async_std::io;
-use async_std::task;
-
+#[cfg(feature = "unstable")]
 #[test]
-fn test_send() -> io::Result<()> {
+fn test_send() -> async_std::io::Result<()> {
+    use async_std::prelude::*;
+    use async_std::{stream, task};
+
     task::block_on(async {
         fn test_send_trait<T: Send>(_: &T) {}
 
-        let stream = futures::stream::pending::<()>();
+        let stream = stream::repeat(1u8).take(10);
         test_send_trait(&stream);
 
         let fut = stream.collect::<Vec<_>>();
 
         // This line triggers a compilation error
         test_send_trait(&fut);
+
+        Ok(())
     })
 }

From 9cb2a764d90bbb1d99ac2d16402c3d3ddc89d25a Mon Sep 17 00:00:00 2001
From: dignifiedquire <me@dignifiedquire.com>
Date: Sat, 27 Jun 2020 16:11:12 +0200
Subject: [PATCH 3/4] first compiling version

---
 src/collections/binary_heap/extend.rs      |  9 ++++--
 src/collections/binary_heap/from_stream.rs |  5 +++-
 src/collections/btree_map/extend.rs        |  9 ++++--
 src/collections/btree_map/from_stream.rs   |  5 +++-
 src/collections/btree_set/extend.rs        |  9 ++++--
 src/collections/btree_set/from_stream.rs   |  5 +++-
 src/collections/hash_map/extend.rs         | 12 +++++---
 src/collections/hash_map/from_stream.rs    |  7 +++--
 src/collections/hash_set/extend.rs         | 11 ++++---
 src/collections/hash_set/from_stream.rs    |  7 +++--
 src/collections/linked_list/extend.rs      |  9 ++++--
 src/collections/linked_list/from_stream.rs |  5 +++-
 src/collections/vec_deque/extend.rs        |  9 ++++--
 src/collections/vec_deque/from_stream.rs   |  5 +++-
 src/option/from_stream.rs                  |  5 +++-
 src/path/pathbuf.rs                        | 12 ++++++--
 src/result/from_stream.rs                  |  5 +++-
 src/stream/extend.rs                       |  9 ++++--
 src/stream/from_stream.rs                  |  9 ++++--
 src/stream/stream/mod.rs                   |  4 +--
 src/string/extend.rs                       | 35 +++++++++++++++-------
 src/string/from_stream.rs                  | 25 ++++++++++++----
 src/unit/extend.rs                         |  9 ++++--
 src/unit/from_stream.rs                    |  5 +++-
 src/vec/extend.rs                          |  9 ++++--
 src/vec/from_stream.rs                     | 24 +++++++++++----
 26 files changed, 186 insertions(+), 72 deletions(-)

diff --git a/src/collections/binary_heap/extend.rs b/src/collections/binary_heap/extend.rs
index 439bf139e..64fe88c2a 100644
--- a/src/collections/binary_heap/extend.rs
+++ b/src/collections/binary_heap/extend.rs
@@ -4,11 +4,14 @@ use std::pin::Pin;
 use crate::prelude::*;
 use crate::stream::{self, IntoStream};
 
-impl<T: Ord> stream::Extend<T> for BinaryHeap<T> {
-    fn extend<'a, S: IntoStream<Item = T> + 'a>(
+impl<T: Ord + Send> stream::Extend<T> for BinaryHeap<T> {
+    fn extend<'a, S: IntoStream<Item = T> + 'a + Send>(
         &'a mut self,
         stream: S,
-    ) -> Pin<Box<dyn Future<Output = ()> + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = ()> + 'a + Send>>
+    where
+        <S as IntoStream>::IntoStream: Send,
+    {
         let stream = stream.into_stream();
 
         self.reserve(stream.size_hint().0);
diff --git a/src/collections/binary_heap/from_stream.rs b/src/collections/binary_heap/from_stream.rs
index 80022d28a..614f5f5de 100644
--- a/src/collections/binary_heap/from_stream.rs
+++ b/src/collections/binary_heap/from_stream.rs
@@ -8,7 +8,10 @@ impl<T: Ord + Send> FromStream<T> for BinaryHeap<T> {
     #[inline]
     fn from_stream<'a, S: IntoStream<Item = T> + 'a>(
         stream: S,
-    ) -> Pin<Box<dyn Future<Output = Self> + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = Self> + 'a + Send>>
+    where
+        <S as IntoStream>::IntoStream: Send,
+    {
         let stream = stream.into_stream();
 
         Box::pin(async move {
diff --git a/src/collections/btree_map/extend.rs b/src/collections/btree_map/extend.rs
index 19d306ffe..69189f7a3 100644
--- a/src/collections/btree_map/extend.rs
+++ b/src/collections/btree_map/extend.rs
@@ -4,11 +4,14 @@ use std::pin::Pin;
 use crate::prelude::*;
 use crate::stream::{self, IntoStream};
 
-impl<K: Ord, V> stream::Extend<(K, V)> for BTreeMap<K, V> {
-    fn extend<'a, S: IntoStream<Item = (K, V)> + 'a>(
+impl<K: Ord + Send, V: Send> stream::Extend<(K, V)> for BTreeMap<K, V> {
+    fn extend<'a, S: IntoStream<Item = (K, V)> + 'a + Send>(
         &'a mut self,
         stream: S,
-    ) -> Pin<Box<dyn Future<Output = ()> + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = ()> + 'a + Send>>
+    where
+        <S as IntoStream>::IntoStream: Send,
+    {
         Box::pin(stream.into_stream().for_each(move |(k, v)| {
             self.insert(k, v);
         }))
diff --git a/src/collections/btree_map/from_stream.rs b/src/collections/btree_map/from_stream.rs
index d1b6ca20a..ef01b6e0d 100644
--- a/src/collections/btree_map/from_stream.rs
+++ b/src/collections/btree_map/from_stream.rs
@@ -8,7 +8,10 @@ impl<K: Ord + Send, V: Send> FromStream<(K, V)> for BTreeMap<K, V> {
     #[inline]
     fn from_stream<'a, S: IntoStream<Item = (K, V)> + 'a>(
         stream: S,
-    ) -> Pin<Box<dyn Future<Output = Self> + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = Self> + 'a + Send>> 
+    where
+        <S as IntoStream>::IntoStream: Send,
+    {
         let stream = stream.into_stream();
 
         Box::pin(async move {
diff --git a/src/collections/btree_set/extend.rs b/src/collections/btree_set/extend.rs
index 422640b15..4222ae7d7 100644
--- a/src/collections/btree_set/extend.rs
+++ b/src/collections/btree_set/extend.rs
@@ -4,11 +4,14 @@ use std::pin::Pin;
 use crate::prelude::*;
 use crate::stream::{self, IntoStream};
 
-impl<T: Ord> stream::Extend<T> for BTreeSet<T> {
-    fn extend<'a, S: IntoStream<Item = T> + 'a>(
+impl<T: Ord + Send> stream::Extend<T> for BTreeSet<T> {
+    fn extend<'a, S: IntoStream<Item = T> + 'a + Send>(
         &'a mut self,
         stream: S,
-    ) -> Pin<Box<dyn Future<Output = ()> + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = ()> + 'a + Send>>
+    where
+        <S as IntoStream>::IntoStream: Send,
+    {
         Box::pin(stream.into_stream().for_each(move |item| {
             self.insert(item);
         }))
diff --git a/src/collections/btree_set/from_stream.rs b/src/collections/btree_set/from_stream.rs
index e943c2731..5fdb33e6c 100644
--- a/src/collections/btree_set/from_stream.rs
+++ b/src/collections/btree_set/from_stream.rs
@@ -8,7 +8,10 @@ impl<T: Ord + Send> FromStream<T> for BTreeSet<T> {
     #[inline]
     fn from_stream<'a, S: IntoStream<Item = T> + 'a>(
         stream: S,
-    ) -> Pin<Box<dyn Future<Output = Self> + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = Self> + 'a + Send>> 
+    where
+        <S as IntoStream>::IntoStream: Send,
+    {
         let stream = stream.into_stream();
 
         Box::pin(async move {
diff --git a/src/collections/hash_map/extend.rs b/src/collections/hash_map/extend.rs
index 0f4ce0c6e..b0b2e494b 100644
--- a/src/collections/hash_map/extend.rs
+++ b/src/collections/hash_map/extend.rs
@@ -7,13 +7,17 @@ use crate::stream::{self, IntoStream};
 
 impl<K, V, H> stream::Extend<(K, V)> for HashMap<K, V, H>
 where
-    K: Eq + Hash,
-    H: BuildHasher + Default,
+    K: Eq + Hash + Send,
+    V: Send,
+    H: BuildHasher + Default + Send,
 {
-    fn extend<'a, S: IntoStream<Item = (K, V)> + 'a>(
+    fn extend<'a, S: IntoStream<Item = (K, V)> + 'a + Send>(
         &'a mut self,
         stream: S,
-    ) -> Pin<Box<dyn Future<Output = ()> + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = ()> + 'a + Send>>
+    where
+        <S as IntoStream>::IntoStream: Send,
+    {
         let stream = stream.into_stream();
 
         // The following is adapted from the hashbrown source code:
diff --git a/src/collections/hash_map/from_stream.rs b/src/collections/hash_map/from_stream.rs
index 40b86f0fe..ae3f11a56 100644
--- a/src/collections/hash_map/from_stream.rs
+++ b/src/collections/hash_map/from_stream.rs
@@ -8,13 +8,16 @@ use crate::stream::{self, FromStream, IntoStream};
 impl<K, V, H> FromStream<(K, V)> for HashMap<K, V, H>
 where
     K: Eq + Hash + Send,
-    H: BuildHasher + Default,
+    H: BuildHasher + Default + Send,
     V: Send,
 {
     #[inline]
     fn from_stream<'a, S: IntoStream<Item = (K, V)> + 'a>(
         stream: S,
-    ) -> Pin<Box<dyn Future<Output = Self> + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = Self> + 'a + Send>> 
+    where
+        <S as IntoStream>::IntoStream: Send,
+    {
         let stream = stream.into_stream();
 
         Box::pin(async move {
diff --git a/src/collections/hash_set/extend.rs b/src/collections/hash_set/extend.rs
index ba872b438..15429d358 100644
--- a/src/collections/hash_set/extend.rs
+++ b/src/collections/hash_set/extend.rs
@@ -7,13 +7,16 @@ use crate::stream::{self, IntoStream};
 
 impl<T, H> stream::Extend<T> for HashSet<T, H>
 where
-    T: Eq + Hash,
-    H: BuildHasher + Default,
+    T: Eq + Hash + Send,
+    H: BuildHasher + Default + Send,
 {
-    fn extend<'a, S: IntoStream<Item = T> + 'a>(
+    fn extend<'a, S: IntoStream<Item = T> + 'a + Send>(
         &'a mut self,
         stream: S,
-    ) -> Pin<Box<dyn Future<Output = ()> + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = ()> + 'a + Send>>
+    where
+        <S as IntoStream>::IntoStream: Send,
+    {
         // The Extend impl for HashSet in the standard library delegates to the internal HashMap.
         // Thus, this impl is just a copy of the async Extend impl for HashMap in this crate.
 
diff --git a/src/collections/hash_set/from_stream.rs b/src/collections/hash_set/from_stream.rs
index e0ca39206..6f640695a 100644
--- a/src/collections/hash_set/from_stream.rs
+++ b/src/collections/hash_set/from_stream.rs
@@ -8,12 +8,15 @@ use crate::stream::{self, FromStream, IntoStream};
 impl<T, H> FromStream<T> for HashSet<T, H>
 where
     T: Eq + Hash + Send,
-    H: BuildHasher + Default,
+    H: BuildHasher + Default + Send,
 {
     #[inline]
     fn from_stream<'a, S: IntoStream<Item = T> + 'a>(
         stream: S,
-    ) -> Pin<Box<dyn Future<Output = Self> + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = Self> + 'a + Send>> 
+    where
+        <S as IntoStream>::IntoStream: Send,
+    {
         let stream = stream.into_stream();
 
         Box::pin(async move {
diff --git a/src/collections/linked_list/extend.rs b/src/collections/linked_list/extend.rs
index b0dff009d..39dffbe46 100644
--- a/src/collections/linked_list/extend.rs
+++ b/src/collections/linked_list/extend.rs
@@ -4,11 +4,14 @@ use std::pin::Pin;
 use crate::prelude::*;
 use crate::stream::{self, IntoStream};
 
-impl<T> stream::Extend<T> for LinkedList<T> {
-    fn extend<'a, S: IntoStream<Item = T> + 'a>(
+impl<T: Send> stream::Extend<T> for LinkedList<T> {
+    fn extend<'a, S: IntoStream<Item = T> + 'a + Send>(
         &'a mut self,
         stream: S,
-    ) -> Pin<Box<dyn Future<Output = ()> + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = ()> + 'a + Send>>
+    where
+        <S as IntoStream>::IntoStream: Send,
+    {
         let stream = stream.into_stream();
         Box::pin(stream.for_each(move |item| self.push_back(item)))
     }
diff --git a/src/collections/linked_list/from_stream.rs b/src/collections/linked_list/from_stream.rs
index 972b39d6f..7c3eb738c 100644
--- a/src/collections/linked_list/from_stream.rs
+++ b/src/collections/linked_list/from_stream.rs
@@ -8,7 +8,10 @@ impl<T: Send> FromStream<T> for LinkedList<T> {
     #[inline]
     fn from_stream<'a, S: IntoStream<Item = T> + 'a>(
         stream: S,
-    ) -> Pin<Box<dyn Future<Output = Self> + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = Self> + 'a + Send>> 
+    where
+        <S as IntoStream>::IntoStream: Send,
+    {
         let stream = stream.into_stream();
 
         Box::pin(async move {
diff --git a/src/collections/vec_deque/extend.rs b/src/collections/vec_deque/extend.rs
index dd2ddce3c..a642313be 100644
--- a/src/collections/vec_deque/extend.rs
+++ b/src/collections/vec_deque/extend.rs
@@ -4,11 +4,14 @@ use std::pin::Pin;
 use crate::prelude::*;
 use crate::stream::{self, IntoStream};
 
-impl<T> stream::Extend<T> for VecDeque<T> {
-    fn extend<'a, S: IntoStream<Item = T> + 'a>(
+impl<T: Send> stream::Extend<T> for VecDeque<T> {
+    fn extend<'a, S: IntoStream<Item = T> + 'a + Send>(
         &'a mut self,
         stream: S,
-    ) -> Pin<Box<dyn Future<Output = ()> + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = ()> + 'a + Send>>
+    where
+        <S as IntoStream>::IntoStream: Send,
+    {
         let stream = stream.into_stream();
 
         self.reserve(stream.size_hint().0);
diff --git a/src/collections/vec_deque/from_stream.rs b/src/collections/vec_deque/from_stream.rs
index 540665705..3e0719ab2 100644
--- a/src/collections/vec_deque/from_stream.rs
+++ b/src/collections/vec_deque/from_stream.rs
@@ -8,7 +8,10 @@ impl<T: Send> FromStream<T> for VecDeque<T> {
     #[inline]
     fn from_stream<'a, S: IntoStream<Item = T> + 'a>(
         stream: S,
-    ) -> Pin<Box<dyn Future<Output = Self> + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = Self> + 'a + Send>> 
+    where
+        <S as IntoStream>::IntoStream: Send,
+    {
         let stream = stream.into_stream();
 
         Box::pin(async move {
diff --git a/src/option/from_stream.rs b/src/option/from_stream.rs
index 90be98b7a..7931d97a6 100644
--- a/src/option/from_stream.rs
+++ b/src/option/from_stream.rs
@@ -14,7 +14,10 @@ where
     #[inline]
     fn from_stream<'a, S: IntoStream<Item = Option<T>> + 'a>(
         stream: S,
-    ) -> Pin<Box<dyn Future<Output = Self> + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = Self> + 'a + Send>> 
+    where
+        <S as IntoStream>::IntoStream: Send,
+    {
         let stream = stream.into_stream();
 
         Box::pin(async move {
diff --git a/src/path/pathbuf.rs b/src/path/pathbuf.rs
index 1e42693c8..b673f1741 100644
--- a/src/path/pathbuf.rs
+++ b/src/path/pathbuf.rs
@@ -320,10 +320,13 @@ impl AsRef<OsStr> for PathBuf {
 
 #[cfg(feature = "unstable")]
 impl<P: AsRef<Path>> stream::Extend<P> for PathBuf {
-    fn extend<'a, S: IntoStream<Item = P> + 'a>(
+    fn extend<'a, S: IntoStream<Item = P> + 'a + Send>(
         &'a mut self,
         stream: S,
-    ) -> Pin<Box<dyn Future<Output = ()> + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = ()> + 'a + Send>>
+    where
+        <S as IntoStream>::IntoStream: Send,
+    {
         let stream = stream.into_stream();
 
         Box::pin(async move {
@@ -341,7 +344,10 @@ impl<'b, P: AsRef<Path> + 'b + Send> FromStream<P> for PathBuf {
     #[inline]
     fn from_stream<'a, S: IntoStream<Item = P> + 'a>(
         stream: S,
-    ) -> Pin<Box<dyn Future<Output = Self> + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = Self> + 'a + Send>>
+    where
+        <S as IntoStream>::IntoStream: Send,
+    {
         let stream = stream.into_stream();
 
         Box::pin(async move {
diff --git a/src/result/from_stream.rs b/src/result/from_stream.rs
index 50d8bedbd..68fa535fa 100644
--- a/src/result/from_stream.rs
+++ b/src/result/from_stream.rs
@@ -32,7 +32,10 @@ where
     #[inline]
     fn from_stream<'a, S: IntoStream<Item = Result<T, E>> + 'a>(
         stream: S,
-    ) -> Pin<Box<dyn Future<Output = Self> + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = Self> + 'a + Send>> 
+    where
+        <S as IntoStream>::IntoStream: Send,
+    {
         let stream = stream.into_stream();
 
         Box::pin(async move {
diff --git a/src/stream/extend.rs b/src/stream/extend.rs
index 702cbcac6..5f58dfe11 100644
--- a/src/stream/extend.rs
+++ b/src/stream/extend.rs
@@ -31,10 +31,12 @@ use crate::stream::IntoStream;
 #[cfg_attr(feature = "docs", doc(cfg(unstable)))]
 pub trait Extend<A> {
     /// Extends a collection with the contents of a stream.
-    fn extend<'a, T: IntoStream<Item = A> + 'a>(
+    fn extend<'a, T: IntoStream<Item = A> + 'a + Send>(
         &'a mut self,
         stream: T,
-    ) -> Pin<Box<dyn Future<Output = ()> + 'a>>;
+    ) -> Pin<Box<dyn Future<Output = ()> + 'a + Send>>
+    where
+        <T as IntoStream>::IntoStream: Send;
 }
 
 /// Extends a collection with the contents of a stream.
@@ -68,7 +70,8 @@ pub trait Extend<A> {
 pub async fn extend<'a, C, T, S>(collection: &mut C, stream: S)
 where
     C: Extend<T>,
-    S: IntoStream<Item = T> + 'a,
+    S: IntoStream<Item = T> + 'a + Send,
+    <S as IntoStream>::IntoStream: Send,
 {
     Extend::extend(collection, stream).await
 }
diff --git a/src/stream/from_stream.rs b/src/stream/from_stream.rs
index 9507309e6..c4001917c 100644
--- a/src/stream/from_stream.rs
+++ b/src/stream/from_stream.rs
@@ -72,7 +72,10 @@ use crate::stream::IntoStream;
 /// impl FromStream<i32> for MyCollection {
 ///     fn from_stream<'a, S: IntoStream<Item = i32> + 'a>(
 ///         stream: S,
-///     ) -> Pin<Box<dyn Future<Output = Self> + 'a>> {
+///     ) -> Pin<Box<dyn Future<Output = Self> + 'a + Send>>
+///    where
+///        <S as IntoStream>::IntoStream: Send,
+///    {
 ///         let stream = stream.into_stream();
 ///
 ///         Box::pin(async move {
@@ -135,5 +138,7 @@ pub trait FromStream<T: Send> {
     /// ```
     fn from_stream<'a, S: IntoStream<Item = T> + 'a>(
         stream: S,
-    ) -> Pin<Box<dyn Future<Output = Self> + 'a>>;
+    ) -> Pin<Box<dyn Future<Output = Self> + 'a + Send>>
+    where
+        <S as IntoStream>::IntoStream: Send;
 }
diff --git a/src/stream/stream/mod.rs b/src/stream/stream/mod.rs
index 42afe9e45..4e074a2f3 100644
--- a/src/stream/stream/mod.rs
+++ b/src/stream/stream/mod.rs
@@ -1888,9 +1888,9 @@ extension_trait! {
         #[cfg_attr(feature = "docs", doc(cfg(unstable)))]
         fn collect<'a, B>(
             self,
-        ) -> impl Future<Output = B> + 'a [Pin<Box<dyn Future<Output = B> + 'a>>]
+        ) -> impl Future<Output = B> + 'a [Pin<Box<dyn Future<Output = B> + 'a + Send>>]
         where
-            Self: Sized + 'a,
+            Self: Sized + 'a + Send,
             B: FromStream<Self::Item>,
             Self::Item: Send,
         {
diff --git a/src/string/extend.rs b/src/string/extend.rs
index 55bec0c55..6b06c9352 100644
--- a/src/string/extend.rs
+++ b/src/string/extend.rs
@@ -5,10 +5,13 @@ use crate::prelude::*;
 use crate::stream::{self, IntoStream};
 
 impl stream::Extend<char> for String {
-    fn extend<'a, S: IntoStream<Item = char> + 'a>(
+    fn extend<'a, S: IntoStream<Item = char> + 'a + Send>(
         &'a mut self,
         stream: S,
-    ) -> Pin<Box<dyn Future<Output = ()> + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = ()> + 'a + Send>> 
+    where
+        <S as IntoStream>::IntoStream: Send,
+    {
         let stream = stream.into_stream();
         self.reserve(stream.size_hint().0);
 
@@ -23,10 +26,13 @@ impl stream::Extend<char> for String {
 }
 
 impl<'b> stream::Extend<&'b char> for String {
-    fn extend<'a, S: IntoStream<Item = &'b char> + 'a>(
+    fn extend<'a, S: IntoStream<Item = &'b char> + 'a + Send>(
         &'a mut self,
         stream: S,
-    ) -> Pin<Box<dyn Future<Output = ()> + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = ()> + 'a + Send>> 
+    where
+        <S as IntoStream>::IntoStream: Send,
+    {
         let stream = stream.into_stream();
 
         Box::pin(async move {
@@ -40,10 +46,13 @@ impl<'b> stream::Extend<&'b char> for String {
 }
 
 impl<'b> stream::Extend<&'b str> for String {
-    fn extend<'a, S: IntoStream<Item = &'b str> + 'a>(
+    fn extend<'a, S: IntoStream<Item = &'b str> + 'a + Send>(
         &'a mut self,
         stream: S,
-    ) -> Pin<Box<dyn Future<Output = ()> + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = ()> + 'a + Send>> 
+    where
+        <S as IntoStream>::IntoStream: Send,
+    {
         let stream = stream.into_stream();
 
         Box::pin(async move {
@@ -57,10 +66,13 @@ impl<'b> stream::Extend<&'b str> for String {
 }
 
 impl stream::Extend<String> for String {
-    fn extend<'a, S: IntoStream<Item = String> + 'a>(
+    fn extend<'a, S: IntoStream<Item = String> + 'a + Send>(
         &'a mut self,
         stream: S,
-    ) -> Pin<Box<dyn Future<Output = ()> + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = ()> + 'a + Send>>
+    where
+        <S as IntoStream>::IntoStream: Send,
+    {
         let stream = stream.into_stream();
 
         Box::pin(async move {
@@ -74,10 +86,13 @@ impl stream::Extend<String> for String {
 }
 
 impl<'b> stream::Extend<Cow<'b, str>> for String {
-    fn extend<'a, S: IntoStream<Item = Cow<'b, str>> + 'a>(
+    fn extend<'a, S: IntoStream<Item = Cow<'b, str>> + 'a + Send>(
         &'a mut self,
         stream: S,
-    ) -> Pin<Box<dyn Future<Output = ()> + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = ()> + 'a + Send>>
+    where
+        <S as IntoStream>::IntoStream: Send,
+    {
         let stream = stream.into_stream();
 
         Box::pin(async move {
diff --git a/src/string/from_stream.rs b/src/string/from_stream.rs
index 375ac3715..d9e824681 100644
--- a/src/string/from_stream.rs
+++ b/src/string/from_stream.rs
@@ -8,7 +8,10 @@ impl FromStream<char> for String {
     #[inline]
     fn from_stream<'a, S: IntoStream<Item = char> + 'a>(
         stream: S,
-    ) -> Pin<Box<dyn Future<Output = Self> + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = Self> + 'a + Send>> 
+    where
+        <S as IntoStream>::IntoStream: Send,
+    {
         let stream = stream.into_stream();
 
         Box::pin(async move {
@@ -23,7 +26,10 @@ impl<'b> FromStream<&'b char> for String {
     #[inline]
     fn from_stream<'a, S: IntoStream<Item = &'b char> + 'a>(
         stream: S,
-    ) -> Pin<Box<dyn Future<Output = Self> + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = Self> + 'a + Send>> 
+    where
+        <S as IntoStream>::IntoStream: Send,
+    {
         let stream = stream.into_stream();
 
         Box::pin(async move {
@@ -38,7 +44,10 @@ impl<'b> FromStream<&'b str> for String {
     #[inline]
     fn from_stream<'a, S: IntoStream<Item = &'b str> + 'a>(
         stream: S,
-    ) -> Pin<Box<dyn Future<Output = Self> + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = Self> + 'a + Send>> 
+    where
+        <S as IntoStream>::IntoStream: Send,
+    {
         let stream = stream.into_stream();
 
         Box::pin(async move {
@@ -53,7 +62,10 @@ impl FromStream<String> for String {
     #[inline]
     fn from_stream<'a, S: IntoStream<Item = String> + 'a>(
         stream: S,
-    ) -> Pin<Box<dyn Future<Output = Self> + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = Self> + 'a + Send>> 
+    where
+        <S as IntoStream>::IntoStream: Send,
+    {
         let stream = stream.into_stream();
 
         Box::pin(async move {
@@ -68,7 +80,10 @@ impl<'b> FromStream<Cow<'b, str>> for String {
     #[inline]
     fn from_stream<'a, S: IntoStream<Item = Cow<'b, str>> + 'a>(
         stream: S,
-    ) -> Pin<Box<dyn Future<Output = Self> + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = Self> + 'a + Send>> 
+    where
+        <S as IntoStream>::IntoStream: Send,
+    {
         let stream = stream.into_stream();
 
         Box::pin(async move {
diff --git a/src/unit/extend.rs b/src/unit/extend.rs
index 55c8e0d08..8f42eb5b7 100644
--- a/src/unit/extend.rs
+++ b/src/unit/extend.rs
@@ -4,10 +4,13 @@ use crate::prelude::*;
 use crate::stream::{self, IntoStream};
 
 impl stream::Extend<()> for () {
-    fn extend<'a, T: IntoStream<Item = ()> + 'a>(
+    fn extend<'a, S: IntoStream<Item = ()> + 'a + Send>(
         &'a mut self,
-        stream: T,
-    ) -> Pin<Box<dyn Future<Output = ()> + 'a>> {
+        stream: S,
+    ) -> Pin<Box<dyn Future<Output = ()> + 'a + Send>> 
+    where
+        <S as IntoStream>::IntoStream: Send,
+    {
         let stream = stream.into_stream();
 
         Box::pin(async move {
diff --git a/src/unit/from_stream.rs b/src/unit/from_stream.rs
index 7b784383d..e88758323 100644
--- a/src/unit/from_stream.rs
+++ b/src/unit/from_stream.rs
@@ -7,7 +7,10 @@ impl FromStream<()> for () {
     #[inline]
     fn from_stream<'a, S: IntoStream<Item = ()> + 'a>(
         stream: S,
-    ) -> Pin<Box<dyn Future<Output = Self> + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = Self> + 'a + Send>>
+    where
+        <S as IntoStream>::IntoStream: Send,
+    {
         Box::pin(stream.into_stream().for_each(drop))
     }
 }
diff --git a/src/vec/extend.rs b/src/vec/extend.rs
index 302fc7a87..8ec00ef86 100644
--- a/src/vec/extend.rs
+++ b/src/vec/extend.rs
@@ -3,11 +3,14 @@ use std::pin::Pin;
 use crate::prelude::*;
 use crate::stream::{self, IntoStream};
 
-impl<T> stream::Extend<T> for Vec<T> {
-    fn extend<'a, S: IntoStream<Item = T> + 'a>(
+impl<T: Send> stream::Extend<T> for Vec<T> {
+    fn extend<'a, S: IntoStream<Item = T> + 'a + Send>(
         &'a mut self,
         stream: S,
-    ) -> Pin<Box<dyn Future<Output = ()> + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = ()> + 'a + Send>>
+    where
+        <S as IntoStream>::IntoStream: Send,
+    {
         let stream = stream.into_stream();
 
         self.reserve(stream.size_hint().0);
diff --git a/src/vec/from_stream.rs b/src/vec/from_stream.rs
index 2b1c31e03..95a1f98c9 100644
--- a/src/vec/from_stream.rs
+++ b/src/vec/from_stream.rs
@@ -10,9 +10,9 @@ impl<T: Send> FromStream<T> for Vec<T> {
     #[inline]
     fn from_stream<'a, S: IntoStream<Item = T>>(
         stream: S,
-    ) -> Pin<Box<dyn Future<Output = Self> + 'a>>
+    ) -> Pin<Box<dyn Future<Output = Self> + 'a + Send>>
     where
-        <S as IntoStream>::IntoStream: 'a,
+        <S as IntoStream>::IntoStream: 'a + Send,
     {
         let stream = stream.into_stream();
 
@@ -28,7 +28,10 @@ impl<'b, T: Clone + Send> FromStream<T> for Cow<'b, [T]> {
     #[inline]
     fn from_stream<'a, S: IntoStream<Item = T> + 'a>(
         stream: S,
-    ) -> Pin<Box<dyn Future<Output = Self> + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = Self> + 'a + Send>> 
+    where
+        <S as IntoStream>::IntoStream: Send
+    {
         let stream = stream.into_stream();
 
         Box::pin(async move {
@@ -41,7 +44,10 @@ impl<T: Send> FromStream<T> for Box<[T]> {
     #[inline]
     fn from_stream<'a, S: IntoStream<Item = T> + 'a>(
         stream: S,
-    ) -> Pin<Box<dyn Future<Output = Self> + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = Self> + 'a + Send>> 
+    where
+        <S as IntoStream>::IntoStream: Send
+    {
         let stream = stream.into_stream();
 
         Box::pin(async move {
@@ -54,7 +60,10 @@ impl<T: Send> FromStream<T> for Rc<[T]> {
     #[inline]
     fn from_stream<'a, S: IntoStream<Item = T> + 'a>(
         stream: S,
-    ) -> Pin<Box<dyn Future<Output = Self> + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = Self> + 'a + Send>> 
+    where
+        <S as IntoStream>::IntoStream: Send
+    {
         let stream = stream.into_stream();
 
         Box::pin(async move {
@@ -67,7 +76,10 @@ impl<T: Send> FromStream<T> for Arc<[T]> {
     #[inline]
     fn from_stream<'a, S: IntoStream<Item = T> + 'a>(
         stream: S,
-    ) -> Pin<Box<dyn Future<Output = Self> + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = Self> + 'a + Send>> 
+    where
+        <S as IntoStream>::IntoStream: Send
+    {
         let stream = stream.into_stream();
 
         Box::pin(async move {

From 656eb010e6bc6757c629304a133111c150fdcf97 Mon Sep 17 00:00:00 2001
From: dignifiedquire <me@dignifiedquire.com>
Date: Sat, 27 Jun 2020 16:13:45 +0200
Subject: [PATCH 4/4] simplify trait bound

---
 src/collections/binary_heap/extend.rs |  2 +-
 src/collections/btree_map/extend.rs   |  2 +-
 src/collections/btree_set/extend.rs   |  2 +-
 src/collections/hash_map/extend.rs    |  2 +-
 src/collections/hash_set/extend.rs    |  2 +-
 src/collections/linked_list/extend.rs |  2 +-
 src/collections/vec_deque/extend.rs   |  2 +-
 src/path/pathbuf.rs                   |  2 +-
 src/stream/extend.rs                  |  4 ++--
 src/string/extend.rs                  | 10 +++++-----
 src/unit/extend.rs                    |  2 +-
 src/vec/extend.rs                     |  2 +-
 12 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/src/collections/binary_heap/extend.rs b/src/collections/binary_heap/extend.rs
index 64fe88c2a..1a9479e14 100644
--- a/src/collections/binary_heap/extend.rs
+++ b/src/collections/binary_heap/extend.rs
@@ -5,7 +5,7 @@ use crate::prelude::*;
 use crate::stream::{self, IntoStream};
 
 impl<T: Ord + Send> stream::Extend<T> for BinaryHeap<T> {
-    fn extend<'a, S: IntoStream<Item = T> + 'a + Send>(
+    fn extend<'a, S: IntoStream<Item = T> + 'a>(
         &'a mut self,
         stream: S,
     ) -> Pin<Box<dyn Future<Output = ()> + 'a + Send>>
diff --git a/src/collections/btree_map/extend.rs b/src/collections/btree_map/extend.rs
index 69189f7a3..4a1ad0618 100644
--- a/src/collections/btree_map/extend.rs
+++ b/src/collections/btree_map/extend.rs
@@ -5,7 +5,7 @@ use crate::prelude::*;
 use crate::stream::{self, IntoStream};
 
 impl<K: Ord + Send, V: Send> stream::Extend<(K, V)> for BTreeMap<K, V> {
-    fn extend<'a, S: IntoStream<Item = (K, V)> + 'a + Send>(
+    fn extend<'a, S: IntoStream<Item = (K, V)> + 'a>(
         &'a mut self,
         stream: S,
     ) -> Pin<Box<dyn Future<Output = ()> + 'a + Send>>
diff --git a/src/collections/btree_set/extend.rs b/src/collections/btree_set/extend.rs
index 4222ae7d7..0f7421023 100644
--- a/src/collections/btree_set/extend.rs
+++ b/src/collections/btree_set/extend.rs
@@ -5,7 +5,7 @@ use crate::prelude::*;
 use crate::stream::{self, IntoStream};
 
 impl<T: Ord + Send> stream::Extend<T> for BTreeSet<T> {
-    fn extend<'a, S: IntoStream<Item = T> + 'a + Send>(
+    fn extend<'a, S: IntoStream<Item = T> + 'a>(
         &'a mut self,
         stream: S,
     ) -> Pin<Box<dyn Future<Output = ()> + 'a + Send>>
diff --git a/src/collections/hash_map/extend.rs b/src/collections/hash_map/extend.rs
index b0b2e494b..15b7e7d46 100644
--- a/src/collections/hash_map/extend.rs
+++ b/src/collections/hash_map/extend.rs
@@ -11,7 +11,7 @@ where
     V: Send,
     H: BuildHasher + Default + Send,
 {
-    fn extend<'a, S: IntoStream<Item = (K, V)> + 'a + Send>(
+    fn extend<'a, S: IntoStream<Item = (K, V)> + 'a>(
         &'a mut self,
         stream: S,
     ) -> Pin<Box<dyn Future<Output = ()> + 'a + Send>>
diff --git a/src/collections/hash_set/extend.rs b/src/collections/hash_set/extend.rs
index 15429d358..0246a1e88 100644
--- a/src/collections/hash_set/extend.rs
+++ b/src/collections/hash_set/extend.rs
@@ -10,7 +10,7 @@ where
     T: Eq + Hash + Send,
     H: BuildHasher + Default + Send,
 {
-    fn extend<'a, S: IntoStream<Item = T> + 'a + Send>(
+    fn extend<'a, S: IntoStream<Item = T> + 'a>(
         &'a mut self,
         stream: S,
     ) -> Pin<Box<dyn Future<Output = ()> + 'a + Send>>
diff --git a/src/collections/linked_list/extend.rs b/src/collections/linked_list/extend.rs
index 39dffbe46..8adc41d73 100644
--- a/src/collections/linked_list/extend.rs
+++ b/src/collections/linked_list/extend.rs
@@ -5,7 +5,7 @@ use crate::prelude::*;
 use crate::stream::{self, IntoStream};
 
 impl<T: Send> stream::Extend<T> for LinkedList<T> {
-    fn extend<'a, S: IntoStream<Item = T> + 'a + Send>(
+    fn extend<'a, S: IntoStream<Item = T> + 'a>(
         &'a mut self,
         stream: S,
     ) -> Pin<Box<dyn Future<Output = ()> + 'a + Send>>
diff --git a/src/collections/vec_deque/extend.rs b/src/collections/vec_deque/extend.rs
index a642313be..9dea92231 100644
--- a/src/collections/vec_deque/extend.rs
+++ b/src/collections/vec_deque/extend.rs
@@ -5,7 +5,7 @@ use crate::prelude::*;
 use crate::stream::{self, IntoStream};
 
 impl<T: Send> stream::Extend<T> for VecDeque<T> {
-    fn extend<'a, S: IntoStream<Item = T> + 'a + Send>(
+    fn extend<'a, S: IntoStream<Item = T> + 'a>(
         &'a mut self,
         stream: S,
     ) -> Pin<Box<dyn Future<Output = ()> + 'a + Send>>
diff --git a/src/path/pathbuf.rs b/src/path/pathbuf.rs
index b673f1741..f9370cbab 100644
--- a/src/path/pathbuf.rs
+++ b/src/path/pathbuf.rs
@@ -320,7 +320,7 @@ impl AsRef<OsStr> for PathBuf {
 
 #[cfg(feature = "unstable")]
 impl<P: AsRef<Path>> stream::Extend<P> for PathBuf {
-    fn extend<'a, S: IntoStream<Item = P> + 'a + Send>(
+    fn extend<'a, S: IntoStream<Item = P> + 'a>(
         &'a mut self,
         stream: S,
     ) -> Pin<Box<dyn Future<Output = ()> + 'a + Send>>
diff --git a/src/stream/extend.rs b/src/stream/extend.rs
index 5f58dfe11..0c7d41049 100644
--- a/src/stream/extend.rs
+++ b/src/stream/extend.rs
@@ -31,7 +31,7 @@ use crate::stream::IntoStream;
 #[cfg_attr(feature = "docs", doc(cfg(unstable)))]
 pub trait Extend<A> {
     /// Extends a collection with the contents of a stream.
-    fn extend<'a, T: IntoStream<Item = A> + 'a + Send>(
+    fn extend<'a, T: IntoStream<Item = A> + 'a>(
         &'a mut self,
         stream: T,
     ) -> Pin<Box<dyn Future<Output = ()> + 'a + Send>>
@@ -70,7 +70,7 @@ pub trait Extend<A> {
 pub async fn extend<'a, C, T, S>(collection: &mut C, stream: S)
 where
     C: Extend<T>,
-    S: IntoStream<Item = T> + 'a + Send,
+    S: IntoStream<Item = T> + 'a,
     <S as IntoStream>::IntoStream: Send,
 {
     Extend::extend(collection, stream).await
diff --git a/src/string/extend.rs b/src/string/extend.rs
index 6b06c9352..eae824cbd 100644
--- a/src/string/extend.rs
+++ b/src/string/extend.rs
@@ -5,7 +5,7 @@ use crate::prelude::*;
 use crate::stream::{self, IntoStream};
 
 impl stream::Extend<char> for String {
-    fn extend<'a, S: IntoStream<Item = char> + 'a + Send>(
+    fn extend<'a, S: IntoStream<Item = char> + 'a>(
         &'a mut self,
         stream: S,
     ) -> Pin<Box<dyn Future<Output = ()> + 'a + Send>> 
@@ -26,7 +26,7 @@ impl stream::Extend<char> for String {
 }
 
 impl<'b> stream::Extend<&'b char> for String {
-    fn extend<'a, S: IntoStream<Item = &'b char> + 'a + Send>(
+    fn extend<'a, S: IntoStream<Item = &'b char> + 'a>(
         &'a mut self,
         stream: S,
     ) -> Pin<Box<dyn Future<Output = ()> + 'a + Send>> 
@@ -46,7 +46,7 @@ impl<'b> stream::Extend<&'b char> for String {
 }
 
 impl<'b> stream::Extend<&'b str> for String {
-    fn extend<'a, S: IntoStream<Item = &'b str> + 'a + Send>(
+    fn extend<'a, S: IntoStream<Item = &'b str> + 'a>(
         &'a mut self,
         stream: S,
     ) -> Pin<Box<dyn Future<Output = ()> + 'a + Send>> 
@@ -66,7 +66,7 @@ impl<'b> stream::Extend<&'b str> for String {
 }
 
 impl stream::Extend<String> for String {
-    fn extend<'a, S: IntoStream<Item = String> + 'a + Send>(
+    fn extend<'a, S: IntoStream<Item = String> + 'a>(
         &'a mut self,
         stream: S,
     ) -> Pin<Box<dyn Future<Output = ()> + 'a + Send>>
@@ -86,7 +86,7 @@ impl stream::Extend<String> for String {
 }
 
 impl<'b> stream::Extend<Cow<'b, str>> for String {
-    fn extend<'a, S: IntoStream<Item = Cow<'b, str>> + 'a + Send>(
+    fn extend<'a, S: IntoStream<Item = Cow<'b, str>> + 'a>(
         &'a mut self,
         stream: S,
     ) -> Pin<Box<dyn Future<Output = ()> + 'a + Send>>
diff --git a/src/unit/extend.rs b/src/unit/extend.rs
index 8f42eb5b7..ffc0c2d9d 100644
--- a/src/unit/extend.rs
+++ b/src/unit/extend.rs
@@ -4,7 +4,7 @@ use crate::prelude::*;
 use crate::stream::{self, IntoStream};
 
 impl stream::Extend<()> for () {
-    fn extend<'a, S: IntoStream<Item = ()> + 'a + Send>(
+    fn extend<'a, S: IntoStream<Item = ()> + 'a>(
         &'a mut self,
         stream: S,
     ) -> Pin<Box<dyn Future<Output = ()> + 'a + Send>> 
diff --git a/src/vec/extend.rs b/src/vec/extend.rs
index 8ec00ef86..717338ab7 100644
--- a/src/vec/extend.rs
+++ b/src/vec/extend.rs
@@ -4,7 +4,7 @@ use crate::prelude::*;
 use crate::stream::{self, IntoStream};
 
 impl<T: Send> stream::Extend<T> for Vec<T> {
-    fn extend<'a, S: IntoStream<Item = T> + 'a + Send>(
+    fn extend<'a, S: IntoStream<Item = T> + 'a>(
         &'a mut self,
         stream: S,
     ) -> Pin<Box<dyn Future<Output = ()> + 'a + Send>>