Add {min,max}_set(_by{_key)?)? functions (5) comparator uses Ordering instead of bool

More canonical.

Author: phimuemue

src/extrema_set.rs

@@ -1,10 +1,12 @@
+use std::cmp::Ordering;
+
 /// Implementation guts for `min_set`, `min_set_by`, and `min_set_by_key`.
-pub fn min_set_impl<I, K, F, L>(mut it: I,
+pub fn min_set_impl<I, K, F, Compare>(mut it: I,
                                 mut key_for: F,
-                                mut lt: L) -> Vec<I::Item>
+                                mut compare: Compare) -> Vec<I::Item>
     where I: Iterator,
           F: FnMut(&I::Item) -> K,
-          L: FnMut(&I::Item, &I::Item, &K, &K) -> bool,
+          Compare: FnMut(&I::Item, &I::Item, &K, &K) -> Ordering,
 {
     let (mut result, mut current_key) = match it.next() {
         None => return Vec::new(),
@@ -16,27 +18,32 @@ pub fn min_set_impl<I, K, F, L>(mut it: I,
 
     it.for_each(|element| {
         let key = key_for(&element);
-        if lt(&element, &result[0], &key, &current_key) {
-            result.clear();
-            result.push(element);
-            current_key = key;
-        } else if !lt(&result[0], &element, &current_key, &key) {
-            result.push(element);
+        match compare(&element, &result[0], &key, &current_key) {
+            Ordering::Less => {
+                result.clear();
+                result.push(element);
+                current_key = key;
+            },
+            Ordering::Equal => {
+                result.push(element);
+            },
+            Ordering::Greater => {
+            },
         }
     });
 
     result
 }
 
 /// Implementation guts for `ax_set`, `max_set_by`, and `max_set_by_key`.
-pub fn max_set_impl<I, K, F, L>(it: I,
+pub fn max_set_impl<I, K, F, Compare>(it: I,
                                 key_for: F,
-                                mut lt: L) -> Vec<I::Item>
+                                mut compare: Compare) -> Vec<I::Item>
     where I: Iterator,
           F: FnMut(&I::Item) -> K,
-          L: FnMut(&I::Item, &I::Item, &K, &K) -> bool,
+          Compare: FnMut(&I::Item, &I::Item, &K, &K) -> Ordering,
 {
-    min_set_impl(it, key_for, |it1, it2, key1, key2| lt(it2, it1, key2, key1))
+    min_set_impl(it, key_for, |it1, it2, key1, key2| compare(it2, it1, key2, key1))
 }
 
 

src/lib.rs

@@ -2930,7 +2930,7 @@ pub trait Itertools : Iterator {
     fn min_set(self) -> Vec<Self::Item>
         where Self: Sized, Self::Item: Ord
     {
-        extrema_set::min_set_impl(self, |_| (), |x, y, _, _| x < y)
+        extrema_set::min_set_impl(self, |_| (), |x, y, _, _| x.cmp(y))
     }
 
     /// Return all minimum elements of an iterator, as determined by
@@ -2964,7 +2964,7 @@ pub trait Itertools : Iterator {
         extrema_set::min_set_impl(
             self,
             |_| (),
-            |x, y, _, _| Ordering::Less == compare(x, y)
+            |x, y, _, _| compare(x, y)
         )
     }
 
@@ -2995,7 +2995,7 @@ pub trait Itertools : Iterator {
     fn min_set_by_key<K, F>(self, key: F) -> Vec<Self::Item>
         where Self: Sized, K: Ord, F: FnMut(&Self::Item) -> K
     {
-        extrema_set::min_set_impl(self, key, |_, _, kx, ky| kx < ky)
+        extrema_set::min_set_impl(self, key, |_, _, kx, ky| kx.cmp(ky))
     }
 
     /// Return all maximum elements of an iterator.
@@ -3024,7 +3024,7 @@ pub trait Itertools : Iterator {
     fn max_set(self) -> Vec<Self::Item>
         where Self: Sized, Self::Item: Ord
     {
-        extrema_set::max_set_impl(self, |_| (), |x, y, _, _| x < y)
+        extrema_set::max_set_impl(self, |_| (), |x, y, _, _| x.cmp(y))
     }
 
     /// Return all maximum elements of an iterator, as determined by
@@ -3058,7 +3058,7 @@ pub trait Itertools : Iterator {
         extrema_set::max_set_impl(
             self,
             |_| (),
-            |x, y, _, _| Ordering::Less == compare(x, y)
+            |x, y, _, _| compare(x, y)
         )
     }
 
@@ -3089,7 +3089,7 @@ pub trait Itertools : Iterator {
     fn max_set_by_key<K, F>(self, key: F) -> Vec<Self::Item>
         where Self: Sized, K: Ord, F: FnMut(&Self::Item) -> K
     {
-        extrema_set::max_set_impl(self, key, |_, _, kx, ky| kx < ky)
+        extrema_set::max_set_impl(self, key, |_, _, kx, ky| kx.cmp(ky))
     }
 
     /// Return the minimum and maximum elements in the iterator.