Method call_minmax

compiler/src/modules/vm/builtins/numeric.rs:255–288

(&mut self, op: u16, is_min: bool, chunk: &crate::modules::parser::SSAChunk, slots: &mut [Val])

    pub fn call_max(&mut self, op: u16, chunk: &crate::modules::parser::SSAChunk, slots: &mut [Val]) -> Result<(), VmErr> { self.call_minmax(op, false, chunk, slots) }

    fn call_minmax(&mut self, op: u16, is_min: bool, chunk: &crate::modules::parser::SSAChunk, slots: &mut [Val]) -> Result<(), VmErr> {
        let (positional, kw_flat, _np, _nk) = self.parse_call_args(op)?;
        // Optional `default=` (returned when a single iterable is empty) and `key=` (compare by key(x)).
        let mut default: Option<Val> = None;
        let mut key: Option<Val> = None;
        for pair in kw_flat.chunks_exact(2) {
            match self.kw_name(pair[0]) {
                Some("default") => default = Some(pair[1]),
                Some("key") => { if !pair[1].is_none() { key = Some(pair[1]); } }
                _ => return Err(cold_type("min()/max() got an unexpected keyword argument")),
            }
        }
        // One arg iterable; many args are values.
        let items = if positional.len() == 1 { self.iter_to_vec_general(positional[0])? } else { positional };
        let label = if is_min { "min() arg is an empty sequence" } else { "max() arg is an empty sequence" };
        if items.is_empty() {
            return match default { Some(d) => { self.push(d); Ok(()) }, None => Err(cold_value(label)) };
        }
        // Without a key, compare elements directly; with one, compare key(x) but return the winning element.
        let keys: Vec<Val> = match key {
            None => items.clone(),
            Some(k) => {
                let mut ks = Vec::with_capacity(items.len());
                for &x in &items { self.push(k); self.push(x); self.exec_call(1, chunk, slots)?; ks.push(self.pop()?); }
                ks
            }
        };
        let mut best = 0;
        for i in 1..items.len() {
            let (l, r) = if is_min { (keys[i], keys[best]) } else { (keys[best], keys[i]) };
            if self.lt_vals(l, r)? { best = i; }
        }
        self.push(items[best]); Ok(())
    }

    pub fn call_sum(&mut self, op: u16) -> Result<(), VmErr> {
        let args = self.pop_n(op as usize)?;