superacli 1.1.4 → 1.1.6

package/ref-monty/crates/monty/src/builtins/round.rs

@@ -0,0 +1,174 @@
+//! Implementation of the round() builtin function.
+
+use crate::{
+    args::ArgValues,
+    bytecode::VM,
+    defer_drop,
+    exception_private::{ExcType, RunResult, SimpleException},
+    resource::ResourceTracker,
+    types::PyTrait,
+    value::Value,
+};
+
+pub fn normalize_bool_to_int(value: Value) -> Value {
+    match value {
+        Value::Bool(b) => Value::Int(i64::from(b)),
+        other => other,
+    }
+}
+
+/// Implementation of the round() builtin function.
+///
+/// Rounds a number to a given precision in decimal digits.
+/// If ndigits is omitted or None, returns the nearest integer.
+/// Uses banker's rounding (round half to even).
+pub fn builtin_round(vm: &mut VM<'_, '_, impl ResourceTracker>, args: ArgValues) -> RunResult<Value> {
+    let (number, ndigits) = args.get_one_two_args("round", vm.heap)?;
+    let number = normalize_bool_to_int(number);
+    defer_drop!(number, vm);
+    defer_drop!(ndigits, vm);
+
+    // Determine the number of digits (None means round to integer)
+    // Extract digits value before potentially consuming ndigits for error handling
+    let digits: Option<i64> = match ndigits {
+        Some(Value::None) => None,
+        Some(Value::Int(n)) => Some(*n),
+        Some(Value::Bool(b)) => Some(i64::from(*b)),
+        Some(v) => {
+            let type_name = v.py_type(vm.heap);
+            return Err(SimpleException::new_msg(
+                ExcType::TypeError,
+                format!("'{type_name}' object cannot be interpreted as an integer"),
+            )
+            .into());
+        }
+        None => None,
+    };
+
+    match number {
+        Value::Int(n) => {
+            if let Some(d) = digits {
+                if d >= 0 {
+                    // Positive or zero digits: return the integer unchanged
+                    Ok(Value::Int(*n))
+                } else {
+                    // Negative digits: round to tens, hundreds, etc. using banker's rounding
+                    // -d is positive since d < 0; use try_from to safely convert
+                    let exp = u32::try_from(-d).unwrap_or(u32::MAX);
+                    let factor = 10_i64.saturating_pow(exp);
+                    let rounded_f = bankers_round(*n as f64 / factor as f64);
+                    let rounded = f64_to_i64(rounded_f) * factor;
+                    Ok(Value::Int(rounded))
+                }
+            } else {
+                // No digits specified: return the integer unchanged
+                Ok(Value::Int(*n))
+            }
+        }
+        Value::Float(f) => {
+            if let Some(d) = digits {
+                // Round to `d` decimal places using banker's rounding.
+                Ok(Value::Float(round_float_to_digits(*f, d)))
+            } else {
+                // No digits: round to nearest integer and return int (banker's rounding)
+                if f.is_nan() {
+                    Err(SimpleException::new_msg(ExcType::ValueError, "cannot convert float NaN to integer").into())
+                } else if f.is_infinite() {
+                    Err(
+                        SimpleException::new_msg(ExcType::OverflowError, "cannot convert float infinity to integer")
+                            .into(),
+                    )
+                } else {
+                    Ok(Value::Int(f64_to_i64(bankers_round(*f))))
+                }
+            }
+        }
+        _ => {
+            let type_name = number.py_type(vm.heap);
+            Err(SimpleException::new_msg(
+                ExcType::TypeError,
+                format!("type {type_name} doesn't define __round__ method"),
+            )
+            .into())
+        }
+    }
+}
+
+/// Implements banker's rounding (round half to even).
+///
+/// This is the rounding mode used by Python's `round()` function.
+/// When the value is exactly halfway between two integers, it rounds to the nearest even integer.
+fn bankers_round(value: f64) -> f64 {
+    let floor = value.floor();
+    let frac = value - floor;
+
+    if frac < 0.5 {
+        floor
+    } else if frac > 0.5 {
+        floor + 1.0
+    } else {
+        // Exactly 0.5 - round to even
+        if f64_to_i64(floor) % 2 == 0 { floor } else { floor + 1.0 }
+    }
+}
+
+/// Rounds a finite float to a given number of decimal digits using banker's rounding.
+///
+/// This is used for `round(x, ndigits)` where Python always returns a float.
+///
+/// For large `ndigits` values where scaling by `10**ndigits` would overflow/underflow `f64`,
+/// CPython returns either the original value (large positive `ndigits`) or a signed zero
+/// (large negative `ndigits`). We mirror that behavior and also preserve the sign of `0.0`.
+fn round_float_to_digits(value: f64, digits: i64) -> f64 {
+    if !value.is_finite() {
+        return value;
+    }
+
+    let rounded = if digits >= 0 {
+        let Ok(exp) = i32::try_from(digits) else {
+            return value;
+        };
+        let multiplier = 10_f64.powi(exp);
+        if !multiplier.is_finite() {
+            return value;
+        }
+        let scaled = value * multiplier;
+        if !scaled.is_finite() {
+            return value;
+        }
+        bankers_round(scaled) / multiplier
+    } else {
+        let Ok(exp) = i32::try_from(digits) else {
+            return 0.0_f64.copysign(value);
+        };
+        let multiplier = 10_f64.powi(exp);
+        if multiplier == 0.0 {
+            return 0.0_f64.copysign(value);
+        }
+        let scaled = value * multiplier;
+        bankers_round(scaled) / multiplier
+    };
+
+    if rounded == 0.0 {
+        0.0_f64.copysign(value)
+    } else {
+        rounded
+    }
+}
+
+/// Converts `f64` to `i64` using saturating float-to-int casting.
+///
+/// Monty uses `i64` for integer values, so float-to-int conversion must pick a
+/// bounded representation:
+/// - Values outside the `i64` range saturate to `i64::MIN`/`i64::MAX`
+/// - `NaN` converts to `0`
+///
+/// This behavior is provided by Rust's `as` casting rules for float-to-int.
+fn f64_to_i64(value: f64) -> i64 {
+    #[expect(
+        clippy::cast_possible_truncation,
+        reason = "intentional truncation; float-to-int casts saturate and map NaN to 0"
+    )]
+    let result = value as i64;
+    result
+}

