superacli 1.1.6 → 1.1.7

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

@@ -1,174 +0,0 @@
-//! 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

@@ -1,151 +0,0 @@
-//! 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

@@ -1,66 +0,0 @@
-//! 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

@@ -1,16 +0,0 @@
-//! 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

@@ -1,77 +0,0 @@
-//! 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))
-}