Adds Stream::lt (#337)

src/stream/stream/lt.rs

@@ -0,0 +1,47 @@
+use std::cmp::Ordering;
+use std::pin::Pin;
+
+use super::partial_cmp::PartialCmpFuture;
+use crate::future::Future;
+use crate::prelude::*;
+use crate::stream::Stream;
+use crate::task::{Context, Poll};
+
+// Determines if the elements of this `Stream` are lexicographically
+// less than those of another.
+#[doc(hidden)]
+#[allow(missing_debug_implementations)]
+pub struct LtFuture<L: Stream, R: Stream> {
+    partial_cmp: PartialCmpFuture<L, R>,
+}
+
+impl<L: Stream, R: Stream> LtFuture<L, R>
+where
+    L::Item: PartialOrd<R::Item>,
+{
+    pin_utils::unsafe_pinned!(partial_cmp: PartialCmpFuture<L, R>);
+
+    pub(super) fn new(l: L, r: R) -> Self {
+        LtFuture {
+            partial_cmp: l.partial_cmp(r),
+        }
+    }
+}
+
+impl<L: Stream, R: Stream> Future for LtFuture<L, R>
+where
+    L: Stream + Sized,
+    R: Stream + Sized,
+    L::Item: PartialOrd<R::Item>,
+{
+    type Output = bool;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let result = futures_core::ready!(self.as_mut().partial_cmp().poll(cx));
+
+        match result {
+            Some(Ordering::Less) => Poll::Ready(true),
+            _ => Poll::Ready(false),
+        }
+    }
+}

src/stream/stream/mod.rs

@@ -33,6 +33,7 @@ mod fold;
 mod for_each;
 mod fuse;
 mod inspect;
+mod lt;
 mod map;
 mod min_by;
 mod next;
@@ -55,6 +56,7 @@ use find::FindFuture;
 use find_map::FindMapFuture;
 use fold::FoldFuture;
 use for_each::ForEachFuture;
+use lt::LtFuture;
 use min_by::MinByFuture;
 use next::NextFuture;
 use nth::NthFuture;
@@ -1258,6 +1260,43 @@ extension_trait! {
         {
             PartialCmpFuture::new(self, other)
         }
+
+        #[doc = r#"
+            Determines if the elements of this `Stream` are lexicographically
+            less than those of another.
+            
+            # Examples
+            ```
+            # fn main() { async_std::task::block_on(async {
+            #
+            use async_std::prelude::*;
+            use std::collections::VecDeque;
+                        
+            let single = VecDeque::from(vec![1]);
+            let single_gt = VecDeque::from(vec![10]);
+            let multi = VecDeque::from(vec![1,2]);
+            let multi_gt = VecDeque::from(vec![1,5]);
+
+            assert_eq!(single.clone().lt(single.clone()).await, false);
+            assert_eq!(single.clone().lt(single_gt.clone()).await, true);
+            assert_eq!(multi.clone().lt(single_gt.clone()).await, true);
+            assert_eq!(multi_gt.clone().lt(multi.clone()).await, false);
+            
+            #
+            # }) }
+            ```
+        "#]
+        fn lt<S>(
+           self,
+           other: S
+        ) -> impl Future<Output = bool> [LtFuture<Self, S>]
+        where
+            Self: Sized + Stream,
+            S: Stream,
+            <Self as Stream>::Item: PartialOrd<S::Item>,
+        {
+            LtFuture::new(self, other)
+        }
     }
 
     impl<S: Stream + Unpin + ?Sized> Stream for Box<S> {