package/ref-monty/crates/monty/src/builtins/sorted.rs

@@ -0,0 +1,151 @@
+//! Implementation of the sorted() builtin function.
+
+use itertools::Itertools;
+
+use crate::{
+    args::ArgValues,
+    bytecode::VM,
+    defer_drop, defer_drop_mut,
+    exception_private::{ExcType, RunResult, SimpleException},
+    heap::{DropWithHeap, HeapData, HeapGuard},
+    resource::ResourceTracker,
+    sorting::{apply_permutation, sort_indices},
+    types::{List, MontyIter, PyTrait},
+    value::Value,
+};
+
+/// Implementation of the sorted() builtin function.
+///
+/// Returns a new sorted list from the items in an iterable.
+/// Supports `key` and `reverse` keyword arguments matching Python's
+/// `sorted(iterable, /, *, key=None, reverse=False)` signature.
+pub fn builtin_sorted(vm: &mut VM<'_, '_, impl ResourceTracker>, args: ArgValues) -> RunResult<Value> {
+    let (iterable, key_fn, reverse) = parse_sorted_args(args, vm)?;
+    defer_drop!(key_fn, vm);
+
+    let items: Vec<_> = MontyIter::new(iterable, vm)?.collect(vm)?;
+    let mut items_guard = HeapGuard::new(items, vm);
+    let (items, vm) = items_guard.as_parts_mut();
+
+    {
+        // Compute key values if a key function was provided, otherwise we'll sort by the items themselves
+        let mut keys_guard;
+        let (compare_values, vm) = if let Some(f) = key_fn {
+            let keys: Vec<Value> = Vec::with_capacity(items.len());
+            // Use a HeapGuard to ensure that if key function evaluation fails partway through,
+            // we clean up any keys that were successfully computed
+            keys_guard = HeapGuard::new(keys, vm);
+            let (keys, vm) = keys_guard.as_parts_mut();
+            items
+                .iter()
+                .map(|item| {
+                    let item = item.clone_with_heap(vm);
+                    vm.evaluate_function("sorted() key argument", f, ArgValues::One(item))
+                })
+                .process_results(|keys_iter| keys.extend(keys_iter))?;
+            keys_guard.as_parts()
+        } else {
+            (&*items, vm)
+        };
+
+        // Sort indices by comparing key values (or items themselves if no key)
+        let len = compare_values.len();
+        let mut indices: Vec<usize> = (0..len).collect();
+
+        sort_indices(&mut indices, compare_values, reverse, vm)?;
+
+        // Rearrange items in-place according to the sorted permutation
+        apply_permutation(items, &mut indices);
+    }
+
+    let (items, vm) = items_guard.into_parts();
+    let heap_id = vm.heap.allocate(HeapData::List(List::new(items)))?;
+    Ok(Value::Ref(heap_id))
+}
+
+/// Parses the arguments for `sorted(iterable, /, *, key=None, reverse=False)`.
+///
+/// Returns `(iterable, key_fn, reverse)` where `key_fn` is `None` when no key
+/// function was provided (or `None` was explicitly passed), and `reverse` defaults
+/// to `false`.
+fn parse_sorted_args(
+    args: ArgValues,
+    vm: &mut VM<'_, '_, impl ResourceTracker>,
+) -> RunResult<(Value, Option<Value>, bool)> {
+    let (mut positional, kwargs) = args.into_parts();
+    let kwargs = kwargs.into_iter();
+    defer_drop_mut!(kwargs, vm);
+
+    // Extract the single required positional argument
+    let positional_len = positional.len();
+    let Some(iterable) = positional.next() else {
+        positional.drop_with_heap(vm);
+        return Err(SimpleException::new_msg(
+            ExcType::TypeError,
+            format!("sorted expected 1 argument, got {positional_len}"),
+        )
+        .into());
+    };
+
+    // Reject extra positional arguments
+    if positional.len() > 0 {
+        let total = positional_len;
+        iterable.drop_with_heap(vm);
+        positional.drop_with_heap(vm);
+        return Err(
+            SimpleException::new_msg(ExcType::TypeError, format!("sorted expected 1 argument, got {total}")).into(),
+        );
+    }
+
+    // Parse keyword arguments: key and reverse
+    let mut iterable_guard = HeapGuard::new(iterable, vm);
+    let vm = iterable_guard.heap();
+    let mut key_guard = HeapGuard::new(None::<Value>, vm);
+    let (key_val, vm) = key_guard.as_parts_mut();
+    let mut reverse_guard = HeapGuard::new(None::<Value>, vm);
+    let (reverse_val, vm) = reverse_guard.as_parts_mut();
+
+    for (kw_key, value) in kwargs {
+        defer_drop!(kw_key, vm);
+        let mut value = HeapGuard::new(value, vm);
+
+        let Some(keyword_name) = kw_key.as_either_str(value.heap().heap) else {
+            return Err(ExcType::type_error("keywords must be strings"));
+        };
+
+        let key_str = keyword_name.as_str(value.heap().interns);
+        let old = if key_str == "key" {
+            key_val.replace(value.into_inner())
+        } else if key_str == "reverse" {
+            reverse_val.replace(value.into_inner())
+        } else {
+            return Err(ExcType::type_error(format!(
+                "'{key_str}' is an invalid keyword argument for sorted()"
+            )));
+        };
+
+        old.drop_with_heap(vm);
+    }
+
+    // Convert reverse to bool (default false)
+    let reverse_val = reverse_guard.into_inner();
+    let vm = key_guard.heap();
+    let reverse = if let Some(v) = reverse_val {
+        let result = v.py_bool(vm);
+        v.drop_with_heap(vm);
+        result
+    } else {
+        false
+    };
+
+    // Handle key function (None means no key function)
+    let key_fn = match key_guard.into_inner() {
+        Some(v) if matches!(v, Value::None) => {
+            v.drop_with_heap(iterable_guard.heap());
+            None
+        }
+        other => other,
+    };
+
+    Ok((iterable_guard.into_inner(), key_fn, reverse))
+}

