diff --git a/src/shell/helper.rs b/src/shell/helper.rs
index 8d75f18b3..a5afcbe28 100644
--- a/src/shell/helper.rs
+++ b/src/shell/helper.rs
@@ -1,6 +1,6 @@
 use rustpython_vm::builtins::{PyDictRef, PyStrRef};
 use rustpython_vm::VirtualMachine;
-use rustpython_vm::{ArgIterable, PyResult, TryFromObject};
+use rustpython_vm::{function::ArgIterable, PyResult, TryFromObject};
 
 pub struct ShellHelper<'vm> {
     vm: &'vm VirtualMachine,
diff --git a/vm/src/anystr.rs b/vm/src/anystr.rs
index 43e89a6e1..0b6cc345a 100644
--- a/vm/src/anystr.rs
+++ b/vm/src/anystr.rs
@@ -2,7 +2,7 @@ use crate::builtins::int::PyIntRef;
 use crate::cformat::CFormatString;
 use crate::function::{single_or_tuple_any, OptionalOption};
 use crate::vm::VirtualMachine;
-use crate::{PyIterator, PyObjectRef, PyResult, TryFromObject, TypeProtocol};
+use crate::{function::PyIterator, PyObjectRef, PyResult, TryFromObject, TypeProtocol};
 use num_traits::{cast::ToPrimitive, sign::Signed};
 use std::str::FromStr;
 
