superacli 1.1.6 → 1.1.8

package/ref-monty/crates/monty/src/asyncio.rs

@@ -1,179 +0,0 @@
-//! Async/await support types for Monty.
-//!
-//! This module contains all async-related types including coroutines, futures,
-//! and task identifiers. The host acts as the event loop - external function
-//! calls return `ExternalFuture` objects that can be awaited.
-
-use crate::{heap::HeapId, intern::FunctionId, value::Value};
-
-/// Unique identifier for external function calls.
-///
-/// Sequential integers allocated by the scheduler. Used to correlate
-/// external function calls with their results when the host resolves them.
-/// The counter always increments, even for sync resolution, to keep IDs unique.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
-pub(crate) struct CallId(u32);
-
-impl CallId {
-    /// Creates a new CallId from a raw value.
-    #[inline]
-    pub fn new(id: u32) -> Self {
-        Self(id)
-    }
-
-    /// Returns the raw u32 value.
-    #[inline]
-    pub fn raw(self) -> u32 {
-        self.0
-    }
-}
-
-/// Unique identifier for an async task.
-///
-/// Sequential integers allocated by the scheduler. Task 0 is always the main task
-/// which uses the VM's stack/frames directly. Spawned tasks (1+) store their own context,
-/// hence `TaskId::default()` is the main task.
-#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
-pub(crate) struct TaskId(u32);
-
-impl TaskId {
-    /// Creates a new TaskId from a raw value.
-    #[inline]
-    pub fn new(id: u32) -> Self {
-        Self(id)
-    }
-
-    /// Returns the raw u32 value.
-    #[inline]
-    pub fn raw(self) -> u32 {
-        self.0
-    }
-
-    /// Returns true if this is the main task (task 0).
-    #[inline]
-    pub fn is_main(self) -> bool {
-        self.0 == 0
-    }
-}
-
-/// Coroutine execution state (single-shot semantics).
-///
-/// Coroutines in Monty follow single-shot semantics - they can only be awaited once.
-/// This differs from Python generators which can be resumed multiple times.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
-pub(crate) enum CoroutineState {
-    /// Coroutine has been created but not yet awaited.
-    New,
-    /// Coroutine is currently executing (has been awaited).
-    Running,
-    /// Coroutine has finished execution.
-    Completed,
-}
-
-/// A coroutine object representing an async function call result.
-///
-/// Created when an `async def` function is called. Argument binding happens at call time;
-/// awaiting the coroutine starts execution. Coroutines use single-shot semantics -
-/// they can only be awaited once.
-///
-/// # Namespace Layout
-///
-/// The `namespace` vector is pre-sized to match the function's namespace size and contains:
-/// ```text
-/// [params...][cell_vars...][free_vars...][locals...]
-/// ```
-/// - Parameter slots are filled with bound argument values at call time
-/// - Cell/free var slots contain `Value::Ref` to captured cells
-/// - Local slots start as `Value::Undefined`
-///
-/// When the coroutine is awaited, these values are pushed onto the VM's stack
-/// as inline locals, and a new frame is pushed to execute the async function body.
-#[derive(Debug, serde::Serialize, serde::Deserialize)]
-pub(crate) struct Coroutine {
-    /// The async function to execute.
-    pub func_id: FunctionId,
-    /// Pre-bound namespace values (sized to function namespace).
-    /// Contains bound parameters, captured cells, and uninitialized locals.
-    pub namespace: Vec<Value>,
-    /// Current execution state.
-    pub state: CoroutineState,
-}
-impl Coroutine {
-    /// Creates a new coroutine for an async function call.
-    ///
-    /// # Arguments
-    /// * `func_id` - The async function to execute
-    /// * `namespace` - Pre-bound namespace with parameters and captured variables
-    pub fn new(func_id: FunctionId, namespace: Vec<Value>) -> Self {
-        Self {
-            func_id,
-            namespace,
-            state: CoroutineState::New,
-        }
-    }
-}
-
-/// An item that can be gathered - either a coroutine or an external future.
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-pub(crate) enum GatherItem {
-    /// A coroutine to spawn as a task.
-    Coroutine(HeapId),
-    /// An external future to wait for resolution.
-    ExternalFuture(CallId),
-}
-
-/// A gather() result tracking multiple coroutines/tasks and external futures.
-///
-/// Created by `asyncio.gather(*awaitables)`. Does NOT spawn tasks immediately -
-/// tasks are spawned when the GatherFuture is awaited in Await.
-///
-/// # Lifecycle
-///
-/// 1. **Creation**: `gather(coro1, coro2, ...)` stores coroutine HeapIds and external CallIds
-/// 2. **Await**: `await gather_future` spawns tasks and blocks the current task
-/// 3. **Completion**: As tasks/futures complete, results are stored in order
-/// 4. **Return**: When all items complete, returns list of results
-///
-/// # Error Handling
-///
-/// On any task failure, sibling tasks are cancelled and the exception propagates
-/// to the task that awaited the gather.
-#[derive(Debug, serde::Serialize, serde::Deserialize)]
-pub(crate) struct GatherFuture {
-    /// Items to gather (coroutines or external futures).
-    pub items: Vec<GatherItem>,
-    /// TaskIds of spawned tasks (only for coroutine items, set when awaited).
-    /// Length matches the number of Coroutine items.
-    pub task_ids: Vec<TaskId>,
-    /// Results from each item, in order (filled as items complete).
-    /// Indices align with `items`.
-    pub results: Vec<Option<Value>>,
-    /// Task waiting on this gather (set when awaited).
-    pub waiter: Option<TaskId>,
-    /// CallIds of external futures we're waiting on.
-    /// Used to check if all external futures have resolved.
-    pub pending_calls: Vec<CallId>,
-}
-
-impl GatherFuture {
-    /// Creates a new GatherFuture with the given items.
-    ///
-    /// # Arguments
-    /// * `items` - Coroutines or external futures to run concurrently
-    pub fn new(items: Vec<GatherItem>) -> Self {
-        let count = items.len();
-        Self {
-            items,
-            task_ids: Vec::new(),
-            results: (0..count).map(|_| None).collect(),
-            waiter: None,
-            pending_calls: Vec::new(),
-        }
-    }
-
-    /// Returns the number of items to gather.
-    #[inline]
-    pub fn item_count(&self) -> usize {
-        self.items.len()
-    }
-}

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