package/ref-monty/crates/monty/src/builtins/sum.rs

@@ -0,0 +1,66 @@
+//! Implementation of the sum() builtin function.
+
+use crate::{
+    args::ArgValues,
+    bytecode::VM,
+    defer_drop, defer_drop_mut,
+    exception_private::{ExcType, RunResult, SimpleException},
+    heap::HeapGuard,
+    resource::ResourceTracker,
+    types::{MontyIter, PyTrait, Type},
+    value::Value,
+};
+
+/// Implementation of the sum() builtin function.
+///
+/// Sums the items of an iterable from left to right with an optional start value.
+/// The default start value is 0. String start values are explicitly rejected
+/// (use `''.join(seq)` instead for string concatenation).
+pub fn builtin_sum(vm: &mut VM<'_, '_, impl ResourceTracker>, args: ArgValues) -> RunResult<Value> {
+    let (iterable, start) = args.get_one_two_args("sum", vm.heap)?;
+    defer_drop_mut!(start, vm);
+
+    let iter = MontyIter::new(iterable, vm)?;
+    defer_drop_mut!(iter, vm);
+
+    // Get the start value, defaulting to 0
+    let accumulator = match start.take() {
+        Some(v) => {
+            // Reject string start values - Python explicitly forbids this
+            if matches!(v.py_type(vm.heap), Type::Str) {
+                v.drop_with_heap(vm);
+                return Err(SimpleException::new_msg(
+                    ExcType::TypeError,
+                    "sum() can't sum strings [use ''.join(seq) instead]",
+                )
+                .into());
+            }
+            v
+        }
+        None => Value::Int(0),
+    };
+
+    // HeapGuard for accumulator: on success we extract it via into_inner(),
+    // on any error path it's dropped automatically
+    let mut acc_guard = HeapGuard::new(accumulator, vm);
+    let (accumulator, vm) = acc_guard.as_parts_mut();
+
+    // Sum all items
+    while let Some(item) = iter.for_next(vm)? {
+        defer_drop!(item, vm);
+
+        // Try to add the item to accumulator
+        if let Some(new_value) = accumulator.py_add(item, vm)? {
+            // Replace the old accumulator with the new value, dropping the old one
+            let old = std::mem::replace(accumulator, new_value);
+            old.drop_with_heap(vm);
+        } else {
+            // Types don't support addition
+            let acc_type = accumulator.py_type(vm.heap);
+            let item_type = item.py_type(vm.heap);
+            return Err(ExcType::binary_type_error("+", acc_type, item_type));
+        }
+    }
+
+    Ok(acc_guard.into_inner())
+}

