🔑 added max_by_key (#73)

Author: timfennis

ndc_lib/src/stdlib/sequence.rs

@@ -111,6 +111,33 @@ mod inner {
             Sequence::Deque(d) => d.try_borrow()?.iter().try_max(),
         }
     }
+    /// Returns the element for which the key function returns the highest value.
+    pub fn max_by_key(seq: &mut Sequence, func: &Callable<'_>) -> EvaluationResult {
+        by_key(seq, func, Ordering::Greater)
+    }
+
+    /// Returns the element for which the key function returns the lowest value.
+    pub fn min_by_key(seq: &mut Sequence, func: &Callable<'_>) -> EvaluationResult {
+        by_key(seq, func, Ordering::Less)
+    }
+
+    /// Returns the maximum element using a comparator function.
+    ///
+    /// The comparator function takes two elements and returns a number. A positive result means the
+    /// first argument is greater than the second, a negative result means the first argument is
+    /// less than the second, and zero means they are equal.
+    pub fn max_by(seq: &mut Sequence, comp: &Callable<'_>) -> EvaluationResult {
+        by_comp(seq, comp, Ordering::Greater)
+    }
+
+    /// Returns the minimum element using a comparator function.
+    ///
+    /// The comparator function takes two elements and returns a number. A positive result means the
+    /// first argument is greater than the second, a negative result means the first argument is
+    /// less than the second, and zero means they are equal.
+    pub fn min_by(seq: &mut Sequence, comp: &Callable<'_>) -> EvaluationResult {
+        by_comp(seq, comp, Ordering::Less)
+    }
 
     /// Returns the lowest element in the sequence.
     pub fn min(seq: &Sequence) -> anyhow::Result<Value> {
@@ -750,6 +777,52 @@ mod inner {
     }
 }
 
+fn by_key(
+    seq: &mut Sequence,
+    func: &Callable<'_>,
+    better: Ordering,
+) -> EvaluationResult {
+    let mut best_value = None;
+    let mut best_key: Option<Value> = None;
+
+    for value in mut_seq_to_iterator(seq) {
+        let new_key = func.call(&mut [value.clone()])?;
+        let is_better = match &best_key {
+            None => true,
+            Some(current_best) => new_key.try_cmp(current_best)? == better,
+        };
+        if is_better {
+            best_key = Some(new_key);
+            best_value = Some(value);
+        }
+    }
+
+    best_value.ok_or_else(|| anyhow::anyhow!("sequence was empty").into())
+}
+
+fn by_comp(
+    seq: &mut Sequence,
+    comp: &Callable<'_>,
+    better: Ordering,
+) -> EvaluationResult {
+    let mut best: Option<Value> = None;
+
+    for value in mut_seq_to_iterator(seq) {
+        let is_better = match &best {
+            None => true,
+            Some(current) => {
+                let result = comp.call(&mut [value.clone(), current.clone()])?;
+                result.try_cmp(&Value::from(0))? == better
+            }
+        };
+        if is_better {
+            best = Some(value);
+        }
+    }
+
+    best.ok_or_else(|| anyhow::anyhow!("sequence was empty").into())
+}
+
 fn fold_iterator(
     iterator: MutableValueIntoIterator<'_>,
     initial: Value,

tests/programs/603_stdlib_seq/005_max_by_key.ndc

@@ -0,0 +1,3 @@
+assert_eq([3, 1, 4, 1, 5, 9].max_by_key(fn(x) => x), 9);
+assert_eq(["foo", "ba", "quux"].max_by_key(fn(s) => s.len()), "quux");
+assert_eq([(1, 10), (2, 5), (3, 8)].max_by_key(fn(t) => t[1]), (1, 10));

tests/programs/603_stdlib_seq/006_min_by_key.ndc

@@ -0,0 +1,3 @@
+assert_eq([3, 1, 4, 1, 5, 9].min_by_key(fn(x) => x), 1);
+assert_eq(["foo", "ba", "quux"].min_by_key(fn(s) => s.len()), "ba");
+assert_eq([(1, 10), (2, 5), (3, 8)].min_by_key(fn(t) => t[1]), (2, 5));

tests/programs/603_stdlib_seq/007_max_by.ndc

@@ -0,0 +1,2 @@
+assert_eq([3, 1, 4, 1, 5, 9].max_by(fn(a, b) => a <=> b), 9);
+assert_eq(["foo", "ba", "quux"].max_by(fn(a, b) => a.len() <=> b.len()), "quux");

tests/programs/603_stdlib_seq/008_min_by.ndc

@@ -0,0 +1,2 @@
+assert_eq([3, 1, 4, 1, 5, 9].min_by(fn(a, b) => a <=> b), 1);
+assert_eq(["foo", "ba", "quux"].min_by(fn(a, b) => a.len() <=> b.len()), "ba");