diff --git a/vm/src/builtins/bytearray.rs b/vm/src/builtins/bytearray.rs
index f2a78a56d..b5378b87a 100644
--- a/vm/src/builtins/bytearray.rs
+++ b/vm/src/builtins/bytearray.rs
@@ -26,8 +26,8 @@ use crate::slots::{
 use crate::utils::Either;
 use crate::vm::VirtualMachine;
 use crate::{
-    ArgIterable, IdProtocol, IntoPyObject, PyClassDef, PyClassImpl, PyComparisonValue, PyContext,
-    PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol,
+    function::ArgIterable, IdProtocol, IntoPyObject, PyClassDef, PyClassImpl, PyComparisonValue,
+    PyContext, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol,
 };
 use bstr::ByteSlice;
 use crossbeam_utils::atomic::AtomicCell;
diff --git a/vm/src/builtins/bytes.rs b/vm/src/builtins/bytes.rs
index 1cb4d5b32..ba2c689b9 100644
--- a/vm/src/builtins/bytes.rs
+++ b/vm/src/builtins/bytes.rs
@@ -18,8 +18,8 @@ use crate::slots::{
 use crate::utils::Either;
 use crate::vm::VirtualMachine;
 use crate::{
-    ArgIterable, IdProtocol, IntoPyObject, IntoPyResult, PyClassImpl, PyComparisonValue, PyContext,
-    PyObjectRef, PyRef, PyResult, PyValue, TryFromBorrowedObject, TypeProtocol,
+    function::ArgIterable, IdProtocol, IntoPyObject, IntoPyResult, PyClassImpl, PyComparisonValue,
+    PyContext, PyObjectRef, PyRef, PyResult, PyValue, TryFromBorrowedObject, TypeProtocol,
 };
 use bstr::ByteSlice;
 use crossbeam_utils::atomic::AtomicCell;
diff --git a/vm/src/builtins/dict.rs b/vm/src/builtins/dict.rs
index 90f06d836..8d5ae4785 100644
--- a/vm/src/builtins/dict.rs
+++ b/vm/src/builtins/dict.rs
@@ -13,9 +13,9 @@ use crate::iterator;
 use crate::slots::{Comparable, Hashable, Iterable, PyComparisonOp, PyIter, Unhashable};
 use crate::vm::{ReprGuard, VirtualMachine};
 use crate::{
-    ArgIterable, IdProtocol, IntoPyObject, ItemProtocol, PyArithmaticValue::*, PyAttributes,
-    PyClassDef, PyClassImpl, PyComparisonValue, PyContext, PyObjectRef, PyRef, PyResult, PyValue,
-    TryFromObject, TypeProtocol,
+    function::ArgIterable, IdProtocol, IntoPyObject, ItemProtocol, PyArithmaticValue::*,
+    PyAttributes, PyClassDef, PyClassImpl, PyComparisonValue, PyContext, PyObjectRef, PyRef,
+    PyResult, PyValue, TryFromObject, TypeProtocol,
 };
 
 pub type DictContentType = dictdatatype::Dict;
diff --git a/vm/src/builtins/iter.rs b/vm/src/builtins/iter.rs
index 619df3b59..95f2f53af 100644
--- a/vm/src/builtins/iter.rs
+++ b/vm/src/builtins/iter.rs
@@ -9,8 +9,8 @@ use super::{int, PyInt};
 use crate::slots::PyIter;
 use crate::vm::VirtualMachine;
 use crate::{
-    ArgCallable, ItemProtocol, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue,
-    TypeProtocol,
+    function::ArgCallable, ItemProtocol, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult,
+    PyValue, TypeProtocol,
 };
 
 /// Marks status of iterator.
diff --git a/vm/src/builtins/list.rs b/vm/src/builtins/list.rs
index 301ba319f..f2312d32e 100644
--- a/vm/src/builtins/list.rs
+++ b/vm/src/builtins/list.rs
@@ -24,8 +24,8 @@ use crate::slots::{Comparable, Hashable, Iterable, PyComparisonOp, PyIter, Unhas
 use crate::utils::Either;
 use crate::vm::{ReprGuard, VirtualMachine};
 use crate::{
-    ArgIterable, PyClassDef, PyClassImpl, PyComparisonValue, PyContext, PyObjectRef, PyRef,
-    PyResult, PyValue, TryFromObject, TypeProtocol,
+    function::ArgIterable, PyClassDef, PyClassImpl, PyComparisonValue, PyContext, PyObjectRef,
+    PyRef, PyResult, PyValue, TryFromObject, TypeProtocol,
 };
 
 /// Built-in mutable sequence.
diff --git a/vm/src/builtins/make_module.rs b/vm/src/builtins/make_module.rs
index a73780595..777220612 100644
--- a/vm/src/builtins/make_module.rs
+++ b/vm/src/builtins/make_module.rs
@@ -32,11 +32,11 @@ mod decl {
     use crate::slots::PyComparisonOp;
     use crate::utils::Either;
     use crate::vm::VirtualMachine;
-    use crate::{py_io, sysmodule};
     use crate::{
-        ArgCallable, ArgIterable, IdProtocol, ItemProtocol, PyArithmaticValue, PyClassImpl,
-        PyObjectRef, PyResult, PyValue, TryFromObject, TypeProtocol,
+        function::ArgCallable, function::ArgIterable, IdProtocol, ItemProtocol, PyArithmaticValue,
+        PyClassImpl, PyObjectRef, PyResult, PyValue, TryFromObject, TypeProtocol,
     };
+    use crate::{py_io, sysmodule};
     use num_traits::{Signed, Zero};
 
     #[pyfunction]
diff --git a/vm/src/builtins/pystr.rs b/vm/src/builtins/pystr.rs
index 8876936d2..9bc687a6d 100644
--- a/vm/src/builtins/pystr.rs
+++ b/vm/src/builtins/pystr.rs
@@ -15,7 +15,7 @@ use crate::slots::{Comparable, Hashable, Iterable, PyComparisonOp, PyIter, SlotC
 use crate::utils::Either;
 use crate::VirtualMachine;
 use crate::{
-    ArgIterable, IdProtocol, IntoPyObject, ItemProtocol, PyClassDef, PyClassImpl,
+    function::ArgIterable, IdProtocol, IntoPyObject, ItemProtocol, PyClassDef, PyClassImpl,
     PyComparisonValue, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TryIntoRef, TypeProtocol,
 };
 use bstr::ByteSlice;
diff --git a/vm/src/builtins/set.rs b/vm/src/builtins/set.rs
index 59667af3a..5dd234c7a 100644
--- a/vm/src/builtins/set.rs
+++ b/vm/src/builtins/set.rs
@@ -12,8 +12,8 @@ use crate::slots::{
 };
 use crate::vm::{ReprGuard, VirtualMachine};
 use crate::{
-    ArgIterable, IdProtocol, PyClassImpl, PyComparisonValue, PyContext, PyObjectRef, PyRef,
-    PyResult, PyValue, TryFromObject, TypeProtocol,
+    function::ArgIterable, IdProtocol, PyClassImpl, PyComparisonValue, PyContext, PyObjectRef,
+    PyRef, PyResult, PyValue, TryFromObject, TypeProtocol,
 };
 use crossbeam_utils::atomic::AtomicCell;
 use std::fmt;
diff --git a/vm/src/bytesinner.rs b/vm/src/bytesinner.rs
index c082d1956..fb0fbdc44 100644
--- a/vm/src/bytesinner.rs
+++ b/vm/src/bytesinner.rs
@@ -11,7 +11,7 @@ use crate::slots::PyComparisonOp;
 use crate::utils::Either;
 use crate::vm::VirtualMachine;
 use crate::{
-    ArgIterable, IdProtocol, PyComparisonValue, PyObjectRef, PyResult, PyValue,
+    function::ArgIterable, IdProtocol, PyComparisonValue, PyObjectRef, PyResult, PyValue,
     TryFromBorrowedObject,
 };
 use bstr::ByteSlice;
diff --git a/vm/src/exceptions.rs b/vm/src/exceptions.rs
index 0d2c1d544..4c5d8a4cb 100644
--- a/vm/src/exceptions.rs
+++ b/vm/src/exceptions.rs
@@ -11,8 +11,8 @@ use crate::types::create_type_with_slots;
 use crate::StaticType;
 use crate::VirtualMachine;
 use crate::{
-    ArgIterable, IdProtocol, IntoPyObject, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult,
-    PyValue, TryFromObject, TypeProtocol,
+    function::ArgIterable, IdProtocol, IntoPyObject, PyClassImpl, PyContext, PyObjectRef, PyRef,
+    PyResult, PyValue, TryFromObject, TypeProtocol,
 };
 
 use crossbeam_utils::atomic::AtomicCell;
diff --git a/vm/src/function.rs b/vm/src/function.rs
index 8ef464be1..c9fefc835 100644
--- a/vm/src/function.rs
+++ b/vm/src/function.rs
@@ -1,3 +1,5 @@
+mod argument;
+
 use self::OptionalArg::*;
 use crate::builtins::pytype::PyTypeRef;
 use crate::builtins::tuple::PyTupleRef;
@@ -13,6 +15,8 @@ use result_like::impl_option_like;
 use std::marker::PhantomData;
 use std::ops::RangeInclusive;
 
+pub use argument::{ArgCallable, ArgIterable, PyIterator};
+
 pub trait IntoFuncArgs: Sized {
     fn into_args(self, vm: &VirtualMachine) -> FuncArgs;
     fn into_method_args(self, obj: PyObjectRef, vm: &VirtualMachine) -> FuncArgs {
diff --git a/vm/src/function/argument.rs b/vm/src/function/argument.rs
new file mode 100644
index 000000000..8b7a1d1ad
--- /dev/null
+++ b/vm/src/function/argument.rs
@@ -0,0 +1,113 @@
+use super::IntoFuncArgs;
+use crate::builtins::iter::PySequenceIterator;
+use crate::{
+    iterator, PyObjectRef, PyResult, PyValue, TryFromObject, TypeProtocol, VirtualMachine,
+};
+use std::marker::PhantomData;
+
+#[derive(Clone, Debug)]
+pub struct ArgCallable {
+    obj: PyObjectRef,
+}
+
+impl ArgCallable {
+    #[inline]
+    pub fn invoke(&self, args: impl IntoFuncArgs, vm: &VirtualMachine) -> PyResult {
+        vm.invoke(&self.obj, args)
+    }
+
+    #[inline]
+    pub fn into_object(self) -> PyObjectRef {
+        self.obj
+    }
+}
+
+impl TryFromObject for ArgCallable {
+    fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
+        if vm.is_callable(&obj) {
+            Ok(ArgCallable { obj })
+        } else {
+            Err(vm.new_type_error(format!("'{}' object is not callable", obj.class().name())))
+        }
+    }
+}
+
+/// An iterable Python object.
+///
+/// `ArgIterable` implements `FromArgs` so that a built-in function can accept
+/// an object that is required to conform to the Python iterator protocol.
+///
+/// ArgIterable can optionally perform type checking and conversions on iterated
+/// objects using a generic type parameter that implements `TryFromObject`.
+pub struct ArgIterable<T = PyObjectRef> {
+    iterable: PyObjectRef,
+    iterfn: Option<crate::slots::IterFunc>,
+    _item: PhantomData<T>,
+}
+
+impl<T> ArgIterable<T> {
+    /// Returns an iterator over this sequence of objects.
+    ///
+    /// This operation may fail if an exception is raised while invoking the
+    /// `__iter__` method of the iterable object.
+    pub fn iter<'a>(&self, vm: &'a VirtualMachine) -> PyResult<PyIterator<'a, T>> {
+        let iter_obj = match self.iterfn {
+            Some(f) => f(self.iterable.clone(), vm)?,
+            None => PySequenceIterator::new(self.iterable.clone()).into_object(vm),
+        };
+
+        let length_hint = iterator::length_hint(vm, iter_obj.clone())?;
+
+        Ok(PyIterator {
+            vm,
+            obj: iter_obj,
+            length_hint,
+            _item: PhantomData,
+        })
+    }
+}
+
+impl<T> TryFromObject for ArgIterable<T>
+where
+    T: TryFromObject,
+{
+    fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
+        let iterfn;
+        {
+            let cls = obj.class();
+            iterfn = cls.mro_find_map(|x| x.slots.iter.load());
+            if iterfn.is_none() && !cls.has_attr("__getitem__") {
+                return Err(vm.new_type_error(format!("'{}' object is not iterable", cls.name())));
+            }
+        }
+        Ok(ArgIterable {
+            iterable: obj,
+            iterfn,
+            _item: PhantomData,
+        })
+    }
+}
+
+pub struct PyIterator<'a, T> {
+    vm: &'a VirtualMachine,
+    obj: PyObjectRef,
+    length_hint: Option<usize>,
+    _item: PhantomData<T>,
+}
+
+impl<'a, T> Iterator for PyIterator<'a, T>
+where
+    T: TryFromObject,
+{
+    type Item = PyResult<T>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        iterator::get_next_object(self.vm, &self.obj)
+            .transpose()
+            .map(|x| x.and_then(|obj| T::try_from_object(self.vm, obj)))
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (self.length_hint.unwrap_or(0), self.length_hint)
+    }
+}
diff --git a/vm/src/pyobject.rs b/vm/src/pyobject.rs
index 27d1ce165..3b8612c1f 100644
--- a/vm/src/pyobject.rs
+++ b/vm/src/pyobject.rs
@@ -4,7 +4,6 @@ use num_traits::ToPrimitive;
 use std::any::Any;
 use std::collections::HashMap;
 use std::fmt;
-use std::marker::PhantomData;
 use std::ops::Deref;
 
 use crate::builtins::builtinfunc::PyNativeFuncDef;
@@ -18,7 +17,6 @@ use crate::builtins::float::PyFloat;
 use crate::builtins::function::PyBoundMethod;
 use crate::builtins::getset::{IntoPyGetterFunc, IntoPySetterFunc, PyGetSet};
 use crate::builtins::int::{PyInt, PyIntRef};
-use crate::builtins::iter::PySequenceIterator;
 use crate::builtins::list::PyList;
 use crate::builtins::namespace::PyNamespace;
 use crate::builtins::object;
@@ -35,7 +33,6 @@ use crate::common::static_cell;
 use crate::dictdatatype::Dict;
 use crate::exceptions::{self, PyBaseExceptionRef};
 use crate::function::{IntoFuncArgs, IntoPyNativeFunc};
-use crate::iterator;
 pub use crate::pyobjectrc::{PyObject, PyObjectRef, PyObjectWeak, PyRef, PyWeakRef};
 use crate::slots::{PyTpFlags, PyTypeSlots};
 use crate::types::{create_type_with_slots, TypeZoo};
@@ -533,33 +530,6 @@ impl<T: PyValue> TryIntoRef<T> for PyRefExact<T> {
     }
 }
 
