From b2af32a000a61b26564878dde6b73cfa71138ff8 Mon Sep 17 00:00:00 2001
From: gnzlbg <gonzalobg88@gmail.com>
Date: Mon, 5 Feb 2018 21:27:19 +0100
Subject: [PATCH 1/4] add is_sorted, is_sorted_by, is_sorted_by_key
---
src/lib.rs | 71 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 71 insertions(+)
diff --git a/src/lib.rs b/src/lib.rs
index 247e6fe81..a501ebbcf 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -953,6 +953,77 @@ pub trait Itertools : Iterator {
peeking_take_while::peeking_take_while(self, accept)
}
+ /// Returns `true` if the elements of the iterator are sorted
+ /// in increasing order.
+ ///
+ /// ```
+ /// # use itertools::Itertools;
+ /// let v = vec![0, 1, 2 , 3];
+ /// assert!(v.iter().is_sorted());
+ ///
+ /// let v = vec![0, 1, 2 , -1];
+ /// assert!(!v.iter().is_sorted());
+ /// ```
+ fn is_sorted(self) -> bool
+ where Self: Sized,
+ Self::Item: Ord,
+ {
+ self.is_sorted_by(|a, b| Ord::cmp(&a, &b))
+ }
+
+ /// Returns `true` if the elements of the iterator
+ /// are sorted according to the `comparison` function.
+ ///
+ /// ```
+ /// # use itertools::Itertools;
+ /// # use std::cmp::Ordering;
+ /// // Is an iterator sorted in decreasing order?
+ /// fn decr<T: Ord>(a: &T, b: &T) -> Ordering {
+ /// a.cmp(b).reverse()
+ /// }
+ ///
+ /// let v = vec![3, 2, 1 , 0];
+ /// assert!(v.iter().is_sorted_by(decr));
+ ///
+ /// let v = vec![3, 2, 1 , 4];
+ /// assert!(!v.iter().is_sorted_by(decr));
+ /// ```
+ fn is_sorted_by<F>(mut self, mut compare: F) -> bool
+ where Self: Sized,
+ Self::Item: Ord,
+ F: FnMut(&Self::Item, &Self::Item) -> Ordering,
+ {
+ let first = self.next();
+ if let Some(mut first) = first {
+ while let Some(second) = self.next() {
+ if compare(&first, &second) == Ordering::Greater {
+ return false;
+ }
+ first = second;
+ }
+ }
+ true
+ }
+
+ /// Returns `true` if the elements of the iterator
+ /// are sorted according to the `key` extraction function.
+ ///
+ /// ```
+ /// # use itertools::Itertools;
+ /// let v = vec![0_i32, -1, 2, -3];
+ /// assert!(v.iter().is_sorted_by_key(|v| v.abs()));
+ ///
+ /// let v = vec![0_i32, -1, 2, 0];
+ /// assert!(!v.iter().is_sorted_by_key(|v| v.abs()));
+ /// ```
+ fn is_sorted_by_key<F, B>(self, mut key: F) -> bool
+ where Self: Sized,
+ B: Ord,
+ F: FnMut(&Self::Item) -> B,
+ {
+ self.map(|v| key(&v)).is_sorted()
+ }
+
/// Return an iterator adaptor that borrows from a `Clone`-able iterator
/// to only pick off elements while the predicate `accept` returns `true`.
///
From c316e3553bb5e657d2286f6140b45cd52b7c1371 Mon Sep 17 00:00:00 2001
From: gnzlbg <gonzalobg88@gmail.com>
Date: Tue, 6 Feb 2018 01:09:05 +0100
Subject: [PATCH 2/4] use &mut self and all
---
src/lib.rs | 15 +++++++++------
1 file changed, 9 insertions(+), 6 deletions(-)
diff --git a/src/lib.rs b/src/lib.rs
index a501ebbcf..b1a71a733 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -964,7 +964,7 @@ pub trait Itertools : Iterator {
/// let v = vec![0, 1, 2 , -1];
/// assert!(!v.iter().is_sorted());
/// ```
- fn is_sorted(self) -> bool
+ fn is_sorted(&mut self) -> bool
where Self: Sized,
Self::Item: Ord,
{
@@ -988,18 +988,21 @@ pub trait Itertools : Iterator {
/// let v = vec![3, 2, 1 , 4];
/// assert!(!v.iter().is_sorted_by(decr));
/// ```
- fn is_sorted_by<F>(mut self, mut compare: F) -> bool
+ fn is_sorted_by<F>(&mut self, mut compare: F) -> bool
where Self: Sized,
Self::Item: Ord,
- F: FnMut(&Self::Item, &Self::Item) -> Ordering,
+ F: FnMut(&Self::Item, &Self::Item) -> Ordering,
{
let first = self.next();
if let Some(mut first) = first {
- while let Some(second) = self.next() {
+ if !self.all(|second| {
if compare(&first, &second) == Ordering::Greater {
return false;
}
first = second;
+ true
+ }) {
+ return false;
}
}
true
@@ -1016,10 +1019,10 @@ pub trait Itertools : Iterator {
/// let v = vec![0_i32, -1, 2, 0];
/// assert!(!v.iter().is_sorted_by_key(|v| v.abs()));
/// ```
- fn is_sorted_by_key<F, B>(self, mut key: F) -> bool
+ fn is_sorted_by_key<F, B>(&mut self, mut key: F) -> bool
where Self: Sized,
B: Ord,
- F: FnMut(&Self::Item) -> B,
+ F: FnMut(&Self::Item) -> B,
{
self.map(|v| key(&v)).is_sorted()
}
From 6ecbb9614075581b063737bae4db7e1db7795ea4 Mon Sep 17 00:00:00 2001
From: gnzlbg <gonzalobg88@gmail.com>
Date: Tue, 6 Feb 2018 01:20:46 +0100
Subject: [PATCH 3/4] remove unnecessary branch
---
src/lib.rs | 6 ++----
1 file changed, 2 insertions(+), 4 deletions(-)
diff --git a/src/lib.rs b/src/lib.rs
index b1a71a733..b8fa51c15 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -995,15 +995,13 @@ pub trait Itertools : Iterator {
{
let first = self.next();
if let Some(mut first) = first {
- if !self.all(|second| {
+ return self.all(|second| {
if compare(&first, &second) == Ordering::Greater {
return false;
}
first = second;
true
- }) {
- return false;
- }
+ });
}
true
}
From 8ca04cfa4d18b81491999910c5b785d6264d6106 Mon Sep 17 00:00:00 2001
From: gnzlbg <gonzalobg88@gmail.com>
Date: Tue, 6 Feb 2018 19:51:08 +0100
Subject: [PATCH 4/4] move to the regular methods section
---
src/lib.rs | 144 ++++++++++++++++++++++++++---------------------------
1 file changed, 72 insertions(+), 72 deletions(-)
diff --git a/src/lib.rs b/src/lib.rs
index b8fa51c15..e6cad757b 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -953,78 +953,6 @@ pub trait Itertools : Iterator {
peeking_take_while::peeking_take_while(self, accept)
}
- /// Returns `true` if the elements of the iterator are sorted
- /// in increasing order.
- ///
- /// ```
- /// # use itertools::Itertools;
- /// let v = vec![0, 1, 2 , 3];
- /// assert!(v.iter().is_sorted());
- ///
- /// let v = vec![0, 1, 2 , -1];
- /// assert!(!v.iter().is_sorted());
- /// ```
- fn is_sorted(&mut self) -> bool
- where Self: Sized,
- Self::Item: Ord,
- {
- self.is_sorted_by(|a, b| Ord::cmp(&a, &b))
- }
-
- /// Returns `true` if the elements of the iterator
- /// are sorted according to the `comparison` function.
- ///
- /// ```
- /// # use itertools::Itertools;
- /// # use std::cmp::Ordering;
- /// // Is an iterator sorted in decreasing order?
- /// fn decr<T: Ord>(a: &T, b: &T) -> Ordering {
- /// a.cmp(b).reverse()
- /// }
- ///
- /// let v = vec![3, 2, 1 , 0];
- /// assert!(v.iter().is_sorted_by(decr));
- ///
- /// let v = vec![3, 2, 1 , 4];
- /// assert!(!v.iter().is_sorted_by(decr));
- /// ```
- fn is_sorted_by<F>(&mut self, mut compare: F) -> bool
- where Self: Sized,
- Self::Item: Ord,
- F: FnMut(&Self::Item, &Self::Item) -> Ordering,
- {
- let first = self.next();
- if let Some(mut first) = first {
- return self.all(|second| {
- if compare(&first, &second) == Ordering::Greater {
- return false;
- }
- first = second;
- true
- });
- }
- true
- }
-
- /// Returns `true` if the elements of the iterator
- /// are sorted according to the `key` extraction function.
- ///
- /// ```
- /// # use itertools::Itertools;
- /// let v = vec![0_i32, -1, 2, -3];
- /// assert!(v.iter().is_sorted_by_key(|v| v.abs()));
- ///
- /// let v = vec![0_i32, -1, 2, 0];
- /// assert!(!v.iter().is_sorted_by_key(|v| v.abs()));
- /// ```
- fn is_sorted_by_key<F, B>(&mut self, mut key: F) -> bool
- where Self: Sized,
- B: Ord,
- F: FnMut(&Self::Item) -> B,
- {
- self.map(|v| key(&v)).is_sorted()
- }
-
/// Return an iterator adaptor that borrows from a `Clone`-able iterator
/// to only pick off elements while the predicate `accept` returns `true`.
///
@@ -1806,6 +1734,78 @@ pub trait Itertools : Iterator {
v
}
+ /// Returns `true` if the elements of the iterator are sorted
+ /// in increasing order.
+ ///
+ /// ```
+ /// # use itertools::Itertools;
+ /// let v = vec![0, 1, 2 , 3];
+ /// assert!(v.iter().is_sorted());
+ ///
+ /// let v = vec![0, 1, 2 , -1];
+ /// assert!(!v.iter().is_sorted());
+ /// ```
+ fn is_sorted(&mut self) -> bool
+ where Self: Sized,
+ Self::Item: Ord,
+ {
+ self.is_sorted_by(|a, b| Ord::cmp(&a, &b))
+ }
+
+ /// Returns `true` if the elements of the iterator
+ /// are sorted according to the `comparison` function.
+ ///
+ /// ```
+ /// # use itertools::Itertools;
+ /// # use std::cmp::Ordering;
+ /// // Is an iterator sorted in decreasing order?
+ /// fn decr<T: Ord>(a: &T, b: &T) -> Ordering {
+ /// a.cmp(b).reverse()
+ /// }
+ ///
+ /// let v = vec![3, 2, 1 , 0];
+ /// assert!(v.iter().is_sorted_by(decr));
+ ///
+ /// let v = vec![3, 2, 1 , 4];
+ /// assert!(!v.iter().is_sorted_by(decr));
+ /// ```
+ fn is_sorted_by<F>(&mut self, mut compare: F) -> bool
+ where Self: Sized,
+ Self::Item: Ord,
+ F: FnMut(&Self::Item, &Self::Item) -> Ordering,
+ {
+ let first = self.next();
+ if let Some(mut first) = first {
+ return self.all(|second| {
+ if compare(&first, &second) == Ordering::Greater {
+ return false;
+ }
+ first = second;
+ true
+ });
+ }
+ true
+ }
+
+ /// Returns `true` if the elements of the iterator
+ /// are sorted according to the `key` extraction function.
+ ///
+ /// ```
+ /// # use itertools::Itertools;
+ /// let v = vec![0_i32, -1, 2, -3];
+ /// assert!(v.iter().is_sorted_by_key(|v| v.abs()));
+ ///
+ /// let v = vec![0_i32, -1, 2, 0];
+ /// assert!(!v.iter().is_sorted_by_key(|v| v.abs()));
+ /// ```
+ fn is_sorted_by_key<F, B>(&mut self, mut key: F) -> bool
+ where Self: Sized,
+ B: Ord,
+ F: FnMut(&Self::Item) -> B,
+ {
+ self.map(|v| key(&v)).is_sorted()
+ }
+
/// Collect all iterator elements into one of two
/// partitions. Unlike `Iterator::partition`, each partition may
/// have a distinct type.