diff --git a/futures-util/src/compat/compat03as01.rs b/futures-util/src/compat/compat03as01.rs
index 763d19b2be..73bff31129 100644
--- a/futures-util/src/compat/compat03as01.rs
+++ b/futures-util/src/compat/compat03as01.rs
@@ -119,7 +119,7 @@ where
     type Error = Fut::Error;
 
     fn poll(&mut self) -> Poll01<Self::Item, Self::Error> {
-        with_context(self, |inner, cx| poll_03_to_01(inner.try_poll(cx)))
+        with_context(self, |inner, cx| poll_03_to_01(inner.poll(cx)))
     }
 }
 
@@ -131,7 +131,7 @@ where
     type Error = St::Error;
 
     fn poll(&mut self) -> Poll01<Option<Self::Item>, Self::Error> {
-        with_context(self, |inner, cx| match inner.try_poll_next(cx)? {
+        with_context(self, |inner, cx| match inner.poll_next(cx)? {
             task03::Poll::Ready(None) => Ok(Async01::Ready(None)),
             task03::Poll::Ready(Some(t)) => Ok(Async01::Ready(Some(t))),
             task03::Poll::Pending => Ok(Async01::NotReady),
diff --git a/futures-util/src/stream/forward.rs b/futures-util/src/stream/forward.rs
index c6e196abf0..2a90f6eb9d 100644
--- a/futures-util/src/stream/forward.rs
+++ b/futures-util/src/stream/forward.rs
@@ -22,7 +22,7 @@ impl<St: TryStream + Unpin, Si: Sink<St::Ok> + Unpin> Unpin for Forward<St, Si>
 impl<St, Si, E> Forward<St, Si>
 where
     Si: Sink<St::Ok, Error = E>,
-    St: TryStream<Error = E> + Stream,
+    St: TryStream<Error = E>,
 {
     unsafe_pinned!(sink: Option<Si>);
     unsafe_pinned!(stream: Fuse<St>);
@@ -53,20 +53,20 @@ where
     }
 }
 
-impl<St, Si, Item, E> FusedFuture for Forward<St, Si>
+impl<St, Si, E> FusedFuture for Forward<St, Si>
 where
-    Si: Sink<Item, Error = E>,
-    St: Stream<Item = Result<Item, E>>,
+    Si: Sink<St::Ok, Error = E>,
+    St: TryStream<Error = E>,
 {
     fn is_terminated(&self) -> bool {
         self.sink.is_none()
     }
 }
 
-impl<St, Si, Item, E> Future for Forward<St, Si>
+impl<St, Si, E> Future for Forward<St, Si>
 where
-    Si: Sink<Item, Error = E>,
-    St: Stream<Item = Result<Item, E>>,
+    Si: Sink<St::Ok, Error = E>,
+    St: TryStream<Error = E>,
 {
     type Output = Result<(), E>;
 
diff --git a/futures-util/src/try_future/err_into.rs b/futures-util/src/try_future/err_into.rs
index 731fcae39e..bc5d2fa1dc 100644
--- a/futures-util/src/try_future/err_into.rs
+++ b/futures-util/src/try_future/err_into.rs
@@ -42,7 +42,7 @@ impl<Fut, E> Future for ErrInto<Fut, E>
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Self::Output> {
-        self.future().try_poll(cx)
+        self.future().poll(cx)
             .map(|res| res.map_err(Into::into))
     }
 }
diff --git a/futures-util/src/try_future/flatten_stream_sink.rs b/futures-util/src/try_future/flatten_stream_sink.rs
index 5a56bf708d..f08419d220 100644
--- a/futures-util/src/try_future/flatten_stream_sink.rs
+++ b/futures-util/src/try_future/flatten_stream_sink.rs
@@ -78,7 +78,7 @@ where
 {
     fn poll_future(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Fut::Error>> {
         if let State::Future(f) = self.as_mut().get_pin_mut() {
-            match ready!(f.try_poll(cx)) {
+            match ready!(f.poll(cx)) {
                 Ok(s) => {
                     // Future resolved to stream.
                     // We do not return, but poll that
@@ -121,7 +121,7 @@ where
     fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
         ready!(self.as_mut().state().poll_future(cx)?);
         match self.as_mut().state().get_pin_mut() {
-            State::StreamOrSink(s) => s.try_poll_next(cx),
+            State::StreamOrSink(s) => s.poll_next(cx),
             State::Done => Poll::Ready(None),
             State::Future(_) => unreachable!(),
         }
diff --git a/futures-util/src/try_future/inspect_err.rs b/futures-util/src/try_future/inspect_err.rs
index 8700337bb2..a201445aba 100644
--- a/futures-util/src/try_future/inspect_err.rs
+++ b/futures-util/src/try_future/inspect_err.rs
@@ -44,7 +44,7 @@ where
     type Output = Result<Fut::Ok, Fut::Error>;
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let e = ready!(self.as_mut().future().try_poll(cx));
+        let e = ready!(self.as_mut().future().poll(cx));
         if let Err(e) = &e {
             self.as_mut().f().take().expect("cannot poll InspectErr twice")(e);
         }
diff --git a/futures-util/src/try_future/inspect_ok.rs b/futures-util/src/try_future/inspect_ok.rs
index 3d0a972226..762abec9d4 100644
--- a/futures-util/src/try_future/inspect_ok.rs
+++ b/futures-util/src/try_future/inspect_ok.rs
@@ -44,7 +44,7 @@ where
     type Output = Result<Fut::Ok, Fut::Error>;
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let e = ready!(self.as_mut().future().try_poll(cx));
+        let e = ready!(self.as_mut().future().poll(cx));
         if let Ok(e) = &e {
             self.as_mut().f().take().expect("cannot poll InspectOk twice")(e);
         }
diff --git a/futures-util/src/try_future/into_future.rs b/futures-util/src/try_future/into_future.rs
index a766d5b66d..f93650a23d 100644
--- a/futures-util/src/try_future/into_future.rs
+++ b/futures-util/src/try_future/into_future.rs
@@ -31,6 +31,6 @@ impl<Fut: TryFuture> Future for IntoFuture<Fut> {
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Self::Output> {
-        self.future().try_poll(cx)
+        self.future().poll(cx)
     }
 }
diff --git a/futures-util/src/try_future/map_err.rs b/futures-util/src/try_future/map_err.rs
index 8edebad86d..2e90710b1a 100644
--- a/futures-util/src/try_future/map_err.rs
+++ b/futures-util/src/try_future/map_err.rs
@@ -42,7 +42,7 @@ impl<Fut, F, E> Future for MapErr<Fut, F>
     ) -> Poll<Self::Output> {
         self.as_mut()
             .future()
-            .try_poll(cx)
+            .poll(cx)
             .map(|result| {
                 let f = self.as_mut().f().take()
                     .expect("MapErr must not be polled after it returned `Poll::Ready`");
diff --git a/futures-util/src/try_future/map_ok.rs b/futures-util/src/try_future/map_ok.rs
index ab28f1443f..56f9732f49 100644
--- a/futures-util/src/try_future/map_ok.rs
+++ b/futures-util/src/try_future/map_ok.rs
@@ -44,7 +44,7 @@ impl<Fut, F, T> Future for MapOk<Fut, F>
     ) -> Poll<Self::Output> {
         self.as_mut()
             .future()
-            .try_poll(cx)
+            .poll(cx)
             .map(|result| {
                 let op = self.as_mut().f().take()
                     .expect("MapOk must not be polled after it returned `Poll::Ready`");
diff --git a/futures-util/src/try_future/select_ok.rs b/futures-util/src/try_future/select_ok.rs
index ae1316a48e..a0894af3cb 100644
--- a/futures-util/src/try_future/select_ok.rs
+++ b/futures-util/src/try_future/select_ok.rs
@@ -1,4 +1,4 @@
-use crate::try_future::TryFutureExt;
+use crate::future::FutureExt;
 use core::iter::FromIterator;
 use core::mem;
 use core::pin::Pin;
@@ -46,7 +46,7 @@ impl<Fut: TryFuture + Unpin> Future for SelectOk<Fut> {
         // loop until we've either exhausted all errors, a success was hit, or nothing is ready
         loop {
             let item = self.inner.iter_mut().enumerate().find_map(|(i, f)| {
-                match f.try_poll_unpin(cx) {
+                match f.poll_unpin(cx) {
                     Poll::Pending => None,
                     Poll::Ready(e) => Some((i, e)),
                 }
diff --git a/futures-util/src/try_future/try_chain.rs b/futures-util/src/try_future/try_chain.rs
index 662bdf2d26..c99a19bb92 100644
--- a/futures-util/src/try_future/try_chain.rs
+++ b/futures-util/src/try_future/try_chain.rs
@@ -50,13 +50,13 @@ impl<Fut1, Fut2, Data> TryChain<Fut1, Fut2, Data>
             let (output, data) = match this {
                 TryChain::First(fut1, data) => {
                     // Poll the first future
-                    let output = ready!(unsafe { Pin::new_unchecked(fut1) }.try_poll(cx));
+                    let output = ready!(unsafe { Pin::new_unchecked(fut1) }.poll(cx));
                     (output, data.take().unwrap())
                 }
                 TryChain::Second(fut2) => {
                     // Poll the second future
                     return unsafe { Pin::new_unchecked(fut2) }
-                        .try_poll(cx)
+                        .poll(cx)
                         .map(|res| {
                             *this = TryChain::Empty; // Drop fut2.
                             res
diff --git a/futures-util/src/try_future/try_join_all.rs b/futures-util/src/try_future/try_join_all.rs
index 30300e4e3e..8425d027ac 100644
--- a/futures-util/src/try_future/try_join_all.rs
+++ b/futures-util/src/try_future/try_join_all.rs
@@ -142,7 +142,7 @@ where
 
         for mut elem in iter_pin_mut(self.elems.as_mut()) {
             if let Some(pending) = elem.as_mut().pending_pin_mut() {
-                match pending.try_poll(cx) {
+                match pending.poll(cx) {
                     Poll::Pending => state = FinalState::Pending,
                     Poll::Ready(output) => match output {
                         Ok(item) => elem.set(ElemState::Done(Some(item))),
diff --git a/futures-util/src/try_future/try_select.rs b/futures-util/src/try_future/try_select.rs
index a1e0b6651f..09a105e369 100644
--- a/futures-util/src/try_future/try_select.rs
+++ b/futures-util/src/try_future/try_select.rs
@@ -2,7 +2,7 @@ use core::pin::Pin;
 use futures_core::future::{Future, TryFuture};
 use futures_core::task::{Context, Poll};
 use crate::future::Either;
-use crate::try_future::TryFutureExt;
+use crate::future::FutureExt;
 
 /// Future for the [`try_select()`] function.
 #[must_use = "futures do nothing unless you `.await` or poll them"]
@@ -65,10 +65,10 @@ impl<A: Unpin, B: Unpin> Future for TrySelect<A, B>
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let (mut a, mut b) = self.inner.take().expect("cannot poll Select twice");
-        match a.try_poll_unpin(cx) {
+        match a.poll_unpin(cx) {
             Poll::Ready(Err(x)) => Poll::Ready(Err(Either::Left((x, b)))),
             Poll::Ready(Ok(x)) => Poll::Ready(Ok(Either::Left((x, b)))),
-            Poll::Pending => match b.try_poll_unpin(cx) {
+            Poll::Pending => match b.poll_unpin(cx) {
                 Poll::Ready(Err(x)) => Poll::Ready(Err(Either::Right((x, a)))),
                 Poll::Ready(Ok(x)) => Poll::Ready(Ok(Either::Right((x, a)))),
                 Poll::Pending => {
diff --git a/futures-util/src/try_future/unwrap_or_else.rs b/futures-util/src/try_future/unwrap_or_else.rs
index 286cc009fb..18ff9d6196 100644
--- a/futures-util/src/try_future/unwrap_or_else.rs
+++ b/futures-util/src/try_future/unwrap_or_else.rs
@@ -45,7 +45,7 @@ impl<Fut, F> Future for UnwrapOrElse<Fut, F>
     ) -> Poll<Self::Output> {
         self.as_mut()
             .future()
-            .try_poll(cx)
+            .poll(cx)
             .map(|result| {
                 let op = self.as_mut().f().take()
                     .expect("UnwrapOrElse already returned `Poll::Ready` before");
diff --git a/futures-util/src/try_stream/and_then.rs b/futures-util/src/try_stream/and_then.rs
index c500028b69..34b72ae180 100644
--- a/futures-util/src/try_stream/and_then.rs
+++ b/futures-util/src/try_stream/and_then.rs
@@ -90,7 +90,7 @@ impl<St, Fut, F> Stream for AndThen<St, Fut, F>
         cx: &mut Context<'_>,
     ) -> Poll<Option<Self::Item>> {
         if self.future.is_none() {
-            let item = match ready!(self.as_mut().stream().try_poll_next(cx)?) {
+            let item = match ready!(self.as_mut().stream().poll_next(cx)?) {
                 None => return Poll::Ready(None),
                 Some(e) => e,
             };
@@ -98,7 +98,7 @@ impl<St, Fut, F> Stream for AndThen<St, Fut, F>
             self.as_mut().future().set(Some(fut));
         }
 
-        let e = ready!(self.as_mut().future().as_pin_mut().unwrap().try_poll(cx));
+        let e = ready!(self.as_mut().future().as_pin_mut().unwrap().poll(cx));
         self.as_mut().future().set(None);
         Poll::Ready(Some(e))
     }
diff --git a/futures-util/src/try_stream/err_into.rs b/futures-util/src/try_stream/err_into.rs
index 462c31a202..c3658e6749 100644
--- a/futures-util/src/try_stream/err_into.rs
+++ b/futures-util/src/try_stream/err_into.rs
@@ -77,7 +77,7 @@ where
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<Self::Item>> {
-        self.stream().try_poll_next(cx)
+        self.stream().poll_next(cx)
             .map(|res| res.map(|some| some.map_err(Into::into)))
     }
 }
diff --git a/futures-util/src/try_stream/inspect_err.rs b/futures-util/src/try_stream/inspect_err.rs
index 588e660d9f..2f754da904 100644
--- a/futures-util/src/try_stream/inspect_err.rs
+++ b/futures-util/src/try_stream/inspect_err.rs
@@ -97,7 +97,7 @@ where
     ) -> Poll<Option<Self::Item>> {
         self.as_mut()
             .stream()
-            .try_poll_next(cx)
+            .poll_next(cx)
             .map(|opt| opt.map(|res| res.map_err(|e| inspect(e, self.as_mut().f()))))
     }
 }
diff --git a/futures-util/src/try_stream/inspect_ok.rs b/futures-util/src/try_stream/inspect_ok.rs
index 1674d91b52..3151b28e34 100644
--- a/futures-util/src/try_stream/inspect_ok.rs
+++ b/futures-util/src/try_stream/inspect_ok.rs
@@ -97,7 +97,7 @@ where
     ) -> Poll<Option<Self::Item>> {
         self.as_mut()
             .stream()
-            .try_poll_next(cx)
+            .poll_next(cx)
             .map(|opt| opt.map(|res| res.map(|e| inspect(e, self.as_mut().f()))))
     }
 }
diff --git a/futures-util/src/try_stream/into_async_read.rs b/futures-util/src/try_stream/into_async_read.rs
index 374299a51f..790b6ca4b1 100644
--- a/futures-util/src/try_stream/into_async_read.rs
+++ b/futures-util/src/try_stream/into_async_read.rs
@@ -1,4 +1,4 @@
-use crate::try_stream::TryStreamExt;
+use crate::stream::StreamExt;
 use core::pin::Pin;
 use futures_core::stream::TryStream;
 use futures_core::task::{Context, Poll};
@@ -73,7 +73,7 @@ where
                     return Poll::Ready(Ok(len));
                 }
                 ReadState::PendingChunk => {
-                    match ready!(self.stream.try_poll_next_unpin(cx)) {
+                    match ready!(self.stream.poll_next_unpin(cx)) {
                         Some(Ok(chunk)) => {
                             if !chunk.as_ref().is_empty() {
                                 self.state = ReadState::Ready {
@@ -138,7 +138,7 @@ where
         cx: &mut Context<'_>,
     ) -> Poll<Result<&[u8]>> {
         while let ReadState::PendingChunk = self.state {
-            match ready!(self.stream.try_poll_next_unpin(cx)) {
+            match ready!(self.stream.poll_next_unpin(cx)) {
                 Some(Ok(chunk)) => {
                     if !chunk.as_ref().is_empty() {
                         self.state = ReadState::Ready {
diff --git a/futures-util/src/try_stream/into_stream.rs b/futures-util/src/try_stream/into_stream.rs
index f265617406..120696fe73 100644
--- a/futures-util/src/try_stream/into_stream.rs
+++ b/futures-util/src/try_stream/into_stream.rs
@@ -60,14 +60,14 @@ impl<St: TryStream + FusedStream> FusedStream for IntoStream<St> {
 }
 
 impl<St: TryStream> Stream for IntoStream<St> {
-    type Item = Result<St::Ok, St::Error>;
+    type Item = St::Item;
 
     #[inline]
     fn poll_next(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<Self::Item>> {
-        self.stream().try_poll_next(cx)
+        self.stream().poll_next(cx)
     }
 }
 
diff --git a/futures-util/src/try_stream/map_err.rs b/futures-util/src/try_stream/map_err.rs
index 68d5d71a3b..32a820e472 100644
--- a/futures-util/src/try_stream/map_err.rs
+++ b/futures-util/src/try_stream/map_err.rs
@@ -91,7 +91,7 @@ where
     ) -> Poll<Option<Self::Item>> {
         self.as_mut()
             .stream()
-            .try_poll_next(cx)
+            .poll_next(cx)
             .map(|opt| opt.map(|res| res.map_err(|e| self.as_mut().f()(e))))
     }
 }
diff --git a/futures-util/src/try_stream/map_ok.rs b/futures-util/src/try_stream/map_ok.rs
index 1738c6e730..6519f33115 100644
--- a/futures-util/src/try_stream/map_ok.rs
+++ b/futures-util/src/try_stream/map_ok.rs
@@ -91,7 +91,7 @@ where
     ) -> Poll<Option<Self::Item>> {
         self.as_mut()
             .stream()
-            .try_poll_next(cx)
+            .poll_next(cx)
             .map(|opt| opt.map(|res| res.map(|x| self.as_mut().f()(x))))
     }
 }
diff --git a/futures-util/src/try_stream/or_else.rs b/futures-util/src/try_stream/or_else.rs
index 0fe256572d..634eb68103 100644
--- a/futures-util/src/try_stream/or_else.rs
+++ b/futures-util/src/try_stream/or_else.rs
@@ -90,7 +90,7 @@ impl<St, Fut, F> Stream for OrElse<St, Fut, F>
         cx: &mut Context<'_>,
     ) -> Poll<Option<Self::Item>> {
         if self.future.is_none() {
-            let item = match ready!(self.as_mut().stream().try_poll_next(cx)) {
+            let item = match ready!(self.as_mut().stream().poll_next(cx)) {
                 None => return Poll::Ready(None),
                 Some(Ok(e)) => return Poll::Ready(Some(Ok(e))),
                 Some(Err(e)) => e,
@@ -99,7 +99,7 @@ impl<St, Fut, F> Stream for OrElse<St, Fut, F>
             self.as_mut().future().set(Some(fut));
         }
 
-        let e = ready!(self.as_mut().future().as_pin_mut().unwrap().try_poll(cx));
+        let e = ready!(self.as_mut().future().as_pin_mut().unwrap().poll(cx));
         self.as_mut().future().set(None);
         Poll::Ready(Some(e))
     }
diff --git a/futures-util/src/try_stream/try_collect.rs b/futures-util/src/try_stream/try_collect.rs
index d22e8e8543..f62dd275ca 100644
--- a/futures-util/src/try_stream/try_collect.rs
+++ b/futures-util/src/try_stream/try_collect.rs
@@ -53,7 +53,7 @@ where
         cx: &mut Context<'_>,
     ) -> Poll<Self::Output> {
         loop {
-            match ready!(self.as_mut().stream().try_poll_next(cx)?) {
+            match ready!(self.as_mut().stream().poll_next(cx)?) {
                 Some(x) => self.as_mut().items().extend(Some(x)),
                 None => return Poll::Ready(Ok(self.as_mut().finish())),
             }
diff --git a/futures-util/src/try_stream/try_concat.rs b/futures-util/src/try_stream/try_concat.rs
index 395f166c6b..7c88d0e209 100644
--- a/futures-util/src/try_stream/try_concat.rs
+++ b/futures-util/src/try_stream/try_concat.rs
@@ -39,7 +39,7 @@ where
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         loop {
-            match ready!(self.as_mut().stream().try_poll_next(cx)?) {
+            match ready!(self.as_mut().stream().poll_next(cx)?) {
                 Some(x) => {
                     let accum = self.as_mut().accum();
                     if let Some(a) = accum {
diff --git a/futures-util/src/try_stream/try_filter.rs b/futures-util/src/try_stream/try_filter.rs
index f5035c13b1..cc3f776b34 100644
--- a/futures-util/src/try_stream/try_filter.rs
+++ b/futures-util/src/try_stream/try_filter.rs
@@ -111,7 +111,7 @@ impl<St, Fut, F> Stream for TryFilter<St, Fut, F>
     ) -> Poll<Option<Result<St::Ok, St::Error>>> {
         loop {
             if self.pending_fut.is_none() {
-                let item = match ready!(self.as_mut().stream().try_poll_next(cx)?) {
+                let item = match ready!(self.as_mut().stream().poll_next(cx)?) {
                     Some(x) => x,
                     None => return Poll::Ready(None),
                 };
diff --git a/futures-util/src/try_stream/try_filter_map.rs b/futures-util/src/try_stream/try_filter_map.rs
index 08b7aa7ce8..56e31c3c82 100644
--- a/futures-util/src/try_stream/try_filter_map.rs
+++ b/futures-util/src/try_stream/try_filter_map.rs
@@ -98,7 +98,7 @@ impl<St, Fut, F, T> Stream for TryFilterMap<St, Fut, F>
     ) -> Poll<Option<Result<T, St::Error>>> {
         loop {
             if self.pending.is_none() {
-                let item = match ready!(self.as_mut().stream().try_poll_next(cx)?) {
+                let item = match ready!(self.as_mut().stream().poll_next(cx)?) {
                     Some(x) => x,
                     None => return Poll::Ready(None),
                 };
@@ -106,7 +106,7 @@ impl<St, Fut, F, T> Stream for TryFilterMap<St, Fut, F>
                 self.as_mut().pending().set(Some(fut));
             }
 
-            let result = ready!(self.as_mut().pending().as_pin_mut().unwrap().try_poll(cx));
+            let result = ready!(self.as_mut().pending().as_pin_mut().unwrap().poll(cx));
             self.as_mut().pending().set(None);
             if let Some(x) = result? {
                 return Poll::Ready(Some(Ok(x)));
diff --git a/futures-util/src/try_stream/try_flatten.rs b/futures-util/src/try_stream/try_flatten.rs
index 5f81b22b4c..cb3a0f0e8f 100644
--- a/futures-util/src/try_stream/try_flatten.rs
+++ b/futures-util/src/try_stream/try_flatten.rs
@@ -96,7 +96,7 @@ where
     fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
         loop {
             if self.next.is_none() {
-                match ready!(self.as_mut().stream().try_poll_next(cx)?) {
+                match ready!(self.as_mut().stream().poll_next(cx)?) {
                     Some(e) => self.as_mut().next().set(Some(e)),
                     None => return Poll::Ready(None),
                 }
@@ -107,7 +107,7 @@ where
                 .next()
                 .as_pin_mut()
                 .unwrap()
-                .try_poll_next(cx)?)
+                .poll_next(cx)?)
             {
                 return Poll::Ready(Some(Ok(item)));
             } else {
diff --git a/futures-util/src/try_stream/try_fold.rs b/futures-util/src/try_stream/try_fold.rs
index b8b8dc24f1..470eb4223e 100644
--- a/futures-util/src/try_stream/try_fold.rs
+++ b/futures-util/src/try_stream/try_fold.rs
@@ -75,7 +75,7 @@ impl<St, Fut, T, F> Future for TryFold<St, Fut, T, F>
                 let accum = match ready!(
                     self.as_mut().future().as_pin_mut()
                        .expect("TryFold polled after completion")
-                       .try_poll(cx)
+                       .poll(cx)
                 ) {
                     Ok(accum) => accum,
                     Err(e) => {
@@ -88,7 +88,7 @@ impl<St, Fut, T, F> Future for TryFold<St, Fut, T, F>
                 self.as_mut().future().set(None);
             }
 
-            let item = match ready!(self.as_mut().stream().try_poll_next(cx)) {
+            let item = match ready!(self.as_mut().stream().poll_next(cx)) {
                 Some(Ok(item)) => Some(item),
                 Some(Err(e)) => {
                     // Indicate that the future can no longer be polled.
diff --git a/futures-util/src/try_stream/try_for_each.rs b/futures-util/src/try_stream/try_for_each.rs
index 2c71107646..cd1cf6c8b2 100644
--- a/futures-util/src/try_stream/try_for_each.rs
+++ b/futures-util/src/try_stream/try_for_each.rs
@@ -56,11 +56,11 @@ impl<St, Fut, F> Future for TryForEach<St, Fut, F>
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         loop {
             if let Some(future) = self.as_mut().future().as_pin_mut() {
-                ready!(future.try_poll(cx))?;
+                ready!(future.poll(cx))?;
             }
             self.as_mut().future().set(None);
 
-            match ready!(self.as_mut().stream().try_poll_next(cx)?) {
+            match ready!(self.as_mut().stream().poll_next(cx)?) {
                 Some(e) => {
                     let future = (self.as_mut().f())(e);
                     self.as_mut().future().set(Some(future));
diff --git a/futures-util/src/try_stream/try_for_each_concurrent.rs b/futures-util/src/try_stream/try_for_each_concurrent.rs
index 19c3e5b89a..4be628aca2 100644
--- a/futures-util/src/try_stream/try_for_each_concurrent.rs
+++ b/futures-util/src/try_stream/try_for_each_concurrent.rs
@@ -85,7 +85,7 @@ impl<St, Fut, F> Future for TryForEachConcurrent<St, Fut, F>
             // Check if we've already created a number of futures greater than `limit`
             if self.limit.map(|limit| limit.get() > current_len).unwrap_or(true) {
                 let poll_res = match self.as_mut().stream().as_pin_mut() {
-                    Some(stream) => stream.try_poll_next(cx),
+                    Some(stream) => stream.poll_next(cx),
                     None => Poll::Ready(None),
                 };
 
diff --git a/futures-util/src/try_stream/try_next.rs b/futures-util/src/try_stream/try_next.rs
index 382550c400..95a2ec0843 100644
--- a/futures-util/src/try_stream/try_next.rs
+++ b/futures-util/src/try_stream/try_next.rs
@@ -1,4 +1,4 @@
-use crate::try_stream::TryStreamExt;
+use crate::stream::StreamExt;
 use core::pin::Pin;
 use futures_core::future::{FusedFuture, Future};
 use futures_core::stream::{FusedStream, TryStream};
@@ -32,6 +32,6 @@ impl<St: ?Sized + TryStream + Unpin> Future for TryNext<'_, St> {
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Self::Output> {
-        self.stream.try_poll_next_unpin(cx)?.map(Ok)
+        self.stream.poll_next_unpin(cx)?.map(Ok)
     }
 }
diff --git a/futures-util/src/try_stream/try_skip_while.rs b/futures-util/src/try_stream/try_skip_while.rs
index 6d446fcc2b..68599f1cc6 100644
--- a/futures-util/src/try_stream/try_skip_while.rs
+++ b/futures-util/src/try_stream/try_skip_while.rs
@@ -107,12 +107,12 @@ impl<St, Fut, F> Stream for TrySkipWhile<St, Fut, F>
         cx: &mut Context<'_>,
     ) -> Poll<Option<Self::Item>> {
         if self.done_skipping {
-            return self.as_mut().stream().try_poll_next(cx);
+            return self.as_mut().stream().poll_next(cx);
         }
 
         loop {
             if self.pending_item.is_none() {
-                let item = match ready!(self.as_mut().stream().try_poll_next(cx)?) {
+                let item = match ready!(self.as_mut().stream().poll_next(cx)?) {
                     Some(e) => e,
                     None => return Poll::Ready(None),
                 };
@@ -121,7 +121,7 @@ impl<St, Fut, F> Stream for TrySkipWhile<St, Fut, F>
                 *self.as_mut().pending_item() = Some(item);
             }
 
-            let skipped = ready!(self.as_mut().pending_fut().as_pin_mut().unwrap().try_poll(cx)?);
+            let skipped = ready!(self.as_mut().pending_fut().as_pin_mut().unwrap().poll(cx)?);
             let item = self.as_mut().pending_item().take().unwrap();
             self.as_mut().pending_fut().set(None);