-#[derive(Clone, Debug)]
-pub struct ArgCallable {
-    obj: PyObjectRef,
-}
-
-impl ArgCallable {
-    #[inline]
-    pub fn invoke(&self, args: impl IntoFuncArgs, vm: &VirtualMachine) -> PyResult {
-        vm.invoke(&self.obj, args)
-    }
-
-    #[inline]
-    pub fn into_object(self) -> PyObjectRef {
-        self.obj
-    }
-}
-
-impl TryFromObject for ArgCallable {
-    fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
-        if vm.is_callable(&obj) {
-            Ok(ArgCallable { obj })
-        } else {
-            Err(vm.new_type_error(format!("'{}' object is not callable", obj.class().name())))
-        }
-    }
-}
-
 pub trait IdProtocol {
     fn get_id(&self) -> usize;
     fn is<T>(&self, other: &T) -> bool
@@ -725,86 +695,6 @@ where
     }
 }
 
-/// An iterable Python object.
-///
-/// `ArgIterable` implements `FromArgs` so that a built-in function can accept
-/// an object that is required to conform to the Python iterator protocol.
-///
-/// ArgIterable can optionally perform type checking and conversions on iterated
-/// objects using a generic type parameter that implements `TryFromObject`.
-pub struct ArgIterable<T = PyObjectRef> {
-    iterable: PyObjectRef,
-    iterfn: Option<crate::slots::IterFunc>,
-    _item: PhantomData<T>,
-}
-
-impl<T> ArgIterable<T> {
-    /// Returns an iterator over this sequence of objects.
-    ///
-    /// This operation may fail if an exception is raised while invoking the
-    /// `__iter__` method of the iterable object.
-    pub fn iter<'a>(&self, vm: &'a VirtualMachine) -> PyResult<PyIterator<'a, T>> {
-        let iter_obj = match self.iterfn {
-            Some(f) => f(self.iterable.clone(), vm)?,
-            None => PySequenceIterator::new(self.iterable.clone()).into_object(vm),
-        };
-
-        let length_hint = iterator::length_hint(vm, iter_obj.clone())?;
-
-        Ok(PyIterator {
-            vm,
-            obj: iter_obj,
-            length_hint,
-            _item: PhantomData,
-        })
-    }
-}
-
-impl<T> TryFromObject for ArgIterable<T>
-where
-    T: TryFromObject,
-{
-    fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
-        let iterfn;
-        {
-            let cls = obj.class();
-            iterfn = cls.mro_find_map(|x| x.slots.iter.load());
-            if iterfn.is_none() && !cls.has_attr("__getitem__") {
-                return Err(vm.new_type_error(format!("'{}' object is not iterable", cls.name())));
-            }
-        }
-        Ok(ArgIterable {
-            iterable: obj,
-            iterfn,
-            _item: PhantomData,
-        })
-    }
-}
-
-pub struct PyIterator<'a, T> {
-    vm: &'a VirtualMachine,
-    obj: PyObjectRef,
-    length_hint: Option<usize>,
-    _item: PhantomData<T>,
-}
-
-impl<'a, T> Iterator for PyIterator<'a, T>
-where
-    T: TryFromObject,
-{
-    type Item = PyResult<T>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        iterator::get_next_object(self.vm, &self.obj)
-            .transpose()
-            .map(|x| x.and_then(|obj| T::try_from_object(self.vm, obj)))
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (self.length_hint.unwrap_or(0), self.length_hint)
-    }
-}
-
 impl TryFromObject for PyObjectRef {
     #[inline]
     fn try_from_object(_vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
@@ -919,13 +809,6 @@ impl<T: PyObjectPayload> IntoPyObject for PyRef<T> {
     }
 }
 
-impl IntoPyObject for ArgCallable {
-    #[inline]
-    fn into_pyobject(self, _vm: &VirtualMachine) -> PyObjectRef {
-        self.into_object()
-    }
-}
-
 impl IntoPyObject for PyObjectRef {
     #[inline]
     fn into_pyobject(self, _vm: &VirtualMachine) -> PyObjectRef {
diff --git a/vm/src/stdlib/array.rs b/vm/src/stdlib/array.rs
index 3da6020d3..6baa015a7 100644
--- a/vm/src/stdlib/array.rs
+++ b/vm/src/stdlib/array.rs
@@ -17,11 +17,11 @@ mod array {
             PyStr, PyStrRef, PyTypeRef,
         },
         byteslike::ArgBytesLike,
-        function::OptionalArg,
+        function::{ArgIterable, OptionalArg},
         sliceable::{saturate_index, PySliceableSequence, PySliceableSequenceMut, SequenceIndex},
         slots::{AsBuffer, Comparable, Iterable, PyComparisonOp, PyIter, SlotConstructor},
-        ArgIterable, IdProtocol, IntoPyObject, IntoPyResult, PyComparisonValue, PyObjectRef, PyRef,
-        PyResult, PyValue, StaticType, TryFromObject, TypeProtocol, VirtualMachine,
+        IdProtocol, IntoPyObject, IntoPyResult, PyComparisonValue, PyObjectRef, PyRef, PyResult,
+        PyValue, StaticType, TryFromObject, TypeProtocol, VirtualMachine,
     };
     use crossbeam_utils::atomic::AtomicCell;
     use itertools::Itertools;
diff --git a/vm/src/stdlib/csv.rs b/vm/src/stdlib/csv.rs
index b7345599b..85a08c64e 100644
--- a/vm/src/stdlib/csv.rs
+++ b/vm/src/stdlib/csv.rs
@@ -1,12 +1,12 @@
 use crate::common::lock::PyMutex;
 use crate::{
     builtins::{PyStr, PyStrRef, PyTypeRef},
-    function::{ArgumentError, FromArgs, FuncArgs},
+    function::{ArgIterable, ArgumentError, FromArgs, FuncArgs},
     iterator,
     slots::PyIter,
     types::create_simple_type,
-    ArgIterable, PyClassImpl, PyObjectRef, PyRef, PyResult, PyValue, StaticType, TryFromObject,
-    TypeProtocol, VirtualMachine,
+    PyClassImpl, PyObjectRef, PyRef, PyResult, PyValue, StaticType, TryFromObject, TypeProtocol,
+    VirtualMachine,
 };
 use itertools::{self, Itertools};
 use std::fmt;
diff --git a/vm/src/stdlib/io.rs b/vm/src/stdlib/io.rs
index f71bad417..8e800e1fa 100644
--- a/vm/src/stdlib/io.rs
+++ b/vm/src/stdlib/io.rs
@@ -95,8 +95,8 @@ mod _io {
     use crate::utils::Either;
     use crate::vm::{ReprGuard, VirtualMachine};
     use crate::{
-        ArgIterable, IdProtocol, IntoPyObject, PyContext, PyObjectRef, PyRef, PyResult, PyValue,
-        StaticType, TryFromObject, TypeProtocol,
+        function::ArgIterable, IdProtocol, IntoPyObject, PyContext, PyObjectRef, PyRef, PyResult,
+        PyValue, StaticType, TryFromObject, TypeProtocol,
     };
 
     #[allow(clippy::let_and_return)]
diff --git a/vm/src/stdlib/itertools.rs b/vm/src/stdlib/itertools.rs
index 0e36ef5f3..95cd5433d 100644
--- a/vm/src/stdlib/itertools.rs
+++ b/vm/src/stdlib/itertools.rs
@@ -8,11 +8,11 @@ mod decl {
     };
     use crate::{
         builtins::{int, PyInt, PyIntRef, PyTupleRef, PyTypeRef},
-        function::{Args, FuncArgs, OptionalArg, OptionalOption},
+        function::{ArgCallable, Args, FuncArgs, OptionalArg, OptionalOption},
         iterator::{call_next, get_iter, get_next_object},
         slots::{PyIter, SlotConstructor},
-        ArgCallable, IdProtocol, IntoPyObject, PyObjectRef, PyRef, PyResult, PyValue, PyWeakRef,
-        StaticType, TypeProtocol, VirtualMachine,
+        IdProtocol, IntoPyObject, PyObjectRef, PyRef, PyResult, PyValue, PyWeakRef, StaticType,
+        TypeProtocol, VirtualMachine,
     };
     use crossbeam_utils::atomic::AtomicCell;
     use num_bigint::BigInt;
diff --git a/vm/src/stdlib/math.rs b/vm/src/stdlib/math.rs
index a966385f0..6da60ff8e 100644
--- a/vm/src/stdlib/math.rs
+++ b/vm/src/stdlib/math.rs
@@ -5,9 +5,9 @@
 
 use crate::{
     builtins::{try_bigint_to_f64, try_f64_to_bigint, IntoPyFloat, PyFloatRef, PyInt, PyIntRef},
-    function::{Args, OptionalArg},
+    function::{ArgIterable, Args, OptionalArg},
     utils::Either,
-    ArgIterable, PyObjectRef, PyResult, PySequence, TypeProtocol, VirtualMachine,
+    PyObjectRef, PyResult, PySequence, TypeProtocol, VirtualMachine,
 };
 use num_bigint::BigInt;
 use num_traits::{One, Signed, Zero};
diff --git a/vm/src/stdlib/os.rs b/vm/src/stdlib/os.rs
index 94c588f91..eaf702e71 100644
--- a/vm/src/stdlib/os.rs
+++ b/vm/src/stdlib/os.rs
@@ -2931,7 +2931,10 @@ mod posix {
     // cfg from nix
     #[cfg(not(any(target_os = "ios", target_os = "macos", target_os = "redox")))]
     #[pyfunction]
-    fn setgroups(group_ids: crate::ArgIterable<u32>, vm: &VirtualMachine) -> PyResult<()> {
+    fn setgroups(
+        group_ids: crate::function::ArgIterable<u32>,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
         let gids = group_ids
             .iter(vm)?
             .map(|entry| match entry {
@@ -2978,13 +2981,13 @@ mod posix {
         #[pyarg(positional)]
         path: PyPathLike,
         #[pyarg(positional)]
-        args: crate::ArgIterable<PyPathLike>,
+        args: crate::function::ArgIterable<PyPathLike>,
         #[pyarg(positional)]
         env: crate::builtins::dict::PyMapping,
         #[pyarg(named, default)]
-        file_actions: Option<crate::ArgIterable<PyTupleRef>>,
+        file_actions: Option<crate::function::ArgIterable<PyTupleRef>>,
         #[pyarg(named, default)]
-        setsigdef: Option<crate::ArgIterable<i32>>,
+        setsigdef: Option<crate::function::ArgIterable<i32>>,
     }
 
     #[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "macos"))]
diff --git a/vm/src/stdlib/sre.rs b/vm/src/stdlib/sre.rs
index d8d153a91..8c28a43f4 100644
--- a/vm/src/stdlib/sre.rs
+++ b/vm/src/stdlib/sre.rs
@@ -9,10 +9,10 @@ mod _sre {
             PyTypeRef,
         },
         common::hash::PyHash,
-        function::{Args, OptionalArg},
+        function::{ArgCallable, Args, OptionalArg},
         slots::{Comparable, Hashable},
-        ArgCallable, IntoPyObject, ItemProtocol, PyComparisonValue, PyObjectRef, PyRef, PyResult,
-        PyValue, StaticType, TryFromBorrowedObject, TryFromObject, VirtualMachine,
+        IntoPyObject, ItemProtocol, PyComparisonValue, PyObjectRef, PyRef, PyResult, PyValue,
+        StaticType, TryFromBorrowedObject, TryFromObject, VirtualMachine,
     };
     use core::str;
     use crossbeam_utils::atomic::AtomicCell;
diff --git a/vm/src/stdlib/ssl.rs b/vm/src/stdlib/ssl.rs
index 1149862f1..9595dcba7 100644
--- a/vm/src/stdlib/ssl.rs
+++ b/vm/src/stdlib/ssl.rs
@@ -4,12 +4,12 @@ use crate::{
     builtins::{pytype, weakref::PyWeak, PyStrRef, PyTypeRef},
     byteslike::{ArgBytesLike, ArgMemoryBuffer, ArgStrOrBytesLike},
     exceptions::{create_exception_type, IntoPyException, PyBaseExceptionRef},
-    function::OptionalArg,
+    function::{ArgCallable, OptionalArg},
     slots::SlotConstructor,
     stdlib::os::PyPathLike,
     utils::{Either, ToCString},
-    ArgCallable, IntoPyObject, ItemProtocol, PyClassImpl, PyObjectRef, PyRef, PyResult, PyValue,
-    StaticType, VirtualMachine,
+    IntoPyObject, ItemProtocol, PyClassImpl, PyObjectRef, PyRef, PyResult, PyValue, StaticType,
+    VirtualMachine,
 };
 use crossbeam_utils::atomic::AtomicCell;
 use foreign_types_shared::{ForeignType, ForeignTypeRef};
diff --git a/vm/src/stdlib/thread.rs b/vm/src/stdlib/thread.rs
index e809259db..1cfa3e8a5 100644
--- a/vm/src/stdlib/thread.rs
+++ b/vm/src/stdlib/thread.rs
@@ -3,12 +3,12 @@
 use crate::{
     builtins::{PyDictRef, PyStrRef, PyTupleRef, PyTypeRef},
     exceptions::{self, IntoPyException},
-    function::{FuncArgs, KwArgs, OptionalArg},
+    function::{ArgCallable, FuncArgs, KwArgs, OptionalArg},
     py_io,
     slots::{SlotGetattro, SlotSetattro},
     utils::Either,
-    ArgCallable, IdProtocol, ItemProtocol, PyClassImpl, PyObjectRef, PyRef, PyResult, PyValue,
-    StaticType, TypeProtocol, VirtualMachine,
+    IdProtocol, ItemProtocol, PyClassImpl, PyObjectRef, PyRef, PyResult, PyValue, StaticType,
+    TypeProtocol, VirtualMachine,
 };
 use parking_lot::{
     lock_api::{RawMutex as RawMutexT, RawMutexTimed, RawReentrantMutex},
diff --git a/wasm/lib/src/browser_module.rs b/wasm/lib/src/browser_module.rs
index 69734680a..ba04648c0 100644
--- a/wasm/lib/src/browser_module.rs
+++ b/wasm/lib/src/browser_module.rs
@@ -8,7 +8,8 @@ use rustpython_vm::function::OptionalArg;
 use rustpython_vm::import::import_file;
 use rustpython_vm::VirtualMachine;
 use rustpython_vm::{
-    ArgCallable, IntoPyObject, PyClassImpl, PyObject, PyObjectRef, PyResult, PyValue, StaticType,
+    function::ArgCallable, IntoPyObject, PyClassImpl, PyObject, PyObjectRef, PyResult, PyValue,
+    StaticType,
 };
 
 use crate::{convert, js_module::PyPromise, vm_class::weak_vm, wasm_builtins::window};
diff --git a/wasm/lib/src/js_module.rs b/wasm/lib/src/js_module.rs
index ccde306e7..b63fd87d8 100644
--- a/wasm/lib/src/js_module.rs
+++ b/wasm/lib/src/js_module.rs
@@ -13,8 +13,8 @@ use rustpython_vm::slots::PyIter;
 use rustpython_vm::types::create_simple_type;
 use rustpython_vm::VirtualMachine;
 use rustpython_vm::{
-    ArgCallable, IntoPyObject, PyClassImpl, PyObjectRef, PyRef, PyResult, PyValue, StaticType,
-    TryFromObject,
+    function::ArgCallable, IntoPyObject, PyClassImpl, PyObjectRef, PyRef, PyResult, PyValue,
+    StaticType, TryFromObject,
 };
 
 #[wasm_bindgen(inline_js = "
@@ -499,9 +499,16 @@ impl PyPromise {
 
                 Ok(PyPromise::from_future(ret_future))
             }
-            PromiseKind::PyProm { then } => {
-                Self::cast_result(vm.invoke(then, (on_fulfill, on_reject)), vm)
-            }
+            PromiseKind::PyProm { then } => Self::cast_result(
+                vm.invoke(
+                    then,
+                    (
+                        on_fulfill.map(|c| c.into_object()),
+                        on_reject.map(|c| c.into_object()),
+                    ),
+                ),
+                vm,
+            ),
             PromiseKind::PyResolved(res) => match on_fulfill {
                 Some(resolve) => Self::cast_result(resolve.invoke((res.clone(),), vm), vm),
                 None => Ok(self.clone()),