@@ -1,55 +0,0 @@
-//! Implementation of the abs() builtin function.
-
-use num_bigint::BigInt;
-use num_traits::Signed;
-
-use crate::{
-    args::ArgValues,
-    bytecode::VM,
-    defer_drop,
-    exception_private::{ExcType, RunResult, SimpleException},
-    heap::HeapData,
-    resource::ResourceTracker,
-    types::{LongInt, PyTrait},
-    value::Value,
-};
-
-/// Implementation of the abs() builtin function.
-///
-/// Returns the absolute value of a number. Works with integers, floats, and LongInts.
-/// For `i64::MIN`, which overflows on negation, promotes to LongInt.
-pub fn builtin_abs(vm: &mut VM<'_, '_, impl ResourceTracker>, args: ArgValues) -> RunResult<Value> {
-    let value = args.get_one_arg("abs", vm.heap)?;
-    defer_drop!(value, vm);
-
-    match value {
-        Value::Int(n) => {
-            // Handle potential overflow for i64::MIN → promote to LongInt
-            if let Some(abs_val) = n.checked_abs() {
-                Ok(Value::Int(abs_val))
-            } else {
-                // i64::MIN.abs() overflows, promote to LongInt
-                let bi = BigInt::from(*n).abs();
-                Ok(LongInt::new(bi).into_value(vm.heap)?)
-            }
-        }
-        Value::Float(f) => Ok(Value::Float(f.abs())),
-        Value::Bool(b) => Ok(Value::Int(i64::from(*b))),
-        Value::Ref(id) => {
-            if let HeapData::LongInt(li) = vm.heap.get(*id) {
-                Ok(li.abs().into_value(vm.heap)?)
-            } else {
-                Err(SimpleException::new_msg(
-                    ExcType::TypeError,
-                    format!("bad operand type for abs(): '{}'", value.py_type(vm.heap)),
-                )
-                .into())
-            }
-        }
-        _ => Err(SimpleException::new_msg(
-            ExcType::TypeError,
-            format!("bad operand type for abs(): '{}'", value.py_type(vm.heap)),
-        )
-        .into()),
-    }
-}

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