package/ref-monty/crates/monty/src/builtins/type_.rs

@@ -0,0 +1,16 @@
+//! Implementation of the type() builtin function.
+
+use super::Builtins;
+use crate::{
+    args::ArgValues, bytecode::VM, defer_drop, exception_private::RunResult, resource::ResourceTracker, types::PyTrait,
+    value::Value,
+};
+
+/// Implementation of the type() builtin function.
+///
+/// Returns the type of an object.
+pub fn builtin_type(vm: &mut VM<'_, '_, impl ResourceTracker>, args: ArgValues) -> RunResult<Value> {
+    let value = args.get_one_arg("type", vm.heap)?;
+    defer_drop!(value, vm);
+    Ok(Value::Builtin(Builtins::Type(value.py_type(vm.heap))))
+}

package/ref-monty/crates/monty/src/builtins/zip.rs

@@ -0,0 +1,77 @@
+//! Implementation of the zip() builtin function.
+
+use crate::{
+    args::ArgValues,
+    bytecode::VM,
+    defer_drop_mut,
+    exception_private::RunResult,
+    heap::HeapData,
+    resource::ResourceTracker,
+    types::{List, MontyIter, allocate_tuple, tuple::TupleVec},
+    value::Value,
+};
+
+/// Implementation of the zip() builtin function.
+///
+/// Returns a list of tuples, where the i-th tuple contains the i-th element
+/// from each of the argument iterables. Stops when the shortest iterable is exhausted.
+/// Note: In Python this returns an iterator, but we return a list for simplicity.
+pub fn builtin_zip(vm: &mut VM<'_, '_, impl ResourceTracker>, args: ArgValues) -> RunResult<Value> {
+    let (positional, kwargs) = args.into_parts();
+    defer_drop_mut!(positional, vm);
+
+    // TODO: support kwargs (strict)
+    kwargs.not_supported_yet("zip", vm.heap)?;
+
+    if positional.len() == 0 {
+        // zip() with no arguments returns empty list
+        let heap_id = vm.heap.allocate(HeapData::List(List::new(Vec::new())))?;
+        return Ok(Value::Ref(heap_id));
+    }
+
+    // Create iterators for each iterable
+    let mut iterators: Vec<MontyIter> = Vec::with_capacity(positional.len());
+    for iterable in positional {
+        match MontyIter::new(iterable, vm) {
+            Ok(iter) => iterators.push(iter),
+            Err(e) => {
+                // Clean up already-created iterators
+                for iter in iterators {
+                    iter.drop_with_heap(vm);
+                }
+                return Err(e);
+            }
+        }
+    }
+
+    let mut result: Vec<Value> = Vec::new();
+
+    // Zip until shortest iterator is exhausted
+    'outer: loop {
+        let mut tuple_items = TupleVec::with_capacity(iterators.len());
+
+        for iter in &mut iterators {
+            if let Some(item) = iter.for_next(vm)? {
+                tuple_items.push(item);
+            } else {
+                // This iterator is exhausted - drop partial tuple items and stop
+                for item in tuple_items {
+                    item.drop_with_heap(vm);
+                }
+                break 'outer;
+            }
+        }
+
+        // Create tuple from collected items
+        let tuple_val = allocate_tuple(tuple_items, vm.heap)?;
+        result.push(tuple_val);
+    }
+
+    // Clean up iterators
+    for iter in iterators {
+        iter.drop_with_heap(vm);
+    }
+
+    let heap_id = vm.heap.allocate(HeapData::List(List::new(result)))?;
+    Ok(Value::Ref(heap_id))
+}