Function prod

crates/stdlib/src/math.rs:490–606

(args: ProdArgs, vm: &VirtualMachine)

    #[pyfunction]
    fn prod(args: ProdArgs, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
        use crate::vm::builtins::PyInt;

        let iter = args.iterable;
        let start = args.start;

        // Check if start is provided and what type it is (exact types only, not subclasses)
        let (mut obj_result, start_is_int, start_is_float) = match &start {
            OptionalArg::Present(s) => {
                let is_int = s.class().is(vm.ctx.types.int_type);
                let is_float = s.class().is(vm.ctx.types.float_type);
                (Some(s.clone()), is_int, is_float)
            }
            OptionalArg::Missing => (None, true, false), // Default is int 1
        };

        let mut item_iter = iter.iter(vm)?;

        // Integer fast path
        if start_is_int && !start_is_float {
            let mut int_result: i64 = match &start {
                OptionalArg::Present(s) => {
                    if let Some(i) = s.downcast_ref::<PyInt>() {
                        match i.as_bigint().try_into() {
                            Ok(v) => v,
                            Err(_) => {
                                // Start overflows i64, fall through to generic path
                                obj_result = Some(s.clone());
                                i64::MAX // Will be ignored
                            }
                        }
                    } else {
                        1
                    }
                }
                OptionalArg::Missing => 1,
            };

            if obj_result.is_none() {
                loop {
                    let item = match item_iter.next() {
                        Some(r) => r?,
                        None => return Ok(vm.ctx.new_int(int_result).into()),
                    };

                    // Only use fast path for exact int type (not subclasses)
                    if item.class().is(vm.ctx.types.int_type)
                        && let Some(int_item) = item.downcast_ref::<PyInt>()
                        && let Ok(b) = int_item.as_bigint().try_into() as Result<i64, _>
                        && let Some(product) = int_result.checked_mul(b)
                    {
                        int_result = product;
                        continue;
                    }

                    // Overflow or non-int: restore to PyObject and continue
                    obj_result = Some(vm.ctx.new_int(int_result).into());
                    let temp = vm._mul(obj_result.as_ref().unwrap(), &item)?;