@@ -1,30 +0,0 @@
-//! Implementation of the all() builtin function.
-
-use crate::{
-    args::ArgValues,
-    bytecode::VM,
-    defer_drop, defer_drop_mut,
-    exception_private::RunResult,
-    resource::ResourceTracker,
-    types::{MontyIter, PyTrait},
-    value::Value,
-};
-
-/// Implementation of the all() builtin function.
-///
-/// Returns True if all elements of the iterable are true (or if the iterable is empty).
-/// Short-circuits on the first falsy value.
-pub fn builtin_all(vm: &mut VM<'_, '_, impl ResourceTracker>, args: ArgValues) -> RunResult<Value> {
-    let iterable = args.get_one_arg("all", vm.heap)?;
-    let iter = MontyIter::new(iterable, vm)?;
-    defer_drop_mut!(iter, vm);
-
-    while let Some(item) = iter.for_next(vm)? {
-        defer_drop!(item, vm);
-        if !item.py_bool(vm) {
-            return Ok(Value::Bool(false));
-        }
-    }
-
-    Ok(Value::Bool(true))
-}

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

@@ -1,30 +0,0 @@
-//! Implementation of the any() builtin function.
-
-use crate::{
-    args::ArgValues,
-    bytecode::VM,
-    defer_drop, defer_drop_mut,
-    exception_private::RunResult,
-    resource::ResourceTracker,
-    types::{MontyIter, PyTrait},
-    value::Value,
-};
-
-/// Implementation of the any() builtin function.
-///
-/// Returns True if any element of the iterable is true.
-/// Returns False for an empty iterable. Short-circuits on the first truthy value.
-pub fn builtin_any(vm: &mut VM<'_, '_, impl ResourceTracker>, args: ArgValues) -> RunResult<Value> {
-    let iterable = args.get_one_arg("any", vm.heap)?;
-    let iter = MontyIter::new(iterable, vm)?;
-    defer_drop_mut!(iter, vm);
-
-    while let Some(item) = iter.for_next(vm)? {
-        defer_drop!(item, vm);
-        if item.py_bool(vm) {
-            return Ok(Value::Bool(true));
-        }
-    }
-
-    Ok(Value::Bool(false))
-}

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

@@ -1,59 +0,0 @@
-//! Implementation of the bin() builtin function.
-
-use num_bigint::BigInt;
-use num_traits::Signed;
-
-use crate::{
-    args::ArgValues,
-    bytecode::VM,
-    defer_drop,
-    exception_private::{ExcType, RunResult},
-    heap::HeapData,
-    resource::ResourceTracker,
-    types::{PyTrait, Str},
-    value::Value,
-};
-
-/// Implementation of the bin() builtin function.
-///
-/// Converts an integer to a binary string prefixed with '0b'.
-/// Supports both i64 and BigInt integers.
-pub fn builtin_bin(vm: &mut VM<'_, '_, impl ResourceTracker>, args: ArgValues) -> RunResult<Value> {
-    let value = args.get_one_arg("bin", vm.heap)?;
-    defer_drop!(value, vm);
-
-    match value {
-        Value::Int(n) => {
-            let abs_digits = format!("{:b}", n.unsigned_abs());
-            let prefix = if *n < 0 { "-0b" } else { "0b" };
-            let heap_id = vm
-                .heap
-                .allocate(HeapData::Str(Str::new(format!("{prefix}{abs_digits}"))))?;
-            Ok(Value::Ref(heap_id))
-        }
-        Value::Bool(b) => {
-            let s = if *b { "0b1" } else { "0b0" };
-            let heap_id = vm.heap.allocate(HeapData::Str(Str::new(s.to_string())))?;
-            Ok(Value::Ref(heap_id))
-        }
-        Value::Ref(id) => {
-            if let HeapData::LongInt(li) = vm.heap.get(*id) {
-                let bin_str = format_bigint_bin(li.inner());
-                let heap_id = vm.heap.allocate(HeapData::Str(Str::new(bin_str)))?;
-                Ok(Value::Ref(heap_id))
-            } else {
-                Err(ExcType::type_error_not_integer(value.py_type(vm.heap)))
-            }
-        }
-        _ => Err(ExcType::type_error_not_integer(value.py_type(vm.heap))),
-    }
-}
-
-/// Formats a BigInt as a binary string with '0b' prefix.
-fn format_bigint_bin(bi: &BigInt) -> String {
-    let is_negative = bi.is_negative();
-    let abs_bi = bi.abs();
-    let bin_digits = format!("{abs_bi:b}");
-    let prefix = if is_negative { "-0b" } else { "0b" };
-    format!("{prefix}{bin_digits}")
-}

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

