Method extract_elements_with

crates/vm/src/vm/mod.rs:1825–1866

(&self, value: &PyObject, func: F)

    }

    pub fn extract_elements_with<T, F>(&self, value: &PyObject, func: F) -> PyResult<Vec<T>>
    where
        F: Fn(PyObjectRef) -> PyResult<T>,
    {
        // Type-specific fast paths corresponding to _list_extend() in CPython
        // Objects/listobject.c. Each branch takes an atomic snapshot to avoid
        // race conditions from concurrent mutation (no GIL).
        let cls = value.class();
        let list_borrow;
        let slice = if cls.is(self.ctx.types.tuple_type) {
            value.downcast_ref::<PyTuple>().unwrap().as_slice()
        } else if cls.is(self.ctx.types.list_type) {
            list_borrow = value.downcast_ref::<PyList>().unwrap().borrow_vec();
            &list_borrow
        } else if cls.is(self.ctx.types.dict_type) {
            let keys = value.downcast_ref::<PyDict>().unwrap().keys_vec();
            return keys.into_iter().map(func).collect();
        } else if cls.is(self.ctx.types.dict_keys_type) {
            let keys = value.downcast_ref::<PyDictKeys>().unwrap().dict.keys_vec();
            return keys.into_iter().map(func).collect();
        } else if cls.is(self.ctx.types.dict_values_type) {
            let values = value
                .downcast_ref::<PyDictValues>()
                .unwrap()
                .dict
                .values_vec();
            return values.into_iter().map(func).collect();
        } else if cls.is(self.ctx.types.dict_items_type) {
            let items = value
                .downcast_ref::<PyDictItems>()
                .unwrap()
                .dict
                .items_vec();
            return items
                .into_iter()
                .map(|(k, v)| func(self.ctx.new_tuple(vec![k, v]).into()))
                .collect();
        } else {
            return self.map_py_iter(value, func);
        };
        slice.iter().map(|obj| func(obj.clone())).collect()
    }

    pub fn map_iterable_object<F, R>(&self, obj: &PyObject, mut f: F) -> PyResult<PyResult<Vec<R>>>
    where