@@ -1,46 +0,0 @@
-//! Implementation of the chr() builtin function.
-
-use crate::{
-    args::ArgValues,
-    bytecode::VM,
-    defer_drop,
-    exception_private::{ExcType, RunResult, SimpleException},
-    resource::ResourceTracker,
-    types::{PyTrait, str::allocate_char},
-    value::Value,
-};
-
-/// Implementation of the chr() builtin function.
-///
-/// Returns a string representing a character whose Unicode code point is the integer.
-/// The valid range for the argument is from 0 through 1,114,111 (0x10FFFF).
-pub fn builtin_chr(vm: &mut VM<'_, '_, impl ResourceTracker>, args: ArgValues) -> RunResult<Value> {
-    let value = args.get_one_arg("chr", vm.heap)?;
-    defer_drop!(value, vm);
-
-    match value {
-        Value::Int(n) => {
-            if *n < 0 || *n > 0x0010_FFFF {
-                Err(SimpleException::new_msg(ExcType::ValueError, "chr() arg not in range(0x110000)").into())
-            } else if let Some(c) = char::from_u32(u32::try_from(*n).expect("chr() range check failed")) {
-                Ok(allocate_char(c, vm.heap)?)
-            } else {
-                // This shouldn't happen for valid Unicode range, but handle it
-                Err(SimpleException::new_msg(ExcType::ValueError, "chr() arg not in range(0x110000)").into())
-            }
-        }
-        Value::Bool(b) => {
-            // bool is subclass of int
-            let c = if *b { '\x01' } else { '\x00' };
-            Ok(allocate_char(c, vm.heap)?)
-        }
-        _ => {
-            let type_name = value.py_type(vm.heap);
-            Err(SimpleException::new_msg(
-                ExcType::TypeError,
-                format!("an integer is required (got type {type_name})"),
-            )
-            .into())
-        }
-    }
-}

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

@@ -1,164 +0,0 @@
-//! Implementation of the divmod() builtin function.
-
-use num_bigint::BigInt;
-use num_integer::Integer;
-use smallvec::smallvec;
-
-use crate::{
-    args::ArgValues,
-    bytecode::VM,
-    defer_drop,
-    exception_private::{ExcType, RunResult, SimpleException},
-    heap::HeapData,
-    resource::{ResourceTracker, check_div_size},
-    types::{LongInt, PyTrait, allocate_tuple},
-    value::{Value, floor_divmod},
-};
-
-/// Implementation of the divmod() builtin function.
-///
-/// Returns a tuple (quotient, remainder) from integer division.
-/// Equivalent to (a // b, a % b).
-pub fn builtin_divmod(vm: &mut VM<'_, '_, impl ResourceTracker>, args: ArgValues) -> RunResult<Value> {
-    let (a, b) = args.get_two_args("divmod", vm.heap)?;
-    let a = super::round::normalize_bool_to_int(a);
-    let b = super::round::normalize_bool_to_int(b);
-    defer_drop!(a, vm);
-    defer_drop!(b, vm);
-    let heap = &mut *vm.heap;
-
-    match (a, b) {
-        (Value::Int(x), Value::Int(y)) => {
-            if *y == 0 {
-                Err(ExcType::divmod_by_zero())
-            } else if let Some((quot, rem)) = floor_divmod(*x, *y) {
-                Ok(allocate_tuple(smallvec![Value::Int(quot), Value::Int(rem)], heap)?)
-            } else {
-                // Overflow - promote to BigInt
-                check_div_size(64, heap.tracker())?;
-                let (quot, rem) = bigint_floor_divmod(&BigInt::from(*x), &BigInt::from(*y));
-                let quot_val = LongInt::new(quot).into_value(heap)?;
-                let rem_val = LongInt::new(rem).into_value(heap)?;
-                Ok(allocate_tuple(smallvec![quot_val, rem_val], heap)?)
-            }
-        }
-        (Value::Int(x), Value::Ref(id)) => {
-            if let HeapData::LongInt(li) = heap.get(*id) {
-                if li.is_zero() {
-                    Err(ExcType::divmod_by_zero())
-                } else {
-                    let x_bi = BigInt::from(*x);
-                    let (quot, rem) = bigint_floor_divmod(&x_bi, li.inner());
-                    let quot_val = LongInt::new(quot).into_value(heap)?;
-                    let rem_val = LongInt::new(rem).into_value(heap)?;
-                    Ok(allocate_tuple(smallvec![quot_val, rem_val], heap)?)
-                }
-            } else {
-                let a_type = a.py_type(heap);
-                let b_type = b.py_type(heap);
-                Err(SimpleException::new_msg(
-                    ExcType::TypeError,
-                    format!("unsupported operand type(s) for divmod(): '{a_type}' and '{b_type}'"),
-                )
-                .into())
-            }
-        }
-        (Value::Ref(id), Value::Int(y)) => {
-            if let HeapData::LongInt(li) = heap.get(*id) {
-                if *y == 0 {
-                    Err(ExcType::divmod_by_zero())
-                } else {
-                    let y_bi = BigInt::from(*y);
-                    let (quot, rem) = bigint_floor_divmod(li.inner(), &y_bi);
-                    let quot_val = LongInt::new(quot).into_value(heap)?;
-                    let rem_val = LongInt::new(rem).into_value(heap)?;
-                    Ok(allocate_tuple(smallvec![quot_val, rem_val], heap)?)
-                }
-            } else {
-                let a_type = a.py_type(heap);
-                let b_type = b.py_type(heap);
-                Err(SimpleException::new_msg(
-                    ExcType::TypeError,
-                    format!("unsupported operand type(s) for divmod(): '{a_type}' and '{b_type}'"),
-                )
-                .into())
-            }
-        }
-        (Value::Ref(id1), Value::Ref(id2)) => {
-            let x_bi = if let HeapData::LongInt(li) = heap.get(*id1) {
-                li.inner().clone()
-            } else {
-                let a_type = a.py_type(heap);
-                let b_type = b.py_type(heap);
-                return Err(SimpleException::new_msg(
-                    ExcType::TypeError,
-                    format!("unsupported operand type(s) for divmod(): '{a_type}' and '{b_type}'"),
-                )
-                .into());
-            };
-            if let HeapData::LongInt(li) = heap.get(*id2) {
-                if li.is_zero() {
-                    Err(ExcType::divmod_by_zero())
-                } else {
-                    let (quot, rem) = bigint_floor_divmod(&x_bi, li.inner());
-                    let quot_val = LongInt::new(quot).into_value(heap)?;
-                    let rem_val = LongInt::new(rem).into_value(heap)?;
-                    Ok(allocate_tuple(smallvec![quot_val, rem_val], heap)?)
-                }
-            } else {
-                let a_type = a.py_type(heap);
-                let b_type = b.py_type(heap);
-                Err(SimpleException::new_msg(
-                    ExcType::TypeError,
-                    format!("unsupported operand type(s) for divmod(): '{a_type}' and '{b_type}'"),
-                )
-                .into())
-            }
-        }
-        (Value::Float(x), Value::Float(y)) => {
-            if *y == 0.0 {
-                Err(ExcType::divmod_by_zero())
-            } else {
-                let quot = (x / y).floor();
-                let rem = x - quot * y;
-                Ok(allocate_tuple(smallvec![Value::Float(quot), Value::Float(rem)], heap)?)
-            }
-        }
-        (Value::Int(x), Value::Float(y)) => {
-            if *y == 0.0 {
-                Err(ExcType::divmod_by_zero())
-            } else {
-                let xf = *x as f64;
-                let quot = (xf / y).floor();
-                let rem = xf - quot * y;
-                Ok(allocate_tuple(smallvec![Value::Float(quot), Value::Float(rem)], heap)?)
-            }
-        }
-        (Value::Float(x), Value::Int(y)) => {
-            if *y == 0 {
-                Err(ExcType::divmod_by_zero())
-            } else {
-                let yf = *y as f64;
-                let quot = (x / yf).floor();
-                let rem = x - quot * yf;
-                Ok(allocate_tuple(smallvec![Value::Float(quot), Value::Float(rem)], heap)?)
-            }
-        }
-        _ => {
-            let a_type = a.py_type(heap);
-            let b_type = b.py_type(heap);
-            Err(SimpleException::new_msg(
-                ExcType::TypeError,
-                format!("unsupported operand type(s) for divmod(): '{a_type}' and '{b_type}'"),
-            )
-            .into())
-        }
-    }
-}
-
-/// Computes Python-style floor division and modulo for BigInts.
-///
-/// Uses `div_mod_floor` from num_integer for correct floor semantics.
-fn bigint_floor_divmod(a: &BigInt, b: &BigInt) -> (BigInt, BigInt) {
-    a.div_mod_floor(b)
-}

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

@@ -1,52 +0,0 @@
-//! Implementation of the enumerate() builtin function.
-
-use smallvec::smallvec;
-
-use crate::{
-    args::ArgValues,
-    bytecode::VM,
-    defer_drop, defer_drop_mut,
-    exception_private::{ExcType, RunResult, SimpleException},
-    heap::HeapData,
-    resource::ResourceTracker,
-    types::{List, MontyIter, PyTrait, allocate_tuple},
-    value::Value,
-};
-
-/// Implementation of the enumerate() builtin function.
-///
-/// Returns a list of (index, value) tuples.
-/// Note: In Python this returns an iterator, but we return a list for simplicity.
-pub fn builtin_enumerate(vm: &mut VM<'_, '_, impl ResourceTracker>, args: ArgValues) -> RunResult<Value> {
-    let (iterable, start) = args.get_one_two_args("enumerate", vm.heap)?;
-    let iter = MontyIter::new(iterable, vm)?;
-    defer_drop_mut!(iter, vm);
-    defer_drop!(start, vm);
-
-    // Get start index (default 0)
-    let mut index: i64 = match start {
-        Some(Value::Int(n)) => *n,
-        Some(Value::Bool(b)) => 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 => 0,
-    };
-
-    let mut result: Vec<Value> = Vec::new();
-
-    while let Some(item) = iter.for_next(vm)? {
-        // Create tuple (index, item)
-        let tuple_val = allocate_tuple(smallvec![Value::Int(index), item], vm.heap)?;
-        result.push(tuple_val);
-        index += 1;
-    }
-
-    let heap_id = vm.heap.allocate(HeapData::List(List::new(result)))?;
-    Ok(Value::Ref(heap_id))
-}

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

@@ -1,67 +0,0 @@
-//! Implementation of the filter() builtin function.
-//!
-//! This module provides the filter() builtin which filters elements from an iterable
-//! based on a predicate function. The implementation supports:
-//! - `None` as predicate (filters falsy values)
-//! - Builtin functions (len, abs, etc.)
-//! - Type constructors (int, str, float, etc.)
-//! - User-defined functions (via `vm.evaluate_function`)
-
-use crate::{
-    args::ArgValues,
-    bytecode::VM,
-    defer_drop, defer_drop_mut,
-    exception_private::RunResult,
-    heap::{HeapData, HeapGuard},
-    resource::ResourceTracker,
-    types::{List, MontyIter, PyTrait},
-    value::Value,
-};
-
-/// Implementation of the filter() builtin function.
-///
-/// Filters elements from an iterable based on a predicate function.
-/// If the predicate is None, filters out falsy values.
-///
-/// Note: In Python this returns an iterator, but we return a list for simplicity.
-///
-/// Examples:
-/// ```python
-/// filter(lambda x: x > 0, [-1, 0, 1, 2])  # [1, 2]
-/// filter(None, [0, 1, False, True, ''])   # [1, True]
-/// ```
-pub fn builtin_filter(vm: &mut VM<'_, '_, impl ResourceTracker>, args: ArgValues) -> RunResult<Value> {
-    let (function, iterable) = args.get_two_args("filter", vm.heap)?;
-    defer_drop!(function, vm);
-
-    let iter = MontyIter::new(iterable, vm)?;
-    defer_drop_mut!(iter, vm);
-
-    let out: Vec<Value> = Vec::new();
-    let mut out_guard = HeapGuard::new(out, vm);
-    let (out, vm) = out_guard.as_parts_mut();
-
-    while let Some(item) = iter.for_next(vm)? {
-        let mut item_guard = HeapGuard::new(item, vm);
-        let (item, vm) = item_guard.as_parts_mut();
-        let should_include = if let Value::None = function {
-            // No predicate - use truthiness of element
-            item.py_bool(vm)
-        } else {
-            // Clone for predicate call - the clone is consumed by evaluate_function
-            let item_for_predicate = item.clone_with_heap(vm);
-            let result = vm.evaluate_function("filter()", function, ArgValues::One(item_for_predicate))?;
-            let is_truthy = result.py_bool(vm);
-            result.drop_with_heap(vm);
-            is_truthy
-        };
-
-        if should_include {
-            out.push(item_guard.into_inner());
-        }
-    }
-
-    let (out, vm) = out_guard.into_parts();
-    let heap_id = vm.heap.allocate(HeapData::List(List::new(out)))?;
-    Ok(Value::Ref(heap